import { DataType } from "./DataType";
import ReadStream from "./streams/ReadStream";
import { CorkFunction, SendFunction } from "./Utils";
import { BadConnectionType } from "./Errors";
import { InvokePackage, Package } from "./Package";
import PackageBuffer, { PackageBufferOptions } from "./PackageBuffer";
import { BatchOption, BatchOptionsValue, ComplexTypesOption, ResponseTimeoutOption, ReturnDataTypeOption } from "./Options";
export declare type TransmitListener = (receiver: string, data: any, type: DataType) => void | Promise<void>;
export declare type InvokeListener = (procedure: string, data: any, end: (data?: any, processComplexTypes?: boolean) => void, reject: (err?: any) => void, type: DataType) => void | Promise<void>;
export interface TransportOptions extends PackageBufferOptions {
    responseTimeout: number;
    binaryContentPacketTimeout: number;
    streamsPerPackageLimit: number;
    streamsEnabled: boolean;
    chunksCanContainStreams: boolean;
    readStream: typeof ReadStream;
}
export default class Transport {
    options: TransportOptions;
    static readonly DEFAULT_OPTIONS: Readonly<TransportOptions>;
    static buildOptions(options: Partial<TransportOptions>): TransportOptions;
    readonly buffer: PackageBuffer;
    onInvalidMessage: (err: Error) => void;
    onListenerError: (err: Error) => void;
    onTransmit: TransmitListener;
    onInvoke: InvokeListener;
    onPing: () => void;
    onPong: () => void;
    send: SendFunction;
    cork: CorkFunction;
    hasLowSendBackpressure: () => boolean;
    readonly badConnectionStamp: number;
    constructor(connector?: {
        onInvalidMessage?: (err: Error) => void;
        onListenerError?: (err: Error) => void;
        onTransmit?: TransmitListener;
        onInvoke?: InvokeListener;
        onPing?: () => void;
        onPong?: () => void;
        send?: SendFunction;
        cork?: CorkFunction;
        hasLowSendBackpressure?: () => boolean;
    }, options?: TransportOptions, connected?: boolean);
    private _binaryContentPacketId;
    private _binaryContentResolver;
    private _objectStreamId;
    private _binaryStreamId;
    private _activeReadStreams;
    private _activeWriteStreams;
    private _cid;
    private _invokeResponsePromises;
    readonly open: boolean;
    private readonly _lowSendBackpressureWaiters;
    private _multiSend;
    emitMessage(rawMsg: string | ArrayBuffer): void;
    emitSendBackpressureDrain(): void;
    emitBadConnection(type: BadConnectionType, msg?: string): void;
    emitConnection(): void;
    private _onListenerError;
    private _rejectInvokeRespPromises;
    private _getNewBinaryContentPacketId;
    private _generateNewBadConnectionStamp;
    private _getNewCid;
    private _getNewStreamId;
    private _processBinaryPacket;
    private _processBinaryContentPacket;
    private _processTransmit;
    private _processJsonActionPacket;
    private _rejectInvoke;
    private _processStreamAccept;
    private _processStreamDataPermission;
    private _processReadStreamClose;
    private _processJsonWriteStreamClose;
    private _processJsonStreamChunk;
    private _processJsonStreamEnd;
    private _processBinaryStreamChunk;
    private _processBinaryStreamEnd;
    private _processInvoke;
    private _sendInvokeDataResp;
    private _processData;
    private _resolveBinaryContent;
    private _resolveMixedJSONDeep;
    private _internalResolveMixedJSONDeep;
    private static _createBinaryContentPacket;
    private _processMixedJSONDeep;
    private _rejectBinaryContentResolver;
    private _emitBadConnectionToStreams;
    prepareTransmit(receiver: string, data?: any, { processComplexTypes }?: ComplexTypesOption): Package;
    prepareInvoke<RDT extends true | false | undefined>(procedure: string, data?: any, { responseTimeout, processComplexTypes, returnDataType }?: ResponseTimeoutOption & ComplexTypesOption & ReturnDataTypeOption<RDT>): InvokePackage<RDT extends true ? [any, DataType] : any>;
    sendPackage(pack: Package, batch?: BatchOptionsValue): void;
    sendPackageWithPromise(pack: Package, batch?: BatchOptionsValue): Promise<void>;
    invoke<RDT extends true | false | undefined>(procedure: string, data?: any, options?: ResponseTimeoutOption & ComplexTypesOption & BatchOption & ReturnDataTypeOption<RDT>): Promise<RDT extends true ? [any, DataType] : any>;
    transmit(receiver: string, data?: any, options?: BatchOption & ComplexTypesOption): void;
    sendPing(): void;
    sendPong(): void;
    private _silentDirectSendPackage;
    private _directSendPackage;
    private static _createBinaryStreamChunkPacket;
    tryCancelPackage(pack: Package): boolean;
    private static _multiBinaryContentPacketId;
    private static _getNewMultiBinaryContentPacketId;
    static prepareMultiTransmit(receiver: string, data?: any, { processComplexTypes }?: ComplexTypesOption): Package;
    private static _processMultiMixedJSONDeep;
    connect(transport: Transport): void;
}