import { AxiosRequestConfig } from 'axios';
import { EventEmitter } from 'events';
import { LiveCaptionEvent, RoleName, ChatMessage as ChatMessage$2, ChatFileShare, FileShareErrorCode, BreakoutConfig, RoomMode, KnockResponse, RtcManager, RtcManagerDispatcher, ServerSocket, RoomJoinedErrors, RoomJoinedSuccess } from '@whereby.com/media';
export { ChatFileShare, KnockResponse, KnockResponseSender, RoomJoinedSuccess } from '@whereby.com/media';
import * as redux_thunk from 'redux-thunk';
import * as _reduxjs_toolkit from '@reduxjs/toolkit';
import * as redux from 'redux';
import { Setup, Params } from '@whereby.com/camera-effects';

type Json = string | number | boolean | null | Array<Json> | {
    [key: string]: Json;
};
interface ResponseOptions {
    data?: Json;
    headers?: Record<string, unknown>;
    status?: number;
    statusText?: string;
    url?: string | null;
}
declare class Response {
    data: Json;
    headers: Record<string, unknown>;
    status: number;
    statusText: string;
    url: string | null;
    constructor(initialValues?: ResponseOptions);
}

type HttpClientRequestConfig = AxiosRequestConfig | {
    [key: string]: unknown;
};
interface IHttpClient {
    request(url: string, options: HttpClientRequestConfig): Promise<Response>;
}
declare class HttpClient implements IHttpClient {
    _baseUrl: string;
    constructor({ baseUrl }: {
        baseUrl: string;
    });
    private _requestAxios;
    request(url: string, options: HttpClientRequestConfig): Promise<Response>;
}

declare class MultipartHttpClient implements IHttpClient {
    _httpClient: IHttpClient;
    constructor({ httpClient }: {
        httpClient: IHttpClient;
    });
    static dataToFormData(data: Record<string, string>): FormData;
    request(url: string, options?: HttpClientRequestConfig): Promise<Response>;
}

interface CredentialsOptions {
    uuid: string;
    hmac: string;
    userId?: string;
}
declare class Credentials {
    credentials: {
        uuid: CredentialsOptions["uuid"];
    };
    hmac: CredentialsOptions["hmac"];
    userId: CredentialsOptions["userId"];
    constructor(uuid: CredentialsOptions["uuid"], hmac: CredentialsOptions["hmac"], userId?: CredentialsOptions["userId"]);
    toJson(): Json;
    static fromJson(json: Json): Credentials;
}

interface AuthenticatedHttpClientOptions {
    httpClient: HttpClient;
    fetchDeviceCredentials: () => Promise<Credentials | null>;
}
declare class AuthenticatedHttpClient {
    private _httpClient;
    private _fetchDeviceCredentials;
    constructor({ httpClient, fetchDeviceCredentials }: AuthenticatedHttpClientOptions);
    request(url: string, options: HttpClientRequestConfig): Promise<Response>;
}
interface ApiClientOptions {
    baseUrl?: string;
    fetchDeviceCredentials?: AuthenticatedHttpClientOptions["fetchDeviceCredentials"];
}
declare class ApiClient {
    authenticatedHttpClient: AuthenticatedHttpClient;
    authenticatedFormDataHttpClient: MultipartHttpClient;
    constructor({ baseUrl, fetchDeviceCredentials, }?: ApiClientOptions);
    request(url: string, options: HttpClientRequestConfig): Promise<Response>;
    requestMultipart(url: string, options: HttpClientRequestConfig): Promise<Response>;
}

declare class DeviceService {
    _apiClient: ApiClient;
    constructor({ apiClient }: {
        apiClient: ApiClient;
    });
    getCredentials(): Promise<Credentials | null>;
}

interface AbstractStore {
    loadOrDefault(defaultValue: Json): Promise<Json>;
    save(value: Json): Promise<void>;
}

declare class CredentialsService extends EventEmitter {
    _deviceService: DeviceService;
    _credentialsStore: AbstractStore;
    credentialsPromise?: Promise<Credentials | null>;
    constructor({ deviceService, credentialsStore, }: {
        deviceService: DeviceService;
        credentialsStore: AbstractStore;
    });
    static create({ baseUrl, storeName, storeType, }: {
        baseUrl: string;
        storeName?: string;
        storeType?: "localStorage" | "chromeStorage";
    }): CredentialsService;
    _fetchNewCredentialsFromApi(): Promise<Credentials | null>;
    getCurrentCredentials(): Promise<Credentials | null>;
    getCredentials(): Promise<Credentials | null>;
    saveCredentials(credentials: Credentials): Promise<Credentials>;
    setUserId(userId: string | null): Promise<void>;
}

declare class EmbeddedFreeTierStatus {
    isExhausted: boolean;
    renewsAt: Date;
    totalMinutesLimit: number;
    totalMinutesUsed: number;
    constructor({ isExhausted, renewsAt, totalMinutesLimit, totalMinutesUsed, }: {
        isExhausted: boolean;
        renewsAt: Date;
        totalMinutesLimit: number;
        totalMinutesUsed: number;
    });
    static fromJson(data: Record<string, unknown>): EmbeddedFreeTierStatus;
}

interface AccountProps {
    basePlanId: string | null;
    isDeactivated: boolean;
    isOnTrial: boolean;
    onTrialUntil: Date | null;
    trialStatus: string | null;
    embeddedFreeTierStatus: EmbeddedFreeTierStatus | null;
}
declare class Account {
    basePlanId: string | null;
    embeddedFreeTierStatus: EmbeddedFreeTierStatus | null;
    isDeactivated: boolean;
    isOnTrial: boolean;
    onTrialUntil: Date | null;
    trialStatus: string | null;
    constructor({ basePlanId, embeddedFreeTierStatus, isDeactivated, isOnTrial, onTrialUntil, trialStatus, }: AccountProps);
    static fromJson(data: Record<string, unknown>): Account;
}

interface OrganizationPermissionAction {
    isAllowed: boolean;
    isSupported: boolean;
}
interface FullOrganizationPermissions {
    images: {
        logoImageUrl: {
            set: OrganizationPermissionAction;
            reset: OrganizationPermissionAction;
        };
        roomBackgroundImageUrl: {
            set: OrganizationPermissionAction;
            reset: OrganizationPermissionAction;
        };
        roomKnockPageBackgroundImageUrl: {
            set: OrganizationPermissionAction;
            reset: OrganizationPermissionAction;
        };
    };
    invitations: {
        add: OrganizationPermissionAction;
        delete: OrganizationPermissionAction;
        list: OrganizationPermissionAction;
    };
    roles: {
        set: OrganizationPermissionAction;
        remove: OrganizationPermissionAction;
        removeSelf: OrganizationPermissionAction;
        list: OrganizationPermissionAction;
    };
    users: {
        signUpWithoutInvitation: OrganizationPermissionAction;
    };
    rooms: {
        customize: OrganizationPermissionAction;
        customizeSelf: OrganizationPermissionAction;
        list: OrganizationPermissionAction;
        lock: OrganizationPermissionAction;
        unclaim: OrganizationPermissionAction;
        unclaimSelf: OrganizationPermissionAction;
    };
    subscriptions: {
        add: OrganizationPermissionAction;
        list: OrganizationPermissionAction;
        payLatestInvoice: OrganizationPermissionAction;
        updatePlan: OrganizationPermissionAction;
    };
    browserExtension: {
        install: OrganizationPermissionAction;
    };
}
type OrganizationPermissions = Partial<FullOrganizationPermissions>;
interface OrganizationLimits {
    maxNumberOfInvitationsAndUsers: number | null;
    maxNumberOfClaimedRooms: number | null;
    maxRoomLimitPerOrganization: number | null;
    trialMinutesLimit: number | null;
    includedUnits: number | null;
}
interface OrganizationOnboardingSurvey {
    name: string;
    value: unknown;
}
type OrganizationPreferences = Record<string, boolean | string | null | number>;
declare function hasValue(value: unknown): boolean;
declare class Organization {
    static GLOBAL_ORGANIZATION_ID: string;
    organizationId: string;
    organizationName: string;
    subdomain: string;
    permissions: OrganizationPermissions;
    limits: OrganizationLimits;
    account: Account | null;
    logoImageUrl: string | null;
    roomBackgroundImageUrl: string | null;
    roomBackgroundThumbnailUrl: string | null;
    roomKnockPageBackgroundImageUrl: string | null;
    roomKnockPageBackgroundThumbnailUrl: string | null;
    preferences: OrganizationPreferences | null;
    onboardingSurvey: OrganizationOnboardingSurvey | null;
    type: string | null;
    constructor(properties: {
        account: Account | null;
        organizationId: string;
        organizationName: string;
        subdomain: string;
        permissions: OrganizationPermissions;
        limits: OrganizationLimits;
        logoImageUrl: string | null;
        roomBackgroundImageUrl: string | null;
        roomBackgroundThumbnailUrl: string | null;
        roomKnockPageBackgroundImageUrl: string | null;
        roomKnockPageBackgroundThumbnailUrl: string | null;
        preferences: OrganizationPreferences | null;
        onboardingSurvey: OrganizationOnboardingSurvey | null;
        type: string | null;
    });
    static fromJson(data: Json): Organization;
}

type FetchOrganizationFunction = () => Promise<Organization | undefined>;
declare class OrganizationApiClient {
    private _apiClient;
    private _fetchOrganization;
    constructor({ apiClient, fetchOrganization, }: {
        apiClient: ApiClient;
        fetchOrganization?: FetchOrganizationFunction;
    });
    _callRequestMethod(method: "request" | "requestMultipart", url: string, options: HttpClientRequestConfig): Promise<Response>;
    request(url: string, options: HttpClientRequestConfig): Promise<Response>;
    requestMultipart(url: string, options: HttpClientRequestConfig): Promise<Response>;
}

type UserConsentAction = "accepted" | "rejected" | null;
type ConsentGrantRequest = {
    readonly consentRevisionId: string;
    readonly action: UserConsentAction;
};

declare class OrganizationService {
    _apiClient: ApiClient;
    constructor({ apiClient }: {
        apiClient: ApiClient;
    });
    createOrganization({ organizationName, subdomain, owner, }: {
        organizationName: string;
        subdomain: string;
        owner: {
            email: string;
            displayName: string;
            verificationCode: string;
            consents?: ReadonlyArray<ConsentGrantRequest>;
        } | {
            idToken: string;
            displayName: string;
            consents?: ReadonlyArray<ConsentGrantRequest>;
        };
    }): Promise<string>;
    getOrganizationBySubdomain(subdomain: string): Promise<Organization | null>;
    getOrganizationByOrganizationId(organizationId: string): Promise<Organization | null>;
    getOrganizationsByContactPoint(options: {
        email: string;
        code: string;
    } | {
        phoneNumber: string;
        code: string;
    }): Promise<ReadonlyArray<Organization>>;
    getOrganizationsByIdToken({ idToken }: {
        idToken: string;
    }): Promise<ReadonlyArray<Organization>>;
    getOrganizationsByLoggedInUser(): Promise<ReadonlyArray<Organization>>;
    getSubdomainAvailability(subdomain: string): Promise<{
        status: string;
    }>;
    updatePreferences({ organizationId, preferences, }: {
        organizationId: string;
        preferences: OrganizationPreferences;
    }): Promise<undefined>;
    deleteOrganization({ organizationId }: {
        organizationId: string;
    }): Promise<undefined>;
}

declare class OrganizationServiceCache {
    private _organizationService;
    private _subdomain;
    private _organizationPromise;
    constructor({ organizationService, subdomain }: {
        organizationService: OrganizationService;
        subdomain: string;
    });
    initOrganization(): Promise<void>;
    fetchOrganization(): Promise<Organization | null>;
}

declare class Room {
    readonly isLocked: boolean;
    constructor(properties?: {});
}

declare class RoomService {
    constructor({ organizationApiClient }: {
        organizationApiClient: any;
    });
    getRooms({ types, fields }?: {
        fields?: never[] | undefined;
    }): any;
    getRoom({ roomName, fields }: {
        roomName: string;
        fields?: Array<string>;
    }): Promise<Room>;
    claimRoom({ roomName, type, mode, isLocked }: {
        roomName: any;
        type: any;
        mode: any;
        isLocked: any;
    }): any;
    unclaimRoom(roomName: any): any;
    renameRoom({ roomName, newRoomName }: {
        roomName: any;
        newRoomName: any;
    }): any;
    changeMode({ roomName, mode }: {
        roomName: any;
        mode: any;
    }): any;
    updatePreferences({ roomName, preferences }: {
        roomName: any;
        preferences: any;
    }): any;
    updateProtectedPreferences({ roomName, preferences }: {
        roomName: any;
        preferences: any;
    }): any;
    getRoomPermissions(roomName: any, { roomKey }?: {}): any;
    getRoomMetrics({ roomName, metrics, from, to }: {
        roomName: any;
        metrics: any;
        from: any;
        to: any;
    }): any;
    changeType({ roomName, type }: {
        roomName: any;
        type: any;
    }): any;
    getForestSocialImage({ roomName, count }: {
        roomName: any;
        count: any;
    }): any;
}

declare class LiveCaption {
    resultId: string;
    participantId: string;
    text: string;
    timestamp: number;
    constructor({ resultId, senderId, text }: LiveCaptionEvent);
}

declare function getUsableCameraEffectPresets(): Promise<string[]>;
declare function isAudioDenoiserSupported(): Promise<boolean>;

interface StickyReaction {
    reaction: string;
    timestamp: string;
}
interface RoomParticipantData {
    breakoutGroup: string | null;
    displayName: string;
    id: string;
    isAudioEnabled: boolean;
    isAudioRecorder: boolean;
    isDialIn: boolean;
    isVideoEnabled: boolean;
    stickyReaction?: StickyReaction | null;
    stream?: MediaStream;
}
declare class RoomParticipant {
    readonly displayName: string;
    readonly id: string;
    readonly stream?: MediaStream;
    readonly isAudioEnabled: boolean;
    readonly isLocalParticipant: boolean;
    readonly isVideoEnabled: boolean;
    readonly breakoutGroup: string | null;
    readonly stickyReaction?: StickyReaction | null;
    readonly isDialIn: boolean;
    readonly isAudioRecorder: boolean;
    constructor({ breakoutGroup, displayName, id, isAudioEnabled, isAudioRecorder, isDialIn, isVideoEnabled, stickyReaction, stream, }: RoomParticipantData);
}
interface RemoteParticipantData {
    newJoiner: boolean;
    streams: string[];
}
type StreamState = "new_accept" | "to_accept" | "done_accept" | "to_unaccept" | "done_unaccept";
interface Stream {
    id: string;
    state: StreamState;
}
interface RemoteParticipant {
    breakoutGroup: string | null;
    deviceId: string;
    displayName: string;
    externalId: string | null;
    id: string;
    isAudioEnabled: boolean;
    isAudioRecorder: boolean;
    isDialIn: boolean;
    isLocalParticipant: boolean;
    isVideoEnabled: boolean;
    newJoiner: boolean;
    presentationStream: (MediaStream & {
        inboundId?: string;
    }) | null;
    roleName: RoleName;
    stickyReaction?: StickyReaction | null;
    stream: (MediaStream & {
        inboundId?: string;
    }) | null;
    streams: Stream[];
}
declare class LocalParticipant extends RoomParticipant {
    readonly isLocalParticipant = true;
    constructor({ breakoutGroup, displayName, id, isAudioEnabled, isAudioRecorder, isDialIn, isVideoEnabled, stickyReaction, stream, }: RoomParticipantData);
}
interface WaitingParticipant {
    id: string;
    displayName: string | null;
}
interface Screenshare {
    participantId: string;
    id: string;
    hasAudioTrack: boolean;
    breakoutGroup: string | null;
    stream?: MediaStream;
    isLocal: boolean;
}

declare function createServices(): {
    credentialsService: CredentialsService;
    apiClient: ApiClient;
    organizationService: OrganizationService;
    fetchOrganizationFromRoomUrl: (roomUrl: string) => Promise<Organization | null>;
};

declare function getAudioTrack(): MediaStreamTrack;
declare function getVideoTrack({ canvas }: {
    canvas: HTMLCanvasElement;
}): MediaStreamTrack;
declare function getFakeMediaStream({ canvas, hasAudio }: {
    canvas: HTMLCanvasElement;
    hasAudio?: boolean;
}): MediaStream;

interface Options {
    delay?: number;
    edges?: boolean;
}
interface DebouncedFunction {
    (...args: any[]): void;
}
declare function debounce(fn: DebouncedFunction, { delay, edges }?: Options): DebouncedFunction;

declare function parseUnverifiedRoomKeyData(roomKey: string): any;

interface WaitingParticipantsState {
    waitingParticipants: WaitingParticipant[];
}

interface StreamingState {
    isStreaming: boolean;
    error: unknown;
    startedAt?: number;
}

interface rtcAnalyticsState {
    reportedValues: {
        [key: string]: unknown;
    };
}

type ChatMessage$1 = Pick<ChatMessage$2, "id" | "senderId" | "parentId" | "timestamp" | "text" | "sig"> & {
    removed: boolean;
    file?: ChatFileShare;
};
interface ChatState {
    chatMessages: ChatMessage$1[];
}

interface NotificationEvent<Type = string, PropsType = unknown> {
    type: Type;
    message: string;
    props: PropsType;
    timestamp: number;
}
interface RequestAudioEventProps {
    client: RemoteParticipant;
    enable: boolean;
}
type RequestAudioEvent = NotificationEvent<"requestAudioEnable" | "requestAudioDisable", RequestAudioEventProps>;
interface RequestVideoEventProps {
    client: RemoteParticipant;
    enable: boolean;
}
type RequestVideoEvent = NotificationEvent<"requestVideoEnable" | "requestVideoDisable", RequestVideoEventProps>;
interface ChatMessageEventProps {
    client: RemoteParticipant;
    chatMessage: ChatMessage$1;
}
type ChatMessageEvent = NotificationEvent<"chatMessageReceived", ChatMessageEventProps>;
interface SignalStatusEventProps {
}
type SignalStatusEvent = NotificationEvent<"signalTrouble" | "signalOk", SignalStatusEventProps>;
interface SignalClientEventProps {
}
type SignalClientEvent = NotificationEvent<"clientUnableToJoinFullRoom", SignalClientEventProps>;
interface StickyReactionEventProps {
    client: RemoteParticipant;
    stickyReaction?: {
        reaction: string;
        timestamp: string;
    } | null;
}
type StickyReactionEvent = NotificationEvent<"remoteHandRaised" | "remoteHandLowered", StickyReactionEventProps>;
interface BreakoutTimerEventProps {
}
type BreakoutTimerEvent = NotificationEvent<"breakoutTimerEnding" | "breakoutTimerEnded" | "breakoutTimerExtended", BreakoutTimerEventProps>;
interface BreakoutGroupAssignedEventProps {
    group: string;
    groupName: string;
}
type BreakoutGroupAssignedEvent = NotificationEvent<"breakoutGroupAssigned", BreakoutGroupAssignedEventProps>;
type NotificationEventTypes = {
    ["requestAudioEnable"]: RequestAudioEvent;
    ["requestAudioDisable"]: RequestAudioEvent;
    ["chatMessageReceived"]: ChatMessageEvent;
    ["remoteHandRaised"]: StickyReactionEvent;
    ["remoteHandLowered"]: StickyReactionEvent;
    ["signalTrouble"]: SignalStatusEvent;
    ["signalOk"]: SignalStatusEvent;
    ["clientUnableToJoinFullRoom"]: SignalClientEvent;
    ["requestVideoEnable"]: RequestVideoEvent;
    ["requestVideoDisable"]: RequestVideoEvent;
    ["breakoutTimerEnding"]: BreakoutTimerEvent;
    ["breakoutTimerEnded"]: BreakoutTimerEvent;
    ["breakoutTimerExtended"]: BreakoutTimerEvent;
    ["breakoutGroupAssigned"]: BreakoutGroupAssignedEvent;
};
type NotificationEvents = NotificationEventTypes[keyof NotificationEventTypes];
type NotificationEventMap = {
    "*": [NotificationEvents];
} & {
    [Type in keyof NotificationEventTypes]: [NotificationEventTypes[Type]];
};

type NotificationsEventEmitter = EventEmitter<NotificationEventMap>;
interface NotificationsState {
    emitter: NotificationsEventEmitter;
    events: Array<NotificationEvent>;
}

interface LocalScreenshareState {
    status: "inactive" | "starting" | "active";
    stream: MediaStream | null;
    error: unknown | null;
}

interface LocalParticipantState$1 extends LocalParticipant {
    isScreenSharing: boolean;
    roleName: RoleName;
    clientClaim?: string;
    breakoutGroupAssigned: string;
}

interface LiveTranscriptionState$1 {
    isInitiator: boolean;
    isTranscribing: boolean;
    error?: string;
    status?: "transcribing" | "requested" | "error";
    startedAt?: number;
}

interface LiveCaptionsState$1 {
    isCaptioning: boolean;
    error?: string;
    status?: "captioning" | "requested" | "error";
    startedAt?: number;
    captionLog: Array<LiveCaption>;
}

type FileShareError = FileShareErrorCode | "upload_failed" | "too_many_files" | "unsupported_file_type" | "file_too_large";
declare const MAX_FILES_PER_UPLOAD = 10;
declare const MAX_FILE_SIZE: number;
declare const ACCEPTED_FILE_TYPES: Record<string, string[]>;
interface FileUpload {
    id: string;
    name: string;
    size: number;
    type: string;
    status: "uploading" | "sent" | "error";
    error?: FileShareError;
}
interface FileShareState {
    uploads: FileUpload[];
    requestInFlight: boolean;
}
interface SendFilesOptions {
    parentId?: string;
    isBroadcast?: boolean;
}

interface CloudRecordingState$1 {
    isInitiator: boolean;
    isRecording: boolean;
    error?: string;
    status?: "recording" | "requested" | "error";
    startedAt?: number;
}

type TryUpdateFn = (presetId: string, setup: Setup, params: Params) => Promise<boolean>;
type StopFn$1 = () => void;
interface CameraEffectsState {
    currentEffectId?: string | null;
    setup?: Setup;
    params?: Params;
    backgroundUrl?: string;
    allowSafari?: boolean;
    isPaused: boolean;
    isSwitching: boolean;
    error?: unknown;
    raw: {
        stop?: StopFn$1;
        tryUpdate?: TryUpdateFn;
        effectStream?: MediaStream;
    };
}

type StopFn = () => void;
interface AudioDenoiserState {
    wanted: boolean;
    isSwitching: boolean;
    error?: unknown;
    raw: {
        stop?: StopFn;
        outputStream?: MediaStream;
        audioContext?: AudioContext;
        denoiserNode?: AudioWorkletNode;
    };
}

interface AuthorizationState {
    roomKey: string | null;
    assistantKey?: string | null;
    roleName: RoleName;
}

declare const DEFAULT_BREAKOUT_TIMER_DURATION = 1800;
interface BreakoutState$1 extends BreakoutConfig {
    error: string | null;
}
declare const BREAKOUT_UNAVAILABLE_ERROR = "Breakout groups are not available in peer-to-peer rooms";
interface BreakoutSessionSettings {
    enforceAssignment?: boolean;
    autoMoveToGroup?: boolean;
    autoMoveToMain?: boolean;
    moveToGroupGracePeriod?: number | null;
    moveToMainGracePeriod?: number | null;
    breakoutTimerSetting?: boolean;
    breakoutTimerDuration?: number;
}
interface StartBreakoutSessionOptions extends BreakoutSessionSettings {
    groups: {
        [groupId: string]: string;
    };
    assignments?: {
        [clientId: string]: string;
    };
}
interface UpdateBreakoutSessionOptions extends BreakoutSessionSettings {
    groups?: {
        [groupId: string]: string;
    };
    assignments?: {
        [clientId: string]: string;
    };
}
declare const BREAKOUT_GROUPS_MIN_MAX: [number, number];
declare function defaultBreakoutGroupName(groupId: string): string;
declare function createBreakoutGroups(count?: number): {
    [groupId: string]: string;
};

interface ConnectionMonitorState {
    running: boolean;
    stopCallbackFunction?: () => void;
}

interface DeviceCredentialsState {
    isFetching: boolean;
    data?: Credentials | null;
}

interface OrganizationState {
    data: Organization | null | undefined;
    isFetching: boolean;
    error: unknown;
}

interface RemoteParticipantSliceState {
    remoteParticipants: RemoteParticipant[];
}

type ClientView = {
    id: string;
    clientId: string;
    displayName: string;
    hasActivePresentation?: boolean;
    stream?: (MediaStream & {
        outboundId?: string;
        inboundId?: string;
    }) | null;
    isLocalClient?: boolean;
    isPresentation?: boolean;
    isVideoEnabled?: boolean;
    isAudioEnabled?: boolean;
    breakoutGroup?: string | null;
    breakoutGroupAssigned?: string;
};

interface RoomState {
    isLocked: boolean;
    mode: RoomMode | null;
}

type LocalMediaOptions$1 = {
    audio: boolean;
    video: boolean;
};
interface LocalMediaState$1 {
    beforeEffectTracks?: {
        audio?: MediaStreamTrack;
        video?: MediaStreamTrack;
    };
    busyDeviceIds: string[];
    cameraDeviceError?: unknown;
    cameraEnabled: boolean;
    currentCameraDeviceId?: string;
    currentMicrophoneDeviceId?: string;
    currentSpeakerDeviceId?: string;
    devices: MediaDeviceInfo[];
    hdMode: boolean;
    isSettingCameraDevice: boolean;
    isSettingMicrophoneDevice: boolean;
    isSettingSpeakerDevice: boolean;
    isSwitchingStream: boolean;
    isTogglingCamera: boolean;
    lowDataMode: boolean;
    microphoneDeviceError?: unknown;
    microphoneEnabled: boolean;
    onDeviceChange?: () => void;
    options?: LocalMediaOptions$1;
    speakerDeviceError?: unknown;
    status: "inactive" | "stopped" | "starting" | "started" | "error";
    startError?: unknown;
    stream?: MediaStream;
    widescreenMode: boolean;
}

interface AppConfig {
    assistantKey?: string | null;
    displayName: string;
    externalId: string | null;
    ignoreBreakoutGroups?: boolean;
    isAudioRecorder?: boolean;
    isDialIn?: boolean;
    isNodeSdk?: boolean;
    localMediaOptions?: LocalMediaOptions$1;
    roomKey: string | null;
    roomUrl: string;
    userAgent?: string;
}
interface AppState {
    displayName: string | null;
    externalId: string | null;
    ignoreBreakoutGroups: boolean;
    initialConfig?: AppConfig;
    isActive: boolean;
    isAssistant: boolean;
    isAudioRecorder: boolean;
    isDialIn: boolean;
    isNodeSdk: boolean;
    roomName: string | null;
    roomUrl: string | null;
    userAgent: string | null;
}

type ConnectionStatus = "ready" | "connecting" | "connected" | "room_locked" | "knocking" | "knock_on_hold" | "knock_rejected" | "kicked" | "leaving" | "left" | "disconnected" | "reconnecting";
interface RoomConnectionState$1 {
    session: {
        createdAt: string;
        id: string;
    } | null;
    status: ConnectionStatus;
    error: string | null;
    knockResponse: KnockResponse | null;
}

interface StreamResolutionUpdate {
    streamId: string;
    width: number;
    height: number;
}
interface RtcConnectionState {
    dispatcherCreated: boolean;
    error: unknown;
    isCreatingDispatcher: boolean;
    reportedStreamResolutions: {
        [streamId: string]: Omit<StreamResolutionUpdate, "streamId">;
    };
    rtcManager: RtcManager | null;
    rtcManagerDispatcher: RtcManagerDispatcher | null;
    rtcManagerInitialized: boolean;
    status: "inactive" | "ready" | "reconnecting";
    isAcceptingStreams: boolean;
}

interface SignalConnectionState {
    deviceIdentified: boolean;
    isIdentifyingDevice: boolean;
    status: "ready" | "connecting" | "connected" | "disconnected" | "reconnecting";
    socket: ServerSocket | null;
}

interface SpotlightsState {
    sorted: {
        clientId: string;
        streamId: string;
    }[];
}

declare const appReducer: redux.Reducer<{
    app: AppState;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState$1;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState$1;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState$1;
    liveTranscription: LiveTranscriptionState$1;
    localMedia: LocalMediaState$1;
    localParticipant: LocalParticipantState$1;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    room: RoomState;
    roomConnection: RoomConnectionState$1;
    rtcAnalytics: rtcAnalyticsState;
    rtcConnection: RtcConnectionState;
    signalConnection: SignalConnectionState;
    spotlights: SpotlightsState;
    streaming: StreamingState;
    waitingParticipants: WaitingParticipantsState;
}, redux.UnknownAction, Partial<{
    app: AppState | undefined;
    audioDenoiser: AudioDenoiserState | undefined;
    authorization: AuthorizationState | undefined;
    breakout: BreakoutState$1 | undefined;
    cameraEffects: CameraEffectsState | undefined;
    chat: ChatState | undefined;
    cloudRecording: CloudRecordingState$1 | undefined;
    connectionMonitor: ConnectionMonitorState | undefined;
    deviceCredentials: DeviceCredentialsState | undefined;
    fileShare: FileShareState | undefined;
    liveCaptions: LiveCaptionsState$1 | undefined;
    liveTranscription: LiveTranscriptionState$1 | undefined;
    localMedia: LocalMediaState$1 | undefined;
    localParticipant: LocalParticipantState$1 | undefined;
    localScreenshare: LocalScreenshareState | undefined;
    notifications: NotificationsState | undefined;
    organization: OrganizationState | undefined;
    remoteParticipants: RemoteParticipantSliceState | undefined;
    room: RoomState | undefined;
    roomConnection: RoomConnectionState$1 | undefined;
    rtcAnalytics: rtcAnalyticsState | undefined;
    rtcConnection: RtcConnectionState | undefined;
    signalConnection: SignalConnectionState | undefined;
    spotlights: SpotlightsState | undefined;
    streaming: StreamingState | undefined;
    waitingParticipants: WaitingParticipantsState | undefined;
}>>;
declare const createStore: ({ preloadedState, injectServices, }: {
    preloadedState?: Partial<RootState>;
    injectServices: ReturnType<typeof createServices>;
}) => _reduxjs_toolkit.EnhancedStore<{
    app: AppState;
    audioDenoiser: AudioDenoiserState;
    authorization: AuthorizationState;
    breakout: BreakoutState$1;
    cameraEffects: CameraEffectsState;
    chat: ChatState;
    cloudRecording: CloudRecordingState$1;
    connectionMonitor: ConnectionMonitorState;
    deviceCredentials: DeviceCredentialsState;
    fileShare: FileShareState;
    liveCaptions: LiveCaptionsState$1;
    liveTranscription: LiveTranscriptionState$1;
    localMedia: LocalMediaState$1;
    localParticipant: LocalParticipantState$1;
    localScreenshare: LocalScreenshareState;
    notifications: NotificationsState;
    organization: OrganizationState;
    remoteParticipants: RemoteParticipantSliceState;
    room: RoomState;
    roomConnection: RoomConnectionState$1;
    rtcAnalytics: rtcAnalyticsState;
    rtcConnection: RtcConnectionState;
    signalConnection: SignalConnectionState;
    spotlights: SpotlightsState;
    streaming: StreamingState;
    waitingParticipants: WaitingParticipantsState;
}, redux.UnknownAction, _reduxjs_toolkit.Tuple<[redux.StoreEnhancer<{
    dispatch: ((action: redux.Action<"listenerMiddleware/add">) => _reduxjs_toolkit.UnsubscribeListener) & redux_thunk.ThunkDispatch<{
        app: AppState;
        audioDenoiser: AudioDenoiserState;
        authorization: AuthorizationState;
        breakout: BreakoutState$1;
        cameraEffects: CameraEffectsState;
        chat: ChatState;
        cloudRecording: CloudRecordingState$1;
        connectionMonitor: ConnectionMonitorState;
        deviceCredentials: DeviceCredentialsState;
        fileShare: FileShareState;
        liveCaptions: LiveCaptionsState$1;
        liveTranscription: LiveTranscriptionState$1;
        localMedia: LocalMediaState$1;
        localParticipant: LocalParticipantState$1;
        localScreenshare: LocalScreenshareState;
        notifications: NotificationsState;
        organization: OrganizationState;
        remoteParticipants: RemoteParticipantSliceState;
        room: RoomState;
        roomConnection: RoomConnectionState$1;
        rtcAnalytics: rtcAnalyticsState;
        rtcConnection: RtcConnectionState;
        signalConnection: SignalConnectionState;
        spotlights: SpotlightsState;
        streaming: StreamingState;
        waitingParticipants: WaitingParticipantsState;
    }, {
        services: {
            credentialsService: CredentialsService;
            apiClient: ApiClient;
            organizationService: OrganizationService;
            fetchOrganizationFromRoomUrl: (roomUrl: string) => Promise<Organization | null>;
        };
    }, redux.UnknownAction>;
}>, redux.StoreEnhancer]>>;
type RootState = ReturnType<typeof appReducer>;
type Store = ReturnType<typeof createStore>;

declare const CLIENT_VIEW_CHANGED = "grid:client-view-changed";
declare const CLIENT_VIEW_SPOTLIGHTS_CHANGED = "grid:client-view-spotlights-changed";
declare const NUMBER_OF_CLIENT_VIEWS_CHANGED = "grid:number-of-client-views-changed";
type GridEvents = {
    [CLIENT_VIEW_CHANGED]: [clientViews: ClientView[]];
    [CLIENT_VIEW_SPOTLIGHTS_CHANGED]: [clientViews: ClientView[]];
    [NUMBER_OF_CLIENT_VIEWS_CHANGED]: [numClients: number];
};

interface GridState {
    allClientViews: ClientView[];
    spotlightedParticipants: ClientView[];
    numParticipants: number;
}

declare abstract class BaseClient<TState, TEvents extends Record<string, unknown[]>> extends EventEmitter<TEvents> {
    protected store: Store;
    protected previousState: TState;
    private stateSubscribers;
    constructor(store: Store);
    abstract getState(): TState;
    subscribe(callback: (state: TState) => void): () => void;
    protected abstract handleStateChanges(state: TState, previousState: TState): void;
    private setupEventBridge;
    destroy(): void;
}

declare class GridClient extends BaseClient<GridState, GridEvents> {
    private clientViewSubscribers;
    private spotlightedSubscribers;
    private numberOfClientViewsSubscribers;
    constructor(store: Store);
    protected handleStateChanges(state: GridState, previousState: GridState): void;
    getState(): GridState;
    subscribeClientViews(callback: (clientViews: ClientView[]) => void): () => void;
    subscribeSpotlightedParticipants(callback: (spotlighted: ClientView[]) => void): () => void;
    subscribeNumberOfClientViews(callback: (num: number) => void): () => void;
    spotlightParticipant(id: string): void;
    removeSpotlight(id: string): void;
    destroy(): void;
}

declare const CAMERA_DEVICE_ERROR_CHANGED = "local-media:camera-device-error-changed";
declare const CAMERA_DEVICES_CHANGED = "local-media:camera-devices-changed";
declare const IS_SETTING_CAMERA_DEVICE = "local-media:is-setting-camera-device";
declare const IS_SETTING_MICROPHONE_DEVICE = "local-media:is-setting-microphone-device";
declare const MICROPHONE_DEVICE_ERROR_CHANGED = "local-media:microphone-device-error-changed";
declare const MICROPHONE_DEVICES_CHANGED = "local-media:microphone-devices-changed";
declare const SPEAKER_DEVICES_CHANGED = "local-media:speaker-devices-changed";
declare const CURRENT_CAMERA_CHANGED = "local-media:current-camera-changed";
declare const CURRENT_MICROPHONE_CHANGED = "local-media:current-microphone-changed";
declare const CURRENT_SPEAKER_CHANGED = "local-media:current-speaker-changed";
declare const LOCAL_MEDIA_STARTING = "local-media:starting";
declare const LOCAL_STREAM_CHANGED = "local-media:local-stream-changed";
declare const LOCAL_MEDIA_START_ERROR_CHANGED = "local-media:start-error-changed";
type LocalMediaEvents = {
    [CAMERA_DEVICE_ERROR_CHANGED]: [error: unknown | null];
    [CAMERA_DEVICES_CHANGED]: [devices: MediaDeviceInfo[]];
    [IS_SETTING_CAMERA_DEVICE]: [isSetting: boolean];
    [IS_SETTING_MICROPHONE_DEVICE]: [isSetting: boolean];
    [MICROPHONE_DEVICE_ERROR_CHANGED]: [error: unknown | null];
    [MICROPHONE_DEVICES_CHANGED]: [devices: MediaDeviceInfo[]];
    [SPEAKER_DEVICES_CHANGED]: [devices: MediaDeviceInfo[]];
    [CURRENT_CAMERA_CHANGED]: [deviceId?: string];
    [CURRENT_MICROPHONE_CHANGED]: [deviceId?: string];
    [CURRENT_SPEAKER_CHANGED]: [speakerId?: string];
    [LOCAL_MEDIA_STARTING]: [starting: boolean];
    [LOCAL_STREAM_CHANGED]: [stream?: MediaStream];
    [LOCAL_MEDIA_START_ERROR_CHANGED]: [error: unknown | null];
};

interface LocalMediaState {
    currentCameraDeviceId?: string;
    currentMicrophoneDeviceId?: string;
    currentSpeakerDeviceId?: string;
    cameraDeviceError: unknown;
    cameraDevices: MediaDeviceInfo[];
    isSettingCameraDevice: boolean;
    isSettingMicrophoneDevice: boolean;
    isStarting: boolean;
    localStream?: MediaStream;
    microphoneDeviceError: unknown;
    microphoneDevices: MediaDeviceInfo[];
    speakerDevices: MediaDeviceInfo[];
    startError: unknown;
}

declare class LocalMediaClient extends BaseClient<LocalMediaState, LocalMediaEvents> {
    private cameraDeviceErrorSubscribers;
    private cameraDeviceSubscribers;
    private isSettingCameraDeviceSubscribers;
    private isSettingMicrophoneDeviceSubscribers;
    private microphoneDeviceErrorSubscribers;
    private microphoneDeviceSubscribers;
    private speakerDeviceSubscribers;
    private currentCameraSubscribers;
    private currentMicrophoneSubscribers;
    private currentSpeakerSubscribers;
    private localMediaStartingSubscribers;
    private localStreamSubscribers;
    private localMediaStartErrorSubscribers;
    constructor(store: Store);
    protected handleStateChanges(state: LocalMediaState, previousState: LocalMediaState): void;
    getState(): LocalMediaState;
    subscribeCameraDeviceError(callback: (error: unknown | null) => void): () => void;
    subscribeCameraDevices(callback: (cameraDevices: MediaDeviceInfo[]) => void): () => void;
    subscribeIsSettingCameraDevice(callback: (isSetting: boolean) => void): () => void;
    subscribeIsSettingMicrophoneDevice(callback: (isSetting: boolean) => void): () => void;
    subscribeMicrophoneDeviceError(callback: (error: unknown | null) => void): () => void;
    subscribeMicrophoneDevices(callback: (microphoneDevices: MediaDeviceInfo[]) => void): () => void;
    subscribeSpeakerDevices(callback: (speakerDevices: MediaDeviceInfo[]) => void): () => void;
    subscribeCurrentCamera(callback: (cameraId?: string) => void): () => void;
    subscribeCurrentMicrophone(callback: (microphoneId?: string) => void): () => void;
    subscribeCurrentSpeaker(callback: (speakerId?: string) => void): () => void;
    subscribeLocalMediaStarting(callback: (starting: boolean) => void): () => void;
    subscribeLocalStream(callback: (stream?: MediaStream) => void): () => void;
    subscribeLocalMediaStartError(callback: (error: unknown | null) => void): () => void;
    startMedia(options?: LocalMediaOptions$1 | MediaStream): Promise<_reduxjs_toolkit.PayloadAction<{
        stream: MediaStream;
        onDeviceChange: DebouncedFunction;
    } | {
        stream: undefined;
        onDeviceChange: DebouncedFunction;
    }, string, {
        arg: LocalMediaOptions$1 | MediaStream;
        requestId: string;
        requestStatus: "fulfilled";
    }, never> | _reduxjs_toolkit.PayloadAction<unknown, string, {
        arg: LocalMediaOptions$1 | MediaStream;
        requestId: string;
        requestStatus: "rejected";
        aborted: boolean;
        condition: boolean;
    } & ({
        rejectedWithValue: true;
    } | ({
        rejectedWithValue: false;
    } & {})), _reduxjs_toolkit.SerializedError>>;
    toggleCamera(enabled?: boolean): void;
    toggleMicrophone(enabled?: boolean): void;
    toggleHdMode(enabled?: boolean): void;
    toggleLowDataMode(enabled?: boolean): void;
    toggleWidescreenMode(enabled?: boolean): void;
    setCameraDevice(deviceId: string): void;
    setMicrophoneDevice(deviceId: string): void;
    setSpeakerDevice(deviceId: string): void;
    stopMedia(): void;
    destroy(): void;
}

type LocalMediaOptions = {
    audio: boolean;
    video: boolean;
};
interface WherebyClientOptions {
    localMediaOptions?: LocalMediaOptions;
    displayName?: string;
    roomUrl?: string;
    assistantKey?: string | null;
    roomKey?: string | null;
    externalId?: string | null;
    isNodeSdk?: boolean;
}
type RemoteParticipantState = Omit<RemoteParticipant, "newJoiner" | "streams"> & {
    breakoutGroupAssigned: string;
};
interface LocalParticipantState extends LocalParticipant {
    isScreenSharing: boolean;
    roleName: RoleName;
    clientClaim?: string;
    breakoutGroupAssigned: string;
}
interface WaitingParticipantState {
    id: string;
    displayName: string | null;
}
interface ChatMessageState {
    senderId: string;
    timestamp: string;
    text: string;
    file?: ChatFileShare;
}
type ScreenshareState = Screenshare;
type LocalScreenshareStatus = "starting" | "active";
type ChatMessage = Pick<ChatMessage$2, "id" | "senderId" | "parentId" | "timestamp" | "text" | "sig"> & {
    removed: boolean;
    file?: ChatFileShare;
};
type CloudRecordingState = {
    error?: string;
    status: "recording" | "requested" | "error";
    startedAt?: number;
};
type LiveCaptionsState = {
    error?: string;
    status: "captioning" | "requested" | "error";
    startedAt?: number;
    captionLog: Array<LiveCaption>;
};
type LiveTranscriptionState = {
    error?: string;
    status: "transcribing" | "requested" | "error";
    startedAt?: number;
};
type LiveStreamState = {
    status: "streaming";
    startedAt?: number;
};
type BreakoutState = {
    isAvailable: boolean;
    error: string | null;
    isActive: boolean;
    currentGroup: {
        id: string | null;
        name: string;
    } | null;
    groups: {
        [groupId: string]: string;
    } | null;
    enforceAssignment: boolean;
    autoMoveToGroup: boolean;
    moveToGroupGracePeriod: number | null;
    autoMoveToMain: boolean;
    moveToMainGracePeriod: number | null;
    breakoutTimerSetting: boolean;
    breakoutTimerDuration: number;
    startedAt: Date | null;
    endTime: number | null;
    moveToGroupAt: number | null;
    moveToMainAt: number | null;
    groupedParticipants: {
        clients: ClientView[];
        group: {
            id: string;
            name: string;
        } | null;
    }[];
    participantsInCurrentGroup: ClientView[];
    broadcastingParticipants: ClientView[];
};
interface RoomConnectionState {
    connectionStatus: ConnectionStatus;
    connectionError: string | null;
    knockResponse: KnockResponse | null;
    chatMessages: ChatMessage[];
    fileUploads: FileUpload[];
    cloudRecording?: CloudRecordingState;
    breakout: BreakoutState;
    events?: NotificationsEventEmitter;
    isCameraEnabled: boolean;
    isMicrophoneEnabled: boolean;
    liveStream?: LiveStreamState;
    liveCaptions?: LiveCaptionsState;
    liveTranscription?: LiveTranscriptionState;
    localScreenshareStatus?: LocalScreenshareStatus;
    localParticipant?: LocalParticipantState;
    remoteParticipants: RemoteParticipantState[];
    screenshares: Screenshare[];
    waitingParticipants: WaitingParticipantState[];
    spotlightedParticipants: ClientView[];
}

declare const BREAKOUT_CONFIG_CHANGED = "breakout:config-changed";
declare const CHAT_NEW_MESSAGE = "chat:new-message";
declare const CLOUD_RECORDING_STATUS_CHANGED = "cloud-recording:status-changed";
declare const CONNECTION_STATUS_CHANGED = "connection:status-changed";
declare const LIVE_CAPTIONS_STATUS_CHANGED = "live-captions:status-changed";
declare const LIVE_TRANSCRIPTION_STATUS_CHANGED = "live-transcription:status-changed";
declare const CONNECTION_ERROR_CHANGED = "connection:error-changed";
declare const LOCAL_PARTICIPANT_CHANGED = "local-participant:changed";
declare const LOCAL_SCREENSHARE_STATUS_CHANGED = "local-screenshare:status-changed";
declare const REMOTE_PARTICIPANTS_CHANGED = "remote-participants:changed";
declare const SCREENSHARE_STARTED = "screenshare:started";
declare const SCREENSHARE_STOPPED = "screenshare:stopped";
declare const CAMERA_STATE_CHANGED = "camera:state-changed";
declare const MICROPHONE_STATE_CHANGED = "microphone:state-changed";
declare const STREAMING_STARTED = "streaming:started";
declare const STREAMING_STOPPED = "streaming:stopped";
declare const WAITING_PARTICIPANT_JOINED = "waiting-participant:joined";
declare const WAITING_PARTICIPANT_LEFT = "waiting-participant:left";
declare const SPOTLIGHT_PARTICIPANT_ADDED = "spotlight:participant-added";
declare const SPOTLIGHT_PARTICIPANT_REMOVED = "spotlight:participant-removed";
declare const ROOM_JOINED = "room:joined";
declare const ROOM_JOINED_ERROR = "room:joined:error";
type RoomJoinedEvent = {
    isLocked: boolean;
    selfId: string;
};
type RoomConnectionEvents = {
    [BREAKOUT_CONFIG_CHANGED]: [config: BreakoutState];
    [CAMERA_STATE_CHANGED]: [isCameraEnabled: boolean];
    [CHAT_NEW_MESSAGE]: [message: ChatMessage$1];
    [CLOUD_RECORDING_STATUS_CHANGED]: [status: CloudRecordingState | undefined];
    [CONNECTION_STATUS_CHANGED]: [status: ConnectionStatus];
    [LIVE_CAPTIONS_STATUS_CHANGED]: [status: LiveCaptionsState | undefined];
    [LIVE_TRANSCRIPTION_STATUS_CHANGED]: [status: LiveTranscriptionState | undefined];
    [CONNECTION_ERROR_CHANGED]: [error: string | null];
    [LOCAL_PARTICIPANT_CHANGED]: [participant?: LocalParticipantState];
    [LOCAL_SCREENSHARE_STATUS_CHANGED]: [status?: LocalScreenshareStatus];
    [MICROPHONE_STATE_CHANGED]: [isMicrophoneEnabled: boolean];
    [REMOTE_PARTICIPANTS_CHANGED]: [participants: RemoteParticipantState[]];
    [SCREENSHARE_STARTED]: [screenshare: Screenshare];
    [SCREENSHARE_STOPPED]: [screenshareId: string];
    [ROOM_JOINED]: [room: RoomJoinedEvent];
    [ROOM_JOINED_ERROR]: [error: RoomJoinedErrors | string];
    [WAITING_PARTICIPANT_JOINED]: [participant: WaitingParticipant];
    [WAITING_PARTICIPANT_LEFT]: [participantId: string];
    [SPOTLIGHT_PARTICIPANT_ADDED]: [participant: ClientView];
    [SPOTLIGHT_PARTICIPANT_REMOVED]: [participantId: string];
    [STREAMING_STARTED]: [streaming: LiveStreamState];
    [STREAMING_STOPPED]: [];
};

declare class RoomConnectionClient extends BaseClient<RoomConnectionState, RoomConnectionEvents> {
    protected options: Partial<AppConfig>;
    private selfId;
    private breakoutSubscribers;
    private cameraStateSubscribers;
    private chatMessageSubscribers;
    private fileUploadsSubscribers;
    private cloudRecordingSubscribers;
    private connectionErrorSubscribers;
    private connectionStatusSubscribers;
    private liveStreamSubscribers;
    private liveCaptionsSubscribers;
    private liveTranscriptionSubscribers;
    private localParticipantSubscribers;
    private localScreenshareStatusSubscribers;
    private microphoneStateSubscribers;
    private remoteParticipantsSubscribers;
    private screenshareSubscribers;
    private spotlightedParticipantsSubscribers;
    private waitingParticipantsSubscribers;
    constructor(store: Store);
    protected handleStateChanges(state: RoomConnectionState, previousState: RoomConnectionState): void;
    private registerAppListeners;
    subscribeToChatMessages(callback: (messages: ChatMessage[]) => void): () => void;
    subscribeToFileUploads(callback: (uploads: FileUpload[]) => void): () => void;
    subscribeToCloudRecording(callback: (status: CloudRecordingState | undefined) => void): () => void;
    subscribeToLiveCaptions(callback: (status: LiveCaptionsState | undefined) => void): () => void;
    subscribeToLiveTranscription(callback: (status: LiveTranscriptionState | undefined) => void): () => void;
    subscribeToBreakoutConfig(callback: (config: BreakoutState) => void): () => void;
    subscribeToConnectionStatus(callback: (status: ConnectionStatus) => void): () => void;
    subscribeToConnectionError(callback: (error: string | null) => void): () => void;
    subscribeToLiveStream(callback: (status: {
        status: "streaming";
    } | undefined) => void): () => void;
    subscribeToLocalScreenshareStatus(callback: (status?: LocalScreenshareStatus) => void): () => void;
    subscribeToLocalParticipant(callback: (participant?: LocalParticipantState) => void): () => void;
    subscribeToRemoteParticipants(callback: (participants: RemoteParticipantState[]) => void): () => void;
    subscribeToScreenshares(callback: (screenshares: ScreenshareState[]) => void): () => void;
    subscribeToWaitingParticipants(callback: (participants: WaitingParticipantState[]) => void): () => void;
    subscribeToSpotlightedParticipants(callback: (participants: ClientView[]) => void): () => void;
    subscribeToMicrophoneState(callback: (isMicrophoneEnabled: boolean) => void): () => void;
    subscribeToCameraState(callback: (isCameraEnabled: boolean) => void): () => void;
    getState(): RoomConnectionState;
    getNotificationsEventEmitter(): NotificationsEventEmitter;
    initialize(options: WherebyClientOptions): void;
    joinRoom(): Promise<RoomJoinedSuccess>;
    sendChatMessage(text: string, parentId?: string, isBroadcast?: boolean): void;
    removeChatMessage(id: string, sig?: string | null): void;
    sendFiles(files: File[], options?: SendFilesOptions): void;
    downloadFile(file: ChatFileShare): Promise<Blob>;
    knock(): void;
    cancelKnock(): void;
    leaveRoom(): void;
    setDisplayName(displayName: string): void;
    toggleCamera(enabled?: boolean): void;
    toggleMicrophone(enabled?: boolean): void;
    toggleHdMode(enabled?: boolean): void;
    toggleLowDataMode(enabled?: boolean): void;
    toggleWidescreenMode(enabled?: boolean): void;
    toggleRaiseHand(enabled?: boolean): void;
    askToSpeak(participantId: string): void;
    askToTurnOnCamera(participantId: string): void;
    acceptWaitingParticipant(participantId: string): void;
    holdWaitingParticipant(participantId: string, response?: string): void;
    rejectWaitingParticipant(participantId: string, response?: string): void;
    startCloudRecording(): void;
    stopCloudRecording(): void;
    startLiveTranscription(): void;
    stopLiveTranscription(): void;
    startLiveCaptions(): void;
    stopLiveCaptions(): void;
    startScreenshare(): void;
    stopScreenshare(): void;
    lockRoom(locked: boolean): void;
    muteParticipants(participantIds: string[]): void;
    turnOffParticipantCameras(participantIds: string[]): void;
    spotlightParticipant(participantId: string): void;
    removeSpotlight(participantId: string): void;
    kickParticipant(participantId: string): void;
    endMeeting(stayBehind?: boolean): void;
    joinBreakoutGroup(group: string): void;
    joinBreakoutMainRoom(): void;
    startBreakoutSession(options: StartBreakoutSessionOptions): void;
    updateBreakoutSession(options: UpdateBreakoutSessionOptions): void;
    stopBreakoutSession(): void;
    assignBreakoutParticipants(assignments: {
        [clientId: string]: string;
    }): void;
    assignAllBreakoutParticipants(): void;
    unassignAllBreakoutParticipants(): void;
    shuffleBreakoutParticipants(): void;
    extendBreakoutTimer(seconds?: number): void;
    stopBreakoutTimer(): void;
    broadcastToGroups(participantId: string): void;
    stopBroadcastToGroups(participantId: string): void;
    reportStreamResolution(streamId: string, width: number, height: number): void;
    switchCameraEffect(effectId: string): Promise<void>;
    switchCameraEffectCustom(imageUrl: string): Promise<void>;
    clearCameraEffect(): Promise<void>;
    enableAudioDenoiser(): Promise<void>;
    disableAudioDenoiser(): Promise<void>;
    destroy(): void;
}

declare class WherebyClient {
    protected store: Store;
    private services;
    private localMediaClient;
    protected roomConnectionClient: RoomConnectionClient;
    private gridClient;
    constructor();
    getLocalMedia(): LocalMediaClient;
    getRoomConnection(): RoomConnectionClient;
    getGrid(): GridClient;
    getStore(): Store;
    destroy(): void;
}

export { ACCEPTED_FILE_TYPES, ApiClient, BREAKOUT_CONFIG_CHANGED, BREAKOUT_GROUPS_MIN_MAX, BREAKOUT_UNAVAILABLE_ERROR, CAMERA_DEVICES_CHANGED, CAMERA_DEVICE_ERROR_CHANGED, CAMERA_STATE_CHANGED, CHAT_NEW_MESSAGE, CLIENT_VIEW_CHANGED, CLIENT_VIEW_SPOTLIGHTS_CHANGED, CLOUD_RECORDING_STATUS_CHANGED, CONNECTION_ERROR_CHANGED, CONNECTION_STATUS_CHANGED, CURRENT_CAMERA_CHANGED, CURRENT_MICROPHONE_CHANGED, CURRENT_SPEAKER_CHANGED, Credentials, CredentialsService, DEFAULT_BREAKOUT_TIMER_DURATION, GridClient, IS_SETTING_CAMERA_DEVICE, IS_SETTING_MICROPHONE_DEVICE, LIVE_CAPTIONS_STATUS_CHANGED, LIVE_TRANSCRIPTION_STATUS_CHANGED, LOCAL_MEDIA_STARTING, LOCAL_MEDIA_START_ERROR_CHANGED, LOCAL_PARTICIPANT_CHANGED, LOCAL_SCREENSHARE_STATUS_CHANGED, LOCAL_STREAM_CHANGED, LiveCaption, LocalMediaClient, LocalParticipant, MAX_FILES_PER_UPLOAD, MAX_FILE_SIZE, MICROPHONE_DEVICES_CHANGED, MICROPHONE_DEVICE_ERROR_CHANGED, MICROPHONE_STATE_CHANGED, NUMBER_OF_CLIENT_VIEWS_CHANGED, Organization, OrganizationApiClient, OrganizationService, OrganizationServiceCache, REMOTE_PARTICIPANTS_CHANGED, ROOM_JOINED, ROOM_JOINED_ERROR, RoomConnectionClient, RoomService, SCREENSHARE_STARTED, SCREENSHARE_STOPPED, SPEAKER_DEVICES_CHANGED, SPOTLIGHT_PARTICIPANT_ADDED, SPOTLIGHT_PARTICIPANT_REMOVED, STREAMING_STARTED, STREAMING_STOPPED, WAITING_PARTICIPANT_JOINED, WAITING_PARTICIPANT_LEFT, WherebyClient, createBreakoutGroups, createServices, debounce, defaultBreakoutGroupName, getAudioTrack, getFakeMediaStream, getUsableCameraEffectPresets, getVideoTrack, hasValue, isAudioDenoiserSupported, parseUnverifiedRoomKeyData };
export type { AppConfig, BreakoutSessionSettings, BreakoutState, BreakoutTimerEvent, ChatMessage, ChatMessageEvent, ChatMessageState, ClientView, CloudRecordingState, ConnectionStatus, FileShareError, FileUpload, FullOrganizationPermissions, GridEvents, GridState, LiveCaptionsState, LiveStreamState, LiveTranscriptionState, LocalMediaEvents, LocalMediaOptions, LocalMediaState, LocalParticipantState, LocalScreenshareStatus, NotificationEvents, NotificationsEventEmitter, OrganizationLimits, OrganizationOnboardingSurvey, OrganizationPermissionAction, OrganizationPermissions, OrganizationPreferences, RemoteParticipant, RemoteParticipantData, RemoteParticipantState, RequestAudioEvent, RequestVideoEvent, RoomConnectionEvents, RoomConnectionState, Screenshare, ScreenshareState, SendFilesOptions, SignalClientEvent, SignalStatusEvent, StartBreakoutSessionOptions, StickyReaction, StickyReactionEvent, StreamState, UpdateBreakoutSessionOptions, WaitingParticipant, WaitingParticipantState, WherebyClientOptions };