import { T as TGAuthEngine, a as TGSocketClientOptions, b as TransmitOptions, I as InvokeOptions, c as IClientSocket, P as ProtocolVersions, A as AuthEngine, d as AuthStatus, S as SubscribeOptions, e as TGChannel, C as ChannelState, f as SCChannelOptions } from './auth-291bd0a8.js';
export { g as AutoReconnectOptions, h as CallIdGenerator, W as WatcherFunction } from './auth-291bd0a8.js';
import { AsyncStreamEmitter, DemuxedConsumableStream } from 'topgun-async-stream-emitter';
import { S as SocketProtocolIgnoreStatuses, a as SocketProtocolErrorStatuses } from './types-d0b0478a.js';
import { SocketState, CodecEngine, EventObject, EventObjectCallback, AuthState, AuthToken } from './types.js';
import 'topgun-jsonwebtoken';
import './auth.js';

/**
 * Constructor
 */
declare class TGTransport extends AsyncStreamEmitter<any> {
    static CONNECTING: SocketState;
    static OPEN: SocketState;
    static CLOSED: SocketState;
    CONNECTING: SocketState;
    OPEN: SocketState;
    CLOSED: SocketState;
    state: SocketState;
    auth: TGAuthEngine;
    codec: CodecEngine;
    options: TGSocketClientOptions;
    connectTimeout: any;
    pingTimeout: any;
    pingTimeoutDisabled: boolean;
    callIdGenerator: any;
    authTokenName: any;
    socket: any;
    readonly _callbackMap: {
        [cid: number]: EventObject;
    };
    private _pingTimeoutTicker;
    private _batchSendList;
    private readonly _connectTimeoutRef;
    private _batchTimeout;
    /**
     * Constructor
     */
    constructor(authEngine: TGAuthEngine, codecEngine: CodecEngine, options: TGSocketClientOptions);
    uri(): string;
    getBytesReceived(): any;
    close(code?: number, data?: any): void;
    transmitObject(eventObject: EventObject, options?: any): number;
    transmit(event: string, data: any, options: TransmitOptions): Promise<void>;
    invokeRaw(event: string, data: any, options: InvokeOptions, callback?: EventObjectCallback): number | null;
    invoke<T>(event: string, data: T, options: InvokeOptions): Promise<EventObject>;
    cancelPendingResponse(cid: number): void;
    decode(message: any): any;
    encode(object: any): any;
    send(data: any): void;
    serializeObject(object: any): string;
    sendObjectBatch(object: any): void;
    sendObjectSingle(object: any): void;
    sendObject(object: any, options?: {
        batch?: boolean;
    }): void;
    _resetPingTimeout(): void;
    private _onOpen;
    private _handshake;
    private _abortAllPendingEventsDueToBadConnection;
    private _onClose;
    private _handleTransmittedEventObject;
    private _onMessage;
    private _onError;
    private _handleEventAckTimeout;
}

declare class TGClientSocket extends AsyncStreamEmitter<any> implements IClientSocket {
    static readonly CONNECTING: SocketState;
    static readonly OPEN: SocketState;
    static readonly CLOSED: SocketState;
    static readonly AUTHENTICATED: AuthState;
    static readonly UNAUTHENTICATED: AuthState;
    static readonly SUBSCRIBED = "subscribed";
    static readonly PENDING = "pending";
    static readonly UNSUBSCRIBED = "unsubscribed";
    static readonly ignoreStatuses: SocketProtocolIgnoreStatuses;
    static readonly errorStatuses: SocketProtocolErrorStatuses;
    readonly CONNECTING: SocketState;
    readonly OPEN: SocketState;
    readonly CLOSED: SocketState;
    readonly AUTHENTICATED: AuthState;
    readonly UNAUTHENTICATED: AuthState;
    readonly SUBSCRIBED = "subscribed";
    readonly PENDING = "pending";
    readonly UNSUBSCRIBED = "unsubscribed";
    readonly ignoreStatuses: SocketProtocolIgnoreStatuses;
    readonly errorStatuses: SocketProtocolErrorStatuses;
    options: TGSocketClientOptions;
    id: string | null;
    clientId?: string | undefined;
    version: string | null;
    protocolVersion: ProtocolVersions;
    state: SocketState;
    authState: AuthState;
    signedAuthToken: string | null;
    authToken: AuthToken | null;
    authTokenName: string;
    wsOptions?: TGSocketClientOptions | undefined;
    pendingReconnect: boolean;
    pendingReconnectTimeout: number;
    preparingPendingSubscriptions: boolean;
    ackTimeout: number;
    connectTimeout: number;
    pingTimeout: number;
    pingTimeoutDisabled: boolean;
    channelPrefix: string | null;
    disconnectOnUnload: boolean;
    connectAttempts: number;
    isBufferingBatch: boolean;
    isBatching: boolean;
    batchOnHandshake: boolean;
    batchOnHandshakeDuration: number;
    auth: AuthEngine;
    codec: CodecEngine;
    transport?: TGTransport | undefined;
    poolIndex?: number | undefined;
    private _reconnectTimeoutRef;
    private readonly _transmitBuffer;
    private readonly _channelMap;
    private _cid;
    private readonly _procedureDemux;
    private readonly _receiverDemux;
    private readonly _channelDataDemux;
    private readonly _channelEventDemux;
    private readonly _privateDataHandlerMap;
    private readonly _privateRPCHandlerMap;
    /**
     * Constructor
     */
    constructor(socketOptions?: TGSocketClientOptions);
    getState(): SocketState;
    getBytesReceived(): number;
    deauthenticate(): Promise<void>;
    connect(): void;
    reconnect(code?: number, reason?: string): void;
    disconnect(code?: number, reason?: string): void;
    decodeBase64(encodedString: string): string;
    encodeBase64(decodedString: string): string;
    getAuthToken(): AuthToken | null;
    getSignedAuthToken(): string;
    /**
     * Perform client-initiated authentication by providing an encrypted token string
     */
    authenticate(signedAuthToken: string): Promise<AuthStatus>;
    decode(message: any): any;
    encode(object: any): any;
    send(data: any): void;
    transmit(event: string, data?: any): Promise<void>;
    invoke(event: string, data: any): Promise<any>;
    publish(channelName: string, data?: any): Promise<any>;
    subscribe(channelName: string, options?: SubscribeOptions): TGChannel<any>;
    unsubscribe(channelName: string): void;
    channel(channelName: string): TGChannel<any>;
    getChannelState(channelName: string): ChannelState;
    getChannelOptions(channelName: string): SCChannelOptions;
    receiver(receiverName: string): DemuxedConsumableStream<any>;
    closeReceiver(receiverName: string): void;
    procedure(procedureName: string): DemuxedConsumableStream<any>;
    closeProcedure(procedureName: string): void;
    closeChannel(channelName: string): void;
    subscriptions(includePending?: boolean): string[];
    isSubscribed(channelName: string, includePending?: boolean): boolean;
    processPendingSubscriptions(): void;
    private _tryUnsubscribe;
    private _triggerChannelUnsubscribe;
    private _trySubscribe;
    private _undecorateChannelName;
    private _decorateChannelName;
    private _cancelPendingSubscribeCallback;
    private _triggerChannelSubscribeFail;
    private _triggerChannelSubscribe;
    private _processOutboundEvent;
    private _handleEventAckTimeout;
    private _flushTransmitBuffer;
    private _onInboundInvoke;
    private _onInboundTransmit;
    private _onClose;
    private _abortAllPendingEventsDueToBadConnection;
    private _suspendSubscriptions;
    private _onError;
    private _onOpen;
    private _tryReconnect;
    private _extractAuthTokenData;
    private _handleBrowserUnload;
    private _changeToUnauthenticatedStateAndClearTokens;
    private _changeToAuthenticatedState;
}

declare function create(options: TGSocketClientOptions): TGClientSocket;

export { AuthEngine, AuthStatus, IClientSocket, InvokeOptions, ProtocolVersions, SubscribeOptions, TGAuthEngine, TGClientSocket, TGSocketClientOptions, TGTransport, TransmitOptions, create };