/* Options:
Date: 2025-05-04 23:22:50
Version: 8.71
Tip: To override a DTO option, remove "//" prefix before updating
BaseUrl: https://team.evovoice.io

//GlobalNamespace: 
//AddServiceStackTypes: True
//AddResponseStatus: False
//AddImplicitVersion: 
//AddDescriptionAsComments: True
IncludeTypes: NotUsedRequest.*
//ExcludeTypes: 
//DefaultImports: package:servicestack/servicestack.dart,dart:typed_data
*/

import 'package:servicestack/servicestack.dart';
import 'dart:typed_data';

class Struct extends Map<String,Value?> implements IConvertible
{
    Struct();
    Struct.fromJson(Map<String, dynamic> json) : super.fromJson(json);
    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson();
    getTypeName() => "Struct";
    TypeContext? context = _ctx;
}

class Value implements IConvertible
{
    bool? boolValue;
    String? stringValue;
    double? numberValue;
    List<Struct>? listValue;
    Struct? structValue;

    Value({this.boolValue,this.stringValue,this.numberValue,this.listValue,this.structValue});
    Value.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        boolValue = json['boolValue'];
        stringValue = json['stringValue'];
        numberValue = JsonConverters.toDouble(json['numberValue']);
        listValue = JsonConverters.fromJson(json['listValue'],'List<Struct>',context!);
        structValue = JsonConverters.fromJson(json['structValue'],'Struct',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'boolValue': boolValue,
        'stringValue': stringValue,
        'numberValue': numberValue,
        'listValue': JsonConverters.toJson(listValue,'List<Struct>',context!),
        'structValue': JsonConverters.toJson(structValue,'Struct',context!)
    };

    getTypeName() => "Value";
    TypeContext? context = _ctx;
}

enum UserDataFieldModes
{
    Hidden,
    ReadOnly,
    ReadWrite,
}

enum ValueTypes
{
    NotSpecified,
    String,
    Boolean,
    Number,
    List,
    Struct,
    Transition,
    Custom,
    Date,
    AudioFile,
    TimeZoneId,
    PhoneNumber,
    User,
    Endpoint,
    Time,
    File,
    FaxNumber,
    EmailAccount,
    Customer,
    Flow,
    Team,
    FlowReference,
    Integration,
    Assistant,
}

enum PushNotificationTypes
{
    SessionDisconnected,
    SessionInvite,
    ChatMessage,
    SessionInactivated,
    AgentStateChanged,
    SessionHeld,
    SessionAnswered,
    ActiveSessionsChanged,
    Ping,
    SessionScreenChanged,
    Toast,
    SessionInfoChanged,
    MessageReceived,
    SessionHolding,
}

enum FlowChannels
{
    Voice,
    Chat,
    Fax,
}

enum AgentStates
{
    Unknown,
    Ready,
    NotReady,
    LoggedOut,
    WrapUp,
    Outgoing,
    Other,
}

enum AgentStateReasons
{
    Unknown,
    SetByUser,
    MissedCall,
    SetBySystem,
}

class PushNotification implements IConvertible
{
    PushNotificationTypes? type;
    FlowChannels? channel;
    String? endpointId;
    String? endpointUserName;
    String? sessionId;
    String? sender;
    String? title;
    String? body;
    int? badge;
    String? attachmentUri;
    String? attachmentContentType;
    AgentStates? agentState;
    AgentStateReasons? agentStateReason;

    PushNotification({this.type,this.channel,this.endpointId,this.endpointUserName,this.sessionId,this.sender,this.title,this.body,this.badge,this.attachmentUri,this.attachmentContentType,this.agentState,this.agentStateReason});
    PushNotification.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        type = JsonConverters.fromJson(json['type'],'PushNotificationTypes',context!);
        channel = JsonConverters.fromJson(json['channel'],'FlowChannels',context!);
        endpointId = json['endpointId'];
        endpointUserName = json['endpointUserName'];
        sessionId = json['sessionId'];
        sender = json['sender'];
        title = json['title'];
        body = json['body'];
        badge = json['badge'];
        attachmentUri = json['attachmentUri'];
        attachmentContentType = json['attachmentContentType'];
        agentState = JsonConverters.fromJson(json['agentState'],'AgentStates',context!);
        agentStateReason = JsonConverters.fromJson(json['agentStateReason'],'AgentStateReasons',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'type': JsonConverters.toJson(type,'PushNotificationTypes',context!),
        'channel': JsonConverters.toJson(channel,'FlowChannels',context!),
        'endpointId': endpointId,
        'endpointUserName': endpointUserName,
        'sessionId': sessionId,
        'sender': sender,
        'title': title,
        'body': body,
        'badge': badge,
        'attachmentUri': attachmentUri,
        'attachmentContentType': attachmentContentType,
        'agentState': JsonConverters.toJson(agentState,'AgentStates',context!),
        'agentStateReason': JsonConverters.toJson(agentStateReason,'AgentStateReasons',context!)
    };

    getTypeName() => "PushNotification";
    TypeContext? context = _ctx;
}

enum ValueSources
{
    Value,
    Flow,
    System,
    Customer,
    Session,
    Endpoint,
    Expression,
    User,
}

enum UIHints
{
    None,
    LargeText,
    InlineForm,
    Password,
    InlineStruct,
}

enum DataFieldUniqueness
{
    NotUnique,
    Unique,
    UniqueToCustomer,
}

class DataField implements IConvertible
{
    String? id;
    String? name;
    ValueTypes? type;
    UIHints? uiHint;
    String? uiTab;
    bool? isAsync;
    bool? disableBinding;
    DataType? structType;
    DataType? listType;
    String? description;
    List<String>? possibleValues;
    bool? isOutput;
    String? customFieldValuesUrl;
    Value? defaultValue;
    String? transitionNameFormat;
    DataFieldUniqueness? uniqueness;
    bool? voiceOnly;
    String? conditionalVisibilityField;
    String? conditionalVisibilityValue;
    bool? noEvalTemplate;
    UserDataFieldModes? userMode;
    bool? anyValueType;

    DataField({this.id,this.name,this.type,this.uiHint,this.uiTab,this.isAsync,this.disableBinding,this.structType,this.listType,this.description,this.possibleValues,this.isOutput,this.customFieldValuesUrl,this.defaultValue,this.transitionNameFormat,this.uniqueness,this.voiceOnly,this.conditionalVisibilityField,this.conditionalVisibilityValue,this.noEvalTemplate,this.userMode,this.anyValueType});
    DataField.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        name = json['name'];
        type = JsonConverters.fromJson(json['type'],'ValueTypes',context!);
        uiHint = JsonConverters.fromJson(json['uiHint'],'UIHints',context!);
        uiTab = json['uiTab'];
        isAsync = json['isAsync'];
        disableBinding = json['disableBinding'];
        structType = JsonConverters.fromJson(json['structType'],'DataType',context!);
        listType = JsonConverters.fromJson(json['listType'],'DataType',context!);
        description = json['description'];
        possibleValues = JsonConverters.fromJson(json['possibleValues'],'List<String>',context!);
        isOutput = json['isOutput'];
        customFieldValuesUrl = json['customFieldValuesUrl'];
        defaultValue = JsonConverters.fromJson(json['defaultValue'],'Value',context!);
        transitionNameFormat = json['transitionNameFormat'];
        uniqueness = JsonConverters.fromJson(json['uniqueness'],'DataFieldUniqueness',context!);
        voiceOnly = json['voiceOnly'];
        conditionalVisibilityField = json['conditionalVisibilityField'];
        conditionalVisibilityValue = json['conditionalVisibilityValue'];
        noEvalTemplate = json['noEvalTemplate'];
        userMode = JsonConverters.fromJson(json['userMode'],'UserDataFieldModes',context!);
        anyValueType = json['anyValueType'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'name': name,
        'type': JsonConverters.toJson(type,'ValueTypes',context!),
        'uiHint': JsonConverters.toJson(uiHint,'UIHints',context!),
        'uiTab': uiTab,
        'isAsync': isAsync,
        'disableBinding': disableBinding,
        'structType': JsonConverters.toJson(structType,'DataType',context!),
        'listType': JsonConverters.toJson(listType,'DataType',context!),
        'description': description,
        'possibleValues': JsonConverters.toJson(possibleValues,'List<String>',context!),
        'isOutput': isOutput,
        'customFieldValuesUrl': customFieldValuesUrl,
        'defaultValue': JsonConverters.toJson(defaultValue,'Value',context!),
        'transitionNameFormat': transitionNameFormat,
        'uniqueness': JsonConverters.toJson(uniqueness,'DataFieldUniqueness',context!),
        'voiceOnly': voiceOnly,
        'conditionalVisibilityField': conditionalVisibilityField,
        'conditionalVisibilityValue': conditionalVisibilityValue,
        'noEvalTemplate': noEvalTemplate,
        'userMode': JsonConverters.toJson(userMode,'UserDataFieldModes',context!),
        'anyValueType': anyValueType
    };

    getTypeName() => "DataField";
    TypeContext? context = _ctx;
}

class DataType implements IConvertible
{
    String? typeName;
    List<DataField>? fields;

    DataType({this.typeName,this.fields});
    DataType.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        typeName = json['typeName'];
        fields = JsonConverters.fromJson(json['fields'],'List<DataField>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'typeName': typeName,
        'fields': JsonConverters.toJson(fields,'List<DataField>',context!)
    };

    getTypeName() => "DataType";
    TypeContext? context = _ctx;
}

class NodeParameter implements IConvertible
{
    String? id;
    ValueTypes? type;
    ValueSources? source;
    bool? isAsync;
    String? referenceId;
    Value? value;
    bool? noEvalTemplate;
    List<NodeParameterMap>? listParameters;
    NodeParameterMap? structParameters;
    bool? isOutput;
    String? expression;
    DataType? listType;

    NodeParameter({this.id,this.type,this.source,this.isAsync,this.referenceId,this.value,this.noEvalTemplate,this.listParameters,this.structParameters,this.isOutput,this.expression,this.listType});
    NodeParameter.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        type = JsonConverters.fromJson(json['type'],'ValueTypes',context!);
        source = JsonConverters.fromJson(json['source'],'ValueSources',context!);
        isAsync = json['isAsync'];
        referenceId = json['referenceId'];
        value = JsonConverters.fromJson(json['value'],'Value',context!);
        noEvalTemplate = json['noEvalTemplate'];
        listParameters = JsonConverters.fromJson(json['listParameters'],'List<NodeParameterMap>',context!);
        structParameters = JsonConverters.fromJson(json['structParameters'],'NodeParameterMap',context!);
        isOutput = json['isOutput'];
        expression = json['expression'];
        listType = JsonConverters.fromJson(json['listType'],'DataType',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'type': JsonConverters.toJson(type,'ValueTypes',context!),
        'source': JsonConverters.toJson(source,'ValueSources',context!),
        'isAsync': isAsync,
        'referenceId': referenceId,
        'value': JsonConverters.toJson(value,'Value',context!),
        'noEvalTemplate': noEvalTemplate,
        'listParameters': JsonConverters.toJson(listParameters,'List<NodeParameterMap>',context!),
        'structParameters': JsonConverters.toJson(structParameters,'NodeParameterMap',context!),
        'isOutput': isOutput,
        'expression': expression,
        'listType': JsonConverters.toJson(listType,'DataType',context!)
    };

    getTypeName() => "NodeParameter";
    TypeContext? context = _ctx;
}

class NotificationInfo extends EntityInfo implements IConvertible
{
    /**
    * The account ID this endpoint is associated with
    */
    // @ApiMember(Description="The account ID this endpoint is associated with")
    String? accountId;

    /**
    * The name of the account this endpoint is associated with
    */
    // @ApiMember(Description="The name of the account this endpoint is associated with")
    String? accountName;

    /**
    * The ID of the customer this endpoint is associated with
    */
    // @ApiMember(Description="The ID of the customer this endpoint is associated with")
    String? customerId;

    /**
    * The name of the customer this endpoint is associated with
    */
    // @ApiMember(Description="The name of the customer this endpoint is associated with")
    String? customerName;

    /**
    * The breadcrumb to the customer for this endpoint
    */
    // @ApiMember(Description="The breadcrumb to the customer for this endpoint")
    List<CustomerBreadcrumb>? customerBreadcrumb;

    /**
    * The type of notification
    */
    // @ApiMember(Description="The type of notification")
    NotificationTypes? type;

    /**
    * The subject of the notification
    */
    // @ApiMember(Description="The subject of the notification")
    String? subject;

    /**
    * The body of the notification
    */
    // @ApiMember(Description="The body of the notification")
    String? body;

    /**
    * The recipients of this notification
    */
    // @ApiMember(Description="The recipients of this notification")
    List<NotificationRecipientInfo>? recipients;

    /**
    * The list of attachments
    */
    // @ApiMember(Description="The list of attachments")
    List<FileInfo>? attachments;

    /**
    * The original from for the session
    */
    // @ApiMember(Description="The original from for the session")
    String? from;

    /**
    * The original To for the session
    */
    // @ApiMember(Description="The original To for the session")
    String? to;

    /**
    * Was there an error?
    */
    // @ApiMember(Description="Was there an error?")
    bool? error;

    /**
    * The error message
    */
    // @ApiMember(Description="The error message")
    String? errorMessage;

    NotificationInfo({this.accountId,this.accountName,this.customerId,this.customerName,this.customerBreadcrumb,this.type,this.subject,this.body,this.recipients,this.attachments,this.from,this.to,this.error,this.errorMessage});
    NotificationInfo.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        accountId = json['accountId'];
        accountName = json['accountName'];
        customerId = json['customerId'];
        customerName = json['customerName'];
        customerBreadcrumb = JsonConverters.fromJson(json['customerBreadcrumb'],'List<CustomerBreadcrumb>',context!);
        type = JsonConverters.fromJson(json['type'],'NotificationTypes',context!);
        subject = json['subject'];
        body = json['body'];
        recipients = JsonConverters.fromJson(json['recipients'],'List<NotificationRecipientInfo>',context!);
        attachments = JsonConverters.fromJson(json['attachments'],'List<FileInfo>',context!);
        from = json['from'];
        to = json['to'];
        error = json['error'];
        errorMessage = json['errorMessage'];
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'accountId': accountId,
        'accountName': accountName,
        'customerId': customerId,
        'customerName': customerName,
        'customerBreadcrumb': JsonConverters.toJson(customerBreadcrumb,'List<CustomerBreadcrumb>',context!),
        'type': JsonConverters.toJson(type,'NotificationTypes',context!),
        'subject': subject,
        'body': body,
        'recipients': JsonConverters.toJson(recipients,'List<NotificationRecipientInfo>',context!),
        'attachments': JsonConverters.toJson(attachments,'List<FileInfo>',context!),
        'from': from,
        'to': to,
        'error': error,
        'errorMessage': errorMessage
    });

    getTypeName() => "NotificationInfo";
    TypeContext? context = _ctx;
}

// @Route("/not-used")
class NotUsedRequest implements IConvertible, IPost
{
    PushNotification? pushNotification;
    List<NotificationInfo>? notifications;
    NodeParameter? nodeParameter;

    NotUsedRequest({this.pushNotification,this.notifications,this.nodeParameter});
    NotUsedRequest.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        pushNotification = JsonConverters.fromJson(json['pushNotification'],'PushNotification',context!);
        notifications = JsonConverters.fromJson(json['notifications'],'List<NotificationInfo>',context!);
        nodeParameter = JsonConverters.fromJson(json['nodeParameter'],'NodeParameter',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'pushNotification': JsonConverters.toJson(pushNotification,'PushNotification',context!),
        'notifications': JsonConverters.toJson(notifications,'List<NotificationInfo>',context!),
        'nodeParameter': JsonConverters.toJson(nodeParameter,'NodeParameter',context!)
    };

    getTypeName() => "NotUsedRequest";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'team.evovoice.io', types: <String, TypeInfo> {
    'Struct': TypeInfo(TypeOf.Class, create:() => Struct()),
    'Value': TypeInfo(TypeOf.Class, create:() => Value()),
    'List<Struct>': TypeInfo(TypeOf.Class, create:() => <Struct>[]),
    'UserDataFieldModes': TypeInfo(TypeOf.Enum, enumValues:UserDataFieldModes.values),
    'ValueTypes': TypeInfo(TypeOf.Enum, enumValues:ValueTypes.values),
    'PushNotificationTypes': TypeInfo(TypeOf.Enum, enumValues:PushNotificationTypes.values),
    'FlowChannels': TypeInfo(TypeOf.Enum, enumValues:FlowChannels.values),
    'AgentStates': TypeInfo(TypeOf.Enum, enumValues:AgentStates.values),
    'AgentStateReasons': TypeInfo(TypeOf.Enum, enumValues:AgentStateReasons.values),
    'PushNotification': TypeInfo(TypeOf.Class, create:() => PushNotification()),
    'ValueSources': TypeInfo(TypeOf.Enum, enumValues:ValueSources.values),
    'UIHints': TypeInfo(TypeOf.Enum, enumValues:UIHints.values),
    'DataFieldUniqueness': TypeInfo(TypeOf.Enum, enumValues:DataFieldUniqueness.values),
    'DataField': TypeInfo(TypeOf.Class, create:() => DataField()),
    'DataType': TypeInfo(TypeOf.Class, create:() => DataType()),
    'List<DataField>': TypeInfo(TypeOf.Class, create:() => <DataField>[]),
    'NodeParameter': TypeInfo(TypeOf.Class, create:() => NodeParameter()),
    'List<NodeParameterMap>': TypeInfo(TypeOf.Class, create:() => <NodeParameterMap>[]),
    'NodeParameterMap': TypeInfo(TypeOf.Class, create:() => NodeParameterMap()),
    'NotificationInfo': TypeInfo(TypeOf.Class, create:() => NotificationInfo()),
    'List<CustomerBreadcrumb>': TypeInfo(TypeOf.Class, create:() => <CustomerBreadcrumb>[]),
    'CustomerBreadcrumb': TypeInfo(TypeOf.Class, create:() => CustomerBreadcrumb()),
    'NotificationTypes': TypeInfo(TypeOf.Class, create:() => NotificationTypes()),
    'List<NotificationRecipientInfo>': TypeInfo(TypeOf.Class, create:() => <NotificationRecipientInfo>[]),
    'NotificationRecipientInfo': TypeInfo(TypeOf.Class, create:() => NotificationRecipientInfo()),
    'List<FileInfo>': TypeInfo(TypeOf.Class, create:() => <FileInfo>[]),
    'FileInfo': TypeInfo(TypeOf.Class, create:() => FileInfo()),
    'NotUsedRequest': TypeInfo(TypeOf.Class, create:() => NotUsedRequest()),
    'List<NotificationInfo>': TypeInfo(TypeOf.Class, create:() => <NotificationInfo>[]),
});