import type { IEffect } from '@vkontakte/calls-video-effects';
import type { RGBTuple } from '@vkontakte/calls-vmoji';
import BaseApi from '../abstract/BaseApi';
import BaseLogger from '../abstract/BaseLogger';
import { AddParticipantParams } from '../abstract/BaseSignaling';
import ConversationFeature from '../enums/ConversationFeature';
import ConversationOption from '../enums/ConversationOption';
import MediaOption from '../enums/MediaOption';
import UpdateDisplayLayoutErrorReason from '../enums/UpdateDisplayLayoutErrorReason';
import UserRole from '../enums/UserRole';
import UserType from '../enums/UserType';
import { JSONObject } from '../static/Json';
import { IAsrStartParams, IAsrStopParams } from '../types/Asr';
import { AudienceModeHandsResponse } from '../types/AudienceMode';
import { ConversationData, ConversationOnStartParams } from '../types/Conversation';
import { ExternalId, ExternalParticipant, ExternalParticipantId, ExternalParticipantListChunk, ExternalUserId } from '../types/ExternalId';
import type { FastJoinHandler } from '../types/FastJoin';
import MediaModifiers from '../types/MediaModifiers';
import { IVideoDimentions } from '../types/MediaSettings';
import { IAddMovieParams, IUpdateMovieData } from '../types/MovieShare';
import MuteStates from '../types/MuteStates';
import { CompositeUserId, IGetParticipantsParameters, ParticipantId, ParticipantStateData } from '../types/Participant';
import { ParticipantLayout } from '../types/ParticipantLayout';
import { ParticipantListChunkParameters } from '../types/ParticipantListChunk';
import ParticipantPriority from '../types/ParticipantPriority';
import { ParticipantStreamDescription } from '../types/ParticipantStreamDescription';
import { ScreenCaptureSettings } from '../types/ScreenCaptureSettings';
import SignalingMessage from '../types/SignalingMessage';
import { WaitingHallResponse } from '../types/WaitingHall';
import EventEmitter from './EventEmitter';
export default class Conversation extends EventEmitter {
    private readonly _api;
    private readonly _signaling;
    private readonly _signalingActor;
    private _mediaSource;
    private _conversation;
    private _myLastRequestedLayouts;
    private _state;
    private _participantState;
    private _participants;
    private _pendingParticipants;
    private _transport;
    private _debugInfo;
    private _volumesDetector;
    private _speakerDetector;
    private _localVolumeDetector;
    private _specListener;
    private _activeSpeakerId;
    private _lastSignalledActiveSpeakerId;
    private _isRealTimeAsrRequested;
    private _serverSettings;
    private static _current;
    private static _activationMutex;
    private static _delayedHangup;
    private static _abortController;
    private readonly _onUnload;
    private readonly _audioOutput;
    private _lastStalled;
    private _audioMixStalled;
    private _audioFix;
    private _streamByStreamId;
    private _streamIdByStreamDescription;
    private _streamWaitTimerByStreamDescription;
    private _sequenceNumberByStreamDescription;
    private _cooldownTimestampByStreamDescription;
    private _cooldownQueueCleanupTimer;
    private readonly _statFirstMediaReceived;
    constructor(api: BaseApi, externalLogger: BaseLogger | null);
    static current(): Conversation | null;
    static hangupAfterInit(): void;
    static id(): string | null;
    onStart({ opponentIds, opponentType, mediaOptions, payload, joiningAllowed, requireAuthToJoin, onlyAdminCanShareMovie, externalIds, onFastStart, conversationId, }: ConversationOnStartParams): Promise<ConversationData>;
    onJoin(joinArgs: {
        conversationId?: string;
        mediaOptions: MediaOption[];
        chatId?: string;
        joinLink?: string;
        observedIds?: ExternalUserId[];
        payload?: string;
        onFastJoin?: FastJoinHandler;
    }): Promise<ConversationData>;
    private _onJoinPart2;
    private _extractExternalRooms;
    private _extractExternalRoomsData;
    onPush(conversationId: string, type?: UserType, peerId?: number, conversationParams?: string, wsEndpoint?: string): Promise<void>;
    private _isInWaitingHall;
    private _isWaitForAdmin;
    private _isRestricted;
    private _isAudienceMode;
    private _isAudienceModeListener;
    private _acceptConcurrent;
    private _getMainRoomParticipants;
    private _decodeExternalConversationParams;
    private _logCallStartEvent;
    accept(mediaOptions: MediaOption[]): Promise<ConversationData>;
    decline(): Promise<void>;
    hangup(): Promise<void>;
    addParticipant(participantIds: ExternalId[], params?: AddParticipantParams): Promise<void>;
    addParticipantLegacy(participantIds: CompositeUserId[], params?: AddParticipantParams): Promise<void>;
    removeParticipant(participantId: CompositeUserId, ban?: boolean): Promise<void>;
    setVolume(volume: number): void;
    updateStatisticsInterval(): void;
    private _openTransport;
    private _close;
    destroy(): Promise<void>;
    private _getConversationParams;
    private _setConversationParams;
    private _addGeoParamsToEndpoint;
    /**
     * @throws ErrorEvent
     */
    private _startConversation;
    /**
     * @throws ErrorEvent
     */
    private _joinConversation;
    /**
     * @throws ErrorEvent
     */
    private _prepareConversation;
    private _createParticipant;
    private _getParticipantId;
    private _setConversation;
    private _updateConversation;
    private _createMediaSource;
    private _connectSignaling;
    private _processConnection;
    private _onConversationParticipantListChunk;
    private _createParticipantListChunk;
    private _participantListChunkToExternalChunk;
    private _registerConnectionParticipants;
    private _registerParticipants;
    /** Установим состояние локальных мьютов */
    private _registerParticipantLocalMuteState;
    private _getStatusByTransportState;
    private _registerParticipantInCache;
    private _getExistedParticipantByIdOrCreate;
    private _getExternalIdByParticipantId;
    private _registerParticipantAndSetMarkersIfChunkEnabled;
    private _warnParticipantNotInConversation;
    private _denormalizeMarkers;
    /**
     * Обрабатывает информацию о сессионных залах
     *
     * @param connection
     */
    private _processRooms;
    /** Обрабатывает информацию о мьютах в основном и сессионных залах */
    private _processMuteStates;
    /**
     * Обрабатывает информацию о записи/трансляции в основном и сессионных залах
     * @param connection
     * @private
     * @hidden
     */
    private _processRecordInfos;
    /**
     * Обрабатывает информацию об адмниских пинах в основном и сессионных залах
     * @param connection
     * @private
     * @hidden
     */
    private _processPinnedParticipants;
    private _allocateTransport;
    private _createSpeakerDetector;
    private _createSpecListener;
    private _logDevices;
    private _logWithMediaSettings;
    private _removeParticipant;
    private _cleanupListeners;
    private _cleanupMediaSource;
    private _cleanupParticipants;
    private _cleanupParticipantAgnosticStreams;
    private _cleanupTransport;
    private _cleanupSpeakerDetector;
    private _cleanupSpecListener;
    private _cleanupSignaling;
    private _onAddParticipant;
    private _onRemoveParticipant;
    changeDevice(kind: MediaDeviceKind): Promise<void>;
    stopVideoTrack(): void | undefined;
    toggleScreenCapturing(settings: ScreenCaptureSettings): Promise<void>;
    disableScreenCapturing(): Promise<void>;
    toggleAnimojiCapturing(state: boolean): void;
    setAnimojiSvg(
    /** svg в незашифрованном (string) или зашифрованном (ArrayBuffer) виде */
    svg: string | ArrayBuffer, 
    /** participantId внешнего участника звонка, не требуется для текущего участника (текущего пользователя клиента) */
    participantId?: ParticipantId | null, 
    /** ключ расшифровки svg внешнего пользователя или кастомный ключ, не требуется для незашифрованных svg */
    decryptionKey?: string | null): void;
    setAnimojiFill(fill: RGBTuple | string): void;
    setVideoStream(stream: MediaStream, isScreen?: boolean): Promise<void>;
    setAudioStream(stream: MediaStream): Promise<void>;
    toggleLocalVideo(enabled: boolean): Promise<void>;
    toggleLocalAudio(enabled: boolean): Promise<void>;
    /**
     * @deprecated Use updateDisplayLayout instead
     */
    changePriorities(priorities: ParticipantPriority[]): Promise<void>;
    changeParticipantState(state: ParticipantStateData, compositeUserId?: CompositeUserId): Promise<void>;
    hold(hold: boolean): Promise<void>;
    putHandsDown(): Promise<void>;
    requestKeyFrame(participantStreamDescription: ParticipantStreamDescription): Promise<void | SignalingMessage>;
    requestTestMode(consumerCommand: string, producerCommand: string): Promise<void>;
    updateDisplayLayout(layouts: ParticipantLayout[]): Promise<void>;
    feedback(key: string): Promise<SignalingMessage>;
    userFeedbackStats(userResponse: number, reason?: string, groupCallUsersCount?: number): void;
    sendClientEvent(eventType: string, eventData?: Record<string, string | number | boolean>, immediately?: boolean): void;
    private _changeMediaSettings;
    private _stopStreaming;
    /**
     * @param layoutByStreamDescription
     * @param throwErrorOutside false используется при внутреннем обращении, когда обработка ошибки не нужна
     */
    private _sendUpdateDisplayLayout;
    private _cleanupCooldownQueue;
    private _onParticipantSourcesUpdate;
    private _onParticipantPromoted;
    private _onChatRoomUpdated;
    private _onSharedMovieUpdate;
    private _onSharedMovieInfoStarted;
    private _processSharedMovieInfos;
    private _processSharedMovieInfo;
    private _processConnectionSharedMovieInfo;
    private _processConnectionAsrInfo;
    private _processConversationUrlSharingInfo;
    private _extractConnectionUrlSharingInfo;
    private _onSharedMovieInfoStopped;
    private _onUrlSharingInfoUpdated;
    private _onFeaturesPerRoleChanged;
    private _waitForStreamIfNeeded;
    private _getStreamDescriptionById;
    private _matchStreamDescription;
    private _getWaitingTime;
    private _isCallAdmin;
    private _checkAdminRole;
    private _isCalledState;
    grantRoles(participantId: ParticipantId, roles: UserRole[], revoke: boolean): Promise<void>;
    startAsr(params: IAsrStartParams): Promise<void>;
    stopAsr(params?: IAsrStopParams): Promise<void>;
    requestAsr(request: boolean): Promise<void>;
    muteParticipant(participantId: (ParticipantId | null) | undefined, muteStates: MuteStates, requestedMedia?: MediaOption[], roomId?: number | null): Promise<void>;
    enableFeatureForRoles(feature: ConversationFeature, roles: UserRole[]): Promise<void>;
    pinParticipant(participantId: ParticipantId, unpin: boolean, roomId?: number | null): Promise<void>;
    updateMediaModifiers(mediaModifiers: MediaModifiers): Promise<void>;
    enableVideoSuspend(enabled: boolean): Promise<void>;
    enableVideoSuspendSuggest(enabled: boolean): Promise<void>;
    changeOptions(changes: {
        [key in ConversationOption]?: boolean;
    }): Promise<void>;
    /**
     * @see https://wiki.odkl.ru/pages/viewpage.action?pageId=89107473
     * @hidden
     */
    getWaitingHall(pageMarker: string | null, count?: number, backward?: boolean): Promise<WaitingHallResponse>;
    private _resolveWaitingHallExternalIds;
    getAudienceModeHands(): Promise<AudienceModeHandsResponse>;
    promoteParticipant(participantId?: CompositeUserId, demote?: boolean): Promise<void>;
    requestPromotion(unrequest?: boolean): Promise<void>;
    acceptPromotion(reject?: boolean): Promise<void>;
    chatMessage(message: string, participantId?: CompositeUserId | null): Promise<void>;
    chatHistory(count: number): Promise<void>;
    customData(data: JSONObject, participantId?: ParticipantId | null): Promise<void>;
    createJoinLink(): Promise<string>;
    removeJoinLink(): Promise<undefined>;
    addMovie({ movieId, gain, metadata, lang }: IAddMovieParams): Promise<{
        movieId: number;
        streamType: string;
    }>;
    updateMovie(params: IUpdateMovieData): Promise<void>;
    removeMovie(movieId: number): Promise<void>;
    startUrlSharing(sharedUrl: string): Promise<void>;
    stopUrlSharing(): Promise<void>;
    updateRooms(rooms: SignalingMessage.Room[], assignRandomly?: boolean): Promise<void>;
    activateRooms(roomIds: number[], deactivate: boolean): Promise<void>;
    switchRoom(toRoomId: number | null, participantId?: ParticipantId): Promise<void>;
    removeRooms(roomIds: number[]): Promise<void>;
    startStream(isRecord?: boolean, name?: string | null, movieId?: string | null, privacy?: 'PUBLIC' | 'FRIENDS' | 'DIRECT_LINK', groupId?: string | null, roomId?: number | null): Promise<undefined>;
    stopStream(roomId?: number | null, remove?: boolean): Promise<undefined>;
    publishStream(roomId?: number | null): Promise<undefined>;
    recordSetConf(king?: ParticipantId, pawns?: ParticipantId[], hideParticipantCount?: boolean, roomId?: number | null): Promise<void>;
    getStreamInfo(): Promise<{
        movieId: any;
        preview: any;
    }>;
    setLocalResolution({ video, effect }: {
        video: IVideoDimentions;
        effect?: IVideoDimentions;
    }): Promise<void>;
    videoEffect(effect: IEffect | null): Promise<void | undefined>;
    audioEffect(effects: string[] | null, isPreset?: boolean): Promise<void | undefined>;
    _convertExternalIdsToServerExternalIds(externalIds: ExternalId[]): SignalingMessage.ExternalId[];
    getParticipants(parameters: IGetParticipantsParameters): Promise<ExternalParticipant[]>;
    getParticipantListChunk(participantListChunkParameters: ParticipantListChunkParameters): Promise<ExternalParticipantListChunk>;
    private _getInitialParticiapntListChunk;
    private _onLocalMediaStreamChanged;
    private _onScreenSharingStatus;
    private _changeRemoteMediaSettings;
    private _extractLocalParticipantFromConnection;
    private _changeLocalParticipantState;
    private _changeRemoteParticipantState;
    private _changeMultipleParticipantState;
    private _invokeRolesChangedCallbackIfNeeded;
    private _onSignalingNotification;
    private _onPromotionApproved;
    private _onSignalingReconnect;
    private _onSignalingFailed;
    private _onAcceptedCall;
    private _onHungup;
    private _onAddedParticipant;
    private _onJoinedParticipant;
    private _onClosedConversation;
    private _onMediaSettingsChanged;
    private _onParticipantStateChanged;
    private _onParticipantsStateChanged;
    private _onNeedRate;
    private _onFeatureSetChanged;
    private _onMultipartyChatCreated;
    private _onForceMediaSettingsChange;
    private _onSettingsUpdate;
    private _onVideoQualityUpdate;
    private _onPeerRegistered;
    private _onMicSwitched;
    private _onChatMessage;
    private _onCustomData;
    private _onRecordInfo;
    private _onStopRecordInfo;
    private _changePinnedParticipantForRoom;
    _changeRecordInfoForRoom(): Promise<void>;
    private _changeAsrInfoForRoom;
    private _changeUrlSharingInfoForRoom;
    private _onParticipantAnimojiChanged;
    private _onAsrStart;
    private _onAsrStop;
    private _onAsrTranscription;
    private _onRolesChanged;
    /**
     * Клиент должен немедленно выключить микрофон и/или камеру
     */
    private _onMuteParticipant;
    private _changeMuteStatesForRoom;
    private _processMuteState;
    private _onPinParticipant;
    private _onOptionsChanged;
    private _onNetworkStatus;
    private _onRemoteStreamSecond;
    /**
     * Коллбек, вызывающийся при получении/остановке стрима от AnimojiReceiver
     * @param participantId - участник, к которому относится стрим
     * @param stream - стрим анимированного аватара, null в случае остановки стрима
     */
    private _onAnimojiStream;
    /**
     * Коллбек, вызывающийся при получении ошибки от AnimojiReceiver
     * @param error - ошибка рендеринга Vmoji
     */
    private _onAnimojiError;
    private _onPeerConnectionClosed;
    private _changeFeatureSet;
    private _changeFeaturesPerRole;
    private _changeNeedRate;
    private _onVolumesDetected;
    private _onSpeakerChanged;
    private _onTransportStateChanged;
    private _onTransportLocalStateChanged;
    private _onRemoteTrackAdded;
    private _onRemoteTrackRemoved;
    private _removeAudioTrack;
    private _removeVideoTrack;
    private _onTopologyChanged;
    private _onAudioMixStall;
    private _onRemoteSignalledStall;
    private _onRemoteDataStats;
    private _fixAudioDevice;
    private _fixVideoDevice;
    private _toggleJoinAvailability;
    private _updateDisplayLayoutFromCache;
    private _setParticipantsStatus;
    private _onJoinLinkChanged;
    private _onRoomsUpdated;
    private _onRoomUpdated;
    private _convertRoomToExternal;
    private _onRoomParticipantsUpdated;
    /**
     * @param roomId
     * @param isStartEvent в случае true будет отправлено стартовое событие установки id сессионного зала
     * @private
     */
    private _onRoomSwitched;
    private _refreshRooms;
    /** получили из сингналинга сообщение о реакции пользователей */
    private _onFeedback;
    private _onDecorativeParticipantIdChanged;
    private _onVideoSuspendSuggest;
    private _isMe;
    private _getMuteStatesForRoomId;
    private _getMuteStatesForCurrentRoom;
    private _setMuteStatesForRoomId;
    private _forceOpenTransportForAloneInCall;
    private _registerParticipant;
    private _getParticipants;
    private _getParticipant;
}
export declare class UpdateDisplayLayoutError extends Error {
    readonly participantErrors: {
        externalId: ExternalParticipantId;
        errorReason: UpdateDisplayLayoutErrorReason;
    }[];
    constructor(m: string, participantErrors: {
        externalId: ExternalParticipantId;
        errorReason: UpdateDisplayLayoutErrorReason;
    }[]);
}