import { EmitCallback, EventContract, EventName, EventSignature, MercuryAggregateResponse, SpruceSchemas } from '@sprucelabs/mercury-types';
import { Schema, SchemaValues } from '@sprucelabs/schema';
import { io, SocketOptions, ManagerOptions } from 'socket.io-client';
import { ConnectionOptions, MercuryClient } from '../types/client.types';
export default class MercurySocketIoClient<Contract extends EventContract> implements MercuryClient<Contract> {
    protected _eventContract?: Contract;
    protected get eventContract(): Contract;
    protected set eventContract(contract: Contract);
    static io: typeof io;
    private log;
    private host;
    private ioOptions;
    private socket?;
    private proxyToken;
    private emitTimeoutMs;
    private reconnectDelayMs;
    private listenerMap;
    private isReAuthing;
    private reconnectPromise;
    protected lastAuthOptions?: {
        skillId?: string | undefined;
        apiKey?: string | undefined;
        token?: string | undefined;
    };
    private shouldReconnect;
    private connectionRetriesRemaining;
    private connectionRetries;
    private registeredListeners;
    private allowNextEventToBeAuthenticate;
    protected auth?: {
        skill?: SpruceSchemas.Spruce.v2020_07_22.Skill;
        person?: SpruceSchemas.Spruce.v2020_07_22.Person;
    };
    private shouldAutoRegisterListeners;
    private isManuallyDisconnected;
    private isReconnecting;
    private id;
    private skipWaitIfReconnecting;
    private maxEmitRetries;
    private authRawResults?;
    protected authPromise?: any;
    protected shouldRegisterProxyOnReconnect: boolean;
    private reconnectKey?;
    constructor(options: {
        host: string;
        eventContract?: Contract;
    } & IoOptions);
    connect(): Promise<void>;
    private emitStatusChange;
    private attachConnectError;
    private attemptReconnectAfterDelay;
    protected reconnect(resolve: any, reject: any, retriesLeft: number): Promise<void>;
    protected waitIfReconnecting(): Promise<void>;
    private reRegisterAllListeners;
    private mapSocketErrorToSpruceError;
    emit<Name extends EventName<Contract>, IEventSignature extends EventSignature = Contract['eventSignatures'][EventName], EmitSchema extends Schema = IEventSignature['emitPayloadSchema'] extends Schema ? IEventSignature['emitPayloadSchema'] : never, ResponseSchema extends Schema = IEventSignature['responsePayloadSchema'] extends Schema ? IEventSignature['responsePayloadSchema'] : never, ResponsePayload = ResponseSchema extends Schema ? SchemaValues<ResponseSchema> : never>(eventName: Name, targetAndPayload?: (EmitSchema extends Schema ? SchemaValues<EmitSchema> : never) | EmitCallback<Contract, Name>, cb?: EmitCallback<Contract, Name>): Promise<MercuryAggregateResponse<ResponsePayload>>;
    private handleLocalEmit;
    emitAndFlattenResponses<Name extends EventName<Contract>, IEventSignature extends EventSignature = Contract['eventSignatures'][EventName], EmitSchema extends Schema = IEventSignature['emitPayloadSchema'] extends Schema ? IEventSignature['emitPayloadSchema'] : never, ResponseSchema extends Schema = IEventSignature['responsePayloadSchema'] extends Schema ? IEventSignature['responsePayloadSchema'] : never, ResponsePayload = ResponseSchema extends Schema ? SchemaValues<ResponseSchema> : never>(eventName: Name, payload?: (EmitSchema extends Schema ? SchemaValues<EmitSchema> : never) | EmitCallback<Contract, Name>, cb?: EmitCallback<Contract, Name>): Promise<ResponsePayload[]>;
    private _emit;
    protected assertValidEmitTargetAndPayload<Name extends EventName<Contract>>(eventName: Name, payload: any): void;
    private handleConfirmPinResponse;
    protected getEventSignatureByName<Name extends EventName<Contract>>(eventName: Name): SpruceSchemas.Mercury.v2020_12_25.EventSignature;
    setShouldAutoRegisterListeners(should: boolean): void;
    on<Name extends EventName<Contract>, IEventSignature extends EventSignature = Contract['eventSignatures'][EventName], EmitSchema extends Schema = IEventSignature['emitPayloadSchema'] extends Schema ? IEventSignature['emitPayloadSchema'] : never>(eventName: Name, cb: (payload: EmitSchema extends Schema ? SchemaValues<EmitSchema> : never) => IEventSignature['responsePayloadSchema'] extends Schema ? Promise<SchemaValues<IEventSignature['responsePayloadSchema']>> | SchemaValues<IEventSignature['responsePayloadSchema']> : Promise<void> | void): Promise<void>;
    private isEventLocal;
    off(eventName: EventName<Contract>, cb?: () => void): Promise<number>;
    private removeLocalListener;
    getId(): string;
    disconnect(): Promise<void>;
    authenticate(options: AuthenticateOptions): Promise<{
        skill: any;
        person: any;
    }>;
    isAuthenticated(): boolean;
    isConnected(): boolean;
    private isSocketConnected;
    getProxyToken(): string | null;
    setProxyToken(token: string): void;
    registerProxyToken(): Promise<any>;
    getIsTestClient(): boolean;
}
type IoOptions = Partial<ManagerOptions & SocketOptions & ConnectionOptions>;
export declare const authenticateFqen = "authenticate::v2020_12_25";
export interface AuthenticateOptions {
    skillId?: string;
    apiKey?: string;
    token?: string;
}
export {};