@100mslive/hms-video-store 0.10.29-alpha.0 → 0.11.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2021 Tushar
+Copyright (c) 2023 100ms
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -44,12 +44,17 @@ object received is frozen, and it is not allowed to mutate it. You'll get an err
 if you try to mutate this data in any way. Immutability of the store is how we ensure
 it to be consistent and reflect the truth at any point of time.
 
+### Installation
+```
+yarn add @100mslive/hms-video-store
+```
+
 ### How To Use
 
 ```js
-const manager = new HMSReactiveStore();
-const hmsActions = manager.getHMSActions();
-const hmsStore = manager.getStore();
+const hms = new HMSReactiveStore();
+const hmsActions = hms.getHMSActions();
+const hmsStore = hms.getStore();
 
 const toggleAudio = () => {
     const isEnabled = hmsStore.getState(selectIsLocalAudioEnabled);
@@ -83,7 +88,7 @@ function join() {
     return <>
         {
             !isConnected &&
-            <Button onClick={hmsActions.join()}>Join</Button>
+            <Button onClick={() => hmsActions.join()}>Join</Button>
         }
     </>
 }
@@ -97,3 +102,5 @@ function join() {
 
 ### Store Graph
 ![Store State](images/store-graph.png)
+
+Refer to [docs](https://www.100ms.live/docs/javascript/v2/quickstart/javascript-quickstart) for more detailed guide

package/dist/{core/IHMSActions.d.ts → IHMSActions.d.ts}

@@ -1,6 +1,5 @@
-import { HLSTimedMetadata, HMSAudioPlugin, HMSAudioTrackSettings, HMSConfig, HMSLogLevel, HMSMediaStreamPlugin, HMSMidCallPreviewConfig, HMSPlaylistSettings, HMSPluginSupportResult, HMSPreferredSimulcastLayer, HMSPreviewConfig, HMSScreenShareConfig, HMSVideoPlugin, HMSVideoTrackSettings, TokenRequest, TokenRequestOptions } from '@100mslive/hms-video';
-import { HLSConfig, RTMPRecordingConfig } from './hmsSDKStore/sdkTypes';
-import { HMSChangeMultiTrackStateParams, HMSGenericTypes, HMSMessageID, HMSPeerID, HMSPeerListIterator, HMSPeerListIteratorOptions, HMSRoleName, HMSTrackID, HMSTrackSource, IHMSInteractivityCenter, IHMSPlaylistActions, IHMSSessionStoreActions } from './schema';
+import { HLSConfig, HLSTimedMetadata, HMSAudioPlugin, HMSAudioTrackSettings, HMSConfig, HMSInteractivityCenter as IHMSInteractivityCenter, HMSLogLevel, HMSMediaStreamPlugin, HMSMidCallPreviewConfig, HMSPlaylistSettings, HMSPluginSupportResult, HMSPreferredSimulcastLayer, HMSPreviewConfig, HMSScreenShareConfig, HMSVideoPlugin, HMSVideoTrackSettings, RTMPRecordingConfig, TokenRequest, TokenRequestOptions } from './internal';
+import { HMSChangeMultiTrackStateParams, HMSGenericTypes, HMSMessageID, HMSPeerID, HMSPeerListIterator, HMSPeerListIteratorOptions, HMSRoleName, HMSTrackID, HMSTrackSource, IHMSPlaylistActions, IHMSSessionStoreActions } from './schema';
 import { HMSRoleChangeRequest } from './selectors';
 /**
  * The below interface defines our SDK API Surface for taking room related actions.

package/dist/{core/IHMSStore.d.ts → IHMSStore.d.ts}

@@ -4,7 +4,7 @@
  * are exported as interfaces to include tsdoc comments with them.
  */
 import { State, StateSelector, StoreApi, Subscribe } from 'zustand/vanilla';
-import { NamedSetState } from './hmsSDKStore/internalTypes';
+import { NamedSetState } from './reactive-store/internalTypes';
 import { HMSGenericTypes, HMSStatsStore, HMSStore } from './schema';
 /**
  * HMS Reactive store can be used to subscribe to different parts of the store using selectors

package/dist/analytics/AdditionalAnalyticsProperties.d.ts

@@ -0,0 +1,23 @@
+import { TransportState } from '../transport/models/TransportState';
+declare type ConnectionType = 'bluetooth' | 'cellular' | 'ethernet' | 'mixed' | 'none' | 'other' | 'unknown' | 'wifi' | 'wimax';
+declare type EffectiveConnectionType = '2g' | '3g' | '4g' | 'slow-2g';
+interface NetworkInformation {
+    type: ConnectionType;
+    effectiveType: EffectiveConnectionType;
+    downlinkMax: number;
+    downlink: number;
+    rtt: number;
+}
+export interface AdditionalAnalyticsProperties {
+    bitrate?: {
+        publish?: number;
+        subscribe?: number;
+    };
+    network_info?: Partial<NetworkInformation>;
+    document_hidden?: boolean;
+    num_degraded_tracks?: number;
+    max_sub_bitrate?: number;
+    recent_pong_response_times: number[];
+    transport_state?: TransportState;
+}
+export {};

package/dist/analytics/AnalyticsEvent.d.ts

@@ -0,0 +1,49 @@
+import { AnalyticsEventLevel } from './AnalyticsEventLevel';
+import { ISignalParamsProvider } from '../signal/ISignalSendParamsProvider';
+interface AnalyticsEventInit {
+    name: string;
+    level: AnalyticsEventLevel;
+    includesPII?: boolean;
+    properties?: Record<string, any>;
+    timestamp?: number;
+}
+interface SignalEventParams {
+    name: string;
+    info: any;
+    timestamp: number;
+}
+export default class AnalyticsEvent implements ISignalParamsProvider<SignalEventParams> {
+    name: string;
+    level: AnalyticsEventLevel;
+    includesPII: boolean;
+    properties: Record<string, any>;
+    metadata: {
+        token?: string;
+        peer: {
+            peer_id?: string;
+            session_id?: string;
+            room_id?: string;
+            role?: string;
+            room_name?: string;
+            joined_at?: number;
+            template_id?: string;
+            session_started_at?: number;
+            user_name?: string;
+            user_data?: string;
+        };
+        userAgent: string;
+    };
+    timestamp: number;
+    event_id: string;
+    device_id: string;
+    constructor({ name, level, properties, includesPII, timestamp }: AnalyticsEventInit);
+    toSignalParams(): {
+        name: string;
+        info: {
+            timestamp: number;
+            domain: import("./AnalyticsEventDomains").DomainCategory;
+        };
+        timestamp: number;
+    };
+}
+export {};

package/dist/analytics/AnalyticsEventDomains.d.ts

@@ -0,0 +1,5 @@
+export declare enum DomainCategory {
+    CUSTOM = "CUSTOM",
+    LOCAL = "LOCAL",
+    HMS = "HMS"
+}

package/dist/analytics/AnalyticsEventFactory.d.ts

@@ -0,0 +1,71 @@
+import { PublishAnalyticPayload, SubscribeAnalyticPayload } from './stats/interfaces';
+import { AdditionalAnalyticsProperties } from './AdditionalAnalyticsProperties';
+import AnalyticsEvent from './AnalyticsEvent';
+import { IAnalyticsPropertiesProvider } from './IAnalyticsPropertiesProvider';
+import { HMSException } from '../error/HMSException';
+import { DeviceMap, SelectedDevices } from '../interfaces';
+import { HMSTrackSettings } from '../media/settings/HMSTrackSettings';
+import { HMSRemoteVideoTrack } from '../media/tracks/HMSRemoteVideoTrack';
+export default class AnalyticsEventFactory {
+    private static KEY_REQUESTED_AT;
+    private static KEY_RESPONDED_AT;
+    static connect(error?: Error, additionalProperties?: AdditionalAnalyticsProperties, requestedAt?: Date, respondedAt?: Date, endpoint?: string): AnalyticsEvent;
+    static disconnect(error?: Error, additionalProperties?: AdditionalAnalyticsProperties): AnalyticsEvent;
+    static preview({ error, ...props }: {
+        error?: Error;
+        time?: number;
+        init_response_time?: number;
+        ws_connect_time?: number;
+        on_policy_change_time?: number;
+        local_audio_track_time?: number;
+        local_video_track_time?: number;
+    }): AnalyticsEvent;
+    static join({ error, ...props }: {
+        error?: Error;
+        is_preview_called?: boolean;
+        start?: Date;
+        end?: Date;
+        time?: number;
+        init_response_time?: number;
+        ws_connect_time?: number;
+        on_policy_change_time?: number;
+        local_audio_track_time?: number;
+        local_video_track_time?: number;
+        retries_join?: number;
+    }): AnalyticsEvent;
+    static publish({ devices, settings, error }: {
+        devices?: DeviceMap;
+        settings?: HMSTrackSettings;
+        error?: Error;
+    }): AnalyticsEvent;
+    static hlsPlayerError(error: HMSException): AnalyticsEvent;
+    static subscribeFail(error: Error): AnalyticsEvent;
+    static leave(): AnalyticsEvent;
+    static autoplayError(): AnalyticsEvent;
+    static audioPlaybackError(error: HMSException): AnalyticsEvent;
+    static deviceChange({ selection, type, devices, error, }: {
+        selection: Partial<SelectedDevices>;
+        type?: 'change' | 'list' | 'audioInput' | 'audioOutput' | 'video';
+        devices: DeviceMap;
+        error?: Error;
+    }): AnalyticsEvent;
+    static performance(stats: IAnalyticsPropertiesProvider): AnalyticsEvent;
+    static rtcStats(stats: IAnalyticsPropertiesProvider): AnalyticsEvent;
+    static rtcStatsFailed(error: HMSException): AnalyticsEvent;
+    /**
+     * TODO: remove once everything is switched to server side degradation, this
+     * event can be handled on server side as well.
+     */
+    static degradationStats(track: HMSRemoteVideoTrack, isDegraded: boolean): AnalyticsEvent;
+    static audioDetectionFail(error: Error, device?: MediaDeviceInfo): AnalyticsEvent;
+    static previewNetworkQuality(properties: {
+        downLink?: string;
+        score?: number;
+        error?: string;
+    }): AnalyticsEvent;
+    static publishStats(properties: PublishAnalyticPayload): AnalyticsEvent;
+    static subscribeStats(properties: SubscribeAnalyticPayload): AnalyticsEvent;
+    private static eventNameFor;
+    private static getPropertiesWithError;
+    private static getErrorProperties;
+}

package/dist/analytics/AnalyticsEventLevel.d.ts

@@ -0,0 +1,12 @@
+export declare enum HMSAnalyticsLevel {
+    VERBOSE = 0,
+    INFO = 1,
+    ERROR = 2,
+    OFF = 3
+}
+export declare enum AnalyticsEventLevel {
+    VERBOSE = 0,
+    INFO = 1,
+    ERROR = 2,
+    OFF = 3
+}

package/dist/analytics/AnalyticsEventsService.d.ts

@@ -0,0 +1,19 @@
+import AnalyticsEvent from './AnalyticsEvent';
+import { HMSAnalyticsLevel } from './AnalyticsEventLevel';
+import { AnalyticsTransport } from './AnalyticsTransport';
+import { Store } from '../sdk/store';
+export declare class AnalyticsEventsService {
+    private store;
+    private bufferSize;
+    private readonly TAG;
+    private transport;
+    private pendingEvents;
+    level: HMSAnalyticsLevel;
+    constructor(store: Store);
+    setTransport(transport: AnalyticsTransport): void;
+    reset(): void;
+    queue(event: AnalyticsEvent): this;
+    flushFailedClientEvents(): void;
+    flush(): void;
+    private sendClientEventOnHTTP;
+}

package/dist/analytics/AnalyticsTimer.d.ts

@@ -0,0 +1,22 @@
+export declare type TimedEventName = 'init' | 'websocket-open' | 'on-policy-change' | 'local-tracks' | 'preview' | 'join';
+export declare enum TimedEvent {
+    INIT = "init_response_time",
+    WEBSOCKET_CONNECT = "ws_connect_time",
+    ON_POLICY_CHANGE = "on_policy_change_time",
+    LOCAL_AUDIO_TRACK = "local_audio_track_time",
+    LOCAL_VIDEO_TRACK = "local_video_track_time",
+    JOIN = "join_time",
+    PREVIEW = "preview_time",
+    PEER_LIST = "peer_list_time",
+    ROOM_STATE = "room_state_time",
+    JOIN_RESPONSE = "join_response_time",
+    GET_TOKEN = "GET_TOKEN"
+}
+export declare class AnalyticsTimer {
+    private eventPerformanceMeasures;
+    start(eventName: TimedEvent): void;
+    end(eventName: TimedEvent): void;
+    getTimeTaken(eventName: TimedEvent): number | undefined;
+    getTimes(...eventNames: TimedEvent[]): {};
+    cleanup(): void;
+}

package/dist/analytics/AnalyticsTransport.d.ts

@@ -0,0 +1,11 @@
+import AnalyticsEvent from './AnalyticsEvent';
+import { IAnalyticsTransportProvider } from './IAnalyticsTransportProvider';
+import { Queue } from '../utils/queue';
+export declare abstract class AnalyticsTransport {
+    abstract transportProvider: IAnalyticsTransportProvider;
+    abstract failedEvents: Queue<AnalyticsEvent>;
+    private readonly TAG;
+    sendEvent(event: AnalyticsEvent): void;
+    flushFailedEvents(currentPeerId?: string): void;
+    private sendSingleEvent;
+}

package/dist/analytics/HTTPAnalyticsTransport.d.ts

@@ -0,0 +1,18 @@
+import AnalyticsEvent from './AnalyticsEvent';
+import { IAnalyticsTransportProvider } from './IAnalyticsTransportProvider';
+import { ENV } from '../utils/support';
+declare class ClientAnalyticsTransport implements IAnalyticsTransportProvider {
+    readonly TAG = "[HTTPAnalyticsTransport]";
+    private failedEvents;
+    isConnected: boolean;
+    private env;
+    private websocketURL;
+    setEnv(env: ENV): void;
+    setWebsocketEndpoint(ws: string): void;
+    sendEvent(event: AnalyticsEvent): void;
+    flushFailedEvents(): void;
+    private addEventToStorage;
+    private removeFromStorage;
+}
+export declare const HTTPAnalyticsTransport: ClientAnalyticsTransport;
+export {};

package/dist/analytics/IAnalyticsPropertiesProvider.d.ts

@@ -0,0 +1,4 @@
+import AnalyticsEvent from './AnalyticsEvent';
+export interface IAnalyticsPropertiesProvider {
+    toAnalyticsProperties: () => AnalyticsEvent['properties'];
+}

package/dist/analytics/IAnalyticsTransportProvider.d.ts

@@ -0,0 +1,6 @@
+import AnalyticsEvent from './AnalyticsEvent';
+export interface IAnalyticsTransportProvider {
+    readonly TAG: string;
+    isConnected: boolean;
+    sendEvent: (event: AnalyticsEvent) => void;
+}

package/dist/analytics/MediaPluginsAnalyticsFactory.d.ts

@@ -0,0 +1,21 @@
+import AnalyticsEvent from './AnalyticsEvent';
+import { HMSException } from '../error/HMSException';
+export default class MediaPluginsAnalyticsFactory {
+    static failure(pluginName: string, error: HMSException): AnalyticsEvent;
+    static audioPluginFailure(pluginName: string, sampleRate: number, error: HMSException): AnalyticsEvent;
+    static audioPluginStats({ pluginName, duration, loadTime, sampleRate, }: {
+        pluginName: string;
+        duration: number;
+        loadTime: number;
+        sampleRate: number;
+    }): AnalyticsEvent;
+    static stats({ pluginName, duration, loadTime, avgPreProcessingTime, avgProcessingTime, inputFrameRate, pluginFrameRate, }: {
+        pluginName: string;
+        duration: number;
+        loadTime: number;
+        avgPreProcessingTime: number;
+        avgProcessingTime: number;
+        inputFrameRate: number;
+        pluginFrameRate: number;
+    }): AnalyticsEvent;
+}

package/dist/analytics/domain-analytics.d.ts

@@ -0,0 +1,2 @@
+import { DomainCategory } from './AnalyticsEventDomains';
+export declare const domainCategory: DomainCategory;

package/dist/analytics/signal-transport/LocalStoageEvents.d.ts

@@ -0,0 +1,9 @@
+import { Queue } from '../../utils/queue';
+import AnalyticsEvent from '../AnalyticsEvent';
+export declare class LocalStorageEvents extends Queue<AnalyticsEvent> {
+    private localStorage;
+    constructor();
+    enqueue(event: AnalyticsEvent): void;
+    dequeue(): AnalyticsEvent | undefined;
+    private initLocalStorageQueue;
+}

package/dist/analytics/signal-transport/SignalAnalyticsTransport.d.ts

@@ -0,0 +1,8 @@
+import { LocalStorageEvents } from './LocalStoageEvents';
+import JsonRpcSignal from '../../signal/jsonrpc';
+import { AnalyticsTransport } from '../AnalyticsTransport';
+export declare class SignalAnalyticsTransport extends AnalyticsTransport {
+    transportProvider: JsonRpcSignal;
+    failedEvents: LocalStorageEvents;
+    constructor(transportProvider: JsonRpcSignal);
+}

package/dist/analytics/stats/BaseStatsAnalytics.d.ts

@@ -0,0 +1,56 @@
+import { LocalAudioTrackAnalytics, LocalBaseSample, LocalVideoSample, LocalVideoTrackAnalytics, PublishAnalyticPayload, RemoteAudioSample, RemoteAudioTrackAnalytics, RemoteVideoSample, RemoteVideoTrackAnalytics, SubscribeAnalyticPayload } from './interfaces';
+import { EventBus } from '../../events/EventBus';
+import { HMSTrackStats } from '../../interfaces';
+import { HMSTrack } from '../../internal';
+import { HMSWebrtcStats } from '../../rtc-stats';
+import { Store } from '../../sdk/store';
+export declare abstract class BaseStatsAnalytics {
+    protected store: Store;
+    protected eventBus: EventBus;
+    protected readonly sampleWindowSize: number;
+    protected readonly pushInterval: number;
+    private shouldSendEvent;
+    protected sequenceNum: number;
+    constructor(store: Store, eventBus: EventBus, sampleWindowSize: number, pushInterval: number);
+    start(): void;
+    stop: () => void;
+    private startLoop;
+    protected abstract sendEvent(): void;
+    protected abstract toAnalytics(): PublishAnalyticPayload | SubscribeAnalyticPayload;
+    protected abstract handleStatsUpdate(hmsStats: HMSWebrtcStats): void;
+}
+declare type TempPublishStats = HMSTrackStats & {
+    availableOutgoingBitrate?: number;
+};
+export declare abstract class RunningTrackAnalytics {
+    readonly sampleWindowSize: number;
+    track: HMSTrack;
+    track_id: string;
+    source: string;
+    ssrc: string;
+    kind: string;
+    rid?: string;
+    samples: (LocalBaseSample | LocalVideoSample | RemoteAudioSample | RemoteVideoSample)[];
+    protected tempStats: TempPublishStats[];
+    constructor({ track, ssrc, rid, kind, sampleWindowSize, }: {
+        track: HMSTrack;
+        ssrc: string;
+        kind: string;
+        rid?: string;
+        sampleWindowSize: number;
+    });
+    push(stat: TempPublishStats): void;
+    protected abstract toAnalytics: () => LocalAudioTrackAnalytics | LocalVideoTrackAnalytics | RemoteAudioTrackAnalytics | RemoteVideoTrackAnalytics;
+    protected abstract createSample: () => LocalBaseSample | LocalVideoSample | RemoteAudioSample | RemoteVideoSample;
+    protected getLatestStat(): TempPublishStats;
+    protected getFirstStat(): TempPublishStats;
+    protected abstract shouldCreateSample: () => boolean;
+    protected calculateSum(key: keyof TempPublishStats): number | undefined;
+    protected calculateAverage(key: keyof TempPublishStats, round?: boolean): number | undefined;
+    protected calculateDifferenceForSample(key: keyof TempPublishStats): number;
+    protected calculateInstancesOfHigh(key: keyof TempPublishStats, threshold: number): number | undefined;
+}
+export declare const hasResolutionChanged: (newStat: TempPublishStats, prevStat: TempPublishStats) => boolean;
+export declare const hasEnabledStateChanged: (newStat: TempPublishStats, prevStat: TempPublishStats) => boolean;
+export declare const removeUndefinedFromObject: <T extends Record<string, any>>(data: T) => T;
+export {};

package/dist/analytics/stats/PublishStatsAnalytics.d.ts

@@ -0,0 +1,17 @@
+import { BaseStatsAnalytics, RunningTrackAnalytics } from './BaseStatsAnalytics';
+import { LocalAudioTrackAnalytics, LocalBaseSample, LocalVideoSample, LocalVideoTrackAnalytics, PublishAnalyticPayload } from './interfaces';
+import { HMSWebrtcStats } from '../../rtc-stats';
+export declare class PublishStatsAnalytics extends BaseStatsAnalytics {
+    protected trackAnalytics: Map<string, RunningLocalTrackAnalytics>;
+    protected toAnalytics(): PublishAnalyticPayload;
+    protected sendEvent(): void;
+    protected handleStatsUpdate(hmsStats: HMSWebrtcStats): void;
+    private getTrackIdentifier;
+}
+declare class RunningLocalTrackAnalytics extends RunningTrackAnalytics {
+    samples: (LocalBaseSample | LocalVideoSample)[];
+    protected createSample: () => LocalBaseSample | LocalVideoSample;
+    protected shouldCreateSample: () => boolean;
+    toAnalytics: () => LocalAudioTrackAnalytics | LocalVideoTrackAnalytics;
+}
+export {};

package/dist/analytics/stats/SubscribeStatsAnalytics.d.ts

@@ -0,0 +1,16 @@
+import { BaseStatsAnalytics, RunningTrackAnalytics } from './BaseStatsAnalytics';
+import { RemoteAudioSample, RemoteAudioTrackAnalytics, RemoteVideoSample, RemoteVideoTrackAnalytics, SubscribeAnalyticPayload } from './interfaces';
+import { HMSWebrtcStats } from '../../rtc-stats';
+export declare class SubscribeStatsAnalytics extends BaseStatsAnalytics {
+    protected trackAnalytics: Map<string, RunningRemoteTrackAnalytics>;
+    protected toAnalytics(): SubscribeAnalyticPayload;
+    protected sendEvent(): void;
+    protected handleStatsUpdate(hmsStats: HMSWebrtcStats): void;
+}
+declare class RunningRemoteTrackAnalytics extends RunningTrackAnalytics {
+    samples: (RemoteAudioSample | RemoteVideoSample)[];
+    protected createSample: () => RemoteAudioSample | RemoteVideoSample;
+    protected shouldCreateSample: () => boolean;
+    toAnalytics: () => RemoteAudioTrackAnalytics | RemoteVideoTrackAnalytics;
+}
+export {};

package/dist/analytics/stats/index.d.ts

@@ -0,0 +1,3 @@
+export * from './interfaces';
+export { PublishStatsAnalytics } from './PublishStatsAnalytics';
+export { SubscribeStatsAnalytics } from './SubscribeStatsAnalytics';

package/dist/analytics/stats/interfaces.d.ts

@@ -0,0 +1,76 @@
+interface BaseStatsPayload {
+    sequence_num: number;
+    max_window_sec: number;
+    joined_at: number;
+}
+export interface PublishAnalyticPayload extends BaseStatsPayload {
+    video: Array<LocalAudioTrackAnalytics>;
+    audio: Array<LocalAudioTrackAnalytics>;
+}
+export interface SubscribeAnalyticPayload extends BaseStatsPayload {
+    video: Array<RemoteVideoTrackAnalytics>;
+    audio: Array<RemoteAudioTrackAnalytics>;
+}
+interface TrackAnalytics<Sample> {
+    track_id: string;
+    rid?: string;
+    ssrc: string;
+    source: string;
+    samples: Array<Sample>;
+}
+export declare type LocalAudioTrackAnalytics = TrackAnalytics<LocalBaseSample>;
+export declare type LocalVideoTrackAnalytics = TrackAnalytics<LocalVideoSample>;
+export declare type RemoteAudioTrackAnalytics = TrackAnalytics<RemoteAudioSample>;
+export declare type RemoteVideoTrackAnalytics = TrackAnalytics<RemoteVideoSample>;
+export interface LocalBaseSample {
+    timestamp: number;
+    avg_round_trip_time_ms?: number;
+    avg_jitter_ms?: number;
+    total_packets_lost?: number;
+    avg_bitrate_bps?: number;
+    avg_available_outgoing_bitrate_bps?: number;
+    total_packets_sent?: number;
+    total_packet_sent_delay_sec?: number;
+    total_nack_count?: number;
+    total_fir_count?: number;
+    total_pli_count?: number;
+}
+export interface LocalVideoSample extends LocalBaseSample {
+    total_quality_limitation?: QualityLimitation;
+    avg_fps?: number;
+    resolution?: Resolution;
+}
+export interface QualityLimitation {
+    bandwith_sec?: number;
+    cpu_sec?: number;
+    other_sec?: number;
+}
+export interface Resolution {
+    width_px?: number;
+    height_px?: number;
+}
+interface RemoteBaseSample {
+    timestamp: number;
+    estimated_playout_timestamp?: number;
+}
+export interface RemoteAudioSample extends RemoteBaseSample {
+    audio_level?: number;
+    audio_concealed_samples?: number;
+    audio_total_samples_received?: number;
+    audio_concealment_events?: number;
+    fec_packets_discarded?: number;
+    fec_packets_received?: number;
+    total_samples_duration?: number;
+    total_packets_received?: number;
+    total_packets_lost?: number;
+    jitter_buffer_delay?: number;
+    jitter_buffer_delay_high_seconds?: number;
+}
+export interface RemoteVideoSample extends RemoteBaseSample {
+    avg_frames_received_per_sec?: number;
+    avg_frames_dropped_per_sec?: number;
+    avg_frames_decoded_per_sec?: number;
+    total_pli_count?: number;
+    total_nack_count?: number;
+}
+export {};

package/dist/audio-sink-manager/AudioSinkManager.d.ts

@@ -0,0 +1,45 @@
+import { DeviceManager } from '../device-manager';
+import { EventBus } from '../events/EventBus';
+import { HMSUpdateListener } from '../interfaces';
+import { Store } from '../sdk/store';
+export declare class AudioSinkManager {
+    private store;
+    private deviceManager;
+    private eventBus;
+    private audioSink?;
+    private autoPausedTracks;
+    private readonly TAG;
+    private volume;
+    private state;
+    private listener?;
+    constructor(store: Store, deviceManager: DeviceManager, eventBus: EventBus);
+    setListener(listener?: HMSUpdateListener): void;
+    private get outputDevice();
+    getVolume(): number;
+    setVolume(value: number): Promise<void>;
+    /**
+     *  This function is to be called only on user interaction when
+     *  autoplay error is received.
+     */
+    unblockAutoplay(): Promise<void>;
+    init(elementId?: string): void;
+    cleanup(): void;
+    private handleAudioPaused;
+    private handleTrackUpdate;
+    private handleTrackAdd;
+    private handleAutoplayError;
+    private handleAudioDeviceChange;
+    /**
+     * try to play audio for the passed in track, assume autoplay error happened if play fails
+     * @param track
+     * @private
+     */
+    private playAudioFor;
+    private handleTrackRemove;
+    private unpauseAudioTracks;
+    private removeAudioElement;
+    /**
+     * Mweb is not able to play via call channel by default, this is to switch from media channel to call channel
+     */
+    private autoSelectAudioOutput;
+}

package/dist/audio-sink-manager/index.d.ts

@@ -0,0 +1 @@
+export { AudioSinkManager } from './AudioSinkManager';

package/dist/common/ui-logger.d.ts

@@ -1,4 +1,4 @@
-import { HMSLogLevel } from '../core/hmsSDKStore/sdkTypes';
+import { HMSLogLevel } from '../internal';
 export declare class HMSLogger {
     static level: HMSLogLevel;
     static v(tag: string, ...data: any[]): void;

package/dist/connection/HMSConnection.d.ts

@@ -0,0 +1,44 @@
+import { HMSConnectionRole } from './model';
+import { HMSLocalTrack } from '../media/tracks';
+import { TrackState } from '../notification-manager';
+import JsonRpcSignal from '../signal/jsonrpc';
+interface RTCIceCandidatePair {
+    local: RTCIceCandidate;
+    remote: RTCIceCandidate;
+}
+export default abstract class HMSConnection {
+    readonly role: HMSConnectionRole;
+    protected readonly signal: JsonRpcSignal;
+    abstract readonly nativeConnection: RTCPeerConnection;
+    /**
+     * We keep a list of pending IceCandidates received
+     * from the signalling server. When the peer-connection
+     * is initialized we call [addIceCandidate] for each.
+     *
+     * WARN:
+     *  - [HMSPublishConnection] keeps the complete list of candidates (for
+     *      ice-connection failed/disconnect) forever.
+     *  - [HMSSubscribeConnection] clears this list as soon as we call [addIceCandidate]
+     */
+    readonly candidates: RTCIceCandidateInit[];
+    selectedCandidatePair?: RTCIceCandidatePair;
+    protected constructor(role: HMSConnectionRole, signal: JsonRpcSignal);
+    get iceConnectionState(): RTCIceConnectionState;
+    get connectionState(): RTCPeerConnectionState;
+    private get action();
+    addTransceiver(track: MediaStreamTrack, init: RTCRtpTransceiverInit): RTCRtpTransceiver;
+    createOffer(tracks?: Map<string, TrackState>, options?: RTCOfferOptions): Promise<RTCSessionDescriptionInit>;
+    createAnswer(options?: RTCOfferOptions | undefined): Promise<RTCSessionDescriptionInit>;
+    setLocalDescription(description: RTCSessionDescriptionInit): Promise<void>;
+    setRemoteDescription(description: RTCSessionDescriptionInit): Promise<void>;
+    addIceCandidate(candidate: RTCIceCandidateInit): Promise<void>;
+    get remoteDescription(): RTCSessionDescription | null;
+    getSenders(): Array<RTCRtpSender>;
+    logSelectedIceCandidatePairs(): void;
+    removeTrack(sender: RTCRtpSender): void;
+    setMaxBitrateAndFramerate(track: HMSLocalTrack): Promise<void>;
+    getStats(): Promise<RTCStatsReport>;
+    close(): Promise<void>;
+    private getReceivers;
+}
+export {};