@naviedu/room-platform-react 0.0.1

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@naviedu/room-platform-react",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "./index.esm.js",
+  "module": "./index.esm.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.esm.js"
+    },
+    "./styles.css": "./styles.css"
+  },
+  "sideEffects": [
+    "*.css"
+  ],
+  "files": [
+    "*.js",
+    "*.d.ts",
+    "*.css",
+    "assets",
+    "extensions",
+    "README.md"
+  ],
+  "peerDependencies": {
+    "react": ">=18 <20",
+    "react-dom": ">=18 <20"
+  },
+  "dependencies": {
+    "@livekit/components-react": "^2.9.21",
+    "@livekit/track-processors": "^0.7.2",
+    "@navi/chat-react": "0.0.0",
+    "@navi/feature-room-platform": "0.0.1",
+    "@navi/whiteboard-core": "0.0.1",
+    "@navi/whiteboard-react": "0.0.1",
+    "sonner": "^2.0.7",
+    "lucide-react": "^1.7.0",
+    "radix-ui": "^1.4.3",
+    "livekit-client": "^2.19.1"
+  }
+}

package/room-action-button.d.ts

@@ -0,0 +1,11 @@
+import { Button } from '@navi/ui';
+import type { ComponentProps, ReactNode } from 'react';
+export type RoomActionState = {
+    label: string;
+    pendingLabel: string;
+    status: 'disabled' | 'idle' | 'pending';
+};
+export declare function RoomActionButton({ icon, state, ...props }: ComponentProps<typeof Button> & {
+    icon: ReactNode;
+    state: RoomActionState;
+}): import("react/jsx-runtime").JSX.Element;

package/room-participant-actions.d.ts

@@ -0,0 +1,9 @@
+import type { RoomParticipantRosterEntry } from './room-platform-types';
+export type RoomParticipantActionsProps = {
+    isActiveSpeaker?: boolean;
+    isLocal?: boolean;
+    isOnline?: boolean;
+    participant: RoomParticipantRosterEntry;
+    participantIdentity?: string;
+};
+export declare function RoomParticipantActions({ isActiveSpeaker, isLocal, isOnline, participant, participantIdentity, }: RoomParticipantActionsProps): import("react/jsx-runtime").JSX.Element;

package/room-participant-list.d.ts

@@ -0,0 +1,7 @@
+import type { RoomParticipantPresence, RoomParticipantRosterEntry, RoomPlatformExtensionProps } from './room-platform-types';
+export type RoomParticipantListProps = {
+    extensionProps: RoomPlatformExtensionProps;
+    presenceByExternalActorId?: ReadonlyMap<string, RoomParticipantPresence>;
+    roster: readonly RoomParticipantRosterEntry[];
+};
+export declare function RoomParticipantList({ extensionProps, presenceByExternalActorId, roster }: RoomParticipantListProps): import("react/jsx-runtime").JSX.Element;

package/room-participant-tab.d.ts

@@ -0,0 +1,6 @@
+import type { RoomParticipantRosterEntry, RoomPlatformExtensionProps } from './room-platform-types';
+export type RoomParticipantTabProps = {
+    extensionProps: RoomPlatformExtensionProps;
+    roster?: readonly RoomParticipantRosterEntry[];
+};
+export declare function RoomParticipantTab({ extensionProps, roster }: RoomParticipantTabProps): import("react/jsx-runtime").JSX.Element;

package/room-platform-active-speaker.d.ts

@@ -0,0 +1,4 @@
+import type { TrackReference } from '@livekit/components-react';
+export declare function RoomPlatformActiveSpeaker({ trackRef }: {
+    trackRef?: TrackReference;
+}): import("react/jsx-runtime").JSX.Element;

package/room-platform-background-settings.d.ts

@@ -0,0 +1,15 @@
+import type { RoomPlatformCameraBackgroundPreset } from './room-platform-camera-background-presets';
+import type { RoomPlatformCameraBackgroundState, RoomPlatformCameraBackgroundUploadPreview } from './use-room-platform-camera-background';
+type RoomPlatformBackgroundSettingsProps = {
+    state: RoomPlatformCameraBackgroundState;
+    presets: RoomPlatformCameraBackgroundPreset[];
+    uploadItems: RoomPlatformCameraBackgroundUploadPreview[];
+    onSelectNoBackground: () => void;
+    onSelectBlurLevel: (level: 'light' | 'strong') => void;
+    onSelectPreset: (presetId: string) => void;
+    onSelectUploaded: (uploadAssetId: string) => void;
+    onDeleteUploaded: (uploadAssetId: string) => void;
+    onUpload: (file: File) => void;
+};
+export declare function RoomPlatformBackgroundSettings({ state, presets, uploadItems, onSelectNoBackground, onSelectBlurLevel, onSelectPreset, onSelectUploaded, onDeleteUploaded, onUpload, }: RoomPlatformBackgroundSettingsProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/room-platform-camera-background-presets.d.ts

@@ -0,0 +1,8 @@
+export type RoomPlatformCameraBackgroundPreset = {
+    id: 'naviedu' | 'alpine-lake' | 'forest-road' | 'tropical-beach' | 'ocean-cliffs' | 'desert-dunes' | 'canyon-view' | 'waterfall-mist' | 'flower-meadow';
+    label: string;
+    imageUrl: string;
+    processorImageUrl: string;
+};
+export declare const ROOM_PLATFORM_CAMERA_BACKGROUND_PRESETS: RoomPlatformCameraBackgroundPreset[];
+export declare const findRoomPlatformCameraBackgroundPreset: (presetId?: string) => RoomPlatformCameraBackgroundPreset;

package/room-platform-camera-background-storage.d.ts

@@ -0,0 +1,38 @@
+export type RoomPlatformCameraBackgroundMode = 'none' | 'blur' | 'preset' | 'upload';
+export type RoomPlatformCameraBackgroundBlurLevel = 'light' | 'strong';
+export type RoomPlatformCameraBackgroundSettings = {
+    mode: RoomPlatformCameraBackgroundMode;
+    blurLevel: RoomPlatformCameraBackgroundBlurLevel;
+    presetId?: string;
+    uploadAssetId?: string;
+    updatedAt: string;
+};
+export type RoomPlatformCameraBackgroundUploadGallery = {
+    assetIds: string[];
+    updatedAt: string;
+};
+export type RoomPlatformCameraBackgroundUploadAsset = {
+    id: string;
+    name: string;
+    mimeType: string;
+    size: number;
+    originalBlob: Blob;
+    mirroredBlob?: Blob;
+    createdAt: string;
+};
+export declare const MAX_UPLOAD_GALLERY_SIZE = 9;
+export declare const DEFAULT_ROOM_PLATFORM_CAMERA_BACKGROUND_SETTINGS: RoomPlatformCameraBackgroundSettings;
+export declare const loadRoomPlatformCameraBackgroundSettings: () => RoomPlatformCameraBackgroundSettings;
+export declare const saveRoomPlatformCameraBackgroundSettings: (input: Pick<RoomPlatformCameraBackgroundSettings, "mode"> & Partial<Pick<RoomPlatformCameraBackgroundSettings, "blurLevel" | "presetId" | "uploadAssetId">>) => RoomPlatformCameraBackgroundSettings;
+export declare const saveRoomPlatformUploadAsset: (file: File) => Promise<RoomPlatformCameraBackgroundUploadAsset>;
+export declare const loadRoomPlatformUploadAsset: (id: string) => Promise<RoomPlatformCameraBackgroundUploadAsset | null>;
+export declare const removeRoomPlatformUploadAsset: (id: string) => Promise<void>;
+export declare const loadLastUploadedAssetId: () => string | null;
+export declare const loadRoomPlatformUploadAssetIds: () => Promise<string[]>;
+export declare const appendRoomPlatformUploadAssetId: (assetId: string) => Promise<string[]>;
+export declare const removeRoomPlatformUploadAssetId: (assetId: string) => Promise<string[]>;
+export declare const saveRoomPlatformUploadAndSelect: (file: File) => Promise<{
+    asset: RoomPlatformCameraBackgroundUploadAsset;
+    galleryAssetIds: string[];
+    settings: RoomPlatformCameraBackgroundSettings;
+}>;

package/room-platform-control-anchor.d.ts

@@ -0,0 +1,10 @@
+import type { CSSProperties, ReactNode } from 'react';
+export type RoomPlatformControlAnchorProps = {
+    anchorKind?: 'video-frame' | 'main-panel';
+    children: ReactNode;
+    controlBar: ReactNode;
+    anchorScope?: 'frame' | 'panel';
+    className?: string;
+    style?: CSSProperties;
+};
+export declare function RoomPlatformControlAnchor({ anchorKind, children, controlBar, anchorScope, className, style, }: RoomPlatformControlAnchorProps): import("react/jsx-runtime").JSX.Element;

package/room-platform-control-bar.d.ts

@@ -0,0 +1,11 @@
+import type { RoomPlatformCameraBackgroundRuntime } from './use-room-platform-camera-background';
+type RoomPlatformControlBarProps = {
+    cameraBackground?: RoomPlatformCameraBackgroundRuntime;
+    isFullscreen?: boolean;
+    isTheaterMode?: boolean;
+    onExit?: () => void;
+    onToggleFullscreen?: () => void;
+    onToggleTheaterMode?: () => void;
+};
+export declare function RoomPlatformControlBar({ cameraBackground, isFullscreen, isTheaterMode, onExit, onToggleFullscreen, onToggleTheaterMode, }: RoomPlatformControlBarProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/room-platform-control-state.d.ts

@@ -0,0 +1,12 @@
+import { type RoomControlRealtimeEvent, type RoomControlState } from '@navi/feature-room-platform';
+export declare const roomPlatformControlStateTopic = "room-platform.actions";
+export type RoomControlStateReduction = {
+    kind: 'ignored';
+} | {
+    kind: 'applied';
+    state: RoomControlState;
+} | {
+    kind: 'gap';
+};
+export declare const parseRoomControlRealtimeEvent: (payload: Uint8Array, topic: string | undefined) => RoomControlRealtimeEvent | undefined;
+export declare const reduceRoomControlState: (current: RoomControlState | undefined, next: RoomControlState) => RoomControlStateReduction;

package/room-platform-current-operation-strip.d.ts

@@ -0,0 +1,13 @@
+import type { RoomParticipantPresence } from './room-platform-types';
+export declare function RoomPlatformCurrentOperationStrip({ activeSpeakerParticipantIdentity, canClearActiveSpeaker, isClearingActiveSpeaker, onClearActiveSpeaker, currentPrivateRoomOperation, onCancelPrivateRoom, participants, }: {
+    activeSpeakerParticipantIdentity?: string;
+    canClearActiveSpeaker?: boolean;
+    isClearingActiveSpeaker?: boolean;
+    onClearActiveSpeaker?: () => void;
+    currentPrivateRoomOperation?: {
+        status: 'ringing' | 'active';
+        studentExternalActorId: string;
+    };
+    onCancelPrivateRoom?: () => Promise<void> | void;
+    participants: readonly Pick<RoomParticipantPresence, 'name' | 'participantIdentity' | 'externalActorId' | 'isLocal'>[];
+}): import("react/jsx-runtime").JSX.Element;

package/room-platform-device-selection.d.ts

@@ -0,0 +1,7 @@
+export type RoomPlatformDeviceFallback = {
+    label: string;
+    value: string;
+};
+export declare const getDeviceValue: (device: MediaDeviceInfo, index: number) => string;
+export declare const getSelectedDeviceValue: (current: string, devices: MediaDeviceInfo[], fallback: RoomPlatformDeviceFallback) => string;
+export declare const getSelectedDevice: (devices: MediaDeviceInfo[], selectedValue: string) => MediaDeviceInfo;

package/room-platform-device-settings.d.ts

@@ -0,0 +1,8 @@
+import type { RoomPlatformCameraBackgroundRuntime } from './use-room-platform-camera-background';
+type RoomPlatformDeviceSettingsProps = {
+    cameraBackground?: RoomPlatformCameraBackgroundRuntime;
+    open: boolean;
+    onClose: () => void;
+};
+export declare function RoomPlatformDeviceSettings({ cameraBackground, open, onClose }: RoomPlatformDeviceSettingsProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/room-platform-local-preview.d.ts

@@ -0,0 +1,6 @@
+import type { TrackReference } from '@livekit/components-react';
+import type { LocalVideoTrack } from 'livekit-client';
+export declare function RoomPlatformLocalPreview({ trackRef, localPreviewTrack, }: {
+    trackRef?: TrackReference;
+    localPreviewTrack?: LocalVideoTrack | null;
+}): import("react/jsx-runtime").JSX.Element;

package/room-platform-media-controls.d.ts

@@ -0,0 +1 @@
+export { RoomPlatformControlBar as RoomPlatformMediaControls } from './room-platform-control-bar';

package/room-platform-media-runtime.d.ts

@@ -0,0 +1,2 @@
+import type { PropsWithChildren } from 'react';
+export declare function RoomPlatformMediaRuntime({ children }: PropsWithChildren): import("react/jsx-runtime").JSX.Element;

package/room-platform-monitor-stage.d.ts

@@ -0,0 +1,7 @@
+import type { RoomParticipantRosterEntry } from './room-platform-types';
+type RoomPlatformMonitorStageProps = {
+    roster: readonly RoomParticipantRosterEntry[];
+    pageSize?: number;
+};
+export declare function RoomPlatformMonitorStage({ roster, pageSize }: RoomPlatformMonitorStageProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/room-platform-monitor-video-tile.d.ts

@@ -0,0 +1,20 @@
+import type { ReactNode } from 'react';
+export type RoomPlatformMonitorVideoTileProps = {
+    testId: string;
+    label: string;
+    statusLabel?: string;
+    notice?: ReactNode;
+    media?: ReactNode;
+    mediaClassName?: string;
+    fallback?: ReactNode;
+    fallbackClassName?: string;
+    showEmptyIcon?: boolean;
+    className?: string;
+    labelPosition?: 'top-left' | 'bottom-left';
+};
+export declare function RoomPlatformMonitorVideoTile({ testId, label, statusLabel, notice, media, mediaClassName, fallback, fallbackClassName, showEmptyIcon, className, labelPosition, }: RoomPlatformMonitorVideoTileProps): import("react/jsx-runtime").JSX.Element;
+export declare const monitorCameraVideoClassName = "h-full w-full object-cover -scale-x-100";
+export type RoomPlatformMonitorSidebarVideoTileProps = Omit<RoomPlatformMonitorVideoTileProps, 'testId'> & {
+    testId: string;
+};
+export declare function RoomPlatformMonitorSidebarVideoTile(props: RoomPlatformMonitorSidebarVideoTileProps): import("react/jsx-runtime").JSX.Element;

package/room-platform-monitor-viewer.d.ts

@@ -0,0 +1,8 @@
+import { RoomPlatformAction } from '@navi/feature-room-platform';
+type RoomPlatformMonitorViewerProps = {
+    enabled: boolean;
+    onStartError?: () => void;
+    performAction: (name: typeof RoomPlatformAction.MONITOR_START | typeof RoomPlatformAction.MONITOR_STOP) => Promise<void>;
+};
+export declare function useRoomPlatformMonitorViewer({ enabled, onStartError, performAction, }: RoomPlatformMonitorViewerProps): void;
+export {};

package/room-platform-private-room-connection.d.ts

@@ -0,0 +1,11 @@
+import type { RoomPrivateRoomConnection, RoomPrivateRoomState } from '@navi/feature-room-platform';
+import type { ReactNode } from 'react';
+export type RoomPlatformPrivateRoomConnectionProps = {
+    state: RoomPrivateRoomState;
+    connection: RoomPrivateRoomConnection;
+    currentExternalActorId: string;
+    onRefresh: () => Promise<void>;
+    onDisconnected?: () => void;
+    children: ReactNode;
+};
+export declare function RoomPlatformPrivateRoomConnection({ state, connection, currentExternalActorId, onRefresh, onDisconnected, children, }: RoomPlatformPrivateRoomConnectionProps): import("react/jsx-runtime").JSX.Element;

package/room-platform-private-room-context.d.ts

@@ -0,0 +1,8 @@
+import type { RoomPrivateRoomConnection, RoomPrivateRoomState } from '@navi/feature-room-platform';
+export type RoomPlatformPrivateRoomContextValue = {
+    privateRoom?: RoomPrivateRoomState;
+    privateRoomConnection?: RoomPrivateRoomConnection;
+    refreshControlState: () => Promise<void>;
+};
+export declare const RoomPlatformPrivateRoomContext: import("react").Context<RoomPlatformPrivateRoomContextValue>;
+export declare function useRoomPlatformPrivateRoomContext(): RoomPlatformPrivateRoomContextValue;

package/room-platform-private-room-control-bar.d.ts

@@ -0,0 +1,12 @@
+import type { RoomPrivateRoomPermission } from '@navi/feature-room-platform';
+export type RoomPlatformPrivateRoomControlBarProps = {
+    publishEnabled: boolean;
+    permissions: RoomPrivateRoomPermission[];
+    screenShareDisabled: boolean;
+    onStartScreenShare: () => Promise<void>;
+    onStopScreenShare: () => Promise<void>;
+    onEnd: () => Promise<void> | void;
+    onEndingChange?: (isEnding: boolean) => void;
+    onEnded?: () => void;
+};
+export declare function RoomPlatformPrivateRoomControlBar({ publishEnabled, permissions, screenShareDisabled, onStartScreenShare, onStopScreenShare, onEnd, onEndingChange, onEnded, }: RoomPlatformPrivateRoomControlBarProps): import("react/jsx-runtime").JSX.Element;

package/room-platform-private-room-experience.d.ts

@@ -0,0 +1,14 @@
+import type { RoomPrivateRoomConnection, RoomPrivateRoomState } from '@navi/feature-room-platform';
+import type { ReactNode } from 'react';
+export type RoomPlatformPrivateRoomExperienceProps = {
+    state: RoomPrivateRoomState;
+    connection: RoomPrivateRoomConnection;
+    currentExternalActorId: string;
+    onEnd: () => Promise<void>;
+    onEndingChange?: (isEnding: boolean) => void;
+    onEnded?: () => void;
+    onStartScreenShare: () => Promise<void>;
+    onStopScreenShare: () => Promise<void>;
+    whiteboard?: ReactNode;
+};
+export declare function RoomPlatformPrivateRoomExperience({ state, connection, currentExternalActorId, onEnd, onEndingChange, onEnded, onStartScreenShare, onStopScreenShare, whiteboard, }: RoomPlatformPrivateRoomExperienceProps): import("react/jsx-runtime").JSX.Element;

package/room-platform-private-room-overlay.d.ts

@@ -0,0 +1,7 @@
+import type { ReactNode } from 'react';
+import type { RoomPlatformPrivateRoomExperienceProps } from './room-platform-private-room-experience';
+export type RoomPlatformPrivateRoomOverlayProps = RoomPlatformPrivateRoomExperienceProps & {
+    roomStatusBanner?: import('./room-platform-private-room-status-banner').RoomPlatformPrivateRoomStatusBannerProps;
+    statusSlot?: ReactNode;
+};
+export declare function RoomPlatformPrivateRoomOverlay({ roomStatusBanner, statusSlot, ...experienceProps }: RoomPlatformPrivateRoomOverlayProps): import("react/jsx-runtime").JSX.Element;

package/room-platform-private-room-stage.d.ts

@@ -0,0 +1,9 @@
+import type { ReactNode } from 'react';
+export type RoomPlatformPrivateRoomStageProps = {
+    callerExternalActorId: string;
+    studentExternalActorId: string;
+    activeScreenShareExternalActorId?: string;
+    controlBar?: ReactNode;
+    whiteboard?: ReactNode;
+};
+export declare function RoomPlatformPrivateRoomStage({ callerExternalActorId, studentExternalActorId, activeScreenShareExternalActorId, controlBar, whiteboard, }: RoomPlatformPrivateRoomStageProps): import("react/jsx-runtime").JSX.Element;

package/room-platform-private-room-status-banner.d.ts

@@ -0,0 +1,8 @@
+export type RoomPlatformPrivateRoomStatusBannerTone = 'info' | 'warning' | 'success';
+export type RoomPlatformPrivateRoomStatusBannerProps = {
+    message?: string;
+    detail?: string;
+    status?: 'active' | 'pending';
+    tone?: RoomPlatformPrivateRoomStatusBannerTone;
+};
+export declare function RoomPlatformPrivateRoomStatusBanner({ message, detail, status, tone, }: RoomPlatformPrivateRoomStatusBannerProps): import("react/jsx-runtime").JSX.Element;

package/room-platform-provider.d.ts

@@ -0,0 +1,35 @@
+import { type RoomControlState, type RoomPlatformCapabilityName } from '@navi/feature-room-platform';
+import { type LocalVideoTrack, Room } from 'livekit-client';
+import { type PropsWithChildren } from 'react';
+import { type RoomLaunchTicketRenewalReason, type RoomPlatformActionName, type RoomPlatformActiveDevices, type RoomPlatformConnectionStatus, type RoomPlatformDeviceKind, type RoomPlatformErrorEvent, type RoomPlatformGatewayAccess, type RoomPlatformLifecycleEvent, type RoomPlatformLocalMediaKind } from './room-platform-types';
+type RoomPlatformLocalMediaState = Record<RoomPlatformLocalMediaKind, boolean>;
+type RoomPlatformContextValue = {
+    access?: RoomPlatformGatewayAccess;
+    activeDevices: RoomPlatformActiveDevices;
+    actionError?: Error;
+    controlState?: RoomControlState;
+    error?: Error;
+    hasCapability: (capability: RoomPlatformCapabilityName) => boolean;
+    isActionPending: (name: RoomPlatformActionName, payload?: Record<string, string>) => boolean;
+    isLocalMediaPending: (kind: RoomPlatformLocalMediaKind) => boolean;
+    localCameraTrack: LocalVideoTrack | null;
+    localPreviewTrack: LocalVideoTrack | null;
+    localMedia: RoomPlatformLocalMediaState;
+    performAction: (name: RoomPlatformActionName, payload?: Record<string, string>) => Promise<void>;
+    room: Room | null;
+    setLocalMediaEnabled: (kind: RoomPlatformLocalMediaKind, enabled: boolean) => Promise<void>;
+    status: RoomPlatformConnectionStatus;
+    switchActiveDevice: (kind: RoomPlatformDeviceKind, deviceId: string) => Promise<void>;
+};
+export type RoomPlatformProviderProps = PropsWithChildren<{
+    apiBaseUrl: string;
+    launchToken: string;
+    onError?: (event: RoomPlatformErrorEvent) => void;
+    onLifecycleEvent?: (event: RoomPlatformLifecycleEvent) => void;
+    onLaunchTicketRequired: (reason: RoomLaunchTicketRenewalReason) => Promise<{
+        launchToken: string;
+    }>;
+}>;
+export declare function RoomPlatformProvider({ apiBaseUrl, children, launchToken, onError, onLifecycleEvent, onLaunchTicketRequired, }: RoomPlatformProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useRoomPlatform(): RoomPlatformContextValue;
+export {};

package/room-platform-room.d.ts

@@ -0,0 +1,2 @@
+import type { RoomPlatformRoomProps } from './room-platform-types';
+export declare function RoomPlatformRoom({ children, extensions, integrations, isPracticeMode, onExit, primaryCameraSelector, showLocalPreview, ...providerProps }: RoomPlatformRoomProps): import("react/jsx-runtime").JSX.Element;

package/room-platform-screen-share-whiteboard-frame.d.ts

@@ -0,0 +1,11 @@
+import { type TrackReference } from '@livekit/components-react';
+import type { ReactEventHandler, ReactNode } from 'react';
+type RoomPlatformScreenShareWhiteboardFrameProps = {
+    aspectRatio: string;
+    children?: ReactNode;
+    onLoadedMetadata?: ReactEventHandler<HTMLVideoElement>;
+    onResize?: ReactEventHandler<HTMLVideoElement>;
+    trackRef: TrackReference;
+};
+export declare function RoomPlatformScreenShareWhiteboardFrame({ aspectRatio, children, onLoadedMetadata, onResize, trackRef, }: RoomPlatformScreenShareWhiteboardFrameProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/room-platform-shell.d.ts

@@ -0,0 +1,17 @@
+import { type ReactNode } from 'react';
+export type RoomPlatformShellControls = {
+    isTheaterMode: boolean;
+    isSidebarOpen: boolean;
+    isFullscreen: boolean;
+    isMobileFullscreen: boolean;
+    onToggleTheaterMode: () => void;
+    onToggleFullscreen: () => void;
+    onOpenSidebar: () => void;
+    onCloseSidebar: () => void;
+};
+export type RoomPlatformShellProps = {
+    topBar: ReactNode;
+    mainPanel: ReactNode | ((controls: RoomPlatformShellControls) => ReactNode);
+    sidebar: ReactNode;
+};
+export declare function RoomPlatformShell({ mainPanel, sidebar, topBar }: RoomPlatformShellProps): import("react/jsx-runtime").JSX.Element;

package/room-platform-speak-queue.d.ts

@@ -0,0 +1,16 @@
+import type { ReactNode } from 'react';
+import type { RoomParticipantPresence } from './room-platform-types';
+export declare function RoomPlatformSpeakQueue({ activeSpeakerParticipantIdentity, activeSpeakerSlot, canApproveSpeak, canClearActiveSpeaker, canRejectSpeak, isClearingActiveSpeaker, isPracticeMode, onApproveSpeakRequest, onClearActiveSpeaker, onRejectSpeakRequest, participants, raisedHandParticipantIdentities, }: {
+    activeSpeakerParticipantIdentity?: string;
+    activeSpeakerSlot?: ReactNode;
+    canApproveSpeak?: boolean;
+    canClearActiveSpeaker?: boolean;
+    canRejectSpeak?: boolean;
+    isClearingActiveSpeaker?: boolean;
+    isPracticeMode?: boolean;
+    onApproveSpeakRequest?: (participantIdentity: string) => Promise<void> | void;
+    onClearActiveSpeaker?: () => void;
+    onRejectSpeakRequest?: (participantIdentity: string) => Promise<void> | void;
+    participants: readonly Pick<RoomParticipantPresence, 'name' | 'participantIdentity' | 'isLocal'>[];
+    raisedHandParticipantIdentities: readonly string[];
+}): import("react/jsx-runtime").JSX.Element;

package/room-platform-stage-selection.d.ts

@@ -0,0 +1,14 @@
+import type { TrackReference } from '@livekit/components-react';
+import type { RoomPlatformPresentation } from './room-platform-types';
+export type RoomPlatformStageModel = {
+    primary?: TrackReference;
+    cameraOverlay?: TrackReference;
+    localPreview?: TrackReference;
+    activeSpeaker?: TrackReference;
+    mediaPresentation: RoomPlatformPresentation;
+};
+export type RoomPlatformPrimaryCameraSelector = (cameraTracks: readonly TrackReference[], activeSpeakerParticipantIdentity?: string) => TrackReference | null;
+export declare function selectRoomPlatformStage(tracks: readonly TrackReference[], { activeSpeakerParticipantIdentity, primaryCameraSelector, }?: {
+    activeSpeakerParticipantIdentity?: string;
+    primaryCameraSelector?: RoomPlatformPrimaryCameraSelector;
+}): RoomPlatformStageModel;

package/room-platform-stage.d.ts

@@ -0,0 +1,13 @@
+import type { ReactNode } from 'react';
+import type { RoomPlatformStageModel } from './room-platform-stage-selection';
+import type { RoomPlatformConnectionStatus } from './room-platform-types';
+type RoomPlatformStageProps = {
+    controlBar?: ReactNode;
+    layout?: 'camera-overlay' | 'stage';
+    model: RoomPlatformStageModel;
+    overlayTrack?: RoomPlatformStageModel['cameraOverlay'];
+    status: RoomPlatformConnectionStatus;
+    whiteboard?: ReactNode;
+};
+export declare function RoomPlatformStage({ controlBar, layout, model, overlayTrack, status, whiteboard, }: RoomPlatformStageProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/room-platform-surface-boundary.d.ts

@@ -0,0 +1,13 @@
+import { Component, type ReactNode } from 'react';
+type RoomPlatformSurfaceBoundaryProps = {
+    children: ReactNode;
+};
+type RoomPlatformSurfaceBoundaryState = {
+    hasError: boolean;
+};
+export declare class RoomPlatformSurfaceBoundary extends Component<RoomPlatformSurfaceBoundaryProps, RoomPlatformSurfaceBoundaryState> {
+    state: RoomPlatformSurfaceBoundaryState;
+    static getDerivedStateFromError(): RoomPlatformSurfaceBoundaryState;
+    render(): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode>> | import("react/jsx-runtime").JSX.Element;
+}
+export {};

package/room-platform-top-bar.d.ts

@@ -0,0 +1,7 @@
+import type { ReactNode } from 'react';
+export type RoomPlatformTopBarProps = {
+    monitorSelector?: ReactNode;
+    topBarLeading?: ReactNode;
+    topBarTrailing?: ReactNode;
+};
+export declare function RoomPlatformTopBar({ monitorSelector, topBarLeading, topBarTrailing }: RoomPlatformTopBarProps): import("react/jsx-runtime").JSX.Element;