purecloud-flow-scripting-api-sdk-javascript 0.63.5 → 0.63.7

package/types.d.ts

@@ -735,7 +735,7 @@ export class ArchEnums {
      * Remember some actions like {@link ArchActionSwitch} will have dynamic outputs and dynamically
      * added outputs will have identifiers that are not in the enum above.
      */
-    readonly OUTPUT_IDS: {"active":"active","canceled":"canceled","closed":"closed","conditionsNotMet":"conditionsNotMet","default":"default","disconnect":"disconnect","emergency":"emergency","error":"error","event":"event","failure":"failure","formOutputs":"formOutputs","found":"found","holiday":"holiday","inactive":"inactive","knowledge":"knowledge","loop":"loop","loopNext":"loopNext","loopsMax":"loopsMax","matchExact":"matchExact","matchMultiple":"matchMultiple","maxNoInputs":"maxNoInputs","maxNoMatches":"maxNoMatches","no":"no","noInput":"noInput","noIntent":"noIntent","notFound":"notFound","open":"open","partiallyFound":"partiallyFound","skipResponseCapture":"skipResponseCapture","success":"success","timeout":"timeout","voicemail":"voicemail","yes":"yes"};
+    readonly OUTPUT_IDS: {"active":"active","canceled":"canceled","closed":"closed","conditionsNotMet":"conditionsNotMet","default":"default","disconnect":"disconnect","emergency":"emergency","error":"error","event":"event","failure":"failure","formOutputs":"formOutputs","found":"found","holiday":"holiday","inactive":"inactive","invalid":"invalid","knowledge":"knowledge","loop":"loop","loopNext":"loopNext","loopsMax":"loopsMax","matchExact":"matchExact","matchMultiple":"matchMultiple","maxNoInputs":"maxNoInputs","maxNoMatches":"maxNoMatches","no":"no","noInput":"noInput","noIntent":"noIntent","notFound":"notFound","open":"open","partiallyFound":"partiallyFound","skipResponseCapture":"skipResponseCapture","success":"success","timeout":"timeout","valid":"valid","voicemail":"voicemail","yes":"yes"};
     /**
      * Returns a string array that contains all valid output identifier strings.
      */
@@ -2989,7 +2989,10 @@ declare type callbackVoid = () => void;
  * create the factory instance as needed.
  */
 export class ArchFactoryFlows extends ArchBaseFactory {
-    // constructor();
+    /**
+     * Returns true indicating that this is an ArchFactoryFlows instance.
+     */
+    readonly isArchFactoryFlows: boolean;
     /**
      * The default division to use for flow creation calls like {@link ArchFactoryFlows#createFlowInboundCallAsync} if no division
      * is specified in the flowDivision parameter.
@@ -3007,17 +3010,12 @@ export class ArchFactoryFlows extends ArchBaseFactory {
      * A logging string for the Architect Factory Flows instance.
      */
     readonly logStr: string;
-    /**
-     * Returns true indicating that this is an ArchFactoryFlows instance.
-     */
-    readonly isArchFactoryFlows: boolean;
     /**
      * Creates a new [bot flow]{@link ArchFlowBot} flow in memory.
      * Upon successful creation the callback function that's passed in will be called with the newly
      * created Architect flow scripting object. Calling operations such as {@link ArchBaseFlow#saveAsync} and
      * {@link ArchBaseFlow#publishAsync} will create these flows in the cloud. Use the {@link ArchBaseFlow#isCreated}
      * property to see if the flow is created within Genesys Cloud.
-     *
      * The bot flow will have a bot that is already created which you can access via.
      * the [startUpObject]{@link ArchBaseFlowWorkflow#startUpObject} property off of the flow.
      * It's important to note that when you create a bot flow, unlike other flow types, Architect Scripting will have already
@@ -3281,6 +3279,30 @@ export class ArchFactoryFlows extends ArchBaseFactory {
      * @returns - while this method returns a promise, you should use the callback function to perform any processing because that callback will be passed the newly created {@link ArchFlowInboundChat} object instance.
      */
     createFlowInboundChatAsync(flowName: string, flowDescription?: string, defaultSupportedLanguage?: ArchLanguage, callbackFunction?: callbackArchFlowInboundChat, flowDivision?: ArchDivision): Promise<ArchFlowInboundChat>;
+    /**
+     * Creates a new [voice]{@link ArchFlowVoice} flow in memory.
+     * Upon successful creation the callback function that's passed in will be called with the newly
+     * created Architect flow scripting object. Calling operations such as {@link ArchBaseFlow#saveAsync} and
+     * {@link ArchBaseFlow#publishAsync} will create these flows in the cloud. Use the {@link ArchBaseFlow#isCreated}
+     * property to see if the flow is created within Genesys Cloud.
+     * @param flowName - the name for the new flow.
+     * @param [flowDescription] - the description for the new flow.
+     * @param [defaultSupportedLanguage] - {@link ArchLanguages#englishUnitedStates} - the default language to use for the flow.
+     * @param [callbackFunction] - a callback function to call if the voice call flow is successfully
+     *                                        created.  The first parameter passed to the callback function will
+     *                                        be the created in-memory flow.
+     * @param [flowDivision] - if specified, the division in which to create the flow.  This must be a division where
+     *                                        the division's {@link ArchDivision#canAddFlow} property returns true.  If not specified,
+     *                                        the division stored in the {@link ArchFactoryFlows#defaultFlowCreationDivision} will be used.
+     * @param [creationData] - if specified, the supplied JSON object will contain a natural language understanding configuration.
+     *                                        Similar to exporting the Natural Language Understanding configuration in Architect's UI, the JSON object
+     *                                        must have an nluDomainVersion property at the root to be valid and then subsequent natural language
+     *                                        configuration meta data underneath it.  Slot names within the JSON object should be compliant with
+     *                                        Architect variable naming standards.  If not specified, a default blank Natural Language Understanding
+     *                                        configuration will be used by Architect Scripting.
+     * @returns - while this method returns a promise, you should use the callback function to perform any processing because the callback will be passed the newly created {@link ArchFlowVoice} instance.
+     */
+    createFlowVoiceAsync(flowName: string, flowDescription?: string, defaultSupportedLanguage?: ArchLanguage, callbackFunction?: (...params: any[]) => any, flowDivision?: ArchDivision, creationData?: any): Promise<ArchFlowVoice>;
     /**
      * Creates a new [voicemail flow]{@link ArchFlowVoicemail} in memory.  Upon successful creation the callback function that's
      * passed in will be called with the newly created Architect flow scripting object.  The voicemail flow will have
@@ -3336,7 +3358,7 @@ export class ArchFactoryFlows extends ArchBaseFactory {
      * @returns -            while this method returns a promise, you should use the callback function to perform any processing because the
      *                                                      callback will be passed the newly created {@link ArchFlowVoiceSurvey} instance.
      */
-    static createFlowVoiceSurveyAsync(flowName: string, flowDescription?: string, defaultSupportedLanguage?: ArchLanguage, callbackFunction?: (...params: any[]) => any, flowDivision?: ArchDivision, creationData?: any, surveyFormName?: string, surveyFormId?: string, createNluFromSurveyForm?: boolean, configureFlowFromSurveyForm?: boolean): Promise<ArchFlowVoiceSurvey>;
+    createFlowVoiceSurveyAsync(flowName: string, flowDescription?: string, defaultSupportedLanguage?: ArchLanguage, callbackFunction?: (...params: any[]) => any, flowDivision?: ArchDivision, creationData?: any, surveyFormName?: string, surveyFormId?: string, createNluFromSurveyForm?: boolean, configureFlowFromSurveyForm?: boolean): Promise<ArchFlowVoiceSurvey>;
     /**
      * Creates a new [workflow]{@link ArchFlowWorkflow} flow in memory.
      * Upon successful creation the callback function that's passed in will be called with the newly
@@ -3559,7 +3581,7 @@ export class ArchFactoryFlows extends ArchBaseFactory {
      * @param [callbackFunction] - a callback function to call if the flow can be found on the server by id and type.
      *                                                     The first parameter passed to the callback function will be the Architect Scripting
      *                                                     flow instance.
-     * @returns - while this method returns a promise, you should use the callback function to perform any processing because that callback will be passed the ArchBaseFlow instance.
+     * @returns - while this method returns a promise, you should use the callback function to perform any processing because that callback will be passed the {@link ArchBaseFlow} instance.
      */
     checkoutAndLoadFlowByFlowIdAsync<T extends ArchBaseFlow = ArchBaseFlow>(flowId: string, flowType: string, forceUnlock?: boolean, flowVersion?: string, callbackFunction?: callbackArchBaseFlow): Promise<T>;
     /**
@@ -4042,7 +4064,6 @@ export class ArchLanguage extends ArchBaseCoreObject {
  * from various methods as they'll represent actual language instances.
  */
 export class ArchLanguages extends ArchBaseObject {
-    // constructor();
     /**
      * Returns the display type name string 'ArchLanguages'.
      */
@@ -4281,8 +4302,9 @@ export class ArchLogging {
     readonly displayTypeName: string;
     /**
      * Logs an error.  This accepts parameters similar to how you would call console.log.
+     * @param args - the values to log, similar to console.log parameters.
      */
-    logError(): void;
+    logError(...args: any[]): void;
     /**
      * Logs an error and then throws an exception with the supplied
      * error message text.
@@ -4291,16 +4313,19 @@ export class ArchLogging {
     logErrorAndThrow(message: string): void;
     /**
      * Logs a note.  This accepts parameters similar to how you would call console.log.
+     * @param args - the values to log, similar to console.log parameters.
      */
-    logNote(): void;
+    logNote(...args: any[]): void;
     /**
      * Logs a verbose note.  This accepts parameters similar to how you would call console.log.
+     * @param args - the values to log, similar to console.log parameters.
      */
-    logNoteVerbose(): void;
+    logNoteVerbose(...args: any[]): void;
     /**
      * Logs a warning.  This accepts parameters similar to how you would call console.log.
+     * @param args - the values to log, similar to console.log parameters.
      */
-    logWarning(): void;
+    logWarning(...args: any[]): void;
     /**
      * A method where you can pass in a callback function that will get called when Architect logging is going
      * to log a message.  This will let you intercept the message, perform your own logging and conditionally
@@ -13429,12 +13454,12 @@ export class ArchActionSetPostFlow extends ArchBaseAction {
      * The target flow to call for this ArchActionSetPostFlow instance. Note that this function accepts either an {@link ArchFlowInfo} or an {@link ArchFlowInfoBasic}
      * instance. If the flow information supplied to the setter does not specify a flow, it will throw an exception.
      * The type of flow specified must also match the type specified in the action instance's actionType property
-     * @param targetFlowInfo - the {@link ArchFlowInfoBasic} that specifies the flow to execute.
+     * @param targetFlowInfo - the {@link ArchFlowInfoBasic} or {@link ArchFlowInfo} that specifies the flow to execute.
      * @param [callbackFunction] - a callback function to call if the flow is successfully
      *                                        configured on this action. The first parameter passed to the
      *                                        callback function will be this Architect Set Post Flow action instance.
      */
-    setTargetFlowInfoAsync(targetFlowInfo: ArchFlowInfoBasic, callbackFunction?: (...params: any[]) => any): void;
+    setTargetFlowInfoAsync(targetFlowInfo: ArchFlowInfo | ArchFlowInfoBasic, callbackFunction?: (...params: any[]) => any): void;
     /**
      * Returns the target type string for the currently configured [action type]{@link ArchActionSetPostFlow#actionType}.
      */
@@ -17486,14 +17511,22 @@ declare type ExportInfoType = {
  */
 declare type callbackExportFullPath = (exportFullPath: string) => void;
 
-/**
- * The base Architect Scripting class for flows.
- * Instances of this class will be created by Architect Scripting as needed.  The {@link ArchFactoryFlows} has methods
- * available to create flows.
- * @param coreFlowViewModel - ( *Internal* ) an Architect core flow view model.
- */
 export class ArchBaseFlow extends ArchBaseCoreObjectWithId {
     // constructor(coreFlowViewModel: any);
+    /**
+     * Returns a definition for this flow type which provides access to information about this flow such as {@link ArchDefinitionFlow#isAvailable}.
+     * ```
+     * // Example code - remember, only access this when your Scripting session is connected!
+     * let archIncomingCallFlowDefinition = scripting.viewModels.flows.ArchFlowInboundCall.definition;
+     * // or for a given ArchFlowInboundCall flow instance:
+     * let archIncomingCallFlowDefinition = archInboundCallFlowInstance.definition;
+     * ```
+     */
+    readonly definition: ArchDefinitionFlow;
+    /**
+     * Returns true indicating that this is an ArchBaseFlow instance.
+     */
+    readonly isArchBaseFlow: boolean;
     /**
      * This adds a new variable to the flow.
      * @param name - the name of the variable to add.  Remember that variable names must
@@ -17523,7 +17556,7 @@ export class ArchBaseFlow extends ArchBaseCoreObjectWithId {
      * @param [callbackFunction] - a callback function to call if the flow was checked out.
      * @returns - while this method returns a promise, you should use the callback function to perform any processing once the flow is checked out.
      */
-    checkoutAsync(forceUnlock?: boolean, callbackFunction?: callbackVoid): Promise<any>;
+    checkoutAsync(forceUnlock?: boolean, callbackFunction?: callbackVoid): Promise<ArchFlowInfo>;
     /**
      * Returns the display type name string 'ArchBaseFlow'.
      */
@@ -17576,7 +17609,7 @@ export class ArchBaseFlow extends ArchBaseCoreObjectWithId {
      * @returns - On your promise's then handler, the first parameter passed to the then function will be this
      * flow instance.
      */
-    checkInAsync(ensureSearchable?: boolean): Promise<any>;
+    checkInAsync(ensureSearchable?: boolean): Promise<ArchBaseFlow | undefined>;
     /**
      * Creates a new flow on the server and saves its configuration
      * @returns - On your promise's then handler, the first parameter passed to the then function will be this
@@ -17665,7 +17698,7 @@ export class ArchBaseFlow extends ArchBaseCoreObjectWithId {
      *                                                    on this flow.  The first parameter passed to the callback function will be this
      *                                                    Architect flow instance.
      */
-    importFromContentAsync(exportContent: string, callbackFunction?: (...params: any[]) => any): Promise<any>;
+    importFromContentAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportContent: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
     /**
      * Imports the flow content from the supplied file path.  Upon successful import, the callback function passed in
      * will be called.  Importing flow contents in to a flow is something where you should *not* attempt to
@@ -17676,11 +17709,2693 @@ export class ArchBaseFlow extends ArchBaseCoreObjectWithId {
      *                                        on this flow.  The first parameter passed to the callback function will be this
      *                                        Architect flow instance.
      */
-    importFromFileAsync(exportFilePath: string, callbackFunction?: (...params: any[]) => any): Promise<any>;
+    importFromFileAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportFilePath: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
     /**
-     * Returns true indicating that this is an ArchBaseFlow instance.
+     * Returns whether or not the flow is created in Genesys Cloud.
      */
-    readonly isArchBaseFlow: boolean;
+    readonly isCreated: boolean;
+    /**
+     * Returns whether or not the flow is read-only.  Flows that have been created locally in
+     * scripting but not saved, checked in or published will report that they are not read-only.
+     */
+    readonly isReadOnly: boolean;
+    /**
+     * Returns whether or not the flow is secure.  That means it contains something that is
+     * secure like a secure variable or secure action.
+     */
+    readonly isSecure: boolean;
+    /**
+     * Returns true indicating the flow acts as a variable container which means you can
+     * add variables to it.
+     */
+    readonly isVariableContainer: boolean;
+    /**
+     * The language settings for the flow.  This property is now deprecated.
+     * Please replace calls to this property with {@link ArchBaseFlow#settingsSupportedLanguages} instead.
+     */
+    readonly languageSettings: ArchSettingsSupportedLanguagesFlow;
+    /**
+     * The name of the flow
+     */
+    name: string;
+    /**
+     * Publishes the flow. This will do a validate, save, checkin and then publish last. Any of these
+     * steps can fail and reject the promise. Operations are not atomic.
+     * @param [ensureSearchable] - whether or not to poll after successful publish to ensure that the flow is available for flow
+     *                                       search operations such as {@link ArchFactoryFlows#getFlowInfoByFlowNameAsync} or {@link ArchFactoryFlows#getFlowInfoByFlowIdAsync}
+     * @returns - On your promise's then handler, the first parameter passed to the then function will be this
+     * flow instance.
+     */
+    publishAsync(ensureSearchable?: boolean): Promise<any>;
+    /**
+     * Save the current flow configuration, creating the flow if needed.
+     * @returns - On your promise's then handler, the first parameter passed to the then function will be this
+     * flow instance.
+     */
+    saveAsync(): Promise<any>;
+    /**
+     * Returns the error handling settings for the flow.
+     */
+    readonly settingsErrorHandling: ArchSettingsEventErrorFlow;
+    /**
+     * Returns the action default settings for the flow.
+     */
+    readonly settingsActionDefaults: ArchSettingsActionDefaults;
+    /**
+     * The supported language settings for the flow.
+     * This method will throw if the flow doesn't support languages.  You can check {@link ArchBaseFlow#supportsLanguages} prior
+     * to calling this method to see if a flow supports languages or not.
+     */
+    readonly settingsSupportedLanguages: ArchSettingsSupportedLanguagesFlow;
+    /**
+     * Returns whether or not this flow supports audio channel.
+     */
+    readonly supportsAudio: boolean;
+    /**
+     * Returns whether or not this flow supports error handling.
+     */
+    readonly supportsErrorHandling: boolean;
+    /**
+     * Returns whether or not this flow supports languages.  If false, that means you have to configure the flow
+     * when creating it to use English United States.
+     * Note:  At this time this functionality is available while we're determining the needs of workflow and
+     * inbound email flow types.  This property may go away in a future release of Architect Scripting.
+     */
+    readonly supportsLanguages: boolean;
+    /**
+     * Returns whether or not this flow supports setting a supported language as the default.
+     */
+    readonly supportsDefaultLanguage: boolean;
+    /**
+     * Returns a URL for this flow.  If the flow has not been created or there is no startup object set on the flow,
+     * the returned URL will be blank.
+     */
+    readonly url: string;
+    /**
+     * Validates the flow. Promise returns an {@link ArchValidationResults} instance.
+     * @returns - On your promise's then handler, the first parameter passed to the then function will be the
+     * validation results.
+     */
+    validateAsync(): Promise<ArchValidationResults>;
+    /**
+     * Returns an array of variables defined at the flow scope for this flow.
+     */
+    readonly variables: ArchBaseVariable[];
+    /**
+     * The identifier string for this object.
+     */
+    readonly id: string;
+    /**
+     * Returns whether or not the id property may be blank or undefined for this object.  For example, the returned settings from {@link ArchMenu#settingsMenu}
+     * will have a blank identifier along with the settings returned from {@link ArchMenu#settingsSpeechRec}.  Note that this is
+     * an extremely rare case.
+     */
+    readonly idMayBeBlank: string;
+    /**
+     * Returns true indicating that this is an ArchBaseCoreObject instance.
+     */
+    readonly isArchBaseCoreObject: boolean;
+    /**
+     * This method iterates over this object and ArchBaseCoreObject instances
+     * within it.  For each object it will call the {@link ArchBaseObject#isFilterMatch} method
+     * with a filter and call the supplied callback function if isMatch returns true.
+     * The callback will be passed an {@link ArchTraverseInfo} with details
+     * about the match such as the match object itself along with current contextual
+     * information such as the object hierarchy for the match object relative to
+     * the object on which this traverse call is being made.
+     *
+     * The traverse [filter]{@link ArchFilterObject} is one which you can create
+     * by calling {@link ArchFactoryFilters#createFilterObject} and then add desired clauses
+     * or clause containers to it.  If not specified, this function will use a
+     * [default filter]{@link ArchFactoryFilters#createFilterTraverseDefault}.
+     *
+     * Here is an example that does a simple flow traversal using the default
+     * filter and logs information about objects in the callback from the
+     * traverse object that's passed back:
+     *
+     * ```
+     * archInboundCallFlow.traverse(function(traverseInfo) {
+     *    archLogging.logNote('  Object     : ' + traverseInfo.matchObject.logStr);
+     *    archLogging.logNote('    Hierarchy: ' + traverseInfo.context.hierarchyStr);
+     * });
+     * ```
+     * This might be enough for most uses and you can check various aspects
+     * about the object in the callback such as "is this an Architect action?" by
+     * seeing if traverseInfo.matchObject.isArchBaseAction is true.  You can specify
+     * a filter for the traversal code to use as well and only have it call your
+     * callback when the object's {@link ArchBaseCoreObject#isFilterMatch} method returns true for
+     * the filter.  Here's an example that creates a filter for callbacks on
+     * [any type of transfer action]{@link ArchBaseActionTransfer}, any
+     * [decision action]{@link ArchActionDecision} or objects whose name
+     * property case insensitively matches the word 'foo'.  While this could all be done
+     * with one property callback clause the example will use multiple clauses for
+     * the sake of simplicity:
+     * ```
+     * const myTraverseFilter = filterFactory.createFilterObject(archEnums.FILTER_CONTAINER_OPERATORS.or);
+     * myTraverseFilter.addClausePropertyValueEquals('isArchBaseActionTransfer', true);
+     * myTraverseFilter.addClausePropertyValueEquals('isArchActionDecision',     true);
+     * myTraverseFilter.addClausePropertyCallback('name', function(propValue, archContainingObject, propName) {
+     *       // We fully spelled out the function signature above but archContainingObject and propName are
+     *       // not needed in this case.  The archContainingObject is the object that contains the
+     *       // property and propName is the property name itself.  We pass in propName because the same
+     *       // function could be used for multiple property callback clauses.
+     *       // Remember to return a boolean true, false or undefined from ths callback.  :)
+     *       return propValue && propValue.toLowerCase() === 'foo';
+     * });
+     * archTask.traverse(function(traverseContext) {
+     *    // You will only be called back here for ArchBaseCoreObject instances that
+     *    // have the isArchBaseActionTransfer or isArchActionDecision property values equal to true.
+     * }, myTraverseFilter);
+     * ```
+     * If you supply a filter with no clauses, this tells the traverse method to
+     * call the supplied callback function for every {@link ArchBaseCoreObject} it traverses.
+     *
+     * If you want traversal itself to stop after a callback, simply return boolean
+     * false from the callback function you supply to the traverse call.
+     *
+     * The traverse method does not process deprecated property names such as [orgId]{@link ArchSession#orgId},
+     * [orgName]{@link ArchSession#orgName} or [languageSettings]{@link ArchBaseFlow#languageSettings}.  Additionally
+     * it does not traverse in to properties that would "jump out" of the current traversal.  An example of this
+     * would be if the code was traversing an {@link ArchActionJumpToMenu} action that it would not start traversing
+     * in to the menu that it jumps to.  Another example would be a {@link ArchActionChangeState} action where
+     * it would not traverse in to the target state of the action.  This also means traversal does not traverse
+     * in to the {@link ArchBaseValue#flowLevelDefault} property.
+     *
+     * And lastly, as Scripting evolves over time with new versions, you can expect to get callbacks for new object
+     * types such as new actions or new properties on objects.  As such, it's important not to assume any particular
+     * order in callbacks to keep code most compatible with traversal callbacks.  Or if you use inequality checks in filter
+     * clauses remember that new "stuff" may satisfy an inequality check which may or may not be anticipated in your logic.
+     *
+     * Note:  This traverse method is a helper method and is very handy for iterating over Architect Scripting
+     * objects and their properties in a generic fashion with filtering capabilities.  Obviously you can write
+     * your own custom traversal code if this implementation doesn't cut it for some reason. :)
+     *
+     * This function returns the number of times it called the callback function.
+     * @param callbackFunction - the callback function to call for objects that match the traverse filter.
+     * @param [traverseFilter = {@link ArchFactoryFilters#createFilterTraverseDefault}] - the filter to use when performing the traversal to determine which
+     *                                              {@link ArchBaseCoreObject} instances you wish to be called back for.  If no
+     *                                              filter is specified, this function will call {@link ArchFactoryFilters#createFilterTraverseDefault} and
+     *                                              use that traversal default filter.  The wantArchBaseValues parameter on that call is set to true.
+     */
+    traverse(callbackFunction: callbackTraverseInfo, traverseFilter?: ArchFilterObject): number;
+    /**
+     * This is a string suitable for logging information about this object where it's just the object's type.  This is normally used
+     * when logging errors that occur in constructor parameter checking because the scripting object isn't set up and the normal
+     * logging str contents wouldn't be set up.
+     */
+    readonly logStrTypeOnly: string;
+    /**
+     * Logs an error to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logErrors} is true.
+     * @param errorStr - the error string to log.
+     */
+    logError(errorStr: string): void;
+    /**
+     * Logs an error to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logErrors} is true and then throws
+     * the string in the errorStr parameter.
+     * @param errorStr - the error string to log.  This should be a non-blank string.
+     */
+    logErrorAndThrow(errorStr: string): void;
+    /**
+     * Logs a note to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logNotes} is true.
+     * @param noteStr - the note string to log.  This should be a non-blank string.
+     */
+    logNote(noteStr: string): void;
+    /**
+     * Logs a note to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logNotesVerbose} is true.
+     * @param noteStr - the note string to log.  This should be a non-blank string.
+     */
+    logNoteVerbose(noteStr: string): void;
+    /**
+     * Logs a warning to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logWarnings} is true.
+     * @param warningStr - the warning string to log.  This should be a non-blank string.
+     */
+    logWarning(warningStr: string): void;
+    /**
+     * Returns whether or not this Architect Scripting object is a match
+     * for the supplied ArchFilterObject instance.
+     * @param archFilterObject - the object filter to use to determine if it's a match.
+     */
+    isFilterMatch(archFilterObject: ArchFilterObject): boolean;
+}
+
+export class ArchBaseFlowBot extends ArchBaseFlowWorkflow {
+    // constructor(coreBotViewModel: any);
+    /**
+     * Returns the display type name string 'ArchBaseFlowBot'.
+     */
+    readonly displayTypeName: string;
+    /**
+     * Returns true indicating that this is an ArchBaseFlowBot instance.
+     */
+    readonly isArchBaseFlowBot: boolean;
+    /**
+     * The user input settings for the flow.
+     */
+    readonly userInputSettings: ArchSettingsUserInput;
+    /**
+     * Returns the error handling settings for the flow.
+     */
+    readonly settingsErrorHandling: ArchSettingsEventErrorFlowBot;
+    /**
+     * This function deletes the specified state from this flow.
+     * @param stateToDelete - the state to delete.
+     */
+    deleteState(stateToDelete: ArchState): void;
+    /**
+     * Sets the specified state to be the starting state on the flow.
+     * @param archState - An Architect Scripting state object.
+     */
+    setStartingState(archState: ArchState): void;
+    /**
+     * Returns the starting state for this flow.
+     * If there is no startup object configured, accessing this property returns null.
+     */
+    readonly startUpObject: ArchState;
+    /**
+     * The states in the flow.
+     */
+    readonly states: ArchState[];
+    /**
+     * This function deletes the specified reusable task from this flow.
+     * @param taskToDelete - the task to delete.  This must be a reusable task which means the {@link ArchTask#isReusableTask}
+     * property on the specified task instance is true.
+     */
+    deleteTask(taskToDelete: ArchTask): void;
+    /**
+     * Returns an array of the currently defined reusable tasks for this flow.
+     */
+    readonly tasksReusable: ArchTask[];
+    /**
+     * This adds a new variable to the flow.
+     * @param name - the name of the variable to add.  Remember that variable names must
+     *                        start with a letter and can then be followed by one or more letters, numbers
+     *                        or underscore characters to be valid.  Submitting the variable scope on the name
+     *                        is optional.  If specified, it must be 'Flow.' in order to be valid since you're
+     *                        adding the variable to a flow. You can also specify 'Slot.' to add a slot variable
+     *                         to the flow as long as the forceSlotVariableCreation parameter is true.
+     * @param type - the data type for the new variable.  Remember that type must be supported
+     *                              in the flow type for which you're looking to add the variable.  If you are
+     *                              not sure if a type is creatable, see the {@link ArchDataType#isScriptCreatableForFlowType} or
+     *                              {@link ArchDataType#isScriptCreatableForFlow} method.
+     * @param [description] - the description for the new variable.
+     * @param [forceSlotVariableCreation] - if true, will force the creation of a slot variable even when a Slot is not created in the Natural Language Understanding (NLU).
+     */
+    addVariable(name: string, type: ArchDataType, description?: string, forceSlotVariableCreation?: boolean): ArchBaseVariable;
+    /**
+     * This deletes the supplied variable from the flow.  Remember you can call {@link ArchBaseVariable#canDelete}
+     * prior to calling this method to know if the supplied flow scoped variable can be deleted.
+     * @param archVariable - the flow scoped variable you wish to delete
+     * @returns - true if the variable was removed successfully, false otherwise.
+     */
+    removeVariable(archVariable: ArchBaseVariable): boolean;
+    /**
+     * Checkout this flow. This function returns an ArchInfo instance for it to the supplied callback function.
+     * @param [forceUnlock] - if true, will force an unlock of the flow.
+     * @param [callbackFunction] - a callback function to call if the flow was checked out.
+     * @returns - while this method returns a promise, you should use the callback function to perform any processing once the flow is checked out.
+     */
+    checkoutAsync(forceUnlock?: boolean, callbackFunction?: callbackVoid): Promise<ArchFlowInfo>;
+    /**
+     * Returns the division associated with this flow.
+     * This method first calls {@link ArchOrganizationInfo#areDivisionsAvailable} to ensure that divisions are available.
+     * If not available, nothing is returned.
+     */
+    readonly division: ArchDivision;
+    /**
+     * Loads a specific version of the flow.  Any previously returned Architect Scripting objects associated with this flow should no
+     * longer be considered valid after loading new configuration.
+     * @param [flowVersion = "latest"] - the version of the flow to get.  Valid values are "latest" to get the latest saved configuration of a flow,
+     * a version value such as "2.0" or "2", "debug" to get the currently published debug version configuration of a flow,
+     * or "published" to get the currently published version configuration of a flow.  If you do not specify a version, then the latest saved configuration will be loaded.
+     * @param [callbackFunction] - a callback function to call if the flow was loaded.
+     * @returns - while this method returns a promise, you should use the callback function to perform any processing when the flow is loaded.
+     */
+    loadAsync(flowVersion?: string, callbackFunction?: callbackVoid): Promise<any>;
+    /**
+     * Returns a string suitable for logging that describes the flow
+     */
+    readonly logStr: string;
+    /**
+     * Unlocks this flow.
+     * @param [callbackFunction] - a callback function to call if the flow can be unlocked.
+     * @returns - while this method returns a promise, you should use the callback function to perform any processing once this flow is unlocked.
+     */
+    unlockAsync(callbackFunction?: callbackVoid): Promise<any>;
+    /**
+     * Helper method that accesses the flow's [settingsSupportedLanguages]{@link ArchBaseFlow#settingsSupportedLanguages} and then calls
+     * the [addSupportedLanguage]{@link ArchSettingsSupportedLanguagesFlow#addSupportedLanguage} function on the returned {@link ArchSettingsSupportedLanguagesFlow}
+     * value.
+     * @param archLanguage - the language to add to supported languages on the flow.  Note that any language used as a supported
+     * language must have at least one region sub-tag.
+     * @param [setAsDefaultLanguage] - if true, the language will be set as the default language on the flow.
+     */
+    addFlowSupportedLanguage(archLanguage: ArchLanguage, setAsDefaultLanguage?: boolean): ArchSettingsSupportedLanguage;
+    /**
+     * Checks flow to see if a language can be added in its current state. Some flows may have restrictions
+     * if any or more than one can be added.
+     */
+    canAddSupportedLanguage(): boolean;
+    /**
+     * Checks in and unlocks the flow for the current user, does a save first
+     * Assumes the flow has been created, throws if not
+     * @param [ensureSearchable] - whether or not to poll after successful checkin to ensure that the flow is available for flow
+     *                                       search operations such as {@link ArchFactoryFlows#getFlowInfoByFlowNameAsync} or {@link ArchFactoryFlows#getFlowInfoByFlowIdAsync}
+     * @returns - On your promise's then handler, the first parameter passed to the then function will be this
+     * flow instance.
+     */
+    checkInAsync(ensureSearchable?: boolean): Promise<ArchBaseFlow | undefined>;
+    /**
+     * Creates a new flow on the server and saves its configuration
+     * @returns - On your promise's then handler, the first parameter passed to the then function will be this
+     * flow instance.
+     */
+    createAsync(): Promise<any>;
+    /**
+     * Accessing this property returns an object with properties whose keys are data type names and values are
+     * {@link ArchDataType} instances.
+     */
+    readonly dataTypes: any;
+    /**
+     * The description of the flow
+     */
+    description: string;
+    /**
+     * Exports the current flow to a file in the specified directory.  This destination directory *must* exist
+     * for the export to succeed.  Note that this uses the file system and should not be used when running in a
+     * browser.
+     * @param [destinationDir] - the directory where the flow export should be saved.
+     * @param [callbackFunction] - the function to call back and pass in the full path where the
+     *                                                      flow export was saved.
+     * @param [flowFormat = ArchEnums.FLOW_FORMAT_TYPES.architect] - the desired flow format to use for the export. See {@link ArchEnums#FLOW_FORMAT_TYPES} for allowable export formats. If no format is used,
+     *                                                                      it will default to the Architect format.
+     * @param [fileName] - the file name to use for the exported flow. If a file extension is not added to the file name, it will use the default file extension for the desired export type for
+     * the desired export format and flow that you are exporting. If the format is YAML, the extension is always '.yaml' regardless of flow type. However, if it is the Architect format, the extension is unique per flow-type.
+     * To find the correct file extension for the Architect format, you can either export a flow from the Architect UI or look at the [flow definition]{@link ArchBaseFlow#definition}
+     * for a flow type and access the [fileExtension]{@link ArchDefinitionFlow#fileExtension} property to get the value. If an extension is found on the file name other than what is
+     * expected, the correct extension will be appended to the end of the exported file as per the logic described previously.
+     */
+    exportToDirAsync(destinationDir?: string, callbackFunction?: callbackExportFullPath, flowFormat?: string, fileName?: string): Promise<string>;
+    /**
+     * Exports the flow to a JSON object.  The object passed back in the callback function
+     * will be a JSON object with a content and fileName property where the content holds
+     * the flow export contents and the fileName property holds the file name where the
+     * export would be written if {@link ArchBaseFlow#exportToDirAsync} is called.
+     * @param callbackFunction - the function to call back with the export information contained
+     *                                                  in the parameter passed to it.
+     * @param [flowFormat = archEnums.FLOW_FORMAT_TYPES.architect] - the desired export format to use on an export. See {@link ArchEnums#FLOW_FORMAT_TYPES} for allowable export formats. If no format is used,
+     *                                                                      it will default to the Architect format.
+     */
+    exportToObjectAsync(callbackFunction: callbackExportObject, flowFormat?: string): Promise<ExportInfoType>;
+    /**
+     * The type of the flow.  The string
+     * values in {@link ArchEnums#FLOW_TYPES} lists valid flow type values.
+     */
+    readonly flowType: string;
+    /**
+     * This function will return the file path where a flow export will be written when calling the {@link ArchBaseFlow#exportToDirAsync}
+     * method for the supplied destination directory and export flow format.  A typical use case for this function would be
+     * to get the export file path prior to calling the {@link ArchBaseFlow#exportToDirAsync} so you could see if the file already exists
+     * and decide if you want to perform an export or not since {@link ArchBaseFlow#exportToDirAsync} will attempt to overwrite
+     * a file if it already exists. Note that this uses the file system and should not be used when running in a
+     * browser.
+     * @param [destinationDir] - the directory where the flow export should be written. If no directory path is given, this method uses the
+     *                                    current working directory.  If a relative path is supplied, it will be resolved relative to the current
+     *                                    working directory.
+     * @param [flowFormat = ArchEnums.FLOW_FORMAT_TYPES.architect] - the desired flow format to use for the export. See {@link ArchEnums#FLOW_FORMAT_TYPES} for allowable export
+     *                                                                      formats. If no format is supplied, it will use the Architect format.
+     * @param [fileName] - the file name to use for the exported flow. If a file extension is not added to the file name, it will use the default file extension for the desired export type for
+     * the desired export format and flow that you are exporting. If the format is YAML, the extension is always '.yaml' regardless of flow type. However, if it is the Architect format, the extension is unique per flow-type.
+     * To find the correct file extension for the Architect format, you can either export a flow from the Architect UI or look at the [flow definition]{@link ArchBaseFlow#definition}
+     * for a flow type and access the [fileExtension]{@link ArchDefinitionFlow#fileExtension} property to get the value. If an extension is found on the file name other than what is
+     * expected, the correct extension will be appended to the end of the exported file as per the logic described previously.
+     */
+    getExportFilePath(destinationDir?: string, flowFormat?: string, fileName?: string): string;
+    /**
+     * Returns the flow scoped variable for the supplied variable identifier ( if it exists ).
+     * If the variable name cannot be found, nothing is returned.
+     * @param variableId - the supllied variable identifier to look up such as __CALL_ANI__.
+     */
+    getVariableById<T extends ArchBaseVariable = ArchBaseVariable>(variableId: string): T;
+    /**
+     * Returns the flow scoped variable for the supplied fully scoped variable name ( if it exists ).  Remember, looking
+     * up variables by name is case insensitive.  If the variable name cannot be found, nothing is returned.
+     * @param variableName - the fully scoped variable name to look up such as Flow.MyVar.
+     */
+    getVariableByName<T extends ArchBaseVariable = ArchBaseVariable>(variableName: string): T;
+    /**
+     * Imports the flow content from the supplied content string.  This content string should be for a flow of the
+     * same type as the one you're importing in to.  Upon successful import, the callback function passed in
+     * will be called.  Importing flow contents in to a flow is something where you should *not* attempt to
+     * do work with the flow on which this is being called until the callback is called.
+     * @param exportContent - the contents from a flow export.
+     * @param [callbackFunction] - a function to call if the export content successfully loaded and configured
+     *                                                    on this flow.  The first parameter passed to the callback function will be this
+     *                                                    Architect flow instance.
+     */
+    importFromContentAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportContent: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
+    /**
+     * Imports the flow content from the supplied file path.  Upon successful import, the callback function passed in
+     * will be called.  Importing flow contents in to a flow is something where you should *not* attempt to
+     * do work with the flow on which this is being called until the callback is called.
+     * Also note that this method should not be used if running in a browser.
+     * @param exportFilePath - the file path to an Architect flow export file that should be imported.
+     * @param [callbackFunction] - a function to call if the export content successfully loaded and configured
+     *                                        on this flow.  The first parameter passed to the callback function will be this
+     *                                        Architect flow instance.
+     */
+    importFromFileAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportFilePath: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
+    /**
+     * Returns whether or not the flow is created in Genesys Cloud.
+     */
+    readonly isCreated: boolean;
+    /**
+     * Returns whether or not the flow is read-only.  Flows that have been created locally in
+     * scripting but not saved, checked in or published will report that they are not read-only.
+     */
+    readonly isReadOnly: boolean;
+    /**
+     * Returns whether or not the flow is secure.  That means it contains something that is
+     * secure like a secure variable or secure action.
+     */
+    readonly isSecure: boolean;
+    /**
+     * Returns true indicating the flow acts as a variable container which means you can
+     * add variables to it.
+     */
+    readonly isVariableContainer: boolean;
+    /**
+     * The language settings for the flow.  This property is now deprecated.
+     * Please replace calls to this property with {@link ArchBaseFlow#settingsSupportedLanguages} instead.
+     */
+    readonly languageSettings: ArchSettingsSupportedLanguagesFlow;
+    /**
+     * The name of the flow
+     */
+    name: string;
+    /**
+     * Publishes the flow. This will do a validate, save, checkin and then publish last. Any of these
+     * steps can fail and reject the promise. Operations are not atomic.
+     * @param [ensureSearchable] - whether or not to poll after successful publish to ensure that the flow is available for flow
+     *                                       search operations such as {@link ArchFactoryFlows#getFlowInfoByFlowNameAsync} or {@link ArchFactoryFlows#getFlowInfoByFlowIdAsync}
+     * @returns - On your promise's then handler, the first parameter passed to the then function will be this
+     * flow instance.
+     */
+    publishAsync(ensureSearchable?: boolean): Promise<any>;
+    /**
+     * Save the current flow configuration, creating the flow if needed.
+     * @returns - On your promise's then handler, the first parameter passed to the then function will be this
+     * flow instance.
+     */
+    saveAsync(): Promise<any>;
+    /**
+     * Returns the action default settings for the flow.
+     */
+    readonly settingsActionDefaults: ArchSettingsActionDefaults;
+    /**
+     * The supported language settings for the flow.
+     * This method will throw if the flow doesn't support languages.  You can check {@link ArchBaseFlow#supportsLanguages} prior
+     * to calling this method to see if a flow supports languages or not.
+     */
+    readonly settingsSupportedLanguages: ArchSettingsSupportedLanguagesFlow;
+    /**
+     * Returns whether or not this flow supports audio channel.
+     */
+    readonly supportsAudio: boolean;
+    /**
+     * Returns whether or not this flow supports error handling.
+     */
+    readonly supportsErrorHandling: boolean;
+    /**
+     * Returns whether or not this flow supports languages.  If false, that means you have to configure the flow
+     * when creating it to use English United States.
+     * Note:  At this time this functionality is available while we're determining the needs of workflow and
+     * inbound email flow types.  This property may go away in a future release of Architect Scripting.
+     */
+    readonly supportsLanguages: boolean;
+    /**
+     * Returns whether or not this flow supports setting a supported language as the default.
+     */
+    readonly supportsDefaultLanguage: boolean;
+    /**
+     * Returns a URL for this flow.  If the flow has not been created or there is no startup object set on the flow,
+     * the returned URL will be blank.
+     */
+    readonly url: string;
+    /**
+     * Validates the flow. Promise returns an {@link ArchValidationResults} instance.
+     * @returns - On your promise's then handler, the first parameter passed to the then function will be the
+     * validation results.
+     */
+    validateAsync(): Promise<ArchValidationResults>;
+    /**
+     * Returns an array of variables defined at the flow scope for this flow.
+     */
+    readonly variables: ArchBaseVariable[];
+    /**
+     * The identifier string for this object.
+     */
+    readonly id: string;
+    /**
+     * Returns whether or not the id property may be blank or undefined for this object.  For example, the returned settings from {@link ArchMenu#settingsMenu}
+     * will have a blank identifier along with the settings returned from {@link ArchMenu#settingsSpeechRec}.  Note that this is
+     * an extremely rare case.
+     */
+    readonly idMayBeBlank: string;
+    /**
+     * Returns true indicating that this is an ArchBaseCoreObject instance.
+     */
+    readonly isArchBaseCoreObject: boolean;
+    /**
+     * This method iterates over this object and ArchBaseCoreObject instances
+     * within it.  For each object it will call the {@link ArchBaseObject#isFilterMatch} method
+     * with a filter and call the supplied callback function if isMatch returns true.
+     * The callback will be passed an {@link ArchTraverseInfo} with details
+     * about the match such as the match object itself along with current contextual
+     * information such as the object hierarchy for the match object relative to
+     * the object on which this traverse call is being made.
+     *
+     * The traverse [filter]{@link ArchFilterObject} is one which you can create
+     * by calling {@link ArchFactoryFilters#createFilterObject} and then add desired clauses
+     * or clause containers to it.  If not specified, this function will use a
+     * [default filter]{@link ArchFactoryFilters#createFilterTraverseDefault}.
+     *
+     * Here is an example that does a simple flow traversal using the default
+     * filter and logs information about objects in the callback from the
+     * traverse object that's passed back:
+     *
+     * ```
+     * archInboundCallFlow.traverse(function(traverseInfo) {
+     *    archLogging.logNote('  Object     : ' + traverseInfo.matchObject.logStr);
+     *    archLogging.logNote('    Hierarchy: ' + traverseInfo.context.hierarchyStr);
+     * });
+     * ```
+     * This might be enough for most uses and you can check various aspects
+     * about the object in the callback such as "is this an Architect action?" by
+     * seeing if traverseInfo.matchObject.isArchBaseAction is true.  You can specify
+     * a filter for the traversal code to use as well and only have it call your
+     * callback when the object's {@link ArchBaseCoreObject#isFilterMatch} method returns true for
+     * the filter.  Here's an example that creates a filter for callbacks on
+     * [any type of transfer action]{@link ArchBaseActionTransfer}, any
+     * [decision action]{@link ArchActionDecision} or objects whose name
+     * property case insensitively matches the word 'foo'.  While this could all be done
+     * with one property callback clause the example will use multiple clauses for
+     * the sake of simplicity:
+     * ```
+     * const myTraverseFilter = filterFactory.createFilterObject(archEnums.FILTER_CONTAINER_OPERATORS.or);
+     * myTraverseFilter.addClausePropertyValueEquals('isArchBaseActionTransfer', true);
+     * myTraverseFilter.addClausePropertyValueEquals('isArchActionDecision',     true);
+     * myTraverseFilter.addClausePropertyCallback('name', function(propValue, archContainingObject, propName) {
+     *       // We fully spelled out the function signature above but archContainingObject and propName are
+     *       // not needed in this case.  The archContainingObject is the object that contains the
+     *       // property and propName is the property name itself.  We pass in propName because the same
+     *       // function could be used for multiple property callback clauses.
+     *       // Remember to return a boolean true, false or undefined from ths callback.  :)
+     *       return propValue && propValue.toLowerCase() === 'foo';
+     * });
+     * archTask.traverse(function(traverseContext) {
+     *    // You will only be called back here for ArchBaseCoreObject instances that
+     *    // have the isArchBaseActionTransfer or isArchActionDecision property values equal to true.
+     * }, myTraverseFilter);
+     * ```
+     * If you supply a filter with no clauses, this tells the traverse method to
+     * call the supplied callback function for every {@link ArchBaseCoreObject} it traverses.
+     *
+     * If you want traversal itself to stop after a callback, simply return boolean
+     * false from the callback function you supply to the traverse call.
+     *
+     * The traverse method does not process deprecated property names such as [orgId]{@link ArchSession#orgId},
+     * [orgName]{@link ArchSession#orgName} or [languageSettings]{@link ArchBaseFlow#languageSettings}.  Additionally
+     * it does not traverse in to properties that would "jump out" of the current traversal.  An example of this
+     * would be if the code was traversing an {@link ArchActionJumpToMenu} action that it would not start traversing
+     * in to the menu that it jumps to.  Another example would be a {@link ArchActionChangeState} action where
+     * it would not traverse in to the target state of the action.  This also means traversal does not traverse
+     * in to the {@link ArchBaseValue#flowLevelDefault} property.
+     *
+     * And lastly, as Scripting evolves over time with new versions, you can expect to get callbacks for new object
+     * types such as new actions or new properties on objects.  As such, it's important not to assume any particular
+     * order in callbacks to keep code most compatible with traversal callbacks.  Or if you use inequality checks in filter
+     * clauses remember that new "stuff" may satisfy an inequality check which may or may not be anticipated in your logic.
+     *
+     * Note:  This traverse method is a helper method and is very handy for iterating over Architect Scripting
+     * objects and their properties in a generic fashion with filtering capabilities.  Obviously you can write
+     * your own custom traversal code if this implementation doesn't cut it for some reason. :)
+     *
+     * This function returns the number of times it called the callback function.
+     * @param callbackFunction - the callback function to call for objects that match the traverse filter.
+     * @param [traverseFilter = {@link ArchFactoryFilters#createFilterTraverseDefault}] - the filter to use when performing the traversal to determine which
+     *                                              {@link ArchBaseCoreObject} instances you wish to be called back for.  If no
+     *                                              filter is specified, this function will call {@link ArchFactoryFilters#createFilterTraverseDefault} and
+     *                                              use that traversal default filter.  The wantArchBaseValues parameter on that call is set to true.
+     */
+    traverse(callbackFunction: callbackTraverseInfo, traverseFilter?: ArchFilterObject): number;
+    /**
+     * This is a string suitable for logging information about this object where it's just the object's type.  This is normally used
+     * when logging errors that occur in constructor parameter checking because the scripting object isn't set up and the normal
+     * logging str contents wouldn't be set up.
+     */
+    readonly logStrTypeOnly: string;
+    /**
+     * Logs an error to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logErrors} is true.
+     * @param errorStr - the error string to log.
+     */
+    logError(errorStr: string): void;
+    /**
+     * Logs an error to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logErrors} is true and then throws
+     * the string in the errorStr parameter.
+     * @param errorStr - the error string to log.  This should be a non-blank string.
+     */
+    logErrorAndThrow(errorStr: string): void;
+    /**
+     * Logs a note to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logNotes} is true.
+     * @param noteStr - the note string to log.  This should be a non-blank string.
+     */
+    logNote(noteStr: string): void;
+    /**
+     * Logs a note to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logNotesVerbose} is true.
+     * @param noteStr - the note string to log.  This should be a non-blank string.
+     */
+    logNoteVerbose(noteStr: string): void;
+    /**
+     * Logs a warning to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logWarnings} is true.
+     * @param warningStr - the warning string to log.  This should be a non-blank string.
+     */
+    logWarning(warningStr: string): void;
+    /**
+     * Returns whether or not this Architect Scripting object is a match
+     * for the supplied ArchFilterObject instance.
+     * @param archFilterObject - the object filter to use to determine if it's a match.
+     */
+    isFilterMatch(archFilterObject: ArchFilterObject): boolean;
+}
+
+export class ArchBaseFlowBotWithKnowledge extends ArchBaseFlowBot {
+    // constructor(coreBotWithKnowledgeViewModel: any);
+    /**
+     * Returns the display type name string 'isArchBaseFlowBotWithKnowledge'.
+     */
+    readonly displayTypeName: string;
+    /**
+     * Returns true indicating that this is an isArchBaseFlowBotWithKnowledge instance.
+     */
+    readonly isArchBaseFlowBotWithKnowledge: boolean;
+    /**
+     * The natural language understanding knowledge settings for the bot flow.
+     * Note that if your organization does not have knowledge base support or the
+     * flow's supported language does not support knowledge, accessing this property
+     * will return null.
+     */
+    readonly knowledgeSettings: ArchSettingsNluKnowledge | null;
+    /**
+     * Bot-specific settings for the flow.
+     */
+    readonly botFlowSettings: ArchSettingsBotFlow;
+    /**
+     * Returns true indicating that this is an ArchBaseFlowBot instance.
+     */
+    readonly isArchBaseFlowBot: boolean;
+    /**
+     * The user input settings for the flow.
+     */
+    readonly userInputSettings: ArchSettingsUserInput;
+    /**
+     * Returns the error handling settings for the flow.
+     */
+    readonly settingsErrorHandling: ArchSettingsEventErrorFlowBot;
+    /**
+     * This function deletes the specified state from this flow.
+     * @param stateToDelete - the state to delete.
+     */
+    deleteState(stateToDelete: ArchState): void;
+    /**
+     * Sets the specified state to be the starting state on the flow.
+     * @param archState - An Architect Scripting state object.
+     */
+    setStartingState(archState: ArchState): void;
+    /**
+     * Returns the starting state for this flow.
+     * If there is no startup object configured, accessing this property returns null.
+     */
+    readonly startUpObject: ArchState;
+    /**
+     * The states in the flow.
+     */
+    readonly states: ArchState[];
+    /**
+     * This function deletes the specified reusable task from this flow.
+     * @param taskToDelete - the task to delete.  This must be a reusable task which means the {@link ArchTask#isReusableTask}
+     * property on the specified task instance is true.
+     */
+    deleteTask(taskToDelete: ArchTask): void;
+    /**
+     * Returns an array of the currently defined reusable tasks for this flow.
+     */
+    readonly tasksReusable: ArchTask[];
+    /**
+     * This adds a new variable to the flow.
+     * @param name - the name of the variable to add.  Remember that variable names must
+     *                        start with a letter and can then be followed by one or more letters, numbers
+     *                        or underscore characters to be valid.  Submitting the variable scope on the name
+     *                        is optional.  If specified, it must be 'Flow.' in order to be valid since you're
+     *                        adding the variable to a flow. You can also specify 'Slot.' to add a slot variable
+     *                         to the flow as long as the forceSlotVariableCreation parameter is true.
+     * @param type - the data type for the new variable.  Remember that type must be supported
+     *                              in the flow type for which you're looking to add the variable.  If you are
+     *                              not sure if a type is creatable, see the {@link ArchDataType#isScriptCreatableForFlowType} or
+     *                              {@link ArchDataType#isScriptCreatableForFlow} method.
+     * @param [description] - the description for the new variable.
+     * @param [forceSlotVariableCreation] - if true, will force the creation of a slot variable even when a Slot is not created in the Natural Language Understanding (NLU).
+     */
+    addVariable(name: string, type: ArchDataType, description?: string, forceSlotVariableCreation?: boolean): ArchBaseVariable;
+    /**
+     * This deletes the supplied variable from the flow.  Remember you can call {@link ArchBaseVariable#canDelete}
+     * prior to calling this method to know if the supplied flow scoped variable can be deleted.
+     * @param archVariable - the flow scoped variable you wish to delete
+     * @returns - true if the variable was removed successfully, false otherwise.
+     */
+    removeVariable(archVariable: ArchBaseVariable): boolean;
+    /**
+     * Checkout this flow. This function returns an ArchInfo instance for it to the supplied callback function.
+     * @param [forceUnlock] - if true, will force an unlock of the flow.
+     * @param [callbackFunction] - a callback function to call if the flow was checked out.
+     * @returns - while this method returns a promise, you should use the callback function to perform any processing once the flow is checked out.
+     */
+    checkoutAsync(forceUnlock?: boolean, callbackFunction?: callbackVoid): Promise<ArchFlowInfo>;
+    /**
+     * Returns the division associated with this flow.
+     * This method first calls {@link ArchOrganizationInfo#areDivisionsAvailable} to ensure that divisions are available.
+     * If not available, nothing is returned.
+     */
+    readonly division: ArchDivision;
+    /**
+     * Loads a specific version of the flow.  Any previously returned Architect Scripting objects associated with this flow should no
+     * longer be considered valid after loading new configuration.
+     * @param [flowVersion = "latest"] - the version of the flow to get.  Valid values are "latest" to get the latest saved configuration of a flow,
+     * a version value such as "2.0" or "2", "debug" to get the currently published debug version configuration of a flow,
+     * or "published" to get the currently published version configuration of a flow.  If you do not specify a version, then the latest saved configuration will be loaded.
+     * @param [callbackFunction] - a callback function to call if the flow was loaded.
+     * @returns - while this method returns a promise, you should use the callback function to perform any processing when the flow is loaded.
+     */
+    loadAsync(flowVersion?: string, callbackFunction?: callbackVoid): Promise<any>;
+    /**
+     * Returns a string suitable for logging that describes the flow
+     */
+    readonly logStr: string;
+    /**
+     * Unlocks this flow.
+     * @param [callbackFunction] - a callback function to call if the flow can be unlocked.
+     * @returns - while this method returns a promise, you should use the callback function to perform any processing once this flow is unlocked.
+     */
+    unlockAsync(callbackFunction?: callbackVoid): Promise<any>;
+    /**
+     * Helper method that accesses the flow's [settingsSupportedLanguages]{@link ArchBaseFlow#settingsSupportedLanguages} and then calls
+     * the [addSupportedLanguage]{@link ArchSettingsSupportedLanguagesFlow#addSupportedLanguage} function on the returned {@link ArchSettingsSupportedLanguagesFlow}
+     * value.
+     * @param archLanguage - the language to add to supported languages on the flow.  Note that any language used as a supported
+     * language must have at least one region sub-tag.
+     * @param [setAsDefaultLanguage] - if true, the language will be set as the default language on the flow.
+     */
+    addFlowSupportedLanguage(archLanguage: ArchLanguage, setAsDefaultLanguage?: boolean): ArchSettingsSupportedLanguage;
+    /**
+     * Checks flow to see if a language can be added in its current state. Some flows may have restrictions
+     * if any or more than one can be added.
+     */
+    canAddSupportedLanguage(): boolean;
+    /**
+     * Checks in and unlocks the flow for the current user, does a save first
+     * Assumes the flow has been created, throws if not
+     * @param [ensureSearchable] - whether or not to poll after successful checkin to ensure that the flow is available for flow
+     *                                       search operations such as {@link ArchFactoryFlows#getFlowInfoByFlowNameAsync} or {@link ArchFactoryFlows#getFlowInfoByFlowIdAsync}
+     * @returns - On your promise's then handler, the first parameter passed to the then function will be this
+     * flow instance.
+     */
+    checkInAsync(ensureSearchable?: boolean): Promise<ArchBaseFlow | undefined>;
+    /**
+     * Creates a new flow on the server and saves its configuration
+     * @returns - On your promise's then handler, the first parameter passed to the then function will be this
+     * flow instance.
+     */
+    createAsync(): Promise<any>;
+    /**
+     * Accessing this property returns an object with properties whose keys are data type names and values are
+     * {@link ArchDataType} instances.
+     */
+    readonly dataTypes: any;
+    /**
+     * The description of the flow
+     */
+    description: string;
+    /**
+     * Exports the current flow to a file in the specified directory.  This destination directory *must* exist
+     * for the export to succeed.  Note that this uses the file system and should not be used when running in a
+     * browser.
+     * @param [destinationDir] - the directory where the flow export should be saved.
+     * @param [callbackFunction] - the function to call back and pass in the full path where the
+     *                                                      flow export was saved.
+     * @param [flowFormat = ArchEnums.FLOW_FORMAT_TYPES.architect] - the desired flow format to use for the export. See {@link ArchEnums#FLOW_FORMAT_TYPES} for allowable export formats. If no format is used,
+     *                                                                      it will default to the Architect format.
+     * @param [fileName] - the file name to use for the exported flow. If a file extension is not added to the file name, it will use the default file extension for the desired export type for
+     * the desired export format and flow that you are exporting. If the format is YAML, the extension is always '.yaml' regardless of flow type. However, if it is the Architect format, the extension is unique per flow-type.
+     * To find the correct file extension for the Architect format, you can either export a flow from the Architect UI or look at the [flow definition]{@link ArchBaseFlow#definition}
+     * for a flow type and access the [fileExtension]{@link ArchDefinitionFlow#fileExtension} property to get the value. If an extension is found on the file name other than what is
+     * expected, the correct extension will be appended to the end of the exported file as per the logic described previously.
+     */
+    exportToDirAsync(destinationDir?: string, callbackFunction?: callbackExportFullPath, flowFormat?: string, fileName?: string): Promise<string>;
+    /**
+     * Exports the flow to a JSON object.  The object passed back in the callback function
+     * will be a JSON object with a content and fileName property where the content holds
+     * the flow export contents and the fileName property holds the file name where the
+     * export would be written if {@link ArchBaseFlow#exportToDirAsync} is called.
+     * @param callbackFunction - the function to call back with the export information contained
+     *                                                  in the parameter passed to it.
+     * @param [flowFormat = archEnums.FLOW_FORMAT_TYPES.architect] - the desired export format to use on an export. See {@link ArchEnums#FLOW_FORMAT_TYPES} for allowable export formats. If no format is used,
+     *                                                                      it will default to the Architect format.
+     */
+    exportToObjectAsync(callbackFunction: callbackExportObject, flowFormat?: string): Promise<ExportInfoType>;
+    /**
+     * The type of the flow.  The string
+     * values in {@link ArchEnums#FLOW_TYPES} lists valid flow type values.
+     */
+    readonly flowType: string;
+    /**
+     * This function will return the file path where a flow export will be written when calling the {@link ArchBaseFlow#exportToDirAsync}
+     * method for the supplied destination directory and export flow format.  A typical use case for this function would be
+     * to get the export file path prior to calling the {@link ArchBaseFlow#exportToDirAsync} so you could see if the file already exists
+     * and decide if you want to perform an export or not since {@link ArchBaseFlow#exportToDirAsync} will attempt to overwrite
+     * a file if it already exists. Note that this uses the file system and should not be used when running in a
+     * browser.
+     * @param [destinationDir] - the directory where the flow export should be written. If no directory path is given, this method uses the
+     *                                    current working directory.  If a relative path is supplied, it will be resolved relative to the current
+     *                                    working directory.
+     * @param [flowFormat = ArchEnums.FLOW_FORMAT_TYPES.architect] - the desired flow format to use for the export. See {@link ArchEnums#FLOW_FORMAT_TYPES} for allowable export
+     *                                                                      formats. If no format is supplied, it will use the Architect format.
+     * @param [fileName] - the file name to use for the exported flow. If a file extension is not added to the file name, it will use the default file extension for the desired export type for
+     * the desired export format and flow that you are exporting. If the format is YAML, the extension is always '.yaml' regardless of flow type. However, if it is the Architect format, the extension is unique per flow-type.
+     * To find the correct file extension for the Architect format, you can either export a flow from the Architect UI or look at the [flow definition]{@link ArchBaseFlow#definition}
+     * for a flow type and access the [fileExtension]{@link ArchDefinitionFlow#fileExtension} property to get the value. If an extension is found on the file name other than what is
+     * expected, the correct extension will be appended to the end of the exported file as per the logic described previously.
+     */
+    getExportFilePath(destinationDir?: string, flowFormat?: string, fileName?: string): string;
+    /**
+     * Returns the flow scoped variable for the supplied variable identifier ( if it exists ).
+     * If the variable name cannot be found, nothing is returned.
+     * @param variableId - the supllied variable identifier to look up such as __CALL_ANI__.
+     */
+    getVariableById<T extends ArchBaseVariable = ArchBaseVariable>(variableId: string): T;
+    /**
+     * Returns the flow scoped variable for the supplied fully scoped variable name ( if it exists ).  Remember, looking
+     * up variables by name is case insensitive.  If the variable name cannot be found, nothing is returned.
+     * @param variableName - the fully scoped variable name to look up such as Flow.MyVar.
+     */
+    getVariableByName<T extends ArchBaseVariable = ArchBaseVariable>(variableName: string): T;
+    /**
+     * Imports the flow content from the supplied content string.  This content string should be for a flow of the
+     * same type as the one you're importing in to.  Upon successful import, the callback function passed in
+     * will be called.  Importing flow contents in to a flow is something where you should *not* attempt to
+     * do work with the flow on which this is being called until the callback is called.
+     * @param exportContent - the contents from a flow export.
+     * @param [callbackFunction] - a function to call if the export content successfully loaded and configured
+     *                                                    on this flow.  The first parameter passed to the callback function will be this
+     *                                                    Architect flow instance.
+     */
+    importFromContentAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportContent: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
+    /**
+     * Imports the flow content from the supplied file path.  Upon successful import, the callback function passed in
+     * will be called.  Importing flow contents in to a flow is something where you should *not* attempt to
+     * do work with the flow on which this is being called until the callback is called.
+     * Also note that this method should not be used if running in a browser.
+     * @param exportFilePath - the file path to an Architect flow export file that should be imported.
+     * @param [callbackFunction] - a function to call if the export content successfully loaded and configured
+     *                                        on this flow.  The first parameter passed to the callback function will be this
+     *                                        Architect flow instance.
+     */
+    importFromFileAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportFilePath: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
+    /**
+     * Returns whether or not the flow is created in Genesys Cloud.
+     */
+    readonly isCreated: boolean;
+    /**
+     * Returns whether or not the flow is read-only.  Flows that have been created locally in
+     * scripting but not saved, checked in or published will report that they are not read-only.
+     */
+    readonly isReadOnly: boolean;
+    /**
+     * Returns whether or not the flow is secure.  That means it contains something that is
+     * secure like a secure variable or secure action.
+     */
+    readonly isSecure: boolean;
+    /**
+     * Returns true indicating the flow acts as a variable container which means you can
+     * add variables to it.
+     */
+    readonly isVariableContainer: boolean;
+    /**
+     * The language settings for the flow.  This property is now deprecated.
+     * Please replace calls to this property with {@link ArchBaseFlow#settingsSupportedLanguages} instead.
+     */
+    readonly languageSettings: ArchSettingsSupportedLanguagesFlow;
+    /**
+     * The name of the flow
+     */
+    name: string;
+    /**
+     * Publishes the flow. This will do a validate, save, checkin and then publish last. Any of these
+     * steps can fail and reject the promise. Operations are not atomic.
+     * @param [ensureSearchable] - whether or not to poll after successful publish to ensure that the flow is available for flow
+     *                                       search operations such as {@link ArchFactoryFlows#getFlowInfoByFlowNameAsync} or {@link ArchFactoryFlows#getFlowInfoByFlowIdAsync}
+     * @returns - On your promise's then handler, the first parameter passed to the then function will be this
+     * flow instance.
+     */
+    publishAsync(ensureSearchable?: boolean): Promise<any>;
+    /**
+     * Save the current flow configuration, creating the flow if needed.
+     * @returns - On your promise's then handler, the first parameter passed to the then function will be this
+     * flow instance.
+     */
+    saveAsync(): Promise<any>;
+    /**
+     * Returns the action default settings for the flow.
+     */
+    readonly settingsActionDefaults: ArchSettingsActionDefaults;
+    /**
+     * The supported language settings for the flow.
+     * This method will throw if the flow doesn't support languages.  You can check {@link ArchBaseFlow#supportsLanguages} prior
+     * to calling this method to see if a flow supports languages or not.
+     */
+    readonly settingsSupportedLanguages: ArchSettingsSupportedLanguagesFlow;
+    /**
+     * Returns whether or not this flow supports audio channel.
+     */
+    readonly supportsAudio: boolean;
+    /**
+     * Returns whether or not this flow supports error handling.
+     */
+    readonly supportsErrorHandling: boolean;
+    /**
+     * Returns whether or not this flow supports languages.  If false, that means you have to configure the flow
+     * when creating it to use English United States.
+     * Note:  At this time this functionality is available while we're determining the needs of workflow and
+     * inbound email flow types.  This property may go away in a future release of Architect Scripting.
+     */
+    readonly supportsLanguages: boolean;
+    /**
+     * Returns whether or not this flow supports setting a supported language as the default.
+     */
+    readonly supportsDefaultLanguage: boolean;
+    /**
+     * Returns a URL for this flow.  If the flow has not been created or there is no startup object set on the flow,
+     * the returned URL will be blank.
+     */
+    readonly url: string;
+    /**
+     * Validates the flow. Promise returns an {@link ArchValidationResults} instance.
+     * @returns - On your promise's then handler, the first parameter passed to the then function will be the
+     * validation results.
+     */
+    validateAsync(): Promise<ArchValidationResults>;
+    /**
+     * Returns an array of variables defined at the flow scope for this flow.
+     */
+    readonly variables: ArchBaseVariable[];
+    /**
+     * The identifier string for this object.
+     */
+    readonly id: string;
+    /**
+     * Returns whether or not the id property may be blank or undefined for this object.  For example, the returned settings from {@link ArchMenu#settingsMenu}
+     * will have a blank identifier along with the settings returned from {@link ArchMenu#settingsSpeechRec}.  Note that this is
+     * an extremely rare case.
+     */
+    readonly idMayBeBlank: string;
+    /**
+     * Returns true indicating that this is an ArchBaseCoreObject instance.
+     */
+    readonly isArchBaseCoreObject: boolean;
+    /**
+     * This method iterates over this object and ArchBaseCoreObject instances
+     * within it.  For each object it will call the {@link ArchBaseObject#isFilterMatch} method
+     * with a filter and call the supplied callback function if isMatch returns true.
+     * The callback will be passed an {@link ArchTraverseInfo} with details
+     * about the match such as the match object itself along with current contextual
+     * information such as the object hierarchy for the match object relative to
+     * the object on which this traverse call is being made.
+     *
+     * The traverse [filter]{@link ArchFilterObject} is one which you can create
+     * by calling {@link ArchFactoryFilters#createFilterObject} and then add desired clauses
+     * or clause containers to it.  If not specified, this function will use a
+     * [default filter]{@link ArchFactoryFilters#createFilterTraverseDefault}.
+     *
+     * Here is an example that does a simple flow traversal using the default
+     * filter and logs information about objects in the callback from the
+     * traverse object that's passed back:
+     *
+     * ```
+     * archInboundCallFlow.traverse(function(traverseInfo) {
+     *    archLogging.logNote('  Object     : ' + traverseInfo.matchObject.logStr);
+     *    archLogging.logNote('    Hierarchy: ' + traverseInfo.context.hierarchyStr);
+     * });
+     * ```
+     * This might be enough for most uses and you can check various aspects
+     * about the object in the callback such as "is this an Architect action?" by
+     * seeing if traverseInfo.matchObject.isArchBaseAction is true.  You can specify
+     * a filter for the traversal code to use as well and only have it call your
+     * callback when the object's {@link ArchBaseCoreObject#isFilterMatch} method returns true for
+     * the filter.  Here's an example that creates a filter for callbacks on
+     * [any type of transfer action]{@link ArchBaseActionTransfer}, any
+     * [decision action]{@link ArchActionDecision} or objects whose name
+     * property case insensitively matches the word 'foo'.  While this could all be done
+     * with one property callback clause the example will use multiple clauses for
+     * the sake of simplicity:
+     * ```
+     * const myTraverseFilter = filterFactory.createFilterObject(archEnums.FILTER_CONTAINER_OPERATORS.or);
+     * myTraverseFilter.addClausePropertyValueEquals('isArchBaseActionTransfer', true);
+     * myTraverseFilter.addClausePropertyValueEquals('isArchActionDecision',     true);
+     * myTraverseFilter.addClausePropertyCallback('name', function(propValue, archContainingObject, propName) {
+     *       // We fully spelled out the function signature above but archContainingObject and propName are
+     *       // not needed in this case.  The archContainingObject is the object that contains the
+     *       // property and propName is the property name itself.  We pass in propName because the same
+     *       // function could be used for multiple property callback clauses.
+     *       // Remember to return a boolean true, false or undefined from ths callback.  :)
+     *       return propValue && propValue.toLowerCase() === 'foo';
+     * });
+     * archTask.traverse(function(traverseContext) {
+     *    // You will only be called back here for ArchBaseCoreObject instances that
+     *    // have the isArchBaseActionTransfer or isArchActionDecision property values equal to true.
+     * }, myTraverseFilter);
+     * ```
+     * If you supply a filter with no clauses, this tells the traverse method to
+     * call the supplied callback function for every {@link ArchBaseCoreObject} it traverses.
+     *
+     * If you want traversal itself to stop after a callback, simply return boolean
+     * false from the callback function you supply to the traverse call.
+     *
+     * The traverse method does not process deprecated property names such as [orgId]{@link ArchSession#orgId},
+     * [orgName]{@link ArchSession#orgName} or [languageSettings]{@link ArchBaseFlow#languageSettings}.  Additionally
+     * it does not traverse in to properties that would "jump out" of the current traversal.  An example of this
+     * would be if the code was traversing an {@link ArchActionJumpToMenu} action that it would not start traversing
+     * in to the menu that it jumps to.  Another example would be a {@link ArchActionChangeState} action where
+     * it would not traverse in to the target state of the action.  This also means traversal does not traverse
+     * in to the {@link ArchBaseValue#flowLevelDefault} property.
+     *
+     * And lastly, as Scripting evolves over time with new versions, you can expect to get callbacks for new object
+     * types such as new actions or new properties on objects.  As such, it's important not to assume any particular
+     * order in callbacks to keep code most compatible with traversal callbacks.  Or if you use inequality checks in filter
+     * clauses remember that new "stuff" may satisfy an inequality check which may or may not be anticipated in your logic.
+     *
+     * Note:  This traverse method is a helper method and is very handy for iterating over Architect Scripting
+     * objects and their properties in a generic fashion with filtering capabilities.  Obviously you can write
+     * your own custom traversal code if this implementation doesn't cut it for some reason. :)
+     *
+     * This function returns the number of times it called the callback function.
+     * @param callbackFunction - the callback function to call for objects that match the traverse filter.
+     * @param [traverseFilter = {@link ArchFactoryFilters#createFilterTraverseDefault}] - the filter to use when performing the traversal to determine which
+     *                                              {@link ArchBaseCoreObject} instances you wish to be called back for.  If no
+     *                                              filter is specified, this function will call {@link ArchFactoryFilters#createFilterTraverseDefault} and
+     *                                              use that traversal default filter.  The wantArchBaseValues parameter on that call is set to true.
+     */
+    traverse(callbackFunction: callbackTraverseInfo, traverseFilter?: ArchFilterObject): number;
+    /**
+     * This is a string suitable for logging information about this object where it's just the object's type.  This is normally used
+     * when logging errors that occur in constructor parameter checking because the scripting object isn't set up and the normal
+     * logging str contents wouldn't be set up.
+     */
+    readonly logStrTypeOnly: string;
+    /**
+     * Logs an error to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logErrors} is true.
+     * @param errorStr - the error string to log.
+     */
+    logError(errorStr: string): void;
+    /**
+     * Logs an error to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logErrors} is true and then throws
+     * the string in the errorStr parameter.
+     * @param errorStr - the error string to log.  This should be a non-blank string.
+     */
+    logErrorAndThrow(errorStr: string): void;
+    /**
+     * Logs a note to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logNotes} is true.
+     * @param noteStr - the note string to log.  This should be a non-blank string.
+     */
+    logNote(noteStr: string): void;
+    /**
+     * Logs a note to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logNotesVerbose} is true.
+     * @param noteStr - the note string to log.  This should be a non-blank string.
+     */
+    logNoteVerbose(noteStr: string): void;
+    /**
+     * Logs a warning to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logWarnings} is true.
+     * @param warningStr - the warning string to log.  This should be a non-blank string.
+     */
+    logWarning(warningStr: string): void;
+    /**
+     * Returns whether or not this Architect Scripting object is a match
+     * for the supplied ArchFilterObject instance.
+     * @param archFilterObject - the object filter to use to determine if it's a match.
+     */
+    isFilterMatch(archFilterObject: ArchFilterObject): boolean;
+}
+
+export class ArchBaseFlowInQueueWorkflow extends ArchBaseFlowWorkflow {
+    // constructor(coreInQueueDigitalFlow: any);
+    /**
+     * Returns the display type name string 'ArchBaseFlowInQueueWorkflow'.
+     */
+    readonly displayTypeName: string;
+    /**
+     * Returns true indicating that this is an ArchBaseFlowInQueueWorkflow object.
+     * This will be true for in-queue email and in-queue short message flows.
+     */
+    readonly isArchBaseFlowInQueueWorkflow: boolean;
+    /**
+     * Returns the periodic state for this flow.
+     */
+    readonly periodicState: ArchState;
+    /**
+     * This function deletes the specified state from this flow.
+     * @param stateToDelete - the state to delete.
+     */
+    deleteState(stateToDelete: ArchState): void;
+    /**
+     * Sets the specified state to be the starting state on the flow.
+     * @param archState - An Architect Scripting state object.
+     */
+    setStartingState(archState: ArchState): void;
+    /**
+     * Returns the starting state for this flow.
+     * If there is no startup object configured, accessing this property returns null.
+     */
+    readonly startUpObject: ArchState;
+    /**
+     * The states in the flow.
+     */
+    readonly states: ArchState[];
+    /**
+     * This function deletes the specified reusable task from this flow.
+     * @param taskToDelete - the task to delete.  This must be a reusable task which means the {@link ArchTask#isReusableTask}
+     * property on the specified task instance is true.
+     */
+    deleteTask(taskToDelete: ArchTask): void;
+    /**
+     * Returns an array of the currently defined reusable tasks for this flow.
+     */
+    readonly tasksReusable: ArchTask[];
+    /**
+     * This adds a new variable to the flow.
+     * @param name - the name of the variable to add.  Remember that variable names must
+     *                        start with a letter and can then be followed by one or more letters, numbers
+     *                        or underscore characters to be valid.  Submitting the variable scope on the name
+     *                        is optional.  If specified, it must be 'Flow.' in order to be valid since you're
+     *                        adding the variable to a flow. You can also specify 'Slot.' to add a slot variable
+     *                         to the flow as long as the forceSlotVariableCreation parameter is true.
+     * @param type - the data type for the new variable.  Remember that type must be supported
+     *                              in the flow type for which you're looking to add the variable.  If you are
+     *                              not sure if a type is creatable, see the {@link ArchDataType#isScriptCreatableForFlowType} or
+     *                              {@link ArchDataType#isScriptCreatableForFlow} method.
+     * @param [description] - the description for the new variable.
+     * @param [forceSlotVariableCreation] - if true, will force the creation of a slot variable even when a Slot is not created in the Natural Language Understanding (NLU).
+     */
+    addVariable(name: string, type: ArchDataType, description?: string, forceSlotVariableCreation?: boolean): ArchBaseVariable;
+    /**
+     * This deletes the supplied variable from the flow.  Remember you can call {@link ArchBaseVariable#canDelete}
+     * prior to calling this method to know if the supplied flow scoped variable can be deleted.
+     * @param archVariable - the flow scoped variable you wish to delete
+     * @returns - true if the variable was removed successfully, false otherwise.
+     */
+    removeVariable(archVariable: ArchBaseVariable): boolean;
+    /**
+     * Checkout this flow. This function returns an ArchInfo instance for it to the supplied callback function.
+     * @param [forceUnlock] - if true, will force an unlock of the flow.
+     * @param [callbackFunction] - a callback function to call if the flow was checked out.
+     * @returns - while this method returns a promise, you should use the callback function to perform any processing once the flow is checked out.
+     */
+    checkoutAsync(forceUnlock?: boolean, callbackFunction?: callbackVoid): Promise<ArchFlowInfo>;
+    /**
+     * Returns the division associated with this flow.
+     * This method first calls {@link ArchOrganizationInfo#areDivisionsAvailable} to ensure that divisions are available.
+     * If not available, nothing is returned.
+     */
+    readonly division: ArchDivision;
+    /**
+     * Loads a specific version of the flow.  Any previously returned Architect Scripting objects associated with this flow should no
+     * longer be considered valid after loading new configuration.
+     * @param [flowVersion = "latest"] - the version of the flow to get.  Valid values are "latest" to get the latest saved configuration of a flow,
+     * a version value such as "2.0" or "2", "debug" to get the currently published debug version configuration of a flow,
+     * or "published" to get the currently published version configuration of a flow.  If you do not specify a version, then the latest saved configuration will be loaded.
+     * @param [callbackFunction] - a callback function to call if the flow was loaded.
+     * @returns - while this method returns a promise, you should use the callback function to perform any processing when the flow is loaded.
+     */
+    loadAsync(flowVersion?: string, callbackFunction?: callbackVoid): Promise<any>;
+    /**
+     * Returns a string suitable for logging that describes the flow
+     */
+    readonly logStr: string;
+    /**
+     * Unlocks this flow.
+     * @param [callbackFunction] - a callback function to call if the flow can be unlocked.
+     * @returns - while this method returns a promise, you should use the callback function to perform any processing once this flow is unlocked.
+     */
+    unlockAsync(callbackFunction?: callbackVoid): Promise<any>;
+    /**
+     * Helper method that accesses the flow's [settingsSupportedLanguages]{@link ArchBaseFlow#settingsSupportedLanguages} and then calls
+     * the [addSupportedLanguage]{@link ArchSettingsSupportedLanguagesFlow#addSupportedLanguage} function on the returned {@link ArchSettingsSupportedLanguagesFlow}
+     * value.
+     * @param archLanguage - the language to add to supported languages on the flow.  Note that any language used as a supported
+     * language must have at least one region sub-tag.
+     * @param [setAsDefaultLanguage] - if true, the language will be set as the default language on the flow.
+     */
+    addFlowSupportedLanguage(archLanguage: ArchLanguage, setAsDefaultLanguage?: boolean): ArchSettingsSupportedLanguage;
+    /**
+     * Checks flow to see if a language can be added in its current state. Some flows may have restrictions
+     * if any or more than one can be added.
+     */
+    canAddSupportedLanguage(): boolean;
+    /**
+     * Checks in and unlocks the flow for the current user, does a save first
+     * Assumes the flow has been created, throws if not
+     * @param [ensureSearchable] - whether or not to poll after successful checkin to ensure that the flow is available for flow
+     *                                       search operations such as {@link ArchFactoryFlows#getFlowInfoByFlowNameAsync} or {@link ArchFactoryFlows#getFlowInfoByFlowIdAsync}
+     * @returns - On your promise's then handler, the first parameter passed to the then function will be this
+     * flow instance.
+     */
+    checkInAsync(ensureSearchable?: boolean): Promise<ArchBaseFlow | undefined>;
+    /**
+     * Creates a new flow on the server and saves its configuration
+     * @returns - On your promise's then handler, the first parameter passed to the then function will be this
+     * flow instance.
+     */
+    createAsync(): Promise<any>;
+    /**
+     * Accessing this property returns an object with properties whose keys are data type names and values are
+     * {@link ArchDataType} instances.
+     */
+    readonly dataTypes: any;
+    /**
+     * The description of the flow
+     */
+    description: string;
+    /**
+     * Exports the current flow to a file in the specified directory.  This destination directory *must* exist
+     * for the export to succeed.  Note that this uses the file system and should not be used when running in a
+     * browser.
+     * @param [destinationDir] - the directory where the flow export should be saved.
+     * @param [callbackFunction] - the function to call back and pass in the full path where the
+     *                                                      flow export was saved.
+     * @param [flowFormat = ArchEnums.FLOW_FORMAT_TYPES.architect] - the desired flow format to use for the export. See {@link ArchEnums#FLOW_FORMAT_TYPES} for allowable export formats. If no format is used,
+     *                                                                      it will default to the Architect format.
+     * @param [fileName] - the file name to use for the exported flow. If a file extension is not added to the file name, it will use the default file extension for the desired export type for
+     * the desired export format and flow that you are exporting. If the format is YAML, the extension is always '.yaml' regardless of flow type. However, if it is the Architect format, the extension is unique per flow-type.
+     * To find the correct file extension for the Architect format, you can either export a flow from the Architect UI or look at the [flow definition]{@link ArchBaseFlow#definition}
+     * for a flow type and access the [fileExtension]{@link ArchDefinitionFlow#fileExtension} property to get the value. If an extension is found on the file name other than what is
+     * expected, the correct extension will be appended to the end of the exported file as per the logic described previously.
+     */
+    exportToDirAsync(destinationDir?: string, callbackFunction?: callbackExportFullPath, flowFormat?: string, fileName?: string): Promise<string>;
+    /**
+     * Exports the flow to a JSON object.  The object passed back in the callback function
+     * will be a JSON object with a content and fileName property where the content holds
+     * the flow export contents and the fileName property holds the file name where the
+     * export would be written if {@link ArchBaseFlow#exportToDirAsync} is called.
+     * @param callbackFunction - the function to call back with the export information contained
+     *                                                  in the parameter passed to it.
+     * @param [flowFormat = archEnums.FLOW_FORMAT_TYPES.architect] - the desired export format to use on an export. See {@link ArchEnums#FLOW_FORMAT_TYPES} for allowable export formats. If no format is used,
+     *                                                                      it will default to the Architect format.
+     */
+    exportToObjectAsync(callbackFunction: callbackExportObject, flowFormat?: string): Promise<ExportInfoType>;
+    /**
+     * The type of the flow.  The string
+     * values in {@link ArchEnums#FLOW_TYPES} lists valid flow type values.
+     */
+    readonly flowType: string;
+    /**
+     * This function will return the file path where a flow export will be written when calling the {@link ArchBaseFlow#exportToDirAsync}
+     * method for the supplied destination directory and export flow format.  A typical use case for this function would be
+     * to get the export file path prior to calling the {@link ArchBaseFlow#exportToDirAsync} so you could see if the file already exists
+     * and decide if you want to perform an export or not since {@link ArchBaseFlow#exportToDirAsync} will attempt to overwrite
+     * a file if it already exists. Note that this uses the file system and should not be used when running in a
+     * browser.
+     * @param [destinationDir] - the directory where the flow export should be written. If no directory path is given, this method uses the
+     *                                    current working directory.  If a relative path is supplied, it will be resolved relative to the current
+     *                                    working directory.
+     * @param [flowFormat = ArchEnums.FLOW_FORMAT_TYPES.architect] - the desired flow format to use for the export. See {@link ArchEnums#FLOW_FORMAT_TYPES} for allowable export
+     *                                                                      formats. If no format is supplied, it will use the Architect format.
+     * @param [fileName] - the file name to use for the exported flow. If a file extension is not added to the file name, it will use the default file extension for the desired export type for
+     * the desired export format and flow that you are exporting. If the format is YAML, the extension is always '.yaml' regardless of flow type. However, if it is the Architect format, the extension is unique per flow-type.
+     * To find the correct file extension for the Architect format, you can either export a flow from the Architect UI or look at the [flow definition]{@link ArchBaseFlow#definition}
+     * for a flow type and access the [fileExtension]{@link ArchDefinitionFlow#fileExtension} property to get the value. If an extension is found on the file name other than what is
+     * expected, the correct extension will be appended to the end of the exported file as per the logic described previously.
+     */
+    getExportFilePath(destinationDir?: string, flowFormat?: string, fileName?: string): string;
+    /**
+     * Returns the flow scoped variable for the supplied variable identifier ( if it exists ).
+     * If the variable name cannot be found, nothing is returned.
+     * @param variableId - the supllied variable identifier to look up such as __CALL_ANI__.
+     */
+    getVariableById<T extends ArchBaseVariable = ArchBaseVariable>(variableId: string): T;
+    /**
+     * Returns the flow scoped variable for the supplied fully scoped variable name ( if it exists ).  Remember, looking
+     * up variables by name is case insensitive.  If the variable name cannot be found, nothing is returned.
+     * @param variableName - the fully scoped variable name to look up such as Flow.MyVar.
+     */
+    getVariableByName<T extends ArchBaseVariable = ArchBaseVariable>(variableName: string): T;
+    /**
+     * Imports the flow content from the supplied content string.  This content string should be for a flow of the
+     * same type as the one you're importing in to.  Upon successful import, the callback function passed in
+     * will be called.  Importing flow contents in to a flow is something where you should *not* attempt to
+     * do work with the flow on which this is being called until the callback is called.
+     * @param exportContent - the contents from a flow export.
+     * @param [callbackFunction] - a function to call if the export content successfully loaded and configured
+     *                                                    on this flow.  The first parameter passed to the callback function will be this
+     *                                                    Architect flow instance.
+     */
+    importFromContentAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportContent: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
+    /**
+     * Imports the flow content from the supplied file path.  Upon successful import, the callback function passed in
+     * will be called.  Importing flow contents in to a flow is something where you should *not* attempt to
+     * do work with the flow on which this is being called until the callback is called.
+     * Also note that this method should not be used if running in a browser.
+     * @param exportFilePath - the file path to an Architect flow export file that should be imported.
+     * @param [callbackFunction] - a function to call if the export content successfully loaded and configured
+     *                                        on this flow.  The first parameter passed to the callback function will be this
+     *                                        Architect flow instance.
+     */
+    importFromFileAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportFilePath: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
+    /**
+     * Returns whether or not the flow is created in Genesys Cloud.
+     */
+    readonly isCreated: boolean;
+    /**
+     * Returns whether or not the flow is read-only.  Flows that have been created locally in
+     * scripting but not saved, checked in or published will report that they are not read-only.
+     */
+    readonly isReadOnly: boolean;
+    /**
+     * Returns whether or not the flow is secure.  That means it contains something that is
+     * secure like a secure variable or secure action.
+     */
+    readonly isSecure: boolean;
+    /**
+     * Returns true indicating the flow acts as a variable container which means you can
+     * add variables to it.
+     */
+    readonly isVariableContainer: boolean;
+    /**
+     * The language settings for the flow.  This property is now deprecated.
+     * Please replace calls to this property with {@link ArchBaseFlow#settingsSupportedLanguages} instead.
+     */
+    readonly languageSettings: ArchSettingsSupportedLanguagesFlow;
+    /**
+     * The name of the flow
+     */
+    name: string;
+    /**
+     * Publishes the flow. This will do a validate, save, checkin and then publish last. Any of these
+     * steps can fail and reject the promise. Operations are not atomic.
+     * @param [ensureSearchable] - whether or not to poll after successful publish to ensure that the flow is available for flow
+     *                                       search operations such as {@link ArchFactoryFlows#getFlowInfoByFlowNameAsync} or {@link ArchFactoryFlows#getFlowInfoByFlowIdAsync}
+     * @returns - On your promise's then handler, the first parameter passed to the then function will be this
+     * flow instance.
+     */
+    publishAsync(ensureSearchable?: boolean): Promise<any>;
+    /**
+     * Save the current flow configuration, creating the flow if needed.
+     * @returns - On your promise's then handler, the first parameter passed to the then function will be this
+     * flow instance.
+     */
+    saveAsync(): Promise<any>;
+    /**
+     * Returns the error handling settings for the flow.
+     */
+    readonly settingsErrorHandling: ArchSettingsEventErrorFlow;
+    /**
+     * Returns the action default settings for the flow.
+     */
+    readonly settingsActionDefaults: ArchSettingsActionDefaults;
+    /**
+     * The supported language settings for the flow.
+     * This method will throw if the flow doesn't support languages.  You can check {@link ArchBaseFlow#supportsLanguages} prior
+     * to calling this method to see if a flow supports languages or not.
+     */
+    readonly settingsSupportedLanguages: ArchSettingsSupportedLanguagesFlow;
+    /**
+     * Returns whether or not this flow supports audio channel.
+     */
+    readonly supportsAudio: boolean;
+    /**
+     * Returns whether or not this flow supports error handling.
+     */
+    readonly supportsErrorHandling: boolean;
+    /**
+     * Returns whether or not this flow supports languages.  If false, that means you have to configure the flow
+     * when creating it to use English United States.
+     * Note:  At this time this functionality is available while we're determining the needs of workflow and
+     * inbound email flow types.  This property may go away in a future release of Architect Scripting.
+     */
+    readonly supportsLanguages: boolean;
+    /**
+     * Returns whether or not this flow supports setting a supported language as the default.
+     */
+    readonly supportsDefaultLanguage: boolean;
+    /**
+     * Returns a URL for this flow.  If the flow has not been created or there is no startup object set on the flow,
+     * the returned URL will be blank.
+     */
+    readonly url: string;
+    /**
+     * Validates the flow. Promise returns an {@link ArchValidationResults} instance.
+     * @returns - On your promise's then handler, the first parameter passed to the then function will be the
+     * validation results.
+     */
+    validateAsync(): Promise<ArchValidationResults>;
+    /**
+     * Returns an array of variables defined at the flow scope for this flow.
+     */
+    readonly variables: ArchBaseVariable[];
+    /**
+     * The identifier string for this object.
+     */
+    readonly id: string;
+    /**
+     * Returns whether or not the id property may be blank or undefined for this object.  For example, the returned settings from {@link ArchMenu#settingsMenu}
+     * will have a blank identifier along with the settings returned from {@link ArchMenu#settingsSpeechRec}.  Note that this is
+     * an extremely rare case.
+     */
+    readonly idMayBeBlank: string;
+    /**
+     * Returns true indicating that this is an ArchBaseCoreObject instance.
+     */
+    readonly isArchBaseCoreObject: boolean;
+    /**
+     * This method iterates over this object and ArchBaseCoreObject instances
+     * within it.  For each object it will call the {@link ArchBaseObject#isFilterMatch} method
+     * with a filter and call the supplied callback function if isMatch returns true.
+     * The callback will be passed an {@link ArchTraverseInfo} with details
+     * about the match such as the match object itself along with current contextual
+     * information such as the object hierarchy for the match object relative to
+     * the object on which this traverse call is being made.
+     *
+     * The traverse [filter]{@link ArchFilterObject} is one which you can create
+     * by calling {@link ArchFactoryFilters#createFilterObject} and then add desired clauses
+     * or clause containers to it.  If not specified, this function will use a
+     * [default filter]{@link ArchFactoryFilters#createFilterTraverseDefault}.
+     *
+     * Here is an example that does a simple flow traversal using the default
+     * filter and logs information about objects in the callback from the
+     * traverse object that's passed back:
+     *
+     * ```
+     * archInboundCallFlow.traverse(function(traverseInfo) {
+     *    archLogging.logNote('  Object     : ' + traverseInfo.matchObject.logStr);
+     *    archLogging.logNote('    Hierarchy: ' + traverseInfo.context.hierarchyStr);
+     * });
+     * ```
+     * This might be enough for most uses and you can check various aspects
+     * about the object in the callback such as "is this an Architect action?" by
+     * seeing if traverseInfo.matchObject.isArchBaseAction is true.  You can specify
+     * a filter for the traversal code to use as well and only have it call your
+     * callback when the object's {@link ArchBaseCoreObject#isFilterMatch} method returns true for
+     * the filter.  Here's an example that creates a filter for callbacks on
+     * [any type of transfer action]{@link ArchBaseActionTransfer}, any
+     * [decision action]{@link ArchActionDecision} or objects whose name
+     * property case insensitively matches the word 'foo'.  While this could all be done
+     * with one property callback clause the example will use multiple clauses for
+     * the sake of simplicity:
+     * ```
+     * const myTraverseFilter = filterFactory.createFilterObject(archEnums.FILTER_CONTAINER_OPERATORS.or);
+     * myTraverseFilter.addClausePropertyValueEquals('isArchBaseActionTransfer', true);
+     * myTraverseFilter.addClausePropertyValueEquals('isArchActionDecision',     true);
+     * myTraverseFilter.addClausePropertyCallback('name', function(propValue, archContainingObject, propName) {
+     *       // We fully spelled out the function signature above but archContainingObject and propName are
+     *       // not needed in this case.  The archContainingObject is the object that contains the
+     *       // property and propName is the property name itself.  We pass in propName because the same
+     *       // function could be used for multiple property callback clauses.
+     *       // Remember to return a boolean true, false or undefined from ths callback.  :)
+     *       return propValue && propValue.toLowerCase() === 'foo';
+     * });
+     * archTask.traverse(function(traverseContext) {
+     *    // You will only be called back here for ArchBaseCoreObject instances that
+     *    // have the isArchBaseActionTransfer or isArchActionDecision property values equal to true.
+     * }, myTraverseFilter);
+     * ```
+     * If you supply a filter with no clauses, this tells the traverse method to
+     * call the supplied callback function for every {@link ArchBaseCoreObject} it traverses.
+     *
+     * If you want traversal itself to stop after a callback, simply return boolean
+     * false from the callback function you supply to the traverse call.
+     *
+     * The traverse method does not process deprecated property names such as [orgId]{@link ArchSession#orgId},
+     * [orgName]{@link ArchSession#orgName} or [languageSettings]{@link ArchBaseFlow#languageSettings}.  Additionally
+     * it does not traverse in to properties that would "jump out" of the current traversal.  An example of this
+     * would be if the code was traversing an {@link ArchActionJumpToMenu} action that it would not start traversing
+     * in to the menu that it jumps to.  Another example would be a {@link ArchActionChangeState} action where
+     * it would not traverse in to the target state of the action.  This also means traversal does not traverse
+     * in to the {@link ArchBaseValue#flowLevelDefault} property.
+     *
+     * And lastly, as Scripting evolves over time with new versions, you can expect to get callbacks for new object
+     * types such as new actions or new properties on objects.  As such, it's important not to assume any particular
+     * order in callbacks to keep code most compatible with traversal callbacks.  Or if you use inequality checks in filter
+     * clauses remember that new "stuff" may satisfy an inequality check which may or may not be anticipated in your logic.
+     *
+     * Note:  This traverse method is a helper method and is very handy for iterating over Architect Scripting
+     * objects and their properties in a generic fashion with filtering capabilities.  Obviously you can write
+     * your own custom traversal code if this implementation doesn't cut it for some reason. :)
+     *
+     * This function returns the number of times it called the callback function.
+     * @param callbackFunction - the callback function to call for objects that match the traverse filter.
+     * @param [traverseFilter = {@link ArchFactoryFilters#createFilterTraverseDefault}] - the filter to use when performing the traversal to determine which
+     *                                              {@link ArchBaseCoreObject} instances you wish to be called back for.  If no
+     *                                              filter is specified, this function will call {@link ArchFactoryFilters#createFilterTraverseDefault} and
+     *                                              use that traversal default filter.  The wantArchBaseValues parameter on that call is set to true.
+     */
+    traverse(callbackFunction: callbackTraverseInfo, traverseFilter?: ArchFilterObject): number;
+    /**
+     * This is a string suitable for logging information about this object where it's just the object's type.  This is normally used
+     * when logging errors that occur in constructor parameter checking because the scripting object isn't set up and the normal
+     * logging str contents wouldn't be set up.
+     */
+    readonly logStrTypeOnly: string;
+    /**
+     * Logs an error to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logErrors} is true.
+     * @param errorStr - the error string to log.
+     */
+    logError(errorStr: string): void;
+    /**
+     * Logs an error to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logErrors} is true and then throws
+     * the string in the errorStr parameter.
+     * @param errorStr - the error string to log.  This should be a non-blank string.
+     */
+    logErrorAndThrow(errorStr: string): void;
+    /**
+     * Logs a note to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logNotes} is true.
+     * @param noteStr - the note string to log.  This should be a non-blank string.
+     */
+    logNote(noteStr: string): void;
+    /**
+     * Logs a note to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logNotesVerbose} is true.
+     * @param noteStr - the note string to log.  This should be a non-blank string.
+     */
+    logNoteVerbose(noteStr: string): void;
+    /**
+     * Logs a warning to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logWarnings} is true.
+     * @param warningStr - the warning string to log.  This should be a non-blank string.
+     */
+    logWarning(warningStr: string): void;
+    /**
+     * Returns whether or not this Architect Scripting object is a match
+     * for the supplied ArchFilterObject instance.
+     * @param archFilterObject - the object filter to use to determine if it's a match.
+     */
+    isFilterMatch(archFilterObject: ArchFilterObject): boolean;
+}
+
+export class ArchBaseFlowInboundOutboundSecureCall extends ArchBaseFlowWithMenus {
+    // constructor(coreInboundOutboundSecureFlowViewModel: any);
+    /**
+     * Returns the display type name string 'ArchBaseFlowInboundOutboundSecureCall'.
+     */
+    readonly displayTypeName: string;
+    /**
+     * The initial audio set on the flow.
+     */
+    readonly initialAudio: ArchAudio;
+    /**
+     * Returns true indicating that this is an ArchBaseFlowInboundOutboundSecureCall object.
+     */
+    readonly isArchBaseFlowInboundOutboundSecureCall: boolean;
+    /**
+     * Sets the specified menu to be the starting task on the flow.
+     * @param archMenu - An Architect Scripting menu object.
+     */
+    setStartingMenu(archMenu: ArchMenu): void;
+    /**
+     * Sets the specified task to be the starting task on the flow.
+     * @param archTask - An Architect Scripting task object.
+     */
+    setStartingTask(archTask: ArchTask): void;
+    /**
+     * The menu settings for the flow.
+     */
+    readonly settingsMenu: ArchSettingsMenuFlow;
+    /**
+     * The prompt settings for the flow.
+     */
+    readonly settingsPrompts: ArchSettingsPromptsFlow;
+    /**
+     * The speech rec settings for the flow.
+     */
+    readonly settingsSpeechRec: ArchSettingsSpeechRecFlow;
+    /**
+     * Returns the starting task or menu for this call flow.
+     * If there is no startup object configured, accessing this property returns null.
+     */
+    readonly startUpObject: ArchTask | ArchMenu | null;
+    /**
+     * The outbound settings for the flow such as contact list and default wrapup code.
+     */
+    readonly settingsOutboundCall: ArchSettingsOutboundCallFlow;
+    /**
+     * This function deletes the specified reusable menu from this flow.
+     * @param menuToDelete - the menu to delete.  This must be a reusable menu which means the {@link ArchMenu#isReusableMenu}
+     * property on the specified menu instance is true.
+     */
+    deleteMenu(menuToDelete: ArchMenu): void;
+    /**
+     * Returns an array of the currently defined reusable menus for this flow.
+     */
+    readonly menusReusable: ArchBaseMenu[];
+    /**
+     * This function deletes the specified reusable task from this flow.
+     * @param taskToDelete - the task to delete.  This must be a reusable task which means the {@link ArchTask#isReusableTask}
+     * property on the specified task instance is true.
+     */
+    deleteTask(taskToDelete: ArchTask): void;
+    /**
+     * Returns an array of the currently defined reusable tasks for this flow.
+     */
+    readonly tasksReusable: ArchTask[];
+    /**
+     * This adds a new variable to the flow.
+     * @param name - the name of the variable to add.  Remember that variable names must
+     *                        start with a letter and can then be followed by one or more letters, numbers
+     *                        or underscore characters to be valid.  Submitting the variable scope on the name
+     *                        is optional.  If specified, it must be 'Flow.' in order to be valid since you're
+     *                        adding the variable to a flow. You can also specify 'Slot.' to add a slot variable
+     *                         to the flow as long as the forceSlotVariableCreation parameter is true.
+     * @param type - the data type for the new variable.  Remember that type must be supported
+     *                              in the flow type for which you're looking to add the variable.  If you are
+     *                              not sure if a type is creatable, see the {@link ArchDataType#isScriptCreatableForFlowType} or
+     *                              {@link ArchDataType#isScriptCreatableForFlow} method.
+     * @param [description] - the description for the new variable.
+     * @param [forceSlotVariableCreation] - if true, will force the creation of a slot variable even when a Slot is not created in the Natural Language Understanding (NLU).
+     */
+    addVariable(name: string, type: ArchDataType, description?: string, forceSlotVariableCreation?: boolean): ArchBaseVariable;
+    /**
+     * This deletes the supplied variable from the flow.  Remember you can call {@link ArchBaseVariable#canDelete}
+     * prior to calling this method to know if the supplied flow scoped variable can be deleted.
+     * @param archVariable - the flow scoped variable you wish to delete
+     * @returns - true if the variable was removed successfully, false otherwise.
+     */
+    removeVariable(archVariable: ArchBaseVariable): boolean;
+    /**
+     * Checkout this flow. This function returns an ArchInfo instance for it to the supplied callback function.
+     * @param [forceUnlock] - if true, will force an unlock of the flow.
+     * @param [callbackFunction] - a callback function to call if the flow was checked out.
+     * @returns - while this method returns a promise, you should use the callback function to perform any processing once the flow is checked out.
+     */
+    checkoutAsync(forceUnlock?: boolean, callbackFunction?: callbackVoid): Promise<ArchFlowInfo>;
+    /**
+     * Returns the division associated with this flow.
+     * This method first calls {@link ArchOrganizationInfo#areDivisionsAvailable} to ensure that divisions are available.
+     * If not available, nothing is returned.
+     */
+    readonly division: ArchDivision;
+    /**
+     * Loads a specific version of the flow.  Any previously returned Architect Scripting objects associated with this flow should no
+     * longer be considered valid after loading new configuration.
+     * @param [flowVersion = "latest"] - the version of the flow to get.  Valid values are "latest" to get the latest saved configuration of a flow,
+     * a version value such as "2.0" or "2", "debug" to get the currently published debug version configuration of a flow,
+     * or "published" to get the currently published version configuration of a flow.  If you do not specify a version, then the latest saved configuration will be loaded.
+     * @param [callbackFunction] - a callback function to call if the flow was loaded.
+     * @returns - while this method returns a promise, you should use the callback function to perform any processing when the flow is loaded.
+     */
+    loadAsync(flowVersion?: string, callbackFunction?: callbackVoid): Promise<any>;
+    /**
+     * Returns a string suitable for logging that describes the flow
+     */
+    readonly logStr: string;
+    /**
+     * Unlocks this flow.
+     * @param [callbackFunction] - a callback function to call if the flow can be unlocked.
+     * @returns - while this method returns a promise, you should use the callback function to perform any processing once this flow is unlocked.
+     */
+    unlockAsync(callbackFunction?: callbackVoid): Promise<any>;
+    /**
+     * Helper method that accesses the flow's [settingsSupportedLanguages]{@link ArchBaseFlow#settingsSupportedLanguages} and then calls
+     * the [addSupportedLanguage]{@link ArchSettingsSupportedLanguagesFlow#addSupportedLanguage} function on the returned {@link ArchSettingsSupportedLanguagesFlow}
+     * value.
+     * @param archLanguage - the language to add to supported languages on the flow.  Note that any language used as a supported
+     * language must have at least one region sub-tag.
+     * @param [setAsDefaultLanguage] - if true, the language will be set as the default language on the flow.
+     */
+    addFlowSupportedLanguage(archLanguage: ArchLanguage, setAsDefaultLanguage?: boolean): ArchSettingsSupportedLanguage;
+    /**
+     * Checks flow to see if a language can be added in its current state. Some flows may have restrictions
+     * if any or more than one can be added.
+     */
+    canAddSupportedLanguage(): boolean;
+    /**
+     * Checks in and unlocks the flow for the current user, does a save first
+     * Assumes the flow has been created, throws if not
+     * @param [ensureSearchable] - whether or not to poll after successful checkin to ensure that the flow is available for flow
+     *                                       search operations such as {@link ArchFactoryFlows#getFlowInfoByFlowNameAsync} or {@link ArchFactoryFlows#getFlowInfoByFlowIdAsync}
+     * @returns - On your promise's then handler, the first parameter passed to the then function will be this
+     * flow instance.
+     */
+    checkInAsync(ensureSearchable?: boolean): Promise<ArchBaseFlow | undefined>;
+    /**
+     * Creates a new flow on the server and saves its configuration
+     * @returns - On your promise's then handler, the first parameter passed to the then function will be this
+     * flow instance.
+     */
+    createAsync(): Promise<any>;
+    /**
+     * Accessing this property returns an object with properties whose keys are data type names and values are
+     * {@link ArchDataType} instances.
+     */
+    readonly dataTypes: any;
+    /**
+     * The description of the flow
+     */
+    description: string;
+    /**
+     * Exports the current flow to a file in the specified directory.  This destination directory *must* exist
+     * for the export to succeed.  Note that this uses the file system and should not be used when running in a
+     * browser.
+     * @param [destinationDir] - the directory where the flow export should be saved.
+     * @param [callbackFunction] - the function to call back and pass in the full path where the
+     *                                                      flow export was saved.
+     * @param [flowFormat = ArchEnums.FLOW_FORMAT_TYPES.architect] - the desired flow format to use for the export. See {@link ArchEnums#FLOW_FORMAT_TYPES} for allowable export formats. If no format is used,
+     *                                                                      it will default to the Architect format.
+     * @param [fileName] - the file name to use for the exported flow. If a file extension is not added to the file name, it will use the default file extension for the desired export type for
+     * the desired export format and flow that you are exporting. If the format is YAML, the extension is always '.yaml' regardless of flow type. However, if it is the Architect format, the extension is unique per flow-type.
+     * To find the correct file extension for the Architect format, you can either export a flow from the Architect UI or look at the [flow definition]{@link ArchBaseFlow#definition}
+     * for a flow type and access the [fileExtension]{@link ArchDefinitionFlow#fileExtension} property to get the value. If an extension is found on the file name other than what is
+     * expected, the correct extension will be appended to the end of the exported file as per the logic described previously.
+     */
+    exportToDirAsync(destinationDir?: string, callbackFunction?: callbackExportFullPath, flowFormat?: string, fileName?: string): Promise<string>;
+    /**
+     * Exports the flow to a JSON object.  The object passed back in the callback function
+     * will be a JSON object with a content and fileName property where the content holds
+     * the flow export contents and the fileName property holds the file name where the
+     * export would be written if {@link ArchBaseFlow#exportToDirAsync} is called.
+     * @param callbackFunction - the function to call back with the export information contained
+     *                                                  in the parameter passed to it.
+     * @param [flowFormat = archEnums.FLOW_FORMAT_TYPES.architect] - the desired export format to use on an export. See {@link ArchEnums#FLOW_FORMAT_TYPES} for allowable export formats. If no format is used,
+     *                                                                      it will default to the Architect format.
+     */
+    exportToObjectAsync(callbackFunction: callbackExportObject, flowFormat?: string): Promise<ExportInfoType>;
+    /**
+     * The type of the flow.  The string
+     * values in {@link ArchEnums#FLOW_TYPES} lists valid flow type values.
+     */
+    readonly flowType: string;
+    /**
+     * This function will return the file path where a flow export will be written when calling the {@link ArchBaseFlow#exportToDirAsync}
+     * method for the supplied destination directory and export flow format.  A typical use case for this function would be
+     * to get the export file path prior to calling the {@link ArchBaseFlow#exportToDirAsync} so you could see if the file already exists
+     * and decide if you want to perform an export or not since {@link ArchBaseFlow#exportToDirAsync} will attempt to overwrite
+     * a file if it already exists. Note that this uses the file system and should not be used when running in a
+     * browser.
+     * @param [destinationDir] - the directory where the flow export should be written. If no directory path is given, this method uses the
+     *                                    current working directory.  If a relative path is supplied, it will be resolved relative to the current
+     *                                    working directory.
+     * @param [flowFormat = ArchEnums.FLOW_FORMAT_TYPES.architect] - the desired flow format to use for the export. See {@link ArchEnums#FLOW_FORMAT_TYPES} for allowable export
+     *                                                                      formats. If no format is supplied, it will use the Architect format.
+     * @param [fileName] - the file name to use for the exported flow. If a file extension is not added to the file name, it will use the default file extension for the desired export type for
+     * the desired export format and flow that you are exporting. If the format is YAML, the extension is always '.yaml' regardless of flow type. However, if it is the Architect format, the extension is unique per flow-type.
+     * To find the correct file extension for the Architect format, you can either export a flow from the Architect UI or look at the [flow definition]{@link ArchBaseFlow#definition}
+     * for a flow type and access the [fileExtension]{@link ArchDefinitionFlow#fileExtension} property to get the value. If an extension is found on the file name other than what is
+     * expected, the correct extension will be appended to the end of the exported file as per the logic described previously.
+     */
+    getExportFilePath(destinationDir?: string, flowFormat?: string, fileName?: string): string;
+    /**
+     * Returns the flow scoped variable for the supplied variable identifier ( if it exists ).
+     * If the variable name cannot be found, nothing is returned.
+     * @param variableId - the supllied variable identifier to look up such as __CALL_ANI__.
+     */
+    getVariableById<T extends ArchBaseVariable = ArchBaseVariable>(variableId: string): T;
+    /**
+     * Returns the flow scoped variable for the supplied fully scoped variable name ( if it exists ).  Remember, looking
+     * up variables by name is case insensitive.  If the variable name cannot be found, nothing is returned.
+     * @param variableName - the fully scoped variable name to look up such as Flow.MyVar.
+     */
+    getVariableByName<T extends ArchBaseVariable = ArchBaseVariable>(variableName: string): T;
+    /**
+     * Imports the flow content from the supplied content string.  This content string should be for a flow of the
+     * same type as the one you're importing in to.  Upon successful import, the callback function passed in
+     * will be called.  Importing flow contents in to a flow is something where you should *not* attempt to
+     * do work with the flow on which this is being called until the callback is called.
+     * @param exportContent - the contents from a flow export.
+     * @param [callbackFunction] - a function to call if the export content successfully loaded and configured
+     *                                                    on this flow.  The first parameter passed to the callback function will be this
+     *                                                    Architect flow instance.
+     */
+    importFromContentAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportContent: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
+    /**
+     * Imports the flow content from the supplied file path.  Upon successful import, the callback function passed in
+     * will be called.  Importing flow contents in to a flow is something where you should *not* attempt to
+     * do work with the flow on which this is being called until the callback is called.
+     * Also note that this method should not be used if running in a browser.
+     * @param exportFilePath - the file path to an Architect flow export file that should be imported.
+     * @param [callbackFunction] - a function to call if the export content successfully loaded and configured
+     *                                        on this flow.  The first parameter passed to the callback function will be this
+     *                                        Architect flow instance.
+     */
+    importFromFileAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportFilePath: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
+    /**
+     * Returns whether or not the flow is created in Genesys Cloud.
+     */
+    readonly isCreated: boolean;
+    /**
+     * Returns whether or not the flow is read-only.  Flows that have been created locally in
+     * scripting but not saved, checked in or published will report that they are not read-only.
+     */
+    readonly isReadOnly: boolean;
+    /**
+     * Returns whether or not the flow is secure.  That means it contains something that is
+     * secure like a secure variable or secure action.
+     */
+    readonly isSecure: boolean;
+    /**
+     * Returns true indicating the flow acts as a variable container which means you can
+     * add variables to it.
+     */
+    readonly isVariableContainer: boolean;
+    /**
+     * The language settings for the flow.  This property is now deprecated.
+     * Please replace calls to this property with {@link ArchBaseFlow#settingsSupportedLanguages} instead.
+     */
+    readonly languageSettings: ArchSettingsSupportedLanguagesFlow;
+    /**
+     * The name of the flow
+     */
+    name: string;
+    /**
+     * Publishes the flow. This will do a validate, save, checkin and then publish last. Any of these
+     * steps can fail and reject the promise. Operations are not atomic.
+     * @param [ensureSearchable] - whether or not to poll after successful publish to ensure that the flow is available for flow
+     *                                       search operations such as {@link ArchFactoryFlows#getFlowInfoByFlowNameAsync} or {@link ArchFactoryFlows#getFlowInfoByFlowIdAsync}
+     * @returns - On your promise's then handler, the first parameter passed to the then function will be this
+     * flow instance.
+     */
+    publishAsync(ensureSearchable?: boolean): Promise<any>;
+    /**
+     * Save the current flow configuration, creating the flow if needed.
+     * @returns - On your promise's then handler, the first parameter passed to the then function will be this
+     * flow instance.
+     */
+    saveAsync(): Promise<any>;
+    /**
+     * Returns the error handling settings for the flow.
+     */
+    readonly settingsErrorHandling: ArchSettingsEventErrorFlow;
+    /**
+     * Returns the action default settings for the flow.
+     */
+    readonly settingsActionDefaults: ArchSettingsActionDefaults;
+    /**
+     * The supported language settings for the flow.
+     * This method will throw if the flow doesn't support languages.  You can check {@link ArchBaseFlow#supportsLanguages} prior
+     * to calling this method to see if a flow supports languages or not.
+     */
+    readonly settingsSupportedLanguages: ArchSettingsSupportedLanguagesFlow;
+    /**
+     * Returns whether or not this flow supports audio channel.
+     */
+    readonly supportsAudio: boolean;
+    /**
+     * Returns whether or not this flow supports error handling.
+     */
+    readonly supportsErrorHandling: boolean;
+    /**
+     * Returns whether or not this flow supports languages.  If false, that means you have to configure the flow
+     * when creating it to use English United States.
+     * Note:  At this time this functionality is available while we're determining the needs of workflow and
+     * inbound email flow types.  This property may go away in a future release of Architect Scripting.
+     */
+    readonly supportsLanguages: boolean;
+    /**
+     * Returns whether or not this flow supports setting a supported language as the default.
+     */
+    readonly supportsDefaultLanguage: boolean;
+    /**
+     * Returns a URL for this flow.  If the flow has not been created or there is no startup object set on the flow,
+     * the returned URL will be blank.
+     */
+    readonly url: string;
+    /**
+     * Validates the flow. Promise returns an {@link ArchValidationResults} instance.
+     * @returns - On your promise's then handler, the first parameter passed to the then function will be the
+     * validation results.
+     */
+    validateAsync(): Promise<ArchValidationResults>;
+    /**
+     * Returns an array of variables defined at the flow scope for this flow.
+     */
+    readonly variables: ArchBaseVariable[];
+    /**
+     * The identifier string for this object.
+     */
+    readonly id: string;
+    /**
+     * Returns whether or not the id property may be blank or undefined for this object.  For example, the returned settings from {@link ArchMenu#settingsMenu}
+     * will have a blank identifier along with the settings returned from {@link ArchMenu#settingsSpeechRec}.  Note that this is
+     * an extremely rare case.
+     */
+    readonly idMayBeBlank: string;
+    /**
+     * Returns true indicating that this is an ArchBaseCoreObject instance.
+     */
+    readonly isArchBaseCoreObject: boolean;
+    /**
+     * This method iterates over this object and ArchBaseCoreObject instances
+     * within it.  For each object it will call the {@link ArchBaseObject#isFilterMatch} method
+     * with a filter and call the supplied callback function if isMatch returns true.
+     * The callback will be passed an {@link ArchTraverseInfo} with details
+     * about the match such as the match object itself along with current contextual
+     * information such as the object hierarchy for the match object relative to
+     * the object on which this traverse call is being made.
+     *
+     * The traverse [filter]{@link ArchFilterObject} is one which you can create
+     * by calling {@link ArchFactoryFilters#createFilterObject} and then add desired clauses
+     * or clause containers to it.  If not specified, this function will use a
+     * [default filter]{@link ArchFactoryFilters#createFilterTraverseDefault}.
+     *
+     * Here is an example that does a simple flow traversal using the default
+     * filter and logs information about objects in the callback from the
+     * traverse object that's passed back:
+     *
+     * ```
+     * archInboundCallFlow.traverse(function(traverseInfo) {
+     *    archLogging.logNote('  Object     : ' + traverseInfo.matchObject.logStr);
+     *    archLogging.logNote('    Hierarchy: ' + traverseInfo.context.hierarchyStr);
+     * });
+     * ```
+     * This might be enough for most uses and you can check various aspects
+     * about the object in the callback such as "is this an Architect action?" by
+     * seeing if traverseInfo.matchObject.isArchBaseAction is true.  You can specify
+     * a filter for the traversal code to use as well and only have it call your
+     * callback when the object's {@link ArchBaseCoreObject#isFilterMatch} method returns true for
+     * the filter.  Here's an example that creates a filter for callbacks on
+     * [any type of transfer action]{@link ArchBaseActionTransfer}, any
+     * [decision action]{@link ArchActionDecision} or objects whose name
+     * property case insensitively matches the word 'foo'.  While this could all be done
+     * with one property callback clause the example will use multiple clauses for
+     * the sake of simplicity:
+     * ```
+     * const myTraverseFilter = filterFactory.createFilterObject(archEnums.FILTER_CONTAINER_OPERATORS.or);
+     * myTraverseFilter.addClausePropertyValueEquals('isArchBaseActionTransfer', true);
+     * myTraverseFilter.addClausePropertyValueEquals('isArchActionDecision',     true);
+     * myTraverseFilter.addClausePropertyCallback('name', function(propValue, archContainingObject, propName) {
+     *       // We fully spelled out the function signature above but archContainingObject and propName are
+     *       // not needed in this case.  The archContainingObject is the object that contains the
+     *       // property and propName is the property name itself.  We pass in propName because the same
+     *       // function could be used for multiple property callback clauses.
+     *       // Remember to return a boolean true, false or undefined from ths callback.  :)
+     *       return propValue && propValue.toLowerCase() === 'foo';
+     * });
+     * archTask.traverse(function(traverseContext) {
+     *    // You will only be called back here for ArchBaseCoreObject instances that
+     *    // have the isArchBaseActionTransfer or isArchActionDecision property values equal to true.
+     * }, myTraverseFilter);
+     * ```
+     * If you supply a filter with no clauses, this tells the traverse method to
+     * call the supplied callback function for every {@link ArchBaseCoreObject} it traverses.
+     *
+     * If you want traversal itself to stop after a callback, simply return boolean
+     * false from the callback function you supply to the traverse call.
+     *
+     * The traverse method does not process deprecated property names such as [orgId]{@link ArchSession#orgId},
+     * [orgName]{@link ArchSession#orgName} or [languageSettings]{@link ArchBaseFlow#languageSettings}.  Additionally
+     * it does not traverse in to properties that would "jump out" of the current traversal.  An example of this
+     * would be if the code was traversing an {@link ArchActionJumpToMenu} action that it would not start traversing
+     * in to the menu that it jumps to.  Another example would be a {@link ArchActionChangeState} action where
+     * it would not traverse in to the target state of the action.  This also means traversal does not traverse
+     * in to the {@link ArchBaseValue#flowLevelDefault} property.
+     *
+     * And lastly, as Scripting evolves over time with new versions, you can expect to get callbacks for new object
+     * types such as new actions or new properties on objects.  As such, it's important not to assume any particular
+     * order in callbacks to keep code most compatible with traversal callbacks.  Or if you use inequality checks in filter
+     * clauses remember that new "stuff" may satisfy an inequality check which may or may not be anticipated in your logic.
+     *
+     * Note:  This traverse method is a helper method and is very handy for iterating over Architect Scripting
+     * objects and their properties in a generic fashion with filtering capabilities.  Obviously you can write
+     * your own custom traversal code if this implementation doesn't cut it for some reason. :)
+     *
+     * This function returns the number of times it called the callback function.
+     * @param callbackFunction - the callback function to call for objects that match the traverse filter.
+     * @param [traverseFilter = {@link ArchFactoryFilters#createFilterTraverseDefault}] - the filter to use when performing the traversal to determine which
+     *                                              {@link ArchBaseCoreObject} instances you wish to be called back for.  If no
+     *                                              filter is specified, this function will call {@link ArchFactoryFilters#createFilterTraverseDefault} and
+     *                                              use that traversal default filter.  The wantArchBaseValues parameter on that call is set to true.
+     */
+    traverse(callbackFunction: callbackTraverseInfo, traverseFilter?: ArchFilterObject): number;
+    /**
+     * This is a string suitable for logging information about this object where it's just the object's type.  This is normally used
+     * when logging errors that occur in constructor parameter checking because the scripting object isn't set up and the normal
+     * logging str contents wouldn't be set up.
+     */
+    readonly logStrTypeOnly: string;
+    /**
+     * Logs an error to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logErrors} is true.
+     * @param errorStr - the error string to log.
+     */
+    logError(errorStr: string): void;
+    /**
+     * Logs an error to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logErrors} is true and then throws
+     * the string in the errorStr parameter.
+     * @param errorStr - the error string to log.  This should be a non-blank string.
+     */
+    logErrorAndThrow(errorStr: string): void;
+    /**
+     * Logs a note to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logNotes} is true.
+     * @param noteStr - the note string to log.  This should be a non-blank string.
+     */
+    logNote(noteStr: string): void;
+    /**
+     * Logs a note to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logNotesVerbose} is true.
+     * @param noteStr - the note string to log.  This should be a non-blank string.
+     */
+    logNoteVerbose(noteStr: string): void;
+    /**
+     * Logs a warning to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logWarnings} is true.
+     * @param warningStr - the warning string to log.  This should be a non-blank string.
+     */
+    logWarning(warningStr: string): void;
+    /**
+     * Returns whether or not this Architect Scripting object is a match
+     * for the supplied ArchFilterObject instance.
+     * @param archFilterObject - the object filter to use to determine if it's a match.
+     */
+    isFilterMatch(archFilterObject: ArchFilterObject): boolean;
+}
+
+export class ArchBaseFlowWithMenus extends ArchBaseFlowWithTasks {
+    // constructor(coreFlowViewModel: any);
+    /**
+     * This function deletes the specified reusable menu from this flow.
+     * @param menuToDelete - the menu to delete.  This must be a reusable menu which means the {@link ArchMenu#isReusableMenu}
+     * property on the specified menu instance is true.
+     */
+    deleteMenu(menuToDelete: ArchMenu): void;
+    /**
+     * Returns an array of the currently defined reusable menus for this flow.
+     */
+    readonly menusReusable: ArchBaseMenu[];
+    /**
+     * This function deletes the specified reusable task from this flow.
+     * @param taskToDelete - the task to delete.  This must be a reusable task which means the {@link ArchTask#isReusableTask}
+     * property on the specified task instance is true.
+     */
+    deleteTask(taskToDelete: ArchTask): void;
+    /**
+     * Returns an array of the currently defined reusable tasks for this flow.
+     */
+    readonly tasksReusable: ArchTask[];
+    /**
+     * This adds a new variable to the flow.
+     * @param name - the name of the variable to add.  Remember that variable names must
+     *                        start with a letter and can then be followed by one or more letters, numbers
+     *                        or underscore characters to be valid.  Submitting the variable scope on the name
+     *                        is optional.  If specified, it must be 'Flow.' in order to be valid since you're
+     *                        adding the variable to a flow. You can also specify 'Slot.' to add a slot variable
+     *                         to the flow as long as the forceSlotVariableCreation parameter is true.
+     * @param type - the data type for the new variable.  Remember that type must be supported
+     *                              in the flow type for which you're looking to add the variable.  If you are
+     *                              not sure if a type is creatable, see the {@link ArchDataType#isScriptCreatableForFlowType} or
+     *                              {@link ArchDataType#isScriptCreatableForFlow} method.
+     * @param [description] - the description for the new variable.
+     * @param [forceSlotVariableCreation] - if true, will force the creation of a slot variable even when a Slot is not created in the Natural Language Understanding (NLU).
+     */
+    addVariable(name: string, type: ArchDataType, description?: string, forceSlotVariableCreation?: boolean): ArchBaseVariable;
+    /**
+     * This deletes the supplied variable from the flow.  Remember you can call {@link ArchBaseVariable#canDelete}
+     * prior to calling this method to know if the supplied flow scoped variable can be deleted.
+     * @param archVariable - the flow scoped variable you wish to delete
+     * @returns - true if the variable was removed successfully, false otherwise.
+     */
+    removeVariable(archVariable: ArchBaseVariable): boolean;
+    /**
+     * Checkout this flow. This function returns an ArchInfo instance for it to the supplied callback function.
+     * @param [forceUnlock] - if true, will force an unlock of the flow.
+     * @param [callbackFunction] - a callback function to call if the flow was checked out.
+     * @returns - while this method returns a promise, you should use the callback function to perform any processing once the flow is checked out.
+     */
+    checkoutAsync(forceUnlock?: boolean, callbackFunction?: callbackVoid): Promise<ArchFlowInfo>;
+    /**
+     * Returns the division associated with this flow.
+     * This method first calls {@link ArchOrganizationInfo#areDivisionsAvailable} to ensure that divisions are available.
+     * If not available, nothing is returned.
+     */
+    readonly division: ArchDivision;
+    /**
+     * Loads a specific version of the flow.  Any previously returned Architect Scripting objects associated with this flow should no
+     * longer be considered valid after loading new configuration.
+     * @param [flowVersion = "latest"] - the version of the flow to get.  Valid values are "latest" to get the latest saved configuration of a flow,
+     * a version value such as "2.0" or "2", "debug" to get the currently published debug version configuration of a flow,
+     * or "published" to get the currently published version configuration of a flow.  If you do not specify a version, then the latest saved configuration will be loaded.
+     * @param [callbackFunction] - a callback function to call if the flow was loaded.
+     * @returns - while this method returns a promise, you should use the callback function to perform any processing when the flow is loaded.
+     */
+    loadAsync(flowVersion?: string, callbackFunction?: callbackVoid): Promise<any>;
+    /**
+     * Returns a string suitable for logging that describes the flow
+     */
+    readonly logStr: string;
+    /**
+     * Unlocks this flow.
+     * @param [callbackFunction] - a callback function to call if the flow can be unlocked.
+     * @returns - while this method returns a promise, you should use the callback function to perform any processing once this flow is unlocked.
+     */
+    unlockAsync(callbackFunction?: callbackVoid): Promise<any>;
+    /**
+     * Helper method that accesses the flow's [settingsSupportedLanguages]{@link ArchBaseFlow#settingsSupportedLanguages} and then calls
+     * the [addSupportedLanguage]{@link ArchSettingsSupportedLanguagesFlow#addSupportedLanguage} function on the returned {@link ArchSettingsSupportedLanguagesFlow}
+     * value.
+     * @param archLanguage - the language to add to supported languages on the flow.  Note that any language used as a supported
+     * language must have at least one region sub-tag.
+     * @param [setAsDefaultLanguage] - if true, the language will be set as the default language on the flow.
+     */
+    addFlowSupportedLanguage(archLanguage: ArchLanguage, setAsDefaultLanguage?: boolean): ArchSettingsSupportedLanguage;
+    /**
+     * Checks flow to see if a language can be added in its current state. Some flows may have restrictions
+     * if any or more than one can be added.
+     */
+    canAddSupportedLanguage(): boolean;
+    /**
+     * Checks in and unlocks the flow for the current user, does a save first
+     * Assumes the flow has been created, throws if not
+     * @param [ensureSearchable] - whether or not to poll after successful checkin to ensure that the flow is available for flow
+     *                                       search operations such as {@link ArchFactoryFlows#getFlowInfoByFlowNameAsync} or {@link ArchFactoryFlows#getFlowInfoByFlowIdAsync}
+     * @returns - On your promise's then handler, the first parameter passed to the then function will be this
+     * flow instance.
+     */
+    checkInAsync(ensureSearchable?: boolean): Promise<ArchBaseFlow | undefined>;
+    /**
+     * Creates a new flow on the server and saves its configuration
+     * @returns - On your promise's then handler, the first parameter passed to the then function will be this
+     * flow instance.
+     */
+    createAsync(): Promise<any>;
+    /**
+     * Accessing this property returns an object with properties whose keys are data type names and values are
+     * {@link ArchDataType} instances.
+     */
+    readonly dataTypes: any;
+    /**
+     * The description of the flow
+     */
+    description: string;
+    /**
+     * Exports the current flow to a file in the specified directory.  This destination directory *must* exist
+     * for the export to succeed.  Note that this uses the file system and should not be used when running in a
+     * browser.
+     * @param [destinationDir] - the directory where the flow export should be saved.
+     * @param [callbackFunction] - the function to call back and pass in the full path where the
+     *                                                      flow export was saved.
+     * @param [flowFormat = ArchEnums.FLOW_FORMAT_TYPES.architect] - the desired flow format to use for the export. See {@link ArchEnums#FLOW_FORMAT_TYPES} for allowable export formats. If no format is used,
+     *                                                                      it will default to the Architect format.
+     * @param [fileName] - the file name to use for the exported flow. If a file extension is not added to the file name, it will use the default file extension for the desired export type for
+     * the desired export format and flow that you are exporting. If the format is YAML, the extension is always '.yaml' regardless of flow type. However, if it is the Architect format, the extension is unique per flow-type.
+     * To find the correct file extension for the Architect format, you can either export a flow from the Architect UI or look at the [flow definition]{@link ArchBaseFlow#definition}
+     * for a flow type and access the [fileExtension]{@link ArchDefinitionFlow#fileExtension} property to get the value. If an extension is found on the file name other than what is
+     * expected, the correct extension will be appended to the end of the exported file as per the logic described previously.
+     */
+    exportToDirAsync(destinationDir?: string, callbackFunction?: callbackExportFullPath, flowFormat?: string, fileName?: string): Promise<string>;
+    /**
+     * Exports the flow to a JSON object.  The object passed back in the callback function
+     * will be a JSON object with a content and fileName property where the content holds
+     * the flow export contents and the fileName property holds the file name where the
+     * export would be written if {@link ArchBaseFlow#exportToDirAsync} is called.
+     * @param callbackFunction - the function to call back with the export information contained
+     *                                                  in the parameter passed to it.
+     * @param [flowFormat = archEnums.FLOW_FORMAT_TYPES.architect] - the desired export format to use on an export. See {@link ArchEnums#FLOW_FORMAT_TYPES} for allowable export formats. If no format is used,
+     *                                                                      it will default to the Architect format.
+     */
+    exportToObjectAsync(callbackFunction: callbackExportObject, flowFormat?: string): Promise<ExportInfoType>;
+    /**
+     * The type of the flow.  The string
+     * values in {@link ArchEnums#FLOW_TYPES} lists valid flow type values.
+     */
+    readonly flowType: string;
+    /**
+     * This function will return the file path where a flow export will be written when calling the {@link ArchBaseFlow#exportToDirAsync}
+     * method for the supplied destination directory and export flow format.  A typical use case for this function would be
+     * to get the export file path prior to calling the {@link ArchBaseFlow#exportToDirAsync} so you could see if the file already exists
+     * and decide if you want to perform an export or not since {@link ArchBaseFlow#exportToDirAsync} will attempt to overwrite
+     * a file if it already exists. Note that this uses the file system and should not be used when running in a
+     * browser.
+     * @param [destinationDir] - the directory where the flow export should be written. If no directory path is given, this method uses the
+     *                                    current working directory.  If a relative path is supplied, it will be resolved relative to the current
+     *                                    working directory.
+     * @param [flowFormat = ArchEnums.FLOW_FORMAT_TYPES.architect] - the desired flow format to use for the export. See {@link ArchEnums#FLOW_FORMAT_TYPES} for allowable export
+     *                                                                      formats. If no format is supplied, it will use the Architect format.
+     * @param [fileName] - the file name to use for the exported flow. If a file extension is not added to the file name, it will use the default file extension for the desired export type for
+     * the desired export format and flow that you are exporting. If the format is YAML, the extension is always '.yaml' regardless of flow type. However, if it is the Architect format, the extension is unique per flow-type.
+     * To find the correct file extension for the Architect format, you can either export a flow from the Architect UI or look at the [flow definition]{@link ArchBaseFlow#definition}
+     * for a flow type and access the [fileExtension]{@link ArchDefinitionFlow#fileExtension} property to get the value. If an extension is found on the file name other than what is
+     * expected, the correct extension will be appended to the end of the exported file as per the logic described previously.
+     */
+    getExportFilePath(destinationDir?: string, flowFormat?: string, fileName?: string): string;
+    /**
+     * Returns the flow scoped variable for the supplied variable identifier ( if it exists ).
+     * If the variable name cannot be found, nothing is returned.
+     * @param variableId - the supllied variable identifier to look up such as __CALL_ANI__.
+     */
+    getVariableById<T extends ArchBaseVariable = ArchBaseVariable>(variableId: string): T;
+    /**
+     * Returns the flow scoped variable for the supplied fully scoped variable name ( if it exists ).  Remember, looking
+     * up variables by name is case insensitive.  If the variable name cannot be found, nothing is returned.
+     * @param variableName - the fully scoped variable name to look up such as Flow.MyVar.
+     */
+    getVariableByName<T extends ArchBaseVariable = ArchBaseVariable>(variableName: string): T;
+    /**
+     * Imports the flow content from the supplied content string.  This content string should be for a flow of the
+     * same type as the one you're importing in to.  Upon successful import, the callback function passed in
+     * will be called.  Importing flow contents in to a flow is something where you should *not* attempt to
+     * do work with the flow on which this is being called until the callback is called.
+     * @param exportContent - the contents from a flow export.
+     * @param [callbackFunction] - a function to call if the export content successfully loaded and configured
+     *                                                    on this flow.  The first parameter passed to the callback function will be this
+     *                                                    Architect flow instance.
+     */
+    importFromContentAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportContent: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
+    /**
+     * Imports the flow content from the supplied file path.  Upon successful import, the callback function passed in
+     * will be called.  Importing flow contents in to a flow is something where you should *not* attempt to
+     * do work with the flow on which this is being called until the callback is called.
+     * Also note that this method should not be used if running in a browser.
+     * @param exportFilePath - the file path to an Architect flow export file that should be imported.
+     * @param [callbackFunction] - a function to call if the export content successfully loaded and configured
+     *                                        on this flow.  The first parameter passed to the callback function will be this
+     *                                        Architect flow instance.
+     */
+    importFromFileAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportFilePath: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
+    /**
+     * Returns whether or not the flow is created in Genesys Cloud.
+     */
+    readonly isCreated: boolean;
+    /**
+     * Returns whether or not the flow is read-only.  Flows that have been created locally in
+     * scripting but not saved, checked in or published will report that they are not read-only.
+     */
+    readonly isReadOnly: boolean;
+    /**
+     * Returns whether or not the flow is secure.  That means it contains something that is
+     * secure like a secure variable or secure action.
+     */
+    readonly isSecure: boolean;
+    /**
+     * Returns true indicating the flow acts as a variable container which means you can
+     * add variables to it.
+     */
+    readonly isVariableContainer: boolean;
+    /**
+     * The language settings for the flow.  This property is now deprecated.
+     * Please replace calls to this property with {@link ArchBaseFlow#settingsSupportedLanguages} instead.
+     */
+    readonly languageSettings: ArchSettingsSupportedLanguagesFlow;
+    /**
+     * The name of the flow
+     */
+    name: string;
+    /**
+     * Publishes the flow. This will do a validate, save, checkin and then publish last. Any of these
+     * steps can fail and reject the promise. Operations are not atomic.
+     * @param [ensureSearchable] - whether or not to poll after successful publish to ensure that the flow is available for flow
+     *                                       search operations such as {@link ArchFactoryFlows#getFlowInfoByFlowNameAsync} or {@link ArchFactoryFlows#getFlowInfoByFlowIdAsync}
+     * @returns - On your promise's then handler, the first parameter passed to the then function will be this
+     * flow instance.
+     */
+    publishAsync(ensureSearchable?: boolean): Promise<any>;
+    /**
+     * Save the current flow configuration, creating the flow if needed.
+     * @returns - On your promise's then handler, the first parameter passed to the then function will be this
+     * flow instance.
+     */
+    saveAsync(): Promise<any>;
+    /**
+     * Returns the error handling settings for the flow.
+     */
+    readonly settingsErrorHandling: ArchSettingsEventErrorFlow;
+    /**
+     * Returns the action default settings for the flow.
+     */
+    readonly settingsActionDefaults: ArchSettingsActionDefaults;
+    /**
+     * The supported language settings for the flow.
+     * This method will throw if the flow doesn't support languages.  You can check {@link ArchBaseFlow#supportsLanguages} prior
+     * to calling this method to see if a flow supports languages or not.
+     */
+    readonly settingsSupportedLanguages: ArchSettingsSupportedLanguagesFlow;
+    /**
+     * Returns whether or not this flow supports audio channel.
+     */
+    readonly supportsAudio: boolean;
+    /**
+     * Returns whether or not this flow supports error handling.
+     */
+    readonly supportsErrorHandling: boolean;
+    /**
+     * Returns whether or not this flow supports languages.  If false, that means you have to configure the flow
+     * when creating it to use English United States.
+     * Note:  At this time this functionality is available while we're determining the needs of workflow and
+     * inbound email flow types.  This property may go away in a future release of Architect Scripting.
+     */
+    readonly supportsLanguages: boolean;
+    /**
+     * Returns whether or not this flow supports setting a supported language as the default.
+     */
+    readonly supportsDefaultLanguage: boolean;
+    /**
+     * Returns a URL for this flow.  If the flow has not been created or there is no startup object set on the flow,
+     * the returned URL will be blank.
+     */
+    readonly url: string;
+    /**
+     * Validates the flow. Promise returns an {@link ArchValidationResults} instance.
+     * @returns - On your promise's then handler, the first parameter passed to the then function will be the
+     * validation results.
+     */
+    validateAsync(): Promise<ArchValidationResults>;
+    /**
+     * Returns an array of variables defined at the flow scope for this flow.
+     */
+    readonly variables: ArchBaseVariable[];
+    /**
+     * The identifier string for this object.
+     */
+    readonly id: string;
+    /**
+     * Returns whether or not the id property may be blank or undefined for this object.  For example, the returned settings from {@link ArchMenu#settingsMenu}
+     * will have a blank identifier along with the settings returned from {@link ArchMenu#settingsSpeechRec}.  Note that this is
+     * an extremely rare case.
+     */
+    readonly idMayBeBlank: string;
+    /**
+     * Returns true indicating that this is an ArchBaseCoreObject instance.
+     */
+    readonly isArchBaseCoreObject: boolean;
+    /**
+     * This method iterates over this object and ArchBaseCoreObject instances
+     * within it.  For each object it will call the {@link ArchBaseObject#isFilterMatch} method
+     * with a filter and call the supplied callback function if isMatch returns true.
+     * The callback will be passed an {@link ArchTraverseInfo} with details
+     * about the match such as the match object itself along with current contextual
+     * information such as the object hierarchy for the match object relative to
+     * the object on which this traverse call is being made.
+     *
+     * The traverse [filter]{@link ArchFilterObject} is one which you can create
+     * by calling {@link ArchFactoryFilters#createFilterObject} and then add desired clauses
+     * or clause containers to it.  If not specified, this function will use a
+     * [default filter]{@link ArchFactoryFilters#createFilterTraverseDefault}.
+     *
+     * Here is an example that does a simple flow traversal using the default
+     * filter and logs information about objects in the callback from the
+     * traverse object that's passed back:
+     *
+     * ```
+     * archInboundCallFlow.traverse(function(traverseInfo) {
+     *    archLogging.logNote('  Object     : ' + traverseInfo.matchObject.logStr);
+     *    archLogging.logNote('    Hierarchy: ' + traverseInfo.context.hierarchyStr);
+     * });
+     * ```
+     * This might be enough for most uses and you can check various aspects
+     * about the object in the callback such as "is this an Architect action?" by
+     * seeing if traverseInfo.matchObject.isArchBaseAction is true.  You can specify
+     * a filter for the traversal code to use as well and only have it call your
+     * callback when the object's {@link ArchBaseCoreObject#isFilterMatch} method returns true for
+     * the filter.  Here's an example that creates a filter for callbacks on
+     * [any type of transfer action]{@link ArchBaseActionTransfer}, any
+     * [decision action]{@link ArchActionDecision} or objects whose name
+     * property case insensitively matches the word 'foo'.  While this could all be done
+     * with one property callback clause the example will use multiple clauses for
+     * the sake of simplicity:
+     * ```
+     * const myTraverseFilter = filterFactory.createFilterObject(archEnums.FILTER_CONTAINER_OPERATORS.or);
+     * myTraverseFilter.addClausePropertyValueEquals('isArchBaseActionTransfer', true);
+     * myTraverseFilter.addClausePropertyValueEquals('isArchActionDecision',     true);
+     * myTraverseFilter.addClausePropertyCallback('name', function(propValue, archContainingObject, propName) {
+     *       // We fully spelled out the function signature above but archContainingObject and propName are
+     *       // not needed in this case.  The archContainingObject is the object that contains the
+     *       // property and propName is the property name itself.  We pass in propName because the same
+     *       // function could be used for multiple property callback clauses.
+     *       // Remember to return a boolean true, false or undefined from ths callback.  :)
+     *       return propValue && propValue.toLowerCase() === 'foo';
+     * });
+     * archTask.traverse(function(traverseContext) {
+     *    // You will only be called back here for ArchBaseCoreObject instances that
+     *    // have the isArchBaseActionTransfer or isArchActionDecision property values equal to true.
+     * }, myTraverseFilter);
+     * ```
+     * If you supply a filter with no clauses, this tells the traverse method to
+     * call the supplied callback function for every {@link ArchBaseCoreObject} it traverses.
+     *
+     * If you want traversal itself to stop after a callback, simply return boolean
+     * false from the callback function you supply to the traverse call.
+     *
+     * The traverse method does not process deprecated property names such as [orgId]{@link ArchSession#orgId},
+     * [orgName]{@link ArchSession#orgName} or [languageSettings]{@link ArchBaseFlow#languageSettings}.  Additionally
+     * it does not traverse in to properties that would "jump out" of the current traversal.  An example of this
+     * would be if the code was traversing an {@link ArchActionJumpToMenu} action that it would not start traversing
+     * in to the menu that it jumps to.  Another example would be a {@link ArchActionChangeState} action where
+     * it would not traverse in to the target state of the action.  This also means traversal does not traverse
+     * in to the {@link ArchBaseValue#flowLevelDefault} property.
+     *
+     * And lastly, as Scripting evolves over time with new versions, you can expect to get callbacks for new object
+     * types such as new actions or new properties on objects.  As such, it's important not to assume any particular
+     * order in callbacks to keep code most compatible with traversal callbacks.  Or if you use inequality checks in filter
+     * clauses remember that new "stuff" may satisfy an inequality check which may or may not be anticipated in your logic.
+     *
+     * Note:  This traverse method is a helper method and is very handy for iterating over Architect Scripting
+     * objects and their properties in a generic fashion with filtering capabilities.  Obviously you can write
+     * your own custom traversal code if this implementation doesn't cut it for some reason. :)
+     *
+     * This function returns the number of times it called the callback function.
+     * @param callbackFunction - the callback function to call for objects that match the traverse filter.
+     * @param [traverseFilter = {@link ArchFactoryFilters#createFilterTraverseDefault}] - the filter to use when performing the traversal to determine which
+     *                                              {@link ArchBaseCoreObject} instances you wish to be called back for.  If no
+     *                                              filter is specified, this function will call {@link ArchFactoryFilters#createFilterTraverseDefault} and
+     *                                              use that traversal default filter.  The wantArchBaseValues parameter on that call is set to true.
+     */
+    traverse(callbackFunction: callbackTraverseInfo, traverseFilter?: ArchFilterObject): number;
+    /**
+     * This is a string suitable for logging information about this object where it's just the object's type.  This is normally used
+     * when logging errors that occur in constructor parameter checking because the scripting object isn't set up and the normal
+     * logging str contents wouldn't be set up.
+     */
+    readonly logStrTypeOnly: string;
+    /**
+     * Logs an error to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logErrors} is true.
+     * @param errorStr - the error string to log.
+     */
+    logError(errorStr: string): void;
+    /**
+     * Logs an error to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logErrors} is true and then throws
+     * the string in the errorStr parameter.
+     * @param errorStr - the error string to log.  This should be a non-blank string.
+     */
+    logErrorAndThrow(errorStr: string): void;
+    /**
+     * Logs a note to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logNotes} is true.
+     * @param noteStr - the note string to log.  This should be a non-blank string.
+     */
+    logNote(noteStr: string): void;
+    /**
+     * Logs a note to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logNotesVerbose} is true.
+     * @param noteStr - the note string to log.  This should be a non-blank string.
+     */
+    logNoteVerbose(noteStr: string): void;
+    /**
+     * Logs a warning to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logWarnings} is true.
+     * @param warningStr - the warning string to log.  This should be a non-blank string.
+     */
+    logWarning(warningStr: string): void;
+    /**
+     * Returns whether or not this Architect Scripting object is a match
+     * for the supplied ArchFilterObject instance.
+     * @param archFilterObject - the object filter to use to determine if it's a match.
+     */
+    isFilterMatch(archFilterObject: ArchFilterObject): boolean;
+}
+
+export class ArchBaseFlowWithTasks extends ArchBaseFlow {
+    // constructor(coreFlowViewModel: any);
+    /**
+     * This function deletes the specified reusable task from this flow.
+     * @param taskToDelete - the task to delete.  This must be a reusable task which means the {@link ArchTask#isReusableTask}
+     * property on the specified task instance is true.
+     */
+    deleteTask(taskToDelete: ArchTask): void;
+    /**
+     * Returns an array of the currently defined reusable tasks for this flow.
+     */
+    readonly tasksReusable: ArchTask[];
+    /**
+     * This adds a new variable to the flow.
+     * @param name - the name of the variable to add.  Remember that variable names must
+     *                        start with a letter and can then be followed by one or more letters, numbers
+     *                        or underscore characters to be valid.  Submitting the variable scope on the name
+     *                        is optional.  If specified, it must be 'Flow.' in order to be valid since you're
+     *                        adding the variable to a flow. You can also specify 'Slot.' to add a slot variable
+     *                         to the flow as long as the forceSlotVariableCreation parameter is true.
+     * @param type - the data type for the new variable.  Remember that type must be supported
+     *                              in the flow type for which you're looking to add the variable.  If you are
+     *                              not sure if a type is creatable, see the {@link ArchDataType#isScriptCreatableForFlowType} or
+     *                              {@link ArchDataType#isScriptCreatableForFlow} method.
+     * @param [description] - the description for the new variable.
+     * @param [forceSlotVariableCreation] - if true, will force the creation of a slot variable even when a Slot is not created in the Natural Language Understanding (NLU).
+     */
+    addVariable(name: string, type: ArchDataType, description?: string, forceSlotVariableCreation?: boolean): ArchBaseVariable;
+    /**
+     * This deletes the supplied variable from the flow.  Remember you can call {@link ArchBaseVariable#canDelete}
+     * prior to calling this method to know if the supplied flow scoped variable can be deleted.
+     * @param archVariable - the flow scoped variable you wish to delete
+     * @returns - true if the variable was removed successfully, false otherwise.
+     */
+    removeVariable(archVariable: ArchBaseVariable): boolean;
+    /**
+     * Checkout this flow. This function returns an ArchInfo instance for it to the supplied callback function.
+     * @param [forceUnlock] - if true, will force an unlock of the flow.
+     * @param [callbackFunction] - a callback function to call if the flow was checked out.
+     * @returns - while this method returns a promise, you should use the callback function to perform any processing once the flow is checked out.
+     */
+    checkoutAsync(forceUnlock?: boolean, callbackFunction?: callbackVoid): Promise<ArchFlowInfo>;
+    /**
+     * Returns the division associated with this flow.
+     * This method first calls {@link ArchOrganizationInfo#areDivisionsAvailable} to ensure that divisions are available.
+     * If not available, nothing is returned.
+     */
+    readonly division: ArchDivision;
+    /**
+     * Loads a specific version of the flow.  Any previously returned Architect Scripting objects associated with this flow should no
+     * longer be considered valid after loading new configuration.
+     * @param [flowVersion = "latest"] - the version of the flow to get.  Valid values are "latest" to get the latest saved configuration of a flow,
+     * a version value such as "2.0" or "2", "debug" to get the currently published debug version configuration of a flow,
+     * or "published" to get the currently published version configuration of a flow.  If you do not specify a version, then the latest saved configuration will be loaded.
+     * @param [callbackFunction] - a callback function to call if the flow was loaded.
+     * @returns - while this method returns a promise, you should use the callback function to perform any processing when the flow is loaded.
+     */
+    loadAsync(flowVersion?: string, callbackFunction?: callbackVoid): Promise<any>;
+    /**
+     * Returns a string suitable for logging that describes the flow
+     */
+    readonly logStr: string;
+    /**
+     * Unlocks this flow.
+     * @param [callbackFunction] - a callback function to call if the flow can be unlocked.
+     * @returns - while this method returns a promise, you should use the callback function to perform any processing once this flow is unlocked.
+     */
+    unlockAsync(callbackFunction?: callbackVoid): Promise<any>;
+    /**
+     * Helper method that accesses the flow's [settingsSupportedLanguages]{@link ArchBaseFlow#settingsSupportedLanguages} and then calls
+     * the [addSupportedLanguage]{@link ArchSettingsSupportedLanguagesFlow#addSupportedLanguage} function on the returned {@link ArchSettingsSupportedLanguagesFlow}
+     * value.
+     * @param archLanguage - the language to add to supported languages on the flow.  Note that any language used as a supported
+     * language must have at least one region sub-tag.
+     * @param [setAsDefaultLanguage] - if true, the language will be set as the default language on the flow.
+     */
+    addFlowSupportedLanguage(archLanguage: ArchLanguage, setAsDefaultLanguage?: boolean): ArchSettingsSupportedLanguage;
+    /**
+     * Checks flow to see if a language can be added in its current state. Some flows may have restrictions
+     * if any or more than one can be added.
+     */
+    canAddSupportedLanguage(): boolean;
+    /**
+     * Checks in and unlocks the flow for the current user, does a save first
+     * Assumes the flow has been created, throws if not
+     * @param [ensureSearchable] - whether or not to poll after successful checkin to ensure that the flow is available for flow
+     *                                       search operations such as {@link ArchFactoryFlows#getFlowInfoByFlowNameAsync} or {@link ArchFactoryFlows#getFlowInfoByFlowIdAsync}
+     * @returns - On your promise's then handler, the first parameter passed to the then function will be this
+     * flow instance.
+     */
+    checkInAsync(ensureSearchable?: boolean): Promise<ArchBaseFlow | undefined>;
+    /**
+     * Creates a new flow on the server and saves its configuration
+     * @returns - On your promise's then handler, the first parameter passed to the then function will be this
+     * flow instance.
+     */
+    createAsync(): Promise<any>;
+    /**
+     * Accessing this property returns an object with properties whose keys are data type names and values are
+     * {@link ArchDataType} instances.
+     */
+    readonly dataTypes: any;
+    /**
+     * The description of the flow
+     */
+    description: string;
+    /**
+     * Exports the current flow to a file in the specified directory.  This destination directory *must* exist
+     * for the export to succeed.  Note that this uses the file system and should not be used when running in a
+     * browser.
+     * @param [destinationDir] - the directory where the flow export should be saved.
+     * @param [callbackFunction] - the function to call back and pass in the full path where the
+     *                                                      flow export was saved.
+     * @param [flowFormat = ArchEnums.FLOW_FORMAT_TYPES.architect] - the desired flow format to use for the export. See {@link ArchEnums#FLOW_FORMAT_TYPES} for allowable export formats. If no format is used,
+     *                                                                      it will default to the Architect format.
+     * @param [fileName] - the file name to use for the exported flow. If a file extension is not added to the file name, it will use the default file extension for the desired export type for
+     * the desired export format and flow that you are exporting. If the format is YAML, the extension is always '.yaml' regardless of flow type. However, if it is the Architect format, the extension is unique per flow-type.
+     * To find the correct file extension for the Architect format, you can either export a flow from the Architect UI or look at the [flow definition]{@link ArchBaseFlow#definition}
+     * for a flow type and access the [fileExtension]{@link ArchDefinitionFlow#fileExtension} property to get the value. If an extension is found on the file name other than what is
+     * expected, the correct extension will be appended to the end of the exported file as per the logic described previously.
+     */
+    exportToDirAsync(destinationDir?: string, callbackFunction?: callbackExportFullPath, flowFormat?: string, fileName?: string): Promise<string>;
+    /**
+     * Exports the flow to a JSON object.  The object passed back in the callback function
+     * will be a JSON object with a content and fileName property where the content holds
+     * the flow export contents and the fileName property holds the file name where the
+     * export would be written if {@link ArchBaseFlow#exportToDirAsync} is called.
+     * @param callbackFunction - the function to call back with the export information contained
+     *                                                  in the parameter passed to it.
+     * @param [flowFormat = archEnums.FLOW_FORMAT_TYPES.architect] - the desired export format to use on an export. See {@link ArchEnums#FLOW_FORMAT_TYPES} for allowable export formats. If no format is used,
+     *                                                                      it will default to the Architect format.
+     */
+    exportToObjectAsync(callbackFunction: callbackExportObject, flowFormat?: string): Promise<ExportInfoType>;
+    /**
+     * The type of the flow.  The string
+     * values in {@link ArchEnums#FLOW_TYPES} lists valid flow type values.
+     */
+    readonly flowType: string;
+    /**
+     * This function will return the file path where a flow export will be written when calling the {@link ArchBaseFlow#exportToDirAsync}
+     * method for the supplied destination directory and export flow format.  A typical use case for this function would be
+     * to get the export file path prior to calling the {@link ArchBaseFlow#exportToDirAsync} so you could see if the file already exists
+     * and decide if you want to perform an export or not since {@link ArchBaseFlow#exportToDirAsync} will attempt to overwrite
+     * a file if it already exists. Note that this uses the file system and should not be used when running in a
+     * browser.
+     * @param [destinationDir] - the directory where the flow export should be written. If no directory path is given, this method uses the
+     *                                    current working directory.  If a relative path is supplied, it will be resolved relative to the current
+     *                                    working directory.
+     * @param [flowFormat = ArchEnums.FLOW_FORMAT_TYPES.architect] - the desired flow format to use for the export. See {@link ArchEnums#FLOW_FORMAT_TYPES} for allowable export
+     *                                                                      formats. If no format is supplied, it will use the Architect format.
+     * @param [fileName] - the file name to use for the exported flow. If a file extension is not added to the file name, it will use the default file extension for the desired export type for
+     * the desired export format and flow that you are exporting. If the format is YAML, the extension is always '.yaml' regardless of flow type. However, if it is the Architect format, the extension is unique per flow-type.
+     * To find the correct file extension for the Architect format, you can either export a flow from the Architect UI or look at the [flow definition]{@link ArchBaseFlow#definition}
+     * for a flow type and access the [fileExtension]{@link ArchDefinitionFlow#fileExtension} property to get the value. If an extension is found on the file name other than what is
+     * expected, the correct extension will be appended to the end of the exported file as per the logic described previously.
+     */
+    getExportFilePath(destinationDir?: string, flowFormat?: string, fileName?: string): string;
+    /**
+     * Returns the flow scoped variable for the supplied variable identifier ( if it exists ).
+     * If the variable name cannot be found, nothing is returned.
+     * @param variableId - the supllied variable identifier to look up such as __CALL_ANI__.
+     */
+    getVariableById<T extends ArchBaseVariable = ArchBaseVariable>(variableId: string): T;
+    /**
+     * Returns the flow scoped variable for the supplied fully scoped variable name ( if it exists ).  Remember, looking
+     * up variables by name is case insensitive.  If the variable name cannot be found, nothing is returned.
+     * @param variableName - the fully scoped variable name to look up such as Flow.MyVar.
+     */
+    getVariableByName<T extends ArchBaseVariable = ArchBaseVariable>(variableName: string): T;
+    /**
+     * Imports the flow content from the supplied content string.  This content string should be for a flow of the
+     * same type as the one you're importing in to.  Upon successful import, the callback function passed in
+     * will be called.  Importing flow contents in to a flow is something where you should *not* attempt to
+     * do work with the flow on which this is being called until the callback is called.
+     * @param exportContent - the contents from a flow export.
+     * @param [callbackFunction] - a function to call if the export content successfully loaded and configured
+     *                                                    on this flow.  The first parameter passed to the callback function will be this
+     *                                                    Architect flow instance.
+     */
+    importFromContentAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportContent: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
+    /**
+     * Imports the flow content from the supplied file path.  Upon successful import, the callback function passed in
+     * will be called.  Importing flow contents in to a flow is something where you should *not* attempt to
+     * do work with the flow on which this is being called until the callback is called.
+     * Also note that this method should not be used if running in a browser.
+     * @param exportFilePath - the file path to an Architect flow export file that should be imported.
+     * @param [callbackFunction] - a function to call if the export content successfully loaded and configured
+     *                                        on this flow.  The first parameter passed to the callback function will be this
+     *                                        Architect flow instance.
+     */
+    importFromFileAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportFilePath: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
     /**
      * Returns whether or not the flow is created in Genesys Cloud.
      */
@@ -17773,80 +20488,157 @@ export class ArchBaseFlow extends ArchBaseCoreObjectWithId {
      */
     readonly variables: ArchBaseVariable[];
     /**
-     * Returns a definition for this flow type which provides access to information about this flow such as {@link ArchDefinitionFlow#isAvailable}.
-     * ```
-     * // Example code - remember, only access this when your Scripting session is connected!
-     * let archIncomingCallFlowDefinition = scripting.viewModels.flows.ArchFlowInboundCall.definition;
-     * // or for a given ArchFlowInboundCall flow instance:
-     * let archIncomingCallFlowDefinition = archInboundCallFlowInstance.definition;
-     * ```
+     * The identifier string for this object.
      */
-    readonly definition: ArchDefinitionFlow;
-}
-
-/**
- * The Architect Scripting class for the Base Bot flow class.
- * Instances of this Architect Scripting object should be created by calling {@link ArchFactoryFlows#createFlowBotAsync}
- * @param coreBotViewModel - ( *Internal* ) an Architect core Bot view model.
- */
-export class ArchBaseFlowBot extends ArchBaseFlowWorkflow {
-    // constructor(coreBotViewModel: any);
+    readonly id: string;
     /**
-     * Returns the display type name string 'ArchBaseFlowBot'.
+     * Returns whether or not the id property may be blank or undefined for this object.  For example, the returned settings from {@link ArchMenu#settingsMenu}
+     * will have a blank identifier along with the settings returned from {@link ArchMenu#settingsSpeechRec}.  Note that this is
+     * an extremely rare case.
      */
-    readonly displayTypeName: string;
+    readonly idMayBeBlank: string;
     /**
-     * Returns true indicating that this is an ArchBaseFlowBot instance.
+     * Returns true indicating that this is an ArchBaseCoreObject instance.
      */
-    readonly isArchBaseFlowBot: boolean;
+    readonly isArchBaseCoreObject: boolean;
     /**
-     * The user input settings for the flow.
+     * This method iterates over this object and ArchBaseCoreObject instances
+     * within it.  For each object it will call the {@link ArchBaseObject#isFilterMatch} method
+     * with a filter and call the supplied callback function if isMatch returns true.
+     * The callback will be passed an {@link ArchTraverseInfo} with details
+     * about the match such as the match object itself along with current contextual
+     * information such as the object hierarchy for the match object relative to
+     * the object on which this traverse call is being made.
+     *
+     * The traverse [filter]{@link ArchFilterObject} is one which you can create
+     * by calling {@link ArchFactoryFilters#createFilterObject} and then add desired clauses
+     * or clause containers to it.  If not specified, this function will use a
+     * [default filter]{@link ArchFactoryFilters#createFilterTraverseDefault}.
+     *
+     * Here is an example that does a simple flow traversal using the default
+     * filter and logs information about objects in the callback from the
+     * traverse object that's passed back:
+     *
+     * ```
+     * archInboundCallFlow.traverse(function(traverseInfo) {
+     *    archLogging.logNote('  Object     : ' + traverseInfo.matchObject.logStr);
+     *    archLogging.logNote('    Hierarchy: ' + traverseInfo.context.hierarchyStr);
+     * });
+     * ```
+     * This might be enough for most uses and you can check various aspects
+     * about the object in the callback such as "is this an Architect action?" by
+     * seeing if traverseInfo.matchObject.isArchBaseAction is true.  You can specify
+     * a filter for the traversal code to use as well and only have it call your
+     * callback when the object's {@link ArchBaseCoreObject#isFilterMatch} method returns true for
+     * the filter.  Here's an example that creates a filter for callbacks on
+     * [any type of transfer action]{@link ArchBaseActionTransfer}, any
+     * [decision action]{@link ArchActionDecision} or objects whose name
+     * property case insensitively matches the word 'foo'.  While this could all be done
+     * with one property callback clause the example will use multiple clauses for
+     * the sake of simplicity:
+     * ```
+     * const myTraverseFilter = filterFactory.createFilterObject(archEnums.FILTER_CONTAINER_OPERATORS.or);
+     * myTraverseFilter.addClausePropertyValueEquals('isArchBaseActionTransfer', true);
+     * myTraverseFilter.addClausePropertyValueEquals('isArchActionDecision',     true);
+     * myTraverseFilter.addClausePropertyCallback('name', function(propValue, archContainingObject, propName) {
+     *       // We fully spelled out the function signature above but archContainingObject and propName are
+     *       // not needed in this case.  The archContainingObject is the object that contains the
+     *       // property and propName is the property name itself.  We pass in propName because the same
+     *       // function could be used for multiple property callback clauses.
+     *       // Remember to return a boolean true, false or undefined from ths callback.  :)
+     *       return propValue && propValue.toLowerCase() === 'foo';
+     * });
+     * archTask.traverse(function(traverseContext) {
+     *    // You will only be called back here for ArchBaseCoreObject instances that
+     *    // have the isArchBaseActionTransfer or isArchActionDecision property values equal to true.
+     * }, myTraverseFilter);
+     * ```
+     * If you supply a filter with no clauses, this tells the traverse method to
+     * call the supplied callback function for every {@link ArchBaseCoreObject} it traverses.
+     *
+     * If you want traversal itself to stop after a callback, simply return boolean
+     * false from the callback function you supply to the traverse call.
+     *
+     * The traverse method does not process deprecated property names such as [orgId]{@link ArchSession#orgId},
+     * [orgName]{@link ArchSession#orgName} or [languageSettings]{@link ArchBaseFlow#languageSettings}.  Additionally
+     * it does not traverse in to properties that would "jump out" of the current traversal.  An example of this
+     * would be if the code was traversing an {@link ArchActionJumpToMenu} action that it would not start traversing
+     * in to the menu that it jumps to.  Another example would be a {@link ArchActionChangeState} action where
+     * it would not traverse in to the target state of the action.  This also means traversal does not traverse
+     * in to the {@link ArchBaseValue#flowLevelDefault} property.
+     *
+     * And lastly, as Scripting evolves over time with new versions, you can expect to get callbacks for new object
+     * types such as new actions or new properties on objects.  As such, it's important not to assume any particular
+     * order in callbacks to keep code most compatible with traversal callbacks.  Or if you use inequality checks in filter
+     * clauses remember that new "stuff" may satisfy an inequality check which may or may not be anticipated in your logic.
+     *
+     * Note:  This traverse method is a helper method and is very handy for iterating over Architect Scripting
+     * objects and their properties in a generic fashion with filtering capabilities.  Obviously you can write
+     * your own custom traversal code if this implementation doesn't cut it for some reason. :)
+     *
+     * This function returns the number of times it called the callback function.
+     * @param callbackFunction - the callback function to call for objects that match the traverse filter.
+     * @param [traverseFilter = {@link ArchFactoryFilters#createFilterTraverseDefault}] - the filter to use when performing the traversal to determine which
+     *                                              {@link ArchBaseCoreObject} instances you wish to be called back for.  If no
+     *                                              filter is specified, this function will call {@link ArchFactoryFilters#createFilterTraverseDefault} and
+     *                                              use that traversal default filter.  The wantArchBaseValues parameter on that call is set to true.
      */
-    readonly userInputSettings: ArchSettingsUserInput;
+    traverse(callbackFunction: callbackTraverseInfo, traverseFilter?: ArchFilterObject): number;
     /**
-     * Returns the error handling settings for the flow.
+     * This is a string suitable for logging information about this object where it's just the object's type.  This is normally used
+     * when logging errors that occur in constructor parameter checking because the scripting object isn't set up and the normal
+     * logging str contents wouldn't be set up.
      */
-    readonly settingsErrorHandling: ArchSettingsEventErrorFlowBot;
-}
-
-export class ArchBaseFlowBotWithKnowledge extends ArchBaseFlowBot {
-    // constructor(coreBotWithKnowledgeViewModel: any);
+    readonly logStrTypeOnly: string;
     /**
-     * Returns the display type name string 'isArchBaseFlowBotWithKnowledge'.
+     * Logs an error to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logErrors} is true.
+     * @param errorStr - the error string to log.
      */
-    readonly displayTypeName: string;
+    logError(errorStr: string): void;
     /**
-     * Returns true indicating that this is an isArchBaseFlowBotWithKnowledge instance.
+     * Logs an error to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logErrors} is true and then throws
+     * the string in the errorStr parameter.
+     * @param errorStr - the error string to log.  This should be a non-blank string.
      */
-    readonly isArchBaseFlowBotWithKnowledge: boolean;
+    logErrorAndThrow(errorStr: string): void;
     /**
-     * The natural language understanding knowledge settings for the bot flow.
-     * Note that if your organization does not have knowledge base support or the
-     * flow's supported language does not support knowledge, accessing this property
-     * will return null.
+     * Logs a note to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logNotes} is true.
+     * @param noteStr - the note string to log.  This should be a non-blank string.
      */
-    readonly knowledgeSettings: ArchSettingsNluKnowledge;
+    logNote(noteStr: string): void;
     /**
-     * Bot-specific settings for the flow.
+     * Logs a note to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logNotesVerbose} is true.
+     * @param noteStr - the note string to log.  This should be a non-blank string.
      */
-    readonly botFlowSettings: ArchSettingsBotFlow;
+    logNoteVerbose(noteStr: string): void;
     /**
-     * Returns true indicating that this is an ArchBaseFlowBot instance.
+     * Logs a warning to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logWarnings} is true.
+     * @param warningStr - the warning string to log.  This should be a non-blank string.
      */
-    readonly isArchBaseFlowBot: boolean;
+    logWarning(warningStr: string): void;
     /**
-     * The user input settings for the flow.
+     * Returns whether or not this Architect Scripting object is a match
+     * for the supplied ArchFilterObject instance.
+     * @param archFilterObject - the object filter to use to determine if it's a match.
      */
-    readonly userInputSettings: ArchSettingsUserInput;
+    isFilterMatch(archFilterObject: ArchFilterObject): boolean;
+}
+
+export class ArchBaseFlowWorkflow extends ArchBaseFlowWithTasks {
+    // constructor(coreBaseWorkflowViewModel: any);
     /**
-     * Returns the error handling settings for the flow.
+     * Returns true indicating that this is an ArchBaseFlowWorkflow object.
      */
-    readonly settingsErrorHandling: ArchSettingsEventErrorFlowBot;
+    readonly isArchBaseFlowWorkflow: boolean;
     /**
      * This function deletes the specified state from this flow.
      * @param stateToDelete - the state to delete.
      */
     deleteState(stateToDelete: ArchState): void;
+    /**
+     * Returns the display type name string 'ArchBaseFlowWorkflow'.
+     */
+    readonly displayTypeName: string;
     /**
      * Sets the specified state to be the starting state on the flow.
      * @param archState - An Architect Scripting state object.
@@ -17900,7 +20692,7 @@ export class ArchBaseFlowBotWithKnowledge extends ArchBaseFlowBot {
      * @param [callbackFunction] - a callback function to call if the flow was checked out.
      * @returns - while this method returns a promise, you should use the callback function to perform any processing once the flow is checked out.
      */
-    checkoutAsync(forceUnlock?: boolean, callbackFunction?: callbackVoid): Promise<any>;
+    checkoutAsync(forceUnlock?: boolean, callbackFunction?: callbackVoid): Promise<ArchFlowInfo>;
     /**
      * Returns the division associated with this flow.
      * This method first calls {@link ArchOrganizationInfo#areDivisionsAvailable} to ensure that divisions are available.
@@ -17949,7 +20741,7 @@ export class ArchBaseFlowBotWithKnowledge extends ArchBaseFlowBot {
      * @returns - On your promise's then handler, the first parameter passed to the then function will be this
      * flow instance.
      */
-    checkInAsync(ensureSearchable?: boolean): Promise<any>;
+    checkInAsync(ensureSearchable?: boolean): Promise<ArchBaseFlow | undefined>;
     /**
      * Creates a new flow on the server and saves its configuration
      * @returns - On your promise's then handler, the first parameter passed to the then function will be this
@@ -18038,7 +20830,7 @@ export class ArchBaseFlowBotWithKnowledge extends ArchBaseFlowBot {
      *                                                    on this flow.  The first parameter passed to the callback function will be this
      *                                                    Architect flow instance.
      */
-    importFromContentAsync(exportContent: string, callbackFunction?: (...params: any[]) => any): Promise<any>;
+    importFromContentAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportContent: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
     /**
      * Imports the flow content from the supplied file path.  Upon successful import, the callback function passed in
      * will be called.  Importing flow contents in to a flow is something where you should *not* attempt to
@@ -18049,7 +20841,7 @@ export class ArchBaseFlowBotWithKnowledge extends ArchBaseFlowBot {
      *                                        on this flow.  The first parameter passed to the callback function will be this
      *                                        Architect flow instance.
      */
-    importFromFileAsync(exportFilePath: string, callbackFunction?: (...params: any[]) => any): Promise<any>;
+    importFromFileAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportFilePath: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
     /**
      * Returns whether or not the flow is created in Genesys Cloud.
      */
@@ -18093,6 +20885,10 @@ export class ArchBaseFlowBotWithKnowledge extends ArchBaseFlowBot {
      * flow instance.
      */
     saveAsync(): Promise<any>;
+    /**
+     * Returns the error handling settings for the flow.
+     */
+    readonly settingsErrorHandling: ArchSettingsEventErrorFlow;
     /**
      * Returns the action default settings for the flow.
      */
@@ -18274,157 +21070,6 @@ export class ArchBaseFlowBotWithKnowledge extends ArchBaseFlowBot {
     isFilterMatch(archFilterObject: ArchFilterObject): boolean;
 }
 
-/**
- * The Architect Scripting class for the base workflow instance.
- * @param coreInQueueDigitalFlow - ( *Internal* ) an Architect core in-queue email or short message flow.
- */
-export class ArchBaseFlowInQueueWorkflow extends ArchBaseFlowWorkflow {
-    // constructor(coreInQueueDigitalFlow: any);
-    /**
-     * Returns the display type name string 'ArchBaseFlowInQueueWorkflow'.
-     */
-    readonly displayTypeName: string;
-    /**
-     * Returns true indicating that this is an ArchBaseFlowInQueueWorkflow object.
-     * This will be true for in-queue email and in-queue short message flows.
-     */
-    readonly isArchBaseFlowInQueueWorkflow: boolean;
-    /**
-     * Sets the specified state to be the periodic state on the in-queue
-     * email or short message flow.  Remember the same state cannot be used
-     * for both the starting state and the periodic state.
-     * @param archState - An Architect Scripting state object.
-     */
-    setPeriodicState(archState: ArchState): void;
-    /**
-     * Returns the periodic state for this flow.
-     */
-    readonly periodicState: ArchState;
-}
-
-/**
- * Creates an instance of an ArchBaseFlowInboundOutboundSecureCall.  This is the base class for inbound / outbound / secure call flows.
- * @param coreInboundOutboundSecureFlowViewModel - ( *Internal* ) an Architect core inbound, outbound or secure call flow view model.
- */
-export class ArchBaseFlowInboundOutboundSecureCall extends ArchBaseFlowWithMenus {
-    // constructor(coreInboundOutboundSecureFlowViewModel: any);
-    /**
-     * Returns the display type name string 'ArchBaseFlowInboundOutboundSecureCall'.
-     */
-    readonly displayTypeName: string;
-    /**
-     * The initial audio set on the flow.
-     */
-    readonly initialAudio: ArchAudio;
-    /**
-     * Returns true indicating that this is an ArchBaseFlowInboundOutboundSecureCall object.
-     */
-    readonly isArchBaseFlowInboundOutboundSecureCall: boolean;
-    /**
-     * Sets the specified menu to be the starting task on the flow.
-     * @param archMenu - An Architect Scripting menu object.
-     */
-    setStartingMenu(archMenu: ArchMenu): void;
-    /**
-     * Sets the specified task to be the starting task on the flow.
-     * @param archTask - An Architect Scripting task object.
-     */
-    setStartingTask(archTask: ArchTask): void;
-    /**
-     * The menu settings for the flow.
-     */
-    readonly settingsMenu: ArchSettingsMenuFlow;
-    /**
-     * The prompt settings for the flow.
-     */
-    readonly settingsPrompts: ArchSettingsPromptsFlow;
-    /**
-     * The speech rec settings for the flow.
-     */
-    readonly settingsSpeechRec: ArchSettingsSpeechRecFlow;
-    /**
-     * Returns the starting task or menu for this call flow.
-     * If there is no startup object configured, accessing this property returns null.
-     */
-    readonly startUpObject: ArchTask | ArchMenu;
-    /**
-     * The outbound settings for the flow such as contact list and default wrapup code.
-     */
-    readonly settingsOutboundCall: ArchSettingsOutboundCallFlow;
-}
-
-/**
- * Creates an instance of an ArchBaseFlowWithMenus.  This is the base class for flows that contain menus.
- * @param coreFlowViewModel - ( *Internal* ) an Architect core flow view model object that contains menus.
- */
-export class ArchBaseFlowWithMenus extends ArchBaseFlowWithTasks {
-    // constructor(coreFlowViewModel: any);
-    /**
-     * This function deletes the specified reusable menu from this flow.
-     * @param menuToDelete - the menu to delete.  This must be a reusable menu which means the {@link ArchMenu#isReusableMenu}
-     * property on the specified menu instance is true.
-     */
-    deleteMenu(menuToDelete: ArchMenu): void;
-    /**
-     * Returns an array of the currently defined reusable menus for this flow.
-     */
-    readonly menusReusable: ArchBaseMenu[];
-}
-
-/**
- * The Architect Scripting class for flows that contain tasks.  Note that a task is not considered to be the same thing
- * as the repeating task in an in-queue call flow.
- * @param coreFlowViewModel - ( *Internal* ) an Architect core flow view model object that contains tasks.
- */
-export class ArchBaseFlowWithTasks extends ArchBaseFlow {
-    // constructor(coreFlowViewModel: any);
-    /**
-     * This function deletes the specified reusable task from this flow.
-     * @param taskToDelete - the task to delete.  This must be a reusable task which means the {@link ArchTask#isReusableTask}
-     * property on the specified task instance is true.
-     */
-    deleteTask(taskToDelete: ArchTask): void;
-    /**
-     * Returns an array of the currently defined reusable tasks for this flow.
-     */
-    readonly tasksReusable: ArchTask[];
-}
-
-/**
- * The Architect Scripting class for the base workflow instance.
- * @param coreBaseWorkflowViewModel - ( *Internal* ) an Architect core base workflow view model.
- */
-export class ArchBaseFlowWorkflow extends ArchBaseFlowWithTasks {
-    // constructor(coreBaseWorkflowViewModel: any);
-    /**
-     * This function deletes the specified state from this flow.
-     * @param stateToDelete - the state to delete.
-     */
-    deleteState(stateToDelete: ArchState): void;
-    /**
-     * Returns the display type name string 'ArchBaseFlowWorkflow'.
-     */
-    readonly displayTypeName: string;
-    /**
-     * Returns true indicating that this is an ArchBaseFlowWorkflow object.
-     */
-    readonly isArchBaseFlowWorkflow: boolean;
-    /**
-     * Sets the specified state to be the starting state on the flow.
-     * @param archState - An Architect Scripting state object.
-     */
-    setStartingState(archState: ArchState): void;
-    /**
-     * Returns the starting state for this flow.
-     * If there is no startup object configured, accessing this property returns null.
-     */
-    readonly startUpObject: ArchState;
-    /**
-     * The states in the flow.
-     */
-    readonly states: ArchState[];
-}
-
 /**
  * The Architect Scripting class that provides internal support for Architect Scripting menu and menu choice objects.
  */
@@ -24850,7 +27495,7 @@ export class ArchFlowBot extends ArchBaseFlowBotWithKnowledge {
      * flow's supported language does not support knowledge, accessing this property
      * will return null.
      */
-    readonly knowledgeSettings: ArchSettingsNluKnowledge;
+    readonly knowledgeSettings: ArchSettingsNluKnowledge | null;
     /**
      * Bot-specific settings for the flow.
      */
@@ -24925,7 +27570,7 @@ export class ArchFlowBot extends ArchBaseFlowBotWithKnowledge {
      * @param [callbackFunction] - a callback function to call if the flow was checked out.
      * @returns - while this method returns a promise, you should use the callback function to perform any processing once the flow is checked out.
      */
-    checkoutAsync(forceUnlock?: boolean, callbackFunction?: callbackVoid): Promise<any>;
+    checkoutAsync(forceUnlock?: boolean, callbackFunction?: callbackVoid): Promise<ArchFlowInfo>;
     /**
      * Returns the division associated with this flow.
      * This method first calls {@link ArchOrganizationInfo#areDivisionsAvailable} to ensure that divisions are available.
@@ -24974,7 +27619,7 @@ export class ArchFlowBot extends ArchBaseFlowBotWithKnowledge {
      * @returns - On your promise's then handler, the first parameter passed to the then function will be this
      * flow instance.
      */
-    checkInAsync(ensureSearchable?: boolean): Promise<any>;
+    checkInAsync(ensureSearchable?: boolean): Promise<ArchBaseFlow | undefined>;
     /**
      * Creates a new flow on the server and saves its configuration
      * @returns - On your promise's then handler, the first parameter passed to the then function will be this
@@ -25063,7 +27708,7 @@ export class ArchFlowBot extends ArchBaseFlowBotWithKnowledge {
      *                                                    on this flow.  The first parameter passed to the callback function will be this
      *                                                    Architect flow instance.
      */
-    importFromContentAsync(exportContent: string, callbackFunction?: (...params: any[]) => any): Promise<any>;
+    importFromContentAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportContent: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
     /**
      * Imports the flow content from the supplied file path.  Upon successful import, the callback function passed in
      * will be called.  Importing flow contents in to a flow is something where you should *not* attempt to
@@ -25074,7 +27719,7 @@ export class ArchFlowBot extends ArchBaseFlowBotWithKnowledge {
      *                                        on this flow.  The first parameter passed to the callback function will be this
      *                                        Architect flow instance.
      */
-    importFromFileAsync(exportFilePath: string, callbackFunction?: (...params: any[]) => any): Promise<any>;
+    importFromFileAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportFilePath: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
     /**
      * Returns whether or not the flow is created in Genesys Cloud.
      */
@@ -25351,7 +27996,7 @@ export class ArchFlowCommonModule extends ArchBaseFlow {
      * @param [callbackFunction] - a callback function to call if the flow was checked out.
      * @returns - while this method returns a promise, you should use the callback function to perform any processing once the flow is checked out.
      */
-    checkoutAsync(forceUnlock?: boolean, callbackFunction?: callbackVoid): Promise<any>;
+    checkoutAsync(forceUnlock?: boolean, callbackFunction?: callbackVoid): Promise<ArchFlowInfo>;
     /**
      * Returns the division associated with this flow.
      * This method first calls {@link ArchOrganizationInfo#areDivisionsAvailable} to ensure that divisions are available.
@@ -25400,7 +28045,7 @@ export class ArchFlowCommonModule extends ArchBaseFlow {
      * @returns - On your promise's then handler, the first parameter passed to the then function will be this
      * flow instance.
      */
-    checkInAsync(ensureSearchable?: boolean): Promise<any>;
+    checkInAsync(ensureSearchable?: boolean): Promise<ArchBaseFlow | undefined>;
     /**
      * Creates a new flow on the server and saves its configuration
      * @returns - On your promise's then handler, the first parameter passed to the then function will be this
@@ -25489,7 +28134,7 @@ export class ArchFlowCommonModule extends ArchBaseFlow {
      *                                                    on this flow.  The first parameter passed to the callback function will be this
      *                                                    Architect flow instance.
      */
-    importFromContentAsync(exportContent: string, callbackFunction?: (...params: any[]) => any): Promise<any>;
+    importFromContentAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportContent: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
     /**
      * Imports the flow content from the supplied file path.  Upon successful import, the callback function passed in
      * will be called.  Importing flow contents in to a flow is something where you should *not* attempt to
@@ -25500,7 +28145,7 @@ export class ArchFlowCommonModule extends ArchBaseFlow {
      *                                        on this flow.  The first parameter passed to the callback function will be this
      *                                        Architect flow instance.
      */
-    importFromFileAsync(exportFilePath: string, callbackFunction?: (...params: any[]) => any): Promise<any>;
+    importFromFileAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportFilePath: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
     /**
      * Returns whether or not the flow is created in Genesys Cloud.
      */
@@ -25753,7 +28398,7 @@ export class ArchFlowDigitalBot extends ArchBaseFlowBotWithKnowledge {
      * flow's supported language does not support knowledge, accessing this property
      * will return null.
      */
-    readonly knowledgeSettings: ArchSettingsNluKnowledge;
+    readonly knowledgeSettings: ArchSettingsNluKnowledge | null;
     /**
      * Bot-specific settings for the flow.
      */
@@ -25828,7 +28473,7 @@ export class ArchFlowDigitalBot extends ArchBaseFlowBotWithKnowledge {
      * @param [callbackFunction] - a callback function to call if the flow was checked out.
      * @returns - while this method returns a promise, you should use the callback function to perform any processing once the flow is checked out.
      */
-    checkoutAsync(forceUnlock?: boolean, callbackFunction?: callbackVoid): Promise<any>;
+    checkoutAsync(forceUnlock?: boolean, callbackFunction?: callbackVoid): Promise<ArchFlowInfo>;
     /**
      * Returns the division associated with this flow.
      * This method first calls {@link ArchOrganizationInfo#areDivisionsAvailable} to ensure that divisions are available.
@@ -25877,7 +28522,7 @@ export class ArchFlowDigitalBot extends ArchBaseFlowBotWithKnowledge {
      * @returns - On your promise's then handler, the first parameter passed to the then function will be this
      * flow instance.
      */
-    checkInAsync(ensureSearchable?: boolean): Promise<any>;
+    checkInAsync(ensureSearchable?: boolean): Promise<ArchBaseFlow | undefined>;
     /**
      * Creates a new flow on the server and saves its configuration
      * @returns - On your promise's then handler, the first parameter passed to the then function will be this
@@ -25966,7 +28611,7 @@ export class ArchFlowDigitalBot extends ArchBaseFlowBotWithKnowledge {
      *                                                    on this flow.  The first parameter passed to the callback function will be this
      *                                                    Architect flow instance.
      */
-    importFromContentAsync(exportContent: string, callbackFunction?: (...params: any[]) => any): Promise<any>;
+    importFromContentAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportContent: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
     /**
      * Imports the flow content from the supplied file path.  Upon successful import, the callback function passed in
      * will be called.  Importing flow contents in to a flow is something where you should *not* attempt to
@@ -25977,7 +28622,7 @@ export class ArchFlowDigitalBot extends ArchBaseFlowBotWithKnowledge {
      *                                        on this flow.  The first parameter passed to the callback function will be this
      *                                        Architect flow instance.
      */
-    importFromFileAsync(exportFilePath: string, callbackFunction?: (...params: any[]) => any): Promise<any>;
+    importFromFileAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportFilePath: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
     /**
      * Returns whether or not the flow is created in Genesys Cloud.
      */
@@ -26253,7 +28898,7 @@ export class ArchFlowInQueueCall extends ArchBaseFlow {
      * @param [callbackFunction] - a callback function to call if the flow was checked out.
      * @returns - while this method returns a promise, you should use the callback function to perform any processing once the flow is checked out.
      */
-    checkoutAsync(forceUnlock?: boolean, callbackFunction?: callbackVoid): Promise<any>;
+    checkoutAsync(forceUnlock?: boolean, callbackFunction?: callbackVoid): Promise<ArchFlowInfo>;
     /**
      * Returns the division associated with this flow.
      * This method first calls {@link ArchOrganizationInfo#areDivisionsAvailable} to ensure that divisions are available.
@@ -26302,7 +28947,7 @@ export class ArchFlowInQueueCall extends ArchBaseFlow {
      * @returns - On your promise's then handler, the first parameter passed to the then function will be this
      * flow instance.
      */
-    checkInAsync(ensureSearchable?: boolean): Promise<any>;
+    checkInAsync(ensureSearchable?: boolean): Promise<ArchBaseFlow | undefined>;
     /**
      * Creates a new flow on the server and saves its configuration
      * @returns - On your promise's then handler, the first parameter passed to the then function will be this
@@ -26391,7 +29036,7 @@ export class ArchFlowInQueueCall extends ArchBaseFlow {
      *                                                    on this flow.  The first parameter passed to the callback function will be this
      *                                                    Architect flow instance.
      */
-    importFromContentAsync(exportContent: string, callbackFunction?: (...params: any[]) => any): Promise<any>;
+    importFromContentAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportContent: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
     /**
      * Imports the flow content from the supplied file path.  Upon successful import, the callback function passed in
      * will be called.  Importing flow contents in to a flow is something where you should *not* attempt to
@@ -26402,7 +29047,7 @@ export class ArchFlowInQueueCall extends ArchBaseFlow {
      *                                        on this flow.  The first parameter passed to the callback function will be this
      *                                        Architect flow instance.
      */
-    importFromFileAsync(exportFilePath: string, callbackFunction?: (...params: any[]) => any): Promise<any>;
+    importFromFileAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportFilePath: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
     /**
      * Returns whether or not the flow is created in Genesys Cloud.
      */
@@ -26642,12 +29287,10 @@ export class ArchFlowInQueueEmail extends ArchBaseFlowInQueueWorkflow {
      */
     readonly isArchFlowInQueueEmail: boolean;
     /**
-     * Sets the specified state to be the periodic state on the in-queue
-     * email or short message flow.  Remember the same state cannot be used
-     * for both the starting state and the periodic state.
-     * @param archState - An Architect Scripting state object.
+     * Returns true indicating that this is an ArchBaseFlowInQueueWorkflow object.
+     * This will be true for in-queue email and in-queue short message flows.
      */
-    setPeriodicState(archState: ArchState): void;
+    readonly isArchBaseFlowInQueueWorkflow: boolean;
     /**
      * Returns the periodic state for this flow.
      */
@@ -26710,7 +29353,7 @@ export class ArchFlowInQueueEmail extends ArchBaseFlowInQueueWorkflow {
      * @param [callbackFunction] - a callback function to call if the flow was checked out.
      * @returns - while this method returns a promise, you should use the callback function to perform any processing once the flow is checked out.
      */
-    checkoutAsync(forceUnlock?: boolean, callbackFunction?: callbackVoid): Promise<any>;
+    checkoutAsync(forceUnlock?: boolean, callbackFunction?: callbackVoid): Promise<ArchFlowInfo>;
     /**
      * Returns the division associated with this flow.
      * This method first calls {@link ArchOrganizationInfo#areDivisionsAvailable} to ensure that divisions are available.
@@ -26759,7 +29402,7 @@ export class ArchFlowInQueueEmail extends ArchBaseFlowInQueueWorkflow {
      * @returns - On your promise's then handler, the first parameter passed to the then function will be this
      * flow instance.
      */
-    checkInAsync(ensureSearchable?: boolean): Promise<any>;
+    checkInAsync(ensureSearchable?: boolean): Promise<ArchBaseFlow | undefined>;
     /**
      * Creates a new flow on the server and saves its configuration
      * @returns - On your promise's then handler, the first parameter passed to the then function will be this
@@ -26848,7 +29491,7 @@ export class ArchFlowInQueueEmail extends ArchBaseFlowInQueueWorkflow {
      *                                                    on this flow.  The first parameter passed to the callback function will be this
      *                                                    Architect flow instance.
      */
-    importFromContentAsync(exportContent: string, callbackFunction?: (...params: any[]) => any): Promise<any>;
+    importFromContentAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportContent: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
     /**
      * Imports the flow content from the supplied file path.  Upon successful import, the callback function passed in
      * will be called.  Importing flow contents in to a flow is something where you should *not* attempt to
@@ -26859,7 +29502,7 @@ export class ArchFlowInQueueEmail extends ArchBaseFlowInQueueWorkflow {
      *                                        on this flow.  The first parameter passed to the callback function will be this
      *                                        Architect flow instance.
      */
-    importFromFileAsync(exportFilePath: string, callbackFunction?: (...params: any[]) => any): Promise<any>;
+    importFromFileAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportFilePath: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
     /**
      * Returns whether or not the flow is created in Genesys Cloud.
      */
@@ -27099,12 +29742,10 @@ export class ArchFlowInQueueShortMessage extends ArchBaseFlowInQueueWorkflow {
      */
     readonly isArchFlowInQueueShortMessage: boolean;
     /**
-     * Sets the specified state to be the periodic state on the in-queue
-     * email or short message flow.  Remember the same state cannot be used
-     * for both the starting state and the periodic state.
-     * @param archState - An Architect Scripting state object.
+     * Returns true indicating that this is an ArchBaseFlowInQueueWorkflow object.
+     * This will be true for in-queue email and in-queue short message flows.
      */
-    setPeriodicState(archState: ArchState): void;
+    readonly isArchBaseFlowInQueueWorkflow: boolean;
     /**
      * Returns the periodic state for this flow.
      */
@@ -27167,7 +29808,7 @@ export class ArchFlowInQueueShortMessage extends ArchBaseFlowInQueueWorkflow {
      * @param [callbackFunction] - a callback function to call if the flow was checked out.
      * @returns - while this method returns a promise, you should use the callback function to perform any processing once the flow is checked out.
      */
-    checkoutAsync(forceUnlock?: boolean, callbackFunction?: callbackVoid): Promise<any>;
+    checkoutAsync(forceUnlock?: boolean, callbackFunction?: callbackVoid): Promise<ArchFlowInfo>;
     /**
      * Returns the division associated with this flow.
      * This method first calls {@link ArchOrganizationInfo#areDivisionsAvailable} to ensure that divisions are available.
@@ -27216,7 +29857,7 @@ export class ArchFlowInQueueShortMessage extends ArchBaseFlowInQueueWorkflow {
      * @returns - On your promise's then handler, the first parameter passed to the then function will be this
      * flow instance.
      */
-    checkInAsync(ensureSearchable?: boolean): Promise<any>;
+    checkInAsync(ensureSearchable?: boolean): Promise<ArchBaseFlow | undefined>;
     /**
      * Creates a new flow on the server and saves its configuration
      * @returns - On your promise's then handler, the first parameter passed to the then function will be this
@@ -27305,7 +29946,7 @@ export class ArchFlowInQueueShortMessage extends ArchBaseFlowInQueueWorkflow {
      *                                                    on this flow.  The first parameter passed to the callback function will be this
      *                                                    Architect flow instance.
      */
-    importFromContentAsync(exportContent: string, callbackFunction?: (...params: any[]) => any): Promise<any>;
+    importFromContentAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportContent: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
     /**
      * Imports the flow content from the supplied file path.  Upon successful import, the callback function passed in
      * will be called.  Importing flow contents in to a flow is something where you should *not* attempt to
@@ -27316,7 +29957,7 @@ export class ArchFlowInQueueShortMessage extends ArchBaseFlowInQueueWorkflow {
      *                                        on this flow.  The first parameter passed to the callback function will be this
      *                                        Architect flow instance.
      */
-    importFromFileAsync(exportFilePath: string, callbackFunction?: (...params: any[]) => any): Promise<any>;
+    importFromFileAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportFilePath: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
     /**
      * Returns whether or not the flow is created in Genesys Cloud.
      */
@@ -27559,6 +30200,10 @@ export class ArchFlowInboundCall extends ArchBaseFlowInboundOutboundSecureCall {
      * The initial audio set on the flow.
      */
     readonly initialAudio: ArchAudio;
+    /**
+     * Returns true indicating that this is an ArchBaseFlowInboundOutboundSecureCall object.
+     */
+    readonly isArchBaseFlowInboundOutboundSecureCall: boolean;
     /**
      * Sets the specified menu to be the starting task on the flow.
      * @param archMenu - An Architect Scripting menu object.
@@ -27585,7 +30230,7 @@ export class ArchFlowInboundCall extends ArchBaseFlowInboundOutboundSecureCall {
      * Returns the starting task or menu for this call flow.
      * If there is no startup object configured, accessing this property returns null.
      */
-    readonly startUpObject: ArchTask | ArchMenu;
+    readonly startUpObject: ArchTask | ArchMenu | null;
     /**
      * The outbound settings for the flow such as contact list and default wrapup code.
      */
@@ -27639,7 +30284,7 @@ export class ArchFlowInboundCall extends ArchBaseFlowInboundOutboundSecureCall {
      * @param [callbackFunction] - a callback function to call if the flow was checked out.
      * @returns - while this method returns a promise, you should use the callback function to perform any processing once the flow is checked out.
      */
-    checkoutAsync(forceUnlock?: boolean, callbackFunction?: callbackVoid): Promise<any>;
+    checkoutAsync(forceUnlock?: boolean, callbackFunction?: callbackVoid): Promise<ArchFlowInfo>;
     /**
      * Returns the division associated with this flow.
      * This method first calls {@link ArchOrganizationInfo#areDivisionsAvailable} to ensure that divisions are available.
@@ -27688,7 +30333,7 @@ export class ArchFlowInboundCall extends ArchBaseFlowInboundOutboundSecureCall {
      * @returns - On your promise's then handler, the first parameter passed to the then function will be this
      * flow instance.
      */
-    checkInAsync(ensureSearchable?: boolean): Promise<any>;
+    checkInAsync(ensureSearchable?: boolean): Promise<ArchBaseFlow | undefined>;
     /**
      * Creates a new flow on the server and saves its configuration
      * @returns - On your promise's then handler, the first parameter passed to the then function will be this
@@ -27777,7 +30422,7 @@ export class ArchFlowInboundCall extends ArchBaseFlowInboundOutboundSecureCall {
      *                                                    on this flow.  The first parameter passed to the callback function will be this
      *                                                    Architect flow instance.
      */
-    importFromContentAsync(exportContent: string, callbackFunction?: (...params: any[]) => any): Promise<any>;
+    importFromContentAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportContent: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
     /**
      * Imports the flow content from the supplied file path.  Upon successful import, the callback function passed in
      * will be called.  Importing flow contents in to a flow is something where you should *not* attempt to
@@ -27788,7 +30433,7 @@ export class ArchFlowInboundCall extends ArchBaseFlowInboundOutboundSecureCall {
      *                                        on this flow.  The first parameter passed to the callback function will be this
      *                                        Architect flow instance.
      */
-    importFromFileAsync(exportFilePath: string, callbackFunction?: (...params: any[]) => any): Promise<any>;
+    importFromFileAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportFilePath: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
     /**
      * Returns whether or not the flow is created in Genesys Cloud.
      */
@@ -28085,7 +30730,7 @@ export class ArchFlowInboundChat extends ArchBaseFlowWorkflow {
      * @param [callbackFunction] - a callback function to call if the flow was checked out.
      * @returns - while this method returns a promise, you should use the callback function to perform any processing once the flow is checked out.
      */
-    checkoutAsync(forceUnlock?: boolean, callbackFunction?: callbackVoid): Promise<any>;
+    checkoutAsync(forceUnlock?: boolean, callbackFunction?: callbackVoid): Promise<ArchFlowInfo>;
     /**
      * Returns the division associated with this flow.
      * This method first calls {@link ArchOrganizationInfo#areDivisionsAvailable} to ensure that divisions are available.
@@ -28134,7 +30779,7 @@ export class ArchFlowInboundChat extends ArchBaseFlowWorkflow {
      * @returns - On your promise's then handler, the first parameter passed to the then function will be this
      * flow instance.
      */
-    checkInAsync(ensureSearchable?: boolean): Promise<any>;
+    checkInAsync(ensureSearchable?: boolean): Promise<ArchBaseFlow | undefined>;
     /**
      * Creates a new flow on the server and saves its configuration
      * @returns - On your promise's then handler, the first parameter passed to the then function will be this
@@ -28223,7 +30868,7 @@ export class ArchFlowInboundChat extends ArchBaseFlowWorkflow {
      *                                                    on this flow.  The first parameter passed to the callback function will be this
      *                                                    Architect flow instance.
      */
-    importFromContentAsync(exportContent: string, callbackFunction?: (...params: any[]) => any): Promise<any>;
+    importFromContentAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportContent: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
     /**
      * Imports the flow content from the supplied file path.  Upon successful import, the callback function passed in
      * will be called.  Importing flow contents in to a flow is something where you should *not* attempt to
@@ -28234,7 +30879,7 @@ export class ArchFlowInboundChat extends ArchBaseFlowWorkflow {
      *                                        on this flow.  The first parameter passed to the callback function will be this
      *                                        Architect flow instance.
      */
-    importFromFileAsync(exportFilePath: string, callbackFunction?: (...params: any[]) => any): Promise<any>;
+    importFromFileAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportFilePath: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
     /**
      * Returns whether or not the flow is created in Genesys Cloud.
      */
@@ -28539,7 +31184,7 @@ export class ArchFlowInboundEmail extends ArchBaseFlowWorkflow {
      * @param [callbackFunction] - a callback function to call if the flow was checked out.
      * @returns - while this method returns a promise, you should use the callback function to perform any processing once the flow is checked out.
      */
-    checkoutAsync(forceUnlock?: boolean, callbackFunction?: callbackVoid): Promise<any>;
+    checkoutAsync(forceUnlock?: boolean, callbackFunction?: callbackVoid): Promise<ArchFlowInfo>;
     /**
      * Returns the division associated with this flow.
      * This method first calls {@link ArchOrganizationInfo#areDivisionsAvailable} to ensure that divisions are available.
@@ -28588,7 +31233,7 @@ export class ArchFlowInboundEmail extends ArchBaseFlowWorkflow {
      * @returns - On your promise's then handler, the first parameter passed to the then function will be this
      * flow instance.
      */
-    checkInAsync(ensureSearchable?: boolean): Promise<any>;
+    checkInAsync(ensureSearchable?: boolean): Promise<ArchBaseFlow | undefined>;
     /**
      * Creates a new flow on the server and saves its configuration
      * @returns - On your promise's then handler, the first parameter passed to the then function will be this
@@ -28677,7 +31322,7 @@ export class ArchFlowInboundEmail extends ArchBaseFlowWorkflow {
      *                                                    on this flow.  The first parameter passed to the callback function will be this
      *                                                    Architect flow instance.
      */
-    importFromContentAsync(exportContent: string, callbackFunction?: (...params: any[]) => any): Promise<any>;
+    importFromContentAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportContent: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
     /**
      * Imports the flow content from the supplied file path.  Upon successful import, the callback function passed in
      * will be called.  Importing flow contents in to a flow is something where you should *not* attempt to
@@ -28688,7 +31333,7 @@ export class ArchFlowInboundEmail extends ArchBaseFlowWorkflow {
      *                                        on this flow.  The first parameter passed to the callback function will be this
      *                                        Architect flow instance.
      */
-    importFromFileAsync(exportFilePath: string, callbackFunction?: (...params: any[]) => any): Promise<any>;
+    importFromFileAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportFilePath: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
     /**
      * Returns whether or not the flow is created in Genesys Cloud.
      */
@@ -28985,7 +31630,7 @@ export class ArchFlowInboundShortMessage extends ArchBaseFlowWorkflow {
      * @param [callbackFunction] - a callback function to call if the flow was checked out.
      * @returns - while this method returns a promise, you should use the callback function to perform any processing once the flow is checked out.
      */
-    checkoutAsync(forceUnlock?: boolean, callbackFunction?: callbackVoid): Promise<any>;
+    checkoutAsync(forceUnlock?: boolean, callbackFunction?: callbackVoid): Promise<ArchFlowInfo>;
     /**
      * Returns the division associated with this flow.
      * This method first calls {@link ArchOrganizationInfo#areDivisionsAvailable} to ensure that divisions are available.
@@ -29034,7 +31679,7 @@ export class ArchFlowInboundShortMessage extends ArchBaseFlowWorkflow {
      * @returns - On your promise's then handler, the first parameter passed to the then function will be this
      * flow instance.
      */
-    checkInAsync(ensureSearchable?: boolean): Promise<any>;
+    checkInAsync(ensureSearchable?: boolean): Promise<ArchBaseFlow | undefined>;
     /**
      * Creates a new flow on the server and saves its configuration
      * @returns - On your promise's then handler, the first parameter passed to the then function will be this
@@ -29123,7 +31768,7 @@ export class ArchFlowInboundShortMessage extends ArchBaseFlowWorkflow {
      *                                                    on this flow.  The first parameter passed to the callback function will be this
      *                                                    Architect flow instance.
      */
-    importFromContentAsync(exportContent: string, callbackFunction?: (...params: any[]) => any): Promise<any>;
+    importFromContentAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportContent: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
     /**
      * Imports the flow content from the supplied file path.  Upon successful import, the callback function passed in
      * will be called.  Importing flow contents in to a flow is something where you should *not* attempt to
@@ -29134,7 +31779,7 @@ export class ArchFlowInboundShortMessage extends ArchBaseFlowWorkflow {
      *                                        on this flow.  The first parameter passed to the callback function will be this
      *                                        Architect flow instance.
      */
-    importFromFileAsync(exportFilePath: string, callbackFunction?: (...params: any[]) => any): Promise<any>;
+    importFromFileAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportFilePath: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
     /**
      * Returns whether or not the flow is created in Genesys Cloud.
      */
@@ -29724,6 +32369,10 @@ export class ArchFlowOutboundCall extends ArchBaseFlowInboundOutboundSecureCall
      * The initial audio set on the flow.
      */
     readonly initialAudio: ArchAudio;
+    /**
+     * Returns true indicating that this is an ArchBaseFlowInboundOutboundSecureCall object.
+     */
+    readonly isArchBaseFlowInboundOutboundSecureCall: boolean;
     /**
      * Sets the specified menu to be the starting task on the flow.
      * @param archMenu - An Architect Scripting menu object.
@@ -29750,7 +32399,7 @@ export class ArchFlowOutboundCall extends ArchBaseFlowInboundOutboundSecureCall
      * Returns the starting task or menu for this call flow.
      * If there is no startup object configured, accessing this property returns null.
      */
-    readonly startUpObject: ArchTask | ArchMenu;
+    readonly startUpObject: ArchTask | ArchMenu | null;
     /**
      * The outbound settings for the flow such as contact list and default wrapup code.
      */
@@ -29804,7 +32453,7 @@ export class ArchFlowOutboundCall extends ArchBaseFlowInboundOutboundSecureCall
      * @param [callbackFunction] - a callback function to call if the flow was checked out.
      * @returns - while this method returns a promise, you should use the callback function to perform any processing once the flow is checked out.
      */
-    checkoutAsync(forceUnlock?: boolean, callbackFunction?: callbackVoid): Promise<any>;
+    checkoutAsync(forceUnlock?: boolean, callbackFunction?: callbackVoid): Promise<ArchFlowInfo>;
     /**
      * Returns the division associated with this flow.
      * This method first calls {@link ArchOrganizationInfo#areDivisionsAvailable} to ensure that divisions are available.
@@ -29853,7 +32502,7 @@ export class ArchFlowOutboundCall extends ArchBaseFlowInboundOutboundSecureCall
      * @returns - On your promise's then handler, the first parameter passed to the then function will be this
      * flow instance.
      */
-    checkInAsync(ensureSearchable?: boolean): Promise<any>;
+    checkInAsync(ensureSearchable?: boolean): Promise<ArchBaseFlow | undefined>;
     /**
      * Creates a new flow on the server and saves its configuration
      * @returns - On your promise's then handler, the first parameter passed to the then function will be this
@@ -29942,7 +32591,7 @@ export class ArchFlowOutboundCall extends ArchBaseFlowInboundOutboundSecureCall
      *                                                    on this flow.  The first parameter passed to the callback function will be this
      *                                                    Architect flow instance.
      */
-    importFromContentAsync(exportContent: string, callbackFunction?: (...params: any[]) => any): Promise<any>;
+    importFromContentAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportContent: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
     /**
      * Imports the flow content from the supplied file path.  Upon successful import, the callback function passed in
      * will be called.  Importing flow contents in to a flow is something where you should *not* attempt to
@@ -29953,7 +32602,7 @@ export class ArchFlowOutboundCall extends ArchBaseFlowInboundOutboundSecureCall
      *                                        on this flow.  The first parameter passed to the callback function will be this
      *                                        Architect flow instance.
      */
-    importFromFileAsync(exportFilePath: string, callbackFunction?: (...params: any[]) => any): Promise<any>;
+    importFromFileAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportFilePath: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
     /**
      * Returns whether or not the flow is created in Genesys Cloud.
      */
@@ -30196,6 +32845,10 @@ export class ArchFlowSecureCall extends ArchBaseFlowInboundOutboundSecureCall {
      * The initial audio set on the flow.
      */
     readonly initialAudio: ArchAudio;
+    /**
+     * Returns true indicating that this is an ArchBaseFlowInboundOutboundSecureCall object.
+     */
+    readonly isArchBaseFlowInboundOutboundSecureCall: boolean;
     /**
      * Sets the specified menu to be the starting task on the flow.
      * @param archMenu - An Architect Scripting menu object.
@@ -30222,7 +32875,7 @@ export class ArchFlowSecureCall extends ArchBaseFlowInboundOutboundSecureCall {
      * Returns the starting task or menu for this call flow.
      * If there is no startup object configured, accessing this property returns null.
      */
-    readonly startUpObject: ArchTask | ArchMenu;
+    readonly startUpObject: ArchTask | ArchMenu | null;
     /**
      * The outbound settings for the flow such as contact list and default wrapup code.
      */
@@ -30276,7 +32929,7 @@ export class ArchFlowSecureCall extends ArchBaseFlowInboundOutboundSecureCall {
      * @param [callbackFunction] - a callback function to call if the flow was checked out.
      * @returns - while this method returns a promise, you should use the callback function to perform any processing once the flow is checked out.
      */
-    checkoutAsync(forceUnlock?: boolean, callbackFunction?: callbackVoid): Promise<any>;
+    checkoutAsync(forceUnlock?: boolean, callbackFunction?: callbackVoid): Promise<ArchFlowInfo>;
     /**
      * Returns the division associated with this flow.
      * This method first calls {@link ArchOrganizationInfo#areDivisionsAvailable} to ensure that divisions are available.
@@ -30325,7 +32978,7 @@ export class ArchFlowSecureCall extends ArchBaseFlowInboundOutboundSecureCall {
      * @returns - On your promise's then handler, the first parameter passed to the then function will be this
      * flow instance.
      */
-    checkInAsync(ensureSearchable?: boolean): Promise<any>;
+    checkInAsync(ensureSearchable?: boolean): Promise<ArchBaseFlow | undefined>;
     /**
      * Creates a new flow on the server and saves its configuration
      * @returns - On your promise's then handler, the first parameter passed to the then function will be this
@@ -30414,7 +33067,7 @@ export class ArchFlowSecureCall extends ArchBaseFlowInboundOutboundSecureCall {
      *                                                    on this flow.  The first parameter passed to the callback function will be this
      *                                                    Architect flow instance.
      */
-    importFromContentAsync(exportContent: string, callbackFunction?: (...params: any[]) => any): Promise<any>;
+    importFromContentAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportContent: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
     /**
      * Imports the flow content from the supplied file path.  Upon successful import, the callback function passed in
      * will be called.  Importing flow contents in to a flow is something where you should *not* attempt to
@@ -30425,7 +33078,7 @@ export class ArchFlowSecureCall extends ArchBaseFlowInboundOutboundSecureCall {
      *                                        on this flow.  The first parameter passed to the callback function will be this
      *                                        Architect flow instance.
      */
-    importFromFileAsync(exportFilePath: string, callbackFunction?: (...params: any[]) => any): Promise<any>;
+    importFromFileAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportFilePath: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
     /**
      * Returns whether or not the flow is created in Genesys Cloud.
      */
@@ -30722,7 +33375,7 @@ export class ArchFlowSurveyInvite extends ArchBaseFlowWorkflow {
      * @param [callbackFunction] - a callback function to call if the flow was checked out.
      * @returns - while this method returns a promise, you should use the callback function to perform any processing once the flow is checked out.
      */
-    checkoutAsync(forceUnlock?: boolean, callbackFunction?: callbackVoid): Promise<any>;
+    checkoutAsync(forceUnlock?: boolean, callbackFunction?: callbackVoid): Promise<ArchFlowInfo>;
     /**
      * Returns the division associated with this flow.
      * This method first calls {@link ArchOrganizationInfo#areDivisionsAvailable} to ensure that divisions are available.
@@ -30771,7 +33424,7 @@ export class ArchFlowSurveyInvite extends ArchBaseFlowWorkflow {
      * @returns - On your promise's then handler, the first parameter passed to the then function will be this
      * flow instance.
      */
-    checkInAsync(ensureSearchable?: boolean): Promise<any>;
+    checkInAsync(ensureSearchable?: boolean): Promise<ArchBaseFlow | undefined>;
     /**
      * Creates a new flow on the server and saves its configuration
      * @returns - On your promise's then handler, the first parameter passed to the then function will be this
@@ -30860,7 +33513,7 @@ export class ArchFlowSurveyInvite extends ArchBaseFlowWorkflow {
      *                                                    on this flow.  The first parameter passed to the callback function will be this
      *                                                    Architect flow instance.
      */
-    importFromContentAsync(exportContent: string, callbackFunction?: (...params: any[]) => any): Promise<any>;
+    importFromContentAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportContent: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
     /**
      * Imports the flow content from the supplied file path.  Upon successful import, the callback function passed in
      * will be called.  Importing flow contents in to a flow is something where you should *not* attempt to
@@ -30871,7 +33524,7 @@ export class ArchFlowSurveyInvite extends ArchBaseFlowWorkflow {
      *                                        on this flow.  The first parameter passed to the callback function will be this
      *                                        Architect flow instance.
      */
-    importFromFileAsync(exportFilePath: string, callbackFunction?: (...params: any[]) => any): Promise<any>;
+    importFromFileAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportFilePath: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
     /**
      * Returns whether or not the flow is created in Genesys Cloud.
      */
@@ -31194,7 +33847,7 @@ export class ArchFlowVoiceSurvey extends ArchBaseFlowBot {
      * @param [callbackFunction] - a callback function to call if the flow was checked out.
      * @returns - while this method returns a promise, you should use the callback function to perform any processing once the flow is checked out.
      */
-    checkoutAsync(forceUnlock?: boolean, callbackFunction?: callbackVoid): Promise<any>;
+    checkoutAsync(forceUnlock?: boolean, callbackFunction?: callbackVoid): Promise<ArchFlowInfo>;
     /**
      * Returns the division associated with this flow.
      * This method first calls {@link ArchOrganizationInfo#areDivisionsAvailable} to ensure that divisions are available.
@@ -31243,7 +33896,7 @@ export class ArchFlowVoiceSurvey extends ArchBaseFlowBot {
      * @returns - On your promise's then handler, the first parameter passed to the then function will be this
      * flow instance.
      */
-    checkInAsync(ensureSearchable?: boolean): Promise<any>;
+    checkInAsync(ensureSearchable?: boolean): Promise<ArchBaseFlow | undefined>;
     /**
      * Creates a new flow on the server and saves its configuration
      * @returns - On your promise's then handler, the first parameter passed to the then function will be this
@@ -31332,7 +33985,7 @@ export class ArchFlowVoiceSurvey extends ArchBaseFlowBot {
      *                                                    on this flow.  The first parameter passed to the callback function will be this
      *                                                    Architect flow instance.
      */
-    importFromContentAsync(exportContent: string, callbackFunction?: (...params: any[]) => any): Promise<any>;
+    importFromContentAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportContent: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
     /**
      * Imports the flow content from the supplied file path.  Upon successful import, the callback function passed in
      * will be called.  Importing flow contents in to a flow is something where you should *not* attempt to
@@ -31343,7 +33996,7 @@ export class ArchFlowVoiceSurvey extends ArchBaseFlowBot {
      *                                        on this flow.  The first parameter passed to the callback function will be this
      *                                        Architect flow instance.
      */
-    importFromFileAsync(exportFilePath: string, callbackFunction?: (...params: any[]) => any): Promise<any>;
+    importFromFileAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportFilePath: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
     /**
      * Returns whether or not the flow is created in Genesys Cloud.
      */
@@ -31582,6 +34235,10 @@ export class ArchFlowVoicemail extends ArchBaseFlowInboundOutboundSecureCall {
      * The initial audio set on the flow.
      */
     readonly initialAudio: ArchAudio;
+    /**
+     * Returns true indicating that this is an ArchBaseFlowInboundOutboundSecureCall object.
+     */
+    readonly isArchBaseFlowInboundOutboundSecureCall: boolean;
     /**
      * Sets the specified menu to be the starting task on the flow.
      * @param archMenu - An Architect Scripting menu object.
@@ -31608,7 +34265,7 @@ export class ArchFlowVoicemail extends ArchBaseFlowInboundOutboundSecureCall {
      * Returns the starting task or menu for this call flow.
      * If there is no startup object configured, accessing this property returns null.
      */
-    readonly startUpObject: ArchTask | ArchMenu;
+    readonly startUpObject: ArchTask | ArchMenu | null;
     /**
      * The outbound settings for the flow such as contact list and default wrapup code.
      */
@@ -31662,7 +34319,7 @@ export class ArchFlowVoicemail extends ArchBaseFlowInboundOutboundSecureCall {
      * @param [callbackFunction] - a callback function to call if the flow was checked out.
      * @returns - while this method returns a promise, you should use the callback function to perform any processing once the flow is checked out.
      */
-    checkoutAsync(forceUnlock?: boolean, callbackFunction?: callbackVoid): Promise<any>;
+    checkoutAsync(forceUnlock?: boolean, callbackFunction?: callbackVoid): Promise<ArchFlowInfo>;
     /**
      * Returns the division associated with this flow.
      * This method first calls {@link ArchOrganizationInfo#areDivisionsAvailable} to ensure that divisions are available.
@@ -31711,7 +34368,7 @@ export class ArchFlowVoicemail extends ArchBaseFlowInboundOutboundSecureCall {
      * @returns - On your promise's then handler, the first parameter passed to the then function will be this
      * flow instance.
      */
-    checkInAsync(ensureSearchable?: boolean): Promise<any>;
+    checkInAsync(ensureSearchable?: boolean): Promise<ArchBaseFlow | undefined>;
     /**
      * Creates a new flow on the server and saves its configuration
      * @returns - On your promise's then handler, the first parameter passed to the then function will be this
@@ -31800,7 +34457,7 @@ export class ArchFlowVoicemail extends ArchBaseFlowInboundOutboundSecureCall {
      *                                                    on this flow.  The first parameter passed to the callback function will be this
      *                                                    Architect flow instance.
      */
-    importFromContentAsync(exportContent: string, callbackFunction?: (...params: any[]) => any): Promise<any>;
+    importFromContentAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportContent: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
     /**
      * Imports the flow content from the supplied file path.  Upon successful import, the callback function passed in
      * will be called.  Importing flow contents in to a flow is something where you should *not* attempt to
@@ -31811,7 +34468,7 @@ export class ArchFlowVoicemail extends ArchBaseFlowInboundOutboundSecureCall {
      *                                        on this flow.  The first parameter passed to the callback function will be this
      *                                        Architect flow instance.
      */
-    importFromFileAsync(exportFilePath: string, callbackFunction?: (...params: any[]) => any): Promise<any>;
+    importFromFileAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportFilePath: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
     /**
      * Returns whether or not the flow is created in Genesys Cloud.
      */
@@ -32108,7 +34765,7 @@ export class ArchFlowWorkflow extends ArchBaseFlowWorkflow {
      * @param [callbackFunction] - a callback function to call if the flow was checked out.
      * @returns - while this method returns a promise, you should use the callback function to perform any processing once the flow is checked out.
      */
-    checkoutAsync(forceUnlock?: boolean, callbackFunction?: callbackVoid): Promise<any>;
+    checkoutAsync(forceUnlock?: boolean, callbackFunction?: callbackVoid): Promise<ArchFlowInfo>;
     /**
      * Returns the division associated with this flow.
      * This method first calls {@link ArchOrganizationInfo#areDivisionsAvailable} to ensure that divisions are available.
@@ -32157,7 +34814,7 @@ export class ArchFlowWorkflow extends ArchBaseFlowWorkflow {
      * @returns - On your promise's then handler, the first parameter passed to the then function will be this
      * flow instance.
      */
-    checkInAsync(ensureSearchable?: boolean): Promise<any>;
+    checkInAsync(ensureSearchable?: boolean): Promise<ArchBaseFlow | undefined>;
     /**
      * Creates a new flow on the server and saves its configuration
      * @returns - On your promise's then handler, the first parameter passed to the then function will be this
@@ -32246,7 +34903,7 @@ export class ArchFlowWorkflow extends ArchBaseFlowWorkflow {
      *                                                    on this flow.  The first parameter passed to the callback function will be this
      *                                                    Architect flow instance.
      */
-    importFromContentAsync(exportContent: string, callbackFunction?: (...params: any[]) => any): Promise<any>;
+    importFromContentAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportContent: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
     /**
      * Imports the flow content from the supplied file path.  Upon successful import, the callback function passed in
      * will be called.  Importing flow contents in to a flow is something where you should *not* attempt to
@@ -32257,7 +34914,7 @@ export class ArchFlowWorkflow extends ArchBaseFlowWorkflow {
      *                                        on this flow.  The first parameter passed to the callback function will be this
      *                                        Architect flow instance.
      */
-    importFromFileAsync(exportFilePath: string, callbackFunction?: (...params: any[]) => any): Promise<any>;
+    importFromFileAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportFilePath: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
     /**
      * Returns whether or not the flow is created in Genesys Cloud.
      */
@@ -32558,7 +35215,7 @@ export class ArchFlowWorkitem extends ArchBaseFlowWorkflow {
      * @param [callbackFunction] - a callback function to call if the flow was checked out.
      * @returns - while this method returns a promise, you should use the callback function to perform any processing once the flow is checked out.
      */
-    checkoutAsync(forceUnlock?: boolean, callbackFunction?: callbackVoid): Promise<any>;
+    checkoutAsync(forceUnlock?: boolean, callbackFunction?: callbackVoid): Promise<ArchFlowInfo>;
     /**
      * Returns the division associated with this flow.
      * This method first calls {@link ArchOrganizationInfo#areDivisionsAvailable} to ensure that divisions are available.
@@ -32607,7 +35264,7 @@ export class ArchFlowWorkitem extends ArchBaseFlowWorkflow {
      * @returns - On your promise's then handler, the first parameter passed to the then function will be this
      * flow instance.
      */
-    checkInAsync(ensureSearchable?: boolean): Promise<any>;
+    checkInAsync(ensureSearchable?: boolean): Promise<ArchBaseFlow | undefined>;
     /**
      * Creates a new flow on the server and saves its configuration
      * @returns - On your promise's then handler, the first parameter passed to the then function will be this
@@ -32696,7 +35353,7 @@ export class ArchFlowWorkitem extends ArchBaseFlowWorkflow {
      *                                                    on this flow.  The first parameter passed to the callback function will be this
      *                                                    Architect flow instance.
      */
-    importFromContentAsync(exportContent: string, callbackFunction?: (...params: any[]) => any): Promise<any>;
+    importFromContentAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportContent: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
     /**
      * Imports the flow content from the supplied file path.  Upon successful import, the callback function passed in
      * will be called.  Importing flow contents in to a flow is something where you should *not* attempt to
@@ -32707,7 +35364,7 @@ export class ArchFlowWorkitem extends ArchBaseFlowWorkflow {
      *                                        on this flow.  The first parameter passed to the callback function will be this
      *                                        Architect flow instance.
      */
-    importFromFileAsync(exportFilePath: string, callbackFunction?: (...params: any[]) => any): Promise<any>;
+    importFromFileAsync<T extends ArchBaseFlow = ArchBaseFlow>(exportFilePath: string, callbackFunction?: (...params: any[]) => any): Promise<T>;
     /**
      * Returns whether or not the flow is created in Genesys Cloud.
      */
@@ -34265,7 +36922,7 @@ export class ArchSettingsDetectionJobIntent extends ArchBaseObject {
     /**
      * Returns true indicating that this is an ArchSettingsDetectionJobIntent instance.
      */
-    readonly isArchSettingsDetectionJobIntent: any;
+    readonly isArchSettingsDetectionJobIntent: boolean;
     /**
      * A string suitable for logging that contains information about this ArchSettingsDetectionJobIntent.
      */
@@ -34737,8 +37394,9 @@ export class ArchSettingsNluIntent extends ArchBaseObject {
      * Associates the given reusable task with the current {@link ArchSettingsNluIntent}. When you associate an intent with a task with input values in a digital flow,
      * and the task is invoked, the runtime will not supply any values for them so any input variables will pick up their
      * default values.
+     * @param archReusableTask - the {@link ArchTask} to associate with this intent
      */
-    associateWithTask: any;
+    associateWithTask(archReusableTask: ArchTask): void;
     /**
      * Returns the {@link ArchTask} that is associated with this {@link ArchSettingsNluIntent}. If one is not associated with
      * this intent or a task is not found, undefined is returned.
@@ -37152,7 +39810,6 @@ export class ArchTtsEngine extends ArchBaseCoreObjectWithId {
  * property to see if your organization supports this functionality.
  */
 export class ArchTtsEngines extends ArchBaseObject {
-    // constructor();
     /**
      * A logging string for the ArchTtsEngines instance.
      */
@@ -37406,17 +40063,9 @@ export class ArchTraverseSettings {
     shouldContinue: boolean;
 }
 
-/**
- * Creates an instance of an ArchValidationIssue object.
- * This object holds validation error and warning information for an object in a flow.  The archObject property
- * will point to the Architect Scripting object for which this issue object is for.  You can then look at the
- * errors or warnings for that object by accessing the error or warning properties on this class.
- * Instances of this object will be created by Architect Scripting when the {@link ArchBaseFlow#validateAsync} method
- * is called and will be returned in the [validation results]{@link ArchValidationResults} returned from that call.
- * @param coreValidationIssue - ( *Internal* ) an Architect core validation issue object
- */
 export class ArchValidationIssue extends ArchBaseCoreObject {
     // constructor(coreValidationIssue: any);
+    readonly isArchValidationIssue: boolean;
     /**
      * Returns the display type name string 'ArchValidationIssue'.
      */
@@ -37483,7 +40132,6 @@ export class ArchValidationIssue extends ArchBaseCoreObject {
      * @param [prefix] - a string to prefix before each line in the returned string.
      */
     getSummaryStr(wantDetails: boolean, prefix?: string): string;
-    readonly isArchValidationIssue: boolean;
     /**
      * The count of rollup errors for this issue.
      */
@@ -37508,17 +40156,136 @@ export class ArchValidationIssue extends ArchBaseCoreObject {
      * Returns a string array of warnings in this issue.  If there are no warnings, no value is returned.
      */
     readonly warnings: string[];
+    /**
+     * Returns true indicating that this is an ArchBaseCoreObject instance.
+     */
+    readonly isArchBaseCoreObject: boolean;
+    /**
+     * This method iterates over this object and ArchBaseCoreObject instances
+     * within it.  For each object it will call the {@link ArchBaseObject#isFilterMatch} method
+     * with a filter and call the supplied callback function if isMatch returns true.
+     * The callback will be passed an {@link ArchTraverseInfo} with details
+     * about the match such as the match object itself along with current contextual
+     * information such as the object hierarchy for the match object relative to
+     * the object on which this traverse call is being made.
+     *
+     * The traverse [filter]{@link ArchFilterObject} is one which you can create
+     * by calling {@link ArchFactoryFilters#createFilterObject} and then add desired clauses
+     * or clause containers to it.  If not specified, this function will use a
+     * [default filter]{@link ArchFactoryFilters#createFilterTraverseDefault}.
+     *
+     * Here is an example that does a simple flow traversal using the default
+     * filter and logs information about objects in the callback from the
+     * traverse object that's passed back:
+     *
+     * ```
+     * archInboundCallFlow.traverse(function(traverseInfo) {
+     *    archLogging.logNote('  Object     : ' + traverseInfo.matchObject.logStr);
+     *    archLogging.logNote('    Hierarchy: ' + traverseInfo.context.hierarchyStr);
+     * });
+     * ```
+     * This might be enough for most uses and you can check various aspects
+     * about the object in the callback such as "is this an Architect action?" by
+     * seeing if traverseInfo.matchObject.isArchBaseAction is true.  You can specify
+     * a filter for the traversal code to use as well and only have it call your
+     * callback when the object's {@link ArchBaseCoreObject#isFilterMatch} method returns true for
+     * the filter.  Here's an example that creates a filter for callbacks on
+     * [any type of transfer action]{@link ArchBaseActionTransfer}, any
+     * [decision action]{@link ArchActionDecision} or objects whose name
+     * property case insensitively matches the word 'foo'.  While this could all be done
+     * with one property callback clause the example will use multiple clauses for
+     * the sake of simplicity:
+     * ```
+     * const myTraverseFilter = filterFactory.createFilterObject(archEnums.FILTER_CONTAINER_OPERATORS.or);
+     * myTraverseFilter.addClausePropertyValueEquals('isArchBaseActionTransfer', true);
+     * myTraverseFilter.addClausePropertyValueEquals('isArchActionDecision',     true);
+     * myTraverseFilter.addClausePropertyCallback('name', function(propValue, archContainingObject, propName) {
+     *       // We fully spelled out the function signature above but archContainingObject and propName are
+     *       // not needed in this case.  The archContainingObject is the object that contains the
+     *       // property and propName is the property name itself.  We pass in propName because the same
+     *       // function could be used for multiple property callback clauses.
+     *       // Remember to return a boolean true, false or undefined from ths callback.  :)
+     *       return propValue && propValue.toLowerCase() === 'foo';
+     * });
+     * archTask.traverse(function(traverseContext) {
+     *    // You will only be called back here for ArchBaseCoreObject instances that
+     *    // have the isArchBaseActionTransfer or isArchActionDecision property values equal to true.
+     * }, myTraverseFilter);
+     * ```
+     * If you supply a filter with no clauses, this tells the traverse method to
+     * call the supplied callback function for every {@link ArchBaseCoreObject} it traverses.
+     *
+     * If you want traversal itself to stop after a callback, simply return boolean
+     * false from the callback function you supply to the traverse call.
+     *
+     * The traverse method does not process deprecated property names such as [orgId]{@link ArchSession#orgId},
+     * [orgName]{@link ArchSession#orgName} or [languageSettings]{@link ArchBaseFlow#languageSettings}.  Additionally
+     * it does not traverse in to properties that would "jump out" of the current traversal.  An example of this
+     * would be if the code was traversing an {@link ArchActionJumpToMenu} action that it would not start traversing
+     * in to the menu that it jumps to.  Another example would be a {@link ArchActionChangeState} action where
+     * it would not traverse in to the target state of the action.  This also means traversal does not traverse
+     * in to the {@link ArchBaseValue#flowLevelDefault} property.
+     *
+     * And lastly, as Scripting evolves over time with new versions, you can expect to get callbacks for new object
+     * types such as new actions or new properties on objects.  As such, it's important not to assume any particular
+     * order in callbacks to keep code most compatible with traversal callbacks.  Or if you use inequality checks in filter
+     * clauses remember that new "stuff" may satisfy an inequality check which may or may not be anticipated in your logic.
+     *
+     * Note:  This traverse method is a helper method and is very handy for iterating over Architect Scripting
+     * objects and their properties in a generic fashion with filtering capabilities.  Obviously you can write
+     * your own custom traversal code if this implementation doesn't cut it for some reason. :)
+     *
+     * This function returns the number of times it called the callback function.
+     * @param callbackFunction - the callback function to call for objects that match the traverse filter.
+     * @param [traverseFilter = {@link ArchFactoryFilters#createFilterTraverseDefault}] - the filter to use when performing the traversal to determine which
+     *                                              {@link ArchBaseCoreObject} instances you wish to be called back for.  If no
+     *                                              filter is specified, this function will call {@link ArchFactoryFilters#createFilterTraverseDefault} and
+     *                                              use that traversal default filter.  The wantArchBaseValues parameter on that call is set to true.
+     */
+    traverse(callbackFunction: callbackTraverseInfo, traverseFilter?: ArchFilterObject): number;
+    /**
+     * This is a string suitable for logging information about this object where it's just the object's type.  This is normally used
+     * when logging errors that occur in constructor parameter checking because the scripting object isn't set up and the normal
+     * logging str contents wouldn't be set up.
+     */
+    readonly logStrTypeOnly: string;
+    /**
+     * Logs an error to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logErrors} is true.
+     * @param errorStr - the error string to log.
+     */
+    logError(errorStr: string): void;
+    /**
+     * Logs an error to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logErrors} is true and then throws
+     * the string in the errorStr parameter.
+     * @param errorStr - the error string to log.  This should be a non-blank string.
+     */
+    logErrorAndThrow(errorStr: string): void;
+    /**
+     * Logs a note to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logNotes} is true.
+     * @param noteStr - the note string to log.  This should be a non-blank string.
+     */
+    logNote(noteStr: string): void;
+    /**
+     * Logs a note to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logNotesVerbose} is true.
+     * @param noteStr - the note string to log.  This should be a non-blank string.
+     */
+    logNoteVerbose(noteStr: string): void;
+    /**
+     * Logs a warning to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logWarnings} is true.
+     * @param warningStr - the warning string to log.  This should be a non-blank string.
+     */
+    logWarning(warningStr: string): void;
+    /**
+     * Returns whether or not this Architect Scripting object is a match
+     * for the supplied ArchFilterObject instance.
+     * @param archFilterObject - the object filter to use to determine if it's a match.
+     */
+    isFilterMatch(archFilterObject: ArchFilterObject): boolean;
 }
 
-/**
- * Creates an instance of an ArchValidationResults object.  The validation results object will be returned
- * from flow [validation]{@link ArchBaseFlow#validateAsync} and contain information about warnings and errors that were reported during validation.
- * There are issues within this results object that can further be accessed to get at more specifics about
- * errors, warnings and the Architect Scripting objects they're associated with.
- * @param coreValidationResultsViewModel - *Internal* The core validation results object
- */
 export class ArchValidationResults extends ArchBaseCoreObject {
     // constructor(coreValidationResultsViewModel: any);
+    readonly isArchValidationResults: boolean;
     /**
      * Returns the display type name string 'ArchValidationResults'.
      */
@@ -37684,7 +40451,131 @@ export class ArchValidationResults extends ArchBaseCoreObject {
      * and adding up the warningCount property for each validation issue.
      */
     readonly warningCountTotal: number;
-    readonly isArchValidationResults: boolean;
+    /**
+     * Returns true indicating that this is an ArchBaseCoreObject instance.
+     */
+    readonly isArchBaseCoreObject: boolean;
+    /**
+     * This method iterates over this object and ArchBaseCoreObject instances
+     * within it.  For each object it will call the {@link ArchBaseObject#isFilterMatch} method
+     * with a filter and call the supplied callback function if isMatch returns true.
+     * The callback will be passed an {@link ArchTraverseInfo} with details
+     * about the match such as the match object itself along with current contextual
+     * information such as the object hierarchy for the match object relative to
+     * the object on which this traverse call is being made.
+     *
+     * The traverse [filter]{@link ArchFilterObject} is one which you can create
+     * by calling {@link ArchFactoryFilters#createFilterObject} and then add desired clauses
+     * or clause containers to it.  If not specified, this function will use a
+     * [default filter]{@link ArchFactoryFilters#createFilterTraverseDefault}.
+     *
+     * Here is an example that does a simple flow traversal using the default
+     * filter and logs information about objects in the callback from the
+     * traverse object that's passed back:
+     *
+     * ```
+     * archInboundCallFlow.traverse(function(traverseInfo) {
+     *    archLogging.logNote('  Object     : ' + traverseInfo.matchObject.logStr);
+     *    archLogging.logNote('    Hierarchy: ' + traverseInfo.context.hierarchyStr);
+     * });
+     * ```
+     * This might be enough for most uses and you can check various aspects
+     * about the object in the callback such as "is this an Architect action?" by
+     * seeing if traverseInfo.matchObject.isArchBaseAction is true.  You can specify
+     * a filter for the traversal code to use as well and only have it call your
+     * callback when the object's {@link ArchBaseCoreObject#isFilterMatch} method returns true for
+     * the filter.  Here's an example that creates a filter for callbacks on
+     * [any type of transfer action]{@link ArchBaseActionTransfer}, any
+     * [decision action]{@link ArchActionDecision} or objects whose name
+     * property case insensitively matches the word 'foo'.  While this could all be done
+     * with one property callback clause the example will use multiple clauses for
+     * the sake of simplicity:
+     * ```
+     * const myTraverseFilter = filterFactory.createFilterObject(archEnums.FILTER_CONTAINER_OPERATORS.or);
+     * myTraverseFilter.addClausePropertyValueEquals('isArchBaseActionTransfer', true);
+     * myTraverseFilter.addClausePropertyValueEquals('isArchActionDecision',     true);
+     * myTraverseFilter.addClausePropertyCallback('name', function(propValue, archContainingObject, propName) {
+     *       // We fully spelled out the function signature above but archContainingObject and propName are
+     *       // not needed in this case.  The archContainingObject is the object that contains the
+     *       // property and propName is the property name itself.  We pass in propName because the same
+     *       // function could be used for multiple property callback clauses.
+     *       // Remember to return a boolean true, false or undefined from ths callback.  :)
+     *       return propValue && propValue.toLowerCase() === 'foo';
+     * });
+     * archTask.traverse(function(traverseContext) {
+     *    // You will only be called back here for ArchBaseCoreObject instances that
+     *    // have the isArchBaseActionTransfer or isArchActionDecision property values equal to true.
+     * }, myTraverseFilter);
+     * ```
+     * If you supply a filter with no clauses, this tells the traverse method to
+     * call the supplied callback function for every {@link ArchBaseCoreObject} it traverses.
+     *
+     * If you want traversal itself to stop after a callback, simply return boolean
+     * false from the callback function you supply to the traverse call.
+     *
+     * The traverse method does not process deprecated property names such as [orgId]{@link ArchSession#orgId},
+     * [orgName]{@link ArchSession#orgName} or [languageSettings]{@link ArchBaseFlow#languageSettings}.  Additionally
+     * it does not traverse in to properties that would "jump out" of the current traversal.  An example of this
+     * would be if the code was traversing an {@link ArchActionJumpToMenu} action that it would not start traversing
+     * in to the menu that it jumps to.  Another example would be a {@link ArchActionChangeState} action where
+     * it would not traverse in to the target state of the action.  This also means traversal does not traverse
+     * in to the {@link ArchBaseValue#flowLevelDefault} property.
+     *
+     * And lastly, as Scripting evolves over time with new versions, you can expect to get callbacks for new object
+     * types such as new actions or new properties on objects.  As such, it's important not to assume any particular
+     * order in callbacks to keep code most compatible with traversal callbacks.  Or if you use inequality checks in filter
+     * clauses remember that new "stuff" may satisfy an inequality check which may or may not be anticipated in your logic.
+     *
+     * Note:  This traverse method is a helper method and is very handy for iterating over Architect Scripting
+     * objects and their properties in a generic fashion with filtering capabilities.  Obviously you can write
+     * your own custom traversal code if this implementation doesn't cut it for some reason. :)
+     *
+     * This function returns the number of times it called the callback function.
+     * @param callbackFunction - the callback function to call for objects that match the traverse filter.
+     * @param [traverseFilter = {@link ArchFactoryFilters#createFilterTraverseDefault}] - the filter to use when performing the traversal to determine which
+     *                                              {@link ArchBaseCoreObject} instances you wish to be called back for.  If no
+     *                                              filter is specified, this function will call {@link ArchFactoryFilters#createFilterTraverseDefault} and
+     *                                              use that traversal default filter.  The wantArchBaseValues parameter on that call is set to true.
+     */
+    traverse(callbackFunction: callbackTraverseInfo, traverseFilter?: ArchFilterObject): number;
+    /**
+     * This is a string suitable for logging information about this object where it's just the object's type.  This is normally used
+     * when logging errors that occur in constructor parameter checking because the scripting object isn't set up and the normal
+     * logging str contents wouldn't be set up.
+     */
+    readonly logStrTypeOnly: string;
+    /**
+     * Logs an error to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logErrors} is true.
+     * @param errorStr - the error string to log.
+     */
+    logError(errorStr: string): void;
+    /**
+     * Logs an error to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logErrors} is true and then throws
+     * the string in the errorStr parameter.
+     * @param errorStr - the error string to log.  This should be a non-blank string.
+     */
+    logErrorAndThrow(errorStr: string): void;
+    /**
+     * Logs a note to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logNotes} is true.
+     * @param noteStr - the note string to log.  This should be a non-blank string.
+     */
+    logNote(noteStr: string): void;
+    /**
+     * Logs a note to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logNotesVerbose} is true.
+     * @param noteStr - the note string to log.  This should be a non-blank string.
+     */
+    logNoteVerbose(noteStr: string): void;
+    /**
+     * Logs a warning to the logging service with a log header from this object's [logStr]{@link ArchBaseObject#logStr} property value when {@link ArchLogging#logWarnings} is true.
+     * @param warningStr - the warning string to log.  This should be a non-blank string.
+     */
+    logWarning(warningStr: string): void;
+    /**
+     * Returns whether or not this Architect Scripting object is a match
+     * for the supplied ArchFilterObject instance.
+     * @param archFilterObject - the object filter to use to determine if it's a match.
+     */
+    isFilterMatch(archFilterObject: ArchFilterObject): boolean;
 }
 
 export class ArchChoice extends ArchBaseCoreObject {
@@ -88491,6 +91382,7 @@ declare module 'purecloud-flow-scripting-api-sdk-javascript' {
             let ArchBaseFilterClausePropertyValue: ArchBaseFilterClausePropertyValue;
             let ArchBaseFilterMatching: ArchBaseObjectFilterCommon;
             let ArchBaseFlow: ArchBaseFlow;
+            let ArchBaseFlowBot: ArchBaseFlowBot;
             let ArchBaseFlowInboundOutboundSecureCall: ArchBaseFlowInboundOutboundSecureCall;
             let ArchBaseFlowWithMenus: ArchBaseFlowWithMenus;
             let ArchBaseFlowWithTasks: ArchBaseFlowWithTasks;