@maravilla-labs/platform 0.1.27 → 0.1.28

package/dist/index.d.ts

@@ -1,3 +1,52 @@
+import { LocalParticipant } from 'livekit-client';
+
+/**
+ * Media service for video/audio room management.
+ *
+ * In production (Deno runtime) calls go through `Deno.core.ops`.
+ * In development they are proxied as HTTP requests to the dev-server.
+ */
+interface MediaRoomInfo {
+    name: string;
+    numParticipants: number;
+    maxParticipants: number;
+    createdAt: number;
+    active: boolean;
+}
+interface MediaRoomInfoSettings {
+    maxParticipants?: number;
+    emptyTimeoutSecs?: number;
+}
+interface MediaParticipantInfo {
+    identity: string;
+    name: string;
+    canPublish?: boolean;
+    canSubscribe?: boolean;
+    canPublishData?: boolean;
+}
+interface MediaTokenResult {
+    token: string;
+    url: string;
+}
+interface MediaService {
+    createRoom(roomId: string, settings?: MediaRoomInfoSettings): Promise<MediaRoomInfo>;
+    deleteRoom(roomId: string): Promise<void>;
+    listRooms(): Promise<MediaRoomInfo[]>;
+    generateToken(roomId: string, participant: MediaParticipantInfo): Promise<MediaTokenResult>;
+    mediaUrl(): Promise<string | null>;
+}
+declare class RemoteMediaService implements MediaService {
+    private baseUrl;
+    private headers;
+    constructor(baseUrl: string, headers: Record<string, string>);
+    private fetch;
+    createRoom(roomId: string, settings?: MediaRoomInfoSettings): Promise<MediaRoomInfo>;
+    deleteRoom(roomId: string): Promise<void>;
+    listRooms(): Promise<MediaRoomInfo[]>;
+    generateToken(roomId: string, participant: MediaParticipantInfo): Promise<MediaTokenResult>;
+    mediaUrl(): Promise<string | null>;
+}
+
 /**
  * Key-Value namespace interface for storing and retrieving data.
  * Similar to Cloudflare Workers KV API for familiar developer experience.
@@ -528,6 +577,8 @@ interface PlatformEnv {
 interface Platform {
     /** Environment containing all available platform services */
     env: PlatformEnv;
+    /** Media service for video/audio room management (optional — available when media is configured) */
+    media?: MediaService;
 }
 
 interface RenEvent {
@@ -538,6 +589,9 @@ interface RenEvent {
     ts?: number;
     src?: string;
     ns?: string;
+    ch?: string;
+    data?: any;
+    uid?: string;
     [extra: string]: any;
 }
 interface RenClientOptions {
@@ -574,6 +628,192 @@ declare function renFetch(input: string | URL | Request, init?: RequestInit, cli
 declare function storageUpload(path: string, file: Blob | File, clientId?: string): Promise<any>;
 declare function storageDelete(path: string, clientId?: string): Promise<any>;
 
+interface RealtimeEvent {
+    event: string;
+    channel: string;
+    data?: any;
+    from?: string;
+    userId?: string;
+    ts?: number;
+    metadata?: any;
+}
+interface PresenceMember {
+    userId: string;
+    metadata?: any;
+    lastSeen?: number;
+}
+interface RealtimeClientOptions {
+    /** WebSocket endpoint (default: auto-detect) */
+    wsEndpoint?: string;
+    /** Client ID (persistent across sessions) */
+    clientId?: string;
+    /** Auto-reconnect on disconnect (default: true) */
+    autoReconnect?: boolean;
+    /** Max reconnect backoff in ms (default: 15000) */
+    maxBackoffMs?: number;
+    /** Enable debug logging (default: false) */
+    debug?: boolean;
+}
+type EventCallback$1 = (event: RealtimeEvent) => void;
+type Unsubscribe = () => void;
+declare class RealtimeClient {
+    private wsEndpoint;
+    private clientId;
+    private ws;
+    private closed;
+    private attempt;
+    private autoReconnect;
+    private maxBackoff;
+    private debug;
+    private channelListeners;
+    private globalListeners;
+    private presenceListeners;
+    private subscribedChannels;
+    private pendingMessages;
+    constructor(opts?: RealtimeClientOptions);
+    private detectEndpoint;
+    private log;
+    /** Connect to the realtime WebSocket server */
+    connect(): void;
+    private scheduleReconnect;
+    private sendRaw;
+    private dispatch;
+    /** Subscribe to messages on a channel */
+    subscribe(channel: string, callback: EventCallback$1, options?: {
+        token?: string;
+    }): Unsubscribe;
+    /** Listen to all events across all channels */
+    onAny(callback: EventCallback$1): Unsubscribe;
+    /** Publish a message to a channel */
+    publish(channel: string, data: any, options?: {
+        userId?: string;
+    }): void;
+    /** Get a presence handle for a channel */
+    presence(channel: string): {
+        /** Join the channel with presence */
+        join: (userId: string, metadata?: any) => void;
+        /** Leave the channel */
+        leave: () => void;
+        /** Listen for users joining */
+        onJoin: (callback: (member: PresenceMember) => void) => Unsubscribe;
+        /** Listen for users leaving */
+        onLeave: (callback: (member: PresenceMember) => void) => Unsubscribe;
+    };
+    /** Get current client ID */
+    getClientId(): string;
+    /** Check if connected */
+    isConnected(): boolean;
+    /** Disconnect and stop reconnecting */
+    disconnect(): void;
+}
+
+declare enum MediaRoomEvent {
+    Connected = "connected",
+    Reconnecting = "reconnecting",
+    Reconnected = "reconnected",
+    Disconnected = "disconnected",
+    ParticipantJoined = "participantJoined",
+    ParticipantLeft = "participantLeft",
+    TrackSubscribed = "trackSubscribed",
+    TrackUnsubscribed = "trackUnsubscribed",
+    TrackMuted = "trackMuted",
+    TrackUnmuted = "trackUnmuted",
+    ActiveSpeakersChanged = "activeSpeakersChanged",
+    DataReceived = "dataReceived",
+    RecordingStatusChanged = "recordingStatusChanged",
+    MediaDevicesChanged = "mediaDevicesChanged"
+}
+type TrackSource = 'camera' | 'microphone' | 'screen_share' | 'screen_share_audio';
+type TrackKind = 'audio' | 'video';
+interface MediaTrackPublication {
+    trackSid: string;
+    source: TrackSource;
+    kind: TrackKind;
+    muted: boolean;
+    track?: MediaStreamTrack;
+}
+interface MediaParticipant {
+    identity: string;
+    name?: string;
+    metadata?: string;
+    isSpeaking: boolean;
+    audioLevel: number;
+    tracks: MediaTrackPublication[];
+}
+interface VideoResolution {
+    width: number;
+    height: number;
+    frameRate?: number;
+}
+interface MediaRoomOptions {
+    autoSubscribe?: boolean;
+    adaptiveStream?: boolean;
+    dynacast?: boolean;
+}
+/** Attach a media track to a video or audio element */
+declare function attachTrack(track: MediaStreamTrack, element: HTMLVideoElement | HTMLAudioElement): void;
+/** Detach media from an element */
+declare function detachTrack(element: HTMLVideoElement | HTMLAudioElement): void;
+declare class MediaLocalParticipant implements MediaParticipant {
+    private lp;
+    /** @internal */
+    constructor(lp: LocalParticipant);
+    get identity(): string;
+    get name(): string | undefined;
+    get metadata(): string | undefined;
+    get isSpeaking(): boolean;
+    get audioLevel(): number;
+    get tracks(): MediaTrackPublication[];
+    get isCameraEnabled(): boolean;
+    enableCamera(options?: {
+        deviceId?: string;
+        resolution?: VideoResolution;
+    }): Promise<void>;
+    disableCamera(): Promise<void>;
+    get isMicrophoneEnabled(): boolean;
+    enableMicrophone(options?: {
+        deviceId?: string;
+    }): Promise<void>;
+    disableMicrophone(): Promise<void>;
+    get isScreenShareEnabled(): boolean;
+    enableScreenShare(options?: {
+        audio?: boolean;
+    }): Promise<void>;
+    disableScreenShare(): Promise<void>;
+    setName(name: string): Promise<void>;
+    setMetadata(metadata: string): Promise<void>;
+    sendData(data: Uint8Array, options?: {
+        reliable?: boolean;
+    }): Promise<void>;
+}
+type EventCallback = (...args: any[]) => void;
+declare class MediaRoom {
+    private room;
+    private listeners;
+    private _localParticipant;
+    constructor();
+    connect(url: string, token: string, options?: MediaRoomOptions): Promise<void>;
+    disconnect(): Promise<void>;
+    get state(): 'disconnected' | 'connecting' | 'connected' | 'reconnecting';
+    get localParticipant(): MediaLocalParticipant;
+    get participants(): Map<string, MediaParticipant>;
+    get activeSpeakers(): MediaParticipant[];
+    get name(): string;
+    get numParticipants(): number;
+    get isRecording(): boolean;
+    on(event: MediaRoomEvent, callback: EventCallback): this;
+    off(event: MediaRoomEvent, callback: EventCallback): this;
+    private emit;
+    switchCamera(deviceId: string): Promise<void>;
+    switchMicrophone(deviceId: string): Promise<void>;
+    switchSpeaker(deviceId: string): Promise<void>;
+    static getDevices(): Promise<MediaDeviceInfo[]>;
+    static getCameras(): Promise<MediaDeviceInfo[]>;
+    static getMicrophones(): Promise<MediaDeviceInfo[]>;
+    static getSpeakers(): Promise<MediaDeviceInfo[]>;
+    private wireEvents;
+}
+
 /**
  * @fileoverview Maravilla Platform SDK
  *
@@ -694,4 +934,4 @@ declare function getPlatform(options?: {
  */
 declare function clearPlatformCache(): void;
 
-export { type Database, type DbFindOptions, type KvListResult, type KvNamespace, type Platform, type PlatformEnv, RenClient, type RenClientOptions, type RenEvent, type Storage$1 as Storage, type StoragePutStreamSource, clearPlatformCache, getOrCreateClientId, getPlatform, renFetch, storageDelete, storageUpload };
+export { type Database, type DbFindOptions, type KvListResult, type KvNamespace, MediaLocalParticipant, type MediaParticipant, type MediaParticipantInfo, MediaRoom, MediaRoomEvent, type MediaRoomInfo, type MediaRoomInfoSettings, type MediaRoomOptions, type MediaService, type MediaTokenResult, type MediaTrackPublication, type Platform, type PlatformEnv, type PresenceMember, RealtimeClient, type RealtimeClientOptions, type RealtimeEvent, RemoteMediaService, RenClient, type RenClientOptions, type RenEvent, type Storage$1 as Storage, type StoragePutStreamSource, type TrackKind, type TrackSource, type VideoResolution, attachTrack, clearPlatformCache, detachTrack, getOrCreateClientId, getPlatform, renFetch, storageDelete, storageUpload };