@hyper-fetch/sockets/dist/index.d.ts

Sockets connection for hyper-fetch

import * as _hyper_fetch_core from '@hyper-fetch/core';
import { ParamsType, PayloadMapperType, EmptyTypes, ExtractUrlParams, TypeWithDefaults, QueryParamsType, QueryParamsMapper, DefaultMapperType, QueryStringifyOptionsType, stringifyQueryParams, LoggerManager, AppManager, LogLevel } from '@hyper-fetch/core';
import EventEmitter from 'events';

type TupleRestType<T> = T extends [first: any, ...rest: infer Rest] ? (Rest extends Array<any> ? Rest : []) : [];

declare class Emitter<Payload, Topic extends string, Socket extends SocketInstance, HasPayload extends boolean = false, HasParams extends boolean = false> {
    readonly socket: Socket;
    readonly emitterOptions: EmitterOptionsType<Topic, ExtractSocketAdapterType<Socket>>;
    readonly topic: Topic;
    params?: ParamsType;
    payload: Payload | undefined;
    options: ExtractAdapterEmitterOptionsType<ExtractSocketAdapterType<Socket>> | undefined;
    /** @internal */
    unstable_payloadMapper?: PayloadMapperType<any>;
    constructor(socket: Socket, emitterOptions: EmitterOptionsType<Topic, ExtractSocketAdapterType<Socket>>, 
    /**
     * Used to recreate the emitter with the same state
     * @internal
     */
    snapshot?: Partial<Emitter<Payload, Topic, Socket, any, any>>);
    setOptions(options: ExtractAdapterEmitterOptionsType<ExtractSocketAdapterType<Socket>> | undefined): Emitter<Payload, Topic, Socket, HasPayload, HasParams>;
    setPayload: <D extends Payload>(payload: D) => Emitter<D, Topic, Socket, D extends EmptyTypes ? false : true, HasParams>;
    setPayloadMapper: <DataMapper extends (payload: Payload) => any | Promise<any>>(payloadMapper: DataMapper) => Emitter<Payload, Topic, Socket, HasPayload, HasParams>;
    setParams(params: NonNullable<ExtractUrlParams<Topic>>): Emitter<Payload, Topic, Socket, HasPayload, true>;
    private paramsMapper;
    clone<NewPayload extends Payload = Payload, NewHasPayload extends boolean = HasPayload, NewHasParams extends boolean = HasParams>(config?: EmitterCloneOptionsType<NewPayload, ParamsType, Topic, Socket>): Emitter<NewPayload, Topic, Socket, NewHasPayload, NewHasParams>;
    emit: EmitType<Emitter<Payload, Topic, Socket, HasPayload, HasParams>>;
}

type EmitterInstanceProperties = {
    payload?: any;
    topic?: string;
    socket?: SocketInstance;
    hasParams?: boolean;
    hasPayload?: boolean;
};
type EmitterInstance<EmitterProperties extends EmitterInstanceProperties = {}> = Emitter<TypeWithDefaults<EmitterProperties, "payload", any>, TypeWithDefaults<EmitterProperties, "topic", any>, TypeWithDefaults<EmitterProperties, "socket", SocketInstance>, TypeWithDefaults<EmitterProperties, "hasPayload", any>, TypeWithDefaults<EmitterProperties, "hasParams", any>>;
type EmitterCloneOptionsType<Payload, Params, Topic extends string, Socket extends SocketInstance> = {
    payload?: Payload;
    params?: Params | null;
} & Partial<EmitterOptionsType<Topic, ExtractSocketAdapterType<Socket>>>;
type EmitterOptionsType<Topic extends string, AdapterType extends SocketAdapterInstance> = {
    topic: Topic;
    options?: ExtractAdapterEmitterOptionsType<AdapterType>;
};
type EmitterCallbackErrorType = (data: {
    error: Error;
}) => void;
type EmitPayloadType<Payload, HasPayload extends boolean> = HasPayload extends false ? {
    payload: Payload;
} : {
    payload?: Payload;
};
type EmitParamsType<Params extends ParamsType | EmptyTypes, HasPayload extends boolean> = HasPayload extends false ? Params extends EmptyTypes ? {
    params?: Params;
} : {
    params: Params;
} : {
    params?: Params;
};
type EmitterRestParams<Adapter extends SocketAdapterInstance> = ExtractAdapterEmitterOptionsType<Adapter> extends any ? {} : ExtractAdapterEmitterOptionsType<Adapter> extends Record<string, any> ? {
    options?: ExtractAdapterEmitterOptionsType<Adapter>;
} : {};
type EmitMethodOptionsType<Emitter extends EmitterInstance> = EmitPayloadType<ExtractEmitterPayloadType<Emitter>, ExtractEmitterHasPayloadType<Emitter>> & EmitParamsType<ExtractUrlParams<ExtractEmitterTopicType<Emitter>>, ExtractEmitterHasParamsType<Emitter>> & EmitterRestParams<ExtractSocketAdapterType<ExtractEmitterSocketType<Emitter>>>;
type EmitType<Emitter extends EmitterInstance> = ExtractEmitterHasPayloadType<Emitter> extends false ? (options: EmitMethodOptionsType<Emitter>) => void : ExtractUrlParams<ExtractEmitterTopicType<Emitter>> extends EmptyTypes ? (options?: EmitMethodOptionsType<Emitter>) => void : ExtractEmitterHasParamsType<Emitter> extends false ? (options: EmitMethodOptionsType<Emitter>) => void : (options?: EmitMethodOptionsType<Emitter>) => void;
type ExtendEmitter<T extends EmitterInstance, Properties extends {
    payload?: any;
    response?: any;
    topic?: string;
    socket?: SocketInstance;
    mappedData?: any;
    hasData?: true | false;
    hasParams?: true | false;
}> = Emitter<TypeWithDefaults<Properties, "payload", ExtractEmitterPayloadType<T>>, Properties["topic"] extends string ? Properties["topic"] : ExtractEmitterTopicType<T>, Properties["socket"] extends SocketInstance ? Properties["socket"] : ExtractEmitterSocketType<T>, Properties["hasData"] extends true ? true : ExtractEmitterHasPayloadType<T>, Properties["hasParams"] extends true ? true : ExtractEmitterHasParamsType<T>>;

declare const getAdapterBindings: <T extends SocketAdapterInstance>(socket: Socket<T>) => {
    socket: Socket<T>;
    adapter: T;
    logger: _hyper_fetch_core.LoggerMethods;
    getQueryParams: () => any;
    onConnect: () => boolean;
    onReconnect: ({ disconnect, connect, }: {
        disconnect: () => Promise<any>;
        connect: () => Promise<any>;
    }) => Promise<boolean>;
    onDisconnect: () => boolean;
    onListen: ({ listener, callback, onUnmount, }: {
        listener: Pick<ListenerInstance, "topic">;
        callback: ListenerCallbackType<T, any>;
        onUnmount?: VoidFunction;
    }) => (() => void);
    onEmit: ({ emitter }: {
        emitter: EmitterInstance;
    }) => Promise<EmitterInstance | null>;
    onEmitError: <ErrorType extends Error>({ emitter, error }: {
        emitter: EmitterInstance;
        error: ErrorType;
    }) => void;
    onConnected: () => void;
    onDisconnected: () => void;
    onError: ({ error }: {
        error: Error;
    }) => void;
    onEvent: ({ topic, data, extra }: {
        topic: string;
        data: any;
        extra: ExtractAdapterExtraType<T>;
    }) => void;
};

declare class SocketAdapter<Extra = undefined, AdapterOptions extends Record<string, any> | EmptyTypes = undefined, ListenerOptions extends Record<string, any> | EmptyTypes = undefined, EmitterOptions extends Record<string, any> | EmptyTypes = undefined, QueryParams extends QueryParamsType | string | EmptyTypes = undefined, QueryParamsMapperType extends QueryParamsMapper<any> | DefaultMapperType = DefaultMapperType> {
    options: {
        name: string;
        queryParams?: QueryParams;
        defaultConnected?: boolean;
        defaultConnecting?: boolean;
        defaultReconnectionAttempts?: number;
        defaultForceClosed?: boolean;
    };
    name: string;
    socket: SocketInstance;
    defaultExtra?: Extra;
    queryParams?: QueryParams;
    queryParamsConfig?: QueryStringifyOptionsType;
    /** Config for the query params mapper */
    unstable_queryParamsMapperConfig: Parameters<QueryParamsMapperType>[1];
    /** Method to get request data and transform them to the required format.  */
    unstable_queryParamsMapper: QueryParamsMapperType;
    adapterOptions: AdapterOptions | EmptyTypes;
    listenerOptions: ListenerOptions | EmptyTypes;
    emitterOptions: EmitterOptions | EmptyTypes;
    private getConnector;
    connected: boolean;
    connecting: boolean;
    reconnectionAttempts: number;
    forceClosed: boolean;
    listeners: Map<string, Map<ListenerCallbackType<this, any>, VoidFunction>>;
    listen: (listener: ListenerInstance, callback: ListenerCallbackType<this, any>) => RemoveListenerCallbackType;
    emit: (emitter: EmitterInstance) => void;
    connect: () => void;
    reconnect: () => void;
    disconnect: () => void;
    constructor(options: {
        name: string;
        queryParams?: QueryParams;
        defaultConnected?: boolean;
        defaultConnecting?: boolean;
        defaultReconnectionAttempts?: number;
        defaultForceClosed?: boolean;
    });
    initialize(socket: SocketInstance): this;
    setQueryParams(queryParams: QueryParams): this;
    setQueryParamsConfig(queryParamsConfig: QueryStringifyOptionsType): this;
    setDefaultExtra(defaultExtra: Extra): this;
    setOptions(adapterOptions: AdapterOptions | EmptyTypes): this;
    setDefaultListenerOptions(listenerOptions: ListenerOptions | EmptyTypes): this;
    setDefaultEmitterOptions(emitterOptions: EmitterOptions | EmptyTypes): this;
    setQueryParamsMapperConfig: <NewQueryParamsMapperConfig extends Parameters<QueryParamsMapperType>[1]>(config: NewQueryParamsMapperConfig) => this;
    /**
     * Set the query params mapping function which get triggered before request get sent
     */
    setQueryParamsMapper: <NewQueryParamsMapper extends QueryParamsMapper<QueryParams>>(queryParamsMapper: NewQueryParamsMapper) => SocketAdapter<Extra, AdapterOptions, ListenerOptions, EmitterOptions, QueryParams, NewQueryParamsMapper>;
    removeListener: ({ topic, callback, }: {
        topic: string;
        callback: ListenerCallbackType<SocketAdapter<Extra, AdapterOptions, ListenerOptions, EmitterOptions, QueryParams, QueryParamsMapperType>, any>;
    }) => boolean;
    triggerListeners: ({ topic, data, extra, }: {
        topic: string;
        data: any;
        extra: ExtractAdapterExtraType<SocketAdapter<Extra, AdapterOptions, ListenerOptions, EmitterOptions, QueryParams, QueryParamsMapperType>>;
    }) => void;
    setConnected: (connected: boolean) => this;
    setConnecting: (connecting: boolean) => this;
    setReconnectionAttempts: (reconnectionAttempts: number) => this;
    setForceClosed: (forceClosed: boolean) => this;
    setConnector: (connector: (bindings: ReturnType<typeof getAdapterBindings<this>>) => Connector) => this;
}

type RemoveListenerCallbackType = () => void;
type SocketAdapterInstance = SocketAdapter<any, any, any, any, any, any>;
type Connector = {
    connect: () => void;
    reconnect: () => void;
    disconnect: () => void;
    listen: (listener: ListenerInstance, callback: ListenerCallbackType<SocketAdapterInstance, any>) => RemoveListenerCallbackType;
    emit: (emitter: EmitterInstance) => void;
};

type SocketData<D = any> = {
    topic: string;
    payload: D;
};

type EventReturnType<GenericDataType, Adapter extends SocketAdapterInstance> = {
    data: GenericDataType;
    extra: ExtractAdapterExtraType<Adapter>;
};
type ExtractEmitterPayloadType<E> = E extends Emitter<infer P, any, any, any, any> ? P : never;
type ExtractEmitterTopicType<E> = E extends Emitter<any, infer T, any, any, any> ? T : never;
type ExtractEmitterSocketType<E> = E extends Emitter<any, any, infer A, any, any> ? A : never;
type ExtractEmitterHasPayloadType<E> = E extends Emitter<any, any, any, infer D, any> ? D : never;
type ExtractEmitterHasParamsType<E> = E extends Emitter<any, any, any, any, infer P> ? P : never;
type ExtractListenerResponseType<T> = T extends Listener<infer R, any, any, any> ? R : never;
type ExtractListenerTopicType<E> = E extends Listener<any, infer T, any, any> ? T : never;
type ExtractListenerSocketType<E> = E extends Listener<any, any, infer A, any> ? A : never;
type ExtractListenerHasParamsType<E> = E extends Listener<any, any, any, infer P> ? P : never;
type ExtractSocketAdapterType<T extends SocketInstance> = T extends Socket<infer Adapter> ? Adapter : never;
type ExtractSocketOptionsType<T extends SocketInstance> = T extends Socket<infer Adapter> ? ExtractAdapterOptionsType<Adapter> : never;
type ExtractSocketExtraType<T extends SocketInstance> = T extends Socket<infer Adapter> ? ExtractAdapterExtraType<Adapter> : never;
type ExtractListenerOptionsType<T extends SocketInstance> = T extends Socket<infer Adapter> ? ExtractAdapterListenerOptionsType<Adapter> : never;
type ExtractEmitterOptionsType<T extends SocketInstance> = T extends Socket<infer Adapter> ? ExtractAdapterEmitterOptionsType<Adapter> : never;
type ExtractAdapterExtraType<T extends SocketAdapterInstance> = T extends SocketAdapter<infer P, any, any, any, any, any> ? P : never;
type ExtractAdapterOptionsType<T extends SocketAdapterInstance> = T extends SocketAdapter<any, infer P, any, any, any, any> ? P : never;
type ExtractAdapterListenerOptionsType<T extends SocketAdapterInstance> = T extends SocketAdapter<any, any, infer P, any, any, any> ? P : never;
type ExtractAdapterEmitterOptionsType<T extends SocketAdapterInstance> = T extends SocketAdapter<any, any, any, infer P, any, any> ? P : never;
type ExtractAdapterQueryParamsType<T extends SocketAdapterInstance> = T extends SocketAdapter<any, any, any, any, infer P, any> ? P : never;
type ExtractAdapterQueryParamsMapperType<T extends SocketAdapterInstance> = T extends SocketAdapter<any, any, any, any, any, infer P> ? P : never;

type ConnectMethodType<AdapterType extends SocketAdapterInstance, EventType = unknown> = (response: Parameters<ListenerCallbackType<AdapterType, EventType>>[0]) => void;

declare class Listener<Response, Topic extends string, Socket extends SocketInstance, HasParams extends boolean = false> {
    readonly socket: Socket;
    readonly listenerOptions: ListenerOptionsType<Topic, ExtractSocketAdapterType<Socket>>;
    readonly topic: Topic;
    params?: ParamsType;
    options?: ExtractAdapterListenerOptionsType<ExtractSocketAdapterType<Socket>>;
    constructor(socket: Socket, listenerOptions: ListenerOptionsType<Topic, ExtractSocketAdapterType<Socket>>);
    setOptions(options: ExtractAdapterListenerOptionsType<ExtractSocketAdapterType<Socket>>): Listener<Response, Topic, Socket, HasParams>;
    setParams(params: ExtractUrlParams<Topic>): Listener<Response, Topic, Socket, true>;
    clone<NewHasParams extends true | false = HasParams>(options?: ListenerConfigurationType<ExtractUrlParams<Topic>, Topic, Socket>): Listener<Response, Topic, Socket, NewHasParams>;
    listen: ListenType<Listener<Response, Topic, Socket, HasParams>, Socket>;
    private paramsMapper;
}

type ListenerInstanceProperties = {
    response?: any;
    topic?: string;
    socket?: SocketInstance;
    hasParams?: boolean;
};
type ListenerInstance<ListenerProperties extends ListenerInstanceProperties = {}> = Listener<TypeWithDefaults<ListenerProperties, "response", any>, TypeWithDefaults<ListenerProperties, "topic", any>, TypeWithDefaults<ListenerProperties, "socket", SocketInstance>, TypeWithDefaults<ListenerProperties, "hasParams", any>>;
type ListenerOptionsType<Topic extends string, AdapterType extends SocketAdapterInstance> = {
    topic: Topic;
    options?: ExtractAdapterListenerOptionsType<AdapterType>;
};
type ListenerConfigurationType<Params, Topic extends string, Socket extends SocketInstance> = {
    params?: Params;
} & Partial<ListenerOptionsType<Topic, ExtractSocketAdapterType<Socket>>>;
type ListenerParamsOptionsType<Listener extends ListenerInstance> = ExtractListenerHasParamsType<Listener> extends false ? {
    params: ExtractUrlParams<ExtractListenerTopicType<Listener>>;
} : {
    params?: never;
};
type ListenType<Listener extends ListenerInstance, Socket extends SocketInstance> = ExtractUrlParams<ExtractListenerTopicType<Listener>> extends EmptyTypes ? (callback: ListenerCallbackType<ExtractSocketAdapterType<Socket>, ExtractListenerResponseType<Listener>>) => () => void : ExtractListenerHasParamsType<Listener> extends true ? (callback: ListenerCallbackType<ExtractSocketAdapterType<Socket>, ExtractListenerResponseType<Listener>>) => () => void : (callback: ListenerCallbackType<ExtractSocketAdapterType<Socket>, ExtractListenerResponseType<Listener>>) => () => void;
type ListenerCallbackType<AdapterType extends SocketAdapterInstance, D> = (response: {
    data: D;
    extra: ExtractAdapterExtraType<AdapterType>;
}) => void;
type ExtendListener<T extends ListenerInstance, Properties extends {
    response?: any;
    topic?: string;
    socket?: SocketInstance;
    hasParams?: true | false;
}> = Listener<TypeWithDefaults<Properties, "response", ExtractListenerResponseType<T>>, Properties["topic"] extends string ? Properties["topic"] : ExtractListenerTopicType<T>, Properties["socket"] extends SocketInstance ? Properties["socket"] : ExtractListenerSocketType<T>, Properties["hasParams"] extends true ? true : ExtractListenerHasParamsType<T>>;

type WebsocketAdapterOptionsType = {
    protocols?: string[];
    pingTimeout?: number;
    pongTimeout?: number;
    heartbeatMessage?: string;
    heartbeat?: boolean;
    autoConnect?: boolean;
};

/**
 * -------------------------------------------
 * Websocket
 * -------------------------------------------
 */
type WebsocketAdapterType = SocketAdapter<MessageEvent<any>, WebsocketAdapterOptionsType, undefined, undefined, QueryParamsType | string, typeof stringifyQueryParams>;
declare const WebsocketAdapter: () => WebsocketAdapterType;

declare class Socket<Adapter extends SocketAdapterInstance = WebsocketAdapterType> {
    options: SocketOptionsType<Adapter>;
    emitter: EventEmitter;
    events: {
        readonly emitError: <ResponseType>({ error }: {
            error: ResponseType;
        }) => void;
        readonly emitConnected: () => void;
        readonly emitDisconnected: () => void;
        readonly emitConnecting: ({ connecting }: {
            connecting: boolean;
        }) => void;
        readonly emitReconnecting: ({ attempts }: {
            attempts: number;
        }) => void;
        readonly emitReconnectingFailed: ({ attempts }: {
            attempts: number;
        }) => void;
        readonly emitListenerEvent: <ResponseType>({ topic, data, extra, }: {
            topic: string;
            data: ResponseType;
            extra: any;
        }) => void;
        readonly emitListenerRemoveEvent: ({ topic }: {
            topic: string;
        }) => void;
        readonly emitEmitterStartEvent: <EmitterType extends EmitterInstance>({ emitter }: {
            emitter: EmitterType;
        }) => void;
        readonly emitEmitterError: <EmitterType extends EmitterInstance>({ error, emitter, }: {
            error: Error;
            emitter: EmitterType;
        }) => void;
        readonly onError: (callback: <ResponseType>({ error }: {
            error: ResponseType;
        }) => void) => VoidFunction;
        readonly onConnected: (callback: () => void) => VoidFunction;
        readonly onDisconnected: (callback: () => void) => VoidFunction;
        readonly onConnecting: (callback: ({ connecting }: {
            connecting: boolean;
        }) => void) => VoidFunction;
        readonly onReconnecting: (callback: ({ attempts }: {
            attempts: number;
        }) => void) => VoidFunction;
        readonly onReconnectingFailed: (callback: ({ attempts }: {
            attempts: number;
        }) => void) => VoidFunction;
        readonly onEmitterStartEvent: <EmitterType extends EmitterInstance>(callback: ({ emitter }: {
            emitter: EmitterType;
        }) => void) => VoidFunction;
        readonly onEmitterStartEventByTopic: <EmitterType extends EmitterInstance>(emitter: Pick<EmitterType, "topic">, callback: ({ emitter }: {
            emitter: EmitterType;
        }) => void) => VoidFunction;
        readonly onEmitterError: <EmitterType extends EmitterInstance>(callback: ({ error, emitter }: {
            error: Error;
            emitter: EmitterType;
        }) => void) => VoidFunction;
        readonly onEmitterErrorByTopic: <EmitterType extends EmitterInstance>(emitter: Pick<EmitterType, "topic">, callback: ({ error, emitter }: {
            error: Error;
            emitter: EmitterType;
        }) => void) => VoidFunction;
        readonly onListenerEvent: <ResponseType = Event>(callback: ({ topic, data, extra, }: {
            topic: string;
            data: ResponseType;
            extra: any;
        }) => void) => VoidFunction;
        readonly onListenerEventByTopic: <ListenerType extends ListenerInstance>(listener: Pick<ListenerType, "topic">, callback: ({ topic, data, extra, }: {
            topic: string;
            data: ResponseType;
            extra: any;
        }) => void) => VoidFunction;
        readonly onListenerRemove: (callback: ({ topic }: {
            topic: string;
        }) => void) => VoidFunction;
        readonly onListenerRemoveByTopic: <ListenerType extends ListenerInstance>(listener: Pick<ListenerType, "topic">, callback: ({ topic }: {
            topic: string;
        }) => void) => VoidFunction;
    };
    url: string;
    reconnectAttempts: number;
    reconnectTime: number;
    debug: boolean;
    autoConnect: boolean;
    unstable_onConnectedCallbacks: OpenCallbackType[];
    unstable_onDisconnectCallbacks: CloseCallbackType[];
    unstable_onReconnectCallbacks: ReconnectCallbackType[];
    unstable_onReconnectFailedCallbacks: ReconnectFailedCallbackType[];
    unstable_onMessageCallbacks: MessageCallbackType<any>[];
    unstable_onSendCallbacks: SendCallbackType<EmitterInstance>[];
    unstable_onErrorCallbacks: ErrorCallbackType<any>[];
    adapter: Adapter;
    loggerManager: LoggerManager;
    appManager: AppManager;
    logger: _hyper_fetch_core.LoggerMethods;
    constructor(options: SocketOptionsType<Adapter>);
    /**
     * This method connects the socket to the server
     */
    connect: () => Promise<void>;
    /**
     * This method disconnects the socket from the server
     */
    disconnect: () => Promise<void>;
    /**
     * This method reconnect the socket to the server
     */
    reconnect: () => Promise<void>;
    setQueryParams: (queryParams: ExtractAdapterQueryParamsType<Adapter>) => this;
    /**
     * This method enables the logger usage and display the logs in console
     */
    setDebug: (enabled: boolean) => this;
    /**
     * Set the logger severity of the messages displayed to the console
     */
    setLogLevel: (level: LogLevel) => this;
    /**
     * Set the new logger instance to the socket
     */
    setLogger: (callback: (socket: Socket<Adapter>) => LoggerManager) => this;
    /**
     * Callbacks
     */
    /**
     * Triggered when connection is opened
     * @param callback
     * @returns
     */
    onConnected(callback: OpenCallbackType): this;
    /**
     * Triggered when connection is closed
     * @param callback
     * @returns
     */
    onDisconnected(callback: CloseCallbackType): this;
    /**
     * Triggered when connection is getting reconnected
     * @param callback
     * @returns
     */
    onReconnect(callback: ReconnectCallbackType): this;
    /**
     * Triggered when connection attempts are stopped
     * @param callback
     * @returns
     */
    onReconnectFailed(callback: ReconnectFailedCallbackType): this;
    /**
     * Triggered when any message is received
     * @param callback
     * @returns
     */
    onMessage<Event>(callback: MessageCallbackType<Event>): this;
    /**
     * Triggered when any event is emitted
     * @param callback
     * @returns
     */
    onSend(callback: SendCallbackType<EmitterInstance>): this;
    /**
     * Triggered when we receive error
     * @param callback
     * @returns
     */
    onError<Event>(callback: ErrorCallbackType<Event>): this;
    /**
     * ********************
     * Interceptors
     * ********************
     */
    unstable__modifySend: (emitter: EmitterInstance) => EmitterInstance;
    unstable__modifyResponse: (data: {
        data: any;
        extra: ExtractAdapterExtraType<Adapter>;
    }) => {
        data: any;
        extra: any;
    };
    /**
     * ********************
     * Creators
     * ********************
     */
    /**
     * Create event listener
     * @param options
     * @returns
     */
    createListener: <Response>() => <Endpoint extends string>(options: ListenerOptionsType<Endpoint, Adapter>) => Listener<Response, Endpoint, Socket<Adapter>, false>;
    /**
     * Create event emitter
     * @param options
     * @returns
     */
    createEmitter: <Payload>() => <Endpoint extends string>(options: EmitterOptionsType<Endpoint, Adapter>) => Emitter<Payload, Endpoint, Socket<Adapter>, false, false>;
}

type SocketInstance = Socket<SocketAdapterInstance>;
type SocketOptionsType<Adapter extends SocketAdapterInstance> = {
    url: string;
    reconnect?: number;
    reconnectTime?: number;
    adapter?: (() => Adapter) | Adapter;
    adapterOptions?: ExtractAdapterOptionsType<Adapter>;
    queryParams?: ExtractAdapterQueryParamsType<Adapter>;
};
type ReconnectCallbackType = () => void;
type ReconnectFailedCallbackType = () => void;
type OpenCallbackType = () => void;
type CloseCallbackType = () => void;
type MessageCallbackType<Event> = (data: {
    event: Event;
}) => Event;
type SendCallbackType<EmitterType extends EmitterInstance> = (data: {
    emitter: EmitterType;
}) => EmitterInstance;
type ErrorCallbackType<Event> = (data: {
    error: Event;
}) => void;

declare const getErrorKey: () => string;
declare const getOpenKey: () => string;
declare const getCloseKey: () => string;
declare const getConnectingKey: () => string;
declare const getReconnectingKey: () => string;
declare const getReconnectingFailedKey: () => string;
declare const getListenerEventKey: () => string;
declare const getListenerRemoveKey: () => string;
declare const getEmitterStartEventKey: () => string;
declare const getEmitterErrorKey: () => string;
declare const getListenerRemoveByTopicKey: (event: string) => string;
declare const getListenerEventByTopicKey: (event: string) => string;
declare const getEmitterStartEventByTopicKey: (event: string) => string;
declare const getEmitterErrorByTopicKey: (event: string) => string;
declare const interceptListener: (interceptors: MessageCallbackType<any>[], event: {
    data: any;
    extra: any;
}) => {
    data: any;
    extra: any;
};
declare const interceptEmitter: <EmitterType extends EmitterInstance>(interceptors: SendCallbackType<EmitterType>[], emitter: EmitterType) => EmitterType;

declare const getSocketEvents: <Adapter extends SocketAdapterInstance>(eventEmitter: EventEmitter) => {
    readonly emitError: <ResponseType>({ error }: {
        error: ResponseType;
    }) => void;
    readonly emitConnected: () => void;
    readonly emitDisconnected: () => void;
    readonly emitConnecting: ({ connecting }: {
        connecting: boolean;
    }) => void;
    readonly emitReconnecting: ({ attempts }: {
        attempts: number;
    }) => void;
    readonly emitReconnectingFailed: ({ attempts }: {
        attempts: number;
    }) => void;
    readonly emitListenerEvent: <ResponseType>({ topic, data, extra, }: {
        topic: string;
        data: ResponseType;
        extra: ExtractAdapterExtraType<Adapter>;
    }) => void;
    readonly emitListenerRemoveEvent: ({ topic }: {
        topic: string;
    }) => void;
    readonly emitEmitterStartEvent: <EmitterType extends EmitterInstance>({ emitter }: {
        emitter: EmitterType;
    }) => void;
    readonly emitEmitterError: <EmitterType extends EmitterInstance>({ error, emitter, }: {
        error: Error;
        emitter: EmitterType;
    }) => void;
    readonly onError: (callback: <ResponseType>({ error }: {
        error: ResponseType;
    }) => void) => VoidFunction;
    readonly onConnected: (callback: () => void) => VoidFunction;
    readonly onDisconnected: (callback: () => void) => VoidFunction;
    readonly onConnecting: (callback: ({ connecting }: {
        connecting: boolean;
    }) => void) => VoidFunction;
    readonly onReconnecting: (callback: ({ attempts }: {
        attempts: number;
    }) => void) => VoidFunction;
    readonly onReconnectingFailed: (callback: ({ attempts }: {
        attempts: number;
    }) => void) => VoidFunction;
    readonly onEmitterStartEvent: <EmitterType extends EmitterInstance>(callback: ({ emitter }: {
        emitter: EmitterType;
    }) => void) => VoidFunction;
    readonly onEmitterStartEventByTopic: <EmitterType extends EmitterInstance>(emitter: Pick<EmitterType, "topic">, callback: ({ emitter }: {
        emitter: EmitterType;
    }) => void) => VoidFunction;
    readonly onEmitterError: <EmitterType extends EmitterInstance>(callback: ({ error, emitter }: {
        error: Error;
        emitter: EmitterType;
    }) => void) => VoidFunction;
    readonly onEmitterErrorByTopic: <EmitterType extends EmitterInstance>(emitter: Pick<EmitterType, "topic">, callback: ({ error, emitter }: {
        error: Error;
        emitter: EmitterType;
    }) => void) => VoidFunction;
    readonly onListenerEvent: <ResponseType = Event>(callback: ({ topic, data, extra, }: {
        topic: string;
        data: ResponseType;
        extra: ExtractAdapterExtraType<Adapter>;
    }) => void) => VoidFunction;
    readonly onListenerEventByTopic: <ListenerType extends ListenerInstance>(listener: Pick<ListenerType, "topic">, callback: ({ topic, data, extra, }: {
        topic: string;
        data: ResponseType;
        extra: ExtractAdapterExtraType<Adapter>;
    }) => void) => VoidFunction;
    readonly onListenerRemove: (callback: ({ topic }: {
        topic: string;
    }) => void) => VoidFunction;
    readonly onListenerRemoveByTopic: <ListenerType extends ListenerInstance>(listener: Pick<ListenerType, "topic">, callback: ({ topic }: {
        topic: string;
    }) => void) => VoidFunction;
};

declare const parseMessageEvent: <T extends {
    topic: string;
    data: any;
    event: any;
}>(event: MessageEvent<any>) => T & {
    event: MessageEvent<any>;
};

declare const getSocketUrl: (url: string, queryParams: string) => string;

declare const getSocketError: (event: Event) => string;

declare const getWebsocketAdapter: (url: string, adapterOptions: WebsocketAdapterOptionsType | EmptyTypes) => {
    listeners: Map<(...args: any[]) => any, {
        type: keyof WebSocketEventMap;
        listener: (...args: any[]) => void;
        options: any;
    }>;
    addEventListener: <K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any, options?: boolean | (AddEventListenerOptions & {
        disableCleanup?: boolean;
    })) => void;
    removeEventListener: <K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any, options?: boolean | EventListenerOptions) => void;
    clearListeners: () => void;
    binaryType: BinaryType;
    readonly bufferedAmount: number;
    readonly extensions: string;
    onclose: ((this: WebSocket, ev: CloseEvent) => any) | null;
    onerror: ((this: WebSocket, ev: Event) => any) | null;
    onmessage: ((this: WebSocket, ev: MessageEvent) => any) | null;
    onopen: ((this: WebSocket, ev: Event) => any) | null;
    readonly protocol: string;
    readonly readyState: number;
    readonly url: string;
    close(code?: number, reason?: string): void;
    send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
    readonly CONNECTING: 0;
    readonly OPEN: 1;
    readonly CLOSING: 2;
    readonly CLOSED: 3;
    dispatchEvent(event: Event): boolean;
} | null;

type SSEAdapterOptionsType = {
    eventSourceInit?: EventSourceInit;
    autoConnect?: boolean;
};

/**
 * -------------------------------------------
 * Websocket
 * -------------------------------------------
 */
type ServerSentEventsAdapterType = SocketAdapter<MessageEvent<any>, SSEAdapterOptionsType, undefined, undefined, QueryParamsType | string, typeof stringifyQueryParams>;
declare const ServerSentEventsAdapter: () => ServerSentEventsAdapterType;

declare const getServerSentEventsAdapter: (url: string, adapterOptions: SSEAdapterOptionsType | EmptyTypes) => {
    listeners: Map<(...args: any[]) => any, {
        type: keyof EventSourceEventMap;
        listener: (...args: any[]) => void;
        options: any;
    }>;
    onopen: EventSource["onopen"];
    onerror: EventSource["onerror"];
    onmessage: EventSource["onmessage"];
    addEventListener: <K extends keyof EventSourceEventMap>(type: K, listener: (this: EventSource, ev: EventSourceEventMap[K]) => any, options?: boolean | (AddEventListenerOptions & {
        disableCleanup?: boolean;
    })) => void;
    removeEventListener: <K extends keyof EventSourceEventMap>(type: K, listener: (this: EventSource, ev: EventSourceEventMap[K]) => any, options?: boolean | EventListenerOptions) => void;
    clearListeners: () => void;
    readonly readyState: number;
    readonly url: string;
    readonly withCredentials: boolean;
    close(): void;
    readonly CONNECTING: 0;
    readonly OPEN: 1;
    readonly CLOSED: 2;
    dispatchEvent(event: Event): boolean;
} | null;

export { type CloseCallbackType, type ConnectMethodType, type Connector, type EmitMethodOptionsType, type EmitParamsType, type EmitPayloadType, type EmitType, Emitter, type EmitterCallbackErrorType, type EmitterCloneOptionsType, type EmitterInstance, type EmitterInstanceProperties, type EmitterOptionsType, type EmitterRestParams, type ErrorCallbackType, type EventReturnType, type ExtendEmitter, type ExtendListener, type ExtractAdapterEmitterOptionsType, type ExtractAdapterExtraType, type ExtractAdapterListenerOptionsType, type ExtractAdapterOptionsType, type ExtractAdapterQueryParamsMapperType, type ExtractAdapterQueryParamsType, type ExtractEmitterHasParamsType, type ExtractEmitterHasPayloadType, type ExtractEmitterOptionsType, type ExtractEmitterPayloadType, type ExtractEmitterSocketType, type ExtractEmitterTopicType, type ExtractListenerHasParamsType, type ExtractListenerOptionsType, type ExtractListenerResponseType, type ExtractListenerSocketType, type ExtractListenerTopicType, type ExtractSocketAdapterType, type ExtractSocketExtraType, type ExtractSocketOptionsType, type ListenType, Listener, type ListenerCallbackType, type ListenerConfigurationType, type ListenerInstance, type ListenerInstanceProperties, type ListenerOptionsType, type ListenerParamsOptionsType, type MessageCallbackType, type OpenCallbackType, type ReconnectCallbackType, type ReconnectFailedCallbackType, type RemoveListenerCallbackType, type SSEAdapterOptionsType, type SendCallbackType, ServerSentEventsAdapter, type ServerSentEventsAdapterType, Socket, SocketAdapter, type SocketAdapterInstance, type SocketData, type SocketInstance, type SocketOptionsType, type TupleRestType, WebsocketAdapter, type WebsocketAdapterOptionsType, type WebsocketAdapterType, getAdapterBindings, getCloseKey, getConnectingKey, getEmitterErrorByTopicKey, getEmitterErrorKey, getEmitterStartEventByTopicKey, getEmitterStartEventKey, getErrorKey, getListenerEventByTopicKey, getListenerEventKey, getListenerRemoveByTopicKey, getListenerRemoveKey, getOpenKey, getReconnectingFailedKey, getReconnectingKey, getServerSentEventsAdapter, getSocketError, getSocketEvents, getSocketUrl, getWebsocketAdapter, interceptEmitter, interceptListener, parseMessageEvent };