@naviedu/room-platform-react 0.0.2 → 0.0.4

package/index.d.ts

@@ -1,32 +1,1042 @@
-export * from './extensions/room-platform-extensions';
-export * from './room-participant-actions';
-export * from './room-participant-list';
-export * from './room-participant-tab';
-export * from './room-action-button';
-export * from './room-platform-active-speaker';
-export * from './room-platform-control-anchor';
-export * from './room-platform-control-bar';
-export * from './room-platform-current-operation-strip';
-export * from './room-platform-local-preview';
-export * from './room-platform-media-controls';
-export * from './room-platform-media-runtime';
-export * from './room-platform-monitor-stage';
-export * from './room-platform-monitor-video-tile';
-export * from './room-platform-monitor-viewer';
-export * from './room-platform-provider';
-export * from './room-platform-private-room-connection';
-export * from './room-platform-private-room-control-bar';
-export * from './room-platform-private-room-experience';
-export * from './room-platform-private-room-overlay';
-export * from './room-platform-private-room-stage';
-export * from './room-platform-private-room-status-banner';
-export * from './room-platform-room';
-export * from './room-platform-shell';
-export * from './room-platform-speak-queue';
-export * from './room-platform-top-bar';
-export * from './room-platform-types';
-export * from './room-platform-video-tile';
-export * from './room-platform-video-tracks';
-export * from './use-room-presence';
-export * from './use-room-platform-private-room';
-export * from './use-room-platform-private-room-control-actions';
+import type { ComponentProps } from 'react';
+import type { ComponentType } from 'react';
+import type { CSSProperties } from 'react';
+import { JSX } from 'react/jsx-runtime';
+import { LocalVideoTrack } from 'livekit-client';
+import { PropsWithChildren } from 'react';
+import * as React_2 from 'react';
+import { ReactNode } from 'react';
+import { Room } from 'livekit-client';
+import { TrackReference } from '@livekit/components-react';
+
+declare function Button({ className, variant, size, asChild, ...props }: React_2.ComponentProps<'button'> & VariantProps<typeof buttonVariants> & {
+    asChild?: boolean;
+}): JSX.Element;
+
+declare const buttonVariants: (props?: {
+    variant?: "link" | "default" | "destructive" | "outline" | "secondary" | "ghost";
+    size?: "xs" | "sm" | "lg" | "default" | "xl" | "icon" | "icon-xs" | "icon-sm" | "icon-lg" | "icon-xl";
+} & ClassProp) => string;
+
+declare type ChatClassNames = {
+    root?: string;
+    roomList?: string;
+    roomTab?: string;
+    panel?: string;
+    messageList?: string;
+    messageItem?: string;
+    composer?: string;
+    forwardDialog?: string;
+    connectionStatus?: string;
+};
+
+declare interface ChatForwardedFromDto {
+    sourceAppId: string;
+    sourceWorkspaceId: string;
+    sourceRoomId: string;
+    sourceMessageId: string;
+    sourceAuthorSnapshot: {
+        subject: string;
+        displayName?: string;
+    };
+    sourceCreatedAt: string;
+}
+
+declare interface ChatMessageDto {
+    id: string;
+    appId: string;
+    workspaceId: string;
+    roomId: string;
+    authorSubject: string;
+    authorDisplayName?: string;
+    text: string;
+    status: 'active' | 'deleted' | 'hidden';
+    createdAt: string;
+    updatedAt?: string;
+    forwardedFrom?: ChatForwardedFromDto;
+}
+
+declare type ChatPermission = (typeof chatPermissions)[number];
+
+declare const chatPermissions: readonly ["read", "send", "delete_own", "edit_own", "moderate", "forward", "manage_room"];
+
+declare type ChatProviderProps = {
+    endpoint: string;
+    realtimeEndpoint: string;
+    token: string;
+    tokenExpiresAt?: string;
+    refreshToken: string;
+    refreshTokenExpiresAt?: string;
+    rooms: ChatRoomDescriptor[];
+    currentRoomId?: string;
+    mode?: 'tabs' | 'compact' | 'full_panel' | 'readonly';
+    className?: string;
+    classNames?: ChatClassNames;
+    tokens?: ChatThemeTokens;
+    historyPageSize?: number;
+    isVisible?: boolean;
+    initialMessages?: Record<string, ChatMessageDto[]>;
+    messageActionWindowMs?: number;
+    now?: () => Date;
+    onError?: (error: Error) => void;
+    children?: ReactNode;
+};
+
+declare interface ChatRoomDescriptor {
+    roomId: string;
+    roomType: ChatRoomType;
+    label?: string;
+    permissions: ChatPermission[];
+}
+
+declare type ChatRoomType = (typeof chatRoomTypes)[number];
+
+declare const chatRoomTypes: readonly ["group", "direct", "staff", "system"];
+
+declare type ChatThemeTokens = {
+    colorPrimary?: string;
+    colorSurface?: string;
+    colorBorder?: string;
+    colorText?: string;
+    radius?: string | number;
+    fontFamily?: string;
+};
+
+declare type ClassProp = {
+    class: ClassValue;
+    className?: never;
+} | {
+    class?: never;
+    className: ClassValue;
+} | {
+    class?: never;
+    className?: never;
+};
+
+declare type ClassValue = CLSX.ClassValue;
+
+declare namespace CLSX {
+    export {
+
+    }
+}
+
+export declare const getParticipantTabTitle: (participantTab: RoomPlatformExtensions["participantTab"]) => string;
+
+export declare function getRoomPlatformPrivateRoomStatusBanner({ privateRoom, isCaller, canMountPrivateRoom, isAcceptingPrivateRoom, isEndingPrivateRoom, privateRoomReturnedNoticeId, }: {
+    privateRoom?: RoomPrivateRoomState;
+    isCaller: boolean;
+    canMountPrivateRoom: boolean;
+    isAcceptingPrivateRoom: boolean;
+    isEndingPrivateRoom: boolean;
+    privateRoomReturnedNoticeId?: string;
+}): RoomPlatformPrivateRoomBannerState | undefined;
+
+export declare const monitorCameraVideoClassName = "h-full w-full object-cover -scale-x-100";
+
+declare type OmitUndefined<T> = T extends undefined ? never : T;
+
+declare interface OperationCommittedEvent {
+    boardId: string;
+    revision: number;
+    operation: WhiteboardCommittedOperation;
+}
+
+export declare function RoomActionButton({ icon, state, ...props }: ComponentProps<typeof Button> & {
+    icon: ReactNode;
+    state: RoomActionState;
+}): JSX.Element;
+
+declare type RoomActionName = (typeof roomActionNames)[number];
+
+declare const roomActionNames: readonly [RoomPlatformAction.PRIVATE_ROOM_INVITE, RoomPlatformAction.PRIVATE_ROOM_RESPOND, RoomPlatformAction.PRIVATE_ROOM_CLOSE, RoomPlatformAction.PRIVATE_ROOM_SCREEN_SHARE_START, RoomPlatformAction.PRIVATE_ROOM_SCREEN_SHARE_STOP, RoomPlatformAction.MONITOR_START, RoomPlatformAction.MONITOR_STOP, RoomPlatformAction.MODERATION_MUTE, RoomPlatformAction.MODERATION_REMOVE, RoomPlatformAction.MODERATION_LOWER_HAND, RoomPlatformAction.WHITEBOARD_CLEAR, RoomPlatformAction.SPEAK_REQUEST, RoomPlatformAction.SPEAK_CANCEL, RoomPlatformAction.SPEAK_APPROVE, RoomPlatformAction.SPEAK_REJECT, RoomPlatformAction.SPEAKER_SET, RoomPlatformAction.SPEAKER_CLEAR];
+
+export declare type RoomActionState = {
+    label: string;
+    pendingLabel: string;
+    status: 'disabled' | 'idle' | 'pending';
+};
+
+declare interface RoomControlState {
+    revision: string;
+    raisedHandParticipantIdentities: string[];
+    activeSpeakerParticipantIdentity?: string;
+    monitorActive: boolean;
+    monitorViewerCount: number;
+}
+
+export declare type RoomLaunchTicketRenewalReason = 'launch_ticket_invalid' | 'access_session_expired' | 'livekit_token_expired' | 'reconnect_authorization_failed';
+
+export declare function RoomParticipantActions({ isActiveSpeaker, isLocal, isOnline, participant, participantIdentity, }: RoomParticipantActionsProps): JSX.Element;
+
+export declare type RoomParticipantActionsProps = {
+    isActiveSpeaker?: boolean;
+    isLocal?: boolean;
+    isOnline?: boolean;
+    participant: RoomParticipantRosterEntry;
+    participantIdentity?: string;
+};
+
+export declare function RoomParticipantList({ extensionProps, presenceByExternalActorId, roster }: RoomParticipantListProps): JSX.Element;
+
+export declare type RoomParticipantListProps = {
+    extensionProps: RoomPlatformExtensionProps;
+    presenceByExternalActorId?: ReadonlyMap<string, RoomParticipantPresence>;
+    roster: readonly RoomParticipantRosterEntry[];
+};
+
+export declare type RoomParticipantPresence = {
+    canPublishAudio: boolean;
+    canPublishVideo: boolean;
+    participantIdentity: string;
+    externalActorId?: string;
+    handRaisedAt?: string;
+    hasAudio: boolean;
+    hasVideo: boolean;
+    isActiveSpeaker: boolean;
+    isHandRaised: boolean;
+    isLocal: boolean;
+    isSpeaking: boolean;
+    name?: string;
+};
+
+export declare type RoomParticipantPresenceState = {
+    isActiveSpeaker?: boolean;
+    isHandRaised?: boolean;
+    isLocal?: boolean;
+    online: boolean;
+    participantIdentity?: string;
+};
+
+export declare type RoomParticipantRosterEntry = {
+    externalActorId: string;
+    displayName: string;
+    avatarUrl?: string;
+    subtitle?: string;
+    supplement?: ComponentType<RoomParticipantRowSupplementProps>;
+};
+
+export declare type RoomParticipantRowSupplementProps = RoomPlatformExtensionProps & {
+    participant: RoomParticipantRosterEntry;
+    presence: RoomParticipantPresenceState;
+};
+
+export declare function RoomParticipantTab({ extensionProps, roster }: RoomParticipantTabProps): JSX.Element;
+
+export declare type RoomParticipantTabProps = {
+    extensionProps: RoomPlatformExtensionProps;
+    roster?: readonly RoomParticipantRosterEntry[];
+};
+
+declare enum RoomPlatformAction {
+    PRIVATE_ROOM_INVITE = "private_room.invite",
+    PRIVATE_ROOM_RESPOND = "private_room.respond",
+    PRIVATE_ROOM_CLOSE = "private_room.close",
+    PRIVATE_ROOM_SCREEN_SHARE_START = "private_room.screen_share.start",
+    PRIVATE_ROOM_SCREEN_SHARE_STOP = "private_room.screen_share.stop",
+    MONITOR_START = "monitor.start",
+    MONITOR_STOP = "monitor.stop",
+    MODERATION_MUTE = "moderation.mute",
+    MODERATION_REMOVE = "moderation.remove",
+    MODERATION_LOWER_HAND = "moderation.lower_hand",
+    WHITEBOARD_CLEAR = "whiteboard.clear",
+    SPEAK_REQUEST = "speak.request",
+    SPEAK_CANCEL = "speak.cancel",
+    SPEAK_APPROVE = "speak.approve",
+    SPEAK_REJECT = "speak.reject",
+    SPEAKER_SET = "speaker.set",
+    SPEAKER_CLEAR = "speaker.clear"
+}
+
+export declare type RoomPlatformActionName = RoomActionName;
+
+export declare type RoomPlatformActions = {
+    hasCapability: (capability: RoomPlatformCapabilityName) => boolean;
+    isPending: (name: RoomPlatformActionName, payload?: Record<string, string>) => boolean;
+    perform: (name: RoomPlatformActionName, payload?: Record<string, string>) => Promise<void>;
+};
+
+export declare type RoomPlatformActiveDevices = Record<RoomPlatformDeviceKind, string | undefined>;
+
+export declare function RoomPlatformActiveSpeaker({ trackRef }: {
+    trackRef?: TrackReference;
+}): JSX.Element;
+
+declare type RoomPlatformCameraBackgroundRuntime = ReturnType<typeof useRoomPlatformCameraBackground>;
+
+declare type RoomPlatformCameraBackgroundState = {
+    mode: 'none' | 'blur' | 'preset' | 'upload';
+    blurLevel: 'light' | 'strong';
+    presetId?: string;
+    uploadAssetId?: string;
+    isSupported: boolean;
+    isApplying: boolean;
+    error: string | null;
+};
+
+declare type RoomPlatformCameraBackgroundUploadPreview = {
+    id: string;
+    name: string;
+    createdAt: string;
+    previewUrl: string;
+};
+
+declare const RoomPlatformCapability: {
+    readonly ROOM_JOIN: "room:join";
+    readonly CHAT_SEND: "chat:send";
+    readonly MEDIA_SUBSCRIBE: "media:subscribe";
+    readonly MEDIA_PUBLISH_AUDIO: "media:publish_audio";
+    readonly MEDIA_PUBLISH_VIDEO: "media:publish_video";
+    readonly MEDIA_SHARE_SCREEN: "media:share_screen";
+    readonly DATA_PUBLISH: "data:publish";
+    readonly ROOM_SPEAK_REQUEST: "room:speak_request";
+    readonly ROOM_MODERATE: "room:moderate";
+    readonly MONITOR_MANAGE: "monitor:manage";
+    readonly PRIVATE_ROOM_INVITE: "private_room:invite";
+    readonly PRIVATE_ROOM_RESPOND: "private_room:respond";
+    readonly PRIVATE_ROOM_CLOSE: "private_room:close";
+    readonly WHITEBOARD_CLEAR: "whiteboard:clear";
+};
+
+declare type RoomPlatformCapabilityName = (typeof RoomPlatformCapability)[keyof typeof RoomPlatformCapability];
+
+export declare type RoomPlatformConnectionStatus = 'connecting' | 'connected' | 'reconnecting' | 'error';
+
+declare 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 declare function RoomPlatformControlAnchor({ anchorKind, children, controlBar, anchorScope, className, style, }: RoomPlatformControlAnchorProps): JSX.Element;
+
+export declare type RoomPlatformControlAnchorProps = {
+    anchorKind?: 'video-frame' | 'main-panel';
+    children: ReactNode;
+    controlBar: ReactNode;
+    anchorScope?: 'frame' | 'panel';
+    className?: string;
+    style?: CSSProperties;
+};
+
+declare function RoomPlatformControlBar({ cameraBackground, isFullscreen, isTheaterMode, onExit, onToggleFullscreen, onToggleTheaterMode, }: RoomPlatformControlBarProps): JSX.Element;
+export { RoomPlatformControlBar }
+export { RoomPlatformControlBar as RoomPlatformMediaControls }
+
+declare type RoomPlatformControlBarProps = {
+    cameraBackground?: RoomPlatformCameraBackgroundRuntime;
+    isFullscreen?: boolean;
+    isTheaterMode?: boolean;
+    onExit?: () => void;
+    onToggleFullscreen?: () => void;
+    onToggleTheaterMode?: () => void;
+};
+
+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'>[];
+}): JSX.Element;
+
+export declare type RoomPlatformDeviceKind = 'audioinput' | 'audiooutput' | 'videoinput';
+
+export declare type RoomPlatformErrorEvent = {
+    error: Error;
+    recoverable: boolean;
+    scope: RoomPlatformErrorScope;
+};
+
+export declare type RoomPlatformErrorScope = 'action' | 'connection' | 'media';
+
+export declare type RoomPlatformEvent = {
+    type: 'connected';
+    roomId: string;
+} | {
+    type: 'reconnecting';
+    reason: RoomLaunchTicketRenewalReason;
+} | {
+    type: 'error';
+    error: Error;
+};
+
+export declare type RoomPlatformExtensionProps = {
+    actions: RoomPlatformActions;
+    capabilities: readonly RoomPlatformCapabilityName[];
+    connectionStatus: RoomPlatformConnectionStatus;
+    currentParticipant?: RoomParticipantPresence;
+    presentation: RoomPlatformPresentation;
+    roomId?: string;
+};
+
+export declare type RoomPlatformExtensions = {
+    topBarLeading?: ComponentType<RoomPlatformExtensionProps>;
+    topBarTrailing?: ComponentType<RoomPlatformExtensionProps>;
+    monitor?: {
+        roster: readonly RoomParticipantRosterEntry[];
+        roomEligible: boolean;
+    };
+    mainWorkspace?: {
+        placement: 'overlay' | 'alongside-stage';
+        component: ComponentType<RoomPlatformExtensionProps>;
+    };
+    sidebarTabs?: readonly {
+        id: string;
+        title: string;
+        component: ComponentType<RoomPlatformExtensionProps>;
+    }[];
+    participantTab?: {
+        mode: 'default';
+        roster?: readonly RoomParticipantRosterEntry[];
+    } | {
+        mode: 'replace';
+        title?: string;
+        component: ComponentType<RoomPlatformExtensionProps>;
+    };
+};
+
+export declare function RoomPlatformExtensionZone({ component: Extension, extensionProps }: RoomPlatformExtensionZoneProps): JSX.Element;
+
+export declare type RoomPlatformExtensionZoneProps = {
+    component: ComponentType<RoomPlatformExtensionProps>;
+    extensionProps: RoomPlatformExtensionProps;
+};
+
+export declare type RoomPlatformGatewayAccess = {
+    accessSessionExpiresAt: string;
+    accessSessionToken: string;
+    capabilities: RoomPlatformCapabilityName[];
+    liveKit: {
+        participantIdentity: string;
+        roomName: string;
+        token: string;
+        wsUrl: string;
+    };
+    roomId: string;
+};
+
+export declare const RoomPlatformGatewayErrorCode: {
+    readonly ACCESS_SESSION_INVALID: "ROOM_PLATFORM_ACCESS_SESSION_INVALID";
+    readonly LAUNCH_TICKET_INVALID: "ROOM_PLATFORM_LAUNCH_TICKET_INVALID";
+};
+
+export declare type RoomPlatformIntegrations = {
+    chat?: Pick<ChatProviderProps, 'endpoint' | 'realtimeEndpoint' | 'token' | 'tokenExpiresAt' | 'refreshToken' | 'refreshTokenExpiresAt' | 'rooms' | 'currentRoomId'>;
+    whiteboard?: {
+        joinState: WhiteboardJoinState;
+        runtime: Pick<WhiteboardRuntimeOptions, 'realtimeEndpoint' | 'recoveryPort'>;
+    };
+};
+
+export declare type RoomPlatformLifecycleEvent = 'exchange.succeeded' | 'exchange.failed' | 'renewal.succeeded' | 'renewal.failed' | 'reconnect.succeeded' | 'reconnect.failed';
+
+export declare type RoomPlatformLocalMediaKind = 'microphone' | 'camera' | 'screenShare';
+
+declare type RoomPlatformLocalMediaState = Record<RoomPlatformLocalMediaKind, boolean>;
+
+export declare function RoomPlatformLocalPreview({ trackRef, localPreviewTrack, }: {
+    trackRef?: TrackReference;
+    localPreviewTrack?: LocalVideoTrack | null;
+}): JSX.Element;
+
+export declare function RoomPlatformMediaRuntime({ children }: PropsWithChildren): JSX.Element;
+
+export declare function RoomPlatformMonitorSidebarVideoTile(props: RoomPlatformMonitorSidebarVideoTileProps): JSX.Element;
+
+export declare type RoomPlatformMonitorSidebarVideoTileProps = Omit<RoomPlatformMonitorVideoTileProps, 'testId'> & {
+    testId: string;
+};
+
+export declare function RoomPlatformMonitorStage({ roster, pageSize }: RoomPlatformMonitorStageProps): JSX.Element;
+
+declare type RoomPlatformMonitorStageProps = {
+    roster: readonly RoomParticipantRosterEntry[];
+    pageSize?: number;
+};
+
+export declare function RoomPlatformMonitorVideoTile({ testId, label, statusLabel, notice, media, mediaClassName, fallback, fallbackClassName, showEmptyIcon, className, labelPosition, }: RoomPlatformMonitorVideoTileProps): JSX.Element;
+
+export declare 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';
+};
+
+declare type RoomPlatformMonitorViewerProps = {
+    enabled: boolean;
+    onStartError?: () => void;
+    performAction: (name: typeof RoomPlatformAction.MONITOR_START | typeof RoomPlatformAction.MONITOR_STOP) => Promise<void>;
+};
+
+export declare type RoomPlatformPresentation = {
+    kind: 'empty';
+} | {
+    kind: 'participant';
+    participantIdentity: string;
+} | {
+    kind: 'screen-share';
+    participantIdentity: string;
+} | {
+    kind: 'whiteboard';
+} | {
+    kind: 'workspace';
+    placement: 'overlay' | 'alongside-stage';
+};
+
+export declare type RoomPlatformPrivateRoomBannerState = Omit<RoomPlatformPrivateRoomStatusBannerProps, 'message'> & {
+    message: string;
+    tone?: RoomPlatformPrivateRoomStatusBannerTone;
+};
+
+export declare function RoomPlatformPrivateRoomConnection({ state, connection, currentExternalActorId, onRefresh, onDisconnected, children, }: RoomPlatformPrivateRoomConnectionProps): JSX.Element;
+
+export declare type RoomPlatformPrivateRoomConnectionProps = {
+    state: RoomPrivateRoomState;
+    connection: RoomPrivateRoomConnection;
+    currentExternalActorId: string;
+    onRefresh: () => Promise<void>;
+    onDisconnected?: () => void;
+    children: ReactNode;
+};
+
+export declare function RoomPlatformPrivateRoomControlBar({ publishEnabled, permissions, screenShareDisabled, onStartScreenShare, onStopScreenShare, onEnd, onEndingChange, onEnded, }: RoomPlatformPrivateRoomControlBarProps): JSX.Element;
+
+export declare 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 RoomPlatformPrivateRoomExperience({ state, connection, currentExternalActorId, onEnd, onEndingChange, onEnded, onStartScreenShare, onStopScreenShare, whiteboard, }: RoomPlatformPrivateRoomExperienceProps): JSX.Element;
+
+export declare 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 RoomPlatformPrivateRoomOverlay({ roomStatusBanner, statusSlot, ...experienceProps }: RoomPlatformPrivateRoomOverlayProps): JSX.Element;
+
+export declare type RoomPlatformPrivateRoomOverlayProps = RoomPlatformPrivateRoomExperienceProps & {
+    roomStatusBanner?: RoomPlatformPrivateRoomStatusBannerProps;
+    statusSlot?: ReactNode;
+};
+
+export declare type RoomPlatformPrivateRoomRuntimeState = {
+    actorExternalId?: string;
+    canMountPrivateRoom: boolean;
+    currentPrivateRoomOperation?: {
+        status: 'ringing' | 'active';
+        studentExternalActorId: string;
+    };
+    hasIncomingPrivateRoom: boolean;
+    isAcceptingPrivateRoom: boolean;
+    isCaller: boolean;
+    privateRoom?: RoomPrivateRoomState;
+    privateRoomConnection?: RoomPrivateRoomConnection;
+    privateRoomReturnedNoticeId?: string;
+    privateRoomStatusBanner?: RoomPlatformPrivateRoomBannerState;
+    acceptPrivateRoom: () => Promise<void>;
+    declinePrivateRoom: () => Promise<void>;
+    cancelPrivateRoom: () => Promise<void>;
+    endPrivateRoom: () => Promise<void>;
+    startPrivateScreenShare: () => Promise<void>;
+    stopPrivateScreenShare: () => Promise<void>;
+    markPrivateRoomEnded: () => void;
+    setIsAcceptingPrivateRoom: (value: boolean) => void;
+};
+
+export declare function RoomPlatformPrivateRoomStage({ callerExternalActorId, studentExternalActorId, activeScreenShareExternalActorId, controlBar, whiteboard, }: RoomPlatformPrivateRoomStageProps): JSX.Element;
+
+export declare type RoomPlatformPrivateRoomStageProps = {
+    callerExternalActorId: string;
+    studentExternalActorId: string;
+    activeScreenShareExternalActorId?: string;
+    controlBar?: ReactNode;
+    whiteboard?: ReactNode;
+};
+
+export declare function RoomPlatformPrivateRoomStatusBanner({ message, detail, status, tone, }: RoomPlatformPrivateRoomStatusBannerProps): JSX.Element;
+
+export declare type RoomPlatformPrivateRoomStatusBannerProps = {
+    message?: string;
+    detail?: string;
+    status?: 'active' | 'pending';
+    tone?: RoomPlatformPrivateRoomStatusBannerTone;
+};
+
+export declare type RoomPlatformPrivateRoomStatusBannerTone = 'info' | 'warning' | 'success';
+
+export declare function RoomPlatformProvider({ apiBaseUrl, children, launchToken, onError, onLifecycleEvent, onLaunchTicketRequired, }: RoomPlatformProviderProps): JSX.Element;
+
+export declare type RoomPlatformProviderProps = PropsWithChildren<{
+    apiBaseUrl: string;
+    launchToken: string;
+    onError?: (event: RoomPlatformErrorEvent) => void;
+    onLifecycleEvent?: (event: RoomPlatformLifecycleEvent) => void;
+    onLaunchTicketRequired: (reason: RoomLaunchTicketRenewalReason) => Promise<{
+        launchToken: string;
+    }>;
+}>;
+
+export declare function RoomPlatformRoom({ children, extensions, integrations, isPracticeMode, onExit, primaryCameraSelector, showLocalPreview, ...providerProps }: RoomPlatformRoomProps): JSX.Element;
+
+export declare type RoomPlatformRoomProps = {
+    apiBaseUrl: string;
+    extensions?: RoomPlatformExtensions;
+    integrations?: RoomPlatformIntegrations;
+    launchToken: string;
+    isPracticeMode?: boolean;
+    primaryCameraSelector?: (cameraTracks: readonly TrackReference[], activeSpeakerParticipantIdentity?: string) => TrackReference | null;
+    showLocalPreview?: boolean;
+    onError?: (event: RoomPlatformErrorEvent) => void;
+    onLifecycleEvent?: (event: RoomPlatformLifecycleEvent) => void;
+    onExit?: () => void;
+    onLaunchTicketRequired: (reason: RoomLaunchTicketRenewalReason) => Promise<{
+        launchToken: string;
+    }>;
+    children?: ReactNode;
+};
+
+export declare const RoomPlatformRuntimeErrorCode: {
+    readonly LIVEKIT_TOKEN_EXPIRED: "LIVEKIT_TOKEN_EXPIRED";
+};
+
+export declare function RoomPlatformShell({ mainPanel, sidebar, topBar }: RoomPlatformShellProps): JSX.Element;
+
+export declare type RoomPlatformShellControls = {
+    isTheaterMode: boolean;
+    isSidebarOpen: boolean;
+    isFullscreen: boolean;
+    isMobileFullscreen: boolean;
+    onToggleTheaterMode: () => void;
+    onToggleFullscreen: () => void;
+    onOpenSidebar: () => void;
+    onCloseSidebar: () => void;
+};
+
+export declare type RoomPlatformShellProps = {
+    topBar: ReactNode;
+    mainPanel: ReactNode | ((controls: RoomPlatformShellControls) => ReactNode);
+    sidebar: ReactNode;
+};
+
+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[];
+}): JSX.Element;
+
+export declare function RoomPlatformTopBar({ monitorSelector, topBarLeading, topBarTrailing }: RoomPlatformTopBarProps): JSX.Element;
+
+export declare type RoomPlatformTopBarProps = {
+    monitorSelector?: ReactNode;
+    topBarLeading?: ReactNode;
+    topBarTrailing?: ReactNode;
+};
+
+export declare function RoomPlatformVideoTile({ kind, label, trackRef, className, media, mediaClassName, labelPosition, }: RoomPlatformVideoTileProps): JSX.Element;
+
+export declare type RoomPlatformVideoTileKind = 'active-speaker' | 'overlay' | 'preview' | 'stage';
+
+export declare type RoomPlatformVideoTileProps = {
+    kind: RoomPlatformVideoTileKind;
+    label?: string;
+    trackRef?: TrackReference;
+    className?: string;
+    media?: ReactNode;
+    mediaClassName?: string;
+    labelPosition?: 'bottom-left' | 'top-left';
+};
+
+export declare function RoomPlatformVideoTracks({ status }: RoomPlatformVideoTracksProps): JSX.Element;
+
+declare type RoomPlatformVideoTracksProps = {
+    status?: RoomPlatformConnectionStatus;
+};
+
+declare interface RoomPrivateRoomConnection {
+    roomName: string;
+    token: string;
+    wsUrl: string;
+    tokenExpiresAt: string;
+    publishEnabled: boolean;
+    permissions: RoomPrivateRoomPermission[];
+}
+
+declare type RoomPrivateRoomPermission = 'media:publish' | 'media:subscribe' | 'media:share_screen';
+
+declare interface RoomPrivateRoomState {
+    id: string;
+    status: RoomPrivateRoomStatus;
+    callerExternalActorId: string;
+    studentExternalActorId: string;
+    roomName: string;
+    activeScreenShareExternalActorId?: string;
+    requestedAt: string;
+    acceptedAt?: string;
+    expiresAt: string;
+}
+
+declare type RoomPrivateRoomStatus = 'ringing' | 'active';
+
+declare interface SocketLike {
+    auth?: unknown;
+    connect: () => void;
+    disconnect: () => void;
+    emit: (event: string, payload?: unknown, acknowledgement?: (response: unknown) => void) => void;
+    on: (event: string, handler: (payload: unknown) => void) => void;
+}
+
+export declare function useRoomPlatform(): RoomPlatformContextValue;
+
+declare function useRoomPlatformCameraBackground({ localVideoTrack }: UseRoomPlatformCameraBackgroundInput): {
+    state: RoomPlatformCameraBackgroundState;
+    uploadItems: RoomPlatformCameraBackgroundUploadPreview[];
+    uploadPreviewUrl: string;
+    setBackgroundOff: () => Promise<void>;
+    setBlurLevel: (blurLevel: "light" | "strong") => Promise<void>;
+    setBlur: () => Promise<void>;
+    setPreset: (presetId: string) => Promise<void>;
+    selectUploaded: (uploadAssetId: string) => Promise<void>;
+    setUploaded: () => Promise<void>;
+    setUpload: (file: File) => Promise<void>;
+    removeUploaded: (uploadAssetId: string) => Promise<void>;
+    clearError: () => void;
+};
+
+declare type UseRoomPlatformCameraBackgroundInput = {
+    localVideoTrack: LocalVideoTrack | null;
+};
+
+export declare function useRoomPlatformMonitorViewer({ enabled, onStartError, performAction, }: RoomPlatformMonitorViewerProps): void;
+
+export declare function useRoomPlatformPrivateRoom(): RoomPlatformPrivateRoomRuntimeState;
+
+export declare function useRoomPlatformPrivateRoomControlActions({ canShareScreen, isScreenSharing, onStartScreenShare, onStopScreenShare, onEnd, onScreenSharingChange, setLocalScreenShareEnabled, onEndingChange, onEnded, }: UseRoomPlatformPrivateRoomControlActionsInput): UseRoomPlatformPrivateRoomControlActionsResult;
+
+export declare type UseRoomPlatformPrivateRoomControlActionsInput = {
+    canShareScreen: boolean;
+    isScreenSharing: boolean;
+    onStartScreenShare: () => Promise<void>;
+    onStopScreenShare: () => Promise<void>;
+    onEnd: () => Promise<void> | void;
+    onScreenSharingChange?: (isScreenSharing: boolean) => void;
+    setLocalScreenShareEnabled?: (enabled: boolean) => Promise<void>;
+    onEndingChange?: (isEnding: boolean) => void;
+    onEnded?: () => void;
+};
+
+export declare type UseRoomPlatformPrivateRoomControlActionsResult = {
+    isScreenSharing: boolean;
+    isScreenSharePending: boolean;
+    isEnding: boolean;
+    canToggleScreenShare: boolean;
+    startScreenShare: () => Promise<void>;
+    stopScreenShare: () => Promise<void>;
+    endPrivateRoom: () => Promise<void>;
+};
+
+export declare function useRoomPlatformPrivateRoomPendingState(): {
+    acceptPending: boolean;
+    declinePending: boolean;
+    endPending: boolean;
+};
+
+export declare function useRoomPresence(): RoomParticipantPresence[];
+
+declare type VariantProps<Component extends (...args: any) => any> = Omit<OmitUndefined<Parameters<Component>[0]>, "class" | "className">;
+
+declare const WHITEBOARD_ANNOTATION_ERASE_OPERATION: "annotation.object.erase";
+
+declare const WHITEBOARD_ANNOTATION_UPSERT_OPERATION: "annotation.object.upsert";
+
+declare const WHITEBOARD_CLEAR_OPERATION: "clear";
+
+declare const WHITEBOARD_RESTORE_CLEAR_OPERATION: "restore_clear";
+
+declare interface WhiteboardAnnotationEraseOperation extends WhiteboardOperationEnvelope {
+    type: typeof WHITEBOARD_ANNOTATION_ERASE_OPERATION;
+    payload: WhiteboardAnnotationErasePayload;
+}
+
+declare interface WhiteboardAnnotationErasePayload extends Record<string, unknown> {
+    objectId: string;
+}
+
+declare type WhiteboardAnnotationSceneObject = WhiteboardAnnotationStrokeSceneObject | WhiteboardAnnotationShapeSceneObject;
+
+declare type WhiteboardAnnotationShapeSceneObject = WhiteboardSceneObject & {
+    objectType: 'annotation.shape';
+    payload: WhiteboardShapeObjectPayload;
+};
+
+declare type WhiteboardAnnotationStrokeSceneObject = WhiteboardSceneObject & {
+    objectType: 'annotation.stroke';
+    payload: WhiteboardStrokeObjectPayload;
+};
+
+declare interface WhiteboardAnnotationUpsertOperation extends WhiteboardOperationEnvelope {
+    type: typeof WHITEBOARD_ANNOTATION_UPSERT_OPERATION;
+    payload: WhiteboardAnnotationUpsertPayload;
+}
+
+declare interface WhiteboardAnnotationUpsertPayload extends Record<string, unknown> {
+    object: WhiteboardAnnotationSceneObject;
+}
+
+declare interface WhiteboardBootstrapRequest {
+    token: string;
+    boardId: string;
+}
+
+declare interface WhiteboardBootstrapResponse {
+    boardId: string;
+    shareSessionKey: string;
+    headRevision: number;
+    objects: WhiteboardSceneObject[];
+}
+
+declare interface WhiteboardClearOperation extends WhiteboardOperationEnvelope {
+    type: typeof WHITEBOARD_CLEAR_OPERATION;
+    payload?: undefined;
+}
+
+declare type WhiteboardCommittedOperation = WhiteboardAnnotationUpsertOperation | WhiteboardAnnotationEraseOperation | WhiteboardClearOperation | WhiteboardRestoreClearOperation;
+
+declare interface WhiteboardDeltaItem {
+    revision: number;
+    createdAt: string;
+    actorSubject?: string | null;
+    operation: WhiteboardCommittedOperation;
+}
+
+declare interface WhiteboardDeltaRequest {
+    token: string;
+    boardId: string;
+    afterRevision: number;
+    limit?: number;
+}
+
+declare interface WhiteboardDeltaResponse {
+    boardId: string;
+    fromRevision: number;
+    toRevision: number;
+    headRevision: number;
+    hasMore: boolean;
+    operations: WhiteboardDeltaItem[];
+}
+
+declare type WhiteboardFreehandKind = (typeof whiteboardFreehandKinds)[number];
+
+declare const whiteboardFreehandKinds: readonly ["pen", "highlighter", "marker"];
+
+declare interface WhiteboardJoinAuth {
+    permissions: WhiteboardPermission[];
+    token: string;
+    tokenExpiresAt: string;
+}
+
+declare type WhiteboardJoinState = {
+    available: true;
+    auth: WhiteboardJoinAuth;
+} | {
+    available: false;
+    unavailableReason: WhiteboardUnavailableReason;
+};
+
+declare interface WhiteboardNormalizedPoint {
+    x: number;
+    y: number;
+}
+
+declare interface WhiteboardOperationEnvelope {
+    operationId: string;
+    type: string;
+    payload?: Record<string, unknown>;
+}
+
+declare type WhiteboardPermission = (typeof whiteboardPermissions)[number];
+
+declare const whiteboardPermissions: readonly ["whiteboard:view", "whiteboard:write", "whiteboard:clear"];
+
+declare interface WhiteboardRecoveryPort {
+    bootstrap: (request: WhiteboardBootstrapRequest, signal: AbortSignal) => Promise<WhiteboardBootstrapResponse>;
+    delta: (request: WhiteboardDeltaRequest, signal: AbortSignal) => Promise<WhiteboardDeltaResponse>;
+}
+
+declare interface WhiteboardRecoveryState {
+    bootstrap: WhiteboardBootstrapResponse;
+    deltas: WhiteboardDeltaResponse[];
+    discardLocalHistory?: boolean;
+    mode?: 'incremental' | 'replace';
+    settledOperationIds?: string[];
+}
+
+declare interface WhiteboardRestoreClearOperation extends WhiteboardOperationEnvelope {
+    type: typeof WHITEBOARD_RESTORE_CLEAR_OPERATION;
+    payload: {
+        clearOperationId: string;
+        objects: WhiteboardAnnotationSceneObject[];
+    };
+}
+
+declare interface WhiteboardRuntimeBoardState {
+    activeShareSessionKey?: string;
+    boardId?: string;
+    confirmedRevision: number;
+    headRevision: number;
+    pendingOperationCount: number;
+}
+
+declare interface WhiteboardRuntimeCommittedEvent extends OperationCommittedEvent {
+    reconcileStrategy: 'replayable';
+}
+
+declare type WhiteboardRuntimeDiagnostic = {
+    type: 'submit_ack';
+    operationId: string;
+    revision: number;
+    latencyMs: number;
+    queueDepth: number;
+} | {
+    type: 'relay_echo';
+    operationId: string;
+    revision: number;
+    latencyMs: number;
+} | {
+    type: 'delta_request';
+    reason: 'initial_gap' | 'reconnect' | 'runtime_gap';
+    afterRevision: number;
+} | {
+    type: 'queue_depth';
+    depth: number;
+} | {
+    type: 'terminal_rollback';
+    operationCount: number;
+};
+
+declare interface WhiteboardRuntimeOptions {
+    onBoardStateChange?: (state: WhiteboardRuntimeBoardState) => void;
+    onCommittedEvent?: (event: WhiteboardRuntimeCommittedEvent) => void;
+    onDiagnostic?: (diagnostic: WhiteboardRuntimeDiagnostic) => void;
+    onRecoveryStateChange?: (recovery: WhiteboardRecoveryState | undefined) => void;
+    onRecoveryStatusChange?: (status: 'idle' | 'restoring' | 'recovered' | 'failed') => void;
+    onSubmitStatusChange?: (status: WhiteboardSubmitStatus) => void;
+    realtimeEndpoint?: string;
+    recoveryPort?: WhiteboardRecoveryPort;
+    socketFactory?: (endpoint: string, options: {
+        auth: {
+            token: string;
+        };
+        path: string;
+    }) => SocketLike;
+}
+
+declare interface WhiteboardSceneObject {
+    objectId: string;
+    objectType: string;
+    latestRevision: number;
+    payload: Record<string, unknown>;
+}
+
+declare type WhiteboardShapeKind = (typeof whiteboardShapeKinds)[number];
+
+declare const whiteboardShapeKinds: readonly ["line", "arrow", "double-arrow", "rectangle", "shaded-rectangle", "filled-rectangle", "circle", "shaded-circle", "filled-circle", "diamond", "shaded-diamond", "filled-diamond"];
+
+declare interface WhiteboardShapeObjectPayload extends Record<string, unknown> {
+    kind: WhiteboardShapeKind;
+    color: string;
+    widthPreset: WhiteboardStrokeWidthPreset;
+    start: WhiteboardNormalizedPoint;
+    end: WhiteboardNormalizedPoint;
+}
+
+declare interface WhiteboardStrokeObjectPayload extends Record<string, unknown> {
+    kind: WhiteboardFreehandKind;
+    color: string;
+    widthPreset: WhiteboardStrokeWidthPreset;
+    points: WhiteboardNormalizedPoint[];
+    vanishAt?: string;
+}
+
+declare type WhiteboardStrokeWidthPreset = (typeof whiteboardStrokeWidthPresets)[number];
+
+declare const whiteboardStrokeWidthPresets: readonly ["xs", "sm", "md", "lg"];
+
+declare type WhiteboardSubmitStatus = {
+    state: 'idle';
+} | {
+    state: 'submitting';
+    operationId: string;
+} | {
+    state: 'accepted';
+    operationId: string;
+} | {
+    state: 'conflict';
+    operationId: string;
+    expectedBaseRevision: number;
+} | {
+    state: 'forbidden';
+    operationId: string;
+} | {
+    state: 'board_not_ready';
+    operationId: string;
+} | {
+    state: 'unavailable';
+    operationId: string;
+    retryAfterMs?: number;
+};
+
+declare type WhiteboardUnavailableReason = (typeof whiteboardUnavailableReasons)[number];
+
+declare const whiteboardUnavailableReasons: readonly ["TOKEN_EXCHANGE_FAILED", "WHITEBOARD_UNAVAILABLE"];
+
+export { }