type TSocketIoMessage = {
    direction: "clientToServer" | "serverToClient";
    event: string;
    data: unknown[];
    timestamp: number;
    isBinary?: boolean;
};
type TSocketIoRecording = {
    type: "socketio";
    requestId: string;
    connection: {
        url: string;
        namespace?: string;
        timestamp: number;
        reject?: {
            message: string;
            afterMs?: number;
            code?: string | number;
            data?: unknown;
        };
    };
    messages: TSocketIoMessage[];
    closedAt?: number;
};
type TOnConnectBurst = {
    responses: {
        event: string;
        args: unknown[];
        delayMs: number;
    }[];
};
type TTriggeredStep = {
    expect: {
        event: string;
        args: unknown[];
    };
    responses: {
        event: string;
        args: unknown[];
        delayMs: number;
    }[];
};
type TSocketScenario = {
    namespace: string;
    onConnect: TOnConnectBurst;
    steps: TTriggeredStep[];
    disconnectAfterMs?: number;
    handshakeReject?: {
        message: string;
        afterMs?: number;
        code?: string | number;
        data?: unknown;
    };
};

type RecordingSourceContract = {
    load(): Promise<TSocketIoRecording>;
};

type ScenarioBuilderContract = {
    build(rec: TSocketIoRecording, opts?: {
        speed?: number;
    }): TSocketScenario;
};

type SocketPlayerContract = {
    start(s: TSocketScenario): Promise<void>;
    close(): void;
    connected(): boolean;
};

type SocketServerContract = {
    start(): Promise<void>;
    close(): void;
    connected(): boolean;
};
declare class MockSocketServer implements SocketServerContract {
    #private;
    constructor({ source, builder, player, buildOptions }: TArgs$1);
    start(): Promise<void>;
    close(): void;
    connected(): boolean;
}

type TArgs$1 = {
    source: RecordingSourceContract;
    builder: ScenarioBuilderContract;
    player: SocketPlayerContract;
    buildOptions?: {
        speed?: number;
    };
};

declare const makeMockSocketServer: ({ data, port, speed, }: TArgs) => MockSocketServer;

type TArgs = {
    data: unknown;
    port: number;
    speed?: number;
};

export { makeMockSocketServer };