/* Options:
Date: 2025-05-04 23:13:32
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: PatchFlow.*
//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 FlowRoles
{
    UI,
    Reference,
    PhoneNumberRouting,
    UserDialOut,
    FaxNumberRouting,
}

enum FlowNodeCategories
{
    General,
    Voice,
    Logic,
    DateAndTime,
    Audio,
    Messaging,
    Assistant,
    Flows,
    Fax,
    Network,
    Cookies,
    CallCenter,
    Intelligence,
}

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

enum FlowChannels
{
    Voice,
    Chat,
    Fax,
}

class FlowNodeSpec implements IConvertible
{
    /**
    * The name of this node
    */
    // @ApiMember(Description="The name of this node")
    String? name;

    /**
    * A description of this node
    */
    // @ApiMember(Description="A description of this node")
    String? description;

    /**
    * Icon class for this node (FontAwesome)
    */
    // @ApiMember(Description="Icon class for this node (FontAwesome)")
    String? iconClass;

    /**
    * The type name for this node
    */
    // @ApiMember(Description="The type name for this node")
    String? typeName;

    /**
    * The category this node should be grouped under
    */
    // @ApiMember(Description="The category this node should be grouped under")
    FlowNodeCategories? category;

    /**
    * The URL where this node is located
    */
    // @ApiMember(Description="The URL where this node is located")
    String? url;

    /**
    * The data type for this node
    */
    // @ApiMember(Description="The data type for this node")
    DataType? dataType;

    /**
    * URL for documentation for this node
    */
    // @ApiMember(Description="URL for documentation for this node")
    String? documentationUrl;

    /**
    * The channels that this node is restricted to
    */
    // @ApiMember(Description="The channels that this node is restricted to")
    List<FlowChannels>? restrictToChannels;

    FlowNodeSpec({this.name,this.description,this.iconClass,this.typeName,this.category,this.url,this.dataType,this.documentationUrl,this.restrictToChannels});
    FlowNodeSpec.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        name = json['name'];
        description = json['description'];
        iconClass = json['iconClass'];
        typeName = json['typeName'];
        category = JsonConverters.fromJson(json['category'],'FlowNodeCategories',context!);
        url = json['url'];
        dataType = JsonConverters.fromJson(json['dataType'],'DataType',context!);
        documentationUrl = json['documentationUrl'];
        restrictToChannels = JsonConverters.fromJson(json['restrictToChannels'],'List<FlowChannels>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'name': name,
        'description': description,
        'iconClass': iconClass,
        'typeName': typeName,
        'category': JsonConverters.toJson(category,'FlowNodeCategories',context!),
        'url': url,
        'dataType': JsonConverters.toJson(dataType,'DataType',context!),
        'documentationUrl': documentationUrl,
        'restrictToChannels': JsonConverters.toJson(restrictToChannels,'List<FlowChannels>',context!)
    };

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

class FlowNodeUI implements IConvertible
{
    /**
    * The X position of the node
    */
    // @ApiMember(Description="The X position of the node")
    double? x;

    /**
    * The Y position of the node
    */
    // @ApiMember(Description="The Y position of the node")
    double? y;

    /**
    * Notes for this node
    */
    // @ApiMember(Description="Notes for this node")
    String? notes;

    FlowNodeUI({this.x,this.y,this.notes});
    FlowNodeUI.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        x = JsonConverters.toDouble(json['x']);
        y = JsonConverters.toDouble(json['y']);
        notes = json['notes'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'x': x,
        'y': y,
        'notes': notes
    };

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

class FlowNode implements IConvertible
{
    /**
    * The ID of this node. Must be unique within the flow but can be anything
    */
    // @ApiMember(Description="The ID of this node. Must be unique within the flow but can be anything")
    String? id;

    /**
    * Is this the starting node for the flow. Only one node can have this set
    */
    // @ApiMember(Description="Is this the starting node for the flow. Only one node can have this set")
    bool? isStartNode;

    /**
    * The name of the node, descriptive to be used as a reminder in the GUI
    */
    // @ApiMember(Description="The name of the node, descriptive to be used as a reminder in the GUI")
    String? name;

    /**
    * The specification for the node
    */
    // @ApiMember(Description="The specification for the node")
    FlowNodeSpec? spec;

    /**
    * The UI data for the node
    */
    // @ApiMember(Description="The UI data for the node")
    FlowNodeUI? ui;

    /**
    * The data for this node. These will be POST'd to the endpoint when it is called.
    */
    // @ApiMember(Description="The data for this node. These will be POST'd to the endpoint when it is called.")
    NodeParameterMap? parameters;

    FlowNode({this.id,this.isStartNode,this.name,this.spec,this.ui,this.parameters});
    FlowNode.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        isStartNode = json['isStartNode'];
        name = json['name'];
        spec = JsonConverters.fromJson(json['spec'],'FlowNodeSpec',context!);
        ui = JsonConverters.fromJson(json['ui'],'FlowNodeUI',context!);
        parameters = JsonConverters.fromJson(json['parameters'],'NodeParameterMap',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'isStartNode': isStartNode,
        'name': name,
        'spec': JsonConverters.toJson(spec,'FlowNodeSpec',context!),
        'ui': JsonConverters.toJson(ui,'FlowNodeUI',context!),
        'parameters': JsonConverters.toJson(parameters,'NodeParameterMap',context!)
    };

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

class FlowExit implements IConvertible
{
    /**
    * The unique ID for this exit
    */
    // @ApiMember(Description="The unique ID for this exit")
    String? id;

    /**
    * The name of this exit
    */
    // @ApiMember(Description="The name of this exit")
    String? name;

    /**
    * The UI for the exit
    */
    // @ApiMember(Description="The UI for the exit")
    FlowNodeUI? ui;

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

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        name = json['name'];
        ui = JsonConverters.fromJson(json['ui'],'FlowNodeUI',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'name': name,
        'ui': JsonConverters.toJson(ui,'FlowNodeUI',context!)
    };

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

class FlowParameter extends DataField implements IConvertible
{
    bool? isPublic;
    bool? isKnob;

    FlowParameter({this.isPublic,this.isKnob});
    FlowParameter.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        isPublic = json['isPublic'];
        isKnob = json['isKnob'];
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'isPublic': isPublic,
        'isKnob': isKnob
    });

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

class FlowUI implements IConvertible
{
    String? selectedNode;
    double? canvasX;
    double? canvasY;
    double? canvasZoom;

    FlowUI({this.selectedNode,this.canvasX,this.canvasY,this.canvasZoom});
    FlowUI.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        selectedNode = json['selectedNode'];
        canvasX = JsonConverters.toDouble(json['canvasX']);
        canvasY = JsonConverters.toDouble(json['canvasY']);
        canvasZoom = JsonConverters.toDouble(json['canvasZoom']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'selectedNode': selectedNode,
        'canvasX': canvasX,
        'canvasY': canvasY,
        'canvasZoom': canvasZoom
    };

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

enum TagColors
{
    Magenta,
    Red,
    Volcano,
    Orange,
    Gold,
    Lime,
    Green,
    Cyan,
    Blue,
    GeekBlue,
    Purple,
}

class Tag implements IConvertible
{
    String? id;
    String? name;
    TagColors? color;

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

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        name = json['name'];
        color = JsonConverters.fromJson(json['color'],'TagColors',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'name': name,
        'color': JsonConverters.toJson(color,'TagColors',context!)
    };

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

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

class FlowInfo extends EntityInfo implements IConvertible
{
    /**
    * The name of this flow
    */
    // @ApiMember(Description="The name of this flow")
    String? name;

    /**
    * The roles that this flow has
    */
    // @ApiMember(Description="The roles that this flow has")
    List<FlowRoles>? roles;

    /**
    * What this flow does
    */
    // @ApiMember(Description="What this flow does")
    String? description;

    /**
    * Any notes for this flow
    */
    // @ApiMember(Description="Any notes for this flow")
    String? notes;

    /**
    * The ID of the account associated with the flow
    */
    // @ApiMember(Description="The ID of the account associated with the flow")
    String? accountId;

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

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

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

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

    /**
    * The nodes in this flow
    */
    // @ApiMember(Description="The nodes in this flow")
    List<FlowNode>? nodes;

    /**
    * The flow's parameters
    */
    // @ApiMember(Description="The flow's parameters")
    List<FlowParameter>? parameters;

    /**
    * The flow's exits
    */
    // @ApiMember(Description="The flow's exits")
    List<FlowExit>? exits;

    /**
    * The UI data for the flow
    */
    // @ApiMember(Description="The UI data for the flow")
    FlowUI? ui;

    /**
    * The list of tags for this flow
    */
    // @ApiMember(Description="The list of tags for this flow")
    List<Tag>? tags;

    /**
    * The number of nodes in this flow
    */
    // @ApiMember(Description="The number of nodes in this flow")
    int? nodeCount;

    FlowInfo({this.name,this.roles,this.description,this.notes,this.accountId,this.accountName,this.customerId,this.customerName,this.customerBreadcrumb,this.nodes,this.parameters,this.exits,this.ui,this.tags,this.nodeCount});
    FlowInfo.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        name = json['name'];
        roles = JsonConverters.fromJson(json['roles'],'List<FlowRoles>',context!);
        description = json['description'];
        notes = json['notes'];
        accountId = json['accountId'];
        accountName = json['accountName'];
        customerId = json['customerId'];
        customerName = json['customerName'];
        customerBreadcrumb = JsonConverters.fromJson(json['customerBreadcrumb'],'List<CustomerBreadcrumb>',context!);
        nodes = JsonConverters.fromJson(json['nodes'],'List<FlowNode>',context!);
        parameters = JsonConverters.fromJson(json['parameters'],'List<FlowParameter>',context!);
        exits = JsonConverters.fromJson(json['exits'],'List<FlowExit>',context!);
        ui = JsonConverters.fromJson(json['ui'],'FlowUI',context!);
        tags = JsonConverters.fromJson(json['tags'],'List<Tag>',context!);
        nodeCount = json['nodeCount'];
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'name': name,
        'roles': JsonConverters.toJson(roles,'List<FlowRoles>',context!),
        'description': description,
        'notes': notes,
        'accountId': accountId,
        'accountName': accountName,
        'customerId': customerId,
        'customerName': customerName,
        'customerBreadcrumb': JsonConverters.toJson(customerBreadcrumb,'List<CustomerBreadcrumb>',context!),
        'nodes': JsonConverters.toJson(nodes,'List<FlowNode>',context!),
        'parameters': JsonConverters.toJson(parameters,'List<FlowParameter>',context!),
        'exits': JsonConverters.toJson(exits,'List<FlowExit>',context!),
        'ui': JsonConverters.toJson(ui,'FlowUI',context!),
        'tags': JsonConverters.toJson(tags,'List<Tag>',context!),
        'nodeCount': nodeCount
    });

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

/**
* Update the specified flow
*/
// @Route("/flows/{flowId}", "PATCH")
// @Api(Description="Update the specified flow")
class PatchFlow implements IReturn<FlowInfo>, IPatch, IConvertible
{
    /**
    * the ID of the flow to update
    */
    // @ApiMember(Description="the ID of the flow to update")
    String? flowId;

    /**
    * The ID of the customer to associate with the flow
    */
    // @ApiMember(Description="The ID of the customer to associate with the flow")
    String? customerId;

    /**
    * The new name for the flow
    */
    // @ApiMember(Description="The new name for the flow")
    String? name;

    /**
    * The roles that this flow has
    */
    // @ApiMember(Description="The roles that this flow has")
    List<FlowRoles>? roles;

    /**
    * What this flow does
    */
    // @ApiMember(Description="What this flow does")
    String? description;

    /**
    * Any notes for this flow
    */
    // @ApiMember(Description="Any notes for this flow")
    String? notes;

    /**
    * The list of nodes for this flow
    */
    // @ApiMember(Description="The list of nodes for this flow")
    List<FlowNode>? nodes;

    /**
    * The list of flow exits
    */
    // @ApiMember(Description="The list of flow exits")
    List<FlowExit>? exits;

    /**
    * The parameters for this flow
    */
    // @ApiMember(Description="The parameters for this flow")
    List<FlowParameter>? parameters;

    /**
    * The time zone ID for this flow
    */
    // @ApiMember(Description="The time zone ID for this flow")
    String? timeZoneId;

    /**
    * The UI data for the flow
    */
    // @ApiMember(Description="The UI data for the flow")
    FlowUI? ui;

    /**
    * The list of tag IDs for this flow
    */
    // @ApiMember(Description="The list of tag IDs for this flow")
    List<String>? tagIds;

    PatchFlow({this.flowId,this.customerId,this.name,this.roles,this.description,this.notes,this.nodes,this.exits,this.parameters,this.timeZoneId,this.ui,this.tagIds});
    PatchFlow.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        flowId = json['flowId'];
        customerId = json['customerId'];
        name = json['name'];
        roles = JsonConverters.fromJson(json['roles'],'List<FlowRoles>',context!);
        description = json['description'];
        notes = json['notes'];
        nodes = JsonConverters.fromJson(json['nodes'],'List<FlowNode>',context!);
        exits = JsonConverters.fromJson(json['exits'],'List<FlowExit>',context!);
        parameters = JsonConverters.fromJson(json['parameters'],'List<FlowParameter>',context!);
        timeZoneId = json['timeZoneId'];
        ui = JsonConverters.fromJson(json['ui'],'FlowUI',context!);
        tagIds = JsonConverters.fromJson(json['tagIds'],'List<String>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'flowId': flowId,
        'customerId': customerId,
        'name': name,
        'roles': JsonConverters.toJson(roles,'List<FlowRoles>',context!),
        'description': description,
        'notes': notes,
        'nodes': JsonConverters.toJson(nodes,'List<FlowNode>',context!),
        'exits': JsonConverters.toJson(exits,'List<FlowExit>',context!),
        'parameters': JsonConverters.toJson(parameters,'List<FlowParameter>',context!),
        'timeZoneId': timeZoneId,
        'ui': JsonConverters.toJson(ui,'FlowUI',context!),
        'tagIds': JsonConverters.toJson(tagIds,'List<String>',context!)
    };

    createResponse() => FlowInfo();
    getResponseTypeName() => "FlowInfo";
    getTypeName() => "PatchFlow";
    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),
    'FlowRoles': TypeInfo(TypeOf.Enum, enumValues:FlowRoles.values),
    'FlowNodeCategories': TypeInfo(TypeOf.Enum, enumValues:FlowNodeCategories.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>[]),
    'FlowChannels': TypeInfo(TypeOf.Enum, enumValues:FlowChannels.values),
    'FlowNodeSpec': TypeInfo(TypeOf.Class, create:() => FlowNodeSpec()),
    'List<FlowChannels>': TypeInfo(TypeOf.Class, create:() => <FlowChannels>[]),
    'FlowNodeUI': TypeInfo(TypeOf.Class, create:() => FlowNodeUI()),
    'FlowNode': TypeInfo(TypeOf.Class, create:() => FlowNode()),
    'NodeParameterMap': TypeInfo(TypeOf.Class, create:() => NodeParameterMap()),
    'FlowExit': TypeInfo(TypeOf.Class, create:() => FlowExit()),
    'FlowParameter': TypeInfo(TypeOf.Class, create:() => FlowParameter()),
    'FlowUI': TypeInfo(TypeOf.Class, create:() => FlowUI()),
    'TagColors': TypeInfo(TypeOf.Enum, enumValues:TagColors.values),
    'Tag': TypeInfo(TypeOf.Class, create:() => Tag()),
    'EntityInfo': TypeInfo(TypeOf.AbstractClass),
    'CustomerBreadcrumb': TypeInfo(TypeOf.Class, create:() => CustomerBreadcrumb()),
    'FlowInfo': TypeInfo(TypeOf.Class, create:() => FlowInfo()),
    'List<FlowRoles>': TypeInfo(TypeOf.Class, create:() => <FlowRoles>[]),
    'List<CustomerBreadcrumb>': TypeInfo(TypeOf.Class, create:() => <CustomerBreadcrumb>[]),
    'List<FlowNode>': TypeInfo(TypeOf.Class, create:() => <FlowNode>[]),
    'List<FlowParameter>': TypeInfo(TypeOf.Class, create:() => <FlowParameter>[]),
    'List<FlowExit>': TypeInfo(TypeOf.Class, create:() => <FlowExit>[]),
    'List<Tag>': TypeInfo(TypeOf.Class, create:() => <Tag>[]),
    'PatchFlow': TypeInfo(TypeOf.Class, create:() => PatchFlow()),
});