@whereby.com/browser-sdk 2.0.0-alpha23 → 2.0.0-alpha26

package/dist/types.d.ts

@@ -1,382 +0,0 @@
-import React from 'react';
-import RtcManager from '@whereby/jslib-media/src/webrtc/RtcManager';
-import { ChatMessage as ChatMessage$1 } from '@whereby/jslib-media/src/utils/ServerSocket';
-
-interface WherebyEmbedAttributes {
-    audio: string;
-    avatarUrl: string;
-    background: string;
-    cameraAccess: string;
-    chat: string;
-    displayName: string;
-    emptyRoomInvitation: string;
-    floatSelf: string;
-    help: string;
-    leaveButton: string;
-    logo: string;
-    people: string;
-    precallReview: string;
-    recording: string;
-    screenshare: string;
-    video: string;
-    virtualBackgroundUrl: string;
-    room: string;
-    style: {
-        [key: string]: string;
-    };
-}
-declare global {
-    namespace JSX {
-        interface IntrinsicElements {
-            ["whereby-embed"]: Partial<WherebyEmbedAttributes>;
-        }
-    }
-}
-
-interface VideoViewSelfProps {
-    stream: MediaStream;
-    muted?: boolean;
-    style?: React.CSSProperties;
-    onResize?: ({ width, height, stream }: {
-        width: number;
-        height: number;
-        stream: MediaStream;
-    }) => void;
-}
-type VideoViewProps = VideoViewSelfProps & React.DetailedHTMLProps<React.VideoHTMLAttributes<HTMLVideoElement>, HTMLVideoElement>;
-declare const _default: ({ muted, stream, onResize, ...rest }: VideoViewProps) => JSX.Element;
-
-type CameraEnabledEvent = {
-    enabled: boolean;
-};
-type MicrophoneEnabledEvent = {
-    enabled: boolean;
-};
-type DeviceListUpdatedEvent = {
-    cameraDevices: MediaDeviceInfo[];
-    microphoneDevices: MediaDeviceInfo[];
-    speakerDevices: MediaDeviceInfo[];
-};
-type DeviceListUpdateErrorEvent = {
-    error: unknown;
-};
-type StreamUpdatedEvent = {
-    stream: MediaStream;
-};
-interface LocalMediaEventsMap {
-    camera_enabled: CustomEvent<CameraEnabledEvent>;
-    device_list_updated: CustomEvent<DeviceListUpdatedEvent>;
-    device_list_update_error: CustomEvent<DeviceListUpdateErrorEvent>;
-    microphone_enabled: CustomEvent<MicrophoneEnabledEvent>;
-    stream_updated: CustomEvent<StreamUpdatedEvent>;
-}
-interface LocalMediaEventTarget extends EventTarget {
-    addEventListener<K extends keyof LocalMediaEventsMap>(type: K, listener: (ev: LocalMediaEventsMap[K]) => void, options?: boolean | AddEventListenerOptions): void;
-    addEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
-}
-declare const TypedLocalMediaEventTarget: new () => LocalMediaEventTarget;
-declare class LocalMedia extends TypedLocalMediaEventTarget {
-    private _constraints;
-    _rtcManagers: RtcManager[];
-    stream: MediaStream;
-    screenshareStream?: MediaStream;
-    constructor(constraints: MediaStreamConstraints);
-    addRtcManager(rtcManager: RtcManager): void;
-    removeRtcManager(rtcManager: RtcManager): void;
-    getCameraDeviceId(): string | undefined;
-    getMicrophoneDeviceId(): string | undefined;
-    isCameraEnabled(): boolean;
-    isMicrophoneEnabled(): boolean;
-    toggleCameraEnabled(enabled?: boolean): void;
-    toggleMichrophoneEnabled(enabled?: boolean): void;
-    startScreenshare(): Promise<MediaStream>;
-    stopScreenshare(): void;
-    setCameraDevice(deviceId: string): Promise<void>;
-    setMicrophoneDevice(deviceId: string): Promise<void>;
-    private _updateDeviceList;
-    start(): Promise<MediaStream>;
-    stop(): void;
-}
-
-interface LocalMediaState {
-    currentCameraDeviceId?: string;
-    currentMicrophoneDeviceId?: string;
-    cameraDeviceError: unknown;
-    cameraDevices: MediaDeviceInfo[];
-    isSettingCameraDevice: boolean;
-    isSettingMicrophoneDevice: boolean;
-    isStarting: boolean;
-    localStream?: MediaStream;
-    microphoneDeviceError: unknown;
-    microphoneDevices: MediaDeviceInfo[];
-    speakerDevices: MediaDeviceInfo[];
-    startError: unknown;
-}
-interface LocalMediaActions {
-    setCameraDevice: InstanceType<typeof LocalMedia>["setCameraDevice"];
-    setMicrophoneDevice: InstanceType<typeof LocalMedia>["setMicrophoneDevice"];
-    toggleCameraEnabled: InstanceType<typeof LocalMedia>["toggleCameraEnabled"];
-    toggleMicrophoneEnabled: InstanceType<typeof LocalMedia>["toggleMichrophoneEnabled"];
-}
-type LocalMediaRef = {
-    state: LocalMediaState;
-    actions: LocalMediaActions;
-    _ref: LocalMedia;
-};
-declare function useLocalMedia(constraints?: MediaStreamConstraints): LocalMediaRef;
-
-interface RoomParticipantData {
-    displayName: string;
-    id: string;
-    stream?: MediaStream;
-    isAudioEnabled: boolean;
-    isVideoEnabled: boolean;
-}
-declare class RoomParticipant {
-    readonly displayName: string;
-    readonly id: string;
-    readonly stream?: MediaStream;
-    readonly isAudioEnabled: boolean;
-    readonly isLocalParticipant: boolean;
-    readonly isVideoEnabled: boolean;
-    constructor({ displayName, id, stream, isAudioEnabled, isVideoEnabled }: RoomParticipantData);
-}
-interface RemoteParticipantData {
-    newJoiner: boolean;
-    streams: string[];
-}
-type StreamState = "new_accept" | "to_accept" | "old_accept" | "done_accept" | "to_unaccept" | "done_unaccept" | "auto";
-interface Stream {
-    id: string;
-    state: StreamState;
-}
-declare class RemoteParticipant extends RoomParticipant {
-    readonly newJoiner: boolean;
-    readonly streams: Stream[];
-    constructor({ displayName, id, newJoiner, streams, isAudioEnabled, isVideoEnabled, }: RoomParticipantData & RemoteParticipantData);
-    addStream(streamId: string, state: StreamState): void;
-    removeStream(streamId: string): void;
-    updateStreamState(streamId: string, state: StreamState): void;
-}
-declare class LocalParticipant extends RoomParticipant {
-    readonly isLocalParticipant = true;
-    constructor({ displayName, id, stream, isAudioEnabled, isVideoEnabled }: RoomParticipantData);
-}
-interface WaitingParticipant {
-    id: string;
-    displayName: string | null;
-}
-declare class Screenshare {
-    readonly participantId: string;
-    readonly id: string;
-    readonly hasAudioTrack: boolean;
-    readonly stream?: MediaStream;
-    readonly isLocal: boolean;
-    constructor({ participantId, id, hasAudioTrack, stream, isLocal }: Screenshare);
-}
-
-type Logger = Pick<Console, "debug" | "error" | "log" | "warn">;
-interface RoomConnectionOptions {
-    displayName?: string;
-    localMediaConstraints?: MediaStreamConstraints;
-    roomKey?: string;
-    logger?: Logger;
-    localMedia?: LocalMedia;
-}
-type ChatMessage = Pick<ChatMessage$1, "senderId" | "timestamp" | "text">;
-type RoomConnectionStatus = "" | "connecting" | "connected" | "room_locked" | "knocking" | "disconnecting" | "disconnected" | "accepted" | "rejected";
-type CloudRecordingState = {
-    status: "" | "recording";
-    startedAt: number | null;
-};
-type StreamingState = {
-    status: "" | "streaming";
-    startedAt: number | null;
-};
-type RoomJoinedEvent = {
-    localParticipant: LocalParticipant;
-    remoteParticipants: RemoteParticipant[];
-    waitingParticipants: WaitingParticipant[];
-};
-type RoomConnectionStatusChangedEvent = {
-    roomConnectionStatus: RoomConnectionStatus;
-};
-type ParticipantJoinedEvent = {
-    remoteParticipant: RemoteParticipant;
-};
-type ParticipantLeftEvent = {
-    participantId: string;
-};
-type ParticipantStreamAddedEvent = {
-    participantId: string;
-    stream: MediaStream;
-};
-type ParticipantAudioEnabledEvent = {
-    participantId: string;
-    isAudioEnabled: boolean;
-};
-type ParticipantVideoEnabledEvent = {
-    participantId: string;
-    isVideoEnabled: boolean;
-};
-type ParticipantMetadataChangedEvent = {
-    participantId: string;
-    displayName: string;
-};
-type ScreenshareStartedEvent = {
-    participantId: string;
-    id: string;
-    hasAudioTrack: boolean;
-    stream: MediaStream;
-    isLocal: boolean;
-};
-type ScreenshareStoppedEvent = {
-    participantId: string;
-    id: string;
-};
-type WaitingParticipantJoinedEvent = {
-    participantId: string;
-    displayName: string | null;
-};
-type WaitingParticipantLeftEvent = {
-    participantId: string;
-};
-interface RoomEventsMap {
-    chat_message: (e: CustomEvent<ChatMessage>) => void;
-    cloud_recording_started: (e: CustomEvent<CloudRecordingState>) => void;
-    cloud_recording_stopped: (e: CustomEvent<CloudRecordingState>) => void;
-    participant_audio_enabled: (e: CustomEvent<ParticipantAudioEnabledEvent>) => void;
-    participant_joined: (e: CustomEvent<ParticipantJoinedEvent>) => void;
-    participant_left: (e: CustomEvent<ParticipantLeftEvent>) => void;
-    participant_metadata_changed: (e: CustomEvent<ParticipantMetadataChangedEvent>) => void;
-    participant_stream_added: (e: CustomEvent<ParticipantStreamAddedEvent>) => void;
-    participant_video_enabled: (e: CustomEvent<ParticipantVideoEnabledEvent>) => void;
-    room_connection_status_changed: (e: CustomEvent<RoomConnectionStatusChangedEvent>) => void;
-    room_joined: (e: CustomEvent<RoomJoinedEvent>) => void;
-    screenshare_started: (e: CustomEvent<ScreenshareStartedEvent>) => void;
-    screenshare_stopped: (e: CustomEvent<ScreenshareStoppedEvent>) => void;
-    streaming_started: (e: CustomEvent<StreamingState>) => void;
-    streaming_stopped: (e: CustomEvent<StreamingState>) => void;
-    waiting_participant_joined: (e: CustomEvent<WaitingParticipantJoinedEvent>) => void;
-    waiting_participant_left: (e: CustomEvent<WaitingParticipantLeftEvent>) => void;
-}
-interface RoomEventTarget extends EventTarget {
-    addEventListener<K extends keyof RoomEventsMap>(type: K, listener: RoomEventsMap[K], options?: boolean | AddEventListenerOptions): void;
-    addEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
-    removeEventListener<K extends keyof RoomEventsMap>(type: K, listener: RoomEventsMap[K], options?: boolean | EventListenerOptions): void;
-    removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
-}
-declare const TypedEventTarget: new () => RoomEventTarget;
-declare class RoomConnection extends TypedEventTarget {
-    localMedia: LocalMedia;
-    localParticipant: LocalParticipant | null;
-    roomUrl: URL;
-    remoteParticipants: RemoteParticipant[];
-    screenshares: Screenshare[];
-    readonly localMediaConstraints?: MediaStreamConstraints;
-    readonly roomName: string;
-    private organizationId;
-    private credentialsService;
-    private apiClient;
-    private organizationService;
-    private organizationServiceCache;
-    private organizationApiClient;
-    private roomService;
-    private _deviceCredentials;
-    private signalSocket;
-    private signalSocketManager;
-    private rtcManagerDispatcher?;
-    private rtcManager?;
-    private roomConnectionStatus;
-    private selfId;
-    private logger;
-    private _ownsLocalMedia;
-    private displayName?;
-    private _roomKey;
-    constructor(roomUrl: string, { displayName, localMedia, localMediaConstraints, logger, roomKey }: RoomConnectionOptions);
-    get roomKey(): string | null;
-    private _handleNewChatMessage;
-    private _handleCloudRecordingStarted;
-    private _handleStreamingStarted;
-    private _handleNewClient;
-    private _handleClientLeft;
-    private _handleClientAudioEnabled;
-    private _handleClientVideoEnabled;
-    private _handleClientMetadataReceived;
-    private _handleKnockHandled;
-    private _handleKnockerLeft;
-    private _handleRoomJoined;
-    private _handleRoomKnocked;
-    private _handleReconnect;
-    private _handleDisconnect;
-    private _handleCloudRecordingStopped;
-    private _handleStreamingStopped;
-    private _handleScreenshareStarted;
-    private _handleScreenshareStopped;
-    private _handleRtcEvent;
-    private _handleRtcManagerCreated;
-    private _handleRtcManagerDestroyed;
-    private _handleAcceptStreams;
-    private _handleStreamAdded;
-    private _joinRoom;
-    join(): Promise<void>;
-    knock(): void;
-    leave(): void;
-    sendChatMessage(text: string): void;
-    setDisplayName(displayName: string): void;
-    acceptWaitingParticipant(participantId: string): void;
-    rejectWaitingParticipant(participantId: string): void;
-    updateStreamResolution({ streamId, width, height }: {
-        streamId?: string;
-        width: number;
-        height: number;
-    }): void;
-    startScreenshare(): Promise<void>;
-    stopScreenshare(): void;
-}
-
-type RemoteParticipantState = Omit<RemoteParticipant, "updateStreamState">;
-interface RoomConnectionState {
-    chatMessages: ChatMessage[];
-    cloudRecording: CloudRecordingState;
-    isJoining: boolean;
-    isStartingScreenshare: boolean;
-    joinError: unknown;
-    startScreenshareError: unknown;
-    localParticipant?: LocalParticipant;
-    mostRecentChatMessage: ChatMessage | null;
-    remoteParticipants: RemoteParticipantState[];
-    screenshares: Screenshare[];
-    roomConnectionStatus: RoomConnectionStatus;
-    streaming: StreamingState;
-    waitingParticipants: WaitingParticipant[];
-}
-interface UseRoomConnectionOptions extends Omit<RoomConnectionOptions, "localMedia"> {
-    localMedia?: LocalMediaRef;
-}
-interface RoomConnectionActions {
-    sendChatMessage(text: string): void;
-    knock(): void;
-    setDisplayName(displayName: string): void;
-    toggleCamera(enabled?: boolean): void;
-    toggleMicrophone(enabled?: boolean): void;
-    acceptWaitingParticipant(participantId: string): void;
-    rejectWaitingParticipant(participantId: string): void;
-    startScreenshare(): void;
-    stopScreenshare(): void;
-}
-type VideoViewComponentProps = Omit<React.ComponentProps<typeof _default>, "onResize">;
-interface RoomConnectionComponents {
-    VideoView: (props: VideoViewComponentProps) => ReturnType<typeof _default>;
-}
-type RoomConnectionRef = {
-    state: RoomConnectionState;
-    actions: RoomConnectionActions;
-    components: RoomConnectionComponents;
-    _ref: RoomConnection;
-};
-declare function useRoomConnection(roomUrl: string, roomConnectionOptions: UseRoomConnectionOptions): RoomConnectionRef;
-
-declare const sdkVersion = "2.0.0-alpha23";
-
-export { _default as VideoView, sdkVersion, useLocalMedia, useRoomConnection };