Update

client/js/dist/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * LeRobot Arena Client Library - TypeScript/JavaScript
+ *
+ * Main entry point for the robotics client library.
+ */
+export * as robotics from './robotics/index.js';
+export * as video from './video/index.js';
+export declare const VERSION = "1.0.0";

client/js/dist/robotics/consumer.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Consumer client for receiving robot commands in LeRobot Arena
+ */
+import { RoboticsClientCore } from './core.js';
+import type { WebSocketMessage, ClientOptions, JointUpdateCallback, StateSyncCallback } from './types.js';
+export declare class RoboticsConsumer extends RoboticsClientCore {
+    private onStateSyncCallback;
+    private onJointUpdateCallback;
+    constructor(baseUrl?: string, options?: ClientOptions);
+    connect(workspaceId: string, roomId: string, participantId?: string): Promise<boolean>;
+    getStateSyncAsync(): Promise<Record<string, number>>;
+    onStateSync(callback: StateSyncCallback): void;
+    onJointUpdate(callback: JointUpdateCallback): void;
+    protected handleRoleSpecificMessage(message: WebSocketMessage): void;
+    private handleStateSync;
+    private handleJointUpdate;
+    /**
+     * Create a consumer and automatically connect to a room
+     */
+    static createAndConnect(workspaceId: string, roomId: string, baseUrl?: string, participantId?: string): Promise<RoboticsConsumer>;
+}

client/js/dist/robotics/core.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Core robotics client for LeRobot Arena
+ * Base class providing REST API and WebSocket functionality
+ */
+import { EventEmitter } from 'eventemitter3';
+import type { ParticipantRole, RoomInfo, RoomState, ConnectionInfo, WebSocketMessage, ClientOptions, ErrorCallback, ConnectedCallback, DisconnectedCallback } from './types.js';
+export declare class RoboticsClientCore extends EventEmitter {
+    protected baseUrl: string;
+    protected apiBase: string;
+    protected websocket: WebSocket | null;
+    protected workspaceId: string | null;
+    protected roomId: string | null;
+    protected role: ParticipantRole | null;
+    protected participantId: string | null;
+    protected connected: boolean;
+    protected options: ClientOptions;
+    protected onErrorCallback: ErrorCallback | null;
+    protected onConnectedCallback: ConnectedCallback | null;
+    protected onDisconnectedCallback: DisconnectedCallback | null;
+    constructor(baseUrl?: string, options?: ClientOptions);
+    listRooms(workspaceId: string): Promise<RoomInfo[]>;
+    createRoom(workspaceId?: string, roomId?: string): Promise<{
+        workspaceId: string;
+        roomId: string;
+    }>;
+    deleteRoom(workspaceId: string, roomId: string): Promise<boolean>;
+    getRoomState(workspaceId: string, roomId: string): Promise<RoomState>;
+    getRoomInfo(workspaceId: string, roomId: string): Promise<RoomInfo>;
+    connectToRoom(workspaceId: string, roomId: string, role: ParticipantRole, participantId?: string): Promise<boolean>;
+    disconnect(): Promise<void>;
+    protected sendJoinMessage(): void;
+    protected handleMessage(message: WebSocketMessage): void;
+    protected handleRoleSpecificMessage(message: WebSocketMessage): void;
+    protected handleError(errorMessage: string): void;
+    sendHeartbeat(): Promise<void>;
+    isConnected(): boolean;
+    getConnectionInfo(): ConnectionInfo;
+    onError(callback: ErrorCallback): void;
+    onConnected(callback: ConnectedCallback): void;
+    onDisconnected(callback: DisconnectedCallback): void;
+    private fetchApi;
+    protected generateWorkspaceId(): string;
+}

client/js/dist/robotics/factory.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Factory functions for creating LeRobot Arena robotics clients
+ */
+import { RoboticsProducer } from './producer.js';
+import { RoboticsConsumer } from './consumer.js';
+import type { ParticipantRole, ClientOptions } from './types.js';
+/**
+ * Factory function to create the appropriate client based on role
+ */
+export declare function createClient(role: ParticipantRole, baseUrl?: string, options?: ClientOptions): RoboticsProducer | RoboticsConsumer;
+/**
+ * Create and connect a producer client
+ */
+export declare function createProducerClient(baseUrl?: string, workspaceId?: string, roomId?: string, participantId?: string, options?: ClientOptions): Promise<RoboticsProducer>;
+/**
+ * Create and connect a consumer client
+ */
+export declare function createConsumerClient(workspaceId: string, roomId: string, baseUrl?: string, participantId?: string, options?: ClientOptions): Promise<RoboticsConsumer>;

client/js/dist/robotics/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * LeRobot Arena Robotics Client - Main Module
+ *
+ * TypeScript/JavaScript client for robotics control and monitoring
+ */
+export { RoboticsClientCore } from './core.js';
+export { RoboticsProducer } from './producer.js';
+export { RoboticsConsumer } from './consumer.js';
+export * from './types.js';
+export { createProducerClient, createConsumerClient, createClient } from './factory.js';

client/js/dist/robotics/producer.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Producer client for controlling robots in LeRobot Arena
+ */
+import { RoboticsClientCore } from './core.js';
+import type { JointData, WebSocketMessage, ClientOptions } from './types.js';
+export declare class RoboticsProducer extends RoboticsClientCore {
+    constructor(baseUrl?: string, options?: ClientOptions);
+    connect(workspaceId: string, roomId: string, participantId?: string): Promise<boolean>;
+    sendJointUpdate(joints: JointData[]): Promise<void>;
+    sendStateSync(state: Record<string, number>): Promise<void>;
+    sendEmergencyStop(reason?: string): Promise<void>;
+    protected handleRoleSpecificMessage(message: WebSocketMessage): void;
+    /**
+     * Create a room and automatically connect as producer
+     */
+    static createAndConnect(baseUrl?: string, workspaceId?: string, roomId?: string, participantId?: string): Promise<RoboticsProducer>;
+    /**
+     * Get the current room ID (useful when auto-created)
+     */
+    get currentRoomId(): string | null;
+}

client/js/dist/robotics/types.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Type definitions for LeRobot Arena Robotics Client
+ */
+export type ParticipantRole = 'producer' | 'consumer';
+export type MessageType = 'joint_update' | 'state_sync' | 'heartbeat' | 'heartbeat_ack' | 'emergency_stop' | 'joined' | 'error';
+export interface JointData {
+    name: string;
+    value: number;
+    speed?: number;
+}
+export interface RoomInfo {
+    id: string;
+    workspace_id: string;
+    participants: {
+        producer: string | null;
+        consumers: string[];
+        total: number;
+    };
+    joints_count: number;
+    has_producer?: boolean;
+    active_consumers?: number;
+}
+export interface RoomState {
+    room_id: string;
+    workspace_id: string;
+    joints: Record<string, number>;
+    participants: {
+        producer: string | null;
+        consumers: string[];
+        total: number;
+    };
+    timestamp: string;
+}
+export interface ConnectionInfo {
+    connected: boolean;
+    workspace_id: string | null;
+    room_id: string | null;
+    role: ParticipantRole | null;
+    participant_id: string | null;
+    base_url: string;
+}
+export interface BaseMessage {
+    type: MessageType;
+    timestamp?: string;
+}
+export interface JointUpdateMessage extends BaseMessage {
+    type: 'joint_update';
+    data: JointData[];
+    source?: string;
+}
+export interface StateSyncMessage extends BaseMessage {
+    type: 'state_sync';
+    data: Record<string, number>;
+}
+export interface HeartbeatMessage extends BaseMessage {
+    type: 'heartbeat';
+}
+export interface HeartbeatAckMessage extends BaseMessage {
+    type: 'heartbeat_ack';
+}
+export interface EmergencyStopMessage extends BaseMessage {
+    type: 'emergency_stop';
+    reason: string;
+    source?: string;
+}
+export interface JoinedMessage extends BaseMessage {
+    type: 'joined';
+    room_id: string;
+    role: ParticipantRole;
+}
+export interface ErrorMessage extends BaseMessage {
+    type: 'error';
+    message: string;
+}
+export type WebSocketMessage = JointUpdateMessage | StateSyncMessage | HeartbeatMessage | HeartbeatAckMessage | EmergencyStopMessage | JoinedMessage | ErrorMessage;
+export interface ApiResponse<T = unknown> {
+    success: boolean;
+    data?: T;
+    error?: string;
+    message?: string;
+}
+export interface ListRoomsResponse {
+    success: boolean;
+    workspace_id: string;
+    rooms: RoomInfo[];
+    total: number;
+}
+export interface CreateRoomResponse {
+    success: boolean;
+    workspace_id: string;
+    room_id: string;
+    message: string;
+}
+export interface GetRoomResponse {
+    success: boolean;
+    workspace_id: string;
+    room: RoomInfo;
+}
+export interface GetRoomStateResponse {
+    success: boolean;
+    workspace_id: string;
+    state: RoomState;
+}
+export interface DeleteRoomResponse {
+    success: boolean;
+    workspace_id: string;
+    message: string;
+}
+export interface CreateRoomRequest {
+    room_id?: string;
+    workspace_id?: string;
+}
+export interface JoinMessage {
+    participant_id: string;
+    role: ParticipantRole;
+}
+export type JointUpdateCallback = (joints: JointData[]) => void;
+export type StateSyncCallback = (state: Record<string, number>) => void;
+export type ErrorCallback = (error: string) => void;
+export type ConnectedCallback = () => void;
+export type DisconnectedCallback = () => void;
+export interface ClientOptions {
+    base_url?: string;
+    timeout?: number;
+    reconnect_attempts?: number;
+    heartbeat_interval?: number;
+}

client/js/dist/video/consumer.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Consumer client for receiving video streams in LeRobot Arena
+ */
+import { VideoClientCore } from './core.js';
+import type { WebSocketMessage, ClientOptions, WebRTCStats, FrameUpdateCallback, VideoConfigUpdateCallback, StreamStartedCallback, StreamStoppedCallback, RecoveryTriggeredCallback, StatusUpdateCallback, StreamStatsCallback, WebRTCOfferMessage } from './types.js';
+export declare class VideoConsumer extends VideoClientCore {
+    private onFrameUpdateCallback;
+    private onVideoConfigUpdateCallback;
+    private onStreamStartedCallback;
+    private onStreamStoppedCallback;
+    private onRecoveryTriggeredCallback;
+    private onStatusUpdateCallback;
+    private onStreamStatsCallback;
+    private iceCandidateQueue;
+    private hasRemoteDescription;
+    constructor(baseUrl?: string, options?: ClientOptions);
+    connect(workspaceId: string, roomId: string, participantId?: string): Promise<boolean>;
+    startReceiving(): Promise<void>;
+    stopReceiving(): Promise<void>;
+    handleWebRTCOffer(message: WebRTCOfferMessage): Promise<void>;
+    private handleWebRTCIce;
+    private processQueuedIceCandidates;
+    createPeerConnection(): RTCPeerConnection;
+    private sendIceCandidateToProducer;
+    private handleStreamStarted;
+    onFrameUpdate(callback: FrameUpdateCallback): void;
+    onVideoConfigUpdate(callback: VideoConfigUpdateCallback): void;
+    onStreamStarted(callback: StreamStartedCallback): void;
+    onStreamStopped(callback: StreamStoppedCallback): void;
+    onRecoveryTriggered(callback: RecoveryTriggeredCallback): void;
+    onStatusUpdate(callback: StatusUpdateCallback): void;
+    onStreamStats(callback: StreamStatsCallback): void;
+    protected handleRoleSpecificMessage(message: WebSocketMessage): void;
+    private handleFrameUpdate;
+    private handleVideoConfigUpdate;
+    private handleStreamStopped;
+    private handleRecoveryTriggered;
+    private handleStatusUpdate;
+    private handleStreamStats;
+    /**
+     * Create a consumer and automatically connect to a room
+     */
+    static createAndConnect(workspaceId: string, roomId: string, baseUrl?: string, participantId?: string): Promise<VideoConsumer>;
+    /**
+     * Get the video element for displaying the remote stream
+     */
+    attachToVideoElement(videoElement: HTMLVideoElement): void;
+    /**
+     * Get current video statistics
+     */
+    getVideoStats(): Promise<WebRTCStats | null>;
+}

client/js/dist/video/core.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Core video client for LeRobot Arena
+ * Base class providing REST API, WebSocket, and WebRTC functionality
+ */
+import { EventEmitter } from 'eventemitter3';
+import type { ParticipantRole, RoomInfo, RoomState, ConnectionInfo, WebSocketMessage, WebRTCSignalResponse, ClientOptions, WebRTCConfig, WebRTCStats, VideoConfig, RecoveryConfig, ErrorCallback, ConnectedCallback, DisconnectedCallback } from './types.js';
+export declare class VideoClientCore extends EventEmitter {
+    protected baseUrl: string;
+    protected apiBase: string;
+    protected websocket: WebSocket | null;
+    protected peerConnection: RTCPeerConnection | null;
+    protected localStream: MediaStream | null;
+    protected remoteStream: MediaStream | null;
+    protected workspaceId: string | null;
+    protected roomId: string | null;
+    protected role: ParticipantRole | null;
+    protected participantId: string | null;
+    protected connected: boolean;
+    protected options: ClientOptions;
+    protected webrtcConfig: WebRTCConfig;
+    protected onErrorCallback: ErrorCallback | null;
+    protected onConnectedCallback: ConnectedCallback | null;
+    protected onDisconnectedCallback: DisconnectedCallback | null;
+    constructor(baseUrl?: string, options?: ClientOptions);
+    listRooms(workspaceId: string): Promise<RoomInfo[]>;
+    createRoom(workspaceId?: string, roomId?: string, config?: VideoConfig, recoveryConfig?: RecoveryConfig): Promise<{
+        workspaceId: string;
+        roomId: string;
+    }>;
+    deleteRoom(workspaceId: string, roomId: string): Promise<boolean>;
+    getRoomState(workspaceId: string, roomId: string): Promise<RoomState>;
+    getRoomInfo(workspaceId: string, roomId: string): Promise<RoomInfo>;
+    sendWebRTCSignal(workspaceId: string, roomId: string, clientId: string, message: RTCSessionDescriptionInit | RTCIceCandidateInit | Record<string, unknown>): Promise<WebRTCSignalResponse>;
+    connectToRoom(workspaceId: string, roomId: string, role: ParticipantRole, participantId?: string): Promise<boolean>;
+    disconnect(): Promise<void>;
+    createPeerConnection(): RTCPeerConnection;
+    createOffer(): Promise<RTCSessionDescriptionInit>;
+    createAnswer(offer: RTCSessionDescriptionInit): Promise<RTCSessionDescriptionInit>;
+    setRemoteDescription(description: RTCSessionDescriptionInit): Promise<void>;
+    addIceCandidate(candidate: RTCIceCandidateInit): Promise<void>;
+    startProducing(constraints?: MediaStreamConstraints): Promise<MediaStream>;
+    startScreenShare(): Promise<MediaStream>;
+    stopProducing(): void;
+    getLocalStream(): MediaStream | null;
+    getRemoteStream(): MediaStream | null;
+    getPeerConnection(): RTCPeerConnection | null;
+    getStats(): Promise<WebRTCStats | null>;
+    protected sendJoinMessage(): void;
+    protected handleMessage(message: WebSocketMessage): void;
+    protected handleRoleSpecificMessage(message: WebSocketMessage): void;
+    protected handleError(errorMessage: string): void;
+    sendHeartbeat(): Promise<void>;
+    isConnected(): boolean;
+    getConnectionInfo(): ConnectionInfo;
+    onError(callback: ErrorCallback): void;
+    onConnected(callback: ConnectedCallback): void;
+    onDisconnected(callback: DisconnectedCallback): void;
+    private fetchApi;
+    private extractVideoStats;
+    protected generateWorkspaceId(): string;
+}

client/js/dist/video/factory.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Factory functions for creating LeRobot Arena video clients
+ */
+import { VideoProducer } from './producer.js';
+import { VideoConsumer } from './consumer.js';
+import type { ParticipantRole, ClientOptions } from './types.js';
+/**
+ * Factory function to create the appropriate client based on role
+ */
+export declare function createClient(role: ParticipantRole, baseUrl?: string, options?: ClientOptions): VideoProducer | VideoConsumer;
+/**
+ * Create and connect a producer client
+ */
+export declare function createProducerClient(baseUrl?: string, workspaceId?: string, roomId?: string, participantId?: string, options?: ClientOptions): Promise<VideoProducer>;
+/**
+ * Create and connect a consumer client
+ */
+export declare function createConsumerClient(workspaceId: string, roomId: string, baseUrl?: string, participantId?: string, options?: ClientOptions): Promise<VideoConsumer>;

client/js/dist/video/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * LeRobot Arena Video Client - Main Module
+ *
+ * TypeScript/JavaScript client for video streaming and monitoring
+ */
+export { VideoClientCore } from './core.js';
+export { VideoProducer } from './producer.js';
+export { VideoConsumer } from './consumer.js';
+export * from './types.js';
+export { createProducerClient, createConsumerClient, createClient } from './factory.js';

client/js/dist/video/producer.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Producer client for video streaming in LeRobot Arena
+ */
+import { VideoClientCore } from './core.js';
+import type { WebSocketMessage, ClientOptions, VideoConfig } from './types.js';
+export declare class VideoProducer extends VideoClientCore {
+    private consumerConnections;
+    constructor(baseUrl?: string, options?: ClientOptions);
+    connect(workspaceId: string, roomId: string, participantId?: string): Promise<boolean>;
+    private connectToExistingConsumers;
+    private createPeerConnectionForConsumer;
+    private restartConnectionToConsumer;
+    private handleConsumerLeft;
+    private restartConnectionsWithNewStream;
+    startCamera(constraints?: MediaStreamConstraints): Promise<MediaStream>;
+    startScreenShare(): Promise<MediaStream>;
+    stopStreaming(): Promise<void>;
+    updateVideoConfig(config: VideoConfig): Promise<void>;
+    sendEmergencyStop(reason?: string): Promise<void>;
+    initiateWebRTCWithConsumer(consumerId: string): Promise<void>;
+    private handleWebRTCAnswer;
+    private handleWebRTCIce;
+    protected handleRoleSpecificMessage(message: WebSocketMessage): void;
+    private handleStatusUpdate;
+    private handleStreamStats;
+    private notifyStreamStarted;
+    private notifyStreamStopped;
+    /**
+     * Create a room and automatically connect as producer
+     */
+    static createAndConnect(baseUrl?: string, workspaceId?: string, roomId?: string, participantId?: string): Promise<VideoProducer>;
+    /**
+     * Get the current room ID (useful when auto-created)
+     */
+    get currentRoomId(): string | null;
+}

client/js/dist/video/types.d.ts

@@ -0,0 +1,249 @@
+/**
+ * Type definitions for LeRobot Arena Video Client
+ * ✅ Fully synchronized with server-side models.py
+ */
+export type ParticipantRole = 'producer' | 'consumer';
+export type MessageType = 'frame_update' | 'video_config_update' | 'stream_started' | 'stream_stopped' | 'recovery_triggered' | 'heartbeat' | 'heartbeat_ack' | 'emergency_stop' | 'joined' | 'error' | 'participant_joined' | 'participant_left' | 'webrtc_offer' | 'webrtc_answer' | 'webrtc_ice' | 'status_update' | 'stream_stats';
+export interface VideoConfig {
+    encoding?: VideoEncoding;
+    resolution?: Resolution;
+    framerate?: number;
+    bitrate?: number;
+    quality?: number;
+}
+export interface Resolution {
+    width: number;
+    height: number;
+}
+export type VideoEncoding = 'jpeg' | 'h264' | 'vp8' | 'vp9';
+export type RecoveryPolicy = 'freeze_last_frame' | 'connection_info' | 'black_screen' | 'fade_to_black' | 'overlay_status';
+export interface RecoveryConfig {
+    frame_timeout_ms?: number;
+    max_frame_reuse_count?: number;
+    recovery_policy?: RecoveryPolicy;
+    fallback_policy?: RecoveryPolicy;
+    show_hold_indicators?: boolean;
+    info_frame_bg_color?: [number, number, number];
+    info_frame_text_color?: [number, number, number];
+    fade_intensity?: number;
+    overlay_opacity?: number;
+}
+export interface FrameData {
+    data: ArrayBuffer;
+    metadata?: Record<string, unknown>;
+}
+export interface StreamStats {
+    stream_id: string;
+    duration_seconds: number;
+    frame_count: number;
+    total_bytes: number;
+    average_fps: number;
+    average_bitrate: number;
+}
+export interface ParticipantInfo {
+    producer: string | null;
+    consumers: string[];
+    total: number;
+}
+export interface RoomInfo {
+    id: string;
+    workspace_id: string;
+    participants: ParticipantInfo;
+    frame_count: number;
+    config: VideoConfig;
+    has_producer: boolean;
+    active_consumers: number;
+}
+export interface RoomState {
+    room_id: string;
+    workspace_id: string;
+    participants: ParticipantInfo;
+    frame_count: number;
+    last_frame_time: string | null;
+    current_config: VideoConfig;
+    timestamp: string;
+}
+export interface ConnectionInfo {
+    connected: boolean;
+    workspace_id: string | null;
+    room_id: string | null;
+    role: ParticipantRole | null;
+    participant_id: string | null;
+    base_url: string;
+}
+export interface BaseMessage {
+    type: MessageType;
+    timestamp?: string;
+}
+export interface FrameUpdateMessage extends BaseMessage {
+    type: 'frame_update';
+    data: ArrayBuffer;
+    metadata?: Record<string, unknown>;
+}
+export interface VideoConfigUpdateMessage extends BaseMessage {
+    type: 'video_config_update';
+    config: VideoConfig;
+    source?: string;
+}
+export interface StreamStartedMessage extends BaseMessage {
+    type: 'stream_started';
+    config: VideoConfig;
+    participant_id: string;
+}
+export interface StreamStoppedMessage extends BaseMessage {
+    type: 'stream_stopped';
+    participant_id: string;
+    reason?: string;
+}
+export interface RecoveryTriggeredMessage extends BaseMessage {
+    type: 'recovery_triggered';
+    policy: RecoveryPolicy;
+    reason: string;
+}
+export interface HeartbeatMessage extends BaseMessage {
+    type: 'heartbeat';
+}
+export interface HeartbeatAckMessage extends BaseMessage {
+    type: 'heartbeat_ack';
+}
+export interface EmergencyStopMessage extends BaseMessage {
+    type: 'emergency_stop';
+    reason: string;
+    source?: string;
+}
+export interface JoinedMessage extends BaseMessage {
+    type: 'joined';
+    room_id: string;
+    role: ParticipantRole;
+}
+export interface ErrorMessage extends BaseMessage {
+    type: 'error';
+    message: string;
+    code?: string;
+}
+export interface ParticipantJoinedMessage extends BaseMessage {
+    type: 'participant_joined';
+    room_id: string;
+    participant_id: string;
+    role: ParticipantRole;
+}
+export interface ParticipantLeftMessage extends BaseMessage {
+    type: 'participant_left';
+    room_id: string;
+    participant_id: string;
+    role: ParticipantRole;
+}
+export interface WebRTCOfferMessage extends BaseMessage {
+    type: 'webrtc_offer';
+    offer: RTCSessionDescriptionInit;
+    from_producer: string;
+}
+export interface WebRTCAnswerMessage extends BaseMessage {
+    type: 'webrtc_answer';
+    answer: RTCSessionDescriptionInit;
+    from_consumer: string;
+}
+export interface WebRTCIceMessage extends BaseMessage {
+    type: 'webrtc_ice';
+    candidate: RTCIceCandidateInit;
+    from_producer?: string;
+    from_consumer?: string;
+}
+export interface StatusUpdateMessage extends BaseMessage {
+    type: 'status_update';
+    status: string;
+    data?: Record<string, unknown>;
+}
+export interface StreamStatsMessage extends BaseMessage {
+    type: 'stream_stats';
+    stats: StreamStats;
+}
+export type WebSocketMessage = FrameUpdateMessage | VideoConfigUpdateMessage | StreamStartedMessage | StreamStoppedMessage | RecoveryTriggeredMessage | HeartbeatMessage | HeartbeatAckMessage | EmergencyStopMessage | JoinedMessage | ErrorMessage | ParticipantJoinedMessage | ParticipantLeftMessage | WebRTCOfferMessage | WebRTCAnswerMessage | WebRTCIceMessage | StatusUpdateMessage | StreamStatsMessage;
+export interface ApiResponse<T = unknown> {
+    success: boolean;
+    data?: T;
+    error?: string;
+    message?: string;
+}
+export interface ListRoomsResponse {
+    success: boolean;
+    workspace_id: string;
+    rooms: RoomInfo[];
+    total: number;
+}
+export interface CreateRoomResponse {
+    success: boolean;
+    workspace_id: string;
+    room_id: string;
+    message: string;
+}
+export interface GetRoomResponse {
+    success: boolean;
+    workspace_id: string;
+    room: RoomInfo;
+}
+export interface GetRoomStateResponse {
+    success: boolean;
+    workspace_id: string;
+    state: RoomState;
+}
+export interface DeleteRoomResponse {
+    success: boolean;
+    workspace_id: string;
+    message: string;
+}
+export interface WebRTCSignalResponse {
+    success: boolean;
+    workspace_id: string;
+    response?: RTCSessionDescriptionInit | RTCIceCandidateInit;
+    message?: string;
+}
+export interface CreateRoomRequest {
+    room_id?: string;
+    workspace_id?: string;
+    name?: string;
+    config?: VideoConfig;
+    recovery_config?: RecoveryConfig;
+    max_consumers?: number;
+}
+export interface WebRTCSignalRequest {
+    client_id: string;
+    message: RTCSessionDescriptionInit | RTCIceCandidateInit | Record<string, unknown>;
+}
+export interface JoinMessage {
+    participant_id: string;
+    role: ParticipantRole;
+}
+export interface WebRTCConfig {
+    iceServers?: RTCIceServer[];
+    constraints?: MediaStreamConstraints;
+    bitrate?: number;
+    framerate?: number;
+    resolution?: Resolution;
+    codecPreferences?: string[];
+}
+export interface WebRTCStats {
+    videoBitsPerSecond: number;
+    framesPerSecond: number;
+    frameWidth: number;
+    frameHeight: number;
+    packetsLost: number;
+    totalPackets: number;
+}
+export type FrameUpdateCallback = (frame: FrameData) => void;
+export type VideoConfigUpdateCallback = (config: VideoConfig) => void;
+export type StreamStartedCallback = (config: VideoConfig, participantId: string) => void;
+export type StreamStoppedCallback = (participantId: string, reason?: string) => void;
+export type RecoveryTriggeredCallback = (policy: RecoveryPolicy, reason: string) => void;
+export type StatusUpdateCallback = (status: string, data?: Record<string, unknown>) => void;
+export type StreamStatsCallback = (stats: StreamStats) => void;
+export type ErrorCallback = (error: string) => void;
+export type ConnectedCallback = () => void;
+export type DisconnectedCallback = () => void;
+export interface ClientOptions {
+    base_url?: string;
+    timeout?: number;
+    reconnect_attempts?: number;
+    heartbeat_interval?: number;
+    webrtc_config?: WebRTCConfig;
+}

client/js/tsconfig.json

@@ -6,7 +6,6 @@
     "moduleResolution": "bundler",
     "allowImportingTsExtensions": true,
     "verbatimModuleSyntax": true,
-    "noEmit": true,
     "declaration": true,
     "emitDeclarationOnly": true,
     "outDir": "dist",