@snapcall/stream-ui 1.25.0 → 1.25.1

package/dist/types.d.ts

@@ -0,0 +1,688 @@
+import * as mediasoupClient from "mediasoup-client";
+import { types } from "mediasoup-client";
+import * as protooClient from "protoo-client";
+import { Transport } from "mediasoup-client/lib/Transport";
+import { CSSProperties } from "react";
+type VideoResolution = 'qvga' | 'vga' | 'hd';
+type PeerId = string;
+type DeviceType = 'webcam' | 'screen' | 'microphone';
+interface Profile {
+    name?: string;
+    image?: string;
+}
+interface Step {
+    type: 'video' | 'audio' | 'screen' | 'image';
+    token: string;
+    title: string;
+    description: string;
+    image_url: string;
+    translation: {
+        title?: string;
+        description?: string;
+        button?: string;
+        languageCode?: string;
+    };
+}
+interface Flow {
+    token: string;
+    name: string;
+    is_default: number;
+    steps: Array<Step>;
+}
+interface FlowV0 {
+    logo_url?: string;
+    image_url?: string;
+    title?: string;
+    text?: string;
+}
+interface InitResult {
+    flow?: Flow;
+    flowV0?: FlowV0;
+}
+interface JoinOptions {
+    languageCode?: string;
+    flowToken?: string;
+    recorder?: boolean;
+    apiKey?: string;
+    email?: string;
+    displayName?: string;
+    profile?: Profile;
+    authKey?: string;
+}
+interface PeerState {
+    peerId: string;
+    profile: Profile;
+    deviceState: DevicesState;
+}
+interface CompanyInfo {
+    name?: string;
+    company_name?: string;
+    avatar_url?: string;
+    terminate_enabled?: boolean;
+}
+type WaitingRequests = Array<{
+    id: string;
+    profile?: Profile;
+}>;
+interface GetRoomPeersResult {
+    peers: Array<{
+        id: string;
+        displayName?: string;
+        profile: Profile;
+        muted: boolean;
+        producersIds: string[];
+        producersData: ProducerData[];
+    }>;
+    videoRecordStarted: boolean;
+    videoRecording: {
+        requested: boolean;
+        started: boolean;
+    };
+}
+interface StreamerState extends PeerState {
+    roomId: string;
+    plan?: string;
+    permissions: Permissions;
+    company?: CompanyInfo;
+    companyId: number;
+    waitingRoomAccess: boolean;
+    peers: Array<PeerState>;
+    joinOptions: JoinOptions;
+}
+interface ProducerData {
+    producerId: string;
+    deviceType: DeviceType;
+    paused: boolean;
+}
+interface PeerInfo {
+    id?: PeerId;
+    peerId: PeerId;
+    muted: boolean;
+    profile: Profile;
+    displayName?: string;
+    producersData: Array<ProducerData>;
+}
+type ConsumerId = string;
+type ProducerId = string;
+interface ConsumerData {
+    mediaSoupConsumer: types.Consumer;
+    deviceType?: DeviceType;
+}
+interface DevicesState {
+    microphone: {
+        enabled: boolean;
+        muted: boolean;
+        device?: MediaDeviceInfo | null;
+    };
+    camera: {
+        enabled: boolean;
+        device?: MediaDeviceInfo | null;
+    };
+    screenshare: {
+        enabled: boolean;
+    };
+}
+interface Config {
+    apiUrl: string;
+    streamerServer: string;
+    streamerApi: string;
+    iceServers: RTCIceServer[];
+    streamApiURL: string;
+}
+type Permission = 'share_link' | 'direct_pay' | 'quick_connect' | 'virtual_background' | 'screen_sharing' | 'instant_picture' | 'request_input' | 'recording' | 'record_video_on_demand';
+type Permissions = Array<Permission>;
+declare global {
+    interface Window {
+        webkitAudioContext: Function;
+    }
+    interface MediaTrackConstraintSet {
+        displaySurface?: ConstrainDOMString;
+        logicalSurface?: ConstrainBoolean;
+        zoom?: number;
+        focusMode?: 'none' | 'manual' | 'single-shot' | 'continuous';
+    }
+    interface MediaTrackCapabilities {
+        zoom: {
+            min: number;
+            max: number;
+            step: number;
+        };
+        focusMode?: Array<'none' | 'manual' | 'single-shot' | 'continuous'>;
+    }
+}
+interface MenuItem {
+    id: string;
+    title: string;
+    jsxIcon?: JSX.Element;
+    srcIcon?: string;
+    action: () => void;
+    danger?: boolean;
+    isNew?: boolean;
+}
+interface MenuCategory {
+    id: string;
+    title?: string;
+    items: MenuItem[];
+}
+type DisplayType = 'icon' | 'full';
+interface SettingShortcut {
+    id: string;
+    displayType: DisplayType;
+}
+interface SettingsCategory extends MenuCategory {
+    position?: number;
+    items: SettingsItem[];
+}
+interface SettingsItem extends MenuItem {
+    position?: number;
+}
+interface AudioLevelListener {
+    onAudioLevel?(audioLevel: number, id: string): void;
+    onMuteDetection?(id: string): void;
+    onStartSpeak(): void;
+    onStopSpeak(): void;
+}
+declare class AudioLevel {
+    readonly id: string;
+    constructor(stream: MediaStream, listener?: AudioLevelListener);
+    /**
+     * return the median of the audio levels (60 per second) for the
+     * current second
+     */
+    getAudioLevelMedian(): number;
+    getCurrentAudioLevel(): number;
+    analyse(): void;
+    startAverageAnalysis(): void;
+    stopAverageAnalysis(): number;
+    getFrequencyData(): Uint8Array;
+    clearListeners(): void;
+    release(): void;
+    static isAPIAvailable(): boolean;
+}
+declare class AudioRenderer {
+    constructor({ consumerId }: {
+        consumerId: string;
+    });
+    destroy(): void;
+    setSource(srcObject: MediaStream): void;
+    setSink(sinkId: string): Promise<void>;
+    getSink(): string;
+    play(): Promise<void>;
+}
+interface MediapipeOptions {
+    type: 'blur' | 'background';
+    fillColor?: string;
+    background?: CanvasImageSource;
+    blurLevel?: number;
+}
+interface DeviceRequest {
+    requestId: string;
+    deviceType: DeviceType;
+}
+interface CustomMessage {
+    chunks: Array<{
+        index: number;
+        data: string;
+    }>;
+    totalChunks: number;
+}
+declare global {
+    export namespace SnapCall {
+        export { Permissions, Permission };
+        export type SnapcallEvent<T> = CustomEvent<T>;
+        export type PeersInfoEvent = SnapcallEvent<{
+            videoRecordStarted: boolean;
+            videoRecording?: {
+                requested: boolean;
+                started: boolean;
+            };
+            peerId: string;
+            plan?: string;
+            permissions: Permissions;
+            peers: {
+                peerId: string;
+                muted: boolean;
+                displayName?: string;
+                profile: Profile;
+            }[];
+        }>;
+        export type PeerInfoEvent = SnapcallEvent<{
+            peerId: string;
+            displayName?: string;
+            profile: Profile;
+        }>;
+        export type RequestAccessEvent = SnapcallEvent<{
+            success: string;
+            message?: string;
+        }>;
+        export type RequestAccessRequestEvent = SnapcallEvent<WaitingRequests[number]>;
+        export type RequestAccessCancelEvent = SnapcallEvent<{
+            id: string;
+        }>;
+        export type ProfileUpdateEvent = SnapcallEvent<{
+            peerId: string;
+            profile: Profile;
+        }>;
+        export type RequestDeviceEvent = SnapcallEvent<{
+            peerId: string;
+            deviceType: DeviceType;
+        }>;
+        export type RequestDeviceResultEvent = SnapcallEvent<{
+            result: {
+                peerId: string;
+                result: boolean;
+            };
+        }>;
+        export type BaseEvent = SnapcallEvent<{}>;
+        export type StreamEvent = SnapcallEvent<{
+            peerId: string;
+        }>;
+        export type RequestResultEvent = SnapcallEvent<{
+            success: Boolean;
+        }>;
+        export type AudioDeviceEvent = SnapcallEvent<MediaDeviceInfo>;
+        export type MediaEvent = SnapcallEvent<{
+            peerId: string;
+            mediaId?: string;
+            deviceType: DeviceType;
+            paused: boolean;
+        }>;
+        export type WebcamUpdateEvent = SnapcallEvent<{
+            numberOfAvailableWebcams: number;
+        }>;
+        export type CriticalErrorEvent = SnapcallEvent<{
+            code: string;
+        }>;
+        export type CustomMessageEvent = SnapcallEvent<{
+            peerId: string;
+            event: {
+                type: string;
+            } & Record<string, any>;
+        }>;
+        export type localVideoChangeEvent = SnapcallEvent<{
+            camera: {
+                device: MediaDeviceInfo | null;
+                resolution: VideoResolution;
+            };
+        }>;
+        export type AgentIdentityEvent = SnapcallEvent<{
+            success: boolean;
+            email?: string;
+            name?: string;
+            avatarUrl?: string;
+        }>;
+        export type RecordStoppedEvent = SnapcallEvent<{
+            url: string;
+            assetId: number;
+        }>;
+        export type AudioLevelEvent = SnapcallEvent<{
+            audioLevel: number;
+        }>;
+        export type InitializedEvent = SnapcallEvent<InitResult>;
+    }
+    export interface PublicPage {
+        token: string;
+        logo_url: string;
+        title: string;
+        description: string;
+        data: {
+            links: {
+                id: 'recordVideo' | 'takePicture' | 'scheduleCall' | 'recordScreen';
+                active: boolean;
+                user_ids?: number[];
+                team_ids?: number[];
+                schedule_ids?: string[];
+            }[];
+        };
+    }
+}
+interface StreamerEventMap {
+    audioLevel: SnapCall.AudioLevelEvent['detail'];
+    localStartSpeak?: SnapCall.BaseEvent['detail'];
+    localStopSpeak?: SnapCall.BaseEvent['detail'];
+    leaveRoom: SnapCall.BaseEvent['detail'];
+    terminateRoom: SnapCall.BaseEvent['detail'];
+    invalidRoom: SnapCall.BaseEvent['detail'];
+    accessRequest: SnapCall.RequestAccessRequestEvent['detail'];
+    cancelAccessRequest: SnapCall.RequestAccessCancelEvent['detail'];
+    requestAccessResult: SnapCall.RequestAccessEvent['detail'];
+    localVideoUnavailable: SnapCall.BaseEvent['detail'];
+    localVideoAvailable: SnapCall.BaseEvent['detail'];
+    microphoneEnabled: SnapCall.BaseEvent['detail'];
+    agentIdentity: SnapCall.AgentIdentityEvent['detail'];
+    peerClosed: SnapCall.StreamEvent['detail'];
+    newPeer: SnapCall.PeerInfoEvent['detail'];
+    selfDisplayName: SnapCall.PeerInfoEvent['detail'];
+    selfProfileUpdate: SnapCall.ProfileUpdateEvent['detail'];
+    profileUpdate: SnapCall.ProfileUpdateEvent['detail'];
+    webcamsUpdate: SnapCall.WebcamUpdateEvent['detail'];
+    customMessage: SnapCall.CustomMessageEvent['detail'];
+    mediaStart: SnapCall.MediaEvent['detail'];
+    mediaStop: SnapCall.MediaEvent['detail'];
+    mediaPause: SnapCall.MediaEvent['detail'];
+    mediaResume: SnapCall.MediaEvent['detail'];
+    microphoneMute: SnapCall.BaseEvent['detail'];
+    microphoneUnmute: SnapCall.BaseEvent['detail'];
+    defaultAudioDeviceChange: SnapCall.AudioDeviceEvent['detail'];
+    screenshareEnabled: SnapCall.BaseEvent['detail'];
+    screenshareDisabled: SnapCall.BaseEvent['detail'];
+    localVideoRotate: SnapCall.BaseEvent['detail'];
+    enterRoom: SnapCall.PeersInfoEvent['detail'];
+    displayName: SnapCall.PeerInfoEvent['detail'];
+    peerStartSpeak: SnapCall.StreamEvent['detail'];
+    peerStopSpeak: SnapCall.StreamEvent['detail'];
+    criticalError: SnapCall.CriticalErrorEvent['detail'];
+    requestDevice: SnapCall.RequestDeviceEvent['detail'];
+    requestDeviceResult: SnapCall.RequestDeviceResultEvent['detail'];
+    devicesListChange: SnapCall.BaseEvent['detail'];
+    localVideoChange: SnapCall.localVideoChangeEvent['detail'];
+    recordStopped: SnapCall.RecordStoppedEvent['detail'];
+    videoRecordingStarted: SnapCall.BaseEvent['detail'];
+    videoRecordingStopped: SnapCall.BaseEvent['detail'];
+    videoRecordingRequested: SnapCall.BaseEvent['detail'];
+    initialized: SnapCall.InitializedEvent['detail'];
+}
+declare class SnapcallEvent<T extends keyof StreamerEventMap> extends CustomEvent<StreamerEventMap[T]> {
+    constructor(name: T, data: CustomEventInit & {
+        detail: StreamerEventMap[T];
+    });
+}
+interface StreamerEventTarget extends EventTarget {
+    addEventListener<T extends keyof StreamerEventMap>(type: T, listener: (event: CustomEvent<StreamerEventMap[T]>) => void, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+    removeEventListener<T extends keyof StreamerEventMap>(type: T, listener: (event: CustomEvent<StreamerEventMap[T]>) => void): void;
+    removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null): void;
+    dispatchEvent<T extends keyof StreamerEventMap>(ev: SnapcallEvent<T>): boolean;
+}
+declare const StreamerEventTargetType: {
+    new (): StreamerEventTarget;
+    prototype: StreamerEventTarget;
+};
+declare class StreamerClient extends StreamerEventTargetType implements AudioLevelListener {
+    peers: Map<PeerId, PeerInfo>;
+    consumers: Map<ConsumerId, ConsumerData>;
+    webcams: Map<string, MediaDeviceInfo>;
+    webcam: {
+        device: MediaDeviceInfo | null;
+        facingMode?: string;
+        resolution: VideoResolution;
+        framerate?: number;
+    };
+    microphone: {
+        device: MediaDeviceInfo | null;
+        muted: boolean;
+    };
+    webcamTrack: MediaStreamTrack | null;
+    webcamZoom: {
+        available: boolean;
+        min: number;
+        max: number;
+    };
+    audioLevel: AudioLevel | undefined;
+    roomId: string;
+    companyId: number;
+    defaultPublicPage?: {
+        token: string;
+    };
+    peerId: PeerId;
+    clientId: string;
+    profile: Profile;
+    protooTransport?: protooClient.WebSocketTransport;
+    protoo?: protooClient.Peer;
+    micProducer?: mediasoupClient.types.Producer;
+    webcamProducer: mediasoupClient.types.Producer | null;
+    screenshareVideoProducer?: mediasoupClient.types.Producer;
+    screenshareAudioProducer?: mediasoupClient.types.Producer;
+    pendingDeviceRequest: Record<string, DeviceRequest>;
+    joinOptions: JoinOptions;
+    audioInputDefaultDevice?: MediaDeviceInfo;
+    devicesList: Array<MediaDeviceInfo>;
+    customMessages: Map<string, CustomMessage>;
+    audioRenderers: Record<string, AudioRenderer>;
+    constructor();
+    getState(): StreamerState;
+    onAudioLevel: (this: any) => void;
+    onStartSpeak(): void;
+    onStopSpeak(): void;
+    generateToken(bid: string): Promise<string>;
+    init(room?: string, options?: JoinOptions): Promise<InitResult>;
+    setAgentIdentity({ apiKey, email }: {
+        apiKey: string;
+        email?: string;
+    }): Promise<void>;
+    acceptAccessRequest(id: string): Promise<any>;
+    setStep(stepToken: string): Promise<void>;
+    denyAccessRequest(id: string): Promise<any>;
+    requestRoomAccess(): Promise<void>;
+    joinRoom(): Promise<void>;
+    getRoomPeers(): Promise<GetRoomPeersResult>;
+    onEnterRoom(): Promise<void>;
+    joinRecorder(): Promise<void>;
+    switchMicrophone(deviceId?: string): Promise<void>;
+    closeMicrophoneProducer(): Promise<void>;
+    onDeviceChange(): Promise<void>;
+    enableMicrophone({ deviceId }?: {
+        deviceId?: string;
+    }): Promise<void>;
+    muteMicrophone(): void;
+    unMuteMicrophone(): void;
+    toggleMute(): Promise<{
+        muted: boolean;
+    }>;
+    release(): void;
+    endCall(): void;
+    terminateRoom(): void;
+    updateWebcams(): Promise<void>;
+    isVideoZoomAvailable(): boolean;
+    handleGetUserMediaError(deviceType: DeviceType, getUserMediaPromise: Promise<MediaStream>): Promise<MediaStream>;
+    restartIce(transport: Transport): Promise<void>;
+    setVideoBackground(options: MediapipeOptions): void;
+    initVideoBackground(): Promise<void>;
+    stopVideoBackground(): Promise<void>;
+    switchWebcam({ device, resolution, rotate, frameRate, facingMode, }: {
+        device?: MediaDeviceInfo;
+        resolution?: VideoResolution;
+        rotate?: boolean;
+        frameRate?: number;
+        facingMode?: string;
+    }): Promise<void>;
+    enableVideo(config?: {
+        device?: MediaDeviceInfo;
+        facingMode?: string;
+        resolution?: VideoResolution;
+        frameRate?: number;
+    }): Promise<void>;
+    rotateVideo(): Promise<void>;
+    zoomVideo(): Promise<void>;
+    unzoomVideo(): Promise<void>;
+    disableVideo(): Promise<void>;
+    enableScreenshare(options?: {
+        mediaStream?: MediaStream;
+        audioTransportOption: 'mix' | 'none' | 'classic';
+    }): Promise<void>;
+    disableScreenshare(): Promise<void>;
+    onConsumerClose({ consumerId }: {
+        consumerId: ConsumerId;
+    }): void;
+    requestVideo({ mediaId, element }: {
+        mediaId: string;
+        element: HTMLVideoElement;
+    }): void;
+    saveCapture(base64Image: string): Promise<{
+        url: string;
+        assetId: number;
+    }>;
+    deleteCapture(assetId: number): Promise<number>;
+    captureVideo(videoElement?: HTMLVideoElement): Promise<string>;
+    requestLocalVideo(element: HTMLVideoElement): {
+        facingMode: string;
+    };
+    requestLocalScreenshare(element: HTMLVideoElement): void;
+    consumePeer({ peerId, producersData, }: {
+        peerId: PeerId;
+        producersData: Array<ProducerData>;
+    }): void;
+    consumeProducer({ peerId, producerId, deviceType, paused, }: {
+        peerId: PeerId;
+        producerId: ProducerId;
+        deviceType: DeviceType;
+        paused: boolean;
+    }): Promise<void>;
+    setDisplayName(displayName: string): Promise<void>;
+    setProfile(profile: Profile): Promise<void>;
+    requestPeerDevice(remotePeerId: string, deviceType: DeviceType): Promise<void>;
+    denyDeviceRequest(deviceType: DeviceType): void;
+    getConsumers(): Map<string, ConsumerData>;
+    getDevicesState(): DevicesState;
+    sendCustomMessageToAll(event: any): Promise<void>;
+    sendCustomMessage(peerId: string, event: any): Promise<void>;
+    listAudioDevices(): Promise<MediaDeviceInfo[]>;
+    listVideoDevices(): Promise<MediaDeviceInfo[]>;
+    isListDevicesSupported(): boolean;
+    getCurrentWebcam(): {
+        device: MediaDeviceInfo | null;
+        resolution: VideoResolution;
+    };
+    getCurrentMicrophoneId(): string | MediaTrackSettings | undefined;
+    getCurrentSpeakerId(): string;
+    setWebcamResolution(resolution: VideoResolution): Promise<void>;
+    createAudioRenderer(consumerId: string): AudioRenderer;
+    deleteAudioRenderer(consumerId: string): void;
+    playAudioRenderer(consumerId: string): Promise<void>;
+    setAudioSink(sinkId: string): Promise<void>;
+    dispatchEvent(event: SnapcallEvent<keyof StreamerEventMap>): boolean;
+    setConfig(config: Partial<Config>): void;
+    getPermissions(): Permissions;
+    startRecord(): Promise<void>;
+    stopRecord(): Promise<void>;
+    getPublicPage(token: string): Promise<PublicPage>;
+    getWaitingRequests(): Promise<WaitingRequests>;
+}
+declare const streamerClient: StreamerClient;
+interface NotificationOptions {
+    icon?: JSX.Element | string;
+    subText?: string;
+    button?: {
+        icon?: JSX.Element | string;
+        text: string;
+        action: () => void;
+        style?: CSSProperties;
+    };
+    status?: {
+        icon?: JSX.Element | string;
+        text?: string;
+        boldText?: string;
+    };
+    width?: string;
+    backgroundColor?: string;
+    messageStyle?: CSSProperties;
+    ellipsis?: boolean;
+}
+type NotificationButton = NonNullable<NotificationOptions['button']>;
+interface CustomNotificationButton extends Omit<NotificationButton, 'action'> {
+    action: ({ close }: {
+        close: () => void;
+    }) => void;
+}
+interface SendNotificationOptions extends Omit<NotificationOptions, 'button'> {
+    button?: CustomNotificationButton;
+    duration?: number;
+}
+declare const sendNotification: (message: string, options?: SendNotificationOptions) => void;
+interface StreamUIMethods {
+    initV2: (options: StreamUIInitOptions) => Promise<void>;
+    init: (options: StreamUIInitOptions) => void;
+    joinRoom: (token: string, options: StreamUIInitOptions) => Promise<void>;
+    setAgentIdentity: typeof streamerClient.setAgentIdentity;
+    enableScreenshare: typeof streamerClient.enableScreenshare;
+    setExtraSettingsOptions: (extraOptions: SettingsCategory[]) => void;
+    sendNotification: typeof sendNotification;
+    startRecord: typeof streamerClient.startRecord;
+    stopRecord: typeof streamerClient.stopRecord;
+    leaveRoom: typeof streamerClient.endCall;
+    terminateRoom: typeof streamerClient.terminateRoom;
+    generateToken: typeof streamerClient.generateToken;
+    addEventListener: typeof streamerClient.addEventListener;
+    removeEventListener: typeof streamerClient.removeEventListener;
+    dispatchEvent: typeof streamerClient.dispatchEvent;
+    getState: typeof streamerClient.getState;
+    setProfile: typeof streamerClient.setProfile;
+    setConfig: typeof streamerClient.setConfig;
+    setLogLevel: (level: number) => void;
+    getPermissions: () => Permissions;
+    streamerClient: StreamerClient;
+}
+interface ControlSettings {
+    available?: boolean;
+    enabled?: boolean;
+}
+interface StreamUIBaseOptions {
+    token?: string;
+    flowToken?: string;
+    authKey?: string;
+    profile?: Profile;
+    apiKey?: string;
+    email?: string;
+    headless?: boolean;
+    greeting?: boolean;
+    recorder?: {
+        enabledModes: Array<'video' | 'screen' | 'photo' | 'audio'>;
+        enabled: boolean;
+        defaultMode?: 'photo' | 'video' | 'audio' | 'screen';
+        skipOnboarding?: boolean;
+    };
+    sharedURL?: string;
+    audioTiles?: boolean;
+    settingsShortcuts?: Array<SettingShortcut>;
+    extraSettingsOptions?: SettingsCategory[];
+    controls?: {
+        microphone?: ControlSettings;
+        camera?: ControlSettings;
+        screenshare?: ControlSettings;
+    };
+    logo?: {
+        text?: string;
+        size?: 'small' | 'medium' | 'large';
+    };
+    showMenuButton?: boolean;
+    GDPRDisclaimer?: {
+        enabled: boolean;
+        text: string;
+        closeText: string;
+    };
+    streamApiURL?: string;
+    apiUrl?: string;
+    tracking?: boolean;
+    language?: string;
+}
+interface StreamUIInitOptions extends StreamUIBaseOptions {
+    element: HTMLElement;
+}
+declare global {
+    interface Window {
+        streamUI: StreamUIMethods;
+        snapcallAPI: {
+            endCall: typeof streamerClient.endCall;
+            terminateRoom: typeof streamerClient.terminateRoom;
+            generateToken: typeof streamerClient.generateToken;
+            setDisplayName: typeof streamerClient.setDisplayName;
+        };
+    }
+    interface MediaSession {
+        setMicrophoneActive?: (active: boolean) => void;
+        setCameraActive?: (active: boolean) => void;
+        setActionHandler(action: MediaSessionAction | 'togglemicrophone' | 'togglecamera' | 'hangup', handler: MediaSessionActionHandler | null): void;
+    }
+    interface WindowEventMap {
+        streamUISetExtraSettingsOptions: CustomEvent;
+    }
+}
+declare global {
+    interface Window {
+        onYouTubeIframeAPIReady: () => void;
+        YT?: {
+            loaded?: boolean;
+        };
+    }
+}
+export const streamUI: StreamUIMethods;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snapcall/stream-ui",
-  "version": "1.25.0",
+  "version": "1.25.1",
   "description": "",
   "source": "src/index.tsx",
   "main": "dist/stream-ui.js",
@@ -39,9 +39,9 @@
     "dev": "npm run serve",
     "serve": "APP_ENV=local parcel serve --https --host 0.0.0.0 --target html",
     "build": "parcel build",
-    "build:npm": "parcel build --no-source-maps --target main --target module",
+    "build:npm": "parcel build --no-source-maps --target main --target module --target types",
     "build:s3": "parcel build --no-source-maps --target umd --target html",
-    "build:streamerClient": "parcel build --target streamerClient",
+    "build:streamerClient": "parcel build --target streamerClient --target types",
     "typecheck": "tsc --noEmit",
     "lint": "eslint src streamerClient --ext .ts,.tsx",
     "prettier": "prettier --check .",