@100mslive/react-native-hms 2.0.0-alpha.0 → 2.0.0-alpha.1

package/lib/typescript/index.d.ts

@@ -22,6 +22,7 @@ export * from './classes/HMSRemoteAudioTrack';
 export * from './classes/HMSPublishSettings';
 export * from './classes/HMSPermissions';
 export * from './classes/HMSPeer';
+export * from './classes/HMSPeerType';
 export * from './classes/HMSLocalVideoTrack';
 export * from './classes/HMSLocalPeer';
 export * from './classes/HMSLocalAudioTrack';
@@ -80,12 +81,38 @@ export * from './classes/HMSQualityLimitationReasons';
 export * from './classes/HMSQualityLimitationReason';
 export * from './classes/HMSCameraControl';
 export * from './classes/HMSIOSAudioMode';
-export type { HMSSessionStore, HMSSessionStoreValue, } from './classes/HMSSessionStore';
+export * from './classes/HMSRecordingState';
+export * from './classes/HMSStreamingState';
+export * from './classes/HMSHLSPlaylistType';
+export type { HMSSessionStore, JsonArray, JsonMap, JsonPrimitive, JsonValue, } from './classes/HMSSessionStore';
 export type { HmsViewComponent as HMSView, HmsComponentProps as HMSViewProps, } from './classes/HmsView';
+export type { HMSPIPConfig } from './classes/HMSPIPConfig';
+export { HMSRecordingState } from './classes/HMSRecordingState';
+export type { HMSPoll } from './classes/polls/HMSPoll';
+export * from './classes/HMSNoiseCancellationPlugin';
+export * from './classes/whiteboard';
+export { HMSPollQuestionType } from './classes/polls/HMSPollQuestionType';
+export { HMSPollType } from './classes/polls/HMSPollType';
+export { HMSPollUserTrackingMode } from './classes/polls/HMSPollUserTrackingMode';
+export { HMSPollUpdateType } from './classes/polls/HMSPollUpdateType';
+export { HMSPollState } from './classes/polls/HMSPollState';
+export { HMSPollQuestion } from './classes/polls/HMSPollQuestion';
+export { HMSPollQuestionOption } from './classes/polls/HMSPollQuestionOption';
+export { HMSPollQuestionAnswer } from './classes/polls/HMSPollQuestionAnswer';
+export { HMSPollQuestionResponse } from './classes/polls/HMSPollQuestionResponse';
+export { PollLeaderboardResponse } from './classes/polls/PollLeaderboardResponse';
+export { HMSPollLeaderboardEntry } from './classes/polls/HMSPollLeaderboardEntry';
+export { HMSPollLeaderboardSummary } from './classes/polls/HMSPollLeaderboardSummary';
+export * from './classes/transcriptions';
 import { HMSSDK as HmsManager } from './classes/HMSSDK';
-export { default as HMSManagerModule } from './classes/HMSManagerModule';
+export { default as HMSManagerModule } from './modules/HMSManagerModule';
 export * from './components/HMSHLSPlayer';
 export * from './hooks/useHMSPeerUpdates';
+export { useHmsViewsResolutionsState } from './hooks/hmsviews';
+export type { NotificationResult } from './utils/notification';
+export { checkNotifications } from './utils/notification';
+export * from './utils/windowController';
+export * from './utils/keyboard';
 export * from './types';
 export * from './stores/types';
 export default HmsManager;

package/lib/typescript/specs/HMSHLSPlayerNativeComponent.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Fabric component spec for `<HMSHLSPlayer />`.
+ *
+ * Renders an HLS stream from the live room (host-published or recorded).
+ * Today's implementation lives in `ios/HMSHLSPlayerManager.swift` (paper)
+ * and `android/.../HMSHLSPlayerManager.kt` + `HMSHLSPlayer.kt` (paper).
+ * Phase 1 adds Fabric counterparts.
+ *
+ * This is the most surface-heavy component in the SDK:
+ *   - 3 props (`url`, `enableStats`, `enableControls`)
+ *   - 4 events (playback state, stats, request-response, captions)
+ *   - 13 imperative commands
+ *
+ * Like {@link HMSViewNativeComponent}, Fabric requires explicit prop and
+ * event payload shapes. For Phase 1 we use minimal shapes that capture
+ * essential fields (e.g. `requestId` for response events) and leave the
+ * rest loose. Phase 2 tightens.
+ */
+/// <reference types="react-native/types/modules/codegen" />
+import type * as React from 'react';
+import type { ViewProps, HostComponent } from 'react-native';
+import type { DirectEventHandler, Double, Int32, WithDefault } from 'react-native/Libraries/Types/CodegenTypes';
+/**
+ * Playback state-change event payload.
+ * Today's emitter in `HMSHLSPlayer.kt` / iOS counterpart sends an
+ * `eventType` plus a state-specific data object. Phase 2 will type the
+ * `data` field per state; Phase 1 carries it as a string blob.
+ */
+type OnHmsHlsPlaybackEventPayload = Readonly<{
+    event: string;
+    data: string;
+}>;
+/**
+ * Stats event payload (RTC-shape stats: bitrate, dropped frames, etc.).
+ * Carried as a stringified JSON blob for Phase 1; Phase 2 types it.
+ */
+type OnHmsHlsStatsEventPayload = Readonly<{
+    event: string;
+    data: string;
+}>;
+/**
+ * Response event for the request-style commands (`areClosedCaptionSupported`,
+ * `isClosedCaptionEnabled`, `getPlayerDurationDetails`). The JS-side
+ * matches the response to the in-flight Promise via `requestId`.
+ */
+type OnDataReturnedPayload = Readonly<{
+    requestId: Int32;
+    result?: string;
+    error?: string;
+}>;
+/**
+ * Closed-captions cue payload. Native-side fires a cue object with start
+ * time, end time, payload string, etc. Phase 1 keeps it as a stringified
+ * blob; Phase 2 will type it.
+ */
+type OnHlsPlayerCuesEventPayload = Readonly<{
+    event: string;
+    data: string;
+}>;
+export interface NativeProps extends ViewProps {
+    /** HLS stream URL to play. */
+    url?: string;
+    /** Emit periodic stats events via `onHmsHlsStatsEvent`. */
+    enableStats?: WithDefault<boolean, false>;
+    /** Show the native player's built-in controls UI overlay. */
+    enableControls?: WithDefault<boolean, false>;
+    /** Playback state changes (started/paused/buffering/ended/...). */
+    onHmsHlsPlaybackEvent?: DirectEventHandler<OnHmsHlsPlaybackEventPayload>;
+    /** Periodic stats (only fired when `enableStats=true`). */
+    onHmsHlsStatsEvent?: DirectEventHandler<OnHmsHlsStatsEventPayload>;
+    /** Response for request-style commands; matched by `requestId`. */
+    onDataReturned?: DirectEventHandler<OnDataReturnedPayload>;
+    /** Closed-captions cue events. */
+    onHlsPlayerCuesEvent?: DirectEventHandler<OnHlsPlayerCuesEventPayload>;
+}
+export interface NativeCommands {
+    /** Start playing. Pass `''` (empty string) to reuse the URL prop. */
+    play: (viewRef: React.ElementRef<HostComponent<NativeProps>>, url: string) => void;
+    /** Stop playback (releases the player). */
+    stop: (viewRef: React.ElementRef<HostComponent<NativeProps>>) => void;
+    /** Pause playback (player remains allocated). */
+    pause: (viewRef: React.ElementRef<HostComponent<NativeProps>>) => void;
+    /** Resume from paused state. */
+    resume: (viewRef: React.ElementRef<HostComponent<NativeProps>>) => void;
+    /** Jump to the live edge (DVR HLS only). */
+    seekToLivePosition: (viewRef: React.ElementRef<HostComponent<NativeProps>>) => void;
+    /** Seek `seconds` ahead from current position. */
+    seekForward: (viewRef: React.ElementRef<HostComponent<NativeProps>>, seconds: Double) => void;
+    /** Seek `seconds` back from current position. */
+    seekBackward: (viewRef: React.ElementRef<HostComponent<NativeProps>>, seconds: Double) => void;
+    /** Set volume `0–100` (integer). */
+    setVolume: (viewRef: React.ElementRef<HostComponent<NativeProps>>, level: Int32) => void;
+    /**
+     * Query whether the stream supports closed captions. Response via
+     * `onDataReturned` matched by `requestId`.
+     */
+    areClosedCaptionSupported: (viewRef: React.ElementRef<HostComponent<NativeProps>>, requestId: Int32) => void;
+    /**
+     * Query whether closed captions are currently enabled. Response via
+     * `onDataReturned` matched by `requestId`.
+     */
+    isClosedCaptionEnabled: (viewRef: React.ElementRef<HostComponent<NativeProps>>, requestId: Int32) => void;
+    /** Enable closed captions display. */
+    enableClosedCaption: (viewRef: React.ElementRef<HostComponent<NativeProps>>) => void;
+    /** Disable closed captions display. */
+    disableClosedCaption: (viewRef: React.ElementRef<HostComponent<NativeProps>>) => void;
+    /**
+     * Get current player duration details (currentTime, duration, live).
+     * Response via `onDataReturned` matched by `requestId`.
+     */
+    getPlayerDurationDetails: (viewRef: React.ElementRef<HostComponent<NativeProps>>, requestId: Int32) => void;
+}
+export declare const Commands: NativeCommands;
+declare const _default: import("react-native/Libraries/Utilities/codegenNativeComponent").NativeComponentType<NativeProps>;
+export default _default;

package/lib/typescript/specs/HMSViewNativeComponent.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Fabric component spec for `<HMSView />` — the native video tile.
+ *
+ * Used to render an `HMSVideoTrack` inside a React Native view tree.
+ * Today's implementation lives in `ios/HMSView.swift` (paper) and
+ * `android/.../HMSSDKViewManager.kt` + `HMSView.kt` (paper). Phase 1
+ * adds Fabric counterparts (`ios/HMSViewComponentView.mm`,
+ * `android/.../HMSSDKViewManager.kt` reworked to implement the generated
+ * `HMSViewManagerInterface`).
+ *
+ * Note: Fabric component specs require explicit prop and event payload
+ * shapes — Codegen does NOT accept `Object` for view props/events the
+ * way it does for TurboModule method payloads. The shapes below are
+ * narrow and well-known, so this isn't the same scaling problem as the
+ * TurboModule's 99-method surface.
+ *
+ * Surface authored: 4 props + 1 imperative command (`capture`) +
+ * 2 events (`onChange` for resolution updates, `onDataReturned` for
+ * capture command responses).
+ */
+/// <reference types="react-native/types/modules/codegen" />
+import type * as React from 'react';
+import type { ViewProps, HostComponent } from 'react-native';
+import type { DirectEventHandler, Int32, WithDefault } from 'react-native/Libraries/Types/CodegenTypes';
+/**
+ * Bag of identifiers passed to the native view to wire it up to a track.
+ * Mirrors the shape constructed in `src/classes/HmsView.tsx`.
+ */
+type DataProp = Readonly<{
+    trackId: string;
+    id: string;
+    mirror: boolean;
+    scaleType: string;
+}>;
+/**
+ * Emitted when the video stream's resolution changes (e.g. simulcast
+ * layer switch). Native fires `topChange`; the JS-side dispatches as
+ * `onChange`. Used to drive Android view-sizing in `HmsView.tsx`.
+ */
+type OnChangeEvent = Readonly<{
+    event: string;
+    data: Readonly<{
+        height: Int32;
+        width: Int32;
+    }>;
+}>;
+/**
+ * Emitted in response to the `capture` imperative command. Carries the
+ * requestId from JS and either a base64 result or an error tuple.
+ */
+type OnDataReturnedEvent = Readonly<{
+    requestId: Int32;
+    result?: string;
+    error?: string;
+}>;
+export interface NativeProps extends ViewProps {
+    /** Track identifier bag. See {@link DataProp}. */
+    data?: DataProp;
+    /**
+     * Enable automatic simulcast layer switching based on network
+     * conditions. iOS-side default in `HMSView.swift` is true.
+     */
+    autoSimulcast?: WithDefault<boolean, true>;
+    /**
+     * How the video fits within the view. Values defined in
+     * `src/classes/HMSVideoViewMode.ts` (ASPECT_FIT, ASPECT_FILL,
+     * ASPECT_BALANCED).
+     */
+    scaleType?: WithDefault<string, 'ASPECT_FILL'>;
+    /**
+     * Render the video above the regular view hierarchy.
+     * Platform: Android only — iOS view manager does not implement this.
+     */
+    setZOrderMediaOverlay?: WithDefault<boolean, false>;
+    /**
+     * Resolution-change events. Renamed from `onChange` to avoid colliding with
+     * RN's built-in `topChange` internal event (registered as bubbling on every
+     * RCTView), which triggers "Event cannot be both direct and bubbling".
+     */
+    onResolutionChange?: DirectEventHandler<OnChangeEvent>;
+    /** Capture command response (success or error). */
+    onDataReturned?: DirectEventHandler<OnDataReturnedEvent>;
+}
+/**
+ * Imperative commands callable on a `<HMSView />` ref.
+ */
+export interface NativeCommands {
+    /**
+     * Capture a snapshot of the current video frame. The result (or
+     * error) is delivered asynchronously via the `onDataReturned` event,
+     * matched to this call by `requestId`.
+     */
+    capture: (viewRef: React.ElementRef<HostComponent<NativeProps>>, requestId: Int32) => void;
+}
+export declare const Commands: NativeCommands;
+declare const _default: import("react-native/Libraries/Utilities/codegenNativeComponent").NativeComponentType<NativeProps>;
+export default _default;

package/lib/typescript/specs/NativeHMSManager.d.ts

@@ -0,0 +1,147 @@
+/**
+ * @100mslive/react-native-hms — TurboModule spec for HMSManager.
+ *
+ * This file is the source of truth for the JS↔native contract under
+ * React Native's New Architecture. At build time, RN's Codegen reads
+ * this spec and produces:
+ *
+ *   - iOS:     ios/build/.../NativeHMSManagerSpec.h (Obj-C++ protocol)
+ *   - Android: android/build/.../NativeHMSManagerSpec.java (abstract class)
+ *   - JS:      typed wrappers + JSI fast-path bindings
+ *
+ * Phase 1 of the New Architecture migration uses **Object-typed** payloads
+ * (every dictionary in/out is just `Object`) to preserve today's runtime
+ * behavior without designing 99 typed payload schemas upfront. Phase 2 will
+ * tighten types per API surface area (room/peer/track core first, then
+ * chat, polls, recording, etc.).
+ *
+ * Method count: 99 iOS (96 async + 3 sync), 98 Android (93 async + 5 sync).
+ * Event count: 28 unique events (24 cross-platform + 4 platform-specific).
+ *
+ * Cross-platform asymmetries are noted inline. See
+ * NEW_ARCHITECTURE_MIGRATION.md / 100ms-rn-new-arch-migration-plan.md.md
+ * for the full migration plan.
+ */
+import type { TurboModule } from 'react-native';
+import type { Int32 } from 'react-native/Libraries/Types/CodegenTypes';
+export interface Spec extends TurboModule {
+    addListener(eventName: string): void;
+    removeListeners(count: Int32): void;
+    build(data: Object): Promise<Object>;
+    destroy(data: Object): Promise<Object>;
+    preview(credentials: Object): void;
+    previewForRole(data: Object): Promise<Object>;
+    cancelPreview(data: Object): Promise<Object>;
+    join(credentials: Object): void;
+    leave(data: Object): Promise<Object>;
+    endRoom(data: Object): Promise<Object>;
+    setLocalMute(data: Object): void;
+    setLocalVideoMute(data: Object): void;
+    switchCamera(data: Object): void;
+    isMute(data: Object): Promise<Object>;
+    changeTrackState(data: Object): Promise<Object>;
+    changeTrackStateForRoles(data: Object): Promise<Object>;
+    setVolume(data: Object): Promise<Object>;
+    remoteMuteAllAudio(data: Object): Promise<Object>;
+    setPlaybackAllowed(data: Object): Promise<Object>;
+    isPlaybackAllowed(data: Object): Promise<Object>;
+    setPlaybackForAllAudio(mute: Object): Promise<Object>;
+    getRemoteVideoTrackFromTrackId(data: Object): Promise<Object>;
+    getRemoteAudioTrackFromTrackId(data: Object): Promise<Object>;
+    getVideoTrackLayer(data: Object): Promise<Object>;
+    getVideoTrackLayerDefinition(data: Object): Promise<Object>;
+    setVideoTrackLayer(data: Object): Promise<Object>;
+    captureImageAtMaxSupportedResolution(data: Object): Promise<Object>;
+    getLocalPeer(data: Object): Promise<Object>;
+    getRemotePeers(data: Object): Promise<Object>;
+    getRoles(data: Object): Promise<Object>;
+    getRoom(data: Object): Promise<Object>;
+    changeName(data: Object): Promise<Object>;
+    changeMetadata(data: Object): Promise<Object>;
+    changeRole(data: Object): Promise<Object>;
+    changeRoleOfPeer(data: Object): Promise<Object>;
+    changeRoleOfPeersWithRoles(data: Object): Promise<Object>;
+    acceptRoleChange(data: Object): Promise<Object>;
+    removePeer(data: Object): Promise<Object>;
+    raiseLocalPeerHand(data: Object): Promise<Object>;
+    lowerLocalPeerHand(data: Object): Promise<Object>;
+    lowerRemotePeerHand(data: Object): Promise<Object>;
+    peerListIteratorHasNext(data: Object): Promise<Object>;
+    peerListIteratorNext(data: Object): Promise<Object>;
+    sendBroadcastMessage(data: Object): Promise<Object>;
+    sendGroupMessage(data: Object): Promise<Object>;
+    sendDirectMessage(data: Object): Promise<Object>;
+    startRTMPOrRecording(data: Object): Promise<Object>;
+    stopRtmpAndRecording(data: Object): Promise<Object>;
+    startHLSStreaming(data: Object): Promise<Object>;
+    stopHLSStreaming(data: Object): Promise<Object>;
+    sendHLSTimedMetadata(data: Object): Promise<Object>;
+    startScreenshare(data: Object): Promise<Object>;
+    stopScreenshare(data: Object): Promise<Object>;
+    isScreenShared(data: Object): Promise<Object>;
+    playAudioShare(data: Object): Promise<Object>;
+    pauseAudioShare(data: Object): Promise<Object>;
+    resumeAudioShare(data: Object): Promise<Object>;
+    stopAudioShare(data: Object): Promise<Object>;
+    setAudioShareVolume(data: Object): Promise<Object>;
+    audioShareCurrentTime(data: Object): Promise<Object>;
+    audioShareDuration(data: Object): Promise<Object>;
+    audioShareIsPlaying(data: Object): Promise<Object>;
+    startAudioshare(data: Object): Promise<Object>;
+    stopAudioshare(data: Object): Promise<Object>;
+    isAudioShared(data: Object): Promise<Object>;
+    switchAudioOutput(data: Object): Promise<Object>;
+    switchAudioOutputUsingIOSUI(data: Object): Promise<Object>;
+    getAudioDevicesList(data: Object): Promise<Object>;
+    getAudioOutputRouteType(data: Object): Promise<Object>;
+    setAudioDeviceChangeListener(data: Object): void;
+    setAudioMode(data: Object): Promise<Object>;
+    setAudioMixingMode(data: Object): Promise<Object>;
+    getAudioMixingMode(data: Object): Promise<Object>;
+    getVolume(data: Object): Promise<Object>;
+    handlePipActions(action: string, data: Object): Promise<Object>;
+    setupPIP(data: Object): Promise<Object>;
+    stopPIP(data: Object): Promise<Object>;
+    disposePIP(data: Object): Promise<Object>;
+    isPIPActive(data: Object): Promise<Object>;
+    changeIOSPIPVideoTrack(data: Object): Promise<Object>;
+    setActiveSpeakerInIOSPIP(data: Object): Promise<Object>;
+    enableNetworkQualityUpdates(data: Object): void;
+    disableNetworkQualityUpdates(data: Object): void;
+    getSessionMetadataForKey(data: Object): Promise<Object>;
+    setSessionMetadataForKey(data: Object): Promise<Object>;
+    addKeyChangeListener(data: Object): Promise<Object>;
+    removeKeyChangeListener(data: Object): Promise<Object>;
+    quickStartPoll(data: Object): Promise<Object>;
+    addResponseOnPollQuestion(data: Object): Promise<Object>;
+    stopPoll(data: Object): Promise<Object>;
+    fetchLeaderboard(data: Object): Promise<Object>;
+    startWhiteboard(data: Object): Promise<Object>;
+    stopWhiteboard(data: Object): Promise<Object>;
+    handleRealTimeTranscription(data: Object): Promise<Object>;
+    enableNoiseCancellationPlugin(data: Object): Promise<Object>;
+    disableNoiseCancellationPlugin(data: Object): Promise<Object>;
+    isNoiseCancellationPluginEnabled(data: Object): Promise<Object>;
+    isNoiseCancellationPluginAvailable(data: Object): Promise<Object>;
+    enableVideoPlugin(data: Object): Promise<Object>;
+    disableVideoPlugin(data: Object): Promise<Object>;
+    changeVirtualBackground(data: Object): Promise<Object>;
+    setVideoFilterParameter(data: Object): Promise<Object>;
+    enableEvent(data: Object): Promise<Object>;
+    disableEvent(data: Object): Promise<Object>;
+    restrictData(data: Object): Promise<Object>;
+    getAuthTokenByRoomCode(data: Object): Promise<Object>;
+    getRoomLayout(data: Object): Promise<Object>;
+    setAlwaysScreenOn(data: Object): Promise<Object>;
+    hideSystemBars(): void;
+    showSystemBars(): void;
+    setPermissionsAccepted(data: Object): Promise<Object>;
+    checkNotifications(): Promise<Object>;
+    getPeerProperty(data: Object): Object;
+    getRoomProperty(data: Object): Object;
+    getPeerListIterator(data: Object): Object;
+    setSoftInputMode(inputMode: number): number;
+    getSoftInputMode(): number;
+}
+declare const _default: Spec;
+export default _default;

package/lib/typescript/stores/hls-player-stats-store.d.ts

@@ -1,7 +1,8 @@
-export declare const useHMSHLSPlayerStatsStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<import("./types").HMSHLSPlayerStatsSlice>, "subscribe"> & {
+import type { HMSHLSPlayerStatsStore } from './types';
+export declare const useHMSHLSPlayerStatsStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<HMSHLSPlayerStatsStore>, "subscribe"> & {
     subscribe: {
-        (listener: (selectedState: import("./types").HMSHLSPlayerStatsSlice, previousSelectedState: import("./types").HMSHLSPlayerStatsSlice) => void): () => void;
-        <U>(selector: (state: import("./types").HMSHLSPlayerStatsSlice) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+        (listener: (selectedState: HMSHLSPlayerStatsStore, previousSelectedState: HMSHLSPlayerStatsStore) => void): () => void;
+        <U>(selector: (state: HMSHLSPlayerStatsStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
             equalityFn?: ((a: U, b: U) => boolean) | undefined;
             fireImmediately?: boolean | undefined;
         } | undefined): () => void;

package/lib/typescript/stores/hms-interactivity-store.d.ts

@@ -0,0 +1,9 @@
+export declare const useHMSInteractivityStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<import("./types").HMSPollsSlice>, "subscribe"> & {
+    subscribe: {
+        (listener: (selectedState: import("./types").HMSPollsSlice, previousSelectedState: import("./types").HMSPollsSlice) => void): () => void;
+        <U>(selector: (state: import("./types").HMSPollsSlice) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+            equalityFn?: ((a: U, b: U) => boolean) | undefined;
+            fireImmediately?: boolean | undefined;
+        } | undefined): () => void;
+    };
+}>;

package/lib/typescript/stores/hms-polls-slice.d.ts

@@ -0,0 +1,5 @@
+import type { StateCreator } from 'zustand';
+import type { HMSInteractivityStore, HMSPollsSlice } from './types';
+export declare const createHMSPollsSlice: StateCreator<HMSInteractivityStore, [
+], [
+], HMSPollsSlice>;

package/lib/typescript/stores/hms-store.d.ts

@@ -1,7 +1,8 @@
-export declare const useHMSStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<import("./types").HMSHLSPlayerPlaybackSlice>, "subscribe"> & {
+import type { HMSStore } from './types';
+export declare const useHMSStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<HMSStore>, "subscribe"> & {
     subscribe: {
-        (listener: (selectedState: import("./types").HMSHLSPlayerPlaybackSlice, previousSelectedState: import("./types").HMSHLSPlayerPlaybackSlice) => void): () => void;
-        <U>(selector: (state: import("./types").HMSHLSPlayerPlaybackSlice) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+        (listener: (selectedState: HMSStore, previousSelectedState: HMSStore) => void): () => void;
+        <U>(selector: (state: HMSStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
             equalityFn?: ((a: U, b: U) => boolean) | undefined;
             fireImmediately?: boolean | undefined;
         } | undefined): () => void;

package/lib/typescript/stores/hmsviews-slice.d.ts

@@ -0,0 +1,5 @@
+import type { StateCreator } from 'zustand';
+import type { HMSViewsSlice, HMSStore } from './types';
+export declare const createHMSViewsSlice: StateCreator<HMSStore, [
+], [
+], HMSViewsSlice>;

package/lib/typescript/stores/types.d.ts

@@ -1,19 +1,34 @@
-import type { HMSHLSPlayerPlaybackState, HMSHLSPlayerPlaybackCueEventData, HMSHLSPlayerPlaybackFailureEventData, HMSHLSPlayerStatsErrorEventData, HMSHLSPlayerStatsUpdateEventData } from '../types';
-export type HMSStore = HMSHLSPlayerPlaybackSlice;
-export type HMSHLSPlayerStatsStore = HMSHLSPlayerStatsSlice;
+import type { HMSPoll } from '../classes/polls/HMSPoll';
+import type { HMSHLSPlayerPlaybackState, HMSHLSPlayerPlaybackCueEventData, HMSHLSPlayerPlaybackFailureEventData, HMSHLSPlayerPlaybackResolutionChangeEventData, HMSHLSPlayerStatsErrorEventData, HMSHLSPlayerStatsUpdateEventData } from '../types';
+export type HMSStore = HMSHLSPlayerPlaybackSlice & HMSViewsSlice;
+export type HMSHLSPlayerStatsStore = HMSHLSPlayerStatsSlice & HLSPlayerClosedCaptionsSlice;
+export type HMSInteractivityStore = HMSPollsSlice;
+export type TrackId = string;
+export type Resolution = {
+    width: number;
+    height: number;
+};
+export interface HMSViewsSlice {
+    hmsviewsResolutions: Record<TrackId, Resolution | undefined>;
+    setHmsviewsResolutions(trackId: TrackId, resolution: Resolution): void;
+}
 export interface HMSHLSPlayerPlaybackCue extends Omit<HMSHLSPlayerPlaybackCueEventData, 'endDate' | 'startDate'> {
     endDate?: Date;
     startDate: Date;
 }
 export type HMSHLSPlayerCue = HMSHLSPlayerPlaybackCue | undefined;
 export type HMSHLSPlayerPlaybackError = HMSHLSPlayerPlaybackFailureEventData['error'] | undefined;
+export type HMSHLSPlayerResolution = HMSHLSPlayerPlaybackResolutionChangeEventData | undefined;
 export interface HMSHLSPlayerPlaybackSlice {
     cue: HMSHLSPlayerCue;
     playbackState: HMSHLSPlayerPlaybackState;
+    resolution: HMSHLSPlayerResolution;
     error: HMSHLSPlayerPlaybackError;
     setCue(cue: HMSHLSPlayerPlaybackCue): void;
     setPlaybackState(playbackState: HMSHLSPlayerPlaybackState): void;
+    setResolution(resolution: HMSHLSPlayerResolution): void;
     setPlaybackError(error: HMSHLSPlayerPlaybackError): void;
+    resetPlaybackSlice(): void;
 }
 export type HMSHLSPlayerStats = HMSHLSPlayerStatsUpdateEventData;
 export type HMSHLSPlayerStatsError = HMSHLSPlayerStatsErrorEventData | undefined;
@@ -22,4 +37,13 @@ export interface HMSHLSPlayerStatsSlice {
     error: HMSHLSPlayerStatsError | undefined;
     changeStats(stats: HMSHLSPlayerStats): void;
     setError(error: HMSHLSPlayerStatsError): void;
+    reset(): void;
+}
+export interface HLSPlayerClosedCaptionsSlice {
+    subtitles: string | null;
+    setSubtitles(subtitles: string | null): void;
 }
+export type HMSPollsSlice = {
+    polls: Record<string, HMSPoll>;
+    setPolls(poll: HMSPoll): void;
+};

package/lib/typescript/types.d.ts

@@ -5,7 +5,8 @@ type HMSHLSPlayerEvent<T extends string, U> = {
 export declare enum HMSHLSPlayerPlaybackEventTypes {
     ON_PLAYBACK_CUE_EVENT = "ON_PLAYBACK_CUE_EVENT",
     ON_PLAYBACK_FAILURE_EVENT = "ON_PLAYBACK_FAILURE_EVENT",
-    ON_PLAYBACK_STATE_CHANGE_EVENT = "ON_PLAYBACK_STATE_CHANGE_EVENT"
+    ON_PLAYBACK_STATE_CHANGE_EVENT = "ON_PLAYBACK_STATE_CHANGE_EVENT",
+    ON_PLAYBACK_RESOLUTION_CHANGE_EVENT = "ON_PLAYBACK_RESOLUTION_CHANGE_EVENT"
 }
 export type HMSHLSPlayerPlaybackCueEventData = {
     id?: string;
@@ -26,17 +27,20 @@ export declare enum HMSHLSPlayerPlaybackState {
     PAUSED = "paused",
     PLAYING = "playing",
     STOPPED = "stopped",
-    UNKNOWN = "unknown",
-    onVideoSizeChanged = "onVideoSizeChanged"
+    UNKNOWN = "unknown"
 }
 export type HMSHLSPlayerPlaybackStateChangeEventData = {
     state: HMSHLSPlayerPlaybackState;
-    aspectRatio: number | undefined;
+};
+export type HMSHLSPlayerPlaybackResolutionChangeEventData = {
+    width: number;
+    height: number;
 };
 type HMSHLSPlayerPlaybackCueEvent = HMSHLSPlayerEvent<HMSHLSPlayerPlaybackEventTypes.ON_PLAYBACK_CUE_EVENT, HMSHLSPlayerPlaybackCueEventData>;
 type HMSHLSPlayerPlaybackFailureEvent = HMSHLSPlayerEvent<HMSHLSPlayerPlaybackEventTypes.ON_PLAYBACK_FAILURE_EVENT, HMSHLSPlayerPlaybackFailureEventData>;
 type HMSHLSPlayerPlaybackStateChangeEvent = HMSHLSPlayerEvent<HMSHLSPlayerPlaybackEventTypes.ON_PLAYBACK_STATE_CHANGE_EVENT, HMSHLSPlayerPlaybackStateChangeEventData>;
-export type HMSHLSPlayerPlaybackEvent = HMSHLSPlayerPlaybackCueEvent | HMSHLSPlayerPlaybackFailureEvent | HMSHLSPlayerPlaybackStateChangeEvent;
+type HMSHLSPLayerPlaybackResolutionChangeEvent = HMSHLSPlayerEvent<HMSHLSPlayerPlaybackEventTypes.ON_PLAYBACK_RESOLUTION_CHANGE_EVENT, HMSHLSPlayerPlaybackResolutionChangeEventData>;
+export type HMSHLSPlayerPlaybackEvent = HMSHLSPlayerPlaybackCueEvent | HMSHLSPlayerPlaybackFailureEvent | HMSHLSPlayerPlaybackStateChangeEvent | HMSHLSPLayerPlaybackResolutionChangeEvent;
 export declare enum HMSHLSPlayerStatsEventTypes {
     ON_STATS_EVENT_ERROR = "ON_STATS_EVENT_ERROR",
     ON_STATS_EVENT_UPDATE = "ON_STATS_EVENT_UPDATE"
@@ -62,4 +66,13 @@ export type HMSHLSPlayerStatsUpdateEventData = {
 type HMSHLSPlayerStatsErrorEvent = HMSHLSPlayerEvent<HMSHLSPlayerStatsEventTypes.ON_STATS_EVENT_ERROR, HMSHLSPlayerStatsErrorEventData>;
 type HMSHLSPlayerStatsUpdateEvent = HMSHLSPlayerEvent<HMSHLSPlayerStatsEventTypes.ON_STATS_EVENT_UPDATE, HMSHLSPlayerStatsUpdateEventData>;
 export type HMSHLSPlayerStatsEvent = HMSHLSPlayerStatsErrorEvent | HMSHLSPlayerStatsUpdateEvent;
+export type HMSHLSPlayerCuesEvent = HMSHLSPlayerEvent<'ON_CLOSED_CAPTION_UPDATE', string | null>;
+export type RequestedDataEvent = {
+    requestId: number;
+    data: any;
+};
+export type HLSPlayerDurationDetails = {
+    streamDuration?: number;
+    rollingWindowTime?: number;
+};
 export {};

package/lib/typescript/utils/emitter/EventEmitter.d.ts

@@ -16,6 +16,7 @@ export { EmitterSubscription } from './_EmitterSubscription';
  */
 export declare class EventEmitter {
     _subscriber: EventSubscriptionVendor;
+    _onAllListenersRemoved: ((eventType: string | 'all') => void) | null | undefined;
     /**
      * @constructor
      *
@@ -23,6 +24,12 @@ export declare class EventEmitter {
      *   to use. If omitted, a new subscriber will be created for the emitter.
      */
     constructor(subscriber?: EventSubscriptionVendor | null);
+    /**
+     * Registers a listener to be invoked when all event listeners have been removed
+     * Given listener is invoked with event type or `all` when all listeners are removed
+     * @param onAllListenersRemoved
+     */
+    registerOnAllListenersRemoved(onAllListenersRemoved: (eventType: string | 'all') => void): void;
     /**
      * Adds a listener to be invoked when events of the specified type are
      * emitted. An optional calling context may be provided. The data arguments

package/lib/typescript/utils/keyboard.d.ts

@@ -0,0 +1,16 @@
+export declare enum SoftInputModes {
+    SOFT_INPUT_ADJUST_NOTHING = 48,
+    SOFT_INPUT_ADJUST_PAN = 32,
+    SOFT_INPUT_ADJUST_RESIZE = 16,
+    SOFT_INPUT_ADJUST_UNSPECIFIED = 0
+}
+/**
+ * [Android Only] Sets the `windowSoftInputMode` value for the current activity
+ * @param inputMode window softinput moede to use. It can be any variant of the {@link SoftInputModes} enum
+ */
+export declare function setSoftInputMode(inputMode: SoftInputModes): void;
+/**
+ * [Android Only] Gets the current `windowSoftInputMode` value of the current activity
+ * @returns current `windowSoftInputMode` ({@link SoftInputModes}) value of the current activity
+ */
+export declare function getSoftInputMode(): SoftInputModes;

package/lib/typescript/utils/notification.d.ts

@@ -0,0 +1,5 @@
+export type NotificationResult = {
+    status: 'granted' | 'blocked';
+    settings: {};
+};
+export declare const checkNotifications: () => Promise<NotificationResult>;

package/lib/typescript/utils/windowController.d.ts

@@ -0,0 +1,10 @@
+export declare class WindowController {
+    /**
+     * [Android Only] Hides the navigation bar.
+     */
+    static hideSystemBars(): any;
+    /**
+     * [Android Only] Shows the navigation bar.
+     */
+    static showSystemBars(): any;
+}