import { BSON } from 'bson';
import { NetworkEventListener } from './utils/NetworkEventListener.js';
import { WebSocketForce, WSLike } from './utils/WebSocketForce.js';
import { PerfectWSSubRoute } from './PerfectWSSubRoute.js';
import { type WSDataMiddleware } from './middleware/dataMiddleware.js';
export type WSErrorShape = {
    message: string;
    code: string;
};
type WSRequestOptionsCallback<Response = any> = (data: Response | null, error: WSErrorShape | null, down: boolean) => void;
export type WSListenCallbackSend = (data: any, down?: boolean, allowPackageLoss?: boolean) => void | Promise<void>;
export type WSCallbackOptions = {
    send: WSListenCallbackSend;
    reject: (reason: string, code: string) => void;
    events: NetworkEventListener;
    abortSignal: AbortSignal;
    ws: WebSocketForce & {
        [key: string]: any;
    };
    requestId: string;
    clientId: string;
};
export type WSListenCallback<Params = any, Response = any> = (params: Params, options: WSCallbackOptions) => Promise<Response> | Response;
export type WSRequestOptions<Response = any, WSType extends WSLike = WSLike> = {
    callback?: WSRequestOptionsCallback<Response>;
    events?: NetworkEventListener;
    abortSignal?: AbortSignal;
    requestId?: string;
    /** Maximum request duration in milliseconds. Defaults to config.requestTimeout; 0 or Infinity disables it. */
    timeout?: number;
    doNotWaitForConnection?: boolean;
};
export type WSClientOptions = {
    /**
     * If true, unknown responses will be ignored and not aborted, and will not sync request when server is opened
     */
    temp?: boolean;
    /**
     * If true, disables ping timeouts and ack system (when the debugger is paused, pings and acks may timeout)
     */
    debugging?: boolean;
    /**
     * Stable logical id for reconnects of this in-memory router. Reusing it in a new process does not restore prior state.
     */
    clientId?: string;
};
type PreparedRequestData = {
    data: any;
    hasLiveResources?: boolean;
    commit: () => void;
    rollback: () => void;
};
export type WSClientResult<WSType extends WSLike = WSLike, Router extends PerfectWS<WSType> = PerfectWS<WSType>> = {
    router: Router;
    setServer: (socket: WSType | WebSocketForce<WSType>) => void;
    unregister: () => void;
};
export type WSServerResult<WSType extends WSLike = WSLike, Router extends PerfectWS<WSType> = PerfectWS<WSType>> = {
    router: Router;
    attachClient: (socket: WSType | WSLike) => () => void;
    autoReconnect: (url: string, webSocketConstructor?: new (url: string) => WSType) => () => void;
    unregister: () => void;
};
export type PerfectWSConfig = {
    connectionTimeout: number;
    reconnectTimeout: number;
    clearOldRequestsDelay: number;
    requestTimeout: number;
    syncRequestsTimeout: number;
    maxListeners: number;
    pingRequestTimeout: number;
    pingIntervalMs: number;
    pingReceiveTimeout: number;
    delayBeforeReconnect: number;
    sendRequestRetries: number;
    verbose: boolean;
    maxTransformDepth: number;
    fullTrustedRPC: boolean;
    syncRequestsWhenServerOpen: boolean;
    abortUnknownResponses: boolean;
    runPingLoop: boolean;
    enableAckSystem: boolean;
    ackTimeout: number;
    ackRetryDelays: number[];
    processedPacketsCleanupInterval: number;
    maxProcessedPackets: number;
    maxTotalProcessedPackets: number;
    maxProcessedPacketClients: number;
    maxPendingAcks: number;
    maxTotalPendingAcks: number;
    maxPendingAcksKept: number;
    maxPendingAborts: number;
    maxTotalPendingAborts: number;
    pendingAbortsMinAge: number;
    maxActiveRequests: number;
    maxInternalRequests: number;
    maxMessageSize: number;
    maxPureRPCHandles: number;
    maxRPCOperations: number;
    autoWrapUnknownClasses: boolean;
    maxGlobalSymbols: number;
    processedPacketsRetention: number;
    clientId?: string;
};
export declare class PerfectWS<WSType extends WSLike = WSLike, ExtraConfig = {
    [key: string]: any;
}> {
    config: PerfectWSConfig & ExtraConfig;
    private _server?;
    private _serverReady;
    private _unregisterServer?;
    private _isClient?;
    private _listenForRequests;
    private _activeRequests;
    private _activeResponses;
    private _waitForNewServer;
    private _clearOldRequestActive;
    private _lastPingTimes;
    private _pendingAborts;
    private _addMiddlewareForNewRequests;
    private _pendingAcks;
    private _processedPackets;
    private _processedPacketsByClient;
    private _processedPacketsByClientCount;
    private _ackCleanupAbortController?;
    private _requestCleanupAbortController;
    private _unregistered;
    get isServerConnected(): boolean;
    get bufferedAmount(): number;
    get serverOpen(): Promise<boolean>;
    protected constructor();
    private _syncRequests;
    syncRequests(): Promise<void>;
    private hasRequest;
    private _ping;
    private __initPrivateMethods;
    private _setServer;
    request<Response = any>(method: string, data?: any, options?: WSRequestOptions<Response, WSType>): Promise<Response>;
    on<Data>(method: string, validator: WSDataMiddleware<Data>, ...callbacks: WSListenCallback<Data>[]): this;
    on(method: string, ...callbacks: WSListenCallback[]): this;
    off(method: string): this;
    protected serialize(data: any): Uint8Array<ArrayBufferLike>;
    protected deserialize(data: any): BSON.Document | null;
    protected serializeRequestData(data: any, events: NetworkEventListener): any;
    protected prepareRequestData(data: any, events: NetworkEventListener): PreparedRequestData;
    protected deserializeRequestData(data: any, events: NetworkEventListener): any;
    /** Whether the request event channel is still needed after the final response. */
    protected shouldKeepResponseAlive(events: NetworkEventListener): boolean;
    protected releaseRequestResources(_events: NetworkEventListener): void;
    private _sendJSON;
    private _sendData;
    private _sendWithAck;
    private _acceptPacket;
    private _pendingAbortKey;
    private _responseKey;
    private _getActiveResponse;
    private _setActiveResponse;
    private _deleteActiveResponse;
    private _onServerResponse;
    private _onRequest;
    private _connectWSToOnRequestResponse;
    private _clearOldRequests;
    private _startAckCleanupLoop;
    private _resolveWaitForServer;
    private _releaseAllChannels;
    protected static _newInstance<WSType extends WSLike = WSLike>(): PerfectWS<WSType, {
        [key: string]: any;
    }>;
    /** Add middleware that applies to every direct and mounted route on this router. */
    use(...middleware: WSListenCallback[]): this;
    /** Mount a child router under a prefix owned by this router. */
    mount(prefix: string, router: PerfectWSSubRoute): this;
    static client<WSType extends WSLike = WSLike>(config?: WSClientOptions): WSClientResult<WSType>;
    static client<WSType extends WSLike = WSLike>(server: WSType | WebSocketForce<WSType>, config?: WSClientOptions): WSClientResult<WSType>;
    static server<WSType extends WSLike = WSLike>(): WSServerResult<WSType>;
    static Router(): PerfectWSSubRoute;
}
export {};