@onlive.ai/common-121 0.2.163 → 0.2.184

package/index.d.ts

@@ -1,10 +1,12 @@
-/*! @onlive.ai/common-121 v0.2.163 | © 2026 Onlive.ai */
+/*! @onlive.ai/common-121 v0.2.184 | © 2026 Onlive.ai */
 import * as lit from 'lit';
 import { LitElement, TemplateResult } from 'lit';
 import * as _lit_react from '@lit/react';
 import { EventName } from '@lit/react';
+import { Room as Room$1, Participant } from 'livekit-client';
+import { ReceivedChatMessage } from '@livekit/components-core';
 
-/*! @onlive.ai/common-121 v0.2.163 | © 2026 Onlive.ai */
+/*! @onlive.ai/common-121 v0.2.184 | © 2026 Onlive.ai */
 
 
 type AssetType = "product" | "multimedia" | "faq" | "file";
@@ -335,4 +337,4133 @@ declare const Upload: _lit_react.ReactWebComponent<OSBUpload, {
     }>>;
 }>;
 
-export { Asset, type AssetDisplayOptions, type AssetItemDisplayOptions, OSBAsset, OSBSideBar, OSBUpload, SideBar, Upload, type UploadConfig };
+/**
+ * @summary Type definitions for the mock LiveKit/Conversation service.
+ *
+ * @description Contains all type definitions needed for the mock implementation
+ * including room state, participant state, track state, agent state, and configuration options.
+ */
+/**
+ * Represents the state of a mock room.
+ *
+ * @property {string} id - Unique room identifier.
+ * @property {string} name - Display name of the room.
+ * @property {string} groupId - Group identifier for room categorization.
+ * @property {string} createdAt - ISO timestamp of room creation.
+ * @property {string} [endedAt] - ISO timestamp when room ended, undefined if active.
+ * @property {Record<string, unknown>} [metadata] - Additional room metadata.
+ * @property {boolean} isActive - Whether the room is currently active.
+ * @property {string[]} participantIds - Array of participant identities in the room.
+ * @property {MockConnectionState} connectionState - Current connection state of the room.
+ */
+interface MockRoomState {
+    id: string;
+    name: string;
+    groupId: string;
+    createdAt: string;
+    endedAt?: string;
+    metadata?: Record<string, unknown>;
+    isActive: boolean;
+    participantIds: string[];
+    connectionState: MockConnectionState$1;
+    wsURL: string;
+    token: string;
+}
+/**
+ * Connection states that mirror LiveKit's ConnectionState enum.
+ */
+type MockConnectionState$1 = "disconnected" | "connecting" | "connected" | "reconnecting";
+/**
+ * Represents the state of a mock participant.
+ *
+ * @property {string} identity - Unique participant identity.
+ * @property {string} [name] - Display name of the participant.
+ * @property {string} roomId - ID of the room the participant is in.
+ * @property {string} joinedAt - ISO timestamp when participant joined.
+ * @property {boolean} isConnected - Whether the participant is currently connected.
+ * @property {string[]} trackIds - Array of track IDs published by this participant.
+ * @property {MockParticipantRole} role - Role of the participant.
+ * @property {Record<string, string>} attributes - Participant attributes.
+ * @property {MockParticipantKind} kind - Kind of participant (standard, ingress, egress, sip, agent).
+ */
+interface MockParticipantState {
+    identity: string;
+    name?: string;
+    roomId: string;
+    joinedAt: string;
+    isConnected: boolean;
+    trackIds: string[];
+    role: MockParticipantRole;
+    attributes: Record<string, string>;
+    kind: MockParticipantKind$1;
+    isLocal: boolean;
+}
+/**
+ * Participant roles in the conversation.
+ */
+type MockParticipantRole = "user" | "agent" | "assistant";
+/**
+ * Participant kinds matching LiveKit's participant types.
+ */
+type MockParticipantKind$1 = "standard" | "ingress" | "egress" | "sip" | "agent";
+/**
+ * Represents the state of a mock track.
+ *
+ * @property {string} id - Unique track identifier.
+ * @property {MockTrackKind} kind - Type of track (audio, video, data).
+ * @property {MockTrackSource} source - Source of the track.
+ * @property {string} participantIdentity - Identity of the participant who published this track.
+ * @property {string} roomId - ID of the room this track belongs to.
+ * @property {string} publishedAt - ISO timestamp when track was published.
+ * @property {boolean} muted - Whether the track is currently muted.
+ * @property {Record<string, unknown>} [metadata] - Additional track metadata.
+ */
+interface MockTrackState {
+    id: string;
+    kind: MockTrackKind;
+    source: MockTrackSource;
+    participantIdentity: string;
+    roomId: string;
+    publishedAt: string;
+    muted: boolean;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Types of tracks that can be published.
+ */
+type MockTrackKind = "audio" | "video" | "data";
+/**
+ * Track source types matching LiveKit's track sources.
+ */
+type MockTrackSource = "camera" | "microphone" | "screen_share" | "screen_share_audio" | "unknown";
+/**
+ * Represents the state of a mock agent.
+ *
+ * @property {string} id - Unique agent identifier.
+ * @property {string} roomId - ID of the room the agent is in.
+ * @property {string} name - Display name of the agent.
+ * @property {MockAgentStatus} status - Current status of the agent.
+ * @property {string} startedAt - ISO timestamp when agent started.
+ * @property {string} [stoppedAt] - ISO timestamp when agent stopped.
+ * @property {MockAgentConfig} config - Agent configuration.
+ * @property {MockAgentMessage[]} messageHistory - History of messages exchanged with agent.
+ */
+interface MockAgentState {
+    id: string;
+    roomId: string;
+    name: string;
+    status: MockAgentStatus;
+    startedAt: string;
+    stoppedAt?: string;
+    config: MockAgentConfig;
+    messageHistory: MockAgentMessage[];
+}
+/**
+ * Agent status values.
+ */
+type MockAgentStatus = "idle" | "starting" | "running" | "stopping" | "stopped" | "error";
+/**
+ * Configuration for a mock agent.
+ *
+ * @property {string} [type] - Type of agent (e.g., 'chat', 'voice').
+ * @property {string} [nature] - Nature of agent ('ai' or 'real').
+ * @property {MockAgentResponseStrategy} responseStrategy - How the agent should respond.
+ * @property {number} [responseDelayMs] - Delay before responding in milliseconds.
+ * @property {string[]} [cannedResponses] - Predefined responses for deterministic testing.
+ * @property {number} [maxMessages] - Maximum messages before stopping.
+ * @property {boolean} [simulateTyping] - Whether to simulate typing indicator.
+ * @property {number} [typingDelayPerChar] - Typing delay per character (ms).
+ * @property {string} [name] - Agent display name.
+ */
+interface MockAgentConfig {
+    type?: string | string[];
+    nature?: "ai" | "real";
+    name?: string;
+    responseStrategy: MockAgentResponseStrategy;
+    responseDelayMs?: number;
+    cannedResponses?: string[];
+    maxMessages?: number;
+    simulateTyping?: boolean;
+    typingDelayPerChar?: number;
+}
+/**
+ * Strategies for how mock agents should respond.
+ */
+type MockAgentResponseStrategy = "echo" | "canned" | "random" | "sequential" | "silent" | "error" | "custom";
+/**
+ * Message exchanged with a mock agent.
+ */
+interface MockAgentMessage {
+    id: string;
+    content: string;
+    role: "user" | "agent";
+    /** Timestamp - ISO string or number */
+    timestamp: string | number;
+}
+/**
+ * Represents a mock message in a room.
+ *
+ * @property {string} id - Unique message identifier.
+ * @property {string} roomId - ID of the room this message belongs to.
+ * @property {string} content - Text content of the message.
+ * @property {string} participantIdentity - Identity of the sender.
+ * @property {string} createdAt - ISO timestamp of message creation.
+ * @property {"standard" | "system"} [type] - Message type classification.
+ * @property {Record<string, unknown>} [attributes] - Message attributes.
+ */
+interface MockMessageState {
+    id: string;
+    roomId: string;
+    content: string;
+    participantIdentity: string;
+    createdAt: string;
+    type?: "standard" | "system";
+    attributes?: Record<string, unknown>;
+}
+/**
+ * All possible mock event types.
+ */
+type MockEventType = "roomCreated" | "roomEnded" | "roomConnectionStateChanged" | "participantJoined" | "participantLeft" | "participantAttributesChanged" | "trackPublished" | "trackUnpublished" | "trackMuted" | "trackUnmuted" | "messageReceived" | "messageSent" | "typingIndicator" | "agentStarted" | "agentStopped" | "agentMessage" | "dataReceived" | "error";
+/**
+ * Base event structure for all mock events.
+ */
+interface MockEventBase {
+    type: MockEventType;
+    timestamp: string;
+    roomId?: string;
+}
+/**
+ * Room created event.
+ */
+interface MockRoomCreatedEvent extends MockEventBase {
+    type: "roomCreated";
+    roomId: string;
+    room: MockRoomState;
+}
+/**
+ * Room ended event.
+ */
+interface MockRoomEndedEvent extends MockEventBase {
+    type: "roomEnded";
+    roomId: string;
+}
+/**
+ * Room connection state changed event.
+ */
+interface MockRoomConnectionStateChangedEvent extends MockEventBase {
+    type: "roomConnectionStateChanged";
+    roomId: string;
+    state: MockConnectionState$1;
+    previousState: MockConnectionState$1;
+}
+/**
+ * Participant joined event.
+ */
+interface MockParticipantJoinedEvent extends MockEventBase {
+    type: "participantJoined";
+    roomId: string;
+    participant: MockParticipantState;
+}
+/**
+ * Participant left event.
+ */
+interface MockParticipantLeftEvent extends MockEventBase {
+    type: "participantLeft";
+    roomId: string;
+    participantIdentity: string;
+}
+/**
+ * Participant attributes changed event.
+ */
+interface MockParticipantAttributesChangedEvent extends MockEventBase {
+    type: "participantAttributesChanged";
+    roomId: string;
+    participantIdentity: string;
+    attributes: Record<string, string>;
+    previousAttributes: Record<string, string>;
+}
+/**
+ * Track published event.
+ */
+interface MockTrackPublishedEvent extends MockEventBase {
+    type: "trackPublished";
+    roomId: string;
+    participantIdentity: string;
+    track: MockTrackState;
+}
+/**
+ * Track unpublished event.
+ */
+interface MockTrackUnpublishedEvent extends MockEventBase {
+    type: "trackUnpublished";
+    roomId: string;
+    participantIdentity: string;
+    trackId: string;
+}
+/**
+ * Track muted event.
+ */
+interface MockTrackMutedEvent extends MockEventBase {
+    type: "trackMuted";
+    roomId: string;
+    trackId: string;
+}
+/**
+ * Track unmuted event.
+ */
+interface MockTrackUnmutedEvent extends MockEventBase {
+    type: "trackUnmuted";
+    roomId: string;
+    trackId: string;
+}
+/**
+ * Message received event.
+ */
+interface MockMessageReceivedEvent extends MockEventBase {
+    type: "messageReceived";
+    roomId: string;
+    message: MockMessageState;
+}
+/**
+ * Message sent event.
+ */
+interface MockMessageSentEvent extends MockEventBase {
+    type: "messageSent";
+    roomId: string;
+    message: MockMessageState;
+}
+/**
+ * Typing indicator event.
+ */
+interface MockTypingIndicatorEvent extends MockEventBase {
+    type: "typingIndicator";
+    roomId: string;
+    participantIdentity: string;
+    isTyping: boolean;
+}
+/**
+ * Agent started event.
+ */
+interface MockAgentStartedEvent extends MockEventBase {
+    type: "agentStarted";
+    roomId: string;
+    agent: MockAgentState;
+}
+/**
+ * Agent stopped event.
+ */
+interface MockAgentStoppedEvent extends MockEventBase {
+    type: "agentStopped";
+    roomId: string;
+    agentId: string;
+}
+/**
+ * Agent message event.
+ */
+interface MockAgentMessageEvent extends MockEventBase {
+    type: "agentMessage";
+    roomId: string;
+    agentId: string;
+    message: MockAgentMessage;
+}
+/**
+ * Data received event.
+ */
+interface MockDataReceivedEvent extends MockEventBase {
+    type: "dataReceived";
+    roomId: string;
+    participantIdentity: string;
+    data: Uint8Array;
+    topic?: string;
+}
+/**
+ * Error event.
+ */
+interface MockErrorEvent extends MockEventBase {
+    type: "error";
+    error: MockError;
+}
+/**
+ * Union type for all mock events.
+ */
+type MockEvent = MockRoomCreatedEvent | MockRoomEndedEvent | MockRoomConnectionStateChangedEvent | MockParticipantJoinedEvent | MockParticipantLeftEvent | MockParticipantAttributesChangedEvent | MockTrackPublishedEvent | MockTrackUnpublishedEvent | MockTrackMutedEvent | MockTrackUnmutedEvent | MockMessageReceivedEvent | MockMessageSentEvent | MockTypingIndicatorEvent | MockAgentStartedEvent | MockAgentStoppedEvent | MockAgentMessageEvent | MockDataReceivedEvent | MockErrorEvent;
+/**
+ * Configuration options for the mock service.
+ *
+ * @property {number} [latencyMs] - Artificial latency in milliseconds.
+ * @property {boolean} [strictMode] - Throw errors for invalid operations.
+ * @property {number} [seed] - Random seed for deterministic behavior.
+ * @property {MockScenario} [scenario] - Predefined scenario to simulate.
+ * @property {MockErrorConfig} [errorConfig] - Configuration for forced errors.
+ * @property {boolean} [autoEmitEvents] - Automatically emit events on state changes.
+ */
+interface MockServiceConfig {
+    latencyMs?: number;
+    strictMode?: boolean;
+    seed?: number;
+    scenario?: MockScenario;
+    errorConfig?: MockErrorConfig;
+    autoEmitEvents?: boolean;
+    organizationId?: string;
+    apiUrl?: string;
+}
+/**
+ * Predefined test scenarios.
+ */
+type MockScenario = "happy_path" | "room_disconnect" | "agent_timeout" | "participant_leave" | "track_failure" | "network_unstable" | "slow_network" | "unreliable";
+/**
+ * Configuration for forced errors.
+ *
+ * @property {boolean} [roomNotFound] - Force "room not found" errors.
+ * @property {boolean} [participantAlreadyJoined] - Force "already joined" errors.
+ * @property {boolean} [trackNotFound] - Force "track not found" errors.
+ * @property {boolean} [unauthorized] - Force authentication errors.
+ * @property {boolean} [networkError] - Force network errors.
+ * @property {number} [errorRate] - Percentage of operations that should fail (0-100).
+ */
+interface MockErrorConfig {
+    roomNotFound?: boolean;
+    participantAlreadyJoined?: boolean;
+    trackNotFound?: boolean;
+    unauthorized?: boolean;
+    networkError?: boolean;
+    errorRate?: number;
+}
+/**
+ * Mock error codes.
+ */
+type MockErrorCode = "ROOM_NOT_FOUND" | "ROOM_ENDED" | "PARTICIPANT_ALREADY_JOINED" | "PARTICIPANT_NOT_FOUND" | "TRACK_NOT_FOUND" | "AGENT_NOT_FOUND" | "UNAUTHORIZED" | "NETWORK_ERROR" | "INVALID_OPERATION" | "TIMEOUT";
+/**
+ * Mock error structure.
+ */
+interface MockError {
+    code: MockErrorCode;
+    message: string;
+    details?: Record<string, unknown>;
+}
+/**
+ * Event listener callback type.
+ */
+type MockEventListener<T extends MockEvent = MockEvent> = (event: T) => void;
+/**
+ * Event listener for specific event types.
+ */
+type MockEventListenerMap = {
+    [K in MockEventType]?: Set<MockEventListener>;
+};
+/**
+ * Complete snapshot of the mock service state.
+ */
+interface MockStateSnapshot {
+    rooms: Map<string, MockRoomState>;
+    participants: Map<string, MockParticipantState>;
+    tracks: Map<string, MockTrackState>;
+    agents: Map<string, MockAgentState>;
+    messages: Map<string, MockMessageState[]>;
+    config: MockServiceConfig;
+    eventHistory: MockEvent[];
+}
+/**
+ * Serializable version of the snapshot for JSON export.
+ */
+interface MockStateSnapshotJSON {
+    rooms: Record<string, MockRoomState>;
+    participants: Record<string, MockParticipantState>;
+    tracks: Record<string, MockTrackState>;
+    agents: Record<string, MockAgentState>;
+    messages: Record<string, MockMessageState[]>;
+    config: MockServiceConfig;
+    eventHistory: MockEvent[];
+    exportedAt: string;
+}
+
+/**
+ * @summary Custom error classes for the mock LiveKit service.
+ *
+ * @description Provides typed error classes that match LiveKit error patterns
+ * for consistent error handling in tests.
+ */
+
+/**
+ * @summary Base error class for mock LiveKit errors.
+ *
+ * @description Extends the standard Error class with mock-specific properties.
+ */
+declare class MockLiveKitError extends Error {
+    /** Error code for programmatic handling */
+    readonly code: MockErrorCode;
+    /** Additional error details */
+    readonly details?: Record<string, unknown>;
+    /**
+     * Creates a new MockLiveKitError.
+     *
+     * @param {MockErrorCode} code - Error code.
+     * @param {string} message - Error message.
+     * @param {Record<string, unknown>} [details] - Additional details.
+     */
+    constructor(code: MockErrorCode, message: string, details?: Record<string, unknown>);
+    /**
+     * Converts the error to a MockError object.
+     *
+     * @returns {MockError} Plain error object.
+     */
+    toMockError(): MockError;
+    /**
+     * Creates a MockLiveKitError from a MockError object.
+     *
+     * @param {MockError} error - Error object.
+     * @returns {MockLiveKitError} Error instance.
+     */
+    static fromMockError(error: MockError): MockLiveKitError;
+}
+/**
+ * Room not found error.
+ */
+declare class RoomNotFoundError extends MockLiveKitError {
+    constructor(roomId: string);
+}
+/**
+ * Room ended error.
+ */
+declare class RoomEndedError extends MockLiveKitError {
+    constructor(roomId: string);
+}
+/**
+ * Participant already joined error.
+ */
+declare class ParticipantAlreadyJoinedError extends MockLiveKitError {
+    constructor(identity: string, roomId: string);
+}
+/**
+ * Participant not found error.
+ */
+declare class ParticipantNotFoundError extends MockLiveKitError {
+    constructor(identity: string);
+}
+/**
+ * Track not found error.
+ */
+declare class TrackNotFoundError extends MockLiveKitError {
+    constructor(trackId: string);
+}
+/**
+ * Agent not found error.
+ */
+declare class AgentNotFoundError extends MockLiveKitError {
+    constructor(agentId: string);
+}
+/**
+ * Unauthorized error.
+ */
+declare class UnauthorizedError extends MockLiveKitError {
+    constructor(message?: string);
+}
+/**
+ * Network error.
+ */
+declare class NetworkError extends MockLiveKitError {
+    constructor(message?: string);
+}
+/**
+ * Invalid operation error.
+ */
+declare class InvalidOperationError extends MockLiveKitError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+/**
+ * Timeout error.
+ */
+declare class TimeoutError extends MockLiveKitError {
+    constructor(operation: string, timeoutMs: number);
+}
+/**
+ * Creates an appropriate error instance from a MockError object.
+ *
+ * @param {MockError} error - Error object.
+ * @returns {MockLiveKitError} Typed error instance.
+ */
+declare function createErrorFromMockError(error: MockError): MockLiveKitError;
+/**
+ * Type guard to check if a value is a MockError.
+ *
+ * @param {unknown} value - Value to check.
+ * @returns {boolean} True if value is a MockError.
+ */
+declare function isMockError(value: unknown): value is MockError;
+/**
+ * Type guard to check if a value is a MockLiveKitError.
+ *
+ * @param {unknown} value - Value to check.
+ * @returns {boolean} True if value is a MockLiveKitError.
+ */
+declare function isMockLiveKitError(value: unknown): value is MockLiveKitError;
+
+/**
+ * @summary Event emitter for mock LiveKit events.
+ *
+ * @description Provides an event system that mimics LiveKit's event handling,
+ * allowing subscription to various room, participant, and track events.
+ */
+
+/**
+ * @summary Event emitter for mock LiveKit service.
+ *
+ * @description Manages event subscriptions and emissions for the mock service.
+ * Supports both typed event listeners and wildcard listeners.
+ */
+declare class MockEventEmitter {
+    /** Map of event type to set of listeners */
+    private listeners;
+    /** Set of wildcard listeners that receive all events */
+    private wildcardListeners;
+    /** History of all emitted events for testing/debugging */
+    private eventHistory;
+    /** Maximum number of events to keep in history */
+    private maxHistorySize;
+    /** Whether to store events in history */
+    private recordHistory;
+    /**
+     * Sets the maximum history size.
+     *
+     * @param {number} size - Maximum number of events to keep.
+     */
+    setMaxHistorySize(size: number): void;
+    /**
+     * Enables or disables event history recording.
+     *
+     * @param {boolean} enabled - Whether to record history.
+     */
+    setRecordHistory(enabled: boolean): void;
+    /**
+     * Subscribes to a specific event type.
+     *
+     * @param {T} type - Event type to listen for.
+     * @param {MockEventListener} listener - Callback function.
+     * @returns {() => void} Unsubscribe function.
+     */
+    on<T extends MockEventType>(type: T, listener: MockEventListener): () => void;
+    /**
+     * Subscribes to a specific event type for a single emission.
+     *
+     * @param {T} type - Event type to listen for.
+     * @param {MockEventListener} listener - Callback function.
+     * @returns {() => void} Unsubscribe function.
+     */
+    once<T extends MockEventType>(type: T, listener: MockEventListener): () => void;
+    /**
+     * Unsubscribes from a specific event type.
+     *
+     * @param {T} type - Event type.
+     * @param {MockEventListener} listener - Listener to remove.
+     */
+    off<T extends MockEventType>(type: T, listener: MockEventListener): void;
+    /**
+     * Subscribes to all events.
+     *
+     * @param {MockEventListener} listener - Callback function.
+     * @returns {() => void} Unsubscribe function.
+     */
+    onAny(listener: MockEventListener): () => void;
+    /**
+     * Removes a wildcard listener.
+     *
+     * @param {MockEventListener} listener - Listener to remove.
+     */
+    offAny(listener: MockEventListener): void;
+    /**
+     * Removes all listeners for a specific event type or all events.
+     *
+     * @param {MockEventType} [type] - Event type (optional, removes all if not specified).
+     */
+    removeAllListeners(type?: MockEventType): void;
+    /**
+     * Emits an event to all relevant listeners.
+     *
+     * @param {MockEvent} event - Event to emit.
+     */
+    emit(event: MockEvent): void;
+    /**
+     * Trims event history to maximum size.
+     */
+    private trimHistory;
+    /**
+     * Emits a room created event.
+     *
+     * @param {MockRoomState} room - Created room.
+     */
+    emitRoomCreated(room: MockRoomState): void;
+    /**
+     * Emits a room ended event.
+     *
+     * @param {string} roomId - Room identifier.
+     */
+    emitRoomEnded(roomId: string): void;
+    /**
+     * Emits a room connection state changed event.
+     *
+     * @param {string} roomId - Room identifier.
+     * @param {MockConnectionState} state - New state.
+     * @param {MockConnectionState} previousState - Previous state.
+     */
+    emitRoomConnectionStateChanged(roomId: string, state: MockConnectionState$1, previousState: MockConnectionState$1): void;
+    /**
+     * Emits a participant joined event.
+     *
+     * @param {string} roomId - Room identifier.
+     * @param {MockParticipantState} participant - Joined participant.
+     */
+    emitParticipantJoined(roomId: string, participant: MockParticipantState): void;
+    /**
+     * Emits a participant left event.
+     *
+     * @param {string} roomId - Room identifier.
+     * @param {string} participantIdentity - Participant identity.
+     */
+    emitParticipantLeft(roomId: string, participantIdentity: string): void;
+    /**
+     * Emits a participant attributes changed event.
+     *
+     * @param {string} roomId - Room identifier.
+     * @param {string} participantIdentity - Participant identity.
+     * @param {Record<string, string>} attributes - New attributes.
+     * @param {Record<string, string>} previousAttributes - Previous attributes.
+     */
+    emitParticipantAttributesChanged(roomId: string, participantIdentity: string, attributes: Record<string, string>, previousAttributes: Record<string, string>): void;
+    /**
+     * Emits a track published event.
+     *
+     * @param {string} roomId - Room identifier.
+     * @param {string} participantIdentity - Participant identity.
+     * @param {MockTrackState} track - Published track.
+     */
+    emitTrackPublished(roomId: string, participantIdentity: string, track: MockTrackState): void;
+    /**
+     * Emits a track unpublished event.
+     *
+     * @param {string} roomId - Room identifier.
+     * @param {string} participantIdentity - Participant identity.
+     * @param {string} trackId - Track identifier.
+     */
+    emitTrackUnpublished(roomId: string, participantIdentity: string, trackId: string): void;
+    /**
+     * Emits a track muted event.
+     *
+     * @param {string} roomId - Room identifier.
+     * @param {string} trackId - Track identifier.
+     */
+    emitTrackMuted(roomId: string, trackId: string): void;
+    /**
+     * Emits a track unmuted event.
+     *
+     * @param {string} roomId - Room identifier.
+     * @param {string} trackId - Track identifier.
+     */
+    emitTrackUnmuted(roomId: string, trackId: string): void;
+    /**
+     * Emits a message received event.
+     *
+     * @param {string} roomId - Room identifier.
+     * @param {MockMessageState} message - Received message.
+     */
+    emitMessageReceived(roomId: string, message: MockMessageState): void;
+    /**
+     * Emits a message sent event.
+     *
+     * @param {string} roomId - Room identifier.
+     * @param {MockMessageState} message - Sent message.
+     */
+    emitMessageSent(roomId: string, message: MockMessageState): void;
+    /**
+     * Emits a typing indicator event.
+     *
+     * @param {string} roomId - Room identifier.
+     * @param {string} participantIdentity - Participant identity.
+     * @param {boolean} isTyping - Whether typing.
+     */
+    emitTypingIndicator(roomId: string, participantIdentity: string, isTyping: boolean): void;
+    /**
+     * Emits an agent started event.
+     *
+     * @param {string} roomId - Room identifier.
+     * @param {MockAgentState} agent - Started agent.
+     */
+    emitAgentStarted(roomId: string, agent: MockAgentState): void;
+    /**
+     * Emits an agent stopped event.
+     *
+     * @param {string} roomId - Room identifier.
+     * @param {string} agentId - Agent identifier.
+     */
+    emitAgentStopped(roomId: string, agentId: string): void;
+    /**
+     * Emits an agent message event.
+     *
+     * @param {string} roomId - Room identifier.
+     * @param {string} agentId - Agent identifier.
+     * @param {MockAgentMessage} message - Agent message.
+     */
+    emitAgentMessage(roomId: string, agentId: string, message: MockAgentMessage): void;
+    /**
+     * Emits a data received event.
+     *
+     * @param {string} roomId - Room identifier.
+     * @param {string} participantIdentity - Participant identity.
+     * @param {Uint8Array} data - Received data.
+     * @param {string} [topic] - Data topic.
+     */
+    emitDataReceived(roomId: string, participantIdentity: string, data: Uint8Array, topic?: string): void;
+    /**
+     * Emits an error event.
+     *
+     * @param {MockError} error - Error details.
+     * @param {string} [roomId] - Optional room identifier.
+     */
+    emitError(error: MockError, roomId?: string): void;
+    /**
+     * Gets the event history.
+     *
+     * @param {MockEventType} [filterType] - Optional filter by event type.
+     * @returns {MockEvent[]} Array of events.
+     */
+    getHistory(filterType?: MockEventType): MockEvent[];
+    /**
+     * Gets the last N events.
+     *
+     * @param {number} count - Number of events to get.
+     * @param {MockEventType} [filterType] - Optional filter by event type.
+     * @returns {MockEvent[]} Array of events.
+     */
+    getLastEvents(count: number, filterType?: MockEventType): MockEvent[];
+    /**
+     * Clears the event history.
+     */
+    clearHistory(): void;
+    /**
+     * Gets the count of listeners for a specific event type.
+     *
+     * @param {MockEventType} type - Event type.
+     * @returns {number} Number of listeners.
+     */
+    listenerCount(type: MockEventType): number;
+}
+
+type FirebaseConfig = {
+    apiKey: string;
+    authDomain: string;
+    databaseURL: string;
+    projectId: string;
+    storageBucket: string;
+    messagingSenderId: string;
+    appId: string;
+    measurementId?: string;
+};
+
+/**
+ * Room API response structure from the backend.
+ *
+ * @property {string} id - Room unique identifier.
+ * @property {string} groupId - Group identifier for room categorization.
+ * @property {string} token - Authentication token for room access.
+ * @property {string} wsURL - WebSocket URL for real-time connection.
+ * @property {string} createdAt - ISO timestamp of room creation.
+ * @property {Record<string, unknown>} [affinity] - Affinity data echoed back from the server.
+ */
+type RoomApiResponse = {
+    id: string;
+    groupId: string;
+    token: string;
+    wsURL: string;
+    createdAt: string;
+    affinity?: Record<string, unknown>;
+};
+/**
+ * Room list item structure for room listings.
+ *
+ * @property {string} id - Room unique identifier.
+ * @property {string} [name] - Optional room display name.
+ * @property {string} [groupId] - Group identifier.
+ * @property {string} [organizationId] - Organization that owns the room.
+ * @property {string | null} [endedAt] - Timestamp when room ended, null if active.
+ * @property {string} createdAt - Room creation timestamp.
+ * @property {string} updatedAt - Last update timestamp.
+ * @property {ApiMessage[]} [messages] - Array of messages in the room.
+ * @property {Record<string, unknown>} [metadata] - Additional room metadata.
+ * @property {"active" | "ended" | "pending"} [status] - Current room status.
+ * @property {number} [messageCount] - Total number of messages.
+ * @property {Array<ParticipantInfo>} participants - Room participants.
+ * @property {Array<EvaluationInfo>} evaluations - Room evaluations/ratings.
+ * @property {number} [participantCount] - Total participant count.
+ * @property {number} [evaluationCount] - Total evaluation count.
+ * @property {CountInfo} [_count] - Aggregated counts.
+ */
+type RoomListItem = {
+    id: string;
+    name?: string;
+    groupId?: string;
+    organizationId?: string;
+    endedAt?: string | null;
+    createdAt: string;
+    updatedAt: string;
+    messages?: ApiMessage[];
+    metadata?: Record<string, unknown>;
+    status?: "active" | "ended" | "pending";
+    messageCount?: number;
+    participants: Array<{
+        id: string;
+        name: string;
+        role: "user" | "agent" | "assistant";
+        externalId?: string;
+        image?: string;
+        isAgent?: boolean;
+        isLocal?: boolean;
+    }>;
+    evaluations: Array<{
+        id: string;
+        rating: number;
+        comment?: string;
+        createdAt: string;
+    }>;
+    participantCount?: number;
+    evaluationCount?: number;
+    _count?: {
+        messages?: number;
+        participants?: number;
+        evaluations?: number;
+    };
+};
+/**
+ * Paginated response for room listings.
+ *
+ * @property {RoomListItem[]} items - Array of room items.
+ * @property {number} count - Total number of items.
+ * @property {number} limit - Maximum items per page.
+ * @property {number} offset - Current page offset.
+ */
+type RoomsApiResponse = {
+    items: RoomListItem[];
+    count: number;
+    limit: number;
+    offset: number;
+};
+/**
+ * Participant information with extended user details.
+ *
+ * @property {string} id - User unique identifier.
+ * @property {"user" | "agent" | "assistant"} role - User's role in the conversation.
+ * @property {string} [avatar] - URL to user's avatar image.
+ * @property {string} [name] - Display name of the user.
+ */
+interface UserFrom extends Participant {
+    id: string;
+    role: "user" | "agent" | "assistant";
+    avatar?: string;
+    name?: string;
+}
+/**
+ * User API response after registration.
+ *
+ * @property {string} id - User unique identifier.
+ * @property {string} externalId - External system identifier.
+ * @property {string} organizationId - Associated organization ID.
+ * @property {string} role - User's assigned role.
+ * @property {string} token - Authentication token.
+ */
+type UserApiResponse = {
+    id: string;
+    externalId: string;
+    organizationId: string;
+    role: string;
+    token: string;
+};
+/**
+ * Agent data for registration.
+ *
+ * @property {string} name - Agent display name.
+ * @property {string} [avatar] - URL to agent's avatar.
+ * @property {string} [email] - Agent email address.
+ */
+interface AgentData {
+    name: string;
+    avatar?: string;
+    email?: string;
+}
+/**
+ * Asset attached to a message.
+ *
+ * @property {string} assetType - Type of asset (product, multimedia, faq, file).
+ * @property {string} assetExternalId - External identifier for the asset.
+ */
+interface Assets {
+    assetType: string;
+    assetExternalId: string;
+}
+/**
+ * Media attachment structure.
+ *
+ * @property {string} url - URL of the media file.
+ * @property {string} ext - File extension.
+ * @property {string} [name] - Optional name of the file.
+ * @property {string} [type] - Optional media type.
+ */
+interface MediaAttachment {
+    name?: string;
+    url: string;
+    ext: string;
+    type?: string;
+}
+/**
+ * Report information for a message.
+ *
+ * @property {string} id - Unique identifier of the report.
+ * @property {string} createdAt - ISO timestamp of report creation.
+ */
+interface ReportInfo {
+    id: string;
+    createdAt: string;
+}
+/**
+ * API message structure extending LiveKit's received chat message.
+ *
+ * @property {"standard" | "system"} [type] - Message type classification.
+ * @property {string} content - Text content of the message.
+ * @property {string} createdAt - ISO timestamp of message creation.
+ * @property {UserFrom} [from] - Sender information.
+ * @property {Array<MediaAttachment>} [media] - Attached media files.
+ * @property {Array<Assets>} [assets] - Attached assets.
+ * @property {Array<ReportInfo>} [reports] - Message reports/flags.
+ * @property {Record<string, unknown>} [metadata] - Additional custom metadata.
+ */
+type ApiMessage = Omit<ReceivedChatMessage, "type"> & {
+    type?: "standard" | "system";
+    content: string;
+    createdAt: string;
+    from?: UserFrom;
+    media?: MediaAttachment[];
+    assets?: Assets[];
+    reports?: ReportInfo[];
+    metadata?: Record<string, unknown>;
+};
+/**
+ * Paginated response for messages.
+ *
+ * @property {ApiMessage[]} items - Array of messages.
+ * @property {number} count - Total message count.
+ * @property {number} limit - Maximum items per page.
+ * @property {number} offset - Current page offset.
+ */
+type MessagesApiResponse = {
+    items: ApiMessage[];
+    count: number;
+    limit: number;
+    offset: number;
+};
+/**
+ * Typing indicator event structure.
+ *
+ * @property {"typing"} type - Event type identifier.
+ * @property {boolean} isTyping - Whether the participant is currently typing.
+ * @property {number} timestamp - Unix timestamp of the event.
+ * @property {string} participantId - Identifier of the typing participant.
+ */
+interface TypingIndicator {
+    type: "typing";
+    isTyping: boolean;
+    timestamp: number;
+    participantId: string;
+}
+/**
+ * Available contextual event names.
+ */
+type ContextualEventNames = "call_ended" | "interrupt";
+/**
+ * Contextual event structure for signaling state changes.
+ *
+ * @property {ContextualEventNames} eventName - Name of the event.
+ * @property {Record<string, unknown>} [eventData] - Additional event data.
+ * @property {boolean} [generateResponse] - Whether to trigger AI response.
+ */
+interface ContextualEvent {
+    eventName: ContextualEventNames;
+    eventData?: Record<string, unknown>;
+    generateResponse?: boolean;
+}
+/**
+ * Request status for call/room requests.
+ */
+type RequestStatus = "pending" | "accepted" | "cancelled" | "not_response" | "disconnected" | "failed";
+/**
+ * Call request structure for real-time request handling.
+ *
+ * @property {string} guestId - Identifier of the requesting guest.
+ * @property {string} [name] - Display name of the guest.
+ * @property {string} createdAt - ISO timestamp of request creation.
+ * @property {string} [roomId] - Associated room identifier.
+ * @property {RequestStatus} status - Current request status.
+ * @property {string | null} assignedAgentId - ID of assigned agent, null if unassigned.
+ * @property {string} id - Unique request identifier.
+ */
+interface CallRequest {
+    guestId: string;
+    name?: string;
+    createdAt: string;
+    roomId?: string;
+    status: RequestStatus;
+    assignedAgentId?: string;
+    id: string;
+    userGroupId?: string;
+}
+/**
+ * Room sync notification data structure.
+ *
+ * @property {boolean} needsSync - Whether the room needs synchronization.
+ * @property {string} [reason] - Reason for the sync request.
+ * @property {number} [timestamp] - Unix timestamp of the sync event.
+ */
+interface RoomSyncData {
+    needsSync: boolean;
+    reason?: string;
+    timestamp?: number;
+}
+/**
+ * New room request notification data.
+ *
+ * @property {Object} requestingUser - Information about the requesting user.
+ * @property {string} requestingUser.id - User identifier.
+ * @property {string} requestingUser.name - User display name.
+ * @property {string} requestingUser.role - User role.
+ * @property {number} timestamp - Request timestamp.
+ * @property {string} [status] - Current request status.
+ */
+interface NewRoomRequestData {
+    requestingUser: {
+        id: string;
+        name: string;
+        role: string;
+    };
+    timestamp: number;
+    status?: string;
+}
+/**
+ * Options for creating a new room.
+ *
+ * @property {string} language - Preferred language code (e.g., "en", "es").
+ * @property {string} timezone - IANA timezone identifier.
+ * @property {Record<string, unknown>} [affinity] - Agent affinity preferences.
+ * @property {boolean} [disablePersistence] - Disable message persistence.
+ * @property {Record<string, unknown>} [metadata] - Additional room metadata.
+ * @property {ContextualEvent[]} [contextualEvents] - Initial contextual events.
+ * @property {string} [initialMessage] - Initial message to send when room is created.
+ */
+type CreateRoomOptions = {
+    language: string;
+    timezone: string;
+    affinity?: Record<string, unknown>;
+    disablePersistence?: boolean;
+    metadata?: Record<string, unknown>;
+    contextualEvents?: ContextualEvent[];
+    userGroupId?: string;
+    initialMessage?: string;
+};
+/**
+ * Options for the unified quick-start endpoint that combines user registration
+ * and room creation in a single HTTP call.
+ *
+ * @property {Object} user - User registration data.
+ * @property {string} user.externalId - External user identifier.
+ * @property {string} user.secret - User authentication secret.
+ * @property {string} [user.name] - User display name.
+ * @property {string} [user.email] - User email address.
+ * @property {string} [user.phone] - User phone number.
+ * @property {string} [user.avatar] - URL of the user's avatar.
+ * @property {Record<string, unknown>} [user.metadata] - Additional user metadata.
+ * @property {string | null} [user.userGroupId] - User group identifier.
+ * @property {string} [user.sessionId] - External session identifier.
+ * @property {Object} room - Room creation data.
+ * @property {string} room.language - Preferred language code (e.g., "en", "es").
+ * @property {string} room.timezone - IANA timezone identifier.
+ * @property {Record<string, unknown>} [room.affinity] - Agent affinity preferences.
+ * @property {string} [room.name] - Room display name.
+ * @property {string} [room.platformType] - Platform type (default: "web").
+ * @property {Record<string, unknown>} [room.metadata] - Additional room metadata.
+ * @property {string | null} [room.userGroupId] - Room user group identifier.
+ * @property {boolean} [room.disablePersistence] - Disable message persistence.
+ * @property {ContextualEvent[]} [room.contextualEvents] - Initial contextual events.
+ * @property {{ content: string; assets?: unknown[] }} [room.initialMessage] - Initial message to include in the room.
+ */
+type QuickStartOptions = {
+    user: {
+        externalId: string;
+        secret: string;
+        name?: string;
+        email?: string;
+        phone?: string;
+        avatar?: string;
+        metadata?: Record<string, unknown>;
+        userGroupId?: string | null;
+        sessionId?: string;
+    };
+    room: {
+        language: string;
+        timezone: string;
+        affinity?: Record<string, unknown>;
+        name?: string;
+        platformType?: string;
+        metadata?: Record<string, unknown>;
+        userGroupId?: string | null;
+        disablePersistence?: boolean;
+        contextualEvents?: ContextualEvent[];
+        initialMessage?: {
+            content: string;
+            assets?: unknown[];
+        };
+    };
+};
+/**
+ * Options for fetching messages.
+ *
+ * @property {string} [roomId] - Filter by room ID.
+ * @property {number} [limit] - Maximum messages to return.
+ * @property {string} [orderBy] - Field to order by.
+ * @property {"asc" | "desc"} [orderDir] - Sort direction.
+ * @property {string} [groupId] - Filter by group ID.
+ * @property {Object} [affinity] - Agent affinity filters.
+ * @property {string[]} [with] - Related entities to include.
+ * @property {boolean} [impersonate] - Enable impersonation mode.
+ */
+type GetMessagesOptions = {
+    roomId?: string;
+    limit?: number;
+    orderBy?: string;
+    orderDir?: "asc" | "desc";
+    groupId?: string;
+    affinity?: {
+        agentId?: string;
+        agentType?: string;
+    };
+    with?: string[];
+    impersonate?: boolean;
+};
+/**
+ * Options for persisting a message.
+ *
+ * @property {string} [externalId] - External message identifier.
+ * @property {string} roomId - Room to persist message in.
+ * @property {string} content - Message content.
+ * @property {string} [identity] - Sender identity.
+ * @property {number} [kind] - Participant kind.
+ */
+type PersistMessageOptions = {
+    externalId?: string;
+    roomId: string;
+    content: string;
+    identity?: string;
+    kind?: number;
+};
+/**
+ * Options for room evaluation/rating.
+ *
+ * @property {number} rating - Numeric rating value.
+ * @property {string} [comment] - Optional feedback comment.
+ * @property {string} [roomId] - Optional room identifier.
+ */
+type EvaluateRoomOptions = {
+    rating: number;
+    comment?: string;
+    roomId?: string;
+};
+/**
+ * Options for message reporting.
+ *
+ * @property {string} messageId - ID of message to report.
+ */
+type MessageReportOptions = {
+    messageId: string;
+};
+/**
+ * Options for updating message reactions.
+ *
+ * @property {string} messageId - ID of message to update.
+ * @property {string[]} [add] - Reactions to add.
+ * @property {string[]} [remove] - Reactions to remove.
+ */
+type MessageReactionOptions = {
+    messageId: string;
+    add?: string[];
+    remove?: string[];
+};
+/**
+ * Options for fetching room listings.
+ *
+ * @property {number} [limit] - Maximum rooms per page.
+ * @property {number} [page] - Page number (1-indexed).
+ * @property {number} [offset] - Offset for pagination.
+ * @property {"createdAt" | "updatedAt" | "lastMessageAt"} [orderBy] - Sort field.
+ * @property {"asc" | "desc"} [orderDir] - Sort direction.
+ * @property {string[]} [ids] - Filter by specific room IDs.
+ * @property {string[]} [with] - Related entities to include.
+ * @property {string[]} [count] - Fields to count.
+ * @property {string[]} [participantIds] - Filter by participant IDs.
+ * @property {string[]} [participantExternalIds] - Filter by external participant IDs.
+ * @property {string} [groupId] - Filter by group ID.
+ * @property {boolean} [hasMessages] - Filter rooms with messages.
+ * @property {boolean} [latestOnly] - Return only latest room per group.
+ * @property {boolean} [includeUnread] - Include unread message count.
+ * @property {"active" | "closed"} [roomStatus] - Filter by room status.
+ * @property {boolean} [archived] - Include archived rooms.
+ */
+type GetRoomsOptions = {
+    limit?: number;
+    page?: number;
+    offset?: number;
+    orderBy?: "createdAt" | "updatedAt" | "lastMessageAt";
+    orderDir?: "asc" | "desc";
+    ids?: string[];
+    with?: string[];
+    count?: string[];
+    participantIds?: string[];
+    participantExternalIds?: string[];
+    groupId?: string;
+    hasMessages?: boolean;
+    latestOnly?: boolean;
+    includeUnread?: boolean;
+    roomStatus?: "active" | "closed";
+    archived?: boolean;
+};
+/**
+ * Options for requesting a new room (call transfer).
+ *
+ * @property {string} originRoom - Source room ID.
+ * @property {string} language - Preferred language.
+ * @property {string} timezone - User's timezone.
+ * @property {Object} [affinity] - Agent preferences.
+ * @property {string} [name] - Display name.
+ */
+type RequestNewRoomOptions = {
+    originRoom: string;
+    language: string;
+    timezone: string;
+    affinity?: {
+        agentType?: string;
+        target?: string;
+    };
+    name?: string;
+    userGroupId?: string;
+};
+/**
+ * Configuration options for the ConversationService.
+ *
+ * @property {string} organizationId - Organization identifier.
+ * @property {string} apiUrl - Base URL for the conversation API.
+ * @property {string} [authUrl] - Optional separate auth service URL.
+ * @property {string} [channelTopic] - Custom LiveKit chat topic.
+ * @property {string} [transcriptionTopic] - Custom transcription topic.
+ * @property {string} [eventsTopic] - Custom events topic.
+ * @property {"disabled" | "server" | "client"} [messagePersistence] - Message persistence mode.
+ * @property {FirebaseConfig} [firebaseConfig] - Optional Firebase configuration for real-time features.
+ */
+type ConversationServiceOptions = {
+    organizationId: string;
+    apiUrl: string;
+    authUrl?: string;
+    channelTopic?: string;
+    transcriptionTopic?: string;
+    eventsTopic?: string;
+    messagePersistence?: "disabled" | "server" | "client";
+    firebaseConfig?: FirebaseConfig;
+};
+/**
+ * Callback type for message listeners.
+ */
+type MessageListener<M = ApiMessage> = (messages: M[]) => void;
+/**
+ * Callback type for typing indicator listeners.
+ */
+type TypingListener = (indicator: TypingIndicator) => void;
+/**
+ * Callback type for call request listeners.
+ */
+type CallRequestListener = (id: string, request: CallRequest) => void;
+
+/**
+ * Extended Room class with persistent metadata.
+ *
+ * @description Extends LiveKit Room with additional properties for
+ * tracking room lifecycle and metadata.
+ */
+declare class Room extends Room$1 {
+    /** Unique room identifier */
+    id: string;
+    /** Group identifier for room categorization */
+    groupId: string;
+    /** ISO timestamp of room creation */
+    createdAt: string;
+    /** ISO timestamp when user connected */
+    connectedAt: string;
+    /** Affinity data echoed back from the server */
+    affinity?: Record<string, unknown>;
+}
+/**
+ * @summary Unified service for conversation management.
+ *
+ * @description A comprehensive service that combines real-time communication (LiveKit)
+ * with presence and request management (Firebase) for handling conversations.
+ * This service manages room lifecycle, messaging, typing indicators, call requests,
+ * and agent presence in a unified API.
+ *
+ * @example
+ * ```typescript
+ * const service = new ConversationService({
+ *   organizationId: 'org-123',
+ *   apiUrl: 'https://api.example.com',
+ *   firebaseConfig: { ... }
+ * });
+ *
+ * // Register user and create room
+ * await service.registerUser('user-123', 'secret');
+ * const room = await service.createRoom({
+ *   language: 'en',
+ *   timezone: 'America/New_York'
+ * });
+ *
+ * // Subscribe to messages
+ * service.subscribeMessages((messages) => {
+ *   console.log('New messages:', messages);
+ * });
+ * ```
+ */
+declare class ConversationService {
+    /** Message event listeners */
+    private listeners;
+    /** Typing indicator listeners */
+    private typingListeners;
+    /** Map for deduplicating transcription segments */
+    private transcriptionMap;
+    /** Base API URL */
+    private apiUrl;
+    /** Authentication service URL */
+    private authUrl?;
+    /** Organization identifier */
+    private organizationId;
+    /** LiveKit chat topic */
+    private channelTopic;
+    /** LiveKit transcription topic */
+    private transcriptionTopic;
+    /** LiveKit events topic */
+    private eventsTopic;
+    /** Message persistence mode */
+    private messagePersistence;
+    /** Abort controllers for cancellable requests */
+    private abortControllers;
+    /** Current authentication token */
+    private authToken;
+    /** Firebase API instance (optional) */
+    private firebaseApi?;
+    /** Firebase presence path */
+    private presencePath?;
+    /** Firebase calls path */
+    private callsPath?;
+    /** Active Firebase unsubscribers */
+    private firebaseUnsubscribers;
+    /** Set of seen request IDs for deduplication */
+    private seenRequestIds;
+    /** Map for content-based deduplication */
+    private lastSnapshotById;
+    /** Current LiveKit room instance */
+    room: Room;
+    /**
+     * Initializes a new instance of the ConversationService.
+     *
+     * @param {ConversationServiceOptions} options - Service configuration options.
+     */
+    constructor(options: ConversationServiceOptions);
+    /**
+     * Creates a new LiveKit Room instance with default settings.
+     *
+     * @private
+     * @returns {Room} New Room instance.
+     */
+    private createRoomInstance;
+    /**
+     * Ensures a room instance exists, creating one if necessary.
+     *
+     * @returns {Room} Current or new Room instance.
+     */
+    ensureRoom(): Room;
+    /**
+     * Initializes Firebase services for presence and request management.
+     *
+     * @private
+     * @param {FirebaseConfig} config - Firebase configuration.
+     */
+    private initializeFirebase;
+    /**
+     * Sets up LiveKit room event handlers for messaging and typing.
+     *
+     * @private
+     */
+    private initializeRoomHandlers;
+    /**
+     * Registers a user for conversation access.
+     *
+     * @async
+     * @param {string} externalId - External user identifier.
+     * @param {string} secret - User authentication secret.
+     * @param {Record<string, unknown>} [userData] - Additional user data.
+     * @param {Record<string, unknown>} [metadata] - User metadata.
+     * @returns {Promise<UserApiResponse>} User registration response with token.
+     */
+    registerUser(externalId: string, secret: string, userData?: Record<string, unknown>, metadata?: Record<string, unknown>): Promise<UserApiResponse>;
+    /**
+     * Registers an agent for handling conversations.
+     *
+     * @async
+     * @param {string} externalId - External agent identifier.
+     * @param {AgentData} agentData - Agent profile data.
+     * @returns {Promise<string>} Authentication token.
+     */
+    registerAgent(externalId: string, agentData: AgentData): Promise<string>;
+    /**
+     * Decodes a JWT token payload without verification.
+     *
+     * @private
+     * @param {string} token - JWT token string.
+     * @returns {{ username?: string; sub?: string; iat?: number; exp?: number } | null} Decoded payload or null if invalid.
+     */
+    private decodeJwtPayload;
+    /**
+     * Performs a unified user registration and room creation in a single HTTP call.
+     *
+     * This method combines the `registerUser` and `createRoom` steps into one request,
+     * reducing latency by eliminating the intermediate round-trip and JWT authentication overhead.
+     * It does not require a prior authentication token — only the organization header.
+     *
+     * @async
+     * @param {QuickStartOptions} options - Combined user and room options.
+     * @returns {Promise<Room>} Connected room instance ready for messaging.
+     * @throws {Error} If the quick-start request fails or returns invalid data.
+     */
+    quickStart(options: QuickStartOptions): Promise<Room>;
+    /**
+     * Creates a new conversation room.
+     *
+     * @async
+     * @param {CreateRoomOptions} options - Room creation options.
+     * @param {Record<string, string>} [userData] - User attributes to set.
+     * @returns {Promise<Room>} Connected room instance.
+     */
+    createRoom(options: CreateRoomOptions): Promise<Room>;
+    /**
+     * Joins an existing conversation room.
+     *
+     * @async
+     * @param {string} roomId - Room identifier to join.
+     * @param {string} timezone - User's timezone.
+     * @param {string} language - Preferred language.
+     * @param {Record<string, unknown>} [attributes] - Additional attributes.
+     * @returns {Promise<Room>} Connected room instance.
+     */
+    joinRoom(roomId: string, timezone: string, language: string, attributes?: Record<string, unknown>): Promise<Room>;
+    /**
+     * Sets room metadata from API response.
+     *
+     * @private
+     * @param {RoomApiResponse} response - Room API response.
+     */
+    private setRoomMetadata;
+    /**
+     * Sets up handler for participant attribute changes.
+     *
+     * @private
+     */
+    private setupParticipantAttributesHandler;
+    /**
+     * Evaluates/rates the current room.
+     *
+     * @async
+     * @param {EvaluateRoomOptions} options - Evaluation options.
+     * @returns {Promise<void>}
+     */
+    evaluateRoom(options: EvaluateRoomOptions): Promise<void>;
+    /**
+     * Closes the current room on the server.
+     *
+     * @async
+     * @returns {Promise<void>}
+     */
+    closeRoom(): Promise<void>;
+    /**
+     * Disconnects from the current room.
+     *
+     * @async
+     * @returns {Promise<void>}
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Stops and unpublishes all currently published local tracks.
+     *
+     * @async
+     * @private
+     * @returns {Promise<void>}
+     */
+    private stopAndUnpublishLocalTracks;
+    /**
+     * Closes the room on server and disconnects locally.
+     *
+     * @async
+     * @returns {Promise<void>}
+     */
+    disconnectAndCloseRoom(): Promise<void>;
+    /**
+     * Marks a room as read.
+     *
+     * @async
+     * @param {string} roomId - Room identifier.
+     * @returns {Promise<void>}
+     */
+    readRoom(roomId: string): Promise<void>;
+    /**
+     * Fetches a list of rooms based on options.
+     *
+     * @async
+     * @param {GetRoomsOptions} options - Room listing options.
+     * @returns {Promise<RoomsApiResponse>} Paginated room list.
+     */
+    getRooms(options: GetRoomsOptions): Promise<RoomsApiResponse>;
+    /**
+     * Handles incoming messages from LiveKit.
+     *
+     * @private
+     */
+    private handleIncomingMessage;
+    /**
+     * Emits a message to all subscribed listeners.
+     *
+     * @private
+     * @param {ApiMessage} message - Message to emit.
+     */
+    private emitMessage;
+    /**
+     * Sends a message in the current room.
+     *
+     * @async
+     * @param {string} message - Message content.
+     * @param {Record<string, string>} [attributes] - Message attributes.
+     * @returns {Promise<void>}
+     */
+    sendMessage(message: string, attributes?: Record<string, string>): Promise<void>;
+    /**
+     * Persists a message to the server.
+     *
+     * @async
+     * @param {PersistMessageOptions} options - Persistence options.
+     * @returns {Promise<MessagesApiResponse>}
+     */
+    persistMessage(options: PersistMessageOptions): Promise<MessagesApiResponse>;
+    /**
+     * Fetches messages based on options.
+     *
+     * @async
+     * @param {GetMessagesOptions} options - Message fetching options.
+     * @returns {Promise<ApiMessage[]>} Array of messages.
+     */
+    getMessages(options: GetMessagesOptions): Promise<ApiMessage[]>;
+    /**
+     * Reports a message for moderation.
+     *
+     * @async
+     * @param {MessageReportOptions} options - Report options.
+     * @returns {Promise<void>}
+     */
+    sendMessageReport(options: MessageReportOptions): Promise<void>;
+    /**
+     * Deletes a message report.
+     *
+     * @async
+     * @param {MessageReportOptions} options - Report options.
+     * @returns {Promise<void>}
+     */
+    deleteMessageReport(options: MessageReportOptions): Promise<void>;
+    /**
+     * Updates reactions on a message.
+     *
+     * @async
+     * @param {MessageReactionOptions} options - Reaction options.
+     * @returns {Promise<void>}
+     */
+    updateMessageReactions(options: MessageReactionOptions): Promise<void>;
+    /**
+     * Subscribes to incoming messages.
+     *
+     * @param {MessageListener<M>} callback - Message listener callback.
+     * @returns {() => void} Unsubscribe function.
+     */
+    subscribeMessages<M extends ApiMessage = ApiMessage>(callback: MessageListener<M>): () => void;
+    /**
+     * Handles data received events for typing indicators.
+     *
+     * @private
+     */
+    private handleDataReceived;
+    /**
+     * Emits a typing indicator to all listeners.
+     *
+     * @private
+     * @param {TypingIndicator} indicator - Typing indicator data.
+     */
+    private emitTypingIndicator;
+    /**
+     * Sends a typing indicator to other participants.
+     *
+     * @async
+     * @param {boolean} isTyping - Whether the user is currently typing.
+     * @returns {Promise<void>}
+     */
+    sendTypingIndicator(isTyping: boolean): Promise<void>;
+    /**
+     * Subscribes to typing indicators from other participants.
+     *
+     * @param {TypingListener} listener - Typing indicator listener.
+     * @returns {() => void} Unsubscribe function.
+     */
+    subscribeTypingIndicators(listener: TypingListener): () => void;
+    /**
+     * Unsubscribes a typing indicator listener.
+     *
+     * @param {TypingListener} listener - Listener to remove.
+     */
+    unsubscribeTypingIndicators(listener: TypingListener): void;
+    /**
+     * Sends a contextual event to the room.
+     *
+     * @async
+     * @param {ContextualEvent} event - Event to send.
+     * @returns {Promise<void>}
+     */
+    sendContextualEvent(event: ContextualEvent): Promise<void>;
+    /**
+     * Requests a new room (call transfer).
+     *
+     * @async
+     * @param {RequestNewRoomOptions} options - Request options.
+     * @returns {Promise<RoomApiResponse>} New room details.
+     */
+    requestNewRoom(options: RequestNewRoomOptions): Promise<RoomApiResponse>;
+    /**
+     * Confirms an active room request.
+     *
+     * @async
+     * @param {string} roomId - Room identifier.
+     * @returns {Promise<{ success: boolean; message: string; roomId: string }>}
+     */
+    confirmRoomRequest(roomId: string): Promise<{
+        success: boolean;
+        message: string;
+        roomId: string;
+    }>;
+    /**
+     * Cancels an active room request.
+     *
+     * @async
+     * @param {string} roomId - Room identifier.
+     * @returns {Promise<{ success: boolean; message: string; roomId: string }>}
+     */
+    cancelRoomRequest(roomId: string): Promise<{
+        success: boolean;
+        message: string;
+        roomId: string;
+    }>;
+    /**
+     * Finishes an active call.
+     *
+     * @async
+     * @returns {Promise<void>}
+     */
+    finishCall(): Promise<void>;
+    /**
+     * Checks if Firebase is initialized.
+     *
+     * @returns {boolean} True if Firebase features are available.
+     */
+    isFirebaseEnabled(): boolean;
+    /**
+     * Gets Firebase API and paths, throwing if not initialized.
+     *
+     * @private
+     * @throws {Error} If Firebase is not initialized.
+     * @returns {{ api: FirebaseApi; presencePath: string; callsPath: string }}
+     */
+    private getFirebase;
+    /**
+     * Gets the presence path for an agent.
+     *
+     * @private
+     * @param {string} agentId - Agent identifier.
+     * @returns {string} Firebase path.
+     */
+    private buildAgentPresencePath;
+    /**
+     * Subscribes to presence changes for all agents.
+     *
+     * @param {(agentId: string, data: object | null) => void} callback - Change handler.
+     * @returns {() => void} Unsubscribe function.
+     */
+    onPresenceChange(callback: (agentId: string, data: object | null) => void): () => void;
+    /**
+     * Subscribes to presence changes for a specific agent.
+     *
+     * @param {string} agentId - Agent identifier.
+     * @param {(agentId: string, data: object | null) => void} callback - Change handler.
+     * @returns {() => void} Unsubscribe function.
+     */
+    onPresenceAgentChange(agentId: string, callback: (agentId: string, data: object | null) => void): () => void;
+    /**
+     * Creates a new call request via API.
+     *
+     * @async
+     * @param {Omit<CallRequest, "status" | "createdAt">} requestData - Request data.
+     * @returns {Promise<string>} Request identifier.
+     */
+    createCallRequest(requestData: Omit<CallRequest, "status" | "createdAt" | "id">): Promise<string>;
+    /**
+     * Subscribes to new call requests.
+     *
+     * @param {CallRequestListener} callback - Request handler.
+     * @returns {() => void} Unsubscribe function.
+     */
+    onNewCallRequest(callback: CallRequestListener): () => void;
+    /**
+     * Subscribes to call request changes.
+     *
+     * @param {CallRequestListener} callback - Change handler.
+     * @returns {() => void} Unsubscribe function.
+     */
+    onCallRequestChange(callback: CallRequestListener): () => void;
+    /**
+     * Subscribes to call request removals.
+     *
+     * @param {(id: string) => void} callback - Removal handler.
+     * @returns {() => void} Unsubscribe function.
+     */
+    onCallRequestRemoved(callback: (id: string) => void): () => void;
+    /**
+     * Accepts a call request.
+     *
+     * @async
+     * @param {string} requestId - Request identifier.
+     * @returns {Promise<void>}
+     */
+    acceptCallRequest(requestId: string): Promise<void>;
+    /**
+     * Cancels a call request via API.
+     *
+     * @async
+     * @param {string} requestId - Request identifier.
+     * @returns {Promise<void>}
+     */
+    cancelCallRequest(requestId: string): Promise<void>;
+    /**
+     * Cancels onDisconnect behavior for a request.
+     *
+     * @async
+     * @param {string} requestId - Request identifier.
+     * @returns {Promise<void>}
+     */
+    cancelOnDisconnect(requestId: string): Promise<void>;
+    /**
+     * Subscribes to pending call requests with deduplication.
+     *
+     * @param {CallRequestListener} callback - Request handler.
+     * @param {{ resetSeen?: boolean }} [options] - Subscription options.
+     * @returns {() => void} Unsubscribe function.
+     */
+    subscribePendingRequests(callback: CallRequestListener, options?: {
+        resetSeen?: boolean;
+    }): () => void;
+    /**
+     * Subscribes to request changes with content deduplication.
+     *
+     * @param {CallRequestListener} callback - Change handler.
+     * @returns {() => void} Unsubscribe function.
+     */
+    subscribeRequestChanges(callback: CallRequestListener): () => void;
+    /**
+     * Attempts to safely accept a request if still pending.
+     *
+     * @async
+     * @param {string} requestId - Request identifier.
+     * @returns {Promise<boolean>} True if successfully accepted.
+     */
+    tryAcceptRequest(requestId: string): Promise<boolean>;
+    /**
+     * Subscribes to room sync notifications.
+     *
+     * @param {string} roomId - Room identifier.
+     * @param {(data: RoomSyncData | null) => void} callback - Sync handler.
+     * @returns {() => void} Unsubscribe function.
+     */
+    onRoomSync(roomId: string, callback: (data: RoomSyncData | null) => void): () => void;
+    /**
+     * Clears the sync flag for a room.
+     *
+     * @async
+     * @param {string} roomId - Room identifier.
+     * @param {string} [reason] - Reason for clearing.
+     * @returns {Promise<void>}
+     */
+    clearRoomSync(roomId: string, reason?: string): Promise<void>;
+    /**
+     * Subscribes to new room request notifications.
+     *
+     * @param {string} roomId - Origin room identifier.
+     * @param {(data: NewRoomRequestData | null) => void} callback - Request handler.
+     * @returns {() => void} Unsubscribe function.
+     */
+    onNewRoomRequest(roomId: string, callback: (data: NewRoomRequestData | null) => void): () => void;
+    /**
+     * Removes all Firebase listeners.
+     */
+    unsubscribeAllFirebase(): void;
+    /**
+     * Cleans up all resources and connections.
+     *
+     * @async
+     * @returns {Promise<void>}
+     */
+    destroy(): Promise<void>;
+}
+
+/**
+ * @file Mock LiveKit Track implementations.
+ *
+ * @description Provides mock implementations of LiveKit Track and TrackPublication
+ * classes for testing audio/video functionality without real media streams.
+ */
+
+/**
+ * Mock track that can attach to HTML media elements.
+ *
+ * @description Simulates LiveKit's Track class with support for synthetic media streams.
+ * Tracks can be attached to DOM elements for visual testing.
+ *
+ * @example
+ * ```typescript
+ * const track = new MockTrack("video", "camera", mediaStreamTrack);
+ * const videoElement = track.attach();
+ * document.body.appendChild(videoElement);
+ * ```
+ */
+declare class MockTrack {
+    /** Track kind (audio, video, data) */
+    kind: MockTrackKind;
+    /** Track source (camera, microphone, screen_share, etc.) */
+    source: string;
+    /** Track SID */
+    sid: string;
+    /** Whether track is muted */
+    muted: boolean;
+    /** Whether track is enabled */
+    enabled: boolean;
+    /** Attached elements */
+    private attachedElements;
+    /** MediaStream track if using synthetic media */
+    private mediaStreamTrack?;
+    /** Cleanup function for synthetic media */
+    private mediaCleanup?;
+    /**
+     * Creates a new MockTrack.
+     *
+     * @param kind - Track kind (audio, video, data).
+     * @param source - Track source identifier.
+     * @param mediaStreamTrack - Optional real MediaStreamTrack for synthetic media.
+     * @param mediaCleanup - Optional cleanup function for synthetic media.
+     */
+    constructor(kind: MockTrackKind, source: string, mediaStreamTrack?: MediaStreamTrack, mediaCleanup?: () => void);
+    /**
+     * Gets the underlying MediaStreamTrack if available.
+     */
+    get mediaTrack(): MediaStreamTrack | undefined;
+    /**
+     * Attaches the track to an HTML element.
+     *
+     * @param element - Optional element to attach to. Creates one if not provided.
+     * @returns The attached HTML media element.
+     */
+    attach(element?: HTMLMediaElement): HTMLMediaElement;
+    /**
+     * Detaches the track from an element or all elements.
+     *
+     * @param element - Optional specific element to detach from.
+     * @returns Array of detached elements.
+     */
+    detach(element?: HTMLMediaElement): HTMLMediaElement[];
+    /**
+     * Stops the track and releases resources.
+     */
+    stop(): void;
+    /**
+     * Sets track mute state.
+     *
+     * @param muted - Whether the track should be muted.
+     */
+    setMuted(muted: boolean): void;
+    /**
+     * Sets track enabled state.
+     *
+     * @param enabled - Whether the track should be enabled.
+     */
+    setEnabled(enabled: boolean): void;
+}
+/**
+ * Mock track publication that wraps a track.
+ *
+ * @description Simulates LiveKit's TrackPublication class which represents
+ * a published track in a room.
+ *
+ * @example
+ * ```typescript
+ * const track = new MockTrack("video", "camera");
+ * const publication = new MockTrackPublication(track);
+ * publication.setSubscribed(true);
+ * ```
+ */
+declare class MockTrackPublication {
+    /** Track SID */
+    trackSid: string;
+    /** Track name */
+    trackName: string;
+    /** Track source */
+    source: string;
+    /** Track kind */
+    kind: MockTrackKind;
+    /** Whether subscribed to this track */
+    subscribed: boolean;
+    /** Whether the publication is enabled */
+    isEnabled: boolean;
+    /** The track itself (may be undefined if not subscribed) */
+    track: MockTrack | null;
+    /**
+     * Gets whether the track is muted.
+     */
+    get isMuted(): boolean;
+    /**
+     * Gets whether the track is subscribed.
+     */
+    get isSubscribed(): boolean;
+    /**
+     * Creates a new MockTrackPublication.
+     *
+     * @param track - The track to wrap.
+     * @param name - Optional publication name.
+     */
+    constructor(track: MockTrack, name?: string);
+    /**
+     * Sets subscription state.
+     *
+     * @param subscribed - Whether to subscribe to the track.
+     */
+    setSubscribed(subscribed: boolean): void;
+    /**
+     * Sets track enabled state.
+     *
+     * @param enabled - Whether the track should be enabled.
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * Mutes or unmutes the track.
+     *
+     * @param muted - Whether the track should be muted.
+     */
+    setMuted(muted: boolean): void;
+}
+
+/**
+ * @file Mock LiveKit LocalParticipant implementation.
+ *
+ * @description Provides a mock implementation of LiveKit's LocalParticipant class
+ * with full track management for camera, microphone, and screen sharing.
+ */
+
+/**
+ * Room interface to avoid circular dependency with MockRoom.
+ */
+interface RoomLike {
+    /** Emit an event on the room */
+    emit: (event: string, ...args: unknown[]) => void;
+}
+/**
+ * Options for publishing a track.
+ */
+interface MockPublishOptions {
+    /** Track name */
+    name?: string;
+    /** Video encoding settings */
+    videoEncoding?: {
+        maxBitrate?: number;
+        maxFramerate?: number;
+    };
+    /** Audio encoding settings */
+    audioEncoding?: {
+        maxBitrate?: number;
+    };
+    /** Whether to simulcast video */
+    simulcast?: boolean;
+    /** Track source override */
+    source?: string;
+}
+/**
+ * Mock local participant with full track management support.
+ *
+ * @description Represents the local user in a LiveKit room. Handles publishing
+ * and unpublishing of local media tracks (camera, microphone, screen share).
+ *
+ * @example
+ * ```typescript
+ * const localParticipant = room.localParticipant;
+ * await localParticipant.setCameraEnabled(true);
+ * await localParticipant.setMicrophoneEnabled(true);
+ * console.log(localParticipant.isCameraEnabled); // true
+ * ```
+ */
+declare class MockLocalParticipant {
+    /** Participant identity */
+    identity: string;
+    /** Server-assigned SID */
+    sid: string;
+    /** Display name */
+    name: string;
+    /** Custom attributes */
+    attributes: Record<string, string>;
+    /** Participant kind */
+    kind: string;
+    /** When the participant joined */
+    joinedAt?: Date;
+    /** Track publications by source */
+    private trackPublications;
+    /** Audio track publications by SID */
+    audioTrackPublications: Map<string, MockTrackPublication>;
+    /** Video track publications by SID */
+    videoTrackPublications: Map<string, MockTrackPublication>;
+    /** Camera enabled state */
+    private _cameraEnabled;
+    /** Microphone enabled state */
+    private _microphoneEnabled;
+    /** Screen share enabled state */
+    private _screenShareEnabled;
+    /** Reference to the parent room */
+    private room;
+    /**
+     * Creates a new MockLocalParticipant.
+     *
+     * @param room - The parent room instance.
+     */
+    constructor(room: RoomLike);
+    /**
+     * Gets whether camera is enabled.
+     */
+    get isCameraEnabled(): boolean;
+    /**
+     * Gets whether microphone is enabled.
+     */
+    get isMicrophoneEnabled(): boolean;
+    /**
+     * Gets whether screen share is enabled.
+     */
+    get isScreenShareEnabled(): boolean;
+    /**
+     * Gets all track publications.
+     *
+     * @returns Array of all track publications.
+     */
+    getTrackPublications(): MockTrackPublication[];
+    /**
+     * Gets a track publication by source.
+     *
+     * @param source - Track source (camera, microphone, screen_share).
+     * @returns The track publication or undefined.
+     */
+    getTrackPublication(source: string): MockTrackPublication | undefined;
+    /**
+     * Gets a track publication by SID.
+     *
+     * @param trackSid - Track SID.
+     * @returns The track publication or undefined.
+     */
+    getTrackPublicationBySid(trackSid: string): MockTrackPublication | undefined;
+    /**
+     * Sets participant attributes.
+     *
+     * @param attributes - Attributes to merge.
+     */
+    setAttributes(attributes: Record<string, string>): void;
+    /**
+     * Enables or disables camera.
+     *
+     * @param enabled - Whether to enable camera.
+     * @param options - Optional publish options.
+     * @returns The track publication or undefined.
+     */
+    setCameraEnabled(enabled: boolean, options?: MockPublishOptions): Promise<MockTrackPublication | undefined>;
+    /**
+     * Enables or disables microphone.
+     *
+     * @param enabled - Whether to enable microphone.
+     * @param options - Optional publish options.
+     * @returns The track publication or undefined.
+     */
+    setMicrophoneEnabled(enabled: boolean, options?: MockPublishOptions): Promise<MockTrackPublication | undefined>;
+    /**
+     * Enables or disables screen sharing.
+     *
+     * @param enabled - Whether to enable screen share.
+     * @param options - Optional publish options.
+     * @returns The track publication or undefined.
+     */
+    setScreenShareEnabled(enabled: boolean, options?: MockPublishOptions): Promise<MockTrackPublication | undefined>;
+    /**
+     * Publishes a custom track.
+     *
+     * @param track - The track to publish.
+     * @param options - Publish options.
+     * @returns The track publication.
+     */
+    publishTrack(track: MockTrack, options?: MockPublishOptions): Promise<MockTrackPublication>;
+    /**
+     * Unpublishes a track.
+     *
+     * @param track - The track to unpublish.
+     */
+    unpublishTrack(track: MockTrack): Promise<void>;
+    /**
+     * Sends text message via data channel.
+     *
+     * @param message - Message content.
+     * @param options - Send options.
+     * @returns Object with message ID.
+     */
+    sendText(_message: string, _options?: {
+        topic?: string;
+        attributes?: Record<string, string>;
+    }): Promise<{
+        id: string;
+    }>;
+    /**
+     * Publishes data to the room.
+     *
+     * @param data - Data to publish.
+     * @param options - Publish options.
+     */
+    publishData(_data: Uint8Array, _options?: {
+        reliable?: boolean;
+        topic?: string;
+        destinationIdentities?: string[];
+    }): Promise<void>;
+    /**
+     * Sets metadata on the participant.
+     *
+     * @param metadata - Metadata string.
+     */
+    setMetadata(metadata: string): Promise<void>;
+    /**
+     * Sets the participant name.
+     *
+     * @param name - Display name.
+     */
+    setName(name: string): Promise<void>;
+    /**
+     * Cleans up all tracks.
+     */
+    cleanup(): void;
+}
+
+/**
+ * @file Mock LiveKit Participant implementations.
+ *
+ * @description Provides mock implementations of LiveKit Participant classes
+ * for simulating remote participants in a room.
+ */
+
+/**
+ * Participant connection quality.
+ */
+type MockConnectionQuality = "excellent" | "good" | "poor" | "lost" | "unknown";
+/**
+ * Participant kind string type (for configuration).
+ */
+type MockParticipantKind = "standard" | "ingress" | "egress" | "sip" | "agent";
+/**
+ * Participant kind enum matching LiveKit's ParticipantKind values.
+ * These numeric values must match livekit-protocol's ParticipantInfo_Kind enum.
+ */
+declare enum ParticipantKindValue {
+    STANDARD = 0,
+    INGRESS = 1,
+    EGRESS = 2,
+    SIP = 3,
+    AGENT = 4
+}
+/**
+ * Mock participant representing a remote user in the room.
+ *
+ * @description Simulates a LiveKit RemoteParticipant with track publications
+ * and attribute management.
+ *
+ * @example
+ * ```typescript
+ * const participant = new MockParticipant("user_123", "John Doe");
+ * participant.addTrackPublication(videoPublication);
+ * console.log(participant.getTrackPublications());
+ * ```
+ */
+declare class MockParticipant {
+    /** Participant identity (unique in room) */
+    identity: string;
+    /** Server-assigned SID */
+    sid: string;
+    /** Display name */
+    name?: string;
+    /** Custom attributes */
+    attributes: Record<string, string>;
+    /**
+     * Participant kind as numeric value.
+     * This matches LiveKit's ParticipantKind enum values.
+     */
+    kind: ParticipantKindValue;
+    /** String representation of kind for convenience */
+    private _kindString;
+    /** Connection quality */
+    connectionQuality: MockConnectionQuality;
+    /** Whether participant is speaking */
+    isSpeaking: boolean;
+    /** Audio level (0-1) */
+    audioLevel: number;
+    /** When the participant joined */
+    joinedAt?: Date;
+    /** Track publications */
+    private trackPublications;
+    /**
+     * Creates a new MockParticipant.
+     *
+     * @param identity - Unique participant identity.
+     * @param name - Optional display name.
+     * @param attributes - Optional custom attributes.
+     * @param kind - Participant kind (default: "standard").
+     */
+    constructor(identity: string, name?: string, attributes?: Record<string, string>, kind?: MockParticipantKind);
+    /**
+     * Checks if this is an agent participant.
+     */
+    get isAgent(): boolean;
+    /**
+     * Gets the string representation of kind.
+     */
+    get kindString(): MockParticipantKind;
+    /**
+     * Checks if camera is enabled (has an unmuted camera track).
+     */
+    get isCameraEnabled(): boolean;
+    /**
+     * Checks if microphone is enabled (has an unmuted microphone track).
+     */
+    get isMicrophoneEnabled(): boolean;
+    /**
+     * Gets a track publication by source.
+     *
+     * @param source - Track source (camera, microphone, etc.).
+     * @returns The track publication or undefined.
+     */
+    getTrackPublication(source: string): MockTrackPublication | undefined;
+    /**
+     * Gets a track publication by SID.
+     *
+     * @param trackSid - Track SID.
+     * @returns The track publication or undefined.
+     */
+    getTrackPublicationBySid(trackSid: string): MockTrackPublication | undefined;
+    /**
+     * Gets all track publications.
+     *
+     * @returns Array of all track publications.
+     */
+    getTrackPublications(): MockTrackPublication[];
+    /**
+     * Gets only audio track publications.
+     */
+    getAudioTracks(): MockTrackPublication[];
+    /**
+     * Gets only video track publications.
+     */
+    getVideoTracks(): MockTrackPublication[];
+    /**
+     * Adds a track publication.
+     *
+     * @param pub - Track publication to add.
+     */
+    addTrackPublication(pub: MockTrackPublication): void;
+    /**
+     * Removes a track publication.
+     *
+     * @param trackSid - Track SID to remove.
+     * @returns The removed publication or undefined.
+     */
+    removeTrackPublication(trackSid: string): MockTrackPublication | undefined;
+    /**
+     * Updates participant attributes.
+     *
+     * @param attributes - Attributes to merge.
+     */
+    setAttributes(attributes: Record<string, string>): void;
+    /**
+     * Gets a specific attribute.
+     *
+     * @param key - Attribute key.
+     * @returns The attribute value or undefined.
+     */
+    getAttribute(key: string): string | undefined;
+    /**
+     * Simulates the participant starting to speak.
+     *
+     * @param audioLevel - Audio level (0-1).
+     */
+    startSpeaking(audioLevel?: number): void;
+    /**
+     * Simulates the participant stopping speaking.
+     */
+    stopSpeaking(): void;
+    /**
+     * Sets connection quality.
+     *
+     * @param quality - Connection quality.
+     */
+    setConnectionQuality(quality: MockConnectionQuality): void;
+    /**
+     * Cleans up all tracks.
+     */
+    cleanup(): void;
+}
+
+/**
+ * @file Mock LiveKit data streams.
+ *
+ * @description Provides mock implementations for LiveKit's text and data streaming
+ * capabilities used for real-time message delivery.
+ */
+/**
+ * Text stream info.
+ */
+interface MockTextStreamInfo {
+    /** Stream ID */
+    id: string;
+    /** Stream topic */
+    topic?: string;
+    /** Stream attributes */
+    attributes?: Record<string, string>;
+    /** Timestamp */
+    timestamp?: number;
+    /** Total size if known */
+    totalSize?: number;
+}
+/**
+ * Mock text stream reader for simulating message streams.
+ *
+ * @description Simulates LiveKit's TextStreamReader for receiving streamed text content.
+ * Supports async iteration for consuming stream chunks.
+ *
+ * @example
+ * ```typescript
+ * const reader = new MockTextStreamReader("msg_1", "agent", "Hello, world!");
+ * for await (const chunk of reader) {
+ *   console.log(chunk); // "Hello, world!"
+ * }
+ * ```
+ */
+declare class MockTextStreamReader {
+    /** Stream info */
+    info: MockTextStreamInfo;
+    /** Sender participant identity */
+    participantIdentity: string;
+    /** Stream topic */
+    topic?: string;
+    /** Content chunks */
+    private chunks;
+    /** Current read index */
+    private index;
+    /** Whether stream is complete */
+    private _complete;
+    /**
+     * Creates a new MockTextStreamReader.
+     *
+     * @param id - Stream ID.
+     * @param participantIdentity - Sender identity.
+     * @param content - Full content or array of chunks.
+     * @param attributes - Optional stream attributes.
+     * @param topic - Optional stream topic.
+     */
+    constructor(id: string, participantIdentity: string, content: string | string[], attributes?: Record<string, string>, topic?: string);
+    /**
+     * Gets whether the stream is complete.
+     */
+    get isComplete(): boolean;
+    /**
+     * Async iterator for stream chunks.
+     */
+    [Symbol.asyncIterator](): AsyncIterableIterator<string>;
+    /**
+     * Reads the next chunk.
+     *
+     * @returns The next chunk or null if complete.
+     */
+    read(): Promise<string | null>;
+    /**
+     * Reads all remaining content.
+     *
+     * @returns The complete remaining content.
+     */
+    readAll(): Promise<string>;
+    /**
+     * Cancels the stream.
+     */
+    cancel(): void;
+}
+
+/**
+ * @file Mock LiveKit Room implementation.
+ *
+ * @description Provides a mock implementation of LiveKit's Room class that simulates
+ * room connections, events, and participant management without real infrastructure.
+ */
+
+/**
+ * Room connection state.
+ */
+type MockConnectionState = "disconnected" | "connecting" | "connected" | "reconnecting";
+/**
+ * RPC method handler type.
+ */
+type MockRpcHandler = (data: {
+    callerIdentity: string;
+    payload: string;
+    responseTimeout: number;
+}) => Promise<string> | string;
+/**
+ * Text stream handler type.
+ */
+type MockTextStreamHandler = (reader: MockTextStreamReader, participant: {
+    identity: string;
+}) => void;
+/**
+ * Event handler type.
+ */
+type MockEventHandler = (...args: unknown[]) => void;
+/**
+ * Options for simulating participant join.
+ */
+interface SimulateParticipantOptions {
+    /** Participant display name */
+    name?: string;
+    /** Participant kind */
+    kind?: MockParticipantKind;
+    /** Custom attributes */
+    attributes?: Record<string, string>;
+    /** Whether to add camera track */
+    withCamera?: boolean;
+    /** Whether to add microphone track */
+    withMicrophone?: boolean;
+}
+/**
+ * Mock Room class that mimics LiveKit's Room behavior.
+ *
+ * @description Simulates a LiveKit room with connection management, participant tracking,
+ * event emission, and RPC/stream handling. Core component for testing real-time features.
+ *
+ * @example
+ * ```typescript
+ * const room = new MockRoom(mockService);
+ * await room.connect("wss://mock.local", "token");
+ *
+ * room.on("ParticipantConnected", (participant) => {
+ *   console.log(`${participant.name} joined`);
+ * });
+ *
+ * await room.simulateAgentJoin("agent_1", "AI Assistant");
+ * ```
+ */
+declare class MockRoom {
+    /** Room ID */
+    id: string;
+    /** Server-assigned SID */
+    sid: string;
+    /** Room group ID */
+    groupId: string;
+    /** Room name */
+    name: string;
+    /** Creation timestamp */
+    createdAt: string;
+    /** Connection timestamp */
+    connectedAt: string;
+    /** Room metadata */
+    metadata?: string;
+    /** Local participant reference */
+    localParticipant: MockLocalParticipant;
+    /** Remote participants by identity */
+    remoteParticipants: Map<string, MockParticipant>;
+    /** Connection state */
+    private _state;
+    /** Event handlers by event name */
+    private eventHandlers;
+    /** Text stream handlers by topic */
+    private textStreamHandlers;
+    /** RPC method handlers */
+    private rpcHandlers;
+    /** Reference to parent service for simulation */
+    private mockService;
+    /**
+     * Creates a new MockRoom.
+     *
+     * @param mockService - Parent mock service for coordination.
+     */
+    constructor(mockService: {
+        simulateLatency(): Promise<void>;
+        getState(): any;
+    });
+    /**
+     * Gets the current connection state.
+     */
+    get state(): MockConnectionState;
+    /**
+     * Sets the connection state.
+     */
+    set state(value: MockConnectionState);
+    /**
+     * Gets the number of participants (including local).
+     */
+    get numParticipants(): number;
+    /**
+     * Gets whether the room is connected.
+     */
+    get isConnected(): boolean;
+    /**
+     * Connects to the room.
+     *
+     * @param wsURL - WebSocket URL.
+     * @param token - Authentication token.
+     */
+    connect(_wsURL: string, _token: string): Promise<void>;
+    /**
+     * Disconnects from the room.
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Simulates reconnection.
+     */
+    reconnect(): Promise<void>;
+    /**
+     * Registers an event handler.
+     *
+     * @param event - Event name.
+     * @param handler - Event handler function.
+     */
+    on(event: string, handler: MockEventHandler): this;
+    /**
+     * Registers a one-time event handler.
+     *
+     * @param event - Event name.
+     * @param handler - Event handler function.
+     */
+    once(event: string, handler: MockEventHandler): this;
+    /**
+     * Removes an event handler.
+     *
+     * @param event - Event name.
+     * @param handler - Handler to remove.
+     */
+    off(event: string, handler: MockEventHandler): this;
+    /**
+     * Removes all event handlers.
+     */
+    removeAllListeners(): void;
+    /**
+     * Emits an event to all registered handlers.
+     *
+     * @param event - Event name.
+     * @param args - Event arguments.
+     */
+    emit(event: string, ...args: unknown[]): void;
+    /**
+     * Registers an RPC method handler.
+     *
+     * @param method - Method name.
+     * @param handler - Method handler.
+     */
+    registerRpcMethod(method: string, handler: MockRpcHandler): void;
+    /**
+     * Unregisters an RPC method handler.
+     *
+     * @param method - Method name.
+     */
+    unregisterRpcMethod(method: string): void;
+    /**
+     * Calls an RPC method (simulates receiving a call).
+     *
+     * @param method - Method name.
+     * @param callerIdentity - Caller identity.
+     * @param payload - Method payload.
+     * @param responseTimeout - Timeout in ms.
+     */
+    callRpc(method: string, callerIdentity: string, payload: string, responseTimeout?: number): Promise<string>;
+    /**
+     * Registers a text stream handler.
+     *
+     * @param topic - Stream topic.
+     * @param handler - Stream handler.
+     */
+    registerTextStreamHandler(topic: string, handler: MockTextStreamHandler): void;
+    /**
+     * Unregisters a text stream handler.
+     *
+     * @param topic - Stream topic.
+     */
+    unregisterTextStreamHandler(topic: string): void;
+    /**
+     * Simulates receiving a text stream.
+     *
+     * @param topic - Stream topic.
+     * @param reader - Text stream reader.
+     */
+    simulateTextStream(topic: string, reader: MockTextStreamReader): void;
+    /**
+     * Gets a participant by identity.
+     *
+     * @param identity - Participant identity.
+     */
+    getParticipantByIdentity(identity: string): MockParticipant | undefined;
+    /**
+     * Gets a participant by SID.
+     *
+     * @param sid - Participant SID.
+     */
+    getParticipantBySid(sid: string): MockParticipant | undefined;
+    /**
+     * Simulates a remote participant joining.
+     *
+     * @param identity - Participant identity.
+     * @param options - Join options.
+     */
+    simulateParticipantJoin(identity: string, options?: SimulateParticipantOptions): Promise<MockParticipant>;
+    /**
+     * Simulates a remote participant leaving.
+     *
+     * @param identity - Participant identity.
+     */
+    simulateParticipantLeave(identity: string): void;
+    /**
+     * Simulates a remote track being published.
+     *
+     * @param participantIdentity - Participant identity.
+     * @param kind - Track kind.
+     * @param source - Track source.
+     */
+    simulateRemoteTrack(participantIdentity: string, kind: "audio" | "video", source: string): Promise<MockTrack | undefined>;
+    /**
+     * Simulates a track being unpublished.
+     *
+     * @param participantIdentity - Participant identity.
+     * @param source - Track source.
+     */
+    simulateTrackUnpublished(participantIdentity: string, source: string): void;
+    /**
+     * Simulates an agent joining with camera and microphone.
+     *
+     * @param identity - Agent identity.
+     * @param name - Agent display name.
+     */
+    simulateAgentJoin(identity: string, name?: string): Promise<MockParticipant>;
+    /**
+     * Simulates a participant's attribute change.
+     *
+     * @param identity - Participant identity.
+     * @param attributes - New attributes.
+     */
+    simulateAttributeChange(identity: string, attributes: Record<string, string>): void;
+    /**
+     * Simulates a track mute/unmute.
+     *
+     * @param participantIdentity - Participant identity.
+     * @param source - Track source.
+     * @param muted - Whether muted.
+     */
+    simulateTrackMuted(participantIdentity: string, source: string, muted: boolean): void;
+    /**
+     * Simulates an active speaker change.
+     *
+     * @param speakerIdentities - Identities of active speakers.
+     */
+    simulateActiveSpeakersChanged(speakerIdentities: string[]): void;
+    /**
+     * Simulates data received event.
+     *
+     * @param data - Binary data.
+     * @param participantIdentity - Sender identity.
+     * @param kind - Data kind.
+     * @param topic - Data topic.
+     */
+    simulateDataReceived(data: Uint8Array, participantIdentity: string, kind?: string, topic?: string): void;
+}
+
+/**
+ * @summary In-memory state management for the mock LiveKit service.
+ *
+ * @description Manages all mock state including rooms, participants, tracks, agents,
+ * and messages. Provides methods for state manipulation and queries.
+ */
+
+/**
+ * @summary Manages in-memory state for the mock service.
+ *
+ * @description Provides a centralized store for all mock LiveKit entities
+ * with methods for CRUD operations and state queries.
+ */
+declare class MockState {
+    /** Map of room ID to room state */
+    private rooms;
+    /** Map of participant identity to participant state */
+    private participants;
+    /** Map of track ID to track state */
+    private tracks;
+    /** Map of agent ID to agent state */
+    private agents;
+    /** Map of room ID to array of messages */
+    private messages;
+    /** Current service configuration */
+    private config;
+    /** Random number generator state for deterministic behavior */
+    private randomState;
+    /**
+     * Initializes a new instance of MockState.
+     *
+     * @param {MockServiceConfig} config - Service configuration.
+     */
+    constructor(config?: MockServiceConfig);
+    /**
+     * Updates the service configuration.
+     *
+     * @param {Partial<MockServiceConfig>} config - Configuration updates.
+     */
+    updateConfig(config: Partial<MockServiceConfig>): void;
+    /**
+     * Gets the current service configuration.
+     *
+     * @returns {MockServiceConfig} Current configuration.
+     */
+    getConfig(): MockServiceConfig;
+    /**
+     * Generates a seeded random number for deterministic behavior.
+     *
+     * @returns {number} Random number between 0 and 1.
+     */
+    random(): number;
+    /**
+     * Creates a new room.
+     *
+     * @param {string} name - Room name.
+     * @param {string} [groupId] - Group identifier.
+     * @param {Record<string, unknown>} [metadata] - Room metadata.
+     * @returns {MockRoomState} Created room state.
+     */
+    createRoom(name: string, groupId?: string, metadata?: Record<string, unknown>): MockRoomState;
+    /**
+     * Gets a room by ID.
+     *
+     * @param {string} roomId - Room identifier.
+     * @returns {MockRoomState | undefined} Room state if found.
+     */
+    getRoom(roomId: string): MockRoomState | undefined;
+    /**
+     * Gets a room by name.
+     *
+     * @param {string} name - Room name.
+     * @returns {MockRoomState | undefined} Room state if found.
+     */
+    getRoomByName(name: string): MockRoomState | undefined;
+    /**
+     * Lists all rooms.
+     *
+     * @param {boolean} [activeOnly] - Only return active rooms.
+     * @returns {MockRoomState[]} Array of room states.
+     */
+    listRooms(activeOnly?: boolean): MockRoomState[];
+    /**
+     * Updates room connection state.
+     *
+     * @param {string} roomId - Room identifier.
+     * @param {MockConnectionState} state - New connection state.
+     * @returns {MockConnectionState | undefined} Previous state if room exists.
+     */
+    updateRoomConnectionState(roomId: string, state: MockConnectionState$1): MockConnectionState$1 | undefined;
+    /**
+     * Ends a room.
+     *
+     * @param {string} roomId - Room identifier.
+     * @returns {boolean} True if room was ended successfully.
+     */
+    endRoom(roomId: string): boolean;
+    /**
+     * Deletes a room and all associated data.
+     *
+     * @param {string} roomId - Room identifier.
+     * @returns {boolean} True if room was deleted.
+     */
+    deleteRoom(roomId: string): boolean;
+    /**
+     * Adds a participant to a room.
+     *
+     * @param {string} roomId - Room identifier.
+     * @param {string} identity - Participant identity.
+     * @param {string} [name] - Display name.
+     * @param {MockParticipantRole} [role] - Participant role.
+     * @param {MockParticipantKind} [kind] - Participant kind.
+     * @param {boolean} [isLocal] - Whether this is the local participant.
+     * @returns {MockParticipantState | MockError} Participant state or error.
+     */
+    addParticipant(roomId: string, identity: string, name?: string, role?: MockParticipantRole, kind?: MockParticipantKind$1, isLocal?: boolean): MockParticipantState | MockError;
+    /**
+     * Gets a participant by identity.
+     *
+     * @param {string} identity - Participant identity.
+     * @returns {MockParticipantState | undefined} Participant state if found.
+     */
+    getParticipant(identity: string): MockParticipantState | undefined;
+    /**
+     * Lists participants in a room.
+     *
+     * @param {string} roomId - Room identifier.
+     * @param {boolean} [connectedOnly] - Only return connected participants.
+     * @returns {MockParticipantState[]} Array of participant states.
+     */
+    listParticipants(roomId: string, connectedOnly?: boolean): MockParticipantState[];
+    /**
+     * Updates participant attributes.
+     *
+     * @param {string} identity - Participant identity.
+     * @param {Record<string, string>} attributes - New attributes.
+     * @returns {Record<string, string> | undefined} Previous attributes if participant exists.
+     */
+    updateParticipantAttributes(identity: string, attributes: Record<string, string>): Record<string, string> | undefined;
+    /**
+     * Removes a participant from a room.
+     *
+     * @param {string} identity - Participant identity.
+     * @returns {MockParticipantState | undefined} Removed participant if found.
+     */
+    removeParticipant(identity: string): MockParticipantState | undefined;
+    /**
+     * Publishes a track for a participant.
+     *
+     * @param {string} participantIdentity - Participant identity.
+     * @param {MockTrackKind} kind - Track kind.
+     * @param {MockTrackSource} source - Track source.
+     * @param {Record<string, unknown>} [metadata] - Track metadata.
+     * @returns {MockTrackState | MockError} Track state or error.
+     */
+    publishTrack(participantIdentity: string, kind: MockTrackKind, source?: MockTrackSource, metadata?: Record<string, unknown>): MockTrackState | MockError;
+    /**
+     * Gets a track by ID.
+     *
+     * @param {string} trackId - Track identifier.
+     * @returns {MockTrackState | undefined} Track state if found.
+     */
+    getTrack(trackId: string): MockTrackState | undefined;
+    /**
+     * Lists tracks for a participant or room.
+     *
+     * @param {string} [roomId] - Filter by room ID.
+     * @param {string} [participantIdentity] - Filter by participant identity.
+     * @returns {MockTrackState[]} Array of track states.
+     */
+    listTracks(roomId?: string, participantIdentity?: string): MockTrackState[];
+    /**
+     * Unpublishes a track.
+     *
+     * @param {string} trackId - Track identifier.
+     * @returns {MockTrackState | undefined} Unpublished track if found.
+     */
+    unpublishTrack(trackId: string): MockTrackState | undefined;
+    /**
+     * Mutes or unmutes a track.
+     *
+     * @param {string} trackId - Track identifier.
+     * @param {boolean} muted - Whether to mute the track.
+     * @returns {boolean} True if track was updated.
+     */
+    setTrackMuted(trackId: string, muted: boolean): boolean;
+    /**
+     * Starts an agent in a room.
+     *
+     * @param {string} roomId - Room identifier.
+     * @param {string} name - Agent name.
+     * @param {Partial<MockAgentConfig>} [config] - Agent configuration.
+     * @returns {MockAgentState | MockError} Agent state or error.
+     */
+    startAgent(roomId: string, name: string, config?: Partial<MockAgentConfig>): MockAgentState | MockError;
+    /**
+     * Gets an agent by ID.
+     *
+     * @param {string} agentId - Agent identifier.
+     * @returns {MockAgentState | undefined} Agent state if found.
+     */
+    getAgent(agentId: string): MockAgentState | undefined;
+    /**
+     * Lists agents in a room.
+     *
+     * @param {string} roomId - Room identifier.
+     * @returns {MockAgentState[]} Array of agent states.
+     */
+    listAgents(roomId: string): MockAgentState[];
+    /**
+     * Stops an agent.
+     *
+     * @param {string} agentId - Agent identifier.
+     * @returns {MockAgentState | undefined} Stopped agent if found.
+     */
+    stopAgent(agentId: string): MockAgentState | undefined;
+    /**
+     * Updates agent status.
+     *
+     * @param {string} agentId - Agent identifier.
+     * @param {MockAgentStatus} status - New status.
+     * @returns {boolean} True if agent was updated.
+     */
+    updateAgentStatus(agentId: string, status: MockAgentStatus): boolean;
+    /**
+     * Adds a message to agent's history.
+     *
+     * @param {string} agentId - Agent identifier.
+     * @param {string} content - Message content.
+     * @param {"user" | "agent"} role - Message role.
+     * @returns {MockAgentMessage | undefined} Created message if agent exists.
+     */
+    addAgentMessage(agentId: string, content: string, role: "user" | "agent"): MockAgentMessage | undefined;
+    /**
+     * Adds a message to a room.
+     *
+     * @param {string} roomId - Room identifier.
+     * @param {string} participantIdentity - Sender identity.
+     * @param {string} content - Message content.
+     * @param {"standard" | "system"} [type] - Message type.
+     * @param {Record<string, unknown>} [attributes] - Message attributes.
+     * @returns {MockMessageState | MockError} Message state or error.
+     */
+    addMessage(roomId: string, participantIdentity: string, content: string, type?: "standard" | "system", attributes?: Record<string, unknown>): MockMessageState | MockError;
+    /**
+     * Gets messages for a room.
+     *
+     * @param {string} roomId - Room identifier.
+     * @param {number} [limit] - Maximum messages to return.
+     * @returns {MockMessageState[]} Array of messages.
+     */
+    getMessages(roomId: string, limit?: number): MockMessageState[];
+    /**
+     * Creates a mock error.
+     *
+     * @param {MockErrorCode} code - Error code.
+     * @param {string} message - Error message.
+     * @param {Record<string, unknown>} [details] - Additional details.
+     * @returns {MockError} Mock error object.
+     */
+    createError(code: MockErrorCode, message: string, details?: Record<string, unknown>): MockError;
+    /**
+     * Checks if a value is a MockError.
+     *
+     * @param {unknown} value - Value to check.
+     * @returns {boolean} True if value is a MockError.
+     */
+    isError(value: unknown): value is MockError;
+    /**
+     * Resets all state.
+     */
+    reset(): void;
+    /**
+     * Gets a complete snapshot of the current state.
+     *
+     * @returns {MockStateSnapshot} Current state snapshot.
+     */
+    getSnapshot(): MockStateSnapshot;
+    /**
+     * Exports state to JSON.
+     *
+     * @returns {MockStateSnapshotJSON} JSON-serializable snapshot.
+     */
+    toJSON(): MockStateSnapshotJSON;
+    /**
+     * Imports state from JSON.
+     *
+     * @param {MockStateSnapshotJSON} json - State to import.
+     */
+    fromJSON(json: MockStateSnapshotJSON): void;
+}
+
+/**
+ * @file Mock Conversation Service implementation.
+ *
+ * @summary Drop-in replacement for ConversationService that operates entirely
+ * in memory without real network calls or LiveKit infrastructure.
+ *
+ * @description Provides a complete mock implementation of ConversationService
+ * using the modular livekit/ and actor/ subsystems. Designed for unit testing,
+ * integration testing, and Storybook demonstrations.
+ *
+ * @example
+ * ```typescript
+ * const service = new MockConversationService({
+ *   organizationId: 'test_org',
+ *   latencyMs: 50,
+ * });
+ *
+ * await service.registerUser('user_1', 'secret', { name: 'John' });
+ * const room = await service.createRoom({ language: 'en', timezone: 'UTC' });
+ *
+ * // Send a message
+ * await service.sendMessage("Hello!");
+ * ```
+ */
+
+/**
+ * Mock implementation of ConversationService.
+ *
+ * @description Provides the same API as ConversationService but operates entirely
+ * in memory. Supports deterministic testing, latency simulation, and event tracking.
+ */
+declare class MockConversationService {
+    /** In-memory state manager */
+    private state;
+    /** Event emitter */
+    private events;
+    /** Message listeners */
+    private messageListeners;
+    /** Typing listeners */
+    private typingListeners;
+    /** Call request listeners */
+    private callRequestListeners;
+    /** Current auth token */
+    private _authToken;
+    /** Registered user data */
+    private _registeredUser;
+    /** Service configuration */
+    private config;
+    /** Active agents by ID */
+    private agents;
+    /** Custom agent response handler */
+    private customAgentHandler?;
+    /** Current mock room instance */
+    room: MockRoom;
+    /**
+     * Gets the current auth token.
+     */
+    get authToken(): string | null;
+    /**
+     * Gets the registered user data.
+     */
+    get registeredUser(): UserApiResponse | null;
+    /**
+     * Creates a new MockConversationService.
+     *
+     * @param options - Service configuration options.
+     */
+    constructor(options?: Partial<ConversationServiceOptions> & Partial<MockServiceConfig>);
+    /**
+     * Gets the internal state manager for testing.
+     */
+    getState(): MockState;
+    /**
+     * Gets the event emitter for subscriptions.
+     */
+    getEvents(): MockEventEmitter;
+    /**
+     * Updates mock configuration.
+     */
+    updateConfig(config: Partial<MockServiceConfig>): void;
+    /**
+     * Gets current configuration.
+     */
+    getConfig(): MockServiceConfig;
+    /**
+     * Simulates network latency.
+     */
+    simulateLatency(): Promise<void>;
+    private applyScenario;
+    private shouldThrowError;
+    /**
+     * Ensures a room instance exists.
+     */
+    ensureRoom(): MockRoom;
+    /**
+     * Registers a user for conversation access.
+     */
+    registerUser(externalId: string, _secret: string, userData?: Record<string, unknown>, _metadata?: Record<string, unknown>): Promise<UserApiResponse>;
+    /**
+     * Registers an agent for handling conversations.
+     */
+    registerAgent(externalId: string, agentData: AgentData): Promise<string>;
+    /**
+     * Mock implementation of the unified quick-start endpoint.
+     * Combines registerUser and createRoom into a single call.
+     */
+    quickStart(options: QuickStartOptions): Promise<MockRoom>;
+    /**
+     * Creates a new conversation room.
+     */
+    createRoom(options: CreateRoomOptions, userData?: Record<string, string>): Promise<MockRoom>;
+    /**
+     * Joins an existing conversation room.
+     */
+    joinRoom(roomId: string, _timezone: string, _language: string, attributes?: Record<string, unknown>): Promise<MockRoom>;
+    /**
+     * Evaluates/rates the current room.
+     */
+    evaluateRoom(options: EvaluateRoomOptions): Promise<void>;
+    /**
+     * Closes the current room on the server.
+     */
+    closeRoom(): Promise<void>;
+    /**
+     * Disconnects from the current room.
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Stops all published local tracks in the current room.
+     */
+    private stopLocalTracks;
+    /**
+     * Closes the room and disconnects.
+     */
+    disconnectAndCloseRoom(): Promise<void>;
+    /**
+     * Marks a room as read.
+     */
+    readRoom(roomId: string): Promise<void>;
+    /**
+     * Fetches a list of rooms.
+     */
+    getRooms(options: GetRoomsOptions): Promise<RoomsApiResponse>;
+    /**
+     * Sends a message in the current room.
+     */
+    sendMessage(message: string, attributes?: Record<string, string>): Promise<void>;
+    /**
+     * Persists a message to storage.
+     */
+    persistMessage(options: PersistMessageOptions): Promise<MessagesApiResponse>;
+    /**
+     * Fetches messages.
+     */
+    getMessages(options: GetMessagesOptions): Promise<ApiMessage[]>;
+    /**
+     * Reports a message.
+     */
+    sendMessageReport(_options: MessageReportOptions): Promise<void>;
+    /**
+     * Deletes a message report.
+     */
+    deleteMessageReport(_options: MessageReportOptions): Promise<void>;
+    /**
+     * Updates message reactions.
+     */
+    updateMessageReactions(_options: MessageReactionOptions): Promise<void>;
+    /**
+     * Subscribes to incoming messages.
+     */
+    subscribeMessages<M extends ApiMessage = ApiMessage>(callback: MessageListener<M>): () => void;
+    /**
+     * Sends a typing indicator.
+     */
+    sendTypingIndicator(isTyping: boolean): Promise<void>;
+    /**
+     * Subscribes to typing indicators.
+     */
+    subscribeTypingIndicators(listener: TypingListener): () => void;
+    /**
+     * Unsubscribes a typing listener.
+     */
+    unsubscribeTypingIndicators(listener: TypingListener): void;
+    /**
+     * Sends a contextual event.
+     */
+    sendContextualEvent(_event: ContextualEvent): Promise<void>;
+    /**
+     * Requests a new room (call transfer).
+     */
+    requestNewRoom(options: RequestNewRoomOptions): Promise<RoomApiResponse>;
+    /**
+     * Confirms a room request.
+     */
+    confirmRoomRequest(roomId: string): Promise<{
+        success: boolean;
+        message: string;
+        roomId: string;
+    }>;
+    /**
+     * Cancels a room request.
+     */
+    cancelRoomRequest(roomId: string): Promise<{
+        success: boolean;
+        message: string;
+        roomId: string;
+    }>;
+    /**
+     * Finishes an active call.
+     */
+    finishCall(): Promise<void>;
+    isFirebaseEnabled(): boolean;
+    onPresenceChange(_callback: (agentId: string, data: object | null) => void): () => void;
+    onPresenceAgentChange(_agentId: string, _callback: (agentId: string, data: object | null) => void): () => void;
+    createCallRequest(_requestData: Omit<CallRequest, "status" | "createdAt" | "id">): Promise<string>;
+    onNewCallRequest(callback: CallRequestListener): () => void;
+    onCallRequestChange(callback: CallRequestListener): () => void;
+    onCallRequestRemoved(_callback: (id: string) => void): () => void;
+    acceptCallRequest(_requestId: string): Promise<void>;
+    cancelCallRequest(_requestId: string): Promise<void>;
+    cancelOnDisconnect(_requestId: string): Promise<void>;
+    subscribePendingRequests(_callback: CallRequestListener, _options?: {
+        resetSeen?: boolean;
+    }): () => void;
+    subscribeRequestChanges(_callback: CallRequestListener): () => void;
+    tryAcceptRequest(_requestId: string): Promise<boolean>;
+    onRoomSync(_roomId: string, _callback: (data: RoomSyncData | null) => void): () => void;
+    clearRoomSync(_roomId: string, _reason?: string): Promise<void>;
+    onNewRoomRequest(_roomId: string, _callback: (data: NewRoomRequestData | null) => void): () => void;
+    unsubscribeAllFirebase(): void;
+    destroy(): Promise<void>;
+    /**
+     * Starts a mock agent in a room.
+     *
+     * If the agent type includes "video" or "voice", the agent will also join
+     * the room as a participant with the appropriate media tracks.
+     */
+    startMockAgent(roomId: string, config?: Partial<MockAgentConfig>): Promise<string>;
+    /**
+     * Stops a mock agent.
+     */
+    stopMockAgent(agentId: string): Promise<void>;
+    /**
+     * Sets a custom agent response handler.
+     */
+    setAgentResponseHandler(handler: (agentId: string, message: string) => string | Promise<string>): void;
+    private triggerAgentResponse;
+    /**
+     * Simulates a call request being received.
+     */
+    simulateCallRequest(requestData: Partial<CallRequest>): void;
+    /**
+     * Simulates a participant joining.
+     */
+    simulateParticipantJoin(identity: string, name?: string, role?: "user" | "agent"): void;
+    /**
+     * Simulates a participant leaving.
+     */
+    simulateParticipantLeave(identity: string): void;
+    /**
+     * Simulates receiving a message.
+     */
+    simulateIncomingMessage(participantIdentity: string, content: string): void;
+    /**
+     * Simulates room disconnection.
+     */
+    simulateDisconnect(): Promise<void>;
+    /**
+     * Resets the mock service.
+     */
+    reset(): void;
+    /**
+     * Seeds the random number generator.
+     */
+    seed(seed: number): void;
+    /**
+     * Sets a predefined scenario.
+     */
+    setScenario(scenario: MockScenario): void;
+    /**
+     * Exports current state to JSON.
+     */
+    exportState(): object;
+    /**
+     * Gets event history.
+     */
+    getEventHistory(filterType?: string): any[];
+}
+
+/**
+ * @summary Factory for creating conversation services (real or mock).
+ *
+ * @description Provides a unified factory for creating ConversationService instances.
+ * Automatically selects between real and mock implementations based on environment
+ * configuration or explicit mode parameter.
+ */
+
+/**
+ * LiveKit/Conversation service mode.
+ */
+type LiveKitMode = "real" | "mock";
+/**
+ * Factory configuration options.
+ */
+interface ConversationServiceFactoryOptions extends Partial<ConversationServiceOptions> {
+    /**
+     * Mode to use: 'real' for actual LiveKit, 'mock' for testing.
+     * If not specified, determined from environment.
+     */
+    mode?: LiveKitMode;
+    /**
+     * Mock-specific configuration (only used when mode is 'mock').
+     */
+    mockConfig?: MockServiceConfig;
+}
+/**
+ * @summary Factory for creating conversation services.
+ *
+ * @description Creates either a real ConversationService or MockConversationService
+ * based on configuration. Supports automatic mode detection from environment variables.
+ *
+ * @example
+ * ```typescript
+ * // Auto-detect mode from environment
+ * const service = ConversationServiceFactory.createFromEnv();
+ *
+ * // Explicit mock mode
+ * const mockService = ConversationServiceFactory.create({
+ *   mode: 'mock',
+ *   organizationId: 'test_org',
+ *   apiUrl: 'https://api.example.com',
+ * });
+ *
+ * // Explicit real mode
+ * const realService = ConversationServiceFactory.create({
+ *   mode: 'real',
+ *   organizationId: 'org_123',
+ *   apiUrl: 'https://api.livekit.io',
+ * });
+ * ```
+ */
+declare class ConversationServiceFactory {
+    /**
+     * Creates a service instance with explicit configuration.
+     *
+     * @param {ConversationServiceFactoryOptions} options - Factory options.
+     * @returns {ConversationService | MockConversationService} Service instance.
+     */
+    static create(options: ConversationServiceFactoryOptions): ConversationService | MockConversationService;
+    /**
+     * Creates a service instance from environment configuration.
+     *
+     * @param {Partial<ConversationServiceFactoryOptions>} [overrides] - Optional overrides.
+     * @returns {ConversationService | MockConversationService} Service instance.
+     */
+    static createFromEnv(overrides?: Partial<ConversationServiceFactoryOptions>): ConversationService | MockConversationService;
+    /**
+     * Creates a mock service for testing.
+     *
+     * @param {MockServiceConfig} [config] - Mock configuration.
+     * @returns {MockConversationService} Mock service instance.
+     */
+    static createMock(config?: MockServiceConfig): MockConversationService;
+    /**
+     * Creates a mock service with deterministic behavior for tests.
+     *
+     * @param {number} [seed] - Random seed for deterministic behavior.
+     * @returns {MockConversationService} Deterministic mock service.
+     */
+    static createDeterministicMock(seed?: number): MockConversationService;
+    /**
+     * Gets the current mode from environment.
+     *
+     * @returns {LiveKitMode} Current mode.
+     */
+    static getCurrentMode(): LiveKitMode;
+    /**
+     * Checks if currently in mock mode.
+     *
+     * @returns {boolean} True if in mock mode.
+     */
+    static isMockMode(): boolean;
+    /**
+     * Type guard to check if a service is a mock.
+     *
+     * @param {ConversationService | MockConversationService} service - Service to check.
+     * @returns {boolean} True if service is a mock.
+     */
+    static isMockService(service: ConversationService | MockConversationService): service is MockConversationService;
+}
+/**
+ * Convenience function to create a service from environment.
+ *
+ * @param {Partial<ConversationServiceFactoryOptions>} [overrides] - Optional overrides.
+ * @returns {ConversationService | MockConversationService} Service instance.
+ */
+declare function createConversationService(overrides?: Partial<ConversationServiceFactoryOptions>): ConversationService | MockConversationService;
+/**
+ * Convenience function to create a mock service.
+ *
+ * @param {MockServiceConfig} [config] - Mock configuration.
+ * @returns {MockConversationService} Mock service instance.
+ */
+declare function createMockConversationService(config?: MockServiceConfig): MockConversationService;
+
+/**
+ * @summary Test fixtures for the mock LiveKit service.
+ *
+ * @description Provides pre-configured room, participant, and agent fixtures
+ * for common testing scenarios.
+ */
+
+/**
+ * Creates a default room fixture.
+ *
+ * @param {Partial<MockRoomState>} [overrides] - Optional overrides.
+ * @returns {MockRoomState} Room fixture.
+ */
+declare function createDefaultRoomFixture(overrides?: Partial<MockRoomState>): MockRoomState;
+/**
+ * Creates a room with a local participant.
+ *
+ * @param {string} [localIdentity] - Local participant identity.
+ * @param {Partial<MockRoomState>} [overrides] - Optional room overrides.
+ * @returns {{ room: MockRoomState; localParticipant: MockParticipantState }} Room and participant.
+ */
+declare function createRoomWithLocalParticipant(localIdentity?: string, overrides?: Partial<MockRoomState>): {
+    room: MockRoomState;
+    localParticipant: MockParticipantState;
+};
+/**
+ * Creates a room with two participants.
+ *
+ * @param {Partial<MockRoomState>} [roomOverrides] - Optional room overrides.
+ * @returns {{ room: MockRoomState; participant1: MockParticipantState; participant2: MockParticipantState }} Room and participants.
+ */
+declare function createRoomWithTwoParticipants(roomOverrides?: Partial<MockRoomState>): {
+    room: MockRoomState;
+    participant1: MockParticipantState;
+    participant2: MockParticipantState;
+};
+/**
+ * Creates a room with an agent.
+ *
+ * @param {Partial<MockAgentConfig>} [agentConfig] - Agent configuration.
+ * @param {Partial<MockRoomState>} [roomOverrides] - Optional room overrides.
+ * @returns {{ room: MockRoomState; localParticipant: MockParticipantState; agent: MockAgentState; agentParticipant: MockParticipantState }} Room, participant, and agent.
+ */
+declare function createRoomWithAgent(agentConfig?: Partial<MockAgentConfig>, roomOverrides?: Partial<MockRoomState>): {
+    room: MockRoomState;
+    localParticipant: MockParticipantState;
+    agent: MockAgentState;
+    agentParticipant: MockParticipantState;
+};
+/**
+ * Creates a room with agent and data track.
+ *
+ * @param {Partial<MockRoomState>} [roomOverrides] - Optional room overrides.
+ * @returns {{ room: MockRoomState; localParticipant: MockParticipantState; agent: MockAgentState; dataTrack: MockTrackState }} Complete fixture.
+ */
+declare function createRoomWithAgentAndDataTrack(roomOverrides?: Partial<MockRoomState>): {
+    room: MockRoomState;
+    localParticipant: MockParticipantState;
+    agent: MockAgentState;
+    dataTrack: MockTrackState;
+};
+/**
+ * Creates a room with audio/video tracks.
+ *
+ * @param {Partial<MockRoomState>} [roomOverrides] - Optional room overrides.
+ * @returns {{ room: MockRoomState; participant: MockParticipantState; audioTrack: MockTrackState; videoTrack: MockTrackState }} Complete fixture.
+ */
+declare function createRoomWithMediaTracks(roomOverrides?: Partial<MockRoomState>): {
+    room: MockRoomState;
+    participant: MockParticipantState;
+    audioTrack: MockTrackState;
+    videoTrack: MockTrackState;
+};
+/**
+ * Creates a default participant fixture.
+ *
+ * @param {string} roomId - Room identifier.
+ * @param {Partial<MockParticipantState>} [overrides] - Optional overrides.
+ * @returns {MockParticipantState} Participant fixture.
+ */
+declare function createParticipantFixture(roomId: string, overrides?: Partial<MockParticipantState>): MockParticipantState;
+/**
+ * Creates a batch of participant fixtures.
+ *
+ * @param {string} roomId - Room identifier.
+ * @param {number} count - Number of participants to create.
+ * @returns {MockParticipantState[]} Array of participant fixtures.
+ */
+declare function createParticipantBatch(roomId: string, count: number): MockParticipantState[];
+/**
+ * Creates a default agent fixture.
+ *
+ * @param {string} roomId - Room identifier.
+ * @param {Partial<MockAgentState>} [overrides] - Optional overrides.
+ * @returns {MockAgentState} Agent fixture.
+ */
+declare function createAgentFixture(roomId: string, overrides?: Partial<MockAgentState>): MockAgentState;
+/**
+ * Creates an agent with canned responses.
+ *
+ * @param {string} roomId - Room identifier.
+ * @param {string[]} responses - Canned responses.
+ * @returns {MockAgentState} Agent fixture.
+ */
+declare function createAgentWithCannedResponses(roomId: string, responses: string[]): MockAgentState;
+/**
+ * Creates an agent configured for sequential responses.
+ *
+ * @param {string} roomId - Room identifier.
+ * @param {string[]} responses - Responses in order.
+ * @returns {MockAgentState} Agent fixture.
+ */
+declare function createSequentialAgent(roomId: string, responses: string[]): MockAgentState;
+/**
+ * Creates a default message fixture.
+ *
+ * @param {string} roomId - Room identifier.
+ * @param {string} participantIdentity - Sender identity.
+ * @param {Partial<MockMessageState>} [overrides] - Optional overrides.
+ * @returns {MockMessageState} Message fixture.
+ */
+declare function createMessageFixture(roomId: string, participantIdentity: string, overrides?: Partial<MockMessageState>): MockMessageState;
+/**
+ * Creates a conversation fixture with multiple messages.
+ *
+ * @param {string} roomId - Room identifier.
+ * @param {Array<{ identity: string; content: string }>} messages - Messages to create.
+ * @returns {MockMessageState[]} Array of message fixtures.
+ */
+declare function createConversationFixture(roomId: string, messages: Array<{
+    identity: string;
+    content: string;
+}>): MockMessageState[];
+/**
+ * Creates a default service configuration.
+ *
+ * @param {Partial<MockServiceConfig>} [overrides] - Optional overrides.
+ * @returns {MockServiceConfig} Configuration fixture.
+ */
+declare function createDefaultConfig(overrides?: Partial<MockServiceConfig>): MockServiceConfig;
+/**
+ * Creates a strict mode configuration.
+ *
+ * @param {Partial<MockServiceConfig>} [overrides] - Optional overrides.
+ * @returns {MockServiceConfig} Configuration fixture.
+ */
+declare function createStrictConfig(overrides?: Partial<MockServiceConfig>): MockServiceConfig;
+/**
+ * Creates a configuration with artificial latency.
+ *
+ * @param {number} latencyMs - Latency in milliseconds.
+ * @param {Partial<MockServiceConfig>} [overrides] - Optional overrides.
+ * @returns {MockServiceConfig} Configuration fixture.
+ */
+declare function createLatencyConfig(latencyMs: number, overrides?: Partial<MockServiceConfig>): MockServiceConfig;
+/**
+ * Creates a deterministic configuration with seed.
+ *
+ * @param {number} seed - Random seed.
+ * @param {Partial<MockServiceConfig>} [overrides] - Optional overrides.
+ * @returns {MockServiceConfig} Configuration fixture.
+ */
+declare function createDeterministicConfig(seed: number, overrides?: Partial<MockServiceConfig>): MockServiceConfig;
+/**
+ * Creates a complete chat scenario with room, participants, and messages.
+ *
+ * @returns {Object} Complete chat scenario fixture.
+ */
+declare function createChatScenario(): {
+    room: MockRoomState;
+    user: MockParticipantState;
+    agent: MockAgentState;
+    agentParticipant: MockParticipantState;
+    messages: MockMessageState[];
+};
+/**
+ * Creates a video call scenario with room, participants, and tracks.
+ *
+ * @returns {Object} Complete video call scenario fixture.
+ */
+declare function createVideoCallScenario(): {
+    room: MockRoomState;
+    participant1: MockParticipantState;
+    participant2: MockParticipantState;
+    tracks: MockTrackState[];
+};
+
+/**
+ * @summary Generator functions for mock IDs, tokens, and URLs.
+ *
+ * @description Provides utility functions for generating deterministic
+ * mock identifiers, tokens, and URLs for testing purposes.
+ */
+/**
+ * Resets the ID counter for deterministic testing.
+ */
+declare function resetIdCounter(): void;
+/**
+ * Sets the ID counter to a specific value.
+ *
+ * @param {number} value - New counter value.
+ */
+declare function setIdCounter(value: number): void;
+/**
+ * Generates a mock ID with a prefix.
+ *
+ * @param {string} prefix - ID prefix (e.g., 'room', 'track', 'agent').
+ * @returns {string} Generated mock ID.
+ *
+ * @example
+ * ```typescript
+ * const roomId = generateMockId('room'); // 'mock_room_1'
+ * const trackId = generateMockId('track'); // 'mock_track_2'
+ * ```
+ */
+declare function generateMockId(prefix: string): string;
+/**
+ * Generates a deterministic mock ID based on seed.
+ *
+ * @param {string} prefix - ID prefix.
+ * @param {number} seed - Seed for deterministic generation.
+ * @returns {string} Generated mock ID.
+ */
+declare function generateSeededMockId(prefix: string, seed: number): string;
+/**
+ * Generates a mock token.
+ *
+ * @param {string} roomId - Room identifier.
+ * @param {string} identity - Participant identity.
+ * @param {string} [timestamp] - Optional timestamp (defaults to now).
+ * @returns {string} Generated mock token.
+ *
+ * @example
+ * ```typescript
+ * const token = generateMockToken('room_1', 'user_123');
+ * // 'mock_token_room_1_user_123_1705692000000'
+ * ```
+ */
+declare function generateMockToken(roomId: string, identity: string, timestamp?: string): string;
+/**
+ * Decodes a mock token to extract its components.
+ *
+ * @param {string} token - Mock token to decode.
+ * @returns {{ roomId: string; identity: string; timestamp: string } | null} Decoded token or null if invalid.
+ */
+declare function decodeMockToken(token: string): {
+    roomId: string;
+    identity: string;
+    timestamp: string;
+} | null;
+/**
+ * Generates a mock WebSocket URL.
+ *
+ * @param {string} roomId - Room identifier.
+ * @returns {string} Generated mock WebSocket URL.
+ */
+declare function generateMockWsUrl(roomId: string): string;
+/**
+ * Generates a mock participant identity.
+ *
+ * @param {string} [prefix] - Optional prefix.
+ * @param {number} [index] - Optional index for deterministic generation.
+ * @returns {string} Generated participant identity.
+ */
+declare function generateMockParticipantIdentity(prefix?: string, index?: number): string;
+/**
+ * Generates a mock room name.
+ *
+ * @param {string} [prefix] - Optional prefix.
+ * @returns {string} Generated room name.
+ */
+declare function generateMockRoomName(prefix?: string): string;
+/**
+ * Generates a mock track SID (Session ID).
+ *
+ * @param {string} kind - Track kind (audio, video, data).
+ * @param {string} participantIdentity - Participant identity.
+ * @returns {string} Generated track SID.
+ */
+declare function generateMockTrackSid(kind: string, participantIdentity: string): string;
+/**
+ * Generates a unique message ID.
+ *
+ * @returns {string} Generated message ID.
+ */
+declare function generateMockMessageId(): string;
+/**
+ * Generates a mock API response ID.
+ *
+ * @param {string} type - Response type (e.g., 'user', 'room').
+ * @returns {string} Generated response ID.
+ */
+declare function generateMockApiResponseId(type: string): string;
+/**
+ * Generates a mock external ID (UUID-like).
+ *
+ * @returns {string} Generated external ID.
+ */
+declare function generateMockExternalId(): string;
+/**
+ * Generates a sequence of mock IDs for batch operations.
+ *
+ * @param {string} prefix - ID prefix.
+ * @param {number} count - Number of IDs to generate.
+ * @returns {string[]} Array of generated IDs.
+ */
+declare function generateMockIdBatch(prefix: string, count: number): string[];
+
+/**
+ * @file Synthetic media generators for mock LiveKit tracks.
+ * @description Generates fake video and audio MediaStreams for visual demos
+ * in Storybook without requiring real camera/microphone access.
+ */
+/**
+ * Configuration for synthetic video generation.
+ */
+interface SyntheticVideoConfig {
+    /** Video width in pixels. Default: 640 */
+    width?: number;
+    /** Video height in pixels. Default: 480 */
+    height?: number;
+    /** Frames per second. Default: 30 */
+    fps?: number;
+    /** Background color. Default: '#1a1a2e' */
+    backgroundColor?: string;
+    /** Foreground/animation color. Default: '#4361ee' */
+    foregroundColor?: string;
+    /** Label to display on video. Default: 'Mock Video' */
+    label?: string;
+    /** Animation type. Default: 'wave' */
+    animation?: "wave" | "pulse" | "bars" | "avatar" | "none";
+}
+/**
+ * Configuration for synthetic audio generation.
+ */
+interface SyntheticAudioConfig {
+    /** Base frequency in Hz. Default: 440 */
+    frequency?: number;
+    /** Volume (0-1). Default: 0.1 */
+    volume?: number;
+    /** Waveform type. Default: 'sine' */
+    waveType?: OscillatorType;
+    /** Whether to add variation. Default: true */
+    addVariation?: boolean;
+    /** Enable audio (false = silent track). Default: false */
+    enabled?: boolean;
+}
+/**
+ * Creates a synthetic video MediaStreamTrack using canvas.
+ *
+ * @param config - Video configuration options.
+ * @returns Object with track and cleanup function.
+ *
+ * @example
+ * ```typescript
+ * const { track, cleanup } = createSyntheticVideoTrack({
+ *   width: 1280,
+ *   height: 720,
+ *   animation: 'avatar',
+ *   label: 'Agent Camera',
+ * });
+ *
+ * videoElement.srcObject = new MediaStream([track]);
+ *
+ * // When done:
+ * cleanup();
+ * ```
+ */
+declare function createSyntheticVideoTrack(config?: SyntheticVideoConfig): {
+    track: MediaStreamTrack;
+    stream: MediaStream;
+    cleanup: () => void;
+};
+/**
+ * Creates a synthetic audio MediaStreamTrack using Web Audio API.
+ *
+ * @param config - Audio configuration options.
+ * @returns Object with track and cleanup function.
+ *
+ * @example
+ * ```typescript
+ * const { track, cleanup } = createSyntheticAudioTrack({
+ *   frequency: 440,
+ *   volume: 0.1,
+ *   enabled: true, // Set to false for silent track
+ * });
+ *
+ * audioElement.srcObject = new MediaStream([track]);
+ *
+ * // When done:
+ * cleanup();
+ * ```
+ */
+declare function createSyntheticAudioTrack(config?: SyntheticAudioConfig): {
+    track: MediaStreamTrack;
+    stream: MediaStream;
+    cleanup: () => void;
+    setVolume: (volume: number) => void;
+    setEnabled: (enabled: boolean) => void;
+};
+/**
+ * Creates a complete mock media setup with both video and audio.
+ *
+ * @param videoConfig - Video configuration.
+ * @param audioConfig - Audio configuration.
+ * @returns Combined media setup.
+ */
+declare function createSyntheticMedia(videoConfig?: SyntheticVideoConfig, audioConfig?: SyntheticAudioConfig): {
+    videoTrack: MediaStreamTrack;
+    audioTrack: MediaStreamTrack;
+    combinedStream: MediaStream;
+    cleanup: () => void;
+    setAudioVolume: (volume: number) => void;
+    setAudioEnabled: (enabled: boolean) => void;
+};
+/**
+ * Preset configurations for common scenarios.
+ */
+declare const SYNTHETIC_MEDIA_PRESETS: {
+    /** Local user camera */
+    readonly localCamera: {
+        readonly video: {
+            readonly width: 640;
+            readonly height: 480;
+            readonly animation: "avatar";
+            readonly label: "You";
+            readonly foregroundColor: "#4361ee";
+        };
+        readonly audio: {
+            readonly enabled: false;
+        };
+    };
+    /** Remote agent camera */
+    readonly agentCamera: {
+        readonly video: {
+            readonly width: 640;
+            readonly height: 480;
+            readonly animation: "avatar";
+            readonly label: "AI Agent";
+            readonly foregroundColor: "#22c55e";
+            readonly backgroundColor: "#0f172a";
+        };
+        readonly audio: {
+            readonly enabled: false;
+            readonly frequency: 300;
+        };
+    };
+    /** Screen share simulation */
+    readonly screenShare: {
+        readonly video: {
+            readonly width: 1920;
+            readonly height: 1080;
+            readonly animation: "bars";
+            readonly label: "Screen Share";
+            readonly backgroundColor: "#0a0a0a";
+            readonly foregroundColor: "#f59e0b";
+        };
+        readonly audio: {
+            readonly enabled: false;
+        };
+    };
+    /** Voice-only call */
+    readonly voiceOnly: {
+        readonly video: {
+            readonly width: 320;
+            readonly height: 240;
+            readonly animation: "wave";
+            readonly label: "Voice Call";
+        };
+        readonly audio: {
+            readonly enabled: false;
+            readonly volume: 0.05;
+        };
+    };
+};
+/**
+ * Creates synthetic media from a preset.
+ */
+declare function createSyntheticMediaFromPreset(preset: keyof typeof SYNTHETIC_MEDIA_PRESETS): ReturnType<typeof createSyntheticMedia>;
+
+/**
+ * Gets or creates a global mock service instance.
+ *
+ * @param {Partial<MockServiceConfig>} config - Service configuration.
+ * @returns {MockConversationService} The mock service instance.
+ */
+declare function getStorybookMockService(config?: Partial<MockServiceConfig>): MockConversationService;
+/**
+ * Resets the global mock service (useful between stories).
+ */
+declare function resetStorybookMockService(): void;
+/**
+ * Destroys the global mock service completely.
+ */
+declare function destroyStorybookMockService(): Promise<void>;
+/**
+ * Configuration for the mock service decorator.
+ */
+interface MockServiceDecoratorConfig {
+    /** Organization ID */
+    organizationId?: string;
+    /** Auto-register a user */
+    autoRegisterUser?: {
+        identity: string;
+        secret?: string;
+        name?: string;
+    };
+    /** Auto-create a room */
+    autoCreateRoom?: {
+        language?: string;
+        timezone?: string;
+    };
+    /** Auto-start an agent */
+    autoStartAgent?: Partial<MockAgentConfig>;
+    /** Pre-seed messages */
+    seedMessages?: Array<{
+        from: string;
+        content: string;
+    }>;
+    /** Latency simulation */
+    latencyMs?: number;
+    /** Scenario to apply */
+    scenario?: MockScenario;
+    /** Whether to simulate video (enables synthetic video tracks) */
+    simulateVideo?: boolean;
+}
+/**
+ * Generic decorator type for Storybook compatibility.
+ * Uses `any` to be compatible with all Storybook renderer types.
+ */
+type Decorator = (storyFn: () => any, context?: any) => any;
+/**
+ * Creates a Storybook decorator that provides a MockConversationService.
+ *
+ * @param {MockServiceDecoratorConfig} config - Decorator configuration.
+ * @returns {Decorator} Storybook decorator function.
+ *
+ * @example
+ * ```typescript
+ * export const Default: Story = {
+ *   decorators: [
+ *     withMockConversationService({
+ *       autoRegisterUser: { identity: 'user_1', name: 'Test User' },
+ *       autoCreateRoom: { language: 'en' },
+ *       autoStartAgent: { responseStrategy: 'echo' },
+ *     }),
+ *   ],
+ * };
+ * ```
+ */
+declare function withMockConversationService(config?: MockServiceDecoratorConfig): Decorator;
+/**
+ * Type guard to check if ConversationService is a mock.
+ *
+ * @param {unknown} service - Service to check.
+ * @returns {service is MockConversationService} True if mock.
+ */
+declare function isMockConversationService(service: unknown): service is MockConversationService;
+/**
+ * Pre-configured scenarios for common Storybook use cases.
+ */
+declare const StorybookScenarios: Record<string, MockServiceDecoratorConfig>;
+/**
+ * Creates a mock service factory function for use in story args.
+ *
+ * This is useful when you need to pass a ConversationService as a prop.
+ *
+ * @param {Partial<MockServiceConfig>} config - Configuration.
+ * @returns {() => MockConversationService} Factory function.
+ *
+ * @example
+ * ```typescript
+ * export const Default: Story = {
+ *   args: {
+ *     conversationService: createMockServiceFactory({
+ *       latencyMs: 100,
+ *     }),
+ *   },
+ * };
+ * ```
+ */
+declare function createMockServiceFactory(config?: Partial<MockServiceConfig>): () => MockConversationService;
+/**
+ * Action helpers for Storybook interactions.
+ */
+declare const MockServiceActions: {
+    /**
+     * Simulates receiving a message.
+     */
+    receiveMessage(from: string, content: string): Promise<void>;
+    /**
+     * Simulates a participant joining.
+     */
+    simulateJoin(identity: string, name?: string): void;
+    /**
+     * Simulates a participant leaving.
+     */
+    simulateLeave(identity: string): void;
+    /**
+     * Simulates a participant joining with video and audio.
+     *
+     * @param identity - Participant identity.
+     * @param name - Display name.
+     * @param options - Additional options.
+     */
+    simulateVideoParticipant(identity: string, name?: string, options?: {
+        withCamera?: boolean;
+        withMicrophone?: boolean;
+    }): Promise<void>;
+    /**
+     * Simulates an agent joining with video capabilities.
+     *
+     * @param identity - Agent identity.
+     * @param name - Display name.
+     */
+    simulateVideoAgent(identity: string, name?: string): Promise<void>;
+    /**
+     * Enables the local participant's camera.
+     */
+    enableLocalCamera(): Promise<void>;
+    /**
+     * Disables the local participant's camera.
+     */
+    disableLocalCamera(): Promise<void>;
+    /**
+     * Enables the local participant's microphone.
+     */
+    enableLocalMicrophone(): Promise<void>;
+    /**
+     * Simulates multiple participants for layout testing.
+     *
+     * @param count - Number of participants to add.
+     */
+    simulateMultipleParticipants(count: number): Promise<void>;
+    /**
+     * Clears all remote participants (useful for reset).
+     */
+    clearParticipants(): void;
+    /**
+     * Simulates a call request.
+     */
+    simulateCallRequest(name: string, guestId?: string): void;
+    /**
+     * Simulates network disconnection.
+     */
+    simulateDisconnect(): Promise<void>;
+    /**
+     * Gets event history for debugging.
+     */
+    getEventHistory(): unknown[];
+    /**
+     * Exports current state for debugging.
+     */
+    exportState(): object;
+    /**
+     * Gets the current room instance.
+     */
+    getRoom(): MockRoom;
+};
+
+export { AgentNotFoundError, Asset, type AssetDisplayOptions, type AssetItemDisplayOptions, ConversationServiceFactory, type ConversationServiceFactoryOptions, InvalidOperationError, type LiveKitMode, type MockAgentConfig, type MockAgentMessage, type MockAgentMessageEvent, type MockAgentResponseStrategy, type MockAgentStartedEvent, type MockAgentState, type MockAgentStatus, type MockAgentStoppedEvent, type MockConnectionState$1 as MockConnectionState, MockConversationService, type MockDataReceivedEvent, type MockError, type MockErrorCode, type MockErrorConfig, type MockErrorEvent, type MockEvent, type MockEventBase, MockEventEmitter, type MockEventListener, type MockEventListenerMap, type MockEventType, MockLiveKitError, MockLocalParticipant, type MockMessageReceivedEvent, type MockMessageSentEvent, type MockMessageState, MockParticipant, type MockParticipantAttributesChangedEvent, type MockParticipantJoinedEvent, type MockParticipantKind$1 as MockParticipantKind, type MockParticipantLeftEvent, type MockParticipantRole, type MockParticipantState, MockRoom, type MockRoomConnectionStateChangedEvent, type MockRoomCreatedEvent, type MockRoomEndedEvent, type MockRoomState, type MockScenario, MockServiceActions, type MockServiceConfig, type MockServiceDecoratorConfig, MockState, type MockStateSnapshot, type MockStateSnapshotJSON, MockTextStreamReader, MockTrack, type MockTrackKind, type MockTrackMutedEvent, MockTrackPublication, type MockTrackPublishedEvent, type MockTrackSource, type MockTrackState, type MockTrackUnmutedEvent, type MockTrackUnpublishedEvent, type MockTypingIndicatorEvent, NetworkError, OSBAsset, OSBSideBar, OSBUpload, ParticipantAlreadyJoinedError, ParticipantNotFoundError, RoomEndedError, RoomNotFoundError, SYNTHETIC_MEDIA_PRESETS, SideBar, StorybookScenarios, type SyntheticAudioConfig, type SyntheticVideoConfig, TimeoutError, TrackNotFoundError, UnauthorizedError, Upload, type UploadConfig, createAgentFixture, createAgentWithCannedResponses, createChatScenario, createConversationFixture, createConversationService, createDefaultConfig, createDefaultRoomFixture, createDeterministicConfig, createErrorFromMockError, createLatencyConfig, createMessageFixture, createMockConversationService, createMockServiceFactory, createParticipantBatch, createParticipantFixture, createRoomWithAgent, createRoomWithAgentAndDataTrack, createRoomWithLocalParticipant, createRoomWithMediaTracks, createRoomWithTwoParticipants, createSequentialAgent, createStrictConfig, createSyntheticAudioTrack, createSyntheticMedia, createSyntheticMediaFromPreset, createSyntheticVideoTrack, createVideoCallScenario, decodeMockToken, destroyStorybookMockService, generateMockApiResponseId, generateMockExternalId, generateMockId, generateMockIdBatch, generateMockMessageId, generateMockParticipantIdentity, generateMockRoomName, generateMockToken, generateMockTrackSid, generateMockWsUrl, generateSeededMockId, getStorybookMockService, isMockConversationService, isMockError, isMockLiveKitError, resetIdCounter, resetStorybookMockService, setIdCounter, withMockConversationService };