/**
 * 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.
       *
       * @returns The Id for the dialog.
       *
       * @remarks
       * This will be automatically generated if not specified.
       */
    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.
       *
       * @returns Unique string which should only change when dialog has changed in a way that should restart the dialog.
       *
       * @remarks
       * This defaults to returning the dialog's `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.
       *
       */
    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 {@link DialogContext} calls this method when it creates
       * a new {@link DialogInstance} for this dialog, pushes it
       * onto the dialog stack, and starts the dialog.
       *
       * A dialog that represents a single-turn conversation should await
       * {@link 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.
       * @returns {Promise<DialogTurnResult>} A promise resolving to the dialog turn result.
       *
       * @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 {@link DialogContext} calls this method when it continues
       * the dialog.
       *
       * To signal to the dialog context that this dialog has completed, await
       * {@link DialogContext.endDialog} before exiting this method.
       *
       */
    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.
       * @returns {Promise<DialogTurnResult>} A promise resolving to the dialog turn result.
       *
       * @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 {@link 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 {@link DialogContext.beginDialog} or {@link 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 {@link DialogContext.endDialog} before exiting this method.
       *
       */
    resumeDialog(dc: DialogContext, reason: DialogReason, result?: any): Promise<DialogTurnResult>;
    /**
       * When overridden in a derived class, prompts the user again 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 {@link 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 {@link 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 {@link DialogContext.emitEvent | DialogContext.emitEvent method },
       * 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.
       *
       * @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.
       *
       * @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.
       */
    protected onPreBubbleEvent(_dc: DialogContext, _e: DialogEvent): Promise<boolean>;
    /**
       * Called after an event was bubbled to all parents and wasn't handled.
       *
       * @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.
       *
       * @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.
       */
    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;
}