import type { BotCtxMethods, BotStateGlobal, BotStateStandAlone, DispatchFn, DynamicBlacklist, FlagsRuntime, ProviderEventTypes, TContext } from './../types';
import type { HostEventTypes } from './eventEmitterClass';
import { EventEmitterClass } from './eventEmitterClass';
import { GlobalState, SingleState } from '../context';
import type { MemoryDB } from '../db';
import type FlowClass from '../io/flowClass';
import type { ProviderClass } from '../provider/interface/provider';
import type { FlowDynamicMessage, GeneralArgs, MessageContextIncoming } from '../types';
import { BlackList, Queue } from '../utils';
declare class CoreClass<P extends ProviderClass = any, D extends MemoryDB = any> extends EventEmitterClass<HostEventTypes> {
    flowClass: FlowClass;
    database: D;
    provider: P;
    queuePrincipal: Queue<unknown>;
    stateHandler: SingleState;
    globalStateHandler: GlobalState;
    dynamicBlacklist: BlackList;
    generalArgs: GeneralArgs & {
        host?: string;
    };
    /**
     * @description
     * - Setup flowClass
     * - Setup database
     * - Setup provider
     * - Setup generalArgs
     */
    constructor(_flow: any, _database: D, _provider: P, _args: GeneralArgs);
    /**
     * Event handler
     */
    listenerBusEvents: () => {
        event: string;
        func: ProviderEventTypes[keyof ProviderEventTypes];
    }[];
    private setHostData;
    handleMsg: (messageCtxInComing: MessageContextIncoming) => Promise<{
        createCtxMessage: (payload: {
            body: any;
            answer: any;
            media: string;
            buttons: any[];
            capture: boolean;
            delay: number;
            keyword: null;
        }, index?: number) => TContext;
        clearQueue: () => void;
        endFlow: (flag: FlagsRuntime, inRef: string | number) => (message?: any) => Promise<void>;
        sendFlow: (messageToSend: any[], numberOrId: string, options?: {
            [key: string]: any;
        }) => Promise<void>;
        continueFlow: (initRef?: any) => Promise<any>;
        fallBack: (flag: FlagsRuntime) => (message?: any) => Promise<void>;
        gotoFlow: (flag: FlagsRuntime) => (flowInstance: {
            toJson: () => any;
            ctx: {
                options: {
                    delay: any;
                };
            };
        }, step?: number) => Promise<void>;
        flowDynamic: (flag: FlagsRuntime, inRef: string, privateOptions: {
            [x: string]: any;
            omitEndFlow?: boolean;
            idleCtx?: boolean;
        }) => (listMessages?: string | string[] | FlowDynamicMessage[], options?: {
            continue: boolean;
        }) => Promise<void>;
        resolveCbEveryCtx: (ctxMessage: TContext, options?: {
            omitEndFlow: boolean;
            idleCtx: boolean;
            triggerKey: boolean;
        }) => Promise<TContext>;
        cbEveryCtx: (inRef: string, options?: {
            [key: string]: any;
        }) => Promise<void | {
            endFlow: any;
            fallBack?: boolean;
            flowDynamic?: boolean;
            gotoFlow?: boolean;
        }>;
    }>;
    /**
     * Enviar mensaje con contexto atraves del proveedor de whatsapp
     * @param {*} numberOrId
     * @param {*} ctxMessage ver más en GLOSSARY.md
     * @returns
     */
    sendProviderAndSave: (numberOrId: string, ctxMessage: TContext) => Promise<void>;
    /**
     * Funcion dedicada a enviar el mensaje sin pasar por el flow
     * (dialogflow)
     * @param {*} messageToSend
     * @param {*} numberOrId
     * @returns
     */
    sendFlowSimple: (messageToSend: any, numberOrId: any) => Promise<{
        (): Promise<void>;
        <T>(value: T): Promise<Awaited<T>>;
        <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>;
    }>;
    /**
     *
     */
    httpServer: (port: number) => void;
    /**
     * Build context methods for HTTP handlers
     * @returns {BotCtxMethods}
     */
    private buildCtxMethods;
    /**
     *
     * @param ctxPolka
     * @returns
     */
    handleCtx: (ctxPolka: (bot: (Pick<P, "sendMessage" | "vendor"> & {
        provider: P;
        blacklist: DynamicBlacklist;
        dispatch: DispatchFn;
        state: (number: string) => BotStateStandAlone;
        globalState: () => BotStateGlobal;
        ctxMethods: BotCtxMethods;
        emit: (eventName: string, args: Record<string, any> & {
            from: string;
        }) => void;
    }) | undefined, req: any, res: any) => Promise<void>) => (...args: any[]) => any;
}
export { CoreClass };
//# sourceMappingURL=coreClass.d.ts.map