import WebsocketTransport from './transport/websocket-transport';
import SignalrTransport from './transport/signalr-transport';
import SignalrCoreTransport from './transport/signalr-core-transport';
import type { ConnectionOptions } from '../types';
import type { StreamingTransportInterface, ReceiveCallback, StateChangeCallback } from './types';
export declare const TRANSPORT_NAME_MAP: {
    "signalrCore-websockets": {
        options: {
            transportType: "signalrCore-websockets";
            skipNegotiation: boolean;
        };
        instance: typeof SignalrCoreTransport;
    };
    "signalrCore-longpolling": {
        options: {
            transportType: "signalrCore-longpolling";
            skipNegotiation: boolean;
        };
        instance: typeof SignalrCoreTransport;
    };
    plainWebSockets: {
        options: {};
        instance: typeof WebsocketTransport;
    };
    webSockets: {
        options: {};
        instance: typeof SignalrTransport;
    };
    longPolling: {
        options: {};
        instance: typeof SignalrTransport;
    };
};
/**
 * Connection facade for multiple supported streaming approaches:
 * - WebSocket
 * - SignalR WebSocket/Long Polling (Legacy/Fallback solution).
 */
declare class Connection {
    baseUrl: string;
    failCallback: () => void;
    startCallback: () => void;
    stateChangedCallback: () => void;
    receiveCallback: ReceiveCallback;
    connectionSlowCallback: () => void;
    subscriptionResetCallback: () => void;
    authToken: string | null;
    authExpiry: number | null | undefined;
    contextId: string | null;
    options: ConnectionOptions;
    transports: Array<typeof TRANSPORT_NAME_MAP[keyof typeof TRANSPORT_NAME_MAP]>;
    state: string;
    transportIndex: number | null;
    transport: StreamingTransportInterface | null;
    unauthorizedCallback: () => void;
    constructor(options: ConnectionOptions, baseUrl: string, failCallback?: () => void);
    private getLogDetails;
    private ensureValidState;
    private onTransportFail;
    private createTransport;
    private getSupportedTransports;
    setUnauthorizedCallback(callback: (url: string) => void): void;
    setStateChangedCallback(callback: StateChangeCallback): void;
    setReceivedCallback(callback: ReceiveCallback): void;
    setConnectionSlowCallback(callback: () => void): void;
    setSubscriptionResetCallback(callback: () => void): void;
    start(callback: () => void): void;
    stop(): void;
    dispose(): void;
    updateQuery(authToken: string, contextId: string, authExpiry?: number, forceAuth?: boolean): void;
    getQuery(): string | void | null | undefined;
    onOrphanFound(): void;
    onSubscribeNetworkError(): void;
    /**
     * Get underlying transport
     *
     */
    getTransport(): StreamingTransportInterface | null;
}
export default Connection;