@microsoft/agents-hosting-dialogs 0.1.49

package/dist/src/componentDialog.js

@@ -0,0 +1,252 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComponentDialog = void 0;
+const dialog_1 = require("./dialog");
+const dialogContext_1 = require("./dialogContext");
+const dialogContainer_1 = require("./dialogContainer");
+const dialogReason_1 = require("./dialogReason");
+const dialogTurnStatus_1 = require("./dialogTurnStatus");
+const PERSISTED_DIALOG_STATE = 'dialogs';
+/**
+ * Base class for a dialog that contains other child dialogs.
+ *
+ * @remarks
+ * Component dialogs let you break your agent's logic up into components that can themselves be added
+ * as a dialog to another `ComponentDialog` or `DialogSet`. Components can also be exported as part
+ * of a node package and used within other agents.
+ *
+ * @param O (Optional) options that can be passed into the `DialogContext.beginDialog()` method.
+ */
+class ComponentDialog extends dialogContainer_1.DialogContainer {
+    /**
+       * Called when the dialog is started and pushed onto the parent's dialog stack.
+       * By default, this calls the
+       * Dialog.BeginDialogAsync(DialogContext, object, CancellationToken) method
+       * of the component dialog's initial dialog, as defined by InitialDialogId.
+       * Override this method in a derived class to implement interrupt logic.
+       *
+       * @param outerDialogContext The parent DialogContext for the current turn of conversation.
+       * @param options Optional, initial information to pass to the dialog.
+       * @returns A Promise representing the asynchronous operation.
+       * @remarks
+       * If the task is successful, the result indicates whether the dialog is still
+       * active after the turn has been processed by the dialog.
+       */
+    async beginDialog(outerDialogContext, options) {
+        await this.checkForVersionChange(outerDialogContext);
+        // Start the inner dialog.
+        const innerDC = this.createChildContext(outerDialogContext);
+        const turnResult = await this.onBeginDialog(innerDC, options);
+        // Check for end of inner dialog
+        if (turnResult.status !== dialogTurnStatus_1.DialogTurnStatus.waiting) {
+            if (turnResult.status === dialogTurnStatus_1.DialogTurnStatus.cancelled) {
+                await this.endComponent(outerDialogContext, turnResult.result);
+                const cancelledTurnResult = {
+                    status: dialogTurnStatus_1.DialogTurnStatus.cancelled,
+                    result: turnResult.result,
+                };
+                return cancelledTurnResult;
+            }
+            // Return result to calling dialog
+            return await this.endComponent(outerDialogContext, turnResult.result);
+        }
+        // Just signal end of turn
+        return dialog_1.Dialog.EndOfTurn;
+    }
+    /**
+       * Called when the dialog is _continued_, where it is the active dialog and the
+       * user replies with a new Activity.
+       * If this method is *not* overridden, the dialog automatically ends when the user replies.
+       *
+       * @param outerDialogContext The parent DialogContext for the current turn of conversation.
+       * @returns A Promise representing the asynchronous operation.
+       * @remarks
+       * If the task is successful, the result indicates whether the dialog is still
+       * active after the turn has been processed by the dialog. The result may also contain a
+       * return value.
+       */
+    async continueDialog(outerDialogContext) {
+        await this.checkForVersionChange(outerDialogContext);
+        // Continue execution of inner dialog.
+        const innerDC = this.createChildContext(outerDialogContext);
+        const turnResult = await this.onContinueDialog(innerDC);
+        // Check for end of inner dialog
+        if (turnResult.status !== dialogTurnStatus_1.DialogTurnStatus.waiting) {
+            // Return result to calling dialog
+            return await this.endComponent(outerDialogContext, turnResult.result);
+        }
+        // Just signal end of turn
+        return dialog_1.Dialog.EndOfTurn;
+    }
+    /**
+       * Called when a child dialog on the parent's dialog stack completed this turn, returning
+       * control to this dialog component.
+       *
+       * @param outerDialogContext The DialogContext for the current turn of conversation.
+       * @param _reason Reason why the dialog resumed.
+       * @param _result Optional, value returned from the dialog that was called. The type
+       * of the value returned is dependent on the child dialog.
+       * @returns A Promise representing the asynchronous operation.
+       * @remarks
+       * If the task is successful, the result indicates whether this dialog is still
+       * active after this dialog turn has been processed.
+       * Generally, the child dialog was started with a call to
+       * beginDialog(DialogContext, object) in the parent's
+       * context. However, if the DialogContext.replaceDialog(string, object) method
+       * is called, the logical child dialog may be different than the original.
+       * If this method is *not* overridden, the dialog automatically calls its
+       * RepromptDialog(ITurnContext, DialogInstance) when the user replies.
+       */
+    async resumeDialog(outerDialogContext, _reason, _result) {
+        await this.checkForVersionChange(outerDialogContext);
+        // Containers are typically leaf nodes on the stack but the dev is free to push other dialogs
+        // on top of the stack which will result in the container receiving an unexpected call to
+        // resumeDialog() when the pushed on dialog ends.
+        // To avoid the container prematurely ending we need to implement this method and simply
+        // ask our inner dialog stack to re-prompt.
+        await this.repromptDialog(outerDialogContext.context, outerDialogContext.activeDialog);
+        return dialog_1.Dialog.EndOfTurn;
+    }
+    /**
+       * Called when the dialog should re-prompt the user for input.
+       *
+       * @param context The TurnContext object for this turn.
+       * @param instance State information for this dialog.
+       * @returns A Promise representing the asynchronous operation.
+       */
+    async repromptDialog(context, instance) {
+        // Forward to inner dialogs
+        const innerDC = this.createInnerDC(context, instance);
+        await innerDC.repromptDialog();
+        // Notify component.
+        await this.onRepromptDialog(context, instance);
+    }
+    /**
+       * Called when the Dialog is ending.
+       *
+       * @param context The TurnContext object for this turn.
+       * @param instance State information associated with the instance of this component Dialog on its parent's dialog stack.
+       * @param reason Reason why the Dialog ended.
+       * @returns A Promise representing the asynchronous operation.
+       * @remarks When this method is called from the parent dialog's context, the component Dialog
+       * cancels all of the dialogs on its inner dialog stack before ending.
+       */
+    async endDialog(context, instance, reason) {
+        // Forward cancel to inner dialogs
+        if (reason === dialogReason_1.DialogReason.cancelCalled) {
+            const innerDC = this.createInnerDC(context, instance);
+            await innerDC.cancelAllDialogs();
+        }
+        // Notify component
+        await this.onEndDialog(context, instance, reason);
+    }
+    /**
+       * Adds a child Dialog or prompt to the components internal DialogSet.
+       *
+       * @param dialog The child Dialog or prompt to add.
+       * @returns The ComponentDialog after the operation is complete.
+       * @remarks
+       * The Dialog.id of the first child added to the component will be assigned to the initialDialogId property.
+       */
+    addDialog(dialog) {
+        this.dialogs.add(dialog);
+        if (this.initialDialogId === undefined) {
+            this.initialDialogId = dialog.id;
+        }
+        return this;
+    }
+    /**
+       * Creates the inner dialog context
+       *
+       * @param outerDialogContext the outer dialog context
+       * @returns The created Dialog Context.
+       */
+    createChildContext(outerDialogContext) {
+        return this.createInnerDC(outerDialogContext, outerDialogContext.activeDialog);
+    }
+    /**
+       * Called anytime an instance of the component has been started.
+       *
+       * @remarks
+       * SHOULD be overridden by components that wish to perform custom interruption logic. The
+       * default implementation calls `innerDC.beginDialog()` with the dialog assigned to
+       * initialdialogid.
+       * @param innerDialogContext Dialog context for the components internal `DialogSet`.
+       * @param options (Optional) options that were passed to the component by its parent.
+       * @returns {Promise<DialogTurnResult>} A promise resolving to the dialog turn result.
+       */
+    onBeginDialog(innerDialogContext, options) {
+        return innerDialogContext.beginDialog(this.initialDialogId, options);
+    }
+    /**
+       * Called anytime a multi-turn component receives additional activities.
+       *
+       * @remarks
+       * SHOULD be overridden by components that wish to perform custom interruption logic. The
+       * default implementation calls `innerDC.continueDialog()`.
+       * @param innerDC Dialog context for the components internal `DialogSet`.
+       * @returns {Promise<DialogTurnResult>} A promise resolving to the dialog turn result.
+       */
+    onContinueDialog(innerDC) {
+        return innerDC.continueDialog();
+    }
+    /**
+       * Called when the component is ending.
+       *
+       * @remarks
+       * If the `reason` code is equal to `DialogReason.cancelCalled`, then any active child dialogs
+       * will be cancelled before this method is called.
+       * @param _context Context for the current turn of conversation.
+       * @param _instance The components instance data within its parents dialog stack.
+       * @param _reason The reason the component is ending.
+       * @returns A promise representing the asynchronous operation.
+       */
+    onEndDialog(_context, _instance, _reason) {
+        return Promise.resolve();
+    }
+    /**
+       * Called when the component has been requested to re-prompt the user for input.
+       *
+       * @remarks
+       * The active child dialog will have already been asked to reprompt before this method is called.
+       * @param _context Context for the current turn of conversation.
+       * @param _instance The instance of the current dialog.
+       * @returns A promise representing the asynchronous operation.
+       */
+    onRepromptDialog(_context, _instance) {
+        return Promise.resolve();
+    }
+    /**
+       * Called when the components last active child dialog ends and the component is ending.
+       *
+       * @remarks
+       * SHOULD be overridden by components that wish to perform custom logic before the component
+       * ends.  The default implementation calls `outerDC.endDialog()` with the `result` returned
+       * from the last active child dialog.
+       * @param outerDC Dialog context for the parents `DialogSet`.
+       * @param result Result returned by the last active child dialog. Can be a value of `undefined`.
+       * @returns {Promise<DialogTurnResult>} A promise resolving to the dialog turn result.
+       */
+    endComponent(outerDC, result) {
+        return outerDC.endDialog(result);
+    }
+    /**
+       * @private
+       * @param context TurnContext or DialogContext for the current turn of conversation with the user.
+       * @param instance DialogInstance which contains the current state information for this dialog.
+       * @returns A new DialogContext instance.
+       * @remarks
+       * You should only call this if you don't have a dc to work with (such as OnResume())
+       */
+    createInnerDC(context, instance) {
+        if (!instance) {
+            const dialogInstance = { state: {} };
+            instance = dialogInstance;
+        }
+        const dialogState = instance.state[PERSISTED_DIALOG_STATE] || { dialogStack: [] };
+        instance.state[PERSISTED_DIALOG_STATE] = dialogState;
+        return new dialogContext_1.DialogContext(this.dialogs, context, dialogState);
+    }
+}
+exports.ComponentDialog = ComponentDialog;
+//# sourceMappingURL=componentDialog.js.map

package/dist/src/componentDialog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"componentDialog.js","sourceRoot":"","sources":["../../src/componentDialog.ts"],"names":[],"mappings":"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"}

package/dist/src/componentRegistration.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+/**
+ * ComponentRegistration is a signature class for discovering assets from components.
+ */
+export declare class ComponentRegistration {
+    private static readonly _components;
+    /**
+       * Gets list of all ComponentRegistration objects registered.
+       *
+       * @returns A list of ComponentRegistration objects.
+       */
+    static get components(): ComponentRegistration[];
+    /**
+       * Add a component, only one instance per type is allowed for components.
+       *
+       * @param componentRegistration The component to be registered.
+       */
+    static add(componentRegistration: ComponentRegistration): void;
+}

package/dist/src/componentRegistration.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComponentRegistration = void 0;
+/**
+ * ComponentRegistration is a signature class for discovering assets from components.
+ */
+class ComponentRegistration {
+    /**
+       * Gets list of all ComponentRegistration objects registered.
+       *
+       * @returns A list of ComponentRegistration objects.
+       */
+    static get components() {
+        return Array.from(ComponentRegistration._components.values());
+    }
+    /**
+       * Add a component, only one instance per type is allowed for components.
+       *
+       * @param componentRegistration The component to be registered.
+       */
+    static add(componentRegistration) {
+        const name = componentRegistration.constructor.name;
+        ComponentRegistration._components.set(name, componentRegistration);
+    }
+}
+exports.ComponentRegistration = ComponentRegistration;
+ComponentRegistration._components = new Map();
+//# sourceMappingURL=componentRegistration.js.map

package/dist/src/componentRegistration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"componentRegistration.js","sourceRoot":"","sources":["../../src/componentRegistration.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH;;GAEG;AACH,MAAa,qBAAqB;IAGhC;;;;SAIK;IACL,MAAM,KAAK,UAAU;QACnB,OAAO,KAAK,CAAC,IAAI,CAAC,qBAAqB,CAAC,WAAW,CAAC,MAAM,EAAE,CAAC,CAAA;IAC/D,CAAC;IAED;;;;SAIK;IACL,MAAM,CAAC,GAAG,CAAE,qBAA4C;QACtD,MAAM,IAAI,GAAG,qBAAqB,CAAC,WAAW,CAAC,IAAI,CAAA;QACnD,qBAAqB,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,EAAE,qBAAqB,CAAC,CAAA;IACpE,CAAC;;AApBH,sDAqBC;AApByB,iCAAW,GAAuC,IAAI,GAAG,EAAiC,CAAA"}

package/dist/src/configurable.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { Converter, ConverterFactory } from './converter';
+/**
+ * Base class for all configurable classes.
+ */
+export declare abstract class Configurable {
+    /**
+       * Fluent method for configuring the object.
+       *
+       * @param config Configuration settings to apply.
+       * @returns The Configurable after the operation is complete.
+       */
+    configure(config: Record<string, unknown>): this;
+    /**
+       * @param _property The key of the conditional selector configuration.
+       * @returns The converter for the selector configuration.
+       */
+    getConverter(_property: string): Converter | ConverterFactory;
+}

package/dist/src/configurable.js

@@ -0,0 +1,60 @@
+"use strict";
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Configurable = void 0;
+/**
+ * Base class for all configurable classes.
+ */
+class Configurable {
+    /**
+       * Fluent method for configuring the object.
+       *
+       * @param config Configuration settings to apply.
+       * @returns The Configurable after the operation is complete.
+       */
+    configure(config) {
+        for (const key in config) {
+            if (Object.prototype.hasOwnProperty.call(config, key)) {
+                const setting = config[`${key}`];
+                const converter = this.getConverter(key);
+                if (converter && typeof converter === 'object') {
+                    this[`${key}`] = converter.convert(setting);
+                }
+                else {
+                    if (Array.isArray(setting)) {
+                        this[`${key}`] = setting;
+                    }
+                    else if (typeof setting === 'object') {
+                        if (typeof this[`${key}`] === 'object') {
+                            // Apply as a map update
+                            for (const child in setting) {
+                                if (Object.prototype.hasOwnProperty.call(setting, child)) {
+                                    this[`${key}`][`${child}`] = setting[`${child}`];
+                                }
+                            }
+                        }
+                        else {
+                            this[`${key}`] = setting;
+                        }
+                    }
+                    else if (setting !== undefined) {
+                        this[`${key}`] = setting;
+                    }
+                }
+            }
+        }
+        return this;
+    }
+    /**
+       * @param _property The key of the conditional selector configuration.
+       * @returns The converter for the selector configuration.
+       */
+    getConverter(_property) {
+        return undefined;
+    }
+}
+exports.Configurable = Configurable;
+//# sourceMappingURL=configurable.js.map

package/dist/src/configurable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"configurable.js","sourceRoot":"","sources":["../../src/configurable.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAIH;;GAEG;AACH,MAAsB,YAAY;IAChC;;;;;SAKK;IACL,SAAS,CAAE,MAA+B;QACxC,KAAK,MAAM,GAAG,IAAI,MAAM,EAAE,CAAC;YACzB,IAAI,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC;gBACtD,MAAM,OAAO,GAAG,MAAM,CAAC,GAAG,GAAG,EAAE,CAAC,CAAA;gBAChC,MAAM,SAAS,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,CAAA;gBACxC,IAAI,SAAS,IAAI,OAAO,SAAS,KAAK,QAAQ,EAAE,CAAC;oBAC/C,IAAI,CAAC,GAAG,GAAG,EAAE,CAAC,GAAG,SAAS,CAAC,OAAO,CAAC,OAAO,CAAC,CAAA;gBAC7C,CAAC;qBAAM,CAAC;oBACN,IAAI,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;wBAC3B,IAAI,CAAC,GAAG,GAAG,EAAE,CAAC,GAAG,OAAO,CAAA;oBAC1B,CAAC;yBAAM,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;wBACvC,IAAI,OAAO,IAAI,CAAC,GAAG,GAAG,EAAE,CAAC,KAAK,QAAQ,EAAE,CAAC;4BACvC,wBAAwB;4BACxB,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;gCAC5B,IAAI,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,EAAE,CAAC;oCACzD,IAAI,CAAC,GAAG,GAAG,EAAE,CAAC,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,GAAG,KAAK,EAAE,CAAC,CAAA;gCAClD,CAAC;4BACH,CAAC;wBACH,CAAC;6BAAM,CAAC;4BACN,IAAI,CAAC,GAAG,GAAG,EAAE,CAAC,GAAG,OAAO,CAAA;wBAC1B,CAAC;oBACH,CAAC;yBAAM,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;wBACjC,IAAI,CAAC,GAAG,GAAG,EAAE,CAAC,GAAG,OAAO,CAAA;oBAC1B,CAAC;gBACH,CAAC;YACH,CAAC;QACH,CAAC;QACD,OAAO,IAAI,CAAA;IACb,CAAC;IAED;;;SAGK;IACL,YAAY,CAAE,SAAiB;QAC7B,OAAO,SAAS,CAAA;IAClB,CAAC;CACF;AA5CD,oCA4CC"}

package/dist/src/configuration.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Configuration is an interface that is used to obtain configurable values
+ */
+export interface Configuration {
+    get<T = unknown>(path?: string[]): T | undefined;
+    set(path: string[], value: unknown): void;
+}
+/**
+ * Useful for shimming Components into ComponentRegistrations
+ */
+export declare const noOpConfiguration: Configuration;

package/dist/src/configuration.js

@@ -0,0 +1,17 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noOpConfiguration = void 0;
+/**
+ * Useful for shimming Components into ComponentRegistrations
+ */
+exports.noOpConfiguration = {
+    get(_path) {
+        return undefined;
+    },
+    set(_path, _value) {
+        // no-op
+    },
+};
+//# sourceMappingURL=configuration.js.map

package/dist/src/configuration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"configuration.js","sourceRoot":"","sources":["../../src/configuration.ts"],"names":[],"mappings":";AAAA,uCAAuC;AACvC,kCAAkC;;;AAUlC;;GAEG;AACU,QAAA,iBAAiB,GAAkB;IAC9C,GAAG,CAAE,KAAK;QACR,OAAO,SAAS,CAAA;IAClB,CAAC;IACD,GAAG,CAAE,KAAK,EAAE,MAAM;QAChB,QAAQ;IACV,CAAC;CACF,CAAA"}

package/dist/src/converter.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+/**
+ * The converter converts object from one type to another.
+ */
+export interface Converter<From = unknown, To = unknown> {
+    convert(value: From | To): To;
+}
+export type ConverterFactory<From = unknown, To = unknown> = {
+    new (...args: unknown[]): Converter<From, To>;
+};

package/dist/src/converter.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=converter.js.map

package/dist/src/converter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"converter.js","sourceRoot":"","sources":["../../src/converter.ts"],"names":[],"mappings":";AAAA;;;GAGG"}

package/dist/src/dialog.d.ts

@@ -0,0 +1,184 @@
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { TurnContext } from '@microsoft/agents-hosting';
+import { DialogContext } from './dialogContext';
+import { Configurable } from './configurable';
+import { DialogTurnResult } from './dialogTurnResult';
+import { DialogEvent } from './dialogEvent';
+import { DialogReason } from './dialogReason';
+import { DialogInstance } from './dialogInstance';
+/**
+ * Defines the core behavior for all dialogs.
+ */
+export declare abstract class Dialog<O extends object = {}> extends Configurable {
+    private _id;
+    /**
+       * 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.
+       */
+    static EndOfTurn: DialogTurnResult;
+    /**
+       * Creates a new instance of the Dialog class.
+       *
+       * @param dialogId Optional. unique ID of the dialog.
+       */
+    constructor(dialogId?: string);
+    /**
+       * Unique ID of the dialog.
+       *
+       * @remarks
+       * This will be automatically generated if not specified.
+       * @returns The Id for the dialog.
+       */
+    get id(): string;
+    /**
+       * Sets the unique ID of the dialog.
+       */
+    set id(value: string);
+    /**
+       * 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(): string;
+    /**
+       * When overridden in a derived class, starts the dialog.
+       *
+       * @param dc The context for the current dialog turn.
+       * @param options Optional. Arguments to use when the dialog starts.
+       *
+       * @remarks
+       * Derived dialogs must override this method.
+       *
+       * The DialogContext calls this method when it creates
+       * a new DialogInstance for this dialog, pushes it
+       * onto the dialog stack, and starts the dialog.
+       *
+       * A dialog that represents a single-turn conversation should await
+       * DialogContext.endDialog before exiting this method.
+       *
+       */
+    abstract beginDialog(dc: DialogContext, options?: O): Promise<DialogTurnResult>;
+    /**
+       * 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.
+       */
+    continueDialog(dc: DialogContext): Promise<DialogTurnResult>;
+    /**
+       * 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.
+       */
+    resumeDialog(dc: DialogContext, reason: DialogReason, result?: any): Promise<DialogTurnResult>;
+    /**
+       * 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.
+       *
+       */
+    repromptDialog(_context: TurnContext, _instance: DialogInstance): Promise<void>;
+    /**
+       * 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.
+       *
+       */
+    endDialog(_context: TurnContext, _instance: DialogInstance, _reason: DialogReason): Promise<void>;
+    /**
+       * 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>;
+    /**
+       * 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.
+       */
+    protected onPreBubbleEvent(_dc: DialogContext, _e: DialogEvent): Promise<boolean>;
+    /**
+       * 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.
+       */
+    protected onPostBubbleEvent(_dc: DialogContext, _e: DialogEvent): Promise<boolean>;
+    /**
+       * 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>'))`.
+       */
+    protected onComputeId(): string;
+}