import BaseSignaling, { AddParticipantParams } from '../abstract/BaseSignaling';
import { ParticipantIdRegistry } from '../classes/ParticipantIdRegistry';
import { SharingStatReport } from '../classes/screenshare/SharingStatReport';
import { TransportTopology } from '../classes/transport/Transport';
import ConversationFeature from '../enums/ConversationFeature';
import ConversationOption from '../enums/ConversationOption';
import MediaOption from '../enums/MediaOption';
import SignalingCommandType from '../enums/SignalingCommandType';
import SignalingConnectionType from '../enums/SignalingConnectionType';
import UserRole from '../enums/UserRole';
import { JSONObject } from '../static/Json';
import { IAsrStartParams, IAsrStopParams } from '../types/Asr';
import { ChangeSimulcast } from '../types/ChangeSimulcast';
import MediaModifiers from '../types/MediaModifiers';
import MediaSettings from '../types/MediaSettings';
import { IAddMovieParams, IUpdateMovieData } from '../types/MovieShare';
import MuteStates from '../types/MuteStates';
import { NetworkStatReport } from '../types/NetworkStatReport';
import { CompositeUserId, ParticipantId, ParticipantStateData } from '../types/Participant';
import ParticipantLayout, { RequestKeyFrame, StopStream } from '../types/ParticipantLayout';
import { ParticipantListChunkParameters } from '../types/ParticipantListChunk';
import { StreamDescriptionString } from '../types/ParticipantStreamDescription';
import { PerfStatReport } from '../types/PerfStatReporter';
import SignalingMessage, { GetParticipantsSignalingResponse, GetRoomsSignalingResponse, SignalingSuccessResponse } from '../types/SignalingMessage';
import { IPublishStreamData, IRecordConfData, IStartStreamData, IStopStreamData } from '../types/Streams';
export default class Signaling extends BaseSignaling {
    private socket;
    protected sequence: number;
    private lastStamp;
    private websocketCommandsQueue;
    private datachannelCommandsQueue;
    private incomingCache;
    private responseHandlers;
    private connectionType;
    private reconnectCount;
    private endpoint;
    private wtEndpoint;
    protected conversationResolve: Function | null;
    protected conversationReject: Function | null;
    private connected;
    private listenersReady;
    private postfix;
    protected peerId: number | null;
    protected conversationId: string | null;
    private reconnectTimer;
    private connectionMessageWaitTimer;
    private doctorTimer;
    private participantIdRegistry;
    private producerNotificationDataChannel;
    private producerCommandDataChannel;
    private producerCommandDataChannelEnabled;
    private producerCommandSerializationService;
    private static get RECONNECT_DELAY();
    private static get RECONNECT_MAX_DELAY();
    private static get RECONNECT_MAX_COUNT();
    private static get WAIT_CONNECTION_DELAY();
    private static get WAIT_RESPONSE_DELAY();
    private static get WAIT_MESSAGE_DELAY();
    get ready(): boolean;
    setEndpoint(endpoint: string): void;
    setWebTransportEndpoint(endpoint: string | null): void;
    setConversationId(conversationId: string): void;
    setParticipantIdRegistry(participantIdRegistry: ParticipantIdRegistry): void;
    setProducerNotificationDataChannel(dataChannel: RTCDataChannel): void;
    setProducerCommandDataChannel(dataChannel: RTCDataChannel): void;
    useCommandDataChannel(status: boolean): void;
    /**
     * Free used resources
     */
    cleanup(): void;
    /**
     * Open a connection with a signaling server
     */
    connect(connectionType: SignalingConnectionType): Promise<SignalingMessage.Connection>;
    /**
     * Send a command to a signaling server
     */
    protected _send<T extends SignalingSuccessResponse>(command: SignalingCommandType, params?: any, needResponse?: boolean, retryCount?: number): Promise<T>;
    /**
     * Send a raw command to a signaling server
     */
    protected _sendRaw<T extends SignalingSuccessResponse>(command: SignalingCommandType, params?: any, needResponse?: boolean, retryCount?: number): Promise<T>;
    private _isDataChannelCommand;
    getNextCommandSequenceNumber(): number;
    hangup(reason: string): Promise<SignalingMessage | void>;
    sendCandidate(participantId: ParticipantId, candidate: RTCIceCandidate): Promise<SignalingMessage>;
    requestTestMode(consumerCommand: string, producerCommand: string | null): Promise<SignalingMessage>;
    sendSdp(participantId: ParticipantId, sdp: RTCSessionDescriptionInit, extraPayload?: Record<string, any>): Promise<SignalingMessage>;
    acceptCall(mediaSettings: MediaSettings): Promise<SignalingMessage>;
    changeMediaSettings(mediaSettings: MediaSettings): Promise<SignalingMessage>;
    changeParticipantState(state: ParticipantStateData, compositeUserId?: CompositeUserId): Promise<SignalingMessage>;
    hold(hold: boolean): Promise<SignalingMessage>;
    putHandsDown(): Promise<SignalingMessage>;
    addParticipant(externalIds: CompositeUserId[], params?: AddParticipantParams): Promise<SignalingMessage>;
    addParticipantLegacy(participantIds: CompositeUserId[], params?: AddParticipantParams): Promise<SignalingMessage>;
    removeParticipant(participantId: CompositeUserId, ban?: boolean): Promise<SignalingMessage>;
    allocateConsumer(description: RTCSessionDescription | null, capabilities: {
        [key: string]: number | boolean | string;
    }): Promise<SignalingMessage>;
    acceptProducer(description: RTCSessionDescriptionInit, ssrcs: string[], sessionId: string): Promise<SignalingMessage>;
    /**
     * @deprecated Use updateDisplayLayout instead
     */
    changePriorities(priorities: {
        [key: string]: number;
    }): Promise<SignalingMessage | void>;
    updateDisplayLayout(layouts: {
        [streamDesc: StreamDescriptionString]: ParticipantLayout | StopStream | RequestKeyFrame;
    }): Promise<SignalingMessage>;
    addMovie(data: IAddMovieParams): Promise<SignalingMessage>;
    updateMovie(data: IUpdateMovieData): Promise<SignalingMessage>;
    removeMovie(data: any): Promise<SignalingMessage>;
    startUrlSharing(sharedUrl: string): Promise<SignalingMessage>;
    stopUrlSharing(): Promise<SignalingMessage>;
    updateRooms(rooms: SignalingMessage.Room[], assignRandomly?: boolean): Promise<SignalingMessage>;
    activateRooms(roomIds: number[], deactivate: boolean): Promise<SignalingMessage>;
    switchRoom(toRoomId: number | null, participantId?: ParticipantId): Promise<SignalingMessage>;
    getRooms(withParticipants: boolean): Promise<GetRoomsSignalingResponse>;
    removeRooms(roomIds: number[]): Promise<SignalingMessage>;
    startStream(data: IStartStreamData): Promise<SignalingMessage>;
    stopStream(data?: IStopStreamData): Promise<SignalingMessage>;
    publishStream(data?: IPublishStreamData): Promise<SignalingMessage>;
    recordSetConf(conf?: IRecordConfData): Promise<SignalingMessage>;
    getRecordStatus(): Promise<SignalingMessage>;
    switchTopology(topology: TransportTopology, force?: boolean): Promise<SignalingMessage>;
    requestRealloc(): Promise<SignalingMessage>;
    reportPerfStat(report: PerfStatReport): Promise<SignalingMessage>;
    reportSharingStat(report: SharingStatReport): Promise<SignalingMessage>;
    reportNetworkStat(report: NetworkStatReport): Promise<SignalingMessage>;
    chatMessage(message: string, participantId?: CompositeUserId | null): Promise<SignalingMessage>;
    chatHistory(count: number): Promise<SignalingMessage>;
    customData(data: JSONObject, participantId: ParticipantId | null): Promise<SignalingMessage>;
    grantRoles(participantId: ParticipantId, roles: UserRole[], revoke: boolean): Promise<SignalingMessage>;
    muteParticipant(participantId: ParticipantId | null, muteStates: MuteStates, requestedMedia: MediaOption[], roomId?: number | null): Promise<SignalingMessage>;
    enableFeatureForRoles(feature: ConversationFeature, roles: UserRole[]): Promise<SignalingMessage>;
    pinParticipant(participantId: ParticipantId, unpin: boolean, roomId: number | null): Promise<SignalingMessage>;
    updateMediaModifiers(mediaModifiers: MediaModifiers): Promise<SignalingMessage>;
    enableVideoSuspend(enabled: boolean): Promise<SignalingMessage>;
    enableVideoSuspendSuggest(enabled: boolean): Promise<SignalingMessage>;
    changeSimulcast(changeSimulcast: ChangeSimulcast): Promise<SignalingMessage>;
    changeOptions(changes: {
        [key in ConversationOption]?: boolean;
    }): Promise<SignalingMessage>;
    getWaitingHall(fromId?: SignalingMessage.WaitingParticipantId | null, count?: number, backward?: boolean): Promise<SignalingMessage>;
    promoteParticipant(participantId?: CompositeUserId, demote?: boolean): Promise<SignalingMessage>;
    requestPromotion(unrequest?: boolean): Promise<SignalingMessage>;
    acceptPromotion(reject?: boolean): Promise<SignalingMessage>;
    feedback(key: string): Promise<SignalingMessage>;
    getHandQueue(): Promise<SignalingMessage>;
    /**
     * Close a connection with a signaling server
     */
    close(): void;
    /**
     * Этот метод нужен т.к. после получения сообщения "connected" устанавливается транспорт
     * и подписывается на сигналинг. Данные приходят очень быстро и транспорт пропускает
     * часть сообщений сигналинга. Этот метод вызывается вручную и сообщает о том,
     * что все подписчики готовы принимать сообщения от сигналинга.
     */
    readyToSend(isReady?: boolean): void;
    getParticipantListChunk(participantListChunkParameters: ParticipantListChunkParameters): Promise<SignalingMessage>;
    getParticipants(externalIds: SignalingMessage.ExternalId[]): Promise<GetParticipantsSignalingResponse>;
    getPeerId(): number | null;
    startAsr(params: IAsrStartParams): Promise<SignalingMessage>;
    stopAsr(params?: IAsrStopParams): Promise<SignalingMessage>;
    requestAsr(request: boolean): Promise<SignalingMessage>;
    protected _connect(connectionType: SignalingConnectionType, useWebTransport: boolean): void;
    protected _disconnect(code?: number): void;
    private _onOpen;
    private _onMessage;
    protected _handleMessage(message: SignalingMessage): void;
    private _handleErrorMessage;
    protected _handleCachedMessages(): void;
    private _throwError;
    private _onError;
    protected _onClose(event: CloseEvent): void;
    protected _closeSocket(error?: Error | null): void;
    protected _reconnect(): void;
    private _handleCommandResponse;
    private _handleCommandsQueue;
    private _startResponseTimer;
    private _serializeBinary;
    private _serializeJson;
    private _convertDisplayLayout;
    protected _waitConnectionMessage(): void;
    protected _stopWaitConnectionMessage(): void;
    /**
     * Отвечает за timeout логику в WebSocket, если неполучаем никаких сообщений в течении WAIT_MESSAGE_DELAY, то запускаем реконнект
     */
    private _startDoctor;
    private _stopDoctor;
    private isWebTransportAvailable;
    private _getSocketType;
    private _markTransportStat;
    private _logTransportStat;
}