purecloud-flow-scripting-api-sdk-javascript 0.59.0 → 0.61.0

package/types.d.ts

@@ -1,5 +1,9 @@
 export class ArchDataType extends ArchBaseCoreObject {
     // constructor(coreExpressionType: any, baseDataTypeNameToUse: string);
+    /**
+     * Returns the name of the data type.
+     */
+    readonly name: string;
     /**
      * A string suitable for logging that contains information about this data type.
      */
@@ -79,6 +83,18 @@ export class ArchDataType extends ArchBaseCoreObject {
      * Returns a localized displayable name string for the data type.
      */
     readonly label: string;
+    /**
+     * If this data type is a custom JSON type, this will return the namespace
+     * for it.  If this data type is not a custom JSON type, nothing is returned.
+     * Valid custom JSON namespaces that can be returned are {@link ArchEnums#CUSTOM_JSON_NAMESPACES}
+     */
+    readonly customJsonNamespace: string;
+    /**
+     * If this data type is a custom JSON type, this will return an Architect data
+     * type custom JSON schema for it.  If this data type is not a custom JSON type,
+     * nothing is returned.
+     */
+    getCustomJsonSchema(): ArchDataTypeJsonCustomSchema;
     /**
      * Returns true indicating that this is an ArchBaseCoreObject instance.
      */
@@ -315,6 +331,33 @@ export class ArchEnums {
      * Returns a string array that contains all valid chooser mode strings.
      */
     readonly CHOOSER_PRESENTATION_MODES_ALL: string[];
+    /**
+     * Returns a JSON object with these properties for whose values are valid custom JSON schema types:
+     * ```
+     * {
+     *   input: 'input'
+     *   output: 'output'
+     * }
+     * ```
+     */
+    readonly CUSTOM_JSON_SCHEMA_TYPES: {"input":"input","output":"output","error":"error"};
+    /**
+     * Returns a string array that contains all valid custom JSON schema types.
+     */
+    readonly CUSTOM_JSON_SCHEMA_TYPES_ALL: string[];
+    /**
+     * Returns a JSON object with these properties for whose values are valid custom JSON type namespaces:
+     * ```
+     * {
+     *   decisionTable: 'decisionTable'
+     * }
+     * ```
+     */
+    readonly CUSTOM_JSON_TYPE_NAMESPACES: {"architect":"architect","decisionTable":"decisionTable","userDefined":"userDefined","worktype":"worktype"};
+    /**
+     * Returns a string array that contains all valid custom JSON type namespaces.
+     */
+    readonly CUSTOM_JSON_TYPE_NAMESPACES_ALL: string[];
     /**
      * Returns a string array that contains all valid DTMF terminating character options
      */
@@ -545,6 +588,21 @@ export class ArchEnums {
      * Returns a string array that contains all valid knowledge path mode strings.
      */
     readonly KNOWLEDGE_PATH_MODES_ALL: string[];
+    /**
+     * Returns a JSON object with these properties whose values are valid knowledge answer content type strings:
+     * ```
+     * {
+     *   standard:   'standard',
+     *   highlight:  'highlight',
+     *   generative: 'generative',
+     * }
+     * ```
+     */
+    readonly KNOWLEDGE_ANSWER_CONTENT_TYPES: {"standard":"standard","highlight":"highlight","generative":"generative"};
+    /**
+     * Returns a string array that contains all valid answer content type strings.
+     */
+    readonly KNOWLEDGE_ANSWER_CONTENT_TYPES_ALL: string[];
     /**
      * Returns a JSON object with these properties whose values are valid knowledge settings mode strings.
      * ```
@@ -718,7 +776,7 @@ export class ArchEnums {
      * }
      * ```
      */
-    readonly POST_FLOW_ACTION_TYPES: {"inboundCallFlow":"inboundCallFlow","voiceSurveyFlow":"voiceSurveyFlow"};
+    readonly POST_FLOW_ACTION_TYPES: {"inboundCallFlow":"inboundCallFlow","voiceSurveyFlow":"voiceSurveyFlow","inboundShortMessageFlow":"inboundShortMessageFlow"};
     /**
      * Returns a string array that contains all valid post flow action type strings.
      */
@@ -733,7 +791,7 @@ export class ArchEnums {
      * }
      * ```
      */
-    readonly POST_FLOW_TARGET_TYPES: {"callee":"callee","caller":"caller","any":"any"};
+    readonly POST_FLOW_TARGET_TYPES: {"callee":"callee","caller":"caller","any":"any","sender":"sender"};
     /**
      * Returns a string array that contains all valid post flow target type strings.
      */
@@ -774,7 +832,7 @@ export class ArchEnums {
      * }
      * ```
      */
-    readonly SEND_NOTIFICATION_TYPES: {"email":"email"};
+    readonly SEND_NOTIFICATION_TYPES: {"email":"email","chat":"chat"};
     /**
      * Returns a string array that contains all valid send notification modes.
      */
@@ -788,7 +846,7 @@ export class ArchEnums {
      * }
      * ```
      */
-    readonly EMAIL_STYLES: {"email":"email"};
+    readonly EMAIL_STYLES: {"email":"email","chat":"chat"};
     /**
      * Returns a string array that contains all valid send notification modes.
      */
@@ -1016,6 +1074,10 @@ export class ArchOrganizationInfo extends ArchBaseObject {
      * Returns true indicating that this is an ArchOrganizationInfo instance.
      */
     readonly isArchOrganizationInfo: boolean;
+    /**
+     * Returns true indicating that agentic virtual agent is available for this ArchOrganizationInfo instance.
+     */
+    readonly agenticVirtualAgentAvailable: boolean;
     /**
      * Returns true indicating that virtual agent is available for this ArchOrganizationInfo instance.
      */
@@ -1024,10 +1086,24 @@ export class ArchOrganizationInfo extends ArchBaseObject {
      * Returns whether Virtual Agent summarization capabilities are available for the organization.
      */
     readonly virtualAgentSummarizationAvailable: boolean;
+    /**
+     * Returns whether large language model (AI) slots are available for use in bot and digital
+     * bot flows for this organization.
+     */
+    readonly botFlowsLLMPoweredSlot: boolean;
+    /**
+     * Returns whether answer generation from a single or multiple knowledge articles in a bot or digital bot flow
+     * is available for this organization.
+     */
+    readonly botFlowsAnswerGeneration: boolean;
     /**
      * Returns whether the Messaging Rich Media Date Picker is available in digital bot flow.
      */
     readonly botFlowsMessagingDatePicker: boolean;
+    /**
+     * Returns whether enhanced recognition failure handling is available in bot or digital bot flows.
+     */
+    readonly botFlowsEnhancedRecognitionFailureHandling: boolean;
     /**
      * Returns whether virtual agent guide is available in bot or digital bot flows.
      */
@@ -2587,6 +2663,27 @@ export class ArchFactoryActions extends ArchBaseFactory {
     addActionShowKnowledgeArticle(archMultiActionContainer: ArchBaseMultiActionContainer, name?: string, previousArchAction?: ArchBaseAction): ArchActionShowKnowledgeArticle;
 }
 
+/**
+ * A factory instance that lets you add Architect data types to flows.
+ * Do not attempt to create an instance of this class.  Architect Scripting will
+ * create the factory instance as needed.
+ */
+export class ArchFactoryDataTypes extends ArchBaseFactory {
+    /**
+     * Returns the display type name string 'ArchFactoryDataTypes'.
+     */
+    readonly displayTypeName: string;
+    /**
+     * Returns the custom JSON data type that is associated with the given [custom JSON namespace]{@link ArchEnums#CUSTOM_JSON_TYPE_NAMESPACES} and entity name. If the data type does not exist within the flow,
+     * it will be created.
+     * @param archBaseFlow - the flow where the data type will be created or retrieved.
+     * @param customJsonNamespace - the custom JSON namespace to use for creating the data type. Allowable values are: {@link ArchEnums#CUSTOM_JSON_TYPE_NAMESPACES}
+     * @param entityName - the name of the entity that is being referenced by the custom JSON namespace.
+     * @param customJsonDataTypeSchemaType - the custom JSON schema types to use for creating the data type. Allowable values are: {@link ArchEnums#CUSTOM_JSON_SCHEMA_TYPES}
+     */
+    getOrCreateCustomJsonDataTypeAsync(archBaseFlow: ArchBaseFlow, customJsonNamespace: string, entityName: string, customJsonDataTypeSchemaType: string): void;
+}
+
 /**
  * A factory instance that lets you create filters.  Filters are used for filtering
  * and matching purposes such as when you want to traverse a flow looking for
@@ -4221,6 +4318,11 @@ export class ArchActionAskForBoolean extends ArchBaseActionAsk {
      * Max No Inputs value is exceeded.
      */
     readonly outputMaxNoInputs: ArchActionOutput;
+    /**
+     * The Max No Matches output for this action which will be taken at runtime if the
+     * Max No Matches value is exceeded.
+     */
+    readonly outputMaxNoMatches: ArchActionOutput;
 }
 
 /**
@@ -4393,10 +4495,23 @@ export class ArchActionAskForSlot extends ArchBaseActionAskNoInputNoMatch {
      * Max No Inputs value is exceeded.
      */
     readonly outputMaxNoInputs: ArchActionOutput;
+    /**
+     * The Max No Matches output for this action which will be taken at runtime if the
+     * Max No Matches value is exceeded.
+     */
+    readonly outputMaxNoMatches: ArchActionOutput;
     /**
      * The continuation prompt will be used when an AI LLM Slot is selected with manually managed prompting.
      */
     readonly continuationPrompt: ArchValueCommunication;
+    /**
+     * Continuation reprompts supplies wording the bot will use for an AI LLM Slot that is configured with manually managed prompting.
+     */
+    readonly continuationReprompts: ArchValueCommunicationCollection;
+    /**
+     * If this property is set to true, the bot will use communication values in the {@link continuationReprompts} Communication collection for continuation prompting.
+     */
+    readonly customizeContinuation: ArchValueBoolean;
     /**
      * The question text for the action.
      */
@@ -6250,10 +6365,6 @@ export class ArchActionCallDialogflowBot extends ArchBaseActionDialogflow {
      * For example -> "Flow.MyStringVar"
      */
     addLiveAgentHandoffMetadataNameValuePair(nameLiteral?: string, outputVariable?: string | ArchBaseVariable): ArchBaseNameValuePair;
-    /**
-     * Returns the Live Agent Handoff Metadata output data configured on the action.
-     */
-    readonly liveAgentHandoffMetadata: ArchBaseNameValuePairs;
     /**
      * Returns the integration name for the currently selected Dialogflow agent.
      */
@@ -6627,6 +6738,10 @@ export class ArchActionCallDialogflowCxBot extends ArchBaseActionDialogflow {
      * Returns true indicating that this is an ArchActionCallDialogflowCxBot instance.
      */
     readonly isArchActionCallDialogflowCxBot: boolean;
+    /**
+     * Returns the Live Agent Handoff Metadata output data configured on the action.
+     */
+    readonly liveAgentHandoffMetadata: ArchBaseNameValuePairs;
     /**
      * The success output for this action
      */
@@ -6704,6 +6819,10 @@ export class ArchActionCallGuide extends ArchBaseActionWithOutputsSuccessFailure
      * Outputs for the call Guide action
      */
     readonly guideOutputs: ArchNamedValueList;
+    /**
+     * The voice processing prompt communication for the Call Guide action.
+     */
+    readonly voiceProcessingPrompt: ArchValueCommunication;
     /**
      * This sets the guide that will be used by the guide identifier.
      * @param guideId - the identifier of the guide.
@@ -8386,7 +8505,7 @@ export class ArchActionDecryptData extends ArchBaseActionWithOutputsSuccessFailu
      * The contents of this named value list come from the Failure Outputs schema. It will contain two values: errorType and errorMessage.
      * These values will be returned by the server if the action takes the Failure path.
      */
-    readonly decryptDataFailureOutputs: ArchNamedValueList;
+    readonly decryptDataOutputsFailure: ArchNamedValueList;
     /**
      * The success output for this action
      */
@@ -8746,6 +8865,11 @@ export class ArchActionDigitalMenu extends ArchBaseActionWithOutputs {
      * Max No Inputs value is exceeded.
      */
     readonly outputMaxNoInputs: ArchActionOutput;
+    /**
+     * The Max No Matches output for this action which will be taken at runtime if the
+     * Max No Matches value is exceeded.
+     */
+    readonly outputMaxNoMatches: ArchActionOutput;
     /**
      * The variable that holds the value of the menu choice chosen by the participant.
      * If no choice is selected by the participant, no updates are
@@ -8850,7 +8974,7 @@ export class ArchActionEncryptData extends ArchBaseActionWithOutputsSuccessFailu
      * The contents of this named value list come from the Failure Outputs schema. It will contain two values: errorType and errorMessage.
      * These values will be returned by the server if the action takes the Failure path.
      */
-    readonly encryptDataFailureOutputs: ArchNamedValueList;
+    readonly encryptDataOutputsFailure: ArchNamedValueList;
     /**
      * The success output for this action
      */
@@ -9714,7 +9838,8 @@ export class ArchActionFindUsersById extends ArchBaseActionFindSystemObjectsById
     readonly findResult: ArchValueUserCollection;
 }
 
-export class ArchActionFindUtilizationLabel {
+export class ArchActionFindUtilizationLabel extends ArchBaseActionFindSystemObjectByName {
+    // constructor(coreFindUtilizationLabelActionViewModel: FindUtilizationLabelActionViewModel);
     /**
      * Returns the display type name string 'ArchActionFindUtilizationLabel'.
      */
@@ -9727,6 +9852,266 @@ export class ArchActionFindUtilizationLabel {
      * The value that will hold the returned utilization label if found.
      */
     readonly findResult: ArchValueUtilizationLabel;
+    /**
+     * The name of the object to look up.  Inheriting Find action instances will provide the context
+     * for the name string.  For example, in the {@link ArchActionFindUserPrompt} action this would be
+     * the name of the user prompt that you wish to look up at runtime.
+     */
+    readonly findName: ArchValueString;
+    /**
+     * The found output for this action
+     */
+    readonly outputFound: ArchActionOutput;
+    /**
+     * The not found output for this action
+     */
+    readonly outputNotFound: ArchActionOutput;
+    /**
+     * Gets an output by its identifier.  If it cannot be found, this method will throw.
+     * Normally you won't need to use this method and will use the helper methods available on inheriting classes
+     * when accessing pre-defined outputs like success, failure, timeout, etc. etc.  Attempting to
+     * get an output by id on a menu choice's action such as the {@link ArchMenuTransferToAcd#actionTransferToAcd}
+     * action on an {@link ArchMenuTransferToAcd} menu will return nothing.
+     * @param output - identifies output you want to obtain.  If output is an ArchBranch instance,
+     *                                         the {@link ArchBranch#outputId} value will be used.  Otherwise valid string
+     *                                         identifier values can be found in {@link ArchEnums#OUTPUT_IDS} or can be a guid.
+     *                                         Remember that requesting the 'success' output on an action with a
+     *                                         [fake success output]{@link ArchBaseActionWithOutputsFakeSuccessFailure#hasFakeSuccessOutput} will return nothing.
+     */
+    getOutputById(output: string | ArchBranch): ArchActionOutput;
+    /**
+     * Gets an output by its identifier.  If it cannot be found, this method will throw.
+     * Normally you won't need to use this method and will use the helper methods available on inheriting classes
+     * when accessing pre-defined outputs like success, failure, timeout, etc. etc.  Attempting to
+     * get an output by id on a menu choice's action such as the {@link ArchMenuTransferToAcd#actionTransferToAcd}
+     * action on an {@link ArchMenuTransferToAcd} menu will return nothing.
+     * @param output - identifies output you want to obtain by name.  If output is an ArchBranch instance,
+     *                                         the {@link ArchBranch#name} value will be used.
+     *                                         Remember that requesting the 'Success' output on an action with a
+     *                                         [fake success output]{@link ArchBaseActionWithOutputsFakeSuccessFailure#hasFakeSuccessOutput} will return nothing.
+     *                                         For non-dynamic outputs, the name should be specified in English.
+     * @param [wantDynamicOutput = false] - because it is possible for some actions to have both a non-dynamic output
+     *                                        and a dynamic output with the same name, this boolean will let you specify
+     *                                        which output you want.  An example of this would be the built in Failure
+     *                                        output on a call bot action but that bot also has an intent named Failure
+     *                                        so the action has two outputs with the same name of 'Failure'.  Only one
+     *                                        of those would be a dynamic output and that's the output for the Failure
+     *                                        intent, not the built-in Failure action output.
+     */
+    getOutputByName(output: string | ArchBranch, wantDynamicOutput?: boolean): ArchActionOutput;
+    /**
+     * Returns the output at the given index.  It's important to note that on actions that have a fake success
+     * output if you request the output at the index for the fake success, you will get nothing returned because
+     * the fake success output isn't something that you should do anything with.  Attempting to
+     * access an output by index on a menu choice's action such as {@link ArchMenuTransferToAcd#actionTransferToAcd}
+     * will return nothing.
+     * @param index - the index of the output to retrieve.  This value should be a non-negative integer.
+     */
+    getOutputByIndex(index: number): ArchActionOutput;
+    /**
+     * Returns the number of outputs on this action.  For actions that have a fake success output like what you
+     * see on the various transfer actions, that will be included in the count to be consistent with the Architect UI.
+     * Attempting to get the output count on a menu choice's action such as such as the {@link ArchMenuTransferToAcd#actionTransferToAcd}
+     * action on an {@link ArchMenuTransferToAcd} menu will return 0.
+     */
+    readonly outputCount: number;
+    /**
+     * Returns an array of action outputs for this action.  Remember that it is possible to have an
+     * undefined item in the returned ArchActionOutput array.  This is true when the output is "fake".
+     * Accessing the outputs on a menu choice's action such as {@link ArchMenuTransferToAcd#actionTransferToAcd}
+     * will return an empty array.
+     */
+    readonly outputs: ArchActionOutput[];
+    /**
+     * A string suitable for logging that contains information about this action.  This will contain the action
+     * tracking id, name and scripting type name.
+     */
+    readonly logStr: string;
+    /**
+     * The Architect action type label
+     */
+    readonly displayTypeNameArchitect: string;
+    /**
+     * Returns whether or not this action is the action property for a [menu choice]{@link ArchBaseMenuChoice}.
+     * For example, the {@link ArchMenuDisconnect#actionDisconnect} property on an {@link ArchMenuDisconnect}
+     * instance.
+     */
+    readonly isMenuChoiceAction: boolean;
+    /**
+     * Returns whether or not this action is reachable at runtime.
+     */
+    readonly isReachable: boolean;
+    /**
+     * Returns whether or not this action is secure which means either the action by its very nature
+     * is secure or it consumes secure data.
+     */
+    readonly isSecure: boolean;
+    /**
+     * Returns whether or not this action is unreachable at runtime.
+     */
+    readonly isUnreachable: boolean;
+    /**
+     * The name of the action
+     */
+    name: string;
+    /**
+     * Returns the parent flow for this action.
+     */
+    readonly parentFlow: ArchBaseFlow;
+    /**
+     * Returns the parent menu choice if this action is the action for a [menu choice]{@link ArchBaseMenuChoice}.
+     * Otherwise, nothing is returned.
+     */
+    readonly parentMenuChoice: ArchBaseMenuChoice;
+    /**
+     * Returns the parent task that contains this action if this action is in a [task]{@link ArchTask} or [looping task]{@link ArchTaskLoop}.
+     * Otherwise, nothing is returned.
+     */
+    readonly parentTask: ArchTask | ArchTaskLoop;
+    /**
+     * Returns the parent state that contains this action if this action is in a [state]{@link ArchState}.
+     * Otherwise, nothing is returned.
+     */
+    readonly parentState: ArchState;
+    /**
+     * The integer tracking identifier for this action.  This is the numeric identifier is displayed in the Architect user interface.
+     */
+    readonly trackingId: number;
+    /**
+     * 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;
 }
 
 /**
@@ -12754,7 +13139,7 @@ export class ArchActionSetUUIData extends ArchBaseAction {
      */
     readonly uuiData: ArchValueString;
     /**
-     * Specifies the when the UUI data should be set.  If the mode is set to transfer, this specifies the outbound UUI data to
+     * Specifies when the UUI data should be set.  If the mode is set to transfer, this specifies the outbound UUI data to
      * set if the call is transferred.  If the mode is set to disconnect, this specifies the outbound UUI data to set if the call
      * disconnects.
      */
@@ -19023,6 +19408,10 @@ export class ArchDefinitionFlow extends ArchBaseDefinition {
      * Returns whether or not this flow type supports default languages.
      */
     readonly supportsDefaultLanguage: boolean;
+    /**
+     * Returns whether or not this flow type supports intent descriptions.
+     */
+    readonly supportsIntentDescriptions: boolean;
     /**
      * Returns whether or not this flow type supports secure variables.
      */
@@ -27792,7 +28181,7 @@ export class ArchMenuTransferToAcd extends ArchBaseMenuChoice {
     /**
      * Returns true indicating that this is an ArchMenuTransferToAcd instance.
      */
-    static isArchMenuTransferToAcd: boolean;
+    readonly isArchMenuTransferToAcd: boolean;
 }
 
 /**
@@ -27814,7 +28203,7 @@ export class ArchMenuTransferToFlow extends ArchBaseMenuChoice {
     /**
      * Returns true indicating that this is an ArchMenuTransferToFlow instance.
      */
-    static isArchMenuTransferToFlow: boolean;
+    readonly isArchMenuTransferToFlow: boolean;
 }
 
 /**
@@ -27856,7 +28245,7 @@ export class ArchMenuTransferToGroup extends ArchBaseMenuChoice {
     /**
      * Returns true indicating that this is an ArchMenuTransferToGroup instance.
      */
-    static isArchMenuTransferToGroup: boolean;
+    readonly isArchMenuTransferToGroup: boolean;
 }
 
 /**
@@ -27878,7 +28267,7 @@ export class ArchMenuTransferToNumber extends ArchBaseMenuChoice {
     /**
      * Returns true indicating that this is an ArchMenuTransferToNumber instance.
      */
-    static isArchMenuTransferToNumber: boolean;
+    readonly isArchMenuTransferToNumber: boolean;
 }
 
 /**
@@ -27900,7 +28289,7 @@ export class ArchMenuTransferToUser extends ArchBaseMenuChoice {
     /**
      * Returns true indicating that this is an ArchMenuTransferToUser instance.
      */
-    static isArchMenuTransferToUser: boolean;
+    readonly isArchMenuTransferToUser: boolean;
 }
 
 /**
@@ -28628,6 +29017,12 @@ export class ArchSettingsBotFlow extends ArchBaseCoreObjectWithId {
      * for Virtual Agent functionality to be used at flow runtime.
      */
     virtualAgentEnabled: boolean;
+    /**
+     * Returns true if Agentic Virtual Agent functionality is enabled for this flow, otherwise false.
+     * This property is automatically set to true when the flow contains Call Guide actions and cannot be set back to false.
+     * To downgrade from an agentic flow back to non-agentic (va flow), you must revert to a previous flow version.
+     */
+    readonly agenticVirtualAgentEnabled: boolean;
 }
 
 /**
@@ -28956,6 +29351,12 @@ export class ArchSettingsEventErrorFlowBot extends ArchSettingsEventErrorFlow {
      * The configured reusable task that the flow will jump to when the agent escalation handling is set to 'Jump to Reusable Task'.
      */
     readonly agentEscalationTargetTask: ArchTask;
+    /**
+     * The subsequent recognition failures configured for the flow. The string values in {@link ArchEnums#SUBSEQUENT_RECOGNITION_FAILURES_MODES}
+     * When set to `executeTask`, the bot will continue to execute the recognition failure task for all subsequent recognition failure events.
+     * When set to `exit`, the bot will exit the flow after the first execution of the recognition failure task.
+     */
+    readonly subsequentRecognitionFailuresHandlingType: ArchValueString;
 }
 
 /**
@@ -29391,6 +29792,25 @@ export class ArchSettingsNluKnowledge extends ArchBaseCoreObject {
      * Helper function to set the knowledge path mode to task.
      */
     setKnowledgePathModeTask(): void;
+    /**
+     * The knowledge answer content type determines what behavior will occur when a knowledge article is matched in a Digital Bot Flow.
+     * There are three options; standard, highlight, and generative. Standard will return the entire matched answer. Highlight will
+     * highlight the answer in the matched answer. Generative will create an AI-generated response to the question from the answer.
+     * The string values in {@link ArchEnums#KNOWLEDGE_ANSWER_CONTENT_TYPES}
+     */
+    readonly knowledgeAnswerContentType: ArchValueString;
+    /**
+     * Helper function to set the knowledge answer content type to standard.
+     */
+    setKnowledgeAnswerContentTypeStandard(): void;
+    /**
+     * Helper function to set the knowledge answer content type to highlight.
+     */
+    setKnowledgeAnswerContentTypeHighlight(): void;
+    /**
+     * Helper function to set the knowledge answer content type to generative.
+     */
+    setKnowledgeAnswerContentTypeGenerative(): void;
     /**
      * Controls how knowledge matches are handled at runtime. The custom setting allows you to choose a reusable task that will
      * be executed when a knowledge match occurs. The string values in {@link ArchEnums#KNOWLEDGE_SETTINGS_MODES} list valid values.
@@ -30590,6 +31010,12 @@ export class ArchSettingsVoiceSurveyFlow extends ArchSettingsBotFlow {
      * for Virtual Agent functionality to be used at flow runtime.
      */
     virtualAgentEnabled: boolean;
+    /**
+     * Returns true if Agentic Virtual Agent functionality is enabled for this flow, otherwise false.
+     * This property is automatically set to true when the flow contains Call Guide actions and cannot be set back to false.
+     * To downgrade from an agentic flow back to non-agentic (va flow), you must revert to a previous flow version.
+     */
+    readonly agenticVirtualAgentEnabled: boolean;
     /**
      * The identifier string for this object.
      */
@@ -32418,13 +32844,13 @@ export class ArchNamedValueList extends ArchBaseValueContainer {
      *                         For example, to retrieve the first named value, pass in 0 assuming there is at least one named
      *                         value in this instance.
      */
-    getNamedValueByIndex(index: number): ArchNamedValue;
+    getNamedValueByIndex<T extends ArchNamedValue | ArchNamedValueList = ArchNamedValue>(index: number): T;
     /**
      * Gets the named value by its name.  This is a case sensitive lookup.  If the named value cannot be found,
      * nothing is returned.
      * @param valueName - the name of the value.
      */
-    getNamedValueByName(valueName: string): ArchNamedValue;
+    getNamedValueByName<T extends ArchNamedValue | ArchNamedValueList = ArchNamedValue>(valueName: string): T;
     /**
      * Returns true indicating that this is an ArchNamedValueList instance.
      */