/* Options:
Date: 2025-05-05 00:55:55
SwiftVersion: 6.0
Version: 8.71
Tip: To override a DTO option, remove "//" prefix before updating
BaseUrl: https://team.evovoice.io

//BaseClass: 
//AddModelExtensions: True
//AddServiceStackTypes: True
//MakePropertiesOptional: True
IncludeTypes: ListFlows.*
//ExcludeTypes: 
//ExcludeGenericBaseTypes: False
//AddResponseStatus: False
//AddImplicitVersion: 
//AddDescriptionAsComments: True
//InitializeCollections: False
//TreatTypesAsStrings: 
//DefaultImports: Foundation,ServiceStack
*/

import Foundation
import ServiceStack

/**
* Lists all the flows
*/
// @Route("/flows", "GET")
// @Api(Description="Lists all the flows")
public class ListFlows : ListRequest<FlowInfo>, IReturn
{
    public typealias Return = ListResponse<FlowInfo>

    /**
    * Filter by accounts
    */
    // @ApiMember(Description="Filter by accounts")
    public var accountIds:[String]?

    /**
    * The IDs of the customers whose flows you want to retrieve
    */
    // @ApiMember(Description="The IDs of the customers whose flows you want to retrieve")
    public var customerIds:[String]?

    /**
    * Filter by name
    */
    // @ApiMember(Description="Filter by name")
    public var nameFilter:String?

    /**
    * The list of tag IDs to filter by (must contain all)
    */
    // @ApiMember(Description="The list of tag IDs to filter by (must contain all)")
    public var tagIds:[String]?

    /**
    * List flows by specific role
    */
    // @ApiMember(Description="List flows by specific role")
    public var role:FlowRoles?

    /**
    * Exclude nodes
    */
    // @ApiMember(Description="Exclude nodes")
    public var includeNodes:Bool?

    /**
    * Node Type Filter
    */
    // @ApiMember(Description="Node Type Filter")
    public var nodeTypeFilter:String?

    required public init(){ super.init() }

    private enum CodingKeys : String, CodingKey {
        case accountIds
        case customerIds
        case nameFilter
        case tagIds
        case role
        case includeNodes
        case nodeTypeFilter
    }

    required public init(from decoder: Decoder) throws {
        try super.init(from: decoder)
        let container = try decoder.container(keyedBy: CodingKeys.self)
        accountIds = try container.decodeIfPresent([String].self, forKey: .accountIds) ?? []
        customerIds = try container.decodeIfPresent([String].self, forKey: .customerIds) ?? []
        nameFilter = try container.decodeIfPresent(String.self, forKey: .nameFilter)
        tagIds = try container.decodeIfPresent([String].self, forKey: .tagIds) ?? []
        role = try container.decodeIfPresent(FlowRoles.self, forKey: .role)
        includeNodes = try container.decodeIfPresent(Bool.self, forKey: .includeNodes)
        nodeTypeFilter = try container.decodeIfPresent(String.self, forKey: .nodeTypeFilter)
    }

    public override func encode(to encoder: Encoder) throws {
        try super.encode(to: encoder)
        var container = encoder.container(keyedBy: CodingKeys.self)
        if accountIds != nil { try container.encode(accountIds, forKey: .accountIds) }
        if customerIds != nil { try container.encode(customerIds, forKey: .customerIds) }
        if nameFilter != nil { try container.encode(nameFilter, forKey: .nameFilter) }
        if tagIds != nil { try container.encode(tagIds, forKey: .tagIds) }
        if role != nil { try container.encode(role, forKey: .role) }
        if includeNodes != nil { try container.encode(includeNodes, forKey: .includeNodes) }
        if nodeTypeFilter != nil { try container.encode(nodeTypeFilter, forKey: .nodeTypeFilter) }
    }
}

public class ListResponse<T : Codable> : Codable
{
    /**
    * The items
    */
    // @ApiMember(Description="The items")
    public var items:[FlowInfo]?

    /**
    * The total number of items
    */
    // @ApiMember(Description="The total number of items")
    public var totalCount:Int?

    /**
    * The total number of pages
    */
    // @ApiMember(Description="The total number of pages")
    public var totalPages:Int?

    /**
    * Are there more pages of items? Used with simplified paging
    */
    // @ApiMember(Description="Are there more pages of items? Used with simplified paging")
    public var hasMorePages:Bool?

    required public init(){}
}

public enum SortOrders : String, Codable
{
    case Ascend
    case Descend
}

public class ListRequest<T : Codable> : IGet, Codable
{
    /**
    * The page of data to retrieve
    */
    // @ApiMember(Description="The page of data to retrieve")
    public var page:Int?

    /**
    * If you want all objects to be returned. This should be used with care
    */
    // @ApiMember(Description="If you want all objects to be returned. This should be used with care")
    public var all:Bool?

    /**
    * The number per page to retrieve
    */
    // @ApiMember(Description="The number per page to retrieve")
    public var countPerPage:Int?

    /**
    * Specific IDs
    */
    // @ApiMember(Description="Specific IDs")
    public var specificIds:[String]?

    /**
    * Specify a sort field
    */
    // @ApiMember(Description="Specify a sort field")
    public var sortField:String?

    /**
    * Specify a sort order
    */
    // @ApiMember(Description="Specify a sort order")
    public var sortOrder:SortOrders?

    /**
    * Disables total / page counts - improves performance. Returns only data. If there is no more data, Items will be empty array
    */
    // @ApiMember(Description="Disables total / page counts - improves performance. Returns only data. If there is no more data, Items will be empty array")
    public var simplifiedPaging:Bool?

    required public init(){}
}

public class Struct : List<String:Value>
{
    required public init(){ super.init() }

    required public init(from decoder: Decoder) throws {
        try super.init(from: decoder)
    }

    public override func encode(to encoder: Encoder) throws {
        try super.encode(to: encoder)
    }
}

public enum UserDataFieldModes : String, Codable
{
    case Hidden
    case ReadOnly
    case ReadWrite
}

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

public enum FlowRoles : String, Codable
{
    case UI
    case Reference
    case PhoneNumberRouting
    case UserDialOut
    case FaxNumberRouting
}

public class FlowNode : Codable
{
    /**
    * 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")
    public var id:String?

    /**
    * 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")
    public var isStartNode:Bool?

    /**
    * 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")
    public var name:String?

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

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

    /**
    * 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.")
    public var parameters:NodeParameterMap?

    required public init(){}
}

public class FlowExit : Codable
{
    /**
    * The unique ID for this exit
    */
    // @ApiMember(Description="The unique ID for this exit")
    public var id:String?

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

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

    required public init(){}
}

public class FlowParameter : DataField
{
    public var isPublic:Bool?
    public var isKnob:Bool?

    required public init(){ super.init() }

    private enum CodingKeys : String, CodingKey {
        case isPublic
        case isKnob
    }

    required public init(from decoder: Decoder) throws {
        try super.init(from: decoder)
        let container = try decoder.container(keyedBy: CodingKeys.self)
        isPublic = try container.decodeIfPresent(Bool.self, forKey: .isPublic)
        isKnob = try container.decodeIfPresent(Bool.self, forKey: .isKnob)
    }

    public override func encode(to encoder: Encoder) throws {
        try super.encode(to: encoder)
        var container = encoder.container(keyedBy: CodingKeys.self)
        if isPublic != nil { try container.encode(isPublic, forKey: .isPublic) }
        if isKnob != nil { try container.encode(isKnob, forKey: .isKnob) }
    }
}

public class FlowUI : Codable
{
    public var selectedNode:String?
    public var canvasX:Double?
    public var canvasY:Double?
    public var canvasZoom:Double?

    required public init(){}
}

public enum FlowChannels : String, Codable
{
    case Voice
    case Chat
    case Fax
}

public class Tag : Codable
{
    public var id:String?
    public var name:String?
    public var color:TagColors?

    required public init(){}
}

public class EntityInfo : Codable
{
    /**
    * The ID of the object
    */
    // @ApiMember(Description="The ID of the object")
    public var id:String?

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

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

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

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

    required public init(){}
}

public class CustomerBreadcrumb : Codable
{
    public var id:String?
    public var name:String?

    required public init(){}
}

public class FlowNodeSpec : Codable
{
    /**
    * The name of this node
    */
    // @ApiMember(Description="The name of this node")
    public var name:String?

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

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

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

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

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

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

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

    /**
    * The channels that this node is restricted to
    */
    // @ApiMember(Description="The channels that this node is restricted to")
    public var restrictToChannels:[FlowChannels]?

    required public init(){}
}

public class DataType : Codable
{
    public var typeName:String?
    public var fields:[DataField]?

    required public init(){}
}

public class Value : Codable
{
    public var boolValue:Bool?
    public var stringValue:String?
    public var numberValue:Double?
    public var listValue:[Struct]?
    public var structValue:Struct?

    required public init(){}
}

public class FlowNodeUI : Codable
{
    /**
    * The X position of the node
    */
    // @ApiMember(Description="The X position of the node")
    public var x:Double?

    /**
    * The Y position of the node
    */
    // @ApiMember(Description="The Y position of the node")
    public var y:Double?

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

    required public init(){}
}

public enum UIHints : String, Codable
{
    case None
    case LargeText
    case InlineForm
    case Password
    case InlineStruct
}

public enum DataFieldUniqueness : String, Codable
{
    case NotUnique
    case Unique
    case UniqueToCustomer
}

public class DataField : Codable
{
    public var id:String?
    public var name:String?
    public var type:ValueTypes?
    public var uiHint:UIHints?
    public var uiTab:String?
    public var isAsync:Bool?
    public var disableBinding:Bool?
    public var structType:DataType?
    public var listType:DataType?
    public var Description:String?
    public var possibleValues:[String]?
    public var isOutput:Bool?
    public var customFieldValuesUrl:String?
    public var defaultValue:Value?
    public var transitionNameFormat:String?
    public var uniqueness:DataFieldUniqueness?
    public var voiceOnly:Bool?
    public var conditionalVisibilityField:String?
    public var conditionalVisibilityValue:String?
    public var noEvalTemplate:Bool?
    public var userMode:UserDataFieldModes?
    public var anyValueType:Bool?

    required public init(){}
}

public enum TagColors : String, Codable
{
    case Magenta
    case Red
    case Volcano
    case Orange
    case Gold
    case Lime
    case Green
    case Cyan
    case Blue
    case GeekBlue
    case Purple
}

public enum FlowNodeCategories : String, Codable
{
    case General
    case Voice
    case Logic
    case DateAndTime
    case Audio
    case Messaging
    case Assistant
    case Flows
    case Fax
    case Network
    case Cookies
    case CallCenter
    case Intelligence
}

public class FlowInfo : EntityInfo
{
    /**
    * The name of this flow
    */
    // @ApiMember(Description="The name of this flow")
    public var name:String?

    /**
    * The roles that this flow has
    */
    // @ApiMember(Description="The roles that this flow has")
    public var roles:[FlowRoles]?

    /**
    * What this flow does
    */
    // @ApiMember(Description="What this flow does")
    public var Description:String?

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

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

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

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

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

    /**
    * The breadcrumb to the flow for this endpoint
    */
    // @ApiMember(Description="The breadcrumb to the flow for this endpoint")
    public var customerBreadcrumb:[CustomerBreadcrumb]?

    /**
    * The nodes in this flow
    */
    // @ApiMember(Description="The nodes in this flow")
    public var nodes:[FlowNode]?

    /**
    * The flow's parameters
    */
    // @ApiMember(Description="The flow's parameters")
    public var parameters:[FlowParameter]?

    /**
    * The flow's exits
    */
    // @ApiMember(Description="The flow's exits")
    public var exits:[FlowExit]?

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

    /**
    * The list of tags for this flow
    */
    // @ApiMember(Description="The list of tags for this flow")
    public var tags:[Tag]?

    /**
    * The number of nodes in this flow
    */
    // @ApiMember(Description="The number of nodes in this flow")
    public var nodeCount:Int?

    required public init(){ super.init() }

    private enum CodingKeys : String, CodingKey {
        case name
        case roles
        case Description
        case notes
        case accountId
        case accountName
        case customerId
        case customerName
        case customerBreadcrumb
        case nodes
        case parameters
        case exits
        case ui
        case tags
        case nodeCount
    }

    required public init(from decoder: Decoder) throws {
        try super.init(from: decoder)
        let container = try decoder.container(keyedBy: CodingKeys.self)
        name = try container.decodeIfPresent(String.self, forKey: .name)
        roles = try container.decodeIfPresent([FlowRoles].self, forKey: .roles) ?? []
        Description = try container.decodeIfPresent(String.self, forKey: .Description)
        notes = try container.decodeIfPresent(String.self, forKey: .notes)
        accountId = try container.decodeIfPresent(String.self, forKey: .accountId)
        accountName = try container.decodeIfPresent(String.self, forKey: .accountName)
        customerId = try container.decodeIfPresent(String.self, forKey: .customerId)
        customerName = try container.decodeIfPresent(String.self, forKey: .customerName)
        customerBreadcrumb = try container.decodeIfPresent([CustomerBreadcrumb].self, forKey: .customerBreadcrumb) ?? []
        nodes = try container.decodeIfPresent([FlowNode].self, forKey: .nodes) ?? []
        parameters = try container.decodeIfPresent([FlowParameter].self, forKey: .parameters) ?? []
        exits = try container.decodeIfPresent([FlowExit].self, forKey: .exits) ?? []
        ui = try container.decodeIfPresent(FlowUI.self, forKey: .ui)
        tags = try container.decodeIfPresent([Tag].self, forKey: .tags) ?? []
        nodeCount = try container.decodeIfPresent(Int.self, forKey: .nodeCount)
    }

    public override func encode(to encoder: Encoder) throws {
        try super.encode(to: encoder)
        var container = encoder.container(keyedBy: CodingKeys.self)
        if name != nil { try container.encode(name, forKey: .name) }
        if roles != nil { try container.encode(roles, forKey: .roles) }
        if Description != nil { try container.encode(Description, forKey: .Description) }
        if notes != nil { try container.encode(notes, forKey: .notes) }
        if accountId != nil { try container.encode(accountId, forKey: .accountId) }
        if accountName != nil { try container.encode(accountName, forKey: .accountName) }
        if customerId != nil { try container.encode(customerId, forKey: .customerId) }
        if customerName != nil { try container.encode(customerName, forKey: .customerName) }
        if customerBreadcrumb != nil { try container.encode(customerBreadcrumb, forKey: .customerBreadcrumb) }
        if nodes != nil { try container.encode(nodes, forKey: .nodes) }
        if parameters != nil { try container.encode(parameters, forKey: .parameters) }
        if exits != nil { try container.encode(exits, forKey: .exits) }
        if ui != nil { try container.encode(ui, forKey: .ui) }
        if tags != nil { try container.encode(tags, forKey: .tags) }
        if nodeCount != nil { try container.encode(nodeCount, forKey: .nodeCount) }
    }
}