/* Options:
Date: 2024-05-29 02:18:14
Version: 6.40
Tip: To override a DTO option, remove "//" prefix before updating
BaseUrl: https://evovoice.io

//GlobalNamespace: 
//AddServiceStackTypes: True
//AddResponseStatus: False
//AddImplicitVersion: 
//AddDescriptionAsComments: True
IncludeTypes: GetIntegration.*
//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,
}

enum IntegrationTypes
{
    HostedSuite,
    OfficeRnd,
    Zoho,
}

abstract class EntityInfo
{
    /**
    * The ID of the object
    */
    // @ApiMember(Description="The ID of the object")
    String? id;

    /**
    * The date the object was created
    */
    // @ApiMember(Description="The date the object was created")
    String? dateCreated;

    /**
    * The date the object was last modified
    */
    // @ApiMember(Description="The date the object was last modified")
    String? dateLastModified;

    /**
    * The user that created this object
    */
    // @ApiMember(Description="The user that created this object")
    String? createdBy;

    /**
    * The user that last modified this object
    */
    // @ApiMember(Description="The user that last modified this object")
    String? lastModifiedBy;

    EntityInfo({this.id,this.dateCreated,this.dateLastModified,this.createdBy,this.lastModifiedBy});
    EntityInfo.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        dateCreated = json['dateCreated'];
        dateLastModified = json['dateLastModified'];
        createdBy = json['createdBy'];
        lastModifiedBy = json['lastModifiedBy'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'dateCreated': dateCreated,
        'dateLastModified': dateLastModified,
        'createdBy': createdBy,
        'lastModifiedBy': lastModifiedBy
    };

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

class CustomerBreadcrumb implements IConvertible
{
    String? id;
    String? name;

    CustomerBreadcrumb({this.id,this.name});
    CustomerBreadcrumb.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        name = json['name'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'name': name
    };

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

enum IntegrationStatuses
{
    NotConfigured,
    Error,
    OK,
}

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

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;
}

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;
}

enum IntegrationFeatures
{
    CrmSync,
    OAuth2,
}

class IntegrationInfo extends EntityInfo implements IConvertible
{
    /**
    * The ID of the account associated with this integration
    */
    // @ApiMember(Description="The ID of the account associated with this integration")
    String? accountId;

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

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

    /**
    * The date the integration was sync'd last
    */
    // @ApiMember(Description="The date the integration was sync'd last")
    String? dateLastSync;

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

    /**
    * The name of the integration (e.g. HostedSuite Dallas)
    */
    // @ApiMember(Description="The name of the integration (e.g. HostedSuite Dallas)")
    String? name;

    /**
    * Automatically create new customers / users when sync'ing with CRM?
    */
    // @ApiMember(Description="Automatically create new customers / users when sync'ing with CRM?")
    bool? automaticallyCreateCustomers;

    /**
    * The type of integration
    */
    // @ApiMember(Description="The type of integration")
    IntegrationTypes? type;

    /**
    * The status of the integration
    */
    // @ApiMember(Description="The status of the integration")
    IntegrationStatuses? status;

    /**
    * The status of the integration
    */
    // @ApiMember(Description="The status of the integration")
    String? statusMessage;

    /**
    * The settings type for this integration
    */
    // @ApiMember(Description="The settings type for this integration")
    DataType? settingsDataType;

    /**
    * The settings for this integration
    */
    // @ApiMember(Description="The settings for this integration")
    Struct? settings;

    /**
    * The features supported by this integration
    */
    // @ApiMember(Description="The features supported by this integration")
    List<IntegrationFeatures>? features;

    /**
    * Is this integration authorized (OAuth)?
    */
    // @ApiMember(Description="Is this integration authorized (OAuth)?")
    bool? isAuthorized;

    IntegrationInfo({this.accountId,this.customerId,this.customerName,this.dateLastSync,this.customerBreadcrumb,this.name,this.automaticallyCreateCustomers,this.type,this.status,this.statusMessage,this.settingsDataType,this.settings,this.features,this.isAuthorized});
    IntegrationInfo.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        accountId = json['accountId'];
        customerId = json['customerId'];
        customerName = json['customerName'];
        dateLastSync = json['dateLastSync'];
        customerBreadcrumb = JsonConverters.fromJson(json['customerBreadcrumb'],'List<CustomerBreadcrumb>',context!);
        name = json['name'];
        automaticallyCreateCustomers = json['automaticallyCreateCustomers'];
        type = JsonConverters.fromJson(json['type'],'IntegrationTypes',context!);
        status = JsonConverters.fromJson(json['status'],'IntegrationStatuses',context!);
        statusMessage = json['statusMessage'];
        settingsDataType = JsonConverters.fromJson(json['settingsDataType'],'DataType',context!);
        settings = JsonConverters.fromJson(json['settings'],'Struct',context!);
        features = JsonConverters.fromJson(json['features'],'List<IntegrationFeatures>',context!);
        isAuthorized = json['isAuthorized'];
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'accountId': accountId,
        'customerId': customerId,
        'customerName': customerName,
        'dateLastSync': dateLastSync,
        'customerBreadcrumb': JsonConverters.toJson(customerBreadcrumb,'List<CustomerBreadcrumb>',context!),
        'name': name,
        'automaticallyCreateCustomers': automaticallyCreateCustomers,
        'type': JsonConverters.toJson(type,'IntegrationTypes',context!),
        'status': JsonConverters.toJson(status,'IntegrationStatuses',context!),
        'statusMessage': statusMessage,
        'settingsDataType': JsonConverters.toJson(settingsDataType,'DataType',context!),
        'settings': JsonConverters.toJson(settings,'Struct',context!),
        'features': JsonConverters.toJson(features,'List<IntegrationFeatures>',context!),
        'isAuthorized': isAuthorized
    });

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

/**
* Get a specific integration
*/
// @Route("/integrations/{integrationId}", "GET")
// @Api(Description="Get a specific integration")
class GetIntegration implements IReturn<IntegrationInfo>, IGet, IConvertible
{
    /**
    * The ID of the integration you want to get
    */
    // @ApiMember(Description="The ID of the integration you want to get")
    String? integrationId;

    GetIntegration({this.integrationId});
    GetIntegration.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        integrationId = json['integrationId'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'integrationId': integrationId
    };

    createResponse() => IntegrationInfo();
    getResponseTypeName() => "IntegrationInfo";
    getTypeName() => "GetIntegration";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: '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),
    'IntegrationTypes': TypeInfo(TypeOf.Enum, enumValues:IntegrationTypes.values),
    'EntityInfo': TypeInfo(TypeOf.AbstractClass),
    'CustomerBreadcrumb': TypeInfo(TypeOf.Class, create:() => CustomerBreadcrumb()),
    'IntegrationStatuses': TypeInfo(TypeOf.Enum, enumValues:IntegrationStatuses.values),
    'UIHints': TypeInfo(TypeOf.Enum, enumValues:UIHints.values),
    'DataType': TypeInfo(TypeOf.Class, create:() => DataType()),
    'List<DataField>': TypeInfo(TypeOf.Class, create:() => <DataField>[]),
    'DataField': TypeInfo(TypeOf.Class, create:() => DataField()),
    'DataFieldUniqueness': TypeInfo(TypeOf.Enum, enumValues:DataFieldUniqueness.values),
    'IntegrationFeatures': TypeInfo(TypeOf.Enum, enumValues:IntegrationFeatures.values),
    'IntegrationInfo': TypeInfo(TypeOf.Class, create:() => IntegrationInfo()),
    'List<CustomerBreadcrumb>': TypeInfo(TypeOf.Class, create:() => <CustomerBreadcrumb>[]),
    'List<IntegrationFeatures>': TypeInfo(TypeOf.Class, create:() => <IntegrationFeatures>[]),
    'GetIntegration': TypeInfo(TypeOf.Class, create:() => GetIntegration()),
});