@signalwire/js 3.29.2 → 4.0.0-beta.0

package/dist/index.d.cts

@@ -0,0 +1,2690 @@
+import { n as JSONRPCRequest, r as JSONRPCResponse, t as EventChannel } from "./base-A5AZTrAd.cjs";
+import * as rxjs0 from "rxjs";
+import { BehaviorSubject, Observable, Observer, ReplaySubject, Subject, Subscription } from "rxjs";
+import { URL as URL$1 } from "node:url";
+
+//#region src/behaviors/Destroyable.d.ts
+declare abstract class Destroyable {
+  protected subscriptions: Subscription[];
+  protected subjects: Subject<unknown>[];
+  protected _destroyed$: Subject<void>;
+  destroy(): void;
+  protected subscribeTo<T>(observable: Observable<T>, observerOrNext: Partial<Observer<T>> | ((value: T) => void) | undefined): void;
+  protected createSubject<T>(): Subject<T>;
+  protected createReplaySubject<T>(bufferSize?: number, windowTime?: number): ReplaySubject<T>;
+  protected createBehaviorSubject<T>(initialValue: T): BehaviorSubject<T>;
+  get $(): Observable<this>;
+  /**
+   * Observable that emits when the instance is destroyed
+   */
+  get destroyed$(): Observable<void>;
+}
+//#endregion
+//#region src/core/types/media.types.d.ts
+/** WebRTC transceiver direction for a single media kind. */
+type MediaDirection = RTCRtpTransceiverDirection;
+/** Audio and video directions "inactive" | "recvonly" | "sendonly" | "sendrecv" | "stopped" */
+interface MediaDirections {
+  /** Audio direction */
+  audio: MediaDirection;
+  /** Video direction */
+  video: MediaDirection;
+}
+/** Options controlling which media tracks to send and receive. */
+interface MediaOptions {
+  /** Enable audio input. */
+  audio?: boolean;
+  /** Enable video input. */
+  video?: boolean;
+  /** Custom constraints for the audio input track. */
+  inputAudioDeviceConstraints?: MediaTrackConstraints;
+  /** Custom constraints for the video input track. */
+  inputVideoDeviceConstraints?: MediaTrackConstraints;
+  /** Pre-existing audio stream to use instead of `getUserMedia`. */
+  inputAudioStream?: MediaStream;
+  /** Pre-existing video stream to use instead of `getUserMedia`. */
+  inputVideoStream?: MediaStream;
+  /** Whether to receive remote audio. */
+  receiveAudio?: boolean;
+  /** Whether to receive remote video. */
+  receiveVideo?: boolean;
+}
+//#endregion
+//#region src/core/types/common.types.d.ts
+interface JSONSerializable {
+  [key: string]: JSONSerializable | string | number | boolean | null | undefined | JSONSerializable[];
+}
+/**
+ * HTTP methods supported by the HTTPRequest interface
+ */
+type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+/**
+ * HTTP headers as key-value pairs
+ */
+type HTTPHeaders = Record<string, string>;
+/**
+ * Represents an HTTP request with all necessary properties for making
+ * REST API calls. Compatible with both browser fetch and Node.js http modules.
+ */
+interface HTTPRequest {
+  /** HTTP method to use for the request */
+  method: HTTPMethod;
+  /** Target URL for the request */
+  url: string | URL;
+  /** Optional HTTP headers */
+  headers?: HTTPHeaders;
+  /** Optional request body (supports various types for flexibility) */
+  body?: string | Blob | ArrayBuffer | FormData | URLSearchParams | ReadableStream | null;
+  /** Optional AbortSignal for request cancellation */
+  signal?: AbortSignal;
+  /** Optional timeout in milliseconds */
+  timeout?: number;
+}
+type HttpBody = string | Blob | ArrayBuffer | ReadableStream | null;
+/**
+ * Represents an HTTP response with status, headers, and body.
+ * Compatible with both browser Response and Node.js http.IncomingMessage.
+ */
+interface HTTPResponse<T extends HttpBody = string> {
+  /** HTTP status code (e.g., 200, 404, 500) */
+  status: number;
+  /** HTTP status text (e.g., "OK", "Not Found") */
+  statusText: string;
+  /** Response headers */
+  headers: HTTPHeaders;
+  /** Response body (flexible type to support various response formats) */
+  body?: T;
+  /** Convenience property: true if status is 200-299 */
+  ok: boolean;
+  /** Final URL after any redirects */
+  url: string;
+}
+interface WebSocketClient {
+  addEventListener: WebSocket['addEventListener'];
+  removeEventListener: WebSocket['removeEventListener'];
+  send: WebSocket['send'];
+  close: WebSocket['close'];
+  readyState: WebSocket['readyState'];
+}
+interface NodeSocketClient extends WebSocketClient {
+  addEventListener(method: 'open' | 'close' | 'error' | 'message', cb: (event: unknown) => void, options?: unknown): void;
+  removeEventListener(method: 'open' | 'close' | 'error' | 'message', cb: (event: unknown) => void): void;
+  send(data: unknown, cb?: (err?: Error) => void): void;
+}
+/**
+ * There's a difference in `searchParams` between URL from
+ * `lib` and URL from `url` (node) that makes using the same
+ * not possible for us.
+ */
+interface NodeSocketAdapter {
+  new (address: string | URL$1, options?: unknown): NodeSocketClient;
+  new (address: string | URL$1, protocols?: string | string[], options?: unknown): NodeSocketClient;
+}
+/** Browser-compatible WebSocket constructor type. */
+type WebSocketAdapter = new (url: string | URL, protocols?: string | string[]) => WebSocketClient;
+/** Authentication credentials for the SDK. */
+interface SDKCredential {
+  /** JWT subscriber access token. */
+  token?: string;
+  /** Pre-authorized session state (alternative to token). */
+  authorizationState?: string;
+  /** Token expiry timestamp in milliseconds since epoch. */
+  expiry_at?: number;
+}
+/** Types of addressable resources in the fabric. */
+type ResourceType = 'app' | 'call' | 'room' | 'subscriber';
+//#endregion
+//#region src/dependencies/interfaces.d.ts
+type StorageScope = 'local' | 'session';
+interface Storage {
+  setItem(key: string, value: string | null, scope: StorageScope): Promise<void>;
+  getItem(key: string, scope: StorageScope): Promise<string | null>;
+  removeItem(key: string, scope: StorageScope): Promise<void>;
+}
+/**
+ * Provides authentication credentials to the SDK.
+ *
+ * Implementors are responsible for:
+ * - Obtaining credentials (e.g. via API calls, user login flows, or third-party auth services).
+ * - Returning a valid {@link SDKCredential} with either a `token` or `authorizationState`.
+ * - Setting `expiry_at` when the credential has a known expiration so the SDK can schedule refresh.
+ * - Handling errors and never leaking sensitive data through error messages.
+ *
+ * The SDK owns the credential lifecycle: it calls `authenticate` once during initialization
+ * and, if `refresh` is provided and `expiry_at` is set, schedules automatic refresh before expiry.
+ */
+interface CredentialProvider {
+  /**
+   * Obtains the initial credentials. Called once during client initialization.
+   *
+   * Implementor responsibilities:
+   * - Resolve with a valid {@link SDKCredential} on success.
+   * - Reject (throw) on failure — this will cause client initialization to fail.
+   *
+   * SDK behavior:
+   * - Awaits this method before establishing the WebSocket connection.
+   * - On rejection, propagates the error to the caller of `SignalWire()`.
+   */
+  authenticate(): Promise<SDKCredential>;
+  /**
+   * Obtains fresh credentials before the current ones expire. Optional.
+   *
+   * Implementor responsibilities:
+   * - Resolve with a new {@link SDKCredential} containing an updated `token` (or `authorizationState`) and `expiry_at`.
+   * - Reject (throw) if refresh is not possible — the SDK will stop the refresh schedule.
+   *
+   * SDK behavior:
+   * - Only called when `expiry_at` was set on the previous credential.
+   * - Scheduled automatically before expiry; implementors do not need to manage timing.
+   * - On rejection, the refresh schedule stops and the session continues with the
+   *   current credentials until they expire.
+   * - When not provided, the SDK uses the initial credentials for the entire session lifetime.
+   */
+  refresh?: () => Promise<SDKCredential>;
+}
+//#endregion
+//#region src/managers/StorageManager.d.ts
+declare class StorageManager {
+  private storageImpl;
+  constructor(storageImpl?: Storage);
+  /**
+   * Validates that a value can be safely serialized to JSON
+   * @throws SerializationError if value contains non-serializable types
+   */
+  private serialize;
+  /**
+   * Stores a value in storage
+   * @throws InvalidStorageValueError if value contains non-serializable types
+   * @throws SerializationError if JSON serialization fails
+   * @throws StorageWriteError if writing to storage fails
+   */
+  setItem(key: string, value: unknown, scope?: StorageScope): Promise<void>;
+  /**
+   * Retrieves a value from storage
+   *
+   * This method distinguishes between:
+   * - Storage errors (network, permission, etc.) - these are thrown
+   * - JSON parse errors - these trigger onParseError and return raw string
+   * - Missing keys - returns null
+   *
+   * @returns The parsed value, raw string (on parse error), or null
+   * @throws StorageReadError
+   */
+  getItem<T = unknown>(key: string, scope?: StorageScope): Promise<T | null>;
+  /**
+   * Removes a value from storage
+   * @throws Error from underlying storage implementation
+   */
+  removeItem(key: string, scope?: StorageScope): Promise<void>;
+}
+//#endregion
+//#region src/containers/PreferencesContainer.d.ts
+/**
+ * Public preferences API for configuring SDK behavior.
+ *
+ * Exposed as {@link SignalWire.preferences}. All timeout values
+ * are in seconds when accessed through this class.
+ *
+ * When {@link enableSavePreferences} is called, preferences are
+ * automatically loaded from storage and synced back on every change.
+ */
+declare class ClientPreferences {
+  private _storage;
+  /**
+   * Enables persistence of preferences to storage.
+   * Loads any previously saved preferences and syncs future changes.
+   */
+  enableSavePreferences(storage: StorageManager): void;
+  /** WebSocket connection timeout in seconds. */
+  get connectionTimeout(): number;
+  set connectionTimeout(seconds: number);
+  /** Timeout for reconnecting to previously attached calls, in seconds. */
+  get reconnectCallsTimeout(): number;
+  set reconnectCallsTimeout(seconds: number);
+  /** Minimum reconnection backoff delay in seconds. */
+  get reconnectDelayMin(): number;
+  set reconnectDelayMin(seconds: number);
+  /** Maximum reconnection backoff delay in seconds. */
+  get reconnectDelayMax(): number;
+  set reconnectDelayMax(seconds: number);
+  /** Custom relay host URL. Empty string uses the default. */
+  get relayHost(): string;
+  set relayHost(value: string);
+  /** Whether to receive remote video by default. */
+  get receiveVideo(): boolean;
+  set receiveVideo(value: boolean);
+  /** Whether to receive remote audio by default. */
+  get receiveAudio(): boolean;
+  set receiveAudio(value: boolean);
+  /** Preferred audio input device for new calls. */
+  get preferredAudioInput(): MediaDeviceInfo | null;
+  set preferredAudioInput(value: MediaDeviceInfo | null);
+  /** Preferred audio output device for new calls. */
+  get preferredAudioOutput(): MediaDeviceInfo | null;
+  set preferredAudioOutput(value: MediaDeviceInfo | null);
+  /** Preferred video input device for new calls. */
+  get preferredVideoInput(): MediaDeviceInfo | null;
+  set preferredVideoInput(value: MediaDeviceInfo | null);
+  /** Default audio input track constraints. */
+  get inputAudioConstraints(): MediaTrackConstraints | undefined;
+  set inputAudioConstraints(value: MediaTrackConstraints | undefined);
+  /** Default video input track constraints. */
+  get inputVideoConstraints(): MediaTrackConstraints | undefined;
+  set inputVideoConstraints(value: MediaTrackConstraints | undefined);
+  /** Debounce time for device change events, in seconds. */
+  get deviceDebounceTime(): number;
+  set deviceDebounceTime(seconds: number);
+  /** Polling interval for device enumeration, in seconds. */
+  get devicePollingInterval(): number;
+  set devicePollingInterval(seconds: number);
+  /** Whether to filter out UDP-based ICE servers. */
+  get disableUdpIceServers(): boolean;
+  set disableUdpIceServers(value: boolean);
+  /** Whether to force TURN relay-only ICE candidates. */
+  get relayOnly(): boolean;
+  set relayOnly(value: boolean);
+  /** Timeout for individual ICE candidate gathering, in seconds. */
+  get iceCandidateTimeout(): number;
+  set iceCandidateTimeout(seconds: number);
+  /** Timeout for the entire ICE gathering phase, in seconds. */
+  get iceGatheringTimeout(): number;
+  set iceGatheringTimeout(seconds: number);
+  /** Custom ICE servers for TURN/STUN configuration. */
+  get iceServers(): RTCIceServer[] | undefined;
+  set iceServers(value: RTCIceServer[] | undefined);
+  /** Custom user variables attached to calls. */
+  get userVariables(): Record<string, unknown>;
+  set userVariables(value: Record<string, unknown>);
+  /** Saves current preferences to storage (fire-and-forget). */
+  private _saveToStorage;
+  /** Loads preferences from storage and applies them to the container. */
+  private _loadFromStorage;
+}
+//#endregion
+//#region src/controllers/HTTPRequestController.d.ts
+type HTTPRequestStatus = 'idle' | 'requesting' | 'success' | 'error';
+interface HTTPRequestControllerOptions {
+  maxRetries?: number;
+  retryDelayMin?: number;
+  retryDelayMax?: number;
+  requestTimeout?: number;
+}
+declare class HTTPRequestController {
+  private baseURL;
+  private credential;
+  private static readonly defaultMaxRetries;
+  private static readonly defaultRetryDelayMinMs;
+  private static readonly defaultRetryDelayMaxMs;
+  private static readonly defaultRequestTimeoutMs;
+  private readonly maxRetries;
+  private readonly retryDelayMin;
+  private readonly retryDelayMax;
+  private readonly requestTimeout;
+  private _responses$;
+  private _errors$;
+  private _status$;
+  constructor(baseURL: string, credential: SDKCredential, options?: HTTPRequestControllerOptions);
+  get status$(): Observable<HTTPRequestStatus>;
+  get status(): HTTPRequestStatus;
+  get responses$(): Observable<HTTPResponse>;
+  get errors$(): Observable<Error>;
+  request(request: HTTPRequest): Promise<HTTPResponse>;
+  private executeWithRetry;
+  private executeRequest;
+  private buildURL;
+  private buildHeaders;
+  private convertResponse;
+}
+//#endregion
+//#region src/behaviors/Fetchable.d.ts
+declare abstract class Fetchable<T = unknown> extends Destroyable {
+  fromPath: string;
+  protected http: HTTPRequestController;
+  fetched$: Observable<boolean>;
+  constructor(fromPath: string, http: HTTPRequestController);
+  protected abstract populateInstance(data: T): void;
+  private fetch;
+}
+//#endregion
+//#region src/core/types/address.types.d.ts
+/**
+ * Pure address-related types (no implementation dependencies)
+ * Types that reference model implementations are in interfaces.ts
+ */
+interface GetAddressResponse {
+  id: string;
+  display_name: string;
+  name: string;
+  preview_url?: string;
+  cover_url?: string;
+  resource_id: string;
+  type: ResourceType;
+  channels: {
+    audio?: string;
+    messaging?: string;
+    video?: string;
+  };
+  locked: boolean;
+  created_at: string;
+}
+//#endregion
+//#region src/core/types/subscriber.types.d.ts
+interface GetSubscriberInfoResponse {
+  id: string;
+  email: string;
+  first_name?: string;
+  last_name?: string;
+  display_name?: string;
+  job_title?: string;
+  time_zone?: number;
+  country?: string;
+  region?: string;
+  company_name?: string;
+  push_notification_key: string;
+  app_settings?: {
+    display_name: string;
+    scopes: string[];
+  };
+  fabric_addresses: GetAddressResponse[];
+}
+//#endregion
+//#region src/core/entities/Subscriber.d.ts
+/**
+ * Authenticated subscriber profile.
+ *
+ * Fetched automatically when a {@link SignalWire} connects.
+ * Contains identity, contact, and organization details.
+ */
+declare class Subscriber extends Fetchable<GetSubscriberInfoResponse> {
+  /** Unique subscriber identifier. */
+  id: string;
+  /** Subscriber email address. */
+  email: string;
+  /** First name. */
+  firstName?: string;
+  /** Last name. */
+  lastName?: string;
+  /** Display name shown to other participants. */
+  displayName?: string;
+  /** Job title. */
+  jobTitle?: string;
+  /** Time zone offset. */
+  timeZone?: number;
+  /** Country code. */
+  country?: string;
+  /** Region/state. */
+  region?: string;
+  /** Company name. */
+  companyName?: string;
+  /** Push notification key for mobile/web push. */
+  pushNotificationKey: string;
+  /** Application-level settings (display name, permission scopes). */
+  appSettings?: {
+    displayName: string;
+    scopes: string[];
+  };
+  /** Fabric addresses associated with this subscriber. */
+  addresses: GetAddressResponse[];
+  constructor(http: HTTPRequestController);
+  protected populateInstance(data: GetSubscriberInfoResponse): void;
+}
+//#endregion
+//#region src/core/types/call.types.d.ts
+type RTCPeerConnectionType = 'offer' | 'answer';
+type RTCPeerConnectionPropose = 'main' | 'screenshare' | 'additional-device';
+type CallConnectStates = 'connecting' | 'connected';
+type SignalingCallStates = 'created' | 'ringing' | 'answered' | 'ending' | 'ended';
+type CallDirection = 'inbound' | 'outbound';
+type CallPlayState = 'playing' | 'paused' | 'finished';
+interface CallDeviceCommonParams {
+  headers?: unknown[];
+}
+interface CallDeviceWebRTCOrSIPParams extends CallDeviceCommonParams {
+  from: string;
+  to: string;
+}
+interface CallDevicePhoneParams extends CallDeviceCommonParams {
+  from_number: string;
+  to_number: string;
+}
+interface CallDeviceWebRTCOrSIP {
+  type: 'webrtc' | 'sip';
+  params: CallDeviceWebRTCOrSIPParams;
+}
+interface CallDevicePhone {
+  type: 'phone';
+  params: CallDevicePhoneParams;
+}
+type CallDevice = CallDeviceWebRTCOrSIP | CallDevicePhone;
+type VideoPosition = 'auto' | `reserved-${number}` | `standard-${number}` | 'off-canvas' | 'playback' | 'full-screen';
+//#endregion
+//#region src/core/RPCMessages/types/common.d.ts
+interface Member {
+  room_session_id: string;
+  room_id: string;
+  member_id: string;
+  call_id: string;
+  name: string;
+  type: 'member' | 'screen';
+  parent_id?: string;
+  requested_position?: string;
+  handraised: boolean;
+  visible: boolean;
+  audio_muted: boolean;
+  video_muted: boolean;
+  deaf: boolean;
+  input_volume: number;
+  output_volume: number;
+  input_sensitivity: number;
+  echo_cancellation: boolean;
+  auto_gain: boolean;
+  noise_suppression: boolean;
+  lowbitrate: boolean;
+  denoise: boolean;
+  talking: boolean;
+  isAudience: boolean;
+  meta: Record<string, unknown>;
+  subscriber_id: string;
+  address_id: string;
+  updated?: string[];
+  node_id: string;
+}
+interface MemberTalkingInfo {
+  member_id: string;
+  talking: boolean;
+  node_id: string;
+}
+interface RoomSession {
+  room_session_id: string;
+  room_id: string;
+  event_channel: string;
+  name: string;
+  layout_name: string;
+  display_name: string;
+  recording: boolean;
+  streaming: boolean;
+  prioritize_handraise: boolean;
+  hide_video_muted: boolean;
+  locked: boolean;
+  meta: Record<string, unknown>;
+  members: Member[];
+  recordings: Record<string, unknown>[];
+  streams: Record<string, unknown>[];
+  playbacks: Record<string, unknown>[];
+}
+interface LayoutLayer {
+  layer_index: number;
+  z_index: number;
+  member_id?: string;
+  playing_file: boolean;
+  position: VideoPosition;
+  reservation: string;
+  visible: boolean;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+interface Layout {
+  layers: LayoutLayer[];
+  id: string;
+  name: string;
+}
+interface ConversationDetails {
+  status: string;
+  start_time: number;
+  end_time?: number;
+}
+interface PartialDialogParams {
+  callID: string;
+}
+interface AudioMediaParams {
+  autoGainControl: boolean;
+  echoCancellation: boolean;
+  noiseSuppression: boolean;
+}
+interface FrameRateConstraint {
+  min: number;
+  ideal: number;
+  max: number;
+}
+interface AspectRatioConstraint {
+  exact: number;
+}
+interface DimensionConstraint {
+  min: number;
+  ideal: number;
+}
+interface VideoAdvancedConstraint {
+  width: DimensionConstraint;
+  height: DimensionConstraint;
+  frameRate: FrameRateConstraint;
+}
+interface VideoMediaParams {
+  frameRate: FrameRateConstraint;
+  aspectRatio: AspectRatioConstraint;
+  width: DimensionConstraint;
+  height: DimensionConstraint;
+  advanced: VideoAdvancedConstraint[];
+  resizeMode: string;
+}
+interface MediaParams {
+  audio?: AudioMediaParams;
+  video?: VideoMediaParams;
+}
+//#endregion
+//#region src/core/RPCMessages/types/verto.d.ts
+interface VertoAnswerParams {
+  callID: string;
+  sdp: string;
+}
+interface VertoMediaParamsParams {
+  callID: string;
+  mediaParams: MediaParams;
+}
+interface VertoPingParams {
+  callID: string;
+  dialogParams: PartialDialogParams;
+}
+//#endregion
+//#region src/core/RPCMessages/types/events.d.ts
+interface SignalwireAuthorizationStatePayload {
+  authorization_state: string;
+}
+interface WebrtcMessagePayload {
+  jsonrpc: '2.0';
+  id: number;
+  method: string;
+  params: VertoAnswerParams | VertoMediaParamsParams | VertoPingParams;
+}
+interface CallJoinedPayload {
+  room_session: RoomSession;
+  room_id: string;
+  room_session_id: string;
+  call_id: string;
+  member_id: string;
+  capabilities: string[];
+  origin_call_id: string;
+}
+interface CallLeftPayload {
+  room_session: RoomSession;
+  room_id: string;
+  room_session_id: string;
+  call_id: string;
+  member_id: string;
+  origin_call_id: string;
+  reason: string;
+}
+interface MemberUpdatedPayload {
+  member: Member;
+  room_id: string;
+  room_session_id: string;
+}
+interface MemberJoinedPayload {
+  member: Member;
+  room_id: string;
+  room_session_id: string;
+}
+interface MemberLeftPayload {
+  member: Member;
+  room_id: string;
+  room_session_id: string;
+  reason: string;
+}
+interface MemberTalkingPayload {
+  member: MemberTalkingInfo;
+  room_id: string;
+  room_session_id: string;
+}
+interface LayoutChangedPayload {
+  room_id: string;
+  room_session_id: string;
+  layout: Layout;
+}
+interface CallUpdatedPayload {
+  room_session: RoomSession;
+  room_id: string;
+  room_session_id: string;
+}
+interface CallStatePayload {
+  call_id: string;
+  node_id: string;
+  segment_id: string;
+  call_state: SignalingCallStates;
+  direction: CallDirection;
+  device: CallDevice;
+  start_time: number;
+  answer_time: number;
+  end_time: number;
+  room_session_id: string;
+}
+interface CallPlayPayload {
+  control_id: string;
+  call_id: string;
+  node_id: string;
+  state: CallPlayState;
+  room_session_id: string;
+}
+interface CallConnectPayload {
+  connect_state: CallConnectStates;
+  call_id: string;
+  node_id: string;
+  segment_id: string;
+  room_session_id: string;
+  peer?: {
+    call_id: string;
+    node_id: string;
+    device: CallDevice;
+  };
+}
+interface ConversationMessagePayload {
+  id: string;
+  type: string;
+  subtype: string;
+  kind: string;
+  hidden: boolean;
+  group_id: string;
+  from_fabric_address_id: string;
+  ts: number;
+  metadata: Record<string, unknown>;
+  details: ConversationDetails;
+  text: string | null;
+  conversation_name: string;
+  user_name: string;
+}
+type ConversationMessageUpdatedPayload = ConversationMessagePayload;
+//#endregion
+//#region src/behaviors/types/collection.types.d.ts
+interface Entity {
+  id: string;
+}
+type FetchController<T extends Entity = Entity> = { [key in keyof Partial<T>]: (v?: unknown) => Promise<T | undefined> } & {
+  next: () => Promise<T[]>;
+  hasMore: boolean | undefined;
+  filter?: (item: T) => item is T;
+  mapper?: (item: unknown) => T;
+};
+interface Collection<T extends Entity = Entity> {
+  loading$: Observable<boolean>;
+  loading: boolean;
+  hasMore$: Observable<boolean>;
+  hasMore: boolean;
+  values: T[];
+  values$: Observable<T[]>;
+  get$(id: string): Observable<T> | undefined;
+  find$(key: keyof T, value: unknown): Promise<Observable<T> | undefined>;
+  loadMore(): void;
+  destroy(): void;
+}
+//#endregion
+//#region src/behaviors/Collection.d.ts
+declare class EntityCollection<T extends Entity = Entity> extends Destroyable implements Collection<T> {
+  private fetchController;
+  private update$;
+  private readonly onError?;
+  loading$: rxjs0.BehaviorSubject<boolean>;
+  values$: ReplaySubject<T[]>;
+  hasMore$: Observable<boolean>;
+  private collectionData;
+  private observablesRegistry;
+  private updateSubscription;
+  private upsertData;
+  private _destroy$;
+  constructor(fetchController: FetchController<T>, update$: Observable<Partial<T>>, onError?: ((error: Error) => void) | undefined);
+  get loading(): boolean;
+  get hasMore(): boolean;
+  get updated$(): Observable<void>;
+  get values(): T[];
+  private init;
+  private fetchMore;
+  private tryFetch;
+  get$(id: string): Observable<T> | undefined;
+  find$(key: keyof T, value: unknown): Promise<Observable<T> | undefined>;
+  loadMore(): void;
+  destroy(): void;
+}
+declare class EntityCollectionTransformed<O extends Entity = Entity, T extends Entity = Entity> implements Collection<T> {
+  private originalCollection;
+  private filter;
+  private mapper;
+  constructor(originalCollection: EntityCollection<O>, filter?: (i: unknown) => i is O, mapper?: (item: O) => T);
+  get loading$(): Observable<boolean>;
+  get loading(): boolean;
+  get hasMore$(): Observable<boolean>;
+  get hasMore(): boolean;
+  get values(): T[];
+  get values$(): Observable<T[]>;
+  get$(id: string): Observable<T> | undefined;
+  find$(key: keyof T, value: unknown): Promise<Observable<T> | undefined>;
+  loadMore(): void;
+  destroy(): void;
+}
+//#endregion
+//#region src/managers/types/verto-manager.types.d.ts
+type ScreenShareStatus = 'none' | 'starting' | 'started' | 'stopping';
+type SignalingStatus = 'trying' | 'ringing' | 'connecting' | 'connected' | 'disconnected' | 'failed';
+interface TransferOptions {
+  destination: string;
+}
+//#endregion
+//#region src/core/RPCMessages/RPCConnect.d.ts
+interface Authorization {
+  jti: string;
+  project_id: string;
+  fabric_subscriber: {
+    version: number;
+    expires_at: number;
+    subscriber_id: string;
+    application_id: string;
+    project_id: string;
+    space_id: string;
+  };
+}
+//#endregion
+//#region src/core/utils.d.ts
+interface PendingRPCOptions {
+  /**
+   * Timeout in milliseconds. Defaults to 5000ms (5 seconds).
+   * If the response is not received within this time, the promise will reject with RPCTimeoutError.
+   */
+  timeoutMs?: number;
+  /**
+   * Optional AbortSignal for cancellation support.
+   * If the signal is aborted, the promise will reject with an AbortError.
+   */
+  signal?: AbortSignal;
+}
+//#endregion
+//#region src/core/capabilities/types.d.ts
+/**
+ * Represents an on/off capability state
+ * Both `on` and `off` can be true if the parent permission grants both
+ */
+interface OnOffCapability {
+  readonly on: boolean;
+  readonly off: boolean;
+}
+/**
+ * Member-level capabilities for self or other members
+ */
+interface MemberCapabilities {
+  readonly muteAudio: OnOffCapability;
+  readonly muteVideo: OnOffCapability;
+  readonly deaf: OnOffCapability;
+  readonly raisehand: OnOffCapability;
+  readonly microphoneVolume: boolean;
+  readonly microphoneSensitivity: boolean;
+  readonly speakerVolume: boolean;
+  readonly position: boolean;
+  readonly meta: boolean;
+  readonly remove: boolean;
+  readonly audioFlags: boolean;
+}
+/**
+ * Call-level capabilities state
+ */
+interface CallCapabilitiesState {
+  readonly self: MemberCapabilities;
+  readonly member: MemberCapabilities;
+  readonly end: boolean;
+  readonly setLayout: boolean;
+  readonly sendDigit: boolean;
+  readonly vmutedHide: OnOffCapability;
+  readonly lock: OnOffCapability;
+  readonly device: boolean;
+  readonly screenshare: boolean;
+}
+//#endregion
+//#region src/core/capabilities/SelfCapabilities.d.ts
+/**
+ * SelfCapabilities manages the capability state for the self participant.
+ *
+ * Capabilities are received from the server via `call.joined` events and determine
+ * what actions the current participant is allowed to perform.
+ *
+ * Each capability is exposed as both:
+ * - An observable (e.g., `end$`) for reactive state management
+ * - A synchronous getter (e.g., `end`) for immediate access
+ *
+ * Member-level capabilities are accessed via the grouped `self` / `member` accessors:
+ * - `capabilities.self.muteAudio` (sync)
+ * - `capabilities.self$` (observable)
+ *
+ * When a new `call.joined` event is received, the capabilities state is
+ * completely replaced (not merged).
+ */
+declare class SelfCapabilities extends Destroyable {
+  private _state$;
+  /**
+   * Updates the capabilities state from raw capability strings.
+   * This completely replaces the current state.
+   *
+   * @param capabilities - Raw capability strings from the server
+   * @internal
+   */
+  updateFromRaw(capabilities: string[]): void;
+  /** Observable for self member capabilities */
+  get self$(): Observable<MemberCapabilities>;
+  /** Current self member capabilities */
+  get self(): MemberCapabilities;
+  /** Observable for other member capabilities */
+  get member$(): Observable<MemberCapabilities>;
+  /** Current other member capabilities */
+  get member(): MemberCapabilities;
+  /** Observable for end call capability */
+  get end$(): Observable<boolean>;
+  /** Current end call capability */
+  get end(): boolean;
+  /** Observable for set layout capability */
+  get setLayout$(): Observable<boolean>;
+  /** Current set layout capability */
+  get setLayout(): boolean;
+  /** Observable for send digit capability */
+  get sendDigit$(): Observable<boolean>;
+  /** Current send digit capability */
+  get sendDigit(): boolean;
+  /** Observable for vmuted hide capability */
+  get vmutedHide$(): Observable<OnOffCapability>;
+  /** Current vmuted hide capability */
+  get vmutedHide(): OnOffCapability;
+  /** Observable for lock capability */
+  get lock$(): Observable<OnOffCapability>;
+  /** Current lock capability */
+  get lock(): OnOffCapability;
+  /** Observable for device capability */
+  get device$(): Observable<boolean>;
+  /** Current device capability */
+  get device(): boolean;
+  /** Observable for screenshare capability */
+  get screenshare$(): Observable<boolean>;
+  /** Current screenshare capability */
+  get screenshare(): boolean;
+  /** Observable for the full capabilities state */
+  get state$(): Observable<CallCapabilitiesState>;
+  /** Current full capabilities state */
+  get state(): CallCapabilitiesState;
+}
+//#endregion
+//#region src/core/entities/types/participant.types.d.ts
+interface SelectDeviceOptions {
+  savePreference?: boolean;
+}
+//#endregion
+//#region src/interfaces/DeviceController.d.ts
+/**
+ * Device interface for media device management
+ * Provides access to media devices and device selection
+ */
+interface DeviceController {
+  readonly audioInputDevices$: Observable<MediaDeviceInfo[]>;
+  readonly audioOutputDevices$: Observable<MediaDeviceInfo[]>;
+  readonly videoInputDevices$: Observable<MediaDeviceInfo[]>;
+  readonly selectedAudioInputDevice$: Observable<MediaDeviceInfo | null>;
+  readonly selectedAudioOutputDevice$: Observable<MediaDeviceInfo | null>;
+  readonly selectedVideoInputDevice$: Observable<MediaDeviceInfo | null>;
+  readonly selectedAudioInputDevice: MediaDeviceInfo | null;
+  readonly selectedAudioOutputDevice: MediaDeviceInfo | null;
+  readonly selectedVideoInputDevice: MediaDeviceInfo | null;
+  readonly audioInputDevices: MediaDeviceInfo[];
+  readonly audioOutputDevices: MediaDeviceInfo[];
+  readonly videoInputDevices: MediaDeviceInfo[];
+  readonly selectedAudioInputDeviceConstraints: MediaTrackConstraints;
+  readonly selectedVideoInputDeviceConstraints: MediaTrackConstraints;
+  deviceInfoToConstraints(deviceInfo: MediaDeviceInfo | null): MediaTrackConstraints;
+  selectAudioInputDevice(device: MediaDeviceInfo | null): void;
+  selectVideoInputDevice(device: MediaDeviceInfo | null): void;
+  selectAudioOutputDevice(device: MediaDeviceInfo | null): void;
+  enableDeviceMonitoring(): void;
+  disableDeviceMonitoring(): void;
+  getDeviceCapabilities(deviceInfo: MediaDeviceInfo): Promise<MediaTrackCapabilities | null>;
+  isValidDevice(deviceInfo: MediaDeviceInfo | null): Promise<boolean>;
+  readonly errors$: Observable<Error>;
+}
+//#endregion
+//#region src/interfaces/VertoManager.d.ts
+/**
+ * VertoManager interface for WebRTC call management
+ * Provides methods for screen sharing, device management, and media constraints
+ */
+interface VertoManager {
+  readonly screenShareStatus$: Observable<ScreenShareStatus>;
+  readonly screenShareStatus: ScreenShareStatus;
+  addScreenMedia(): Promise<void>;
+  removeScreenMedia(): Promise<void>;
+  addInputDevice(options?: MediaOptions): Promise<string | undefined>;
+  removeInputDevices(id: string): Promise<void>;
+  addMainInputDevices(options?: MediaOptions): Promise<void>;
+  updateMediaConstraints(options?: {
+    audio?: MediaTrackConstraints;
+    video?: MediaTrackConstraints;
+  }): Promise<void>;
+  muteMainAudioInputDevice(): void;
+  unmuteMainAudioInputDevice(): Promise<void>;
+  muteMainVideoInputDevice(): void;
+  unmuteMainVideoInputDevice(): Promise<void>;
+}
+//#endregion
+//#region src/core/entities/Participant.d.ts
+/**
+ * Callback type for executing call methods
+ * Injected to avoid circular dependency with Call class
+ */
+type ExecuteMethod = <T extends JSONRPCResponse = JSONRPCResponse>(target: string, method: string, args: Record<string, unknown>) => Promise<T>;
+type ParticipantState = Member & {
+  position: LayoutLayer;
+};
+/**
+ * Represents a participant in a call.
+ *
+ * Provides observable state (audio/video mute, hand raise, volume, etc.)
+ * and control methods for the participant. See {@link SelfParticipant} for
+ * the local participant with additional device control.
+ */
+declare class Participant extends Destroyable implements CallParticipant {
+  protected executeMethod: ExecuteMethod;
+  protected deviceController: DeviceController;
+  /** Unique member ID of this participant. */
+  readonly id: string;
+  private _state$;
+  constructor(id: string, executeMethod: ExecuteMethod, deviceController: DeviceController);
+  /** @internal */
+  upnext(data: Partial<ParticipantState>): void;
+  /** Observable of the participant's display name. */
+  get name$(): Observable<string>;
+  /** Observable of the participant type (e.g. `'member'`, `'screen'`). */
+  get type$(): Observable<string>;
+  /** Observable indicating whether the participant has raised their hand. */
+  get handraised$(): Observable<boolean>;
+  /** Observable indicating whether the participant is visible in the layout. */
+  get visible$(): Observable<boolean>;
+  /** Observable indicating whether the participant's audio is muted. */
+  get audioMuted$(): Observable<boolean>;
+  /** Observable indicating whether the participant's video is muted. */
+  get videoMuted$(): Observable<boolean>;
+  /** Observable indicating whether the participant is deafened. */
+  get deaf$(): Observable<boolean>;
+  /** Observable of the participant's microphone input volume. */
+  get inputVolume$(): Observable<number>;
+  /** Observable of the participant's speaker output volume. */
+  get outputVolume$(): Observable<number>;
+  /** Observable of the microphone input sensitivity level. */
+  get inputSensitivity$(): Observable<number>;
+  /** Observable indicating whether echo cancellation is enabled. */
+  get echoCancellation$(): Observable<boolean>;
+  /** Observable indicating whether auto-gain control is enabled. */
+  get autoGain$(): Observable<boolean>;
+  /** Observable indicating whether noise suppression is enabled. */
+  get noiseSuppression$(): Observable<boolean>;
+  /** Observable indicating whether low-bitrate mode is active. */
+  get lowbitrate$(): Observable<boolean>;
+  /** Observable indicating whether noise reduction is active. */
+  get denoise$(): Observable<boolean>;
+  /** Observable of custom metadata for this participant. */
+  get meta$(): Observable<Record<string, unknown>>;
+  /** Observable of the participant's subscriber ID. */
+  get subscriberId$(): Observable<string>;
+  /** Observable of the participant's address ID. */
+  get addressId$(): Observable<string>;
+  /** Observable of the server node ID for this participant. */
+  get nodeId$(): Observable<string>;
+  /** Observable indicating whether the participant is currently speaking. */
+  get isTalking$(): Observable<boolean>;
+  /** Whether the participant is currently speaking. */
+  get isTalking(): boolean;
+  /** Observable of the participant's layout position. */
+  get position$(): Observable<LayoutLayer | undefined>;
+  /** Current layout position. */
+  get position(): LayoutLayer | undefined;
+  /** Whether the participant is an audience member (view-only). */
+  get isAudience(): boolean;
+  /** Display name of this participant. */
+  get name(): string | undefined;
+  /** Participant type (e.g. `'member'`, `'screen'`). */
+  get type(): string | undefined;
+  get handraised(): boolean;
+  get visible(): boolean;
+  get audioMuted(): boolean;
+  get videoMuted(): boolean;
+  get deaf(): boolean;
+  get inputVolume(): number | undefined;
+  get outputVolume(): number | undefined;
+  get inputSensitivity(): number | undefined;
+  get echoCancellation(): boolean;
+  get autoGain(): boolean;
+  get noiseSuppression(): boolean;
+  get lowbitrate(): boolean;
+  get denoise(): boolean;
+  get meta(): Record<string, unknown> | undefined;
+  get subscriberId(): string | undefined;
+  get addressId(): string | undefined;
+  get nodeId(): string | undefined;
+  /** @internal */
+  get value(): Partial<Member>;
+  /** Toggles the deafened state (mutes/unmutes incoming audio). */
+  toggleDeaf(): Promise<void>;
+  /** Toggles the hand-raised state. */
+  toggleHandraise(): Promise<void>;
+  /** Mutes the participant's audio. */
+  mute(): Promise<void>;
+  /** Unmutes the participant's audio. */
+  unmute(): Promise<void>;
+  /** Toggles the participant's audio mute state. */
+  toggleMute(): Promise<void>;
+  /** Mutes the participant's video. */
+  muteVideo(): Promise<void>;
+  /** Unmutes the participant's video. */
+  unmuteVideo(): Promise<void>;
+  /** Toggles the participant's video mute state. */
+  toggleMuteVideo(): Promise<void>;
+  /** Toggles echo cancellation on the audio input. */
+  toggleEchoCancellation(): Promise<void>;
+  /** Toggles automatic gain control on the audio input. */
+  toggleAudioInputAutoGain(): Promise<void>;
+  /** Toggles noise suppression on the audio input. */
+  toggleNoiseSuppression(): Promise<void>;
+  toggleLowbitrate(): Promise<void>;
+  /** Sets the microphone input sensitivity level. */
+  setAudioInputSensitivity(value: number): Promise<void>;
+  /** Sets the microphone input volume level. */
+  setAudioInputVolume(value: number): Promise<void>;
+  /** Sets the speaker output volume level. */
+  setAudioOutputVolume(value: number): Promise<void>;
+  /** Sets the participant's position in the video layout. */
+  setPosition(value: VideoPosition): Promise<void>;
+  /** Removes this participant from the call. */
+  remove(): Promise<void>;
+  /** Ends the call for this participant. */
+  end(): Promise<void>;
+  setMeta(_meta: Record<string, unknown>): Promise<void>;
+  updateMeta(_meta: Record<string, unknown>): Promise<void>;
+  destroy(): void;
+}
+/**
+ * The local participant in a call, with additional device and media control.
+ *
+ * Extends {@link Participant} with screen sharing, device selection,
+ * and local media stream management.
+ */
+declare class SelfParticipant extends Participant implements CallSelfParticipant {
+  private vertoManager;
+  /**
+   * Capabilities for this participant.
+   * Contains all capability flags as both observables and values.
+   */
+  readonly capabilities: SelfCapabilities;
+  constructor(id: string, executeMethod: ExecuteMethod, vertoManager: VertoManager, deviceController: DeviceController);
+  destroy(): void;
+  /** Starts sharing the local screen. */
+  startScreenShare(): Promise<void>;
+  /** Observable of the current screen share status. */
+  get screenShareStatus$(): Observable<ScreenShareStatus>;
+  /** Current screen share status. */
+  get screenShareStatus(): ScreenShareStatus;
+  /** Stops the current screen share. */
+  stopScreenShare(): Promise<void>;
+  /** Adds an additional media input device to the call. */
+  addAdditionalDevice(options: MediaOptions): Promise<void>;
+  /** Removes an additional media input device by ID. */
+  removeAdditionalDevice(id: string): Promise<void>;
+  /** Adds or replaces the primary audio input device with optional constraints or stream. */
+  addAudioInputDevice({
+    constraints,
+    stream
+  }?: {
+    constraints?: MediaTrackConstraints;
+    stream?: MediaStream;
+  }): Promise<void>;
+  /** Adds or replaces the primary video input device with optional constraints or stream. */
+  addVideoInputDevice({
+    constraints,
+    stream
+  }?: {
+    constraints?: MediaTrackConstraints;
+    stream?: MediaStream;
+  }): Promise<void>;
+  /** Adds or replaces primary input devices (audio and/or video). */
+  addInputDevices(options?: MediaOptions): Promise<void>;
+  /** Selects the audio input device for future calls. Optionally saves as a preference. */
+  selectAudioInputDevice(device: MediaDeviceInfo, options?: SelectDeviceOptions): void;
+  /** Updates the audio input track constraints for the active call. */
+  setAudioInputDeviceConstraints(constraints: MediaTrackConstraints): Promise<void>;
+  /** Updates both audio and video input track constraints for the active call. */
+  setInputDevicesConstraints(constraints: {
+    audio: MediaTrackConstraints;
+    video: MediaTrackConstraints;
+  }): Promise<void>;
+  /** Selects the video input device for future calls. Optionally saves as a preference. */
+  selectVideoInputDevice(device: MediaDeviceInfo, options?: SelectDeviceOptions): void;
+  /** Updates the video input track constraints for the active call. */
+  setVideoInputDeviceConstraints(constraints: MediaTrackConstraints): Promise<void>;
+  /** Selects the audio output device. Optionally saves as a preference. */
+  selectAudioOutputDevice(device: MediaDeviceInfo, options?: SelectDeviceOptions): void;
+  mute(): Promise<void>;
+  unmute(): Promise<void>;
+  muteVideo(): Promise<void>;
+  unmuteVideo(): Promise<void>;
+}
+/** Type guard that checks if a participant is the local {@link SelfParticipant}. */
+declare const isSelfParticipant: (participant: Participant) => participant is SelfParticipant;
+//#endregion
+//#region src/core/entities/types/call.types.d.ts
+/**
+ * Base participant interface for call participants
+ * Defines the full public contract for participant objects exposed by Call
+ */
+interface CallParticipant {
+  readonly id: string;
+  readonly name$: Observable<string>;
+  readonly type$: Observable<string>;
+  readonly handraised$: Observable<boolean>;
+  readonly visible$: Observable<boolean>;
+  readonly audioMuted$: Observable<boolean>;
+  readonly videoMuted$: Observable<boolean>;
+  readonly deaf$: Observable<boolean>;
+  readonly inputVolume$: Observable<number>;
+  readonly outputVolume$: Observable<number>;
+  readonly inputSensitivity$: Observable<number>;
+  readonly echoCancellation$: Observable<boolean>;
+  readonly autoGain$: Observable<boolean>;
+  readonly noiseSuppression$: Observable<boolean>;
+  readonly lowbitrate$: Observable<boolean>;
+  readonly denoise$: Observable<boolean>;
+  readonly meta$: Observable<Record<string, unknown>>;
+  readonly subscriberId$: Observable<string>;
+  readonly addressId$: Observable<string>;
+  readonly nodeId$: Observable<string>;
+  readonly isTalking$: Observable<boolean>;
+  readonly position$: Observable<LayoutLayer | undefined>;
+  readonly name: string | undefined;
+  readonly type: string | undefined;
+  readonly handraised: boolean;
+  readonly visible: boolean;
+  readonly audioMuted: boolean;
+  readonly videoMuted: boolean;
+  readonly deaf: boolean;
+  readonly inputVolume: number | undefined;
+  readonly outputVolume: number | undefined;
+  readonly inputSensitivity: number | undefined;
+  readonly echoCancellation: boolean;
+  readonly autoGain: boolean;
+  readonly noiseSuppression: boolean;
+  readonly lowbitrate: boolean;
+  readonly denoise: boolean;
+  readonly meta: Record<string, unknown> | undefined;
+  readonly subscriberId: string | undefined;
+  readonly addressId: string | undefined;
+  readonly nodeId: string | undefined;
+  readonly isTalking: boolean;
+  readonly position: LayoutLayer | undefined;
+  readonly isAudience: boolean;
+  toggleDeaf(): Promise<void>;
+  toggleHandraise(): Promise<void>;
+  mute(): Promise<void>;
+  unmute(): Promise<void>;
+  toggleMute(): Promise<void>;
+  muteVideo(): Promise<void>;
+  unmuteVideo(): Promise<void>;
+  toggleMuteVideo(): Promise<void>;
+  toggleEchoCancellation(): Promise<void>;
+  toggleAudioInputAutoGain(): Promise<void>;
+  toggleNoiseSuppression(): Promise<void>;
+  toggleLowbitrate(): Promise<void>;
+  setAudioInputSensitivity(value: number): Promise<void>;
+  setAudioInputVolume(value: number): Promise<void>;
+  setAudioOutputVolume(value: number): Promise<void>;
+  setPosition(value: VideoPosition): Promise<void>;
+  remove(): Promise<void>;
+  end(): Promise<void>;
+  setMeta(meta: Record<string, unknown>): Promise<void>;
+  updateMeta(meta: Record<string, unknown>): Promise<void>;
+}
+/**
+ * Self participant interface with control methods
+ * Extends CallParticipant with methods for controlling the local participant
+ */
+interface CallSelfParticipant extends CallParticipant {
+  readonly screenShareStatus$: Observable<string>;
+  readonly screenShareStatus: string;
+  startScreenShare(): Promise<void>;
+  stopScreenShare(): Promise<void>;
+  selectAudioInputDevice(device: MediaDeviceInfo): void;
+  selectVideoInputDevice(device: MediaDeviceInfo): void;
+  selectAudioOutputDevice(device: MediaDeviceInfo): void;
+}
+/**
+ * Minimal interface for a collection with pagination
+ */
+interface CallTextMessageCollection {
+  readonly values$: Observable<unknown[]>;
+  readonly hasMore$: Observable<boolean>;
+  loadMore(): void;
+}
+/**
+ * Minimal address interface for call context
+ * Avoids circular dependency with full Address class
+ */
+interface CallAddress {
+  readonly id: string;
+  readonly displayName?: string;
+  readonly type?: string;
+  sendText(text: string): Promise<void>;
+  readonly textMessages$: Observable<CallTextMessageCollection | undefined>;
+}
+/** Lifecycle status of a call. */
+type CallStatus = 'new' | 'trying' | 'ringing' | 'connecting' | 'connected' | 'disconnecting' | 'disconnected' | 'failed' | 'destroyed';
+/** Configuration options for creating a call. */
+interface CallOptions extends MediaOptions {
+  /** Target server node ID. */
+  readonly nodeId?: string;
+  /** Pre-assigned call ID (used for reattach). */
+  readonly callId?: string;
+  /** Destination URI. */
+  readonly to?: string;
+  /** SDP offer for inbound calls. */
+  readonly initOffer?: string;
+  /** Whether this call is being reattached after reconnect. */
+  readonly reattach?: boolean;
+  /** Display name of the caller. */
+  readonly fromName?: string;
+  /** Address URI of the caller. */
+  readonly from?: string;
+  /** Display name of the callee. */
+  readonly toName?: string;
+  /** Direction hint for display purposes. */
+  readonly displayDirection?: string;
+  /** Custom user variables sent with the call invite. */
+  readonly userVariables?: Record<string, unknown>;
+}
+/** Observable state of a call (status, recording, participants, etc.). */
+interface CallState {
+  readonly id: string;
+  readonly status$: Observable<CallStatus>;
+  readonly status: CallStatus;
+  readonly recording$: Observable<boolean>;
+  readonly recording: boolean;
+  readonly streaming$: Observable<boolean>;
+  readonly streaming: boolean;
+  readonly raiseHandPriority$: Observable<boolean>;
+  readonly raiseHandPriority: boolean;
+  readonly locked$: Observable<boolean>;
+  readonly locked: boolean;
+  readonly meta$: Observable<Record<string, unknown>>;
+  readonly meta: Record<string, unknown>;
+  readonly participants$: Observable<CallParticipant[]>;
+  readonly participants: CallParticipant[];
+  setMeta(meta: Record<string, unknown>): Promise<void>;
+  updateMeta(meta: Record<string, unknown>): Promise<void>;
+}
+/**
+ * Public interface for an active WebRTC call.
+ *
+ * Provides access to media streams, participants, layout, signaling events,
+ * and control actions (hangup, mute, transfer, etc.).
+ */
+interface Call extends CallState {
+  readonly capabilities$: Observable<string[]>;
+  readonly capabilities: string[];
+  readonly mediaDirections$: Observable<MediaDirections>;
+  readonly mediaDirections: MediaDirections;
+  readonly self$: Observable<CallSelfParticipant | null>;
+  readonly self: CallSelfParticipant | null;
+  readonly to?: string;
+  readonly direction: 'inbound' | 'outbound';
+  readonly layouts$: Observable<string[]>;
+  readonly layouts: string[];
+  readonly layout$: Observable<string>;
+  readonly layout?: string;
+  readonly layoutLayers$: Observable<LayoutLayer[]>;
+  readonly layoutLayers: LayoutLayer[];
+  readonly localStream$: Observable<MediaStream | null>;
+  readonly localStream: MediaStream | null;
+  readonly remoteStream$: Observable<MediaStream | null>;
+  readonly remoteStream: MediaStream | null;
+  readonly rtcPeerConnection: RTCPeerConnection | undefined;
+  readonly errors$: Observable<Error>;
+  readonly signalingEvent$: Observable<Record<string, unknown>>;
+  readonly address?: CallAddress;
+  readonly address$: Observable<CallAddress | undefined>;
+  hangup(): Promise<void>;
+  toggleLock(): Promise<void>;
+  toggleHold(): Promise<void>;
+  setLayout(layout: string, positions: Record<string, VideoPosition>): Promise<void>;
+  startRecording(): Promise<void>;
+  startStreaming(): Promise<void>;
+  transfer(options: TransferOptions): Promise<void>;
+  toggleIncomingVideo(): Promise<void>;
+  toggleIncomingAudio(): Promise<void>;
+  answer(): void;
+  reject(): void;
+  sendDigits(digits: string): Promise<void>;
+  executeMethod<T extends JSONRPCResponse = JSONRPCResponse>(target: string, method: string, args: Record<string, unknown>): Promise<T>;
+}
+/**
+ * Extended Call interface with internal management capabilities
+ * Provides access to lower-level call operations, event streams, and session management
+ */
+interface CallManager extends Call {
+  readonly options: CallOptions;
+  readonly fromName?: string;
+  readonly from?: string;
+  readonly toName?: string;
+  readonly selfId$: Observable<string | null>;
+  readonly selfId: string | null;
+  readonly nodeId$: Observable<string | null>;
+  readonly nodeId: string | null;
+  readonly answered$: Observable<boolean>;
+  readonly callUpdated$: Observable<CallUpdatedPayload>;
+  readonly memberJoined$: Observable<MemberJoinedPayload>;
+  readonly memberLeft$: Observable<MemberLeftPayload>;
+  readonly memberUpdated$: Observable<MemberUpdatedPayload>;
+  readonly memberTalking$: Observable<MemberTalkingPayload>;
+  readonly callStates$: Observable<CallStatePayload>;
+  readonly layoutUpdates$: Observable<LayoutChangedPayload>;
+  readonly callEvent$: Observable<unknown>;
+  addCallId(callId: string): void;
+  /** @internal */
+  createParticipant(memberId: string, selfId?: string | null): Participant | SelfParticipant;
+  execute<T extends JSONRPCResponse = JSONRPCResponse>(request: JSONRPCRequest, options?: PendingRPCOptions): Promise<T>;
+  destroy(): void;
+}
+//#endregion
+//#region src/interfaces/AddressProvider.d.ts
+/**
+ * Provider interface for resolving addresses by ID
+ *
+ * This interface breaks the circular dependency between Address and Directory
+ * by providing a minimal contract that Address needs from the Directory.
+ *
+ * @typeParam TAddress - The Address type, defaults to never to enforce explicit typing
+ *
+ * @remarks
+ * Uses a generic type parameter to maintain type safety while avoiding
+ * circular dependencies. Implementations should provide the concrete Address type.
+ */
+interface AddressProvider<TAddress = never> {
+  /**
+   * Get an observable stream for a specific address by ID
+   *
+   * @param id - The address ID to retrieve
+   * @returns Observable of the address, or undefined if not found
+   */
+  get$(id: string): Observable<TAddress> | undefined;
+}
+//#endregion
+//#region src/core/types/conversation.types.d.ts
+/**
+ * Address history entry from conversation messages
+ * Contains a reference to the sender address as an observable
+ *
+ * @typeParam TAddress - The Address type, provided by the implementation
+ *
+ * @remarks
+ * Uses a generic type parameter to maintain type safety while avoiding
+ * circular dependencies. The Address class provides the concrete type.
+ */
+interface AddressHistory<TAddress = never> {
+  id: string;
+  kind: string;
+  status: string;
+  started: number;
+  ended?: number;
+  fromAddress$: Observable<TAddress> | undefined;
+}
+/**
+ * Text message from conversation
+ * Contains a reference to the sender address as an observable
+ *
+ * @typeParam TAddress - The Address type, provided by the implementation
+ *
+ * @remarks
+ * Uses a generic type parameter to maintain type safety while avoiding
+ * circular dependencies. The Address class provides the concrete type.
+ */
+interface TextMessage<TAddress = never> {
+  id: string;
+  fromAddress$: Observable<TAddress> | undefined;
+  created: number;
+  text: string;
+}
+/**
+ * Conversation message response from backend
+ */
+interface GetConversationMessageResponse {
+  id: string;
+  from_fabric_address_id: string;
+  group_id: string;
+  ts: number;
+  details: ConversationDetails;
+  type: string;
+  subtype: string;
+  kind?: string;
+  text?: string;
+}
+//#endregion
+//#region src/interfaces/Conversations.d.ts
+/**
+ * Interface for conversation message collection
+ *
+ * Type alias for EntityCollection specialized for conversation messages.
+ * Decouples Address from ConversationsManager's concrete ConversationMessageCollection class.
+ *
+ * @remarks
+ * The concrete ConversationMessageCollection class in ConversationsManager.ts
+ * extends EntityCollection<GetConversationMessageResponse> and satisfies this type.
+ */
+type ConversationMessageCollection = EntityCollection<GetConversationMessageResponse>;
+/**
+ * Provider interface for conversation management
+ *
+ * Defines the minimal interface required by Address and other consumers
+ * of conversation functionality. Implemented by ConversationsManager.
+ *
+ * @remarks
+ * This interface enables dependency injection and breaks circular dependencies
+ * by allowing consumers to depend on the interface rather than the concrete manager.
+ */
+interface ConversationsProvider {
+  /**
+   * Get or create a conversation message collection for an address
+   *
+   * @param addressId - The fabric address ID to get messages for
+   * @returns Promise resolving to a collection of conversation messages
+   *
+   * @remarks
+   * This method handles joining conversations if needed and creates
+   * a reactive collection that updates with new messages via observables
+   */
+  getConversationMessageCollection(addressId: string): Promise<ConversationMessageCollection>;
+  /**
+   * Send a text message to an address
+   *
+   * @param text - The message text to send
+   * @param destinationAddressId - The fabric address ID to send to
+   * @returns Promise that resolves when message is sent
+   *
+   * @throws {ConversationError} If sending fails
+   */
+  sendText(text: string, destinationAddressId: string): Promise<void>;
+}
+//#endregion
+//#region src/core/entities/Address.d.ts
+type AddressState = GetAddressResponse;
+/**
+ * Represents a contact or room in the directory.
+ *
+ * Provides identity metadata, conversation history, text messaging,
+ * and activity state for an address entry.
+ */
+declare class Address extends Destroyable {
+  private readonly addressId;
+  private conversationManager;
+  private addressProvider;
+  private initConversationMessages;
+  /** Observable of text messages for this address. Lazily loads conversation data. */
+  textMessages$: Observable<EntityCollectionTransformed<GetConversationMessageResponse, TextMessage<Address>> | undefined>;
+  /** Observable of call history for this address. Lazily loads conversation data. */
+  history$: Observable<EntityCollectionTransformed<GetConversationMessageResponse, AddressHistory<Address>> | undefined>;
+  private _conversationMessages?;
+  private _state$;
+  private _history$?;
+  private _textMessages$?;
+  constructor(addressId: string, conversationManager: ConversationsProvider, addressProvider: AddressProvider<Address>);
+  /** @internal */
+  upnext(state: Partial<AddressState>): void;
+  /** @internal */
+  get state(): AddressState | null;
+  /** Unique address identifier. */
+  get id(): string;
+  /** Address name (resource identifier). */
+  get name(): string;
+  /** ISO timestamp of when the address was created. */
+  get createdAt(): string;
+  /** Default communication channel URI (video for rooms, audio otherwise). */
+  get defaultChannel(): string | undefined;
+  /** Observable of the human-readable display name. */
+  get displayName$(): Observable<string>;
+  /** Human-readable display name. */
+  get displayName(): string;
+  /** Observable of the preview image URL. */
+  get previewUrl$(): Observable<string | undefined>;
+  /** Preview image URL. */
+  get previewUrl(): string | undefined;
+  /** Observable of the cover image URL. */
+  get coverUrl$(): Observable<string | undefined>;
+  /** Cover image URL. */
+  get coverUrl(): string | undefined;
+  /** Observable of the underlying resource ID. */
+  get resourceId$(): Observable<string>;
+  /** Underlying resource ID. */
+  get resourceId(): string;
+  /** Observable of the resource type (e.g. `'room'`, `'subscriber'`). */
+  get type$(): Observable<ResourceType>;
+  /** Resource type (e.g. `'room'`, `'subscriber'`). */
+  get type(): ResourceType;
+  /** Observable of available communication channels (audio, video, messaging). */
+  get channels$(): Observable<{
+    audio?: string;
+    messaging?: string;
+    video?: string;
+  }>;
+  /** Available communication channels. */
+  get channels(): {
+    audio?: string;
+    messaging?: string;
+    video?: string;
+  };
+  /** Whether the address (room) is locked. */
+  get locked(): boolean;
+  /** Observable indicating whether the address (room) is locked. */
+  get locked$(): Observable<boolean>;
+  /** Sends a text message to this address. */
+  sendText(text: string): Promise<void>;
+  /** Collection of text messages for this address, with pagination support. */
+  get textMessage(): EntityCollectionTransformed<GetConversationMessageResponse, TextMessage<Address>> | undefined;
+  /** Collection of call history entries for this address, with pagination support. */
+  get history(): EntityCollectionTransformed<GetConversationMessageResponse, AddressHistory<Address>> | undefined;
+  /** Observable of active call states for this address. @throws {UnimplementedError} Requires presence support. */
+  get activity$(): Observable<CallState[]>;
+  /** Active call states for this address. @throws {UnimplementedError} Requires presence support. */
+  get activity(): CallState[];
+}
+//#endregion
+//#region src/managers/AttachManager.d.ts
+interface AttachableCall {
+  id: string;
+  to?: string;
+  mediaDirections: MediaDirections;
+}
+interface OutboundCallProvider {
+  createOutboundCall(destination: string | Address, options?: CallOptions): Promise<Call>;
+}
+declare class AttachManager {
+  private readonly storage;
+  private readonly deviceController;
+  private readonly reconnectCallsTimeout;
+  private attachKey;
+  private session;
+  constructor(storage: StorageManager, deviceController: DeviceController, reconnectCallsTimeout: number, attachKey: string);
+  detachAll(): Promise<void>;
+  setSession(session: OutboundCallProvider): void;
+  private readAttached;
+  private writeAttached;
+  attach(call: AttachableCall): Promise<void>;
+  detach(call: AttachableCall): Promise<void>;
+  flush(): Promise<void>;
+  reattachCalls(): Promise<void>;
+  private buildCallOptions;
+  private detachExpired;
+}
+//#endregion
+//#region src/managers/TransportManager.d.ts
+declare class TransportManager extends Destroyable {
+  private readonly storage;
+  private readonly protocolKey;
+  private readonly onError?;
+  private initialized$;
+  protocol$: rxjs0.ReplaySubject<string | undefined>;
+  private isConnecting;
+  private isConnected;
+  private ackEvent;
+  private replySignalwirePing;
+  private _outgoingMessages$;
+  private _webSocketConnections;
+  private _jsonRPCMessage$;
+  private _jsonRPCResponse$;
+  private _incomingEvent$;
+  constructor(storage: StorageManager, protocolKey: string, webSocketConstructor: WebSocketAdapter | NodeSocketAdapter, relayHost: string, onError?: ((error: Error) => void) | undefined);
+  setProtocol(protocol: string | undefined): Promise<void>;
+  get incomingEvent$(): Observable<JSONRPCRequest | JSONRPCResponse>;
+  get connectionStatus$(): Observable<string>;
+  connect(): Promise<void>;
+  reconnect(): void;
+  execute<T extends JSONRPCResponse = JSONRPCResponse>(request: JSONRPCRequest, options?: PendingRPCOptions): Promise<T>;
+  send(message: unknown): void;
+  disconnect(): void;
+  destroy(): void;
+  private _loadProtocolFromStorage;
+  private _updateProtocolInStorage;
+  private _init;
+}
+//#endregion
+//#region src/core/entities/Directory.d.ts
+/**
+ * Directory interface for managing addresses
+ *
+ * This is the public API contract for address directory functionality.
+ * It provides access to addresses, loading capabilities, and search functionality.
+ *
+ * @public
+ */
+interface Directory extends AddressProvider<Address> {
+  /**
+   * Observable stream of all addresses in the directory
+   * Emits a new array whenever addresses are added, removed, or updated
+   */
+  readonly addresses$: Observable<Address[]>;
+  /**
+   * Current snapshot of all addresses in the directory
+   */
+  readonly addresses: Address[];
+  /**
+   * Observable indicating whether more addresses can be loaded from the server
+   */
+  readonly hasMore$: Observable<boolean>;
+  /**
+   * Observable indicating the current loading state
+   * Emits `true` when loading, `false` when idle
+   */
+  readonly loading$: Observable<boolean>;
+  readonly loading: boolean;
+  /**
+   * Load more addresses from the server
+   * Only loads if `hasMore` is true
+   */
+  loadMore(): void;
+  /**
+   * Get a specific address by ID
+   *
+   * @param addressId - The address ID to retrieve
+   * @returns The address instance, or undefined if not found
+   */
+  get(addressId: string): Address | undefined;
+  /**
+   * Find an address ID by searching for a name
+   *
+   * @param uri - The address name to search for
+   * @returns Promise resolving to the address ID, or undefined if not found
+   */
+  findAddressIdByURI(uri: string): Promise<string | undefined>;
+}
+//#endregion
+//#region src/interfaces/ClientSession.d.ts
+/**
+ * Minimal interface for what Call needs from session management
+ * need to interact with the session layer
+ */
+interface ClientSession {
+  /**
+   * Execute an RPC request through the session transport
+   * @param request - The JSON-RPC request to execute
+   * @param options - Optional RPC execution options (timeout, etc.)
+   * @returns Promise resolving to the RPC response
+   */
+  execute<T extends JSONRPCResponse = JSONRPCResponse>(request: JSONRPCRequest, options?: PendingRPCOptions): Promise<T>;
+  /**
+   * Observable stream of incoming signaling events
+   * Used by Call to listen for call-related events from the server
+   */
+  readonly signalingEvent$: Observable<Record<string, unknown>>;
+  /**
+   * ICE servers configuration for WebRTC peer connections
+   * Used by VertoManager to configure RTCPeerConnection
+   */
+  readonly iceServers: RTCIceServer[] | undefined;
+}
+//#endregion
+//#region src/managers/ClientSessionManager.d.ts
+declare class ClientSessionManager extends Destroyable implements ClientSession {
+  private credential;
+  private readonly transport;
+  private readonly storage;
+  private readonly authorizationStateKey;
+  private readonly attachManager;
+  private callFactory;
+  private callCreateTimeout;
+  private readonly agent;
+  private readonly eventAcks;
+  initialized$: Observable<boolean>;
+  authorization$: rxjs0.Subject<Authorization>;
+  private authorizationState$;
+  private connectVersion;
+  private _errors$;
+  private _directory?;
+  private _authenticated$;
+  private _subscriberInfo$;
+  private _calls$;
+  private _iceServers$;
+  constructor(credential: SDKCredential, transport: TransportManager, storage: StorageManager, authorizationStateKey: string, deviceController: DeviceController, attachManager: AttachManager);
+  get incomingCalls$(): Observable<Call[]>;
+  get incomingCalls(): Call[];
+  get subscriberInfo$(): Observable<Address | null>;
+  get subscriberInfo(): Address | null;
+  get calls$(): Observable<Call[]>;
+  get calls(): Call[];
+  get iceServers(): RTCIceServer[] | undefined;
+  get errors$(): Observable<Error>;
+  get authenticated$(): Observable<boolean>;
+  get authenticated(): boolean;
+  /**
+   * Set the directory instance
+   * Called by SignalWire after directory is created
+   * @internal
+   */
+  setDirectory(directory: Directory): void;
+  execute<T extends JSONRPCResponse = JSONRPCResponse>(request: JSONRPCRequest, options?: PendingRPCOptions): Promise<T>;
+  send(message: JSONSerializable): void;
+  private init;
+  private setupMessageHandlers;
+  private loadAuthorizationStateFromStorage;
+  private updateAuthorizationStateInStorage;
+  private get authStateEvent$();
+  get signalingEvent$(): Observable<{
+    event_type: "webrtc.message";
+    event_channel: string;
+    timestamp: number;
+    project_id: string;
+    node_id: string;
+    params: WebrtcMessagePayload;
+  } | {
+    event_type: "signalwire.authorization.state";
+    params: SignalwireAuthorizationStatePayload;
+  } | {
+    event_type: "call.joined";
+    event_channel: string;
+    timestamp: number;
+    params: CallJoinedPayload;
+  } | {
+    event_type: "call.left";
+    event_channel: string;
+    timestamp: number;
+    params: CallLeftPayload;
+  } | {
+    event_type: "call.updated";
+    event_channel: string;
+    timestamp: number;
+    params: CallUpdatedPayload;
+  } | {
+    event_type: "call.state";
+    event_channel: string;
+    timestamp: number;
+    params: CallStatePayload;
+  } | {
+    event_type: "call.play";
+    event_channel: string;
+    timestamp: number;
+    params: CallPlayPayload;
+  } | {
+    event_type: "call.connect";
+    event_channel: string;
+    timestamp: number;
+    params: CallConnectPayload;
+  } | {
+    event_type: "member.updated";
+    event_channel: EventChannel;
+    timestamp: number;
+    params: MemberUpdatedPayload;
+  } | {
+    event_type: "member.joined";
+    event_channel: EventChannel;
+    timestamp: number;
+    params: MemberJoinedPayload;
+  } | {
+    event_type: "member.left";
+    event_channel: EventChannel;
+    timestamp: number;
+    params: MemberLeftPayload;
+  } | {
+    event_type: "member.talking";
+    event_channel: EventChannel;
+    timestamp: number;
+    params: MemberTalkingPayload;
+  } | {
+    event_type: "layout.changed";
+    event_channel: EventChannel;
+    timestamp: number;
+    params: LayoutChangedPayload;
+  } | {
+    event_type: "conversation.message";
+    event_channel: string;
+    timestamp: string;
+    is_author: boolean;
+    params: ConversationMessagePayload;
+  } | {
+    event_type: "conversation.message.updated";
+    event_channel: string;
+    timestamp: string;
+    is_author: boolean;
+    params: ConversationMessageUpdatedPayload;
+  }>;
+  private get vertoInvite$();
+  private get contexts();
+  private get eventing();
+  private get topics();
+  private get authentication();
+  connect(): Promise<void>;
+  private handleAuthenticationError;
+  cleanupStoredConnectionParams(): Promise<void>;
+  protected updateAuthState(authorization_state: string): Promise<void>;
+  private authenticate;
+  disconnect(): Promise<void>;
+  private createInboundCall;
+  createOutboundCall(destination: string | Address, options?: CallOptions): Promise<Call>;
+  private createCall;
+  destroy(): void;
+}
+declare class ClientSessionWrapper {
+  private clientSessionManager;
+  constructor(clientSessionManager: ClientSessionManager);
+  get authenticated$(): Observable<boolean>;
+  get authenticated(): boolean;
+  get signalingEvent$(): Observable<{
+    event_type: "webrtc.message";
+    event_channel: string;
+    timestamp: number;
+    project_id: string;
+    node_id: string;
+    params: WebrtcMessagePayload;
+  } | {
+    event_type: "signalwire.authorization.state";
+    params: SignalwireAuthorizationStatePayload;
+  } | {
+    event_type: "call.joined";
+    event_channel: string;
+    timestamp: number;
+    params: CallJoinedPayload;
+  } | {
+    event_type: "call.left";
+    event_channel: string;
+    timestamp: number;
+    params: CallLeftPayload;
+  } | {
+    event_type: "call.updated";
+    event_channel: string;
+    timestamp: number;
+    params: CallUpdatedPayload;
+  } | {
+    event_type: "call.state";
+    event_channel: string;
+    timestamp: number;
+    params: CallStatePayload;
+  } | {
+    event_type: "call.play";
+    event_channel: string;
+    timestamp: number;
+    params: CallPlayPayload;
+  } | {
+    event_type: "call.connect";
+    event_channel: string;
+    timestamp: number;
+    params: CallConnectPayload;
+  } | {
+    event_type: "member.updated";
+    event_channel: EventChannel;
+    timestamp: number;
+    params: MemberUpdatedPayload;
+  } | {
+    event_type: "member.joined";
+    event_channel: EventChannel;
+    timestamp: number;
+    params: MemberJoinedPayload;
+  } | {
+    event_type: "member.left";
+    event_channel: EventChannel;
+    timestamp: number;
+    params: MemberLeftPayload;
+  } | {
+    event_type: "member.talking";
+    event_channel: EventChannel;
+    timestamp: number;
+    params: MemberTalkingPayload;
+  } | {
+    event_type: "layout.changed";
+    event_channel: EventChannel;
+    timestamp: number;
+    params: LayoutChangedPayload;
+  } | {
+    event_type: "conversation.message";
+    event_channel: string;
+    timestamp: string;
+    is_author: boolean;
+    params: ConversationMessagePayload;
+  } | {
+    event_type: "conversation.message.updated";
+    event_channel: string;
+    timestamp: string;
+    is_author: boolean;
+    params: ConversationMessageUpdatedPayload;
+  }>;
+  execute<T extends JSONRPCResponse = JSONRPCResponse>(request: JSONRPCRequest, options?: PendingRPCOptions): Promise<T>;
+  get incomingCalls$(): Observable<Call[]>;
+  get incomingCalls(): Call[];
+  get calls$(): Observable<Call[]>;
+  get calls(): Call[];
+}
+//#endregion
+//#region src/clients/SignalWire.d.ts
+/** Options for constructing a {@link SignalWire}. */
+interface SignalWireOptions {
+  /** Skip automatic WebSocket connection on construction. */
+  skipConnection?: boolean;
+  /** Skip automatic subscriber registration on construction. */
+  skipRegister?: boolean;
+  /** Skip reconnecting to previously attached calls. */
+  skipReconnect?: boolean;
+  /** Skip monitoring media device changes. */
+  skipDeviceMonitoring?: boolean;
+  /** Whether to reconnect to previously attached calls. */
+  reconnectAttachedCalls?: boolean;
+  /** Whether to save preferences. */
+  savePreferences?: boolean;
+  /** Custom storage implementation for persistence. */
+  storageImplementation?: Storage;
+  /** Custom WebSocket constructor */
+  webSocketConstructor?: WebSocketAdapter | NodeSocketAdapter;
+}
+/** Options for {@link SignalWire.dial}. Extends {@link MediaOptions} with dial-specific settings. */
+interface DialOptions extends MediaOptions {}
+/**
+ * Main entry point for the SignalWire Browser SDK.
+ *
+ * Manages authentication, WebSocket transport, call creation, and media devices.
+ *
+ * @example
+ * ```ts
+ * const client = new SignalWire(credentialProvider);
+ * client.isConnected$.subscribe(connected => console.log('Connected:', connected));
+ * const call = await client.dial('/public/my-room');
+ * ```
+ */
+declare class SignalWire extends Destroyable implements DeviceController {
+  /** Global SDK preferences (timeouts, ICE config, media defaults). */
+  preferences: ClientPreferences;
+  private _subscriber$;
+  private _directory$;
+  private _transport;
+  private _clientSession;
+  private _publicSession;
+  private _deviceController;
+  private _attachManager?;
+  private _isConnected$;
+  private _isRegistered$;
+  private _errors$;
+  private _options;
+  private _refreshTimerId?;
+  private _deps;
+  constructor(credentialProvider: CredentialProvider, options?: SignalWireOptions);
+  private validateCredentials;
+  private init;
+  private handleAttachments;
+  /**
+   * Establishes the WebSocket connection and authenticates the session.
+   *
+   * ## Reconnection behavior
+   *
+   * After a successful connection the underlying {@link WebSocketController}
+   * automatically attempts to reconnect whenever the socket closes
+   * unexpectedly (e.g. network change, server restart). Reconnection uses an
+   * **exponential back-off** strategy:
+   *
+   * - First retry after `reconnectDelayMin` (default **1 s**).
+   * - Each subsequent retry doubles the delay up to `reconnectDelayMax`
+   *   (default **30 s**).
+   * - The delay resets to `reconnectDelayMin` once a connection succeeds.
+   * - A per-attempt `connectionTimeout` (default **10 s**) aborts the
+   *   attempt and schedules the next retry if the server does not respond.
+   *
+   * Calling {@link disconnect} stops the reconnection loop entirely.
+   *
+   * ## Message handling during temporary disconnections
+   *
+   * While the socket is not in the `connected` state, **outgoing messages
+   * are queued** in an internal buffer. Once the connection is
+   * re-established the queue is flushed in order so no outgoing RPC call is
+   * lost.
+   *
+   * **Incoming** server-to-client messages that arrive while the socket is
+   * down are *not* buffered by the SDK — they are expected to be
+   * re-delivered by the server after the session is re-authenticated.
+   * Active RPC calls that were awaiting a response will time out
+   * (default **5 s**) and reject with an `RPCTimeoutError`; callers should
+   * handle this and retry if appropriate.
+   *
+   * The connection status can be observed via the `status$` observable on
+   * the transport layer, which emits `'connecting'`, `'connected'`,
+   * `'reconnecting'`, `'disconnecting'`, or `'disconnected'`.
+   */
+  connect(): Promise<void>;
+  /**
+   * Observable that emits the {@link Subscriber} profile once fetched,
+   * or `undefined` before authentication completes.
+   *
+   * @example
+   * ```ts
+   * client.subscriber$.subscribe(sub => {
+   *   if (sub) console.log('Logged in as', sub.email);
+   * });
+   * ```
+   */
+  get subscriber$(): Observable<Subscriber | undefined>;
+  /** Current subscriber snapshot, or `undefined` if not yet authenticated. */
+  get subscriber(): Subscriber | undefined;
+  /**
+   * Observable that emits the {@link Directory} instance once the client is connected,
+   * or `undefined` while disconnected. Subscribe to this to safely wait for the directory
+   * to become available without risking an error.
+   *
+   * @example
+   * ```ts
+   * client.directory$.subscribe(dir => {
+   *   if (dir) dir.addresses$.subscribe(console.log);
+   * });
+   * ```
+   */
+  get directory$(): Observable<Directory | undefined>;
+  /**
+   * Current directory snapshot, or `undefined` if the client is not yet connected.
+   * Prefer {@link directory$} when you need to react to the directory becoming available.
+   */
+  get directory(): Directory | undefined;
+  /** Observable that emits when the subscriber registration state changes. */
+  get isRegistered$(): Observable<boolean>;
+  /** Whether the subscriber is currently registered. */
+  get isRegistered(): boolean;
+  /** Whether the client is currently connected. */
+  get isConnected(): boolean;
+  /** Observable that emits when the connection state changes. */
+  get isConnected$(): Observable<boolean>;
+  /** Observable that emits `true` when the client is both connected and authenticated. */
+  get ready$(): Observable<boolean>;
+  /** Observable stream of errors from transport, authentication, and devices. */
+  get errors$(): Observable<Error>;
+  /** Disconnects the WebSocket and tears down the session. */
+  disconnect(): Promise<void>;
+  private waitAuthentication;
+  /** Registers the subscriber as online to receive inbound calls and events. */
+  register(): Promise<void>;
+  /** Unregisters the subscriber, going offline for inbound calls. */
+  unregister(): Promise<void>;
+  /**
+   * Places an outbound call to the given destination.
+   * @param destination - Address URI string or {@link Address} instance to call.
+   * @param options - Media and dial options (audio/video, constraints).
+   * @returns The created {@link Call} instance.
+   */
+  dial(destination: string | Address, options?: DialOptions): Promise<Call>;
+  /** The underlying client session for advanced RPC operations. */
+  get session(): ClientSessionWrapper;
+  /** Observable list of available audio input (microphone) devices. */
+  get audioInputDevices$(): Observable<MediaDeviceInfo[]>;
+  /** Current snapshot of available audio input devices. */
+  get audioInputDevices(): MediaDeviceInfo[];
+  /** Observable list of available audio output (speaker) devices. */
+  get audioOutputDevices$(): Observable<MediaDeviceInfo[]>;
+  /** Current snapshot of available audio output devices. */
+  get audioOutputDevices(): MediaDeviceInfo[];
+  /** Observable list of available video input (camera) devices. */
+  get videoInputDevices$(): Observable<MediaDeviceInfo[]>;
+  /** Current snapshot of available video input devices. */
+  get videoInputDevices(): MediaDeviceInfo[];
+  /** Observable of the currently selected audio input device. */
+  get selectedAudioInputDevice$(): Observable<MediaDeviceInfo | null>;
+  /** Observable of the currently selected audio output device. */
+  get selectedAudioOutputDevice$(): Observable<MediaDeviceInfo | null>;
+  /** Observable of the currently selected video input device. */
+  get selectedVideoInputDevice$(): Observable<MediaDeviceInfo | null>;
+  /** Currently selected audio input device, or `null` if none. */
+  get selectedAudioInputDevice(): MediaDeviceInfo | null;
+  /** Currently selected audio output device, or `null` if none. */
+  get selectedAudioOutputDevice(): MediaDeviceInfo | null;
+  /** Currently selected video input device, or `null` if none. */
+  get selectedVideoInputDevice(): MediaDeviceInfo | null;
+  /** Media track constraints for the selected audio input device. */
+  get selectedAudioInputDeviceConstraints(): MediaTrackConstraints;
+  /** Media track constraints for the selected video input device. */
+  get selectedVideoInputDeviceConstraints(): MediaTrackConstraints;
+  /** Converts a `MediaDeviceInfo` to track constraints suitable for `getUserMedia`. */
+  deviceInfoToConstraints(deviceInfo: MediaDeviceInfo | null): MediaTrackConstraints;
+  /** Sets the preferred audio input device. */
+  selectAudioInputDevice(device: MediaDeviceInfo | null): void;
+  /** Sets the preferred video input device. */
+  selectVideoInputDevice(device: MediaDeviceInfo | null): void;
+  /** Sets the preferred audio output device. */
+  selectAudioOutputDevice(device: MediaDeviceInfo | null): void;
+  /** Starts monitoring for media device changes (connect/disconnect). */
+  enableDeviceMonitoring(): void;
+  /** Stops monitoring for media device changes. */
+  disableDeviceMonitoring(): void;
+  getDeviceCapabilities(deviceInfo: MediaDeviceInfo): Promise<MediaTrackCapabilities | null>;
+  isValidDevice(deviceInfo: MediaDeviceInfo | null): Promise<boolean>;
+  destroy(): void;
+}
+//#endregion
+//#region src/utils/embeddableCall.d.ts
+/** Options for {@link embeddableCall}. */
+interface EmbeddableCallOptions {
+  /** Destination URI to call. */
+  to: string;
+  /** Embed token for authentication. */
+  embedToken: string;
+  /** SignalWire host URL. */
+  host: string;
+}
+/**
+ * Creates a call using an embed token for simple, embeddable integrations.
+ *
+ * Handles client creation, authentication, and dialing in a single call.
+ *
+ * @param options - Embed token, host, and destination.
+ * @returns The created {@link Call} instance.
+ */
+declare function embeddableCall(options: EmbeddableCallOptions): Promise<Call>;
+//#endregion
+//#region src/dependencies/StaticCredentialProvider.d.ts
+/**
+ * Credential provider that returns a fixed set of credentials.
+ *
+ * Use when the token is already available (e.g. from a backend endpoint).
+ *
+ * @example
+ * ```ts
+ * const provider = new StaticCredentialProvider({ token: 'my-sat-token' });
+ * const client = new SignalWire(provider);
+ * ```
+ */
+declare class StaticCredentialProvider implements CredentialProvider {
+  private credentials;
+  constructor(credentials: SDKCredential);
+  /** Returns the static credentials. */
+  authenticate(): Promise<SDKCredential>;
+}
+//#endregion
+//#region src/core/errors.d.ts
+declare class CallCreateError extends Error {
+  message: string;
+  error: unknown;
+  constructor(message: string, error?: unknown, options?: ErrorOptions);
+}
+declare class VertoPongError extends Error {
+  originalError: unknown;
+  constructor(originalError: unknown);
+}
+declare class MessageParseError extends Error {
+  originalError: unknown;
+  constructor(originalError: unknown);
+}
+declare class CollectionFetchError extends Error {
+  operation: string;
+  originalError: unknown;
+  constructor(operation: string, originalError: unknown);
+}
+declare class MediaTrackError extends Error {
+  operation: string;
+  kind: string;
+  originalError: unknown;
+  constructor(operation: string, kind: string, originalError: unknown);
+}
+//#endregion
+//#region src/controllers/RTCPeerConnectionController.d.ts
+interface RTCPeerConnectionControllerOptions extends MediaOptions {
+  callId?: string;
+  WebRTCPeerConnectionConstructor?: typeof RTCPeerConnection;
+  getUserMedia?: (constraints: MediaStreamConstraints) => Promise<MediaStream>;
+  getDisplayMedia?: (options: DisplayMediaStreamOptions) => Promise<MediaStream>;
+  rtcConfiguration?: RTCConfiguration;
+  simulcast?: boolean;
+  sfu?: boolean;
+  msStreamsNumber?: number;
+  propose: RTCPeerConnectionPropose;
+  iceServers?: RTCIceServer[];
+  disableUdpIceServers?: boolean;
+  relayOnly?: boolean;
+  iceCandidateTimeout?: number;
+  iceGatheringTimeout?: number;
+}
+type RTCPeerConnectionControllerOptionsPartial = Partial<RTCPeerConnectionControllerOptions>;
+interface UpdateSDPStatusParams {
+  status: 'received' | 'sent' | 'failed';
+  sdp?: string;
+}
+declare class RTCPeerConnectionController extends Destroyable {
+  protected options: RTCPeerConnectionControllerOptionsPartial;
+  readonly id: string;
+  firstSDPExchangeCompleted: boolean;
+  sdpInit?: RTCSessionDescriptionInit;
+  private negotiationNeeded$;
+  private deviceController;
+  private localStreamController;
+  private transceiverController?;
+  readonly localDescription$: Observable<RTCSessionDescription | null>;
+  peerConnection?: RTCPeerConnection;
+  private initPromise?;
+  private connectionTimeout;
+  private connectionTimer?;
+  private oniceconnectionstatechangeHandler;
+  private onconnectionstatechangeHandler;
+  private onsignalingstatechangeHandler;
+  private onicegatheringstatechangeHandler;
+  private onnegotiationneededHandler;
+  private updateSelectedInputDevice;
+  private _isNegotiating$;
+  private _iceGatheringController?;
+  private _memberId;
+  private _type;
+  private _iceConnectionState$;
+  private _connectionState$;
+  private _signalingState$;
+  private _iceGatheringState$;
+  private _errors$;
+  private _iceCandidates$;
+  private _initialized$;
+  private _remoteDescription$;
+  private _remoteStream$;
+  constructor(options?: RTCPeerConnectionControllerOptionsPartial, remoteSessionDescription?: string, deviceController?: DeviceController);
+  private get iceGatheringController();
+  private get shouldEmitLocalDescription();
+  private removeConnectionTimer;
+  setMemberId(memberId: string | null): void;
+  get memberId(): string | null;
+  stopTrackSender(kind: 'audio' | 'video' | 'both', options?: {
+    updateTransceiverDirection: boolean;
+  }): void;
+  get isNegotiating$(): Observable<boolean>;
+  get isNegotiating(): boolean;
+  updateMediaDevicesOptions(options: MediaOptions): void;
+  get iceGatheringState$(): Observable<RTCIceGatheringState>;
+  get mediaTrackEnded$(): Observable<MediaStreamTrack>;
+  get errors$(): Observable<Error>;
+  get iceCandidates$(): Observable<RTCIceCandidate[]>;
+  get initialized$(): Observable<boolean>;
+  get remoteDescription$(): Observable<RTCSessionDescription | null>;
+  get localStream$(): Observable<MediaStream | null>;
+  get remoteStream$(): Observable<MediaStream | null>;
+  get localAudioTracks$(): Observable<MediaStreamTrack[]>;
+  get localVideoTracks$(): Observable<MediaStreamTrack[]>;
+  get iceConnectionState$(): Observable<RTCIceConnectionState>;
+  get connectionState$(): Observable<RTCPeerConnectionState>;
+  get signalingState$(): Observable<RTCSignalingState>;
+  get type(): RTCPeerConnectionType;
+  get propose(): RTCPeerConnectionPropose;
+  get isAdditionalDevice(): boolean;
+  get isMainDevice(): boolean;
+  get isScreenShare(): boolean;
+  protected get iceServers(): RTCIceServer[];
+  private get rtcConfiguration();
+  get receiveVideo(): boolean;
+  get receiveAudio(): boolean;
+  get localStream(): MediaStream | null;
+  get remoteStream(): MediaStream | null;
+  private get inputAudioDeviceConstraints();
+  private get inputVideoDeviceConstraints();
+  private get WebRTCPeerConnectionConstructor();
+  private get offerOptions();
+  private get answerOptions();
+  /**
+   * Initialize the RTCPeerConnection and setup event listeners.
+   * Called automatically when localDescription$ is subscribed to (deferred pattern).
+   * Uses Promise memoization to ensure initialization only happens once,
+   * even if called concurrently.
+   */
+  private init;
+  /**
+   * Internal initialization implementation.
+   * Should only be called via init() to ensure single execution.
+   */
+  private doInit;
+  private setupPeerConnection;
+  private startNegotiation;
+  /**
+   * Create an SDP offer and set it as local description.
+   */
+  private createOffer;
+  updateAnswerStatus({
+    status,
+    sdp
+  }: UpdateSDPStatusParams): Promise<void>;
+  updateOfferStatus({
+    status,
+    sdp
+  }: UpdateSDPStatusParams): Promise<void>;
+  private handleOfferReceived;
+  private readyToConnect;
+  private setRemoteDescriptionBefore;
+  protected setLocalDescription(params: RTCSessionDescriptionInit): Promise<void>;
+  setLocalDescriptionBefore(sdp?: string): Promise<string>;
+  /**
+   * Create an SDP answer and set it as local description.
+   */
+  private createAnswer;
+  /**
+   * Setup event listeners on RTCPeerConnection for state changes.
+   */
+  private setupEventListeners;
+  private negotiationEnded;
+  restarIce(): void;
+  /**
+   * Setup track handling for remote tracks.
+   */
+  private setupTrackHandling;
+  private setupLocalTracks;
+  private getUserMedia;
+  private getDisplayMedia;
+  private setupRemoteTracks;
+  restoreTrackSender(kind: 'audio' | 'video' | 'both'): Promise<void>;
+  /**
+   * Add a local media track to the peer connection.
+   * @param track - The MediaStreamTrack to add
+   */
+  addLocalTrack(track: MediaStreamTrack): void;
+  /**
+   * Remove a local media track from the peer connection.
+   * @param trackId - The ID of the track to remove
+   */
+  removeLocalTrack(trackId: string): void;
+  /**
+   * Replace all existing media tracks with a new media  track.
+   * Convenience method for single-track scenarios.
+   * @param track - The MediaStreamTrack to set
+   */
+  setLocalTrack(track: MediaStreamTrack): void;
+  updateSendersConstraints(kind: 'audio' | 'video', constraints?: MediaTrackConstraints): Promise<void>;
+  /**
+   * Clean up resources and close the peer connection.
+   * Completes all observables to prevent memory leaks.
+   */
+  destroy(): void;
+  private removeAllListeners;
+  private stopRemoteTracks;
+  get mediaDirections(): {
+    audio: RTCRtpTransceiverDirection;
+    video: RTCRtpTransceiverDirection;
+  };
+  protected _setRemoteDescription(params: RTCSessionDescriptionInit): Promise<void>;
+}
+//#endregion
+//#region src/interfaces/WebRTCVerto.d.ts
+/**
+ * Extended interface for WebRTC Verto Manager
+ * Includes WebRTC-specific state and peer connection management
+ */
+interface WebRTCVerto extends VertoManager {
+  readonly selfId$: Observable<string | null>;
+  readonly selfId: string | null;
+  readonly nodeId$: Observable<string | null>;
+  readonly nodeId: string | null;
+  readonly localStream$: Observable<MediaStream>;
+  readonly localStream: MediaStream | null;
+  readonly remoteStream$: Observable<MediaStream>;
+  readonly remoteStream: MediaStream | null;
+  readonly mediaDirections$: Observable<MediaDirections>;
+  readonly mediaDirections: MediaDirections;
+  readonly signalingStatus$: Observable<SignalingStatus>;
+  readonly mainPeerConnection: RTCPeerConnectionController;
+  bye(cause?: string): Promise<void>;
+  sendDigits(dtmf: string): Promise<void>;
+  hold(): Promise<void>;
+  unhold(): Promise<void>;
+  destroy(): void;
+  transfer(options: TransferOptions): Promise<void>;
+}
+//#endregion
+//#region src/managers/CallEventsManager.d.ts
+interface WebRTCCallEventManagerOptions {}
+declare class CallEventsManager extends Destroyable {
+  protected webRtcCallSession: CallManager;
+  protected options: WebRTCCallEventManagerOptions;
+  private selfId?;
+  private originCallId?;
+  private callIds;
+  private roomSessionIds;
+  private _status$;
+  private _participants$;
+  private _self$;
+  private _sessionState$;
+  constructor(webRtcCallSession: CallManager, options?: WebRTCCallEventManagerOptions);
+  get participants$(): Observable<CallParticipant[]>;
+  get self$(): Observable<CallSelfParticipant>;
+  get status$(): Observable<CallStatus>;
+  get status(): CallStatus;
+  isRoomSessionIdValid(roomSessionId: string): boolean;
+  addCallId(callId: string): void;
+  isCallIdValid(callId: string): boolean;
+  get recording$(): Observable<boolean>;
+  get recordings$(): Observable<Record<string, unknown>[]>;
+  get streaming$(): Observable<boolean>;
+  get streams$(): Observable<Record<string, unknown>[]>;
+  get playbacks$(): Observable<Record<string, unknown>[]>;
+  get raiseHandPriority$(): Observable<boolean>;
+  get locked$(): Observable<boolean>;
+  get meta$(): Observable<Record<string, unknown>>;
+  get capabilities$(): Observable<string[]>;
+  get layout$(): Observable<string>;
+  get layouts$(): Observable<string[]>;
+  get layoutLayers$(): Observable<LayoutLayer[]>;
+  get self(): CallSelfParticipant | null;
+  get layoutLayers(): LayoutLayer[];
+  get recording(): boolean;
+  get streaming(): boolean;
+  get raiseHandPriority(): boolean;
+  get locked(): boolean;
+  get meta(): Record<string, unknown>;
+  get layout(): string | undefined;
+  get layouts(): string[];
+  get capabilities(): string[];
+  isSessionEvent(id: string): boolean;
+  protected initSubscriptions(): void;
+  private updateParticipantPositions;
+  updateLayouts(): void;
+  private updateParticipants;
+  private upsertParticipant;
+  private get callJoinedEvent$();
+  private get layoutChangedEvent$();
+  private get memberUpdates$();
+  destroy(): void;
+}
+//#endregion
+//#region src/core/entities/Call.d.ts
+/**
+ * Manager instances returned by initialization callback
+ */
+interface CallManagers {
+  vertoManager: WebRTCVerto;
+  callEventsManager: CallEventsManager;
+}
+/**
+ * Initialization callback that creates managers for a Call instance
+ * @param call - The WebRTCCall instance being initialized
+ * @returns Manager instances for the call
+ */
+type ManagerInitializer = (call: WebRTCCall) => CallManagers;
+/**
+ * Required initialization configuration for Call constructor.
+ * Calls must be created via {@link CallFactory} which provides these dependencies.
+ */
+interface CallInitialization {
+  /**
+   * Callback function that creates and wires manager instances
+   */
+  initializeManagers: ManagerInitializer;
+  /**
+   * Device controller for media device access
+   */
+  deviceController: DeviceController;
+}
+/**
+ * Concrete WebRTC call implementation.
+ *
+ * Manages the full lifecycle of a call including signaling, media streams,
+ * participants, layout, and event routing. Created via {@link SignalWire.dial}
+ * or received as an inbound call.
+ */
+declare class WebRTCCall extends Destroyable implements CallManager {
+  clientSession: ClientSession;
+  options: CallOptions;
+  address?: Address | undefined;
+  /** Unique identifier for this call. */
+  readonly id: string;
+  /** Destination URI this call was placed to. */
+  to?: string;
+  protected readonly participantsMap: Map<string, Participant>;
+  private vertoManager;
+  private callEventsManager;
+  private participantFactory;
+  private _errors$;
+  private _status$;
+  private _answered$;
+  private _holdState;
+  constructor(clientSession: ClientSession, options: CallOptions, initialization: CallInitialization, address?: Address | undefined);
+  /** Observable stream of errors from media, signaling, and peer connection layers. */
+  get errors$(): Observable<Error>;
+  /** @internal Push an error to the call's error stream. */
+  emitError(error: Error): void;
+  /** Whether this call is `'inbound'` or `'outbound'`. */
+  get direction(): CallDirection;
+  /** Observable of the address associated with this call. */
+  get address$(): Observable<Address | undefined>;
+  /** Display name of the caller. */
+  get fromName(): string | undefined;
+  /** Address URI of the caller. */
+  get from(): string | undefined;
+  /** Display name of the callee. */
+  get toName(): string | undefined;
+  /** Toggles whether incoming video is received. @throws {UnimplementedError} Not yet implemented. */
+  toggleIncomingVideo(): Promise<void>;
+  /** Toggles whether incoming audio is received. @throws {UnimplementedError} Not yet implemented. */
+  toggleIncomingAudio(): Promise<void>;
+  /** @internal Registers an additional call ID for event routing. */
+  addCallId(callId: string): void;
+  /** List of capabilities available in the current call. */
+  get capabilities(): string[];
+  /** Current snapshot of all participants in the call. */
+  get participants(): CallParticipant[];
+  /** The local participant, or `null` if not yet joined. */
+  get self(): CallSelfParticipant | null;
+  toggleLock(): Promise<void>;
+  toggleHold(): Promise<void>;
+  startRecording(): Promise<void>;
+  startStreaming(): Promise<void>;
+  setMeta(_meta: Record<string, unknown>): Promise<void>;
+  updateMeta(_meta: Record<string, unknown>): Promise<void>;
+  /** Observable of layout layer positions for all participants. */
+  get layoutLayers$(): Observable<LayoutLayer[]>;
+  /** Current snapshot of layout layers. */
+  get layoutLayers(): LayoutLayer[];
+  /** Executes a Verto RPC method targeting a specific participant. */
+  executeMethod<T extends JSONRPCResponse = JSONRPCResponse>(target: string, method: string, args: Record<string, unknown>): Promise<T>;
+  private buildMethodParams;
+  /** Observable of the current call status (e.g. `'ringing'`, `'connected'`). */
+  get status$(): Observable<CallStatus>;
+  /** Observable of the participants list, emits on join/leave/update. */
+  get participants$(): Observable<CallParticipant[]>;
+  /** Observable of the local (self) participant. */
+  get self$(): Observable<CallSelfParticipant>;
+  /** Observable indicating whether the call is being recorded. */
+  get recording$(): Observable<boolean>;
+  /** Observable indicating whether the call is being streamed. */
+  get streaming$(): Observable<boolean>;
+  /** Observable indicating whether raise-hand priority is active. */
+  get raiseHandPriority$(): Observable<boolean>;
+  /** Observable indicating whether the call room is locked. */
+  get locked$(): Observable<boolean>;
+  /** Observable of custom metadata associated with the call. */
+  get meta$(): Observable<Record<string, unknown>>;
+  /** Observable of the call's capability flags. */
+  get capabilities$(): Observable<string[]>;
+  /** Observable of the current layout name. */
+  get layout$(): Observable<string>;
+  /** Current call status. */
+  get status(): CallStatus;
+  /** Whether the call is currently being recorded. */
+  get recording(): boolean;
+  /** Whether the call is currently being streamed. */
+  get streaming(): boolean;
+  /** Whether raise-hand priority is active. */
+  get raiseHandPriority(): boolean;
+  /** Whether the call room is locked. */
+  get locked(): boolean;
+  /** Current custom metadata of the call. */
+  get meta(): Record<string, unknown>;
+  /** Current layout name, or `undefined` if not set. */
+  get layout(): string | undefined;
+  /** Observable of available layout names. */
+  get layouts$(): Observable<string[]>;
+  /** Current snapshot of available layout names. */
+  get layouts(): string[];
+  /** Observable of the local media stream (camera/microphone). */
+  get localStream$(): Observable<MediaStream>;
+  /** Current local media stream, or `null` if not available. */
+  get localStream(): MediaStream | null;
+  /** Observable of the remote media stream from the far end. */
+  get remoteStream$(): Observable<MediaStream>;
+  /** Current remote media stream, or `null` if not available. */
+  get remoteStream(): MediaStream | null;
+  /** @internal */
+  createParticipant(memberId: string, selfId?: string | null): Participant | SelfParticipant;
+  /** Observable of the current audio/video send/receive directions. */
+  get mediaDirections$(): Observable<MediaDirections>;
+  /** Current audio/video send/receive directions. */
+  get mediaDirections(): MediaDirections;
+  protected get participantsId$(): Observable<string[]>;
+  /** Executes a raw JSON-RPC request on the client session. */
+  execute<T extends JSONRPCResponse = JSONRPCResponse>(request: JSONRPCRequest, options?: PendingRPCOptions): Promise<T>;
+  /** Observable of the local participant's member ID. */
+  get selfId$(): Observable<string | null>;
+  /** Local participant's member ID, or `null` if not joined. */
+  get selfId(): string | null;
+  /** Observable of the server node ID handling this call. */
+  get nodeId$(): Observable<string | null>;
+  /** Server node ID handling this call, or `null`. */
+  get nodeId(): string | null;
+  private isCallSessionEvent;
+  private get callSessionEvents$();
+  /** Observable of call-updated events. */
+  get callUpdated$(): Observable<CallUpdatedPayload>;
+  /** Observable of member-joined events. */
+  get memberJoined$(): Observable<MemberJoinedPayload>;
+  /** Observable of member-left events. */
+  get memberLeft$(): Observable<MemberLeftPayload>;
+  /** Observable of member-updated events (mute, volume, etc.). */
+  get memberUpdated$(): Observable<MemberUpdatedPayload>;
+  /** Observable of member-talking events (speech start/stop). */
+  get memberTalking$(): Observable<MemberTalkingPayload>;
+  /** Observable of call state-change events. */
+  get callStates$(): Observable<CallStatePayload>;
+  /** Observable of layout-changed events. */
+  get layoutUpdates$(): Observable<LayoutChangedPayload>;
+  /** Underlying `RTCPeerConnection`, for advanced use cases. */
+  get rtcPeerConnection(): RTCPeerConnection | undefined;
+  /** Observable of raw signaling events as plain objects. */
+  get signalingEvent$(): Observable<Record<string, unknown>>;
+  /** Observable of WebRTC-specific signaling messages. */
+  get webrtcMessages$(): Observable<WebrtcMessagePayload>;
+  /** Observable of call-level signaling events. */
+  get callEvent$(): Observable<WebrtcMessagePayload | CallJoinedPayload | CallLeftPayload | CallUpdatedPayload | CallStatePayload | CallPlayPayload | CallConnectPayload | MemberUpdatedPayload | MemberJoinedPayload | MemberLeftPayload | MemberTalkingPayload | LayoutChangedPayload | ConversationMessagePayload>;
+  /** Observable of layout-changed signaling events. */
+  get layoutEvent$(): Observable<LayoutChangedPayload>;
+  /** Hangs up the call and releases all resources. */
+  hangup(): Promise<void>;
+  /** Sends DTMF digits (e.g. `'1234#'`) on the call. */
+  sendDigits(dtmf: string): Promise<void>;
+  /** Accepts an inbound call. */
+  answer(): void;
+  /** Rejects an inbound call. */
+  reject(): void;
+  /** Observable that emits `true` when answered, `false` when rejected. */
+  get answered$(): Observable<boolean>;
+  /**
+   * Sets the call layout and participant positions.
+   * @param layout - Layout name (must be one of {@link layouts}).
+   * @param positions - Map of member IDs to video positions.
+   */
+  setLayout(layout: string, positions: Record<string, VideoPosition>): Promise<void>;
+  /** Transfers the call to other participants. */
+  transfer(options: TransferOptions): Promise<void>;
+  /** Destroys the call, releasing all resources and subscriptions. */
+  destroy(): void;
+}
+//#endregion
+//#region src/index.d.ts
+/**
+ * Library version from package.json, injected at build time.
+ */
+declare const version: string;
+/**
+ * Flag indicating the library has been loaded and is ready to use.
+ * For UMD builds: `window.SignalWire.ready`
+ * For ES modules: `import { ready } from '@signalwire/js'`
+ */
+declare const ready: boolean;
+//#endregion
+export { Address, type AddressHistory, type Call, type CallAddress, CallCreateError, type CallOptions, type CallParticipant, type CallSelfParticipant, type CallState, type CallStatus, ClientPreferences, CollectionFetchError, type DialOptions, type Directory, type ExecuteMethod, type LayoutLayer, type MediaDirection, type MediaDirections, type MediaOptions, MediaTrackError, MessageParseError, type NodeSocketAdapter, Participant, type SDKCredential, SelfParticipant, SignalWire, type SignalWireOptions, StaticCredentialProvider, Subscriber, type TextMessage, VertoPongError, WebRTCCall, type WebSocketAdapter, embeddableCall, isSelfParticipant, ready, version };
+//# sourceMappingURL=index.d.cts.map