import * as actions from './actions';
import * as connectionStatuses from './constants/connectionStatuses';
import * as eventTypes from './constants/eventTypes';
import * as serverDisconnectionReasons from './constants/serverDisconnectionReasons';
import * as serverErrorCodes from './constants/serverErrorCodes';
import * as serverPushActions from './constants/serverPushActions';
import * as sortOrders from './constants/sortOrders';
import * as userTypes from './constants/userTypes';
import * as clientEntities from './types/clientEntities';
import { RequestBodyResumeChatData, RequestBodyStartChatData } from './clientDataParsers';
import { SendCustomerActionsOptions } from './sendCustomerActions';
import { SendGreetingButtonClickedOptions } from './sendGreetingButtonClicked';
import { Config, Page, SortOrder } from './types';
import { UploadFileOptions } from './uploadFile';
export { default as debug } from './debug';
export { connectionStatuses, eventTypes, serverDisconnectionReasons, serverErrorCodes, serverPushActions, sortOrders, userTypes, };
export * from './types/clientEntities';
export type { CustomerSessionFields, CustomerData, CustomerDataProvider, IdentityProvider, Config, ConnectionStatus, Page, SortOrder, SubscribablePush, } from './types/index';
export type { CustomerAuth, CustomerAuthToken } from '@livechat/customer-auth';
export type { SendCustomerActionsAction, SendCustomerActionsOptions } from './sendCustomerActions';
export * from './serverEventParser';
export { parseForm } from './serverFrameParser';
export declare const init: (config: Config) => Readonly<{
    acceptGreeting({ greetingId, uniqueId }: {
        greetingId: number;
        uniqueId: string;
    }): Promise<Readonly<{
        readonly success: true;
    }>>;
    auth: import("@livechat/customer-auth/src/types").CustomerAuth;
    cancelGreeting({ uniqueId }: {
        uniqueId: string;
    }): Promise<Readonly<{
        readonly success: true;
    }>>;
    cancelRate(params: {
        chatId: string;
        properties: Array<'score' | 'comment'>;
    }): Promise<Readonly<{
        readonly success: true;
    }>>;
    connect: () => void;
    deactivateChat({ id }: {
        id: string;
    }): Promise<Readonly<{
        readonly success: true;
    }>>;
    deleteChatProperties({ id, properties }: {
        id: string;
        properties: Record<string, string[]>;
    }): Promise<Readonly<{
        readonly success: true;
    }>>;
    deleteEventProperties({ chatId, threadId, eventId, properties, }: {
        chatId: string;
        threadId: string;
        eventId: string;
        properties: Record<string, string[]>;
    }): Promise<Readonly<{
        readonly success: true;
    }>>;
    deleteThreadProperties({ chatId, threadId, properties, }: {
        chatId: string;
        threadId: string;
        properties: Record<string, string[]>;
    }): Promise<Readonly<{
        readonly success: true;
    }>>;
    destroy(): void;
    disconnect(): void;
    getChat({ chatId, threadId }: {
        chatId: string;
        threadId?: string | undefined;
    }): Promise<{
        thread: clientEntities.Thread | null;
        id: string;
        access: clientEntities.Access;
        users: clientEntities.ChatUser[];
        properties: import("./types/serverEntities").Properties;
        eventsSeenUpToMap: clientEntities.EventsSeenUpToMap;
    }>;
    getChatHistory({ chatId }: {
        chatId: string;
    }): import("./chatHistory").HistoryIterator;
    getCustomer(): Promise<{
        type: "customer";
        id: string;
        name?: string | undefined;
        email?: string | undefined;
        avatar?: string | undefined;
        sessionFields: clientEntities.CustomerSessionFields;
        statistics: {
            chatsCount: number;
            threadsCount: number;
            visitsCount: number;
            pageViewsCount: number;
            greetingsShownCount: number;
            greetingsAcceptedCount: number;
        };
    }>;
    getForm({ groupId, type }: {
        groupId: number;
        type: clientEntities.FormType;
    }): Promise<{
        enabled: false;
    } | {
        form: {
            id: string;
            fields: clientEntities.FormField[];
        };
        enabled: true;
    }>;
    getUrlInfo({ url }: {
        url: string;
    }): Promise<clientEntities.UrlInfo>;
    listChats(params?: {
        pageId: string;
    } | {
        pageId?: undefined;
        limit?: number;
    }): Promise<{
        chatsSummary: clientEntities.ChatSummary[];
        totalChats: number;
        users: clientEntities.ChatUser[];
        previousPageId: string | null;
        nextPageId: string | null;
    }>;
    listGroupStatuses({ groupIds }?: {
        groupIds?: number[] | undefined;
    }): Promise<Record<number, import("./types/serverEntities").GroupStatus>>;
    listThreads(params: {
        chatId: string;
        sortOrder?: SortOrder;
        limit?: number;
        pageId?: undefined;
        minEventsCount?: number;
    } | {
        chatId: string;
        pageId: string;
    }): Promise<{
        threads: clientEntities.Thread[];
        previousPageId: string | null;
        nextPageId: string | null;
    }>;
    markEventsAsSeen({ chatId, seenUpTo }: {
        chatId: string;
        seenUpTo: string;
    }): Promise<Readonly<{
        readonly success: true;
    }>>;
    on: {
        <Key extends import("mitt").EventType>(type: Key, handler: import("mitt").Handler<{
            [x: string]: unknown;
            [x: symbol]: unknown;
        }[Key]>): void;
        (type: "*", handler: import("mitt").WildcardHandler<{
            [x: string]: unknown;
            [x: symbol]: unknown;
        }>): void;
    };
    once: {
        <Key extends import("mitt").EventType>(type: Key, handler: import("mitt").Handler<{
            [x: string]: unknown;
            [x: symbol]: unknown;
        }[Key]>): void;
        (type: "*", handler: import("mitt").WildcardHandler<{
            [x: string]: unknown;
            [x: symbol]: unknown;
        }>): void;
    };
    off: {
        <Key_1 extends import("mitt").EventType>(type: Key_1, handler?: import("mitt").Handler<{
            [x: string]: unknown;
            [x: symbol]: unknown;
        }[Key_1]> | undefined): void;
        (type: "*", handler: import("mitt").WildcardHandler<{
            [x: string]: unknown;
            [x: symbol]: unknown;
        }>): void;
    } & {
        (type: "*", handler: import("mitt").WildcardHandler<{
            [x: string]: unknown;
            [x: symbol]: unknown;
        }>): void;
        (): void;
    };
    rateChat(params: {
        chatId: string;
        rating: {
            comment?: string;
            score?: 0 | 1;
        };
    }): Promise<Readonly<{
        readonly success: true;
    }>>;
    requestWelcomeMessage({ id }?: {
        id?: string | undefined;
    }): Promise<{
        id: string;
        predictedAgent: {
            type: "agent";
            id: string;
            name: string;
            avatar: string;
            jobTitle: string;
            isBot: boolean;
        } & {
            botType: "chatbot" | "ai_agent";
        };
        queue: boolean;
    }>;
    resumeChat(data: RequestBodyResumeChatData): Promise<clientEntities.IncomingChat>;
    sendEvent(params: Parameters<typeof actions.sendEvent>[0]): Promise<clientEntities.Event>;
    sendGreetingButtonClicked(options: SendGreetingButtonClickedOptions): Promise<void>;
    sendCustomerActions(options: SendCustomerActionsOptions): Promise<void>;
    sendRichMessagePostback({ chatId, threadId, eventId, postback, }: {
        chatId: string;
        threadId: string;
        eventId: string;
        postback: {
            id: string;
            toggled: boolean;
        };
    }): Promise<Readonly<{
        readonly success: true;
    }>>;
    setCustomerSessionFields({ sessionFields }: {
        sessionFields: clientEntities.CustomerSessionFields;
    }): Promise<Readonly<{
        readonly success: true;
    }>>;
    setSneakPeek: ({ chatId, sneakPeekText }: {
        chatId: string;
        sneakPeekText: string;
    }) => void;
    startChat(data?: RequestBodyStartChatData): Promise<clientEntities.IncomingChat>;
    updateChatProperties({ id, properties }: {
        id: string;
        properties: clientEntities.Properties;
    }): Promise<Readonly<{
        readonly success: true;
    }>>;
    updateCustomer(update: clientEntities.CustomerUpdate): Promise<Readonly<{
        readonly success: true;
    }>>;
    updateCustomerPage(page: Page): void;
    updateEventProperties({ chatId, threadId, eventId, properties, }: {
        chatId: string;
        threadId: string;
        eventId: string;
        properties: clientEntities.Properties;
    }): Promise<Readonly<{
        readonly success: true;
    }>>;
    updateThreadProperties({ chatId, threadId, properties, }: {
        chatId: string;
        threadId: string;
        properties: clientEntities.Properties;
    }): Promise<Readonly<{
        readonly success: true;
    }>>;
    uploadFile(options: UploadFileOptions): {
        promise: Promise<{
            url: string;
        }>;
        cancel(): void;
    };
}>;
export type CustomerSDK = ReturnType<typeof init>;
//# sourceMappingURL=index.d.ts.map