mediasfu-shared 1.0.6 → 1.2.0

package/dist/methods/utils/headless/moderation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"moderation.d.ts","sourceRoot":"","sources":["../../../../src/methods/utils/headless/moderation.ts"],"names":[],"mappings":"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"}

package/dist/methods/utils/headless/participantState.d.ts

@@ -0,0 +1,128 @@
+import { Participant } from '../../../types/types';
+import { HeadlessOptions } from './headlessTypes';
+export interface ParticipantMediaState {
+    participant: Participant | null;
+    /** The participant's own display name, or '' when unresolved. */
+    name: string;
+    /** True when this row is the local user. */
+    isSelf: boolean;
+    /** True when the participant is a host (islevel '2'). */
+    isHost: boolean;
+    /** True when the participant is publishing a camera. */
+    hasVideo: boolean;
+    /** True when the participant is publishing a microphone. */
+    hasAudio: boolean;
+    /** True when the participant's microphone is muted. */
+    muted: boolean;
+    /** The camera producer id, or '' when not publishing. */
+    videoProducerId: string;
+    /** The microphone producer id, or '' when not publishing. */
+    audioProducerId: string;
+}
+export interface GetParticipantMediaStateOptions extends HeadlessOptions {
+    /** Match by display name. */
+    name?: string;
+    /** Match by participant id. Takes precedence over `name`. */
+    id?: string;
+}
+export type GetParticipantMediaStateType = (options: GetParticipantMediaStateOptions) => ParticipantMediaState;
+/**
+ * Whether a participant is publishing, and what to label them.
+ *
+ * "Is this person on camera?" is not `participant.muted` and not the presence of
+ * a stream in your grid — it is whether `videoID` holds a real producer
+ * reference. MediaSFU writes the string `'none'` rather than an empty value when
+ * there is no producer, which is why a naive truthiness check reports everyone
+ * as publishing.
+ *
+ * @example
+ * ```ts
+ * import { getParticipantMediaState } from 'mediasfu-shared';
+ *
+ * const paul = getParticipantMediaState({ parameters, name: 'Paul' });
+ * if (paul.hasVideo) renderCamera(paul.videoProducerId);
+ * ```
+ */
+export declare function getParticipantMediaState({ parameters, name, id, }: GetParticipantMediaStateOptions): ParticipantMediaState;
+export type ListParticipantMediaStatesType = (options: HeadlessOptions) => ParticipantMediaState[];
+/** {@link getParticipantMediaState} for everyone currently in the room. */
+export declare function listParticipantMediaStates({ parameters, }: HeadlessOptions): ParticipantMediaState[];
+export interface ActiveSpeaker {
+    /** Loudest participant's display name, or '' when the room is quiet. */
+    name: string;
+    /** That participant's average loudness. */
+    level: number;
+    participant: Participant | null;
+}
+export type GetActiveSpeakerType = (options: HeadlessOptions) => ActiveSpeaker;
+/**
+ * The loudest participant right now.
+ *
+ * Reads `audioDecibels`, which the SDK maintains per participant. MediaSFU's own
+ * grids treat roughly 127.5 as the noise floor, so quieter rooms report no
+ * active speaker rather than flickering between people.
+ *
+ * @example
+ * ```ts
+ * const speaker = getActiveSpeaker({ parameters });
+ * if (speaker.name) highlight(speaker.name);
+ * ```
+ */
+export declare function getActiveSpeaker({ parameters }: HeadlessOptions): ActiveSpeaker;
+export interface MediaDeviceList {
+    cameras: MediaDeviceInfo[];
+    microphones: MediaDeviceInfo[];
+}
+export type ListMediaDevicesType = (options: HeadlessOptions) => Promise<MediaDeviceList>;
+/**
+ * Cameras and microphones available for a device picker.
+ *
+ * Uses the SDK's own `getMediaDevicesList` when the bag exposes it, so the
+ * result reflects the same `mediaDevices` instance the SDK captures with;
+ * otherwise falls back to `navigator.mediaDevices.enumerateDevices()`.
+ *
+ * Labels are blank until the user has granted permission once — call this after
+ * the first successful capture if you need readable device names.
+ *
+ * @example
+ * ```ts
+ * const { cameras } = await listMediaDevices({ parameters });
+ * await runMediaControl({
+ *   parameters,
+ *   control: 'switchVideo',
+ *   extra: { videoPreference: cameras[1].deviceId },
+ * });
+ * ```
+ */
+export declare function listMediaDevices({ parameters, }: HeadlessOptions): Promise<MediaDeviceList>;
+export interface SelectedDevices {
+    /** Device id of the camera currently in use, or '' when none is selected. */
+    cameraId: string;
+    /** Device id of the microphone currently in use, or '' when none is selected. */
+    microphoneId: string;
+    /** Cameras the SDK has enumerated for this room. */
+    cameras: MediaDeviceInfo[];
+    /** Microphones the SDK has enumerated for this room. */
+    microphones: MediaDeviceInfo[];
+}
+export type GetSelectedDevicesType = (options: HeadlessOptions) => SelectedDevices;
+/**
+ * Which camera and microphone the SDK is actually using, plus the device lists
+ * it has already enumerated.
+ *
+ * Unlike {@link listMediaDevices} this is synchronous and needs no permission
+ * prompt: it reads `userDefaultVideoInputDevice` / `userDefaultAudioInputDevice`
+ * and the `videoInputs` / `audioInputs` the SDK populated during setup. Use it
+ * to mark the current entry in a device picker; use `listMediaDevices` when you
+ * need a freshly enumerated list.
+ *
+ * @example
+ * ```tsx
+ * const { cameras, cameraId } = getSelectedDevices({ parameters });
+ * <select value={cameraId} onChange={(e) => room.controls.selectCamera(e.target.value)}>
+ *   {cameras.map((d) => <option key={d.deviceId} value={d.deviceId}>{d.label}</option>)}
+ * </select>
+ * ```
+ */
+export declare function getSelectedDevices({ parameters }: HeadlessOptions): SelectedDevices;
+//# sourceMappingURL=participantState.d.ts.map

package/dist/methods/utils/headless/participantState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"participantState.d.ts","sourceRoot":"","sources":["../../../../src/methods/utils/headless/participantState.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,EAAE,eAAe,EAAsB,MAAM,iBAAiB,CAAC;AAkBtE,MAAM,WAAW,qBAAqB;IACpC,WAAW,EAAE,WAAW,GAAG,IAAI,CAAC;IAChC,iEAAiE;IACjE,IAAI,EAAE,MAAM,CAAC;IACb,4CAA4C;IAC5C,MAAM,EAAE,OAAO,CAAC;IAChB,yDAAyD;IACzD,MAAM,EAAE,OAAO,CAAC;IAChB,wDAAwD;IACxD,QAAQ,EAAE,OAAO,CAAC;IAClB,4DAA4D;IAC5D,QAAQ,EAAE,OAAO,CAAC;IAClB,uDAAuD;IACvD,KAAK,EAAE,OAAO,CAAC;IACf,yDAAyD;IACzD,eAAe,EAAE,MAAM,CAAC;IACxB,6DAA6D;IAC7D,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,+BAAgC,SAAQ,eAAe;IACtE,6BAA6B;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,6DAA6D;IAC7D,EAAE,CAAC,EAAE,MAAM,CAAC;CACb;AAED,MAAM,MAAM,4BAA4B,GAAG,CACzC,OAAO,EAAE,+BAA+B,KACrC,qBAAqB,CAAC;AAE3B;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,wBAAwB,CAAC,EACvC,UAAU,EACV,IAAS,EACT,EAAO,GACR,EAAE,+BAA+B,GAAG,qBAAqB,CA0BzD;AAED,MAAM,MAAM,8BAA8B,GAAG,CAC3C,OAAO,EAAE,eAAe,KACrB,qBAAqB,EAAE,CAAC;AAE7B,2EAA2E;AAC3E,wBAAgB,0BAA0B,CAAC,EACzC,UAAU,GACX,EAAE,eAAe,GAAG,qBAAqB,EAAE,CAS3C;AAED,MAAM,WAAW,aAAa;IAC5B,wEAAwE;IACxE,IAAI,EAAE,MAAM,CAAC;IACb,2CAA2C;IAC3C,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,WAAW,GAAG,IAAI,CAAC;CACjC;AAED,MAAM,MAAM,oBAAoB,GAAG,CAAC,OAAO,EAAE,eAAe,KAAK,aAAa,CAAC;AAE/E;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,UAAU,EAAE,EAAE,eAAe,GAAG,aAAa,CAkB/E;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,WAAW,EAAE,eAAe,EAAE,CAAC;CAChC;AAED,MAAM,MAAM,oBAAoB,GAAG,CACjC,OAAO,EAAE,eAAe,KACrB,OAAO,CAAC,eAAe,CAAC,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,gBAAgB,CAAC,EACrC,UAAU,GACX,EAAE,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,CAqB5C;AAED,MAAM,WAAW,eAAe;IAC9B,6EAA6E;IAC7E,QAAQ,EAAE,MAAM,CAAC;IACjB,iFAAiF;IACjF,YAAY,EAAE,MAAM,CAAC;IACrB,oDAAoD;IACpD,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,wDAAwD;IACxD,WAAW,EAAE,eAAe,EAAE,CAAC;CAChC;AAED,MAAM,MAAM,sBAAsB,GAAG,CAAC,OAAO,EAAE,eAAe,KAAK,eAAe,CAAC;AAEnF;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,UAAU,EAAE,EAAE,eAAe,GAAG,eAAe,CAQnF"}

package/dist/methods/utils/headless/playback.d.ts

@@ -0,0 +1,106 @@
+import { HeadlessOptions } from './headlessTypes';
+/**
+ * Explicit playback: HLS and WHEP.
+ *
+ * **This is deliberately not part of the media-card surface.** WebRTC media is
+ * *auto-consumed* — the SDK subscribes for you, and `getRemoteVideoStreams` /
+ * `getAudioGridComponents` hand you what already arrived. HLS and WHEP are the
+ * opposite: nothing is consumed until you ask, because each one opens a
+ * connection the room did not ask for and would otherwise pay for.
+ *
+ * So the API here is imperative — `attachPlayback` / `detachPlayback` — rather
+ * than a reactive getter. Mixing these into the media cards would mean every
+ * room silently opened an HLS or WHEP connection whether or not anything
+ * rendered it.
+ *
+ * When to reach for which:
+ *
+ * | | latency | cost per viewer | use it for |
+ * | --- | --- | --- | --- |
+ * | WebRTC (auto) | sub-second | an SFU consumer | anyone who takes part |
+ * | WHEP | sub-second | an SFU consumer | standards-based egress to non-SDK players |
+ * | HLS | seconds | a CDN request | audiences too large to fan out over the SFU |
+ *
+ * A large passive audience on HLS is the reason this exists: it moves the
+ * expensive part — media fan-out — off the SFU.
+ */
+export type PlaybackProtocol = 'hls' | 'whep';
+export interface PlaybackSource {
+    protocol: PlaybackProtocol;
+    url: string;
+}
+/**
+ * Playback URLs the server has published for this room.
+ *
+ * Returns nothing when the room has none — HLS and WHEP are provisioned
+ * server-side, so absence means "not enabled for this room", not an error.
+ */
+export declare function getPlaybackSources({ parameters }: HeadlessOptions): PlaybackSource[];
+/** A running playback. Always `detachPlayback` it — none of this is garbage-collected. */
+export interface PlaybackHandle {
+    protocol: PlaybackProtocol;
+    url: string;
+    /** The media, when the protocol produces one directly (WHEP). */
+    stream: MediaStream | null;
+    /** Release the connection, the player, and the element's source. */
+    detach: () => void;
+}
+export interface AttachPlaybackOptions {
+    /** Playback URL, or a `PlaybackSource` from `getPlaybackSources`. */
+    source: string | PlaybackSource;
+    /** The element to play into. Required for HLS; optional for WHEP. */
+    video?: HTMLVideoElement | null;
+    /** Force a protocol. Inferred from the URL when omitted. */
+    protocol?: PlaybackProtocol;
+    /**
+     * Factory returning an hls.js instance, e.g. `() => new Hls({ lowLatencyMode: true })`.
+     *
+     * Required for HLS anywhere except Safari, and injected rather than imported
+     * so hls.js never becomes a dependency of this SDK — most rooms never play
+     * HLS, and React Native cannot use it at all.
+     */
+    hlsFactory?: () => any;
+    /** Extra headers for the WHEP POST, e.g. an auth token. */
+    headers?: Record<string, string>;
+    /** ICE servers for WHEP. Defaults to the room's own when available. */
+    iceServers?: RTCIceServer[];
+}
+export type AttachPlaybackType = (options: AttachPlaybackOptions) => Promise<PlaybackHandle>;
+/**
+ * Start an explicit playback.
+ *
+ * @example
+ * ```ts
+ * import Hls from 'hls.js';
+ *
+ * const [source] = getPlaybackSources({ parameters });
+ * const handle = await attachPlayback({
+ *   source,
+ *   video: videoRef.current,
+ *   hlsFactory: () => new Hls({ lowLatencyMode: true }),
+ * });
+ * // later, always:
+ * detachPlayback(handle);
+ * ```
+ */
+export declare function attachPlayback({ source, video, protocol, hlsFactory, headers, iceServers, }: AttachPlaybackOptions): Promise<PlaybackHandle>;
+/** Stop a playback and release everything it holds. Safe to call twice. */
+export declare function detachPlayback(handle: PlaybackHandle | null | undefined): void;
+export interface PublishWhipOptions {
+    /** The WHIP endpoint. */
+    url: string;
+    /** The stream to publish. */
+    stream: MediaStream;
+    headers?: Record<string, string>;
+    iceServers?: RTCIceServer[];
+}
+/**
+ * Publish a stream to a WHIP endpoint.
+ *
+ * The symmetric counterpart of WHEP, and equally explicit. This is *not* how
+ * you publish into a MediaSFU room — use `produceMedia` for that, which goes
+ * through the room's own transport and respects its capture entitlements. WHIP
+ * is for pushing to a standards-based ingest that is not this room.
+ */
+export declare function publishWhip({ url, stream, headers, iceServers, }: PublishWhipOptions): Promise<PlaybackHandle>;
+//# sourceMappingURL=playback.d.ts.map

package/dist/methods/utils/headless/playback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"playback.d.ts","sourceRoot":"","sources":["../../../../src/methods/utils/headless/playback.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAsB,MAAM,iBAAiB,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,MAAM,MAAM,gBAAgB,GAAG,KAAK,GAAG,MAAM,CAAC;AAE9C,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,UAAU,EAAE,EAAE,eAAe,GAAG,cAAc,EAAE,CASpF;AAED,0FAA0F;AAC1F,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,iEAAiE;IACjE,MAAM,EAAE,WAAW,GAAG,IAAI,CAAC;IAC3B,oEAAoE;IACpE,MAAM,EAAE,MAAM,IAAI,CAAC;CACpB;AAED,MAAM,WAAW,qBAAqB;IACpC,qEAAqE;IACrE,MAAM,EAAE,MAAM,GAAG,cAAc,CAAC;IAChC,qEAAqE;IACrE,KAAK,CAAC,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAChC,4DAA4D;IAC5D,QAAQ,CAAC,EAAE,gBAAgB,CAAC;IAC5B;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,MAAM,GAAG,CAAC;IACvB,2DAA2D;IAC3D,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,uEAAuE;IACvE,UAAU,CAAC,EAAE,YAAY,EAAE,CAAC;CAC7B;AAkJD,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,EAAE,qBAAqB,KAAK,OAAO,CAAC,cAAc,CAAC,CAAC;AAE7F;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,cAAc,CAAC,EACnC,MAAM,EACN,KAAK,EACL,QAAQ,EACR,UAAU,EACV,OAAO,EACP,UAAU,GACX,EAAE,qBAAqB,GAAG,OAAO,CAAC,cAAc,CAAC,CAUjD;AAED,2EAA2E;AAC3E,wBAAgB,cAAc,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,CAG9E;AAMD,MAAM,WAAW,kBAAkB;IACjC,yBAAyB;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,6BAA6B;IAC7B,MAAM,EAAE,WAAW,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,UAAU,CAAC,EAAE,YAAY,EAAE,CAAC;CAC7B;AAED;;;;;;;GAOG;AACH,wBAAsB,WAAW,CAAC,EAChC,GAAG,EACH,MAAM,EACN,OAAY,EACZ,UAAU,GACX,EAAE,kBAAkB,GAAG,OAAO,CAAC,cAAc,CAAC,CAsC9C"}

package/dist/methods/utils/headless/roomActions.d.ts

@@ -0,0 +1,88 @@
+import { HeadlessOptions } from './headlessTypes';
+export interface HeadlessActionResult {
+    ok: boolean;
+    /** Empty when `ok`; otherwise a short, user-safe explanation. */
+    error: string;
+}
+export interface LeaveRoomOptions extends HeadlessOptions {
+    /** Ban the member on the way out. Requires host privileges. */
+    ban?: boolean;
+    /** Whether a host exit should end the room for everyone. Defaults to true. */
+    endRoomOnHostExit?: boolean;
+}
+export type LeaveRoomType = (options: LeaveRoomOptions) => Promise<HeadlessActionResult>;
+/**
+ * Leave the room from a headless surface.
+ *
+ * Without this you have to pull `socket`, `localSocket`, `member` and `roomName`
+ * off the bag yourself and hand them to `confirmExit` — four chances to pass a
+ * stale value, and a silent no-op when you do.
+ *
+ * Never throws: a failed exit comes back as `{ ok: false, error }` so a Leave
+ * button can report why rather than appearing to work.
+ *
+ * @example
+ * ```ts
+ * import { leaveRoom } from 'mediasfu-shared';
+ *
+ * const result = await leaveRoom({
+ *   parameters: parameterStore.getCurrent(),
+ *   endRoomOnHostExit: false,
+ * });
+ * if (!result.ok) setNotice(result.error);
+ * ```
+ */
+export declare function leaveRoom({ parameters, ban, endRoomOnHostExit, }: LeaveRoomOptions): Promise<HeadlessActionResult>;
+export interface SendChatMessageOptions extends HeadlessOptions {
+    message: string;
+    /** Specific recipients. Empty (default) sends to the group. */
+    receivers?: string[];
+    /** Send to everyone. Defaults to true when `receivers` is empty. */
+    group?: boolean;
+}
+export type SendChatMessageType = (options: SendChatMessageOptions) => Promise<HeadlessActionResult>;
+/**
+ * Send a chat message from a headless surface.
+ *
+ * `sendMessage` takes eleven fields that all have to be lifted off the bag in
+ * the right combination; this resolves them for you, including the
+ * `localSocket`-before-`socket` preference the SDK uses for chat.
+ *
+ * @example
+ * ```ts
+ * import { sendChatMessage } from 'mediasfu-shared';
+ *
+ * await sendChatMessage({ parameters, message: 'Hello everyone' });
+ * await sendChatMessage({ parameters, message: 'Just you', receivers: ['Paul'] });
+ * ```
+ */
+export declare function sendChatMessage({ parameters, message, receivers, group, }: SendChatMessageOptions): Promise<HeadlessActionResult>;
+export interface RunMediaControlOptions extends HeadlessOptions {
+    /** Which control to run. */
+    control: 'clickAudio' | 'clickVideo' | 'clickScreenShare' | 'switchAudio' | 'switchVideo' | 'switchVideoAlt';
+    /** Extra arguments, e.g. `{ audioPreference: deviceId }` for `switchAudio`. */
+    extra?: Record<string, any>;
+}
+export type RunMediaControlType = (options: RunMediaControlOptions) => Promise<HeadlessActionResult>;
+/**
+ * Invoke a media control safely from a headless surface.
+ *
+ * Gates on {@link getRoomReadiness} first — firing `clickVideo` before the
+ * transport exists fails silently and looks like a dead button — then resolves
+ * the control off the current bag rather than a snapshot the caller captured
+ * earlier.
+ *
+ * @example
+ * ```ts
+ * import { runMediaControl } from 'mediasfu-shared';
+ *
+ * await runMediaControl({ parameters, control: 'clickVideo' });
+ * await runMediaControl({
+ *   parameters,
+ *   control: 'switchVideo',
+ *   extra: { videoPreference: deviceId },
+ * });
+ * ```
+ */
+export declare function runMediaControl({ parameters, control, extra, }: RunMediaControlOptions): Promise<HeadlessActionResult>;
+//# sourceMappingURL=roomActions.d.ts.map

package/dist/methods/utils/headless/roomActions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roomActions.d.ts","sourceRoot":"","sources":["../../../../src/methods/utils/headless/roomActions.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAsB,MAAM,iBAAiB,CAAC;AAItE,MAAM,WAAW,oBAAoB;IACnC,EAAE,EAAE,OAAO,CAAC;IACZ,iEAAiE;IACjE,KAAK,EAAE,MAAM,CAAC;CACf;AAcD,MAAM,WAAW,gBAAiB,SAAQ,eAAe;IACvD,+DAA+D;IAC/D,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,8EAA8E;IAC9E,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED,MAAM,MAAM,aAAa,GAAG,CAC1B,OAAO,EAAE,gBAAgB,KACtB,OAAO,CAAC,oBAAoB,CAAC,CAAC;AAEnC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,SAAS,CAAC,EAC9B,UAAU,EACV,GAAW,EACX,iBAAwB,GACzB,EAAE,gBAAgB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAyBlD;AAED,MAAM,WAAW,sBAAuB,SAAQ,eAAe;IAC7D,OAAO,EAAE,MAAM,CAAC;IAChB,+DAA+D;IAC/D,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,oEAAoE;IACpE,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,MAAM,mBAAmB,GAAG,CAChC,OAAO,EAAE,sBAAsB,KAC5B,OAAO,CAAC,oBAAoB,CAAC,CAAC;AAEnC;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,eAAe,CAAC,EACpC,UAAU,EACV,OAAO,EACP,SAAc,EACd,KAAK,GACN,EAAE,sBAAsB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAiCxD;AAED,MAAM,WAAW,sBAAuB,SAAQ,eAAe;IAC7D,4BAA4B;IAC5B,OAAO,EACH,YAAY,GACZ,YAAY,GACZ,kBAAkB,GAClB,aAAa,GACb,aAAa,GACb,gBAAgB,CAAC;IACrB,+EAA+E;IAC/E,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC7B;AAED,MAAM,MAAM,mBAAmB,GAAG,CAChC,OAAO,EAAE,sBAAsB,KAC5B,OAAO,CAAC,oBAAoB,CAAC,CAAC;AAEnC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,eAAe,CAAC,EACpC,UAAU,EACV,OAAO,EACP,KAAK,GACN,EAAE,sBAAsB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAkCxD"}

package/dist/methods/utils/headless/sessionControls.d.ts

@@ -0,0 +1,159 @@
+import { HeadlessOptions } from './headlessTypes';
+import { HeadlessActionResult } from './roomActions';
+export interface SwitchDeviceOptions extends HeadlessOptions {
+    /** `deviceId` from `listMediaDevices()`. */
+    deviceId: string;
+}
+export type SwitchCameraType = (options: SwitchDeviceOptions) => Promise<HeadlessActionResult>;
+/**
+ * Switch to a different camera.
+ *
+ * Pairs with `listMediaDevices()` / `getSelectedDevices()`, which could
+ * previously only report devices with no way to act on them.
+ *
+ * Goes through the SDK's own `switchUserVideo`, so the producer track is
+ * replaced on the existing transport — remote viewers see the new camera
+ * without the call renegotiating — and host restrictions still apply. A refusal
+ * (blocked by the host, audio-only event) is returned as `ok: false` with the
+ * reason rather than resolving silently.
+ *
+ * @example
+ * ```ts
+ * const { video } = await listMediaDevices();
+ * await switchCamera({ parameters, deviceId: video[1].deviceId });
+ * ```
+ */
+export declare function switchCamera({ parameters, deviceId, }: SwitchDeviceOptions): Promise<HeadlessActionResult>;
+/**
+ * Flip between the front and rear cameras.
+ *
+ * This toggles — the SDK's `switchVideoAlt` swaps whichever facing mode is
+ * current and takes no target, so there is no way to ask for "front"
+ * specifically. Use `switchCamera` with a deviceId when you need to land on a
+ * particular camera; use this on mobile, where device ids are unstable across
+ * sessions but the flip gesture is what users expect.
+ */
+export declare function flipCamera({ parameters }: HeadlessOptions): Promise<HeadlessActionResult>;
+export type SwitchMicrophoneType = (options: SwitchDeviceOptions) => Promise<HeadlessActionResult>;
+/** Switch to a different microphone. The audio counterpart of `switchCamera`. */
+export declare function switchMicrophone({ parameters, deviceId, }: SwitchDeviceOptions): Promise<HeadlessActionResult>;
+/** 'allow' — anyone may; 'approval' — must ask the host; 'disallow' — nobody may. */
+export type RoomPolicyValue = 'allow' | 'approval' | 'disallow';
+export interface SetRoomMediaPolicyOptions extends HeadlessOptions {
+    audio?: RoomPolicyValue;
+    video?: RoomPolicyValue;
+    screenshare?: RoomPolicyValue;
+    chat?: RoomPolicyValue;
+}
+/**
+ * Set what participants are allowed to do — the room-wide policy behind the
+ * SDK's settings modal.
+ *
+ * This is the *rule*, not a one-off action: `setParticipantMedia` (moderation)
+ * turns one person's camera off now, whereas `video: 'approval'` here means
+ * everyone must ask before turning one on. `getMediaPermissions()` reads the
+ * same four values back.
+ *
+ * Host only. Any value left undefined keeps its current setting.
+ *
+ * @example
+ * ```ts
+ * await setRoomMediaPolicy({ parameters, audio: 'approval', screenshare: 'disallow' });
+ * ```
+ */
+export declare function setRoomMediaPolicy({ parameters, audio, video, screenshare, chat, }: SetRoomMediaPolicyOptions): Promise<HeadlessActionResult>;
+export interface ChatMessage {
+    sender: string;
+    message: string;
+    timestamp: string;
+    /** Recipients — empty/[] means it went to everyone. */
+    receivers: string[];
+    /** True when this is a direct message rather than a room-wide one. */
+    direct: boolean;
+    /** True when the local user sent it. */
+    mine: boolean;
+}
+export interface GetChatMessagesOptions extends HeadlessOptions {
+    /** 'all' (default), 'group' for room-wide only, or 'direct' for DMs only. */
+    scope?: 'all' | 'group' | 'direct';
+    /** Only messages exchanged with this person. Implies direct messages. */
+    withPerson?: string;
+}
+/**
+ * Read the chat.
+ *
+ * `sendChatMessage` existed with no way to read replies, so a headless surface
+ * could talk but not listen. Direct messages are flagged and filterable, since
+ * rendering a DM in the room-wide thread leaks it to the wrong audience.
+ *
+ * Call from `onMediaChanged` or a render to get the current list.
+ */
+export declare function getChatMessages({ parameters, scope, withPerson, }: GetChatMessagesOptions): ChatMessage[];
+export interface PendingApprovals {
+    /** People held in the waiting room. */
+    waiting: {
+        name: string;
+        id: string;
+    }[];
+    /** Requests to unmute, turn a camera on, share, or chat. */
+    requests: {
+        id: string;
+        name: string;
+        icon: string;
+        username: string;
+    }[];
+    /** Total items needing a host decision. */
+    total: number;
+}
+/**
+ * Everything currently awaiting a host decision.
+ *
+ * `respondToWaitingParticipant` and `respondToParticipantRequest` could act on
+ * these but nothing could list them, so a headless host had no way to know a
+ * decision was pending. Badge `total` and render the two lists.
+ */
+export declare function getPendingApprovals({ parameters }: HeadlessOptions): PendingApprovals;
+export interface SessionTimer {
+    /** Elapsed wall time, formatted by the SDK (e.g. "12:04"). */
+    elapsed: string;
+    /**
+     * True while the server is asking whether you are still there — see
+     * `getPresenceCheck`, which you must answer or be disconnected.
+     */
+    presenceCheckPending: boolean;
+}
+/**
+ * How long the session has been running.
+ *
+ * Deliberately does not report "time remaining": the server sends that on the
+ * `meetingTimeRemaining` event, which the SDK forwards straight to `showAlert`
+ * without storing it. There is no field to read, and inventing one from the
+ * last alert would be a guess. Watch `showAlert` if you need the warning.
+ */
+export declare function getSessionTimer({ parameters }: HeadlessOptions): SessionTimer;
+export interface PresenceCheck {
+    /** True while the "are you still there?" check is waiting on an answer. */
+    pending: boolean;
+}
+/**
+ * Whether the server is currently asking if you are still there.
+ *
+ * **This matters more headlessly than it looks.** On an idle room the server
+ * emits `meetingStillThere`, and the SDK opens a modal that counts down and
+ * then emits `disconnectUser`. With `returnUI={false}` that modal is still
+ * mounted — inside a root collapsed to 0×0 — so the countdown runs invisibly
+ * and the session is dropped with nothing shown and nothing to click.
+ *
+ * Poll this (from `onMediaChanged`, or a timer) and call `confirmStillHere`
+ * to stay in the room.
+ */
+export declare function getPresenceCheck({ parameters }: HeadlessOptions): PresenceCheck;
+/**
+ * Answer the "are you still there?" check and stay in the room.
+ *
+ * Closing the check is the whole answer — the SDK only disconnects on the
+ * countdown expiring, so cancelling it is what keeps the session alive. Safe to
+ * call when nothing is pending.
+ */
+export declare function confirmStillHere({ parameters }: HeadlessOptions): HeadlessActionResult;
+//# sourceMappingURL=sessionControls.d.ts.map

package/dist/methods/utils/headless/sessionControls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessionControls.d.ts","sourceRoot":"","sources":["../../../../src/methods/utils/headless/sessionControls.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAsB,MAAM,iBAAiB,CAAC;AAEtE,OAAO,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAuCrD,MAAM,WAAW,mBAAoB,SAAQ,eAAe;IAC1D,4CAA4C;IAC5C,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,EAAE,mBAAmB,KAAK,OAAO,CAAC,oBAAoB,CAAC,CAAC;AAE/F;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,YAAY,CAAC,EACjC,UAAU,EACV,QAAQ,GACT,EAAE,mBAAmB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAIrD;AAED;;;;;;;;GAQG;AACH,wBAAsB,UAAU,CAAC,EAAE,UAAU,EAAE,EAAE,eAAe,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAG/F;AAED,MAAM,MAAM,oBAAoB,GAAG,CAAC,OAAO,EAAE,mBAAmB,KAAK,OAAO,CAAC,oBAAoB,CAAC,CAAC;AAEnG,iFAAiF;AACjF,wBAAsB,gBAAgB,CAAC,EACrC,UAAU,EACV,QAAQ,GACT,EAAE,mBAAmB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAIrD;AAMD,qFAAqF;AACrF,MAAM,MAAM,eAAe,GAAG,OAAO,GAAG,UAAU,GAAG,UAAU,CAAC;AAEhE,MAAM,WAAW,yBAA0B,SAAQ,eAAe;IAChE,KAAK,CAAC,EAAE,eAAe,CAAC;IACxB,KAAK,CAAC,EAAE,eAAe,CAAC;IACxB,WAAW,CAAC,EAAE,eAAe,CAAC;IAC9B,IAAI,CAAC,EAAE,eAAe,CAAC;CACxB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,kBAAkB,CAAC,EACvC,UAAU,EACV,KAAK,EACL,KAAK,EACL,WAAW,EACX,IAAI,GACL,EAAE,yBAAyB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CA+B3D;AAMD,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,uDAAuD;IACvD,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,sEAAsE;IACtE,MAAM,EAAE,OAAO,CAAC;IAChB,wCAAwC;IACxC,IAAI,EAAE,OAAO,CAAC;CACf;AAED,MAAM,WAAW,sBAAuB,SAAQ,eAAe;IAC7D,6EAA6E;IAC7E,KAAK,CAAC,EAAE,KAAK,GAAG,OAAO,GAAG,QAAQ,CAAC;IACnC,yEAAyE;IACzE,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,EAC9B,UAAU,EACV,KAAa,EACb,UAAe,GAChB,EAAE,sBAAsB,GAAG,WAAW,EAAE,CA2BxC;AAED,MAAM,WAAW,gBAAgB;IAC/B,uCAAuC;IACvC,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACxC,4DAA4D;IAC5D,QAAQ,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACzE,2CAA2C;IAC3C,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,UAAU,EAAE,EAAE,eAAe,GAAG,gBAAgB,CAkBrF;AAED,MAAM,WAAW,YAAY;IAC3B,8DAA8D;IAC9D,OAAO,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,oBAAoB,EAAE,OAAO,CAAC;CAC/B;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,EAAE,UAAU,EAAE,EAAE,eAAe,GAAG,YAAY,CAM7E;AAED,MAAM,WAAW,aAAa;IAC5B,2EAA2E;IAC3E,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,UAAU,EAAE,EAAE,eAAe,GAAG,aAAa,CAG/E;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,UAAU,EAAE,EAAE,eAAe,GAAG,oBAAoB,CAQtF"}