@microsoft/agents-hosting-dialogs 0.1.49

package/dist/src/dialog.js

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dialog = void 0;
+const configurable_1 = require("./configurable");
+const dialogTurnStatus_1 = require("./dialogTurnStatus");
+/**
+ * Defines the core behavior for all dialogs.
+ */
+class Dialog extends configurable_1.Configurable {
+    /**
+       * Creates a new instance of the Dialog class.
+       *
+       * @param dialogId Optional. unique ID of the dialog.
+       */
+    constructor(dialogId) {
+        super();
+        this.id = dialogId;
+    }
+    /**
+       * Unique ID of the dialog.
+       *
+       * @remarks
+       * This will be automatically generated if not specified.
+       * @returns The Id for the dialog.
+       */
+    get id() {
+        if (this._id === undefined) {
+            this._id = this.onComputeId();
+        }
+        return this._id;
+    }
+    /**
+       * Sets the unique ID of the dialog.
+       */
+    set id(value) {
+        this._id = value;
+    }
+    /**
+       * An encoded string used to aid in the detection of agent changes on re-deployment.
+       *
+       * @remarks
+       * This defaults to returning the dialogs [id](#id) but can be overridden to provide more
+       * precise change detection logic. Any dialog on the stack that has its version change will
+       * result in a `versionChanged` event will be raised. If this event is not handled by the agent,
+       * an error will be thrown resulting in the agent error handler logic being run.
+       *
+       * Returning an empty string will disable version tracking for the component all together.
+       * @returns Unique string which should only change when dialog has changed in a way that should restart the dialog.
+       */
+    getVersion() {
+        return this.id;
+    }
+    /**
+       * When overridden in a derived class, continues the dialog.
+       *
+       * @param dc The context for the current dialog turn.
+       *
+       * @remarks
+       * Derived dialogs that support multiple-turn conversations should override this method.
+       * By default, this method signals that the dialog is complete and returns.
+       *
+       * The DialogContext calls this method when it continues
+       * the dialog.
+       *
+       * To signal to the dialog context that this dialog has completed, await
+       * DialogContext.endDialog before exiting this method.
+       *
+       * @returns {Promise<DialogTurnResult>} A promise resolving to the dialog turn result.
+       */
+    async continueDialog(dc) {
+        // By default just end the current dialog.
+        return dc.endDialog();
+    }
+    /**
+       * When overridden in a derived class, resumes the dialog after the dialog above it on the stack completes.
+       *
+       * @param dc The context for the current dialog turn.
+       * @param reason The reason the dialog is resuming. This will typically be DialogReason.endCalled
+       * @param result Optional. The return value, if any, from the dialog that ended.
+       *
+       * @remarks
+       * Derived dialogs that support multiple-turn conversations should override this method.
+       * By default, this method signals that the dialog is complete and returns.
+       *
+       * The DialogContext calls this method when it resumes
+       * the dialog. If the previous dialog on the stack returned a value, that value is in the `result`
+       * parameter.
+       *
+       * To start a _child_ dialog, use DialogContext.beginDialog or DialogContext.prompt; however, this dialog will not
+       * necessarily be the one that started the child dialog.
+       * To signal to the dialog context that this dialog has completed, await DialogContext.endDialog before exiting this method.
+       *
+       * @returns {Promise<DialogTurnResult>} A promise resolving to the dialog turn result.
+       */
+    async resumeDialog(dc, reason, result) {
+        // By default just end the current dialog and return result to parent.
+        return dc.endDialog(result);
+    }
+    /**
+       * When overridden in a derived class, reprompts the user for input.
+       *
+       * @param _context The context object for the turn.
+       * @param _instance Current state information for this dialog.
+       *
+       * @remarks
+       * Derived dialogs that support validation and re-prompt logic should override this method.
+       * By default, this method has no effect.
+       *
+       * The DialogContext calls this method when the current
+       * dialog should re-request input from the user. This method is implemented for prompt dialogs.
+       *
+       */
+    async repromptDialog(_context, _instance) {
+        // No-op by default
+    }
+    /**
+       * When overridden in a derived class, performs clean up for the dialog before it ends.
+       *
+       * @param _context The context object for the turn.
+       * @param _instance Current state information for this dialog.
+       * @param _reason The reason the dialog is ending.
+       *
+       * @remarks
+       * Derived dialogs that need to perform logging or cleanup before ending should override this method.
+       * By default, this method has no effect.
+       *
+       * The DialogContext calls this method when the current
+       * dialog is ending.
+       *
+       */
+    async endDialog(_context, _instance, _reason) {
+        // No-op by default
+    }
+    /**
+       * Called when an event has been raised, using `DialogContext.emitEvent()`, by either the current dialog or a dialog that the current dialog started.
+       *
+       * @param dialogContext - The dialog context for the current turn of conversation.
+       * @param event - The event being raised.
+       * @returns True if the event is handled by the current dialog and bubbling should stop.
+       */
+    async onDialogEvent(dialogContext, event) {
+        // Before bubble
+        let handled = await this.onPreBubbleEvent(dialogContext, event);
+        // Bubble as needed
+        if (!handled && event.bubble && dialogContext.parent !== undefined) {
+            handled = await dialogContext.parent.emitEvent(event.name, event.value, true, false);
+        }
+        // Post bubble
+        if (!handled) {
+            handled = await this.onPostBubbleEvent(dialogContext, event);
+        }
+        return handled;
+    }
+    /**
+       * Called before an event is bubbled to its parent.
+       *
+       * @remarks
+       * This is a good place to perform interception of an event as returning `true` will prevent
+       * any further bubbling of the event to the dialogs parents and will also prevent any child
+       * dialogs from performing their default processing.
+       * @param _dc The dialog context for the current turn of conversation.
+       * @param _e The event being raised.
+       * @returns Whether the event is handled by the current dialog and further processing should stop.
+       */
+    async onPreBubbleEvent(_dc, _e) {
+        return false;
+    }
+    /**
+       * Called after an event was bubbled to all parents and wasn't handled.
+       *
+       * @remarks
+       * This is a good place to perform default processing logic for an event. Returning `true` will
+       * prevent any processing of the event by child dialogs.
+       * @param _dc The dialog context for the current turn of conversation.
+       * @param _e The event being raised.
+       * @returns Whether the event is handled by the current dialog and further processing should stop.
+       */
+    async onPostBubbleEvent(_dc, _e) {
+        return false;
+    }
+    /**
+       * Called when a unique ID needs to be computed for a dialog.
+       *
+       * @remarks
+       * SHOULD be overridden to provide a more contextually relevant ID. The preferred pattern for
+       * ID's is `<dialog type>(this.hashedLabel('<dialog args>'))`.
+       */
+    onComputeId() {
+        throw new Error('Dialog.onComputeId(): not implemented.');
+    }
+}
+exports.Dialog = Dialog;
+/**
+   * Gets a default end-of-turn result.
+   *
+   * @remarks
+   * This result indicates that a dialog (or a logical step within a dialog) has completed
+   * processing for the current turn, is still active, and is waiting for more input.
+   */
+Dialog.EndOfTurn = { status: dialogTurnStatus_1.DialogTurnStatus.waiting };
+//# sourceMappingURL=dialog.js.map

package/dist/src/dialog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dialog.js","sourceRoot":"","sources":["../../src/dialog.ts"],"names":[],"mappings":";;;AAMA,iDAA6C;AAK7C,yDAAqD;AAErD;;GAEG;AACH,MAAsB,MAA8B,SAAQ,2BAAY;IAYtE;;;;SAIK;IACL,YAAa,QAAiB;QAC5B,KAAK,EAAE,CAAA;QACP,IAAI,CAAC,EAAE,GAAG,QAAQ,CAAA;IACpB,CAAC;IAED;;;;;;SAMK;IACL,IAAI,EAAE;QACJ,IAAI,IAAI,CAAC,GAAG,KAAK,SAAS,EAAE,CAAC;YAC3B,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,WAAW,EAAE,CAAA;QAC/B,CAAC;QACD,OAAO,IAAI,CAAC,GAAG,CAAA;IACjB,CAAC;IAED;;SAEK;IACL,IAAI,EAAE,CAAE,KAAa;QACnB,IAAI,CAAC,GAAG,GAAG,KAAK,CAAA;IAClB,CAAC;IAED;;;;;;;;;;;SAWK;IACL,UAAU;QACR,OAAO,IAAI,CAAC,EAAE,CAAA;IAChB,CAAC;IAqBD;;;;;;;;;;;;;;;;SAgBK;IACL,KAAK,CAAC,cAAc,CAAE,EAAiB;QACrC,0CAA0C;QAC1C,OAAO,EAAE,CAAC,SAAS,EAAE,CAAA;IACvB,CAAC;IAED;;;;;;;;;;;;;;;;;;;;SAoBK;IACL,KAAK,CAAC,YAAY,CAAE,EAAiB,EAAE,MAAoB,EAAE,MAAY;QACvE,sEAAsE;QACtE,OAAO,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC,CAAA;IAC7B,CAAC;IAED;;;;;;;;;;;;;SAaK;IACL,KAAK,CAAC,cAAc,CAAE,QAAqB,EAAE,SAAyB;QACpE,mBAAmB;IACrB,CAAC;IAED;;;;;;;;;;;;;;SAcK;IACL,KAAK,CAAC,SAAS,CAAE,QAAqB,EAAE,SAAyB,EAAE,OAAqB;QACtF,mBAAmB;IACrB,CAAC;IAED;;;;;;SAMK;IACL,KAAK,CAAC,aAAa,CAAE,aAA4B,EAAE,KAAkB;QACnE,gBAAgB;QAChB,IAAI,OAAO,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,aAAa,EAAE,KAAK,CAAC,CAAA;QAE/D,mBAAmB;QACnB,IAAI,CAAC,OAAO,IAAI,KAAK,CAAC,MAAM,IAAI,aAAa,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;YACnE,OAAO,GAAG,MAAM,aAAa,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC,CAAA;QACtF,CAAC;QAED,cAAc;QACd,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,OAAO,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,aAAa,EAAE,KAAK,CAAC,CAAA;QAC9D,CAAC;QAED,OAAO,OAAO,CAAA;IAChB,CAAC;IAED;;;;;;;;;;SAUK;IACK,KAAK,CAAC,gBAAgB,CAAE,GAAkB,EAAE,EAAe;QACnE,OAAO,KAAK,CAAA;IACd,CAAC;IAED;;;;;;;;;SASK;IACK,KAAK,CAAC,iBAAiB,CAAE,GAAkB,EAAE,EAAe;QACpE,OAAO,KAAK,CAAA;IACd,CAAC;IAED;;;;;;SAMK;IACK,WAAW;QACnB,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAA;IAC3D,CAAC;;AAjOH,wBAkOC;AA/NC;;;;;;KAMK;AACE,gBAAS,GAAqB,EAAE,MAAM,EAAE,mCAAgB,CAAC,OAAO,EAAE,CAAA"}

package/dist/src/dialogContainer.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { Dialog } from './dialog';
+import { DialogSet } from './dialogSet';
+import { DialogContext } from './dialogContext';
+import { DialogEvent } from './dialogEvent';
+/**
+ * A container for a set of Dialogs.
+ */
+export declare abstract class DialogContainer<O extends object = {}> extends Dialog<O> {
+    /**
+       * The containers dialog set.
+       */
+    readonly dialogs: DialogSet;
+    /**
+       * Creates an inner dialog context for the containers active child.
+       *
+       * @param dialogContext Parents dialog context.
+       * @returns A new dialog context for the active child or `undefined` if there is no active child.
+       */
+    abstract createChildContext(dialogContext: DialogContext): DialogContext | undefined;
+    /**
+       * Finds a child dialog that was previously added to the container.
+       *
+       * @param dialogId ID of the dialog to lookup.
+       * @returns The Dialog if found; otherwise null.
+       */
+    findDialog(dialogId: string): Dialog | undefined;
+    /**
+       * Called when an event has been raised, using `DialogContext.emitEvent()`,
+       * by either the current dialog or a dialog that the current dialog started.
+       *
+       * @param dialogContext The dialog context for the current turn of conversation.
+       * @param event The event being raised.
+       * @returns True if the event is handled by the current dialog and bubbling should stop.
+       */
+    onDialogEvent(dialogContext: DialogContext, event: DialogEvent): Promise<boolean>;
+    /**
+       * Returns internal version identifier for this container.
+       *
+       * @remarks
+       * DialogContainers detect changes of all sub-components in the container and map that to a `versionChanged` event.
+       * Because they do this, DialogContainers "hide" the internal changes and just have the .id. This isolates changes
+       * to the container level unless a container doesn't handle it.  To support this DialogContainers define a
+       * protected method getInternalVersion() which computes if this dialog or child dialogs have changed
+       * which is then examined via calls to checkForVersionChange().
+       * @returns Version which represents the change of the internals of this container.
+       */
+    protected getInternalVersion(): string;
+    /**
+       * Checks to see if a containers child dialogs have changed since the current dialog instance
+       * was started.
+       *
+       * @remarks
+       * This should be called at the start of `beginDialog()`, `continueDialog()`, and `resumeDialog()`.
+       * @param dialogContext Current dialog context.
+       */
+    protected checkForVersionChange(dialogContext: DialogContext): Promise<void>;
+}

package/dist/src/dialogContainer.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DialogContainer = void 0;
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+const dialog_1 = require("./dialog");
+const dialogSet_1 = require("./dialogSet");
+const dialogEvents_1 = require("./dialogEvents");
+/**
+ * A container for a set of Dialogs.
+ */
+class DialogContainer extends dialog_1.Dialog {
+    constructor() {
+        super(...arguments);
+        /**
+           * The containers dialog set.
+           */
+        this.dialogs = new dialogSet_1.DialogSet(undefined);
+    }
+    /**
+       * Finds a child dialog that was previously added to the container.
+       *
+       * @param dialogId ID of the dialog to lookup.
+       * @returns The Dialog if found; otherwise null.
+       */
+    findDialog(dialogId) {
+        return this.dialogs.find(dialogId);
+    }
+    /**
+       * Called when an event has been raised, using `DialogContext.emitEvent()`,
+       * by either the current dialog or a dialog that the current dialog started.
+       *
+       * @param dialogContext The dialog context for the current turn of conversation.
+       * @param event The event being raised.
+       * @returns True if the event is handled by the current dialog and bubbling should stop.
+       */
+    async onDialogEvent(dialogContext, event) {
+        const handled = await super.onDialogEvent(dialogContext, event);
+        if (!handled && event.name === dialogEvents_1.DialogEvents.versionChanged) {
+            const traceMessage = `Unhandled dialog event: ${event.name}. Active Dialog: ${dialogContext.activeDialog.id}`;
+            await dialogContext.context.sendTraceActivity(traceMessage);
+        }
+        return handled;
+    }
+    /**
+       * Returns internal version identifier for this container.
+       *
+       * @remarks
+       * DialogContainers detect changes of all sub-components in the container and map that to a `versionChanged` event.
+       * Because they do this, DialogContainers "hide" the internal changes and just have the .id. This isolates changes
+       * to the container level unless a container doesn't handle it.  To support this DialogContainers define a
+       * protected method getInternalVersion() which computes if this dialog or child dialogs have changed
+       * which is then examined via calls to checkForVersionChange().
+       * @returns Version which represents the change of the internals of this container.
+       */
+    getInternalVersion() {
+        return this.dialogs.getVersion();
+    }
+    /**
+       * Checks to see if a containers child dialogs have changed since the current dialog instance
+       * was started.
+       *
+       * @remarks
+       * This should be called at the start of `beginDialog()`, `continueDialog()`, and `resumeDialog()`.
+       * @param dialogContext Current dialog context.
+       */
+    async checkForVersionChange(dialogContext) {
+        const current = dialogContext.activeDialog.version;
+        dialogContext.activeDialog.version = this.getInternalVersion();
+        // Check for change of previously stored hash
+        if (current && current !== dialogContext.activeDialog.version) {
+            // Give agent an opportunity to handle the change.
+            // - If agent handles it the changeHash will have been updated as to avoid triggering the
+            //   change again.
+            await dialogContext.emitEvent(dialogEvents_1.DialogEvents.versionChanged, this.id, true, false);
+        }
+    }
+}
+exports.DialogContainer = DialogContainer;
+//# sourceMappingURL=dialogContainer.js.map

package/dist/src/dialogContainer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dialogContainer.js","sourceRoot":"","sources":["../../src/dialogContainer.ts"],"names":[],"mappings":";;;AAAA;;;GAGG;AACH,qCAAiC;AACjC,2CAAuC;AAEvC,iDAA6C;AAG7C;;GAEG;AACH,MAAsB,eAAuC,SAAQ,eAAS;IAA9E;;QACE;;aAEK;QACI,YAAO,GAAG,IAAI,qBAAS,CAAC,SAAS,CAAC,CAAA;IAwE7C,CAAC;IA9DC;;;;;SAKK;IACL,UAAU,CAAE,QAAgB;QAC1B,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;IACpC,CAAC;IAED;;;;;;;SAOK;IACL,KAAK,CAAC,aAAa,CAAE,aAA4B,EAAE,KAAkB;QACnE,MAAM,OAAO,GAAG,MAAM,KAAK,CAAC,aAAa,CAAC,aAAa,EAAE,KAAK,CAAC,CAAA;QAC/D,IAAI,CAAC,OAAO,IAAI,KAAK,CAAC,IAAI,KAAK,2BAAY,CAAC,cAAc,EAAE,CAAC;YAC3D,MAAM,YAAY,GAAG,2BAA2B,KAAK,CAAC,IAAI,oBAAoB,aAAa,CAAC,YAAY,CAAC,EAAE,EAAE,CAAA;YAC7G,MAAM,aAAa,CAAC,OAAO,CAAC,iBAAiB,CAAC,YAAY,CAAC,CAAA;QAC7D,CAAC;QACD,OAAO,OAAO,CAAA;IAChB,CAAC;IAED;;;;;;;;;;SAUK;IACK,kBAAkB;QAC1B,OAAO,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,CAAA;IAClC,CAAC;IAED;;;;;;;SAOK;IACK,KAAK,CAAC,qBAAqB,CAAE,aAA4B;QACjE,MAAM,OAAO,GAAG,aAAa,CAAC,YAAY,CAAC,OAAO,CAAA;QAClD,aAAa,CAAC,YAAY,CAAC,OAAO,GAAG,IAAI,CAAC,kBAAkB,EAAE,CAAA;QAE9D,6CAA6C;QAC7C,IAAI,OAAO,IAAI,OAAO,KAAK,aAAa,CAAC,YAAY,CAAC,OAAO,EAAE,CAAC;YAC9D,kDAAkD;YAClD,yFAAyF;YACzF,kBAAkB;YAClB,MAAM,aAAa,CAAC,SAAS,CAAC,2BAAY,CAAC,cAAc,EAAE,IAAI,CAAC,EAAE,EAAE,IAAI,EAAE,KAAK,CAAC,CAAA;QAClF,CAAC;IACH,CAAC;CACF;AA5ED,0CA4EC"}

package/dist/src/dialogContext.d.ts

@@ -0,0 +1,272 @@
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { Activity, TurnContext, TurnContextStateCollection } from '@microsoft/agents-hosting';
+import { Dialog } from './dialog';
+import { DialogSet } from './dialogSet';
+import { PromptOptions } from './prompts';
+import { DialogStateManager } from './memory';
+import { DialogManager } from './dialogManager';
+import { DialogInstance } from './dialogInstance';
+import { DialogTurnResult } from './dialogTurnResult';
+import { Choice } from './choices';
+/**
+ * Contains dialog state, information about the state of the dialog stack, for a specific DialogSet.
+ *
+ * @remarks
+ * State is read from and saved to storage each turn, and state cache for the turn is managed through the TurnContext.
+ *
+ * For more information, see the articles on
+ * [Managing state](https://docs.microsoft.com/azure/bot-service/bot-builder-concept-state) and
+ * [Dialogs library](https://docs.microsoft.com/azure/bot-service/bot-builder-concept-dialog).
+ */
+export interface DialogState {
+    /**
+       * Contains state information for each Dialog on the stack.
+       */
+    dialogStack: DialogInstance[];
+}
+/**
+ * The context for the current dialog turn with respect to a specific DialogSet.
+ *
+ * @remarks
+ * This includes the turn context, information about the dialog set, and the state of the dialog stack.
+ *
+ * From code outside of a dialog in the set, use DialogSet.createContext
+ * to create the dialog context. Then use the methods of the dialog context to manage the progression of dialogs in the set.
+ *
+ * When you implement a dialog, the dialog context is a parameter available to the various methods you override or implement.
+ *
+ */
+export declare class DialogContext {
+    /**
+       * Creates an new instance of the DialogContext class.
+       *
+       * @param dialogs The DialogSet for which to create the dialog context.
+       * @param contextOrDialogContext The TurnContext object for the current turn.
+       * @param state The state object to use to read and write DialogState to storage.
+       * @remarks
+       * Passing in a DialogContext instance will clone the dialog context.
+       */
+    constructor(dialogs: DialogSet, contextOrDialogContext: TurnContext, state: DialogState);
+    /**
+       * Creates an new instance of the DialogContext class.
+       *
+       * @param dialogs The DialogSet for which to create the dialog context.
+       * @param contextOrDialogContext The DialogContext object for the current turn.
+       * @param state The state object to use to read and write DialogState to storage.
+       * @remarks
+       * Passing in a DialogContext instance will clone the dialog context.
+       */
+    constructor(dialogs: DialogSet, contextOrDialogContext: DialogContext, state: DialogState);
+    /**
+       * Gets the dialogs that can be called directly from this context.
+       */
+    dialogs: DialogSet;
+    /**
+       * Gets the context object for the turn.
+       */
+    context: TurnContext;
+    /**
+       * Gets the current dialog stack.
+       */
+    stack: DialogInstance[];
+    /**
+       * The parent dialog context for this dialog context, or `undefined` if this context doesn't have a parent.
+       *
+       * @remarks
+       * When it attempts to start a dialog, the dialog context searches for the Dialog.id
+       * in its DialogContext.dialogs. If the dialog to start is not found
+       * in this dialog context, it searches in its parent dialog context, and so on.
+       */
+    parent: DialogContext | undefined;
+    /**
+       * @returns Dialog context for child if the active dialog is a container.
+       */
+    get child(): DialogContext | undefined;
+    /**
+       * @returns The state information for the dialog on the top of the dialog stack, or `undefined` if
+       * the stack is empty.
+       */
+    get activeDialog(): DialogInstance | undefined;
+    /**
+       * Gets the DialogStateManager which manages view of all memory scopes.
+       */
+    state: DialogStateManager;
+    /**
+       * Gets the services collection which is contextual to this dialog context.
+       */
+    services: TurnContextStateCollection;
+    /**
+       * @deprecated This property serves no function.
+       * @returns The current dialog manager instance. This property is deprecated.
+       */
+    get dialogManager(): DialogManager;
+    /**
+       * Obtain the CultureInfo in DialogContext.
+       *
+       * @returns a locale string.
+       */
+    getLocale(): string;
+    /**
+       * Starts a dialog instance and pushes it onto the dialog stack.
+       * Creates a new instance of the dialog and pushes it onto the stack.
+       *
+       * @param dialogId ID of the dialog to start.
+       * @param options Optional. Arguments to pass into the dialog when it starts.
+       * @returns {Promise<DialogTurnResult>} a promise resolving to the dialog turn result.
+       * @remarks
+       * If there's already an active dialog on the stack, that dialog will be paused until
+       * it is again the top dialog on the stack.
+       *
+       * The DialogTurnResult.status of returned object describes
+       * the status of the dialog stack after this method completes.
+       *
+       * This method throws an exception if the requested dialog can't be found in this dialog context
+       * or any of its ancestors.
+       *
+       */
+    beginDialog(dialogId: string, options?: object): Promise<DialogTurnResult>;
+    /**
+       * Cancels all dialogs on the dialog stack, and clears stack.
+       *
+       * @param cancelParents Optional. If `true` all parent dialogs will be cancelled as well.
+       * @param eventName Optional. Name of a custom event to raise as dialogs are cancelled. This defaults to DialogEvents.cancelDialog.
+       * @param eventValue Optional. Value to pass along with custom cancellation event.
+       * @returns {Promise<DialogTurnResult>} a promise resolving to the dialog turn result.
+       * @remarks
+       * This calls each dialog's .Dialog.endDialog method before
+       * removing the dialog from the stack.
+       *
+       * If there were any dialogs on the stack initially, the DialogTurnResult.status
+       * of the return value is DialogTurnStatus.cancelled; otherwise, it's
+       * DialogTurnStatus.empty.
+       *
+       */
+    cancelAllDialogs(cancelParents?: boolean, eventName?: string, eventValue?: any): Promise<DialogTurnResult>;
+    /**
+       * Searches for a dialog with a given ID.
+       *
+       * @param dialogId ID of the dialog to search for.
+       * @returns The dialog for the provided ID.
+       * @remarks
+       * If the dialog to start is not found in the DialogSet associated
+       * with this dialog context, it attempts to find the dialog in its parent dialog context.
+       *
+       */
+    findDialog(dialogId: string): Dialog | undefined;
+    /**
+       * Helper function to simplify formatting the options for calling a prompt dialog.
+       *
+       * @param dialogId ID of the prompt dialog to start.
+       * @param promptOrOptions The text of the initial prompt to send the user,
+       *      the activity to send as the initial prompt, or
+       *      the object with which to format the prompt dialog.
+       * @param choices Optional. Array of choices for the user to choose from,
+       *      for use with a ChoicePrompt.
+       *
+       * @remarks
+       * This helper method formats the object to use as the `options` parameter, and then calls
+       * DialogContext.beginDialog to start the specified prompt dialog.
+       *
+       */
+    prompt(dialogId: string, promptOrOptions: string | Partial<Activity> | PromptOptions): Promise<DialogTurnResult>;
+    /**
+       * Helper function to simplify formatting the options for calling a prompt dialog.
+       *
+       * @param dialogId ID of the prompt dialog to start.
+       * @param promptOrOptions The text of the initial prompt to send the user,
+       * the Activity to send as the initial prompt, or
+       * the object with which to format the prompt dialog.
+       * @param choices Optional. Array of choices for the user to choose from,
+       * for use with a ChoicePrompt.
+       * @remarks
+       * This helper method formats the object to use as the `options` parameter, and then calls
+       * DialogContext.beginDialog to start the specified prompt dialog.
+       *
+       */
+    prompt(dialogId: string, promptOrOptions: string | Partial<Activity> | PromptOptions, choices: (string | Choice)[]): Promise<DialogTurnResult>;
+    /**
+       * Continues execution of the active dialog, if there is one, by passing this dialog context to its
+       * Dialog.continueDialog method.
+       *
+       * @returns {Promise<DialogTurnResult>} a promise resolving to the dialog turn result.
+       * @remarks
+       * After the call completes, you can check the turn context's TurnContext.responded
+       * property to determine if the dialog sent a reply to the user.
+       *
+       * The DialogTurnResult.status of returned object describes
+       * the status of the dialog stack after this method completes.
+       *
+       * Typically, you would call this from within your agent's turn handler.
+       *
+       */
+    continueDialog(): Promise<DialogTurnResult>;
+    /**
+       * Ends a dialog and pops it off the stack. Returns an optional result to the dialog's parent.
+       *
+       * @param result Optional. A result to pass to the parent logic. This might be the next dialog
+       *      on the stack, or if this was the last dialog on the stack, a parent dialog context or
+       *      the agent's turn handler.
+       * @returns {Promise<DialogTurnResult>} a promise resolving to the dialog turn result.
+       * @remarks
+       * The _parent_ dialog is the next dialog on the dialog stack, if there is one. This method
+       * calls the parent's Dialog.resumeDialog method,
+       * passing the result returned by the ending dialog. If there is no parent dialog, the turn ends
+       * and the result is available to the agent through the returned object's
+       * DialogTurnResult.result property.
+       *
+       * The DialogTurnResult.status of returned object describes
+       * the status of the dialog stack after this method completes.
+       *
+       * Typically, you would call this from within the logic for a specific dialog to signal back to
+       * the dialog context that the dialog has completed, the dialog should be removed from the stack,
+       * and the parent dialog should resume.
+       *
+       */
+    endDialog(result?: any): Promise<DialogTurnResult>;
+    /**
+       * Ends the active dialog and starts a new dialog in its place.
+       *
+       * @param dialogId ID of the dialog to start.
+       * @param options Optional. Arguments to pass into the new dialog when it starts.
+       * @returns {Promise<DialogTurnResult>} a promise resolving to the dialog turn result.
+       * @remarks
+       * This is particularly useful for creating a loop or redirecting to another dialog.
+       *
+       * The DialogTurnResult.status of returned object describes
+       * the status of the dialog stack after this method completes.
+       *
+       * This method is similar to ending the current dialog and immediately beginning the new one.
+       * However, the parent dialog is neither resumed nor otherwise notified.
+       *
+       */
+    replaceDialog(dialogId: string, options?: object): Promise<DialogTurnResult>;
+    /**
+       * Requests the active dialog to re-prompt the user for input.
+       *
+       * @remarks
+       * This calls the active dialog's Dialog.repromptDialog method.
+       *
+       */
+    repromptDialog(): Promise<void>;
+    /**
+       * Searches for a dialog with a given ID.
+       *
+       * @remarks
+       * Emits a named event for the current dialog, or someone who started it, to handle.
+       * @param name Name of the event to raise.
+       * @param value Optional. Value to send along with the event.
+       * @param bubble Optional. Flag to control whether the event should be bubbled to its parent if not handled locally. Defaults to a value of `true`.
+       * @param fromLeaf Optional. Whether the event is emitted from a leaf node.
+       * @returns `true` if the event was handled.
+       */
+    emitEvent(name: string, value?: any, bubble?: boolean, fromLeaf?: boolean): Promise<boolean>;
+    /**
+       * @private
+       * @param reason
+       * @param result
+       */
+    private endActiveDialog;
+}