import { Socket } from 'socket.io-client';
import type { Packet } from 'socket.io-parser';
export type { Socket } from 'socket.io-client';
type GetState<State> = () => State;
interface AnyAction extends Action {
    [extraProps: string]: any;
}
interface Action<T = any> {
    type: T;
}
export interface Dispatch<A extends Action = AnyAction> {
    <T extends A>(action: T): T;
}
export type StoreType<ApplicationState> = {
    dispatch: Dispatch;
    getState: GetState<ApplicationState>;
};
export type HistoryType = {
    push: (target: string) => void;
};
export type AdditionalParameters = {
    [key: string]: number | string | string[] | Record<string, unknown>;
};
type DefaultResultType = boolean | string | Record<string, string | boolean | number | unknown>;
type DefaultMessageType = string | boolean | boolean[] | Record<string, string | boolean | number | unknown> | undefined;
export type EventCallback<Result = DefaultResultType, Message = DefaultMessageType> = (result: Result, message: Message) => void;
export type SocketEventEmitter<DataToEmit, Result extends DefaultResultType = DefaultResultType, Message extends DefaultMessageType = DefaultMessageType> = (emitName: string, dataToEmit?: DataToEmit, ack?: EventCallback<Result, Message> | null) => void;
type EmitArgs<T> = T extends [...infer U] ? U : unknown;
type EmitGenericArgs = any[];
type InnerEmmiter<State, DataToEmit extends NonNullable<unknown> = NonNullable<unknown>> = (emitter: SocketEventEmitter<DataToEmit, any, any>, state: State, dispatch: Dispatch, ...args: EmitGenericArgs) => void;
export type PushToEmitQueueFunction<ApplicationState> = <EmitterArgs extends unknown[], DataToEmit extends NonNullable<unknown>>(innerEmitter: InnerEmmiter<ApplicationState, DataToEmit>, ...args: EmitArgs<EmitterArgs>) => void;
export type GetPushToEmitQueueFunction<ApplicationState> = (getState: GetState<ApplicationState>, dispatch: Dispatch) => PushToEmitQueueFunction<ApplicationState>;
export type ConnectionManager<ApplicationState> = {
    emitQueue: GetPushToEmitQueueFunction<ApplicationState>;
    closeConnection: (closeCallback?: () => void) => void;
    connectToSockets(store: StoreType<ApplicationState>, history: HistoryType, connectCallback?: () => void, disconnectCallback?: () => void, additionalParametersAddedOnConnect?: AdditionalParameters): void;
};
export type FirstEmitCallback<ApplicationState> = (getState: GetState<ApplicationState>, dispatch: Dispatch) => {
    emit: InnerEmmiter<ApplicationState>;
    args: unknown[];
};
type DisconnectDescription = Error | {
    description: string;
    context?: unknown;
};
export type ManagerReservedEventsHandlers<ApplicationState> = {
    open: (store: StoreType<ApplicationState>, emitQueue: PushToEmitQueueFunction<ApplicationState>) => void;
    error: (store: StoreType<ApplicationState>, err: Error) => void;
    ping: () => void;
    packet: (store: StoreType<ApplicationState>, packet: Packet) => void;
    close: (reason: string, description?: DisconnectDescription) => void;
    reconnect_failed: (store: StoreType<ApplicationState>, emitQueue: PushToEmitQueueFunction<ApplicationState>) => void;
    reconnect_attempt: (store: StoreType<ApplicationState>, emitQueue: PushToEmitQueueFunction<ApplicationState>, attempt: number) => void;
    reconnect_error: (store: StoreType<ApplicationState>, emitQueue: PushToEmitQueueFunction<ApplicationState>, err: Error) => void;
    reconnect: (store: StoreType<ApplicationState>, emitQueue: PushToEmitQueueFunction<ApplicationState>, attempt: number) => void;
};
export type SocketEventListener<ApplicationState> = (socket: Socket, getState: GetState<ApplicationState>, dispatch: Dispatch, history: HistoryType, ...args: unknown[]) => void;
export type SocketAndManagerReservedEvents<ApplicationState> = Partial<SocketReservedEvents<ApplicationState> & ManagerReservedEventsHandlers<ApplicationState>>;
export type SocketEmitWrapperFunction = <DataToEmit extends NonNullable<unknown>>(emitName: string, dataToSend: DataToEmit, newAck: EventCallback<any, any> | null, callback: SocketEventEmitter<DataToEmit>) => void;
export type SocketReservedEvents<ApplicationState> = {
    connect: (store: StoreType<ApplicationState>, toEmitQueue: PushToEmitQueueFunction<ApplicationState>, history: HistoryType, connectCallback: () => void, disconnectCallback: () => void) => void;
    connect_error: (store: StoreType<ApplicationState>, toEmitQueue: PushToEmitQueueFunction<ApplicationState>, err: Error) => void;
    disconnect: (store: StoreType<ApplicationState>, reason: Socket.DisconnectReason, description?: DisconnectDescription) => void;
};
export type ToEmitItem = [
    emitName: string,
    newArgs: Record<string, unknown>,
    ack: EventCallback | null
];
//# sourceMappingURL=SocketConnectionManager.types.d.ts.map