import { DialogAdapter } from "./DialogAdapter";
export class DialogAdapterWatson extends DialogAdapter {
    /**
     * Prefix in Watson context that identifies items shared among
     *   Watson assistants participating in a multi-bot setup
     */
    static "__#7@#PREFIX_SHARED_WATSON": string;
    /**
     * Prefix in Watson context that identifies items shared between the router
     *   and Watson assistants
     */
    static "__#7@#PREFIX_SHARED_ROUTER": string;
    /**
     * Video formats that are supported by webchat router and Html5 video tag
     */
    static "__#7@#SUPPORTED_VIDEO_HTML5_FORMATS": string[];
    /**
     * Video format that is supported by webchat router
     */
    static "__#7@#VIDEO_YOUTUBE_FORMAT": string;
    /**
     * @param {object} params - Adapter parameters
     * @param {AdapterFactory} params.factory
     * @param {object} params.rawIOData - See OrchestratorFactory.create()
     * @param {object} params.config - the configurtion (typically just passed
     *   from the configuration file)
     *   It shoud contain at least the following:
     *     watson {
     *       apiUrl {string}
     *       apiVersion {string} - In the format YYYY-MM-DD
     *       apikey {string|Object}
     *       assistantId {string|Object}
     *       callRetries {number} - the maximum number of call retries
     *       anonymize {boolean} - Whether anonymization should be applied
     *     }
     *   and optionally:
     *       routerContextRWParams - list of the router shared context
     *                               parameters that may be set from Watson
     *       requestTimeoutMS - Timeout of requests to Watson (defaults to 3000)
     *   Logging setup:
     *     logs: {
     *       appInsights {string} - optional, enables AppInsights
     *       logzioToken {string} - optional, enables Logz.io
     *       prefix {string} - required for Logz.io
     *       isProduction {boolean} - required forr Logz.io
     *     }
     *   Parameters config.watson.apikey and config.watson.assistantId use Object
     *   format in case of multi-watson configuration; in this case the format is
     *   { APP_ID: APIKEY, ... } resp. { APP_ID: ASSISTANT_ID, ... }
     * @param {AssistantV2} params.watsonApi
     * @param {object} params.watsonConfig - Watson configuration gathered from
     *   the context configuration variables ($genbot-config-*)
     * @param {string} params.appId
     * @param {Console} params.logger
     * @param {Session} params.session
     * @param {Function} params.AnonymizerClass - class used as the anonymizer
     * @param {Function} params.anonymizationSplitter - see Anonymization
     */
    constructor(params: {
        factory: AdapterFactory;
        rawIOData: object;
        config: object;
        watsonApi: AssistantV2;
        watsonConfig: object;
        appId: string;
        logger: Console;
        session: Session;
        AnonymizerClass: Function;
        anonymizationSplitter: Function;
    });
    stats: {
        name: string;
        status: string;
        duration: number;
        calls: number;
    };
    anonymizer: any;
    /**
     * @param {string} appId
     * @returns {void}
     */
    setAppId(appId: string): void;
    appId: any;
    /**
     * @returns {object}
     */
    _getLastResponseContext(): object;
    /**
     * @param {object} context
     * @returns {object}
     */
    _removeRequestFromContext(context: object): object;
    /**
     * @param {GenericChatRequest} request
     * @returns {object}
     */
    _getContextForReturnFromPlugin(request: GenericChatRequest): object;
    /**
     * @param {GenericChatRequest} request
     * @returns {object}
     */
    _getContextForRequestWithParams(request: GenericChatRequest): object;
    /**
     * @param {GenericChatRequest} request
     * @returns {object}
     */
    _getContextForRoutingRequest(request: GenericChatRequest): object;
    /**
     * @param {object} context
     * @returns {void}
     */
    _addSharedContextToWatsonContext(context: object): void;
    /**
     * @param {object} context
     * @returns {void}
     */
    _addWatsonSharedContextToWatsonContext(context: object): void;
    /**
     * @param {object} context
     * @returns {void}
     */
    _addRouterSharedContextToWatsonContext(context: object): void;
    /**
     * @returns {object}
     */
    _getSuggestionId(): object;
    /**
     * @returns {object}
     */
    _getDefaultContext(): object;
    /**
     * @param {GenericChatRequest} request
     * @returns {object}
     */
    _getContextForTechnicalInput(request: GenericChatRequest): object;
    /**
     * @param {GenericChatRequest} request
     * @returns {object}
     */
    _getContextForEvent(request: GenericChatRequest): object;
    /**
     * @param {object} variables
     * @returns {void}
     */
    _saveVarsSoTheyCanBeDeletedAfterWatsonCall(variables: object): void;
    tmpVariables: string[] | undefined;
    /**
     * @param {object} watsonResponse
     * @returns {void}
     */
    _deleteVariablesFromWatsonContext(watsonResponse: object): void;
    /**
     * Converts object with namepace separator in keys to hierarchical object
     * (e. g. { 'a-b': 0 } => { a: { b: 0 } }
     *
     * @param {object} source
     * @param {string} [prefix]
     * @param {string} [separator]
     * @returns {object}
     */
    _namespaceNotationToObject(source: object, prefix?: string | undefined, separator?: string | undefined): object;
    /**
     * @param {object} context
     * @param {Array<string>} filter
     * @returns {object}
     */
    _getContextRequestParams(context: object, filter: Array<string>): object;
    /**
     * @param {GenericChatRequest} request
     * @param {GenericChatResponse} responseRest
     * @returns {object}
     */
    getRequestContext(request?: GenericChatRequest, responseRest?: GenericChatResponse): object;
    /**
     * @param {object} context
     * @returns {void}
     */
    _removeGenbotConfigurationFromContext(context: object): void;
    /**
     * @param {boolean} forceNewSession
     * @returns {Promise<string>} - Watson session id
     */
    _getWatsonSessionId(forceNewSession?: boolean): Promise<string>;
    /**
     * Abstract method implementation
     *
     */
    startWatsonSession(): Promise<any>;
    /**
     * @returns {object} - keys: sessionId, responseTime, watsonOnlyTime
     */
    _requestSessionFromWatson(): object;
    /**
     * @param {GenericChatRequest} request
     * @returns {boolean}
     */
    _isTechnicalInput(request: GenericChatRequest): boolean;
    /**
     * @param {GenericChatRequest} request
     * @returns {boolean}
     */
    _isEventToBeSentToWatson(request: GenericChatRequest): boolean;
    /**
     * @returns {boolean}
     */
    _updateWatsonApi(): boolean;
    watsonApi: any;
    /**
     * @param {GenericChatRequest} request
     * @returns {GenericChatResponse}
     */
    _getResponseForInvalidRouting(request: GenericChatRequest): GenericChatResponse;
    /**
     * @param {string} errorText
     * @returns {GenericChatReponse}
     */
    _getErrorResponse(errorText: string): GenericChatReponse;
    /**
     * @param {GenericChatResponse} responseRest
     * @param {GenericChatRequest} request
     * @returns {object}
     */
    _getWatsonInput(responseRest: GenericChatResponse, request: GenericChatRequest): object;
    /**
     * @param {string} text
     */
    _sanitizeTextForWatson(text: string): string;
    /**
     * @param {GenericChatRequest} request
     * @returns {object}
     */
    _getWatsonInputForUserInput(request: GenericChatRequest): object;
    /**
     * @param {GenericChatRequest} request
     * @returns {string} - Returns null if there is no intent specified
     */
    _getRoutingIntent(request: GenericChatRequest): string;
    /**
     * @returns {object}
     */
    _getWatsonInputForTechnicalInput(): object;
    /**
     * @return {object}
     */
    _getRawRequestData(): object;
    /**
     * @param {boolean} restart
     * @returns {object}
     */
    getWatsonMessageOptions(restart?: boolean): object;
    /**
     * @param {object} context
     */
    _addVarsToRequestContext(context: object): void;
    /**
     * @param {object} context
     * @param {object} values
     */
    _addVarsToWatsonContext(context: object, values: object): void;
    /**
     * @param {object} watsonResponse
     * @param {GenericChatResponse} responseRest
     * @param {GenericChatRequest} request
     * @param {GenericChatResponse} response
     * @returns {object}
     */
    _addPluginAfterCallDebugToResponse(watsonResponse: object, responseRest: GenericChatResponse, request: GenericChatRequest, response: GenericChatResponse): object;
    /**
     * @param {object} watsonResponse
     * @param {GenericChatResponse} responseRest
     * @param {GenericChatRequest} request
     * @param {GenericChatResponse} response
     * @returns {void}
     */
    _parseConversationDebugMessages(watsonResponse: object, responseRest: GenericChatResponse, request: GenericChatRequest, response: GenericChatResponse): void;
    /**
     * @param {object} watsonResponse
     * @param {GenericChatResponse} responseRest
     * @param {GenericChatRequest} request
     * @param {GenericChatResponse} response
     * @returns {object}
     */
    _addAnonymizationDebugToResponse(watsonResponse: object, responseRest: GenericChatResponse, request: GenericChatRequest, response: GenericChatResponse): object;
    watsonMessageCall(context: any, input: any): Promise<any>;
    _replaceVariables(string: any, conversationVariables: any, watsonVariables: any): any;
    replaceVariables(generic: any, conversationVariables: any, watsonVariables: any): void;
    replaceStringVariables(input: any): Promise<PromiseSettledResult<any>[]>;
    /**
     * @param {object} context
     * @param {object} input
     * @returns {Promise<object>}
     */
    watsonMessage(context: object, input: object): Promise<object>;
    /**
     * @param {object} variables
     * @returns {void}
     */
    _saveConversationVariablesLocally(variables: object): void;
    conversationVariables: object | undefined;
    /**
     * @param {GenericChatResponse} responseRest
     * @param {GenericChatRequest} request
     * @returns {object}
     */
    _getWatsonInputForResponseRest(responseRest: GenericChatResponse, request: GenericChatRequest): object;
    /**
     * @param {GenericChatResponse} responseRest
     * @param {GenericChatRequest} request
     * @returns {object}
     */
    _getWatsonInputForSuggestionSelected(responseRest: GenericChatResponse, request: GenericChatRequest): object;
    /**
     * @param {object} action
     * @param {GenericChatRequest} request
     * @returns {boolean}
     */
    _isPluginActionForRequest(action: object, request: GenericChatRequest): boolean;
    /**
     * Throws an exception if request.action is not recognized
     *
     * @param {GenericChatResponse} responseRest
     * @param {GenericChatRequest} request
     * @returns {object}
     */
    _getWatsonInputForPluginAfterCall(responseRest: GenericChatResponse, request: GenericChatRequest): object;
    /**
     * @returns {object}
     */
    _getWatsonInputForReturnFromMicroApp(): object;
    /**
     * @param {GenericChatRequest} request
     * @param {object} watsonInput
     * @param {object} context
     * @param {int} startTimeMS - getResponse start time in ms
     * @returns {object}
     */
    _getWatsonResponse(request: GenericChatRequest, watsonInput: object, context: object, startTimeMS: int): object;
    /**
     * @param {GenericChatRequest} request
     * @returns {object}
     */
    _getResponseForIgnoredTechnicalInput(request: GenericChatRequest): object;
    /**
     * @param {GenericChatRequest} request
     * @returns {boolean}
     */
    _isIgnoredTechnicalInput(request: GenericChatRequest): boolean;
    /**
     * @param {string} oldSessionId
     * @param {string} newSessionId
     * @param {string} senderId
     * @param {integer} responseTime
     * @param {string} watsonOnlyTime
     * @param {string} extraInfo
     * @returns {void}
     */
    _logWatsonCreateSession(oldSessionId: string, newSessionId: string, senderId: string, responseTime: integer, watsonOnlyTime: string, extraInfo?: string): void;
    /**
     * @param {integer} attemptNo - Counted from 1
     * @param {string} oldSessionId
     * @param {string} senderId
     * @param {integer} responseTime
     * @param {Error} exception
     * @param {string} extraInfo
     * @returns {void}
     */
    _logWatsonCreateSessionFailure(attemptNo: integer, oldSessionId: string, senderId: string, responseTime: integer, exception: Error, extraInfo?: string): void;
    /**
     * @returns {string}
     */
    getAssistantId(): string;
    /**
     * @param {GenericChatRequest} request
     * @param {string} sessionId
     * @param {string} senderId
     * @param {integer} responseTime
     * @param {object} watsonInput
     * @param {object} watsonResponse
     * @param {string} extraInfo
     * @returns {void}
     */
    logWatsonMessage(request: GenericChatRequest, sessionId: string, senderId: string, responseTime: integer, watsonInput: object, watsonResponse: object, extraInfo?: string): void;
    /**
     * @param {GenericChatRequest} request
     * @param {integer} attemptNo - Counted from 1
     * @param {string} sessionId
     * @param {string} senderId
     * @param {integer} responseTime
     * @param {object} watsonInput
     * @param {Error} exception
     * @param {string} extraInfo
     * @returns {void}
     */
    _logWatsonMessageFailure(request: GenericChatRequest, attemptNo: integer, sessionId: string, senderId: string, responseTime: integer, watsonInput: object, exception: Error, extraInfo?: string): void;
    /**
     * Overridden method
     *
     * @param {GenericChatRequest} request
     * @param {object} watsonResponse - Watson response
     * @param {GenericChatResponse} responseRest
     * @returns {GenericChatResponse}
     */
    toGenericResponse(request: GenericChatRequest, watsonResponse: object, responseRest?: GenericChatResponse): GenericChatResponse;
    /**
     * Overridden method
     *
     * @param {object} watsonResponse
     * @param {object} response - Watson response
     * @param {object} watsonSharedContextOverride
     * @param {object} routerSharedContextOverride
     * @returns {boolean} True if the required context update is valid
     */
    _addSharedContextToResponse(watsonResponse: object, response: object, watsonSharedContextOverride?: object, routerSharedContextOverride?: object): boolean;
    /**
     * @param {object} watsonResponse
     * @param {string} prefix
     * @param {object} override
     * @return {object}
     */
    _extractContextPartWithPrefixFromResponse(watsonResponse: object, prefix: string, override: object): object;
    /**
     * @param {object} obj
     * @param {object} oldObj
     * @returns {object} Returns object of changed and added properties
     *   (deleted properties are ignored)
     */
    _getObjModification(obj: object, oldObj: object): object;
    /**
     * Overridden method
     *
     * @param {object} watsonResponse
     * @param {object} response - Watson response
     * @param {object} sharedContextOverride
     * @returns {boolean} True if the requested context update is valid
     */
    _addWatsonSharedContextToResponse(watsonResponse: object, response: object, sharedContextOverride?: object): boolean;
    /**
     * Overridden method
     *
     * @param {object} watsonResponse
     * @param {object} response - Watson response
     * @param {object} sharedContextOverride
     * @returns {boolean} True if the requested context update is valid
     */
    _addRouterSharedContextToResponse(watsonResponse: object, response: object, sharedContextOverride?: object): boolean;
    /**
     * @param {GenericChatRequest} request
     * @param {object} routingConfig
     * @param {boolean} externalTarget
     * @param {object} response - Watson response
     * @returns {GenericChatResponse}
     */
    _addRoutingInfoToResponse(request: GenericChatRequest, routingConfig: object, externalTarget: boolean, response: object): GenericChatResponse;
    /**
     * @param {object} watsonResponse - Raw response received from Watson
     *   Assistant
     * @returns {boolean}
     */
    _isRoutingRule(watsonResponse: object): boolean;
    /**
     * @param {GenericChatRequest} request
     * @param {object} watsonResponse - Raw response received from Watson
     *   Assistant
     * @param {GenericChatResponse} genericResponse
     */
    _addResponseToGenericResponse(request: GenericChatRequest, watsonResponse: object, genericResponse: GenericChatResponse): void;
    disambiguationFound: boolean | undefined;
    /**
     * Creates a copy of the watson response where the data that will
     * not be needed any more are removed
     *
     * @param {object} watsonResponse
     * @returns {object}
     */
    _pruneWatsonResponse(watsonResponse: object): object;
    /**
     * @param {number} index
     * @param {object[]} items
     * @returns {boolean}
     */
    _isLastTextInWatsonReponseItems(index: number, items: object[]): boolean;
    /**
     * @param {object} watsonResponse - Raw response received from Watson
     *   Assistant
     * @returns {object}
     */
    _getResponseContext(watsonResponse: object): object;
    /**
     * @param {object} watsonResponse - Raw response received from Watson
     *   Assistant
     * @returns {Array} - Array of watson response elements
     */
    _getResponseItems(watsonResponse: object): any[];
    /**
     * @param {object} watsonResponse - Raw response received from Watson
     *   Assistant
     * @returns {Array} - Array of watson response user defined actions
     */
    _getResponseCustomActions(watsonResponse: object): any[];
    /**
     * @param {object} item - Watson raw response item
     * @param {GenericChatResponse} response
     * @return {void}
     */
    _extractText(item: object, response: GenericChatResponse): void;
    /**
     * @param {GenericChatRequest} request
     * @param {object} watsonResponse
     * @param {object} action - the actions element fromt the 'user_defined'
     *   part of the Watson response
     * @param {object} context
     * @param {GenericChatResponse} response
     * @return {void}
     */
    _extractAction(request: GenericChatRequest, watsonResponse: object, action: object, context: object, response: GenericChatResponse): void;
    /**
     * @param {object} watsonResponse
     * @param {object} context
     * @param {GenericChatResponse} genericResponse
     * @return {void}
     */
    _extractMicroApp(watsonResponse: object, context: object, genericResponse: GenericChatResponse): void;
    /**
     * @param {object} microapp
     * @param {GenericChatResponse} genericResponse
     * @returns {booelan}
     */
    _microAppSpecValid(microapp: object, genericResponse: GenericChatResponse): booelan;
    /**
     * @param {Array<object>} nodesVisited - nodes in the format in which it comes
     *   from Watson
     * @returns {Array<string>}
     */
    _filterDialogNodesForStatistics(nodesVisited: Array<object>): Array<string>;
    /**
     * @param {object} watsonResponse - Watson response
     * @param {GenericChatResponse} genericResponse
     */
    _checkInstructionsInWatsonContext(watsonResponse: object, genericResponse: GenericChatResponse): void;
    /**
     * @param {object} watsonResponse - Watson response
     * @param {GenericChatResponse} genericResponse
     */
    _addDialogStatisticsToResponse(watsonResponse: object, genericResponse: GenericChatResponse): void;
    /**
     * @param {object[]} nodesVisited - nodes_visited part of the
     *   watson message() response
     * @returns {boolean}
     */
    _isInSlot(nodesVisited: object[]): boolean;
    /**
     * @param {object} action - See _extractAction()
     * @param {object} context
     * @param {GenericChatResponse} response
     * @return {boolean} - Returns true if the action corresponds to the plugin
     *   call
     */
    _extractActionPluginCall(action: object, context: object, response: GenericChatResponse): boolean;
    /**
     * @param {object} action - See _extractAction()
     * @param {object} context
     * @param {GenericChatResponse} response
     * @return {boolean} - Returns true if the action corresponds to the plugin
     *   call
     */
    _extractUiAction(action: object, context: object, response: GenericChatResponse): boolean;
    /**
     * @returns {boolean}
     */
    _inMasterBot(): boolean;
    /**
     * @param {object} routeSpec - The route part of the Watson JSON
     *   (see doc/WatsonAssitant.md)
     * @param {GenericChatResponse} response - ResponseItemError is written here in case
     *   of check failure
     * @returns {boolean}
     */
    _routeTargetOk(routeSpec: object, response: GenericChatResponse): boolean;
    /**
     * @returns {Set<string>}
     */
    _getRoutingTargets(): Set<string>;
    /**
     * @param {object} watsonResponse
     * @param {object} routeSpec - The route part of the Watson JSON
     *   (see doc/WatsonAssitant.md)
     * @param {GenericChatResponse} response - ResponseItemError is written here in case
     *   of check failure
     * @returns {boolean}
     */
    _routeTextOK(watsonResponse: object, routeSpec: object, response: GenericChatResponse): boolean;
    /**
     * @param {object} routeSpec - The route part of the Watson JSON
     *   (see doc/WatsonAssitant.md)
     * @param {GenericChatResponse} response - ResponseItemError is written here in case
     *   of check failure
     * @returns {boolean}
     */
    _routeParamsOK(routeSpec: object, response: GenericChatResponse): boolean;
    /**
     * @returns {Array<string>}
     */
    _getRouteParams(): Array<string>;
    /**
     * @returns {Array<string>} Names of route params that are processed
     *   (it may contain context variables)
     */
    _getRouteParamsToProcess(): Array<string>;
    /**
     * @param {Array<object>} objects
     * @returns {object}
     */
    _mergeObjects(...objects: Array<object>): object;
    /**
     * @param {string} appId
     * @returns {string}
     */
    _getAppType(appId: string): string;
    /**
     * @param {GenericChatRequest} request
     * @param {object} watsonResponse
     * @param {object} action - See _extractAction()
     * @param {object} context
     * @param {GenericChatResponse} response
     * @return {boolean} - Returns true if the action corresponds to route
     */
    _extractActionRoute(request: GenericChatRequest, watsonResponse: object, action: object, context: object, response: GenericChatResponse): boolean;
    /**
     * Replaces variable references in value. The following constructs are
     * recognized (in case it is a standalone string, 'a$b' is not expanded):
     *   $VARIABLE_NAME
     *   $VARIABLE_NAME.PROPERTY_NAME (nested hierarchies are supported)
     *
     *   If variable (or the referenced property) does not exist in context,
     *   the reference is expanded to 'null'
     *
     * @param {any} value
     * @param {object} context
     * @returns {any}
     */
    _expandValueUsingContext(value: any, context: object): any;
    /**
     * @param {object} action - See _extractAction()
     * @param {ResponseItemPluginCall} pluginCall
     * @returns {boolean} - true on success
     */
    _addEventToPluginCall(action: object, pluginCall: ResponseItemPluginCall): boolean;
    /**
     * @param {object} action
     * @param {object} context
     * @param {ResponseItemPluginCall} pluginCall
     * @returns {boolean} - true on success (also in case no params were specified)
     */
    _addParamsToPluginCall(action: object, context: object, pluginCall: ResponseItemPluginCall): boolean;
    /**
     * @param {object} action
     * @param {ResponseItemPluginCall} pluginCall
     * @param {GenericChatResponse} response
     * @returns {boolean} - Returns false on error
     */
    _addActionsToPluginCall(action: object, pluginCall: ResponseItemPluginCall, response: GenericChatResponse): boolean;
    /**
     * Checks whether the action 'on' property is specified correctly; if not,
     * ResponseItemError is added to the response
     *
     * @param {object} action
     * @param {GenericChatResponse} response
     * @returs {boolean}
     */
    _actionOnOk(action: object, response: GenericChatResponse): boolean;
    /**
     * Checks whether the action plugin name is set; if not, adds
     * ResponseItemError to the response and returns false
     *
     * @param {object} action
     * @param {GenericChatResponse} response
     * @returs {boolean}
     */
    _actionPluginNameOk(action: object, response: GenericChatResponse): boolean;
    /**
     * Checks that there are no unrecognized properties
     *
     * @param {object} action
     * @param {GenericChatResponse} response
     * @returs {boolean}
     */
    _noUnrecognizedActionProperties(action: object, response: GenericChatResponse): boolean;
    /**
     * @param {object} item - Watson raw response item
     * @param {GenericChatResponse} response
     * @returns {void}
     */
    _extractOptions(item: object, response: GenericChatResponse): void;
    /**
     * @param {object} item - Watson raw response item
     * @param {GenericChatResponse} response
     * @returns {void}
     */
    _extractMessageAttributes(item: object, response: GenericChatResponse): void;
    /**
     * @param {object} item - Watson raw response item
     * @param {GenericChatResponse} response
     * @returns {void}
     */
    _extractImage(item: object, response: GenericChatResponse): void;
    /**
     * @param {object} item - Watson raw response item
     * @param {GenericChatResponse} response
     * @returns {void}
     */
    _extractVideo(item: object, response: GenericChatResponse): void;
    /**
     * @param {object} item - Watson raw response item
     * @param {GenericChatResponse} response
     * @returns {void}
     */
    _extractSuggestions(item: object, response: GenericChatResponse): void;
    /**
     * @param {object} item - Watson raw response item
     * @param {GenericChatResponse} response
     * @returns {void}
     */
    _extractPause(item: object, response: GenericChatResponse): void;
    /**
     * @param {string} text
     * @param {GenericChatResponse} response
     * @return {void}
     */
    _parseWatsonText(text: string, response: GenericChatResponse): void;
    /**
     * @param {GenericChatResponse} response
     * @return {void}
     */
    _skipDuplicatedOptions(response: GenericChatResponse): void;
    /**
     * @param {object[]} parts
     * @param {ResponseItemGroup} response
     * @return {void}
     */
    _analyzeWatsonTextXMLPart(parts: object[], response: ResponseItemGroup): void;
    /**
     * Checks whether given child is allowed in given parent (e. g.
     * ResponseItemLink is not allowed in ResponseItemUnorderedList);
     * If the validation failes, ReponseItemError is added to the response
     *
     * @param {ResponseItem} child
     * @param {ResponseItem} parent
     * @returns {boolean}
     */
    _childAllowedInParent(child: ResponseItem, parent: ResponseItem): boolean;
    /**
     * Checks whether the given child has to be skipped for the given parent
     * (e. g. white characters inside <ul>)
     *
     * @param {ResponseItem} child
     * @param {ResponseItem} parent
     * @returns {boolean}
     */
    _childHasToBeSkippedInParent(child: ResponseItem, parent: ResponseItem): boolean;
    /**
     * @param {object} part
     * @param {ResponseItemGroup} response
     * @return {boolean} True if the part is a text
     */
    _analyzeWatsonTextXMLPartText(part: object, response: ResponseItemGroup): boolean;
    /**
     * @param {object} part
     * @param {ResponseItemGroup} response
     * @return {boolean} True if the part are buttons
     */
    _analyzeWatsonTextXMLPartButtons(part: object, response: ResponseItemGroup): boolean;
    /**
     * @param {object} part
     * @param {ResponseItemGroup} response
     * @return {boolean} True if the part is a pause
     */
    _analyzeWatsonTextXMLPartPause(part: object, response: ResponseItemGroup): boolean;
    /**
     * @param {object} part
     * @param {ResponseItemGroup} response
     * @return {boolean} True if the part is a <br/>
     */
    _analyzeWatsonTextXMLPartBr(part: object, response: ResponseItemGroup): boolean;
    /**
     * @param {string} url
     * @returns {string} Adds https:// to the beginning if there is no protocol
     */
    _urlWithProtocol(url: string): string;
    /**
     * @param {object} part
     * @param {ResponseItemGroup} response
     * @return {boolean} True if the part is a link
     */
    _analyzeWatsonTextXMLPartLink(part: object, response: ResponseItemGroup): boolean;
    /**
     * @param {object} part
     * @param {ResponseItemGroup} response
     * @return {boolean} True if the part is an unordered list
     */
    _analyzeWatsonTextXMLPartUnorderedList(part: object, response: ResponseItemGroup): boolean;
    /**
     * @param {object} part
     * @param {ResponseItemGroup} response
     * @return {boolean} True if the part is a list item
     */
    _analyzeWatsonTextXMLPartListItem(part: object, response: ResponseItemGroup): boolean;
    /**
     * @param {object} part
     * @param {ResponseItemGroup} response
     * @return {boolean} True if the part is a link
     */
    _analyzeWatsonTextXMLPartStrong(part: object, response: ResponseItemGroup): boolean;
    /**
     * @param {object} part
     * @param {ResponseItemGroup} response
     * @return {boolean} True if the part is a link
     */
    _analyzeWatsonTextXMLPartEmphasis(part: object, response: ResponseItemGroup): boolean;
    /**
     * @param {object} part
     * @param {ResponseItemGroup} response
     * @return {boolean} True if the part is a link
     */
    _analyzeWatsonTextXMLPartImage(part: object, response: ResponseItemGroup): boolean;
    /**
     * @param {object} part
     * @param {ResponseItemGroup} response
     * @return {boolean} True if the part is a link
     */
    _analyzeWatsonTextXMLPartVideo(part: object, response: ResponseItemGroup): boolean;
    /**
     * @param {object} part
     * @param {ResponseItemGroup} response
     * @return {boolean} true
     */
    _analyzeWatsonTextXMLPartAcceptAny(part: object, response: ResponseItemGroup): boolean;
    /**
     * @param {object} part
     * @param {ResponseItemGroup} response
     * @return {boolean} true
     */
    _analyzeWatsonTextXMLPartUnsupported(part: object, response: ResponseItemGroup): boolean;
    #private;
}
import { GenericChatResponse } from "../../response/GenericChatResponse";
import { ResponseItemGroup } from "../../response/GenericChatResponse";
export { DialogAdapter };