Evo Voice

<back to all web services

ListFlows

Lists all the flows

import Foundation
import ServiceStack

/**
* Lists all the flows
*/
// @Api(Description="Lists all the flows")
public class ListFlows : ListRequest<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 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 enum SortOrders : String, Codable
{
    case Ascend
    case Descend
}

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

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 enum FlowRoles : String, Codable
{
    case UI
    case Reference
    case PhoneNumberRouting
    case UserDialOut
    case FaxNumberRouting
}

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

    required public init(){}
}

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 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 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 DataType : Codable
{
    public var typeName:String
    public var fields:[DataField]

    required public init(){}
}

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 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 UIHints : String, Codable
{
    case None
    case LargeText
    case InlineForm
    case Password
    case InlineStruct
}

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 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 DataFieldUniqueness : String, Codable
{
    case NotUnique
    case Unique
    case UniqueToCustomer
}

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

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

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 class NodeParameterMap : List<String:NodeParameter>
{
    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 class NodeParameter : Codable
{
    public var id:String
    public var type:ValueTypes
    public var source:ValueSources
    public var isAsync:Bool
    public var referenceId:String
    public var value:Value
    public var noEvalTemplate:Bool
    public var listParameters:[NodeParameterMap]
    public var structParameters:NodeParameterMap
    public var isOutput:Bool
    public var expression:String
    public var listType:DataType

    required public init(){}
}

public enum ValueSources : String, Codable
{
    case Value
    case Flow
    case System
    case Customer
    case Session
    case Endpoint
    case Expression
    case User
}

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 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 FlowUI : Codable
{
    public var selectedNode:String
    public var canvasX:Double
    public var canvasY:Double
    public var canvasZoom:Double

    required public init(){}
}

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

    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 class ListResponse<T : Codable> : Codable
{
    /**
    * The items
    */
    // @ApiMember(Description="The items")
    public var items:[AccountInfo]

    /**
    * 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 class AccountInfo : EntityInfo
{
    /**
    * The name of this account
    */
    // @ApiMember(Description="The name of this account")
    public var name:String

    /**
    * The ID of this account's parent
    */
    // @ApiMember(Description="The ID of this account's parent")
    public var parentAccountId:String

    /**
    * The twilio account SID
    */
    // @ApiMember(Description="The twilio account SID")
    public var twilioAccountSid:String

    /**
    * The ancestors of this account. Useful for breadcrumbs
    */
    // @ApiMember(Description="The ancestors of this account. Useful for breadcrumbs")
    public var ancestorIds:[String]

    /**
    * The max number of phone numbers this account can have
    */
    // @ApiMember(Description="The max number of phone numbers this account can have")
    public var maxPhoneNumbers:Int

    /**
    * This account is BYOA
    */
    // @ApiMember(Description="This account is BYOA")
    public var isBYOA:Bool

    /**
    * TrustHub Profile Sid
    */
    // @ApiMember(Description="TrustHub Profile Sid")
    public var trustHubProfileSid:String

    /**
    * The ID of the logo file
    */
    // @ApiMember(Description="The ID of the logo file")
    public var logoId:String

    /**
    * The URI of the logo file
    */
    // @ApiMember(Description="The URI of the logo file")
    public var logoUri:String

    /**
    * The billing settings for this account
    */
    // @ApiMember(Description="The billing settings for this account")
    public var billingSettings:BillingSettings

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

    private enum CodingKeys : String, CodingKey {
        case name
        case parentAccountId
        case twilioAccountSid
        case ancestorIds
        case maxPhoneNumbers
        case isBYOA
        case trustHubProfileSid
        case logoId
        case logoUri
        case billingSettings
    }

    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)
        parentAccountId = try container.decodeIfPresent(String.self, forKey: .parentAccountId)
        twilioAccountSid = try container.decodeIfPresent(String.self, forKey: .twilioAccountSid)
        ancestorIds = try container.decodeIfPresent([String].self, forKey: .ancestorIds) ?? []
        maxPhoneNumbers = try container.decodeIfPresent(Int.self, forKey: .maxPhoneNumbers)
        isBYOA = try container.decodeIfPresent(Bool.self, forKey: .isBYOA)
        trustHubProfileSid = try container.decodeIfPresent(String.self, forKey: .trustHubProfileSid)
        logoId = try container.decodeIfPresent(String.self, forKey: .logoId)
        logoUri = try container.decodeIfPresent(String.self, forKey: .logoUri)
        billingSettings = try container.decodeIfPresent(BillingSettings.self, forKey: .billingSettings)
    }

    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 parentAccountId != nil { try container.encode(parentAccountId, forKey: .parentAccountId) }
        if twilioAccountSid != nil { try container.encode(twilioAccountSid, forKey: .twilioAccountSid) }
        if ancestorIds != nil { try container.encode(ancestorIds, forKey: .ancestorIds) }
        if maxPhoneNumbers != nil { try container.encode(maxPhoneNumbers, forKey: .maxPhoneNumbers) }
        if isBYOA != nil { try container.encode(isBYOA, forKey: .isBYOA) }
        if trustHubProfileSid != nil { try container.encode(trustHubProfileSid, forKey: .trustHubProfileSid) }
        if logoId != nil { try container.encode(logoId, forKey: .logoId) }
        if logoUri != nil { try container.encode(logoUri, forKey: .logoUri) }
        if billingSettings != nil { try container.encode(billingSettings, forKey: .billingSettings) }
    }
}

public class BillingSettings : Codable
{
    public var base:BillingItem
    public var localNumbers:BillingItem
    public var tollFreeNumbers:BillingItem
    public var inboundVoiceCalls:BillingItem
    public var outboundVoiceCalls:BillingItem
    public var inboundFaxes:BillingItem
    public var outboundFaxes:BillingItem
    public var inboundSmsMessages:BillingItem
    public var outboundSmsMessages:BillingItem
    public var aiInsights:BillingItem
    public var aiLiveMinutes:BillingItem

    required public init(){}
}

public class BillingItem : Codable
{
    public var baseCost:Double
    public var rawUnitMultiplier:Double
    public var unitCost:Double
    public var allowance:Int

    required public init(){}
}

Swift ListFlows DTOs

GET /flows HTTP/1.1 
Host: team.evovoice.io 
Accept: application/xml

HTTP/1.1 200 OK
Content-Type: application/xml
Content-Length: length

<ListResponseOfFlowInfoM153aFo_P xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.datacontract.org/2004/07/Voice.Api">
  <HasMorePages>false</HasMorePages>
  <Items xmlns:d2p1="http://schemas.datacontract.org/2004/07/Voice.Api.Flows">
    <d2p1:FlowInfo>
      <CreatedBy>String</CreatedBy>
      <DateCreated>String</DateCreated>
      <DateLastModified>String</DateLastModified>
      <Id>String</Id>
      <LastModifiedBy>String</LastModifiedBy>
      <d2p1:AccountId>String</d2p1:AccountId>
      <d2p1:AccountName>String</d2p1:AccountName>
      <d2p1:CustomerBreadcrumb xmlns:d4p1="http://schemas.datacontract.org/2004/07/Voice.Api.Customers">
        <d4p1:CustomerBreadcrumb>
          <d4p1:Id>String</d4p1:Id>
          <d4p1:Name>String</d4p1:Name>
        </d4p1:CustomerBreadcrumb>
      </d2p1:CustomerBreadcrumb>
      <d2p1:CustomerId>String</d2p1:CustomerId>
      <d2p1:CustomerName>String</d2p1:CustomerName>
      <d2p1:Description>String</d2p1:Description>
      <d2p1:Exits>
        <d2p1:FlowExit>
          <d2p1:Id>String</d2p1:Id>
          <d2p1:Name>String</d2p1:Name>
          <d2p1:UI>
            <d2p1:Notes>String</d2p1:Notes>
            <d2p1:X>0</d2p1:X>
            <d2p1:Y>0</d2p1:Y>
          </d2p1:UI>
        </d2p1:FlowExit>
      </d2p1:Exits>
      <d2p1:Name>String</d2p1:Name>
      <d2p1:NodeCount>0</d2p1:NodeCount>
      <d2p1:Nodes>
        <d2p1:FlowNode>
          <d2p1:Id>String</d2p1:Id>
          <d2p1:IsStartNode>false</d2p1:IsStartNode>
          <d2p1:Name>String</d2p1:Name>
          <d2p1:Parameters xmlns:d6p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
            <d6p1:KeyValueOfstringNodeParameteripFhVFNS>
              <d6p1:Key>String</d6p1:Key>
              <d6p1:Value i:nil="true" />
            </d6p1:KeyValueOfstringNodeParameteripFhVFNS>
          </d2p1:Parameters>
          <d2p1:Spec>
            <d2p1:Category>General</d2p1:Category>
            <d2p1:DataType xmlns:d7p1="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data" i:nil="true" />
            <d2p1:Description>String</d2p1:Description>
            <d2p1:DocumentationUrl>String</d2p1:DocumentationUrl>
            <d2p1:IconClass>String</d2p1:IconClass>
            <d2p1:Name>String</d2p1:Name>
            <d2p1:RestrictToChannels>
              <d2p1:FlowChannels>Voice</d2p1:FlowChannels>
            </d2p1:RestrictToChannels>
            <d2p1:TypeName>String</d2p1:TypeName>
            <d2p1:Url>String</d2p1:Url>
          </d2p1:Spec>
          <d2p1:UI>
            <d2p1:Notes>String</d2p1:Notes>
            <d2p1:X>0</d2p1:X>
            <d2p1:Y>0</d2p1:Y>
          </d2p1:UI>
        </d2p1:FlowNode>
      </d2p1:Nodes>
      <d2p1:Notes>String</d2p1:Notes>
      <d2p1:Parameters>
        <d2p1:FlowParameter>
          <AnyValueType xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data">false</AnyValueType>
          <ConditionalVisibilityField xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data">String</ConditionalVisibilityField>
          <ConditionalVisibilityValue xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data">String</ConditionalVisibilityValue>
          <CustomFieldValuesUrl xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data">String</CustomFieldValuesUrl>
          <DefaultValue xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data">
            <BoolValue>false</BoolValue>
            <ListValue xmlns:d7p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
              <d7p1:ArrayOfKeyValueOfstringValue8Ahp2kgT i:nil="true" />
            </ListValue>
            <NumberValue>0</NumberValue>
            <StringValue>String</StringValue>
            <StructValue xmlns:d7p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays" i:nil="true" />
          </DefaultValue>
          <Description xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data">String</Description>
          <DisableBinding xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data">false</DisableBinding>
          <Id xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data">String</Id>
          <IsAsync xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data">false</IsAsync>
          <IsOutput xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data">false</IsOutput>
          <ListType i:nil="true" xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data" />
          <Name xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data">String</Name>
          <NoEvalTemplate xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data">false</NoEvalTemplate>
          <PossibleValues xmlns:d6p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays" xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data">
            <d6p1:string>String</d6p1:string>
          </PossibleValues>
          <StructType i:nil="true" xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data" />
          <TransitionNameFormat xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data">String</TransitionNameFormat>
          <Type xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data">NotSpecified</Type>
          <UIHint xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data">None</UIHint>
          <UITab xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data">String</UITab>
          <Uniqueness xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data">NotUnique</Uniqueness>
          <UserMode xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data">Hidden</UserMode>
          <VoiceOnly xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data">false</VoiceOnly>
          <d2p1:IsKnob>false</d2p1:IsKnob>
          <d2p1:IsPublic>false</d2p1:IsPublic>
        </d2p1:FlowParameter>
      </d2p1:Parameters>
      <d2p1:Roles>
        <d2p1:FlowRoles>UI</d2p1:FlowRoles>
      </d2p1:Roles>
      <d2p1:Tags xmlns:d4p1="http://schemas.datacontract.org/2004/07/Voice.Api.Settings">
        <d4p1:Tag>
          <d4p1:Color>Magenta</d4p1:Color>
          <d4p1:Id>String</d4p1:Id>
          <d4p1:Name>String</d4p1:Name>
        </d4p1:Tag>
      </d2p1:Tags>
      <d2p1:UI>
        <d2p1:CanvasX>0</d2p1:CanvasX>
        <d2p1:CanvasY>0</d2p1:CanvasY>
        <d2p1:CanvasZoom>0</d2p1:CanvasZoom>
        <d2p1:SelectedNode>String</d2p1:SelectedNode>
      </d2p1:UI>
    </d2p1:FlowInfo>
  </Items>
  <TotalCount>0</TotalCount>
  <TotalPages>0</TotalPages>
</ListResponseOfFlowInfoM153aFo_P>