import { a as JSONRPCSuccessResponse, i as JSONRPCResponse, n as JSONRPCErrorResponse, r as JSONRPCRequest, t as EventChannel } from "./base-Cif20s3C.cjs";
import { URL as URL$1 } from "node:url";
import * as rxjs0 from "rxjs";
import { BehaviorSubject, Observable, Observer, ReplaySubject, Subject, Subscription } from "rxjs";

//#region src/core/types/common.types.d.ts
/** JSON-compatible value type for serializable data structures. */
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;
}
/** Browser-compatible WebSocket client interface. */
interface WebSocketClient {
  addEventListener: WebSocket['addEventListener'];
  removeEventListener: WebSocket['removeEventListener'];
  send: WebSocket['send'];
  close: WebSocket['close'];
  readyState: WebSocket['readyState'];
}
/** Node.js WebSocket client interface with event listener overloads. */
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.
 *
 * At least one of `token` or `authorizationState` must be provided.
 */
interface SDKCredential {
  /** JWT user access token (SAT). */
  token?: string;
  /** Pre-authorized session state (alternative to token). */
  authorizationState?: string;
  /** Token expiry timestamp in milliseconds since epoch. When set, the SDK attempts credential refresh before expiry. */
  expiry_at?: number;
}
/** Types of addressable resources in the fabric. */
type ResourceType = 'app' | 'call' | 'room' | 'subscriber';
//#endregion
//#region src/dependencies/interfaces.d.ts
/** Persistence scope: browser `localStorage` or `sessionStorage`. */
type StorageScope = 'local' | 'session';
/** Key-value storage interface for persisting SDK preferences and state. */
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>;
  /** Clears all keys in the given scope. Implementations may scope the clear to SDK keys only. */
  clear(scope: StorageScope): Promise<void>;
}
/**
 * Context provided by the SDK when calling {@link CredentialProvider.authenticate}.
 *
 * Contains optional parameters the SDK generates internally (e.g., DPoP fingerprint)
 * that the implementor can forward to their server-side token endpoint.
 */
interface AuthenticateContext {
  /**
   * JWK Thumbprint (RFC 7638) of the SDK's ephemeral DPoP key pair.
   *
   * When present, the implementor should forward this value as the `fingerprint`
   * parameter to the server-side SAT issuance endpoint alongside `scope: "sat:refresh"`.
   * This enables the server to bind the SAT to the SDK's key pair, allowing
   * automatic Client Bound SAT refresh without developer intervention.
   *
   * When absent (e.g., Web Crypto API not available), the implementor should
   * proceed without DPoP binding.
   */
  fingerprint?: string;
}
/**
 * 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.
 *
 * ## Refresh precedence
 *
 * The SDK selects exactly one refresh mechanism per session, evaluated at connect
 * time (and re-evaluated on reconnect):
 *
 * | `refresh` provided | SAT carries `sat:refresh` scope | Active mechanism                     |
 * | ------------------ | -------------------------------- | ------------------------------------ |
 * | yes                | yes                              | Client Bound SAT (DPoP, internal)    |
 * | yes                | no                               | Developer-provided `refresh()`       |
 * | no                 | yes                              | Client Bound SAT (DPoP, internal)    |
 * | no                 | no                               | None — session ends at `expiry_at`   |
 *
 * When the SDK falls back to the developer-provided `refresh()` because the SAT
 * lacked `sat:refresh` scope, a `credential_refresh_fallback` event is emitted on
 * `SignalWire.warnings$` so application code can observe the transition.
 *
 * Mint a SAT via `POST /api/fabric/subscribers/tokens` with `fingerprint` and
 * `scope: ["sat:refresh"]` (both currently optional on that endpoint) to enable
 * the Client Bound SAT path; otherwise provide `refresh()` here.
 */
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.
   * - When `context.fingerprint` is provided, forward it to the server-side token
   *   endpoint with `scope: "sat:refresh"` to enable automatic token refresh.
   *   Ignoring `context.fingerprint` causes the SDK to fall back to `refresh()`
   *   (if provided) or end the session at expiry.
   *
   * SDK behavior:
   * - Awaits this method before establishing the WebSocket connection.
   * - On rejection, propagates the error to the caller of `SignalWire()`.
   */
  authenticate(context?: AuthenticateContext): 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 AND the
   *   SAT does not carry `sat:refresh` scope (otherwise the SDK refreshes
   *   internally via Client Bound SAT). See the precedence table above.
   * - 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.
   */
  refresh?: () => Promise<SDKCredential>;
}
/**
 * Provides custom WebRTC API implementations for non-standard environments.
 *
 * Use this when the standard browser WebRTC APIs are not available or need
 * to be replaced (e.g., Citrix HDX, React Native, Electron).
 *
 * @example
 * ```typescript
 * import { SignalWire, type WebRTCApiProvider } from '@signalwire/js';
 *
 * const provider: WebRTCApiProvider = {
 *   RTCPeerConnection: CustomRTCPeerConnection,
 *   mediaDevices: {
 *     getUserMedia: (constraints) => customGetUserMedia(constraints),
 *     enumerateDevices: () => customEnumerateDevices(),
 *     addEventListener: (type, listener) => { ... },
 *     removeEventListener: (type, listener) => { ... },
 *   }
 * };
 *
 * const client = new SignalWire(credentialProvider, { webRTCApiProvider: provider });
 * ```
 */
interface WebRTCApiProvider {
  /** Custom RTCPeerConnection constructor. */
  RTCPeerConnection: typeof RTCPeerConnection;
  /** Custom media device access. Only the methods used by the SDK are required. */
  mediaDevices: WebRTCMediaDevices;
}
/**
 * Subset of the `MediaDevices` interface actually used by the SDK.
 *
 * Implementations only need to provide these methods — the full browser
 * `MediaDevices` type is intentionally not required so that React Native
 * and other non-browser environments can conform without polyfilling
 * unused APIs.
 */
interface WebRTCMediaDevices {
  getUserMedia(constraints: MediaStreamConstraints): Promise<MediaStream>;
  getDisplayMedia?(options: DisplayMediaStreamOptions): Promise<MediaStream>;
  enumerateDevices(): Promise<MediaDeviceInfo[]>;
  addEventListener(type: string, listener: EventListenerOrEventListenerObject): void;
  removeEventListener(type: string, listener: EventListenerOrEventListenerObject): void;
}
//#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>;
  /**
   * Clears all SDK keys from both 'local' and 'session' scopes.
   * @throws StorageWriteError if clearing fails
   */
  clearAll(): Promise<void>;
}
//#endregion
//#region src/behaviors/Destroyable.d.ts
declare abstract class Destroyable {
  protected subscriptions: Subscription[];
  protected subjects: Subject<unknown>[];
  protected _destroyed$: Subject<void>;
  private _observableCache?;
  destroy(): void;
  protected cachedObservable<T>(key: string, factory: () => Observable<T>): Observable<T>;
  /**
   * Like `cachedObservable`, but defers emissions to the microtask queue
   * via `observeOn(asapScheduler)`.
   *
   * Use ONLY for public-facing observable getters that external consumers
   * subscribe to. Prevents a class of bugs where `BehaviorSubject` or
   * `ReplaySubject` replays synchronously during `subscribe()`, before
   * the subscription variable is assigned in the caller's scope.
   *
   * Do NOT use for observables consumed internally by the SDK — internal
   * code using `subscribeTo()`, `firstValueFrom()`, or `withLatestFrom()`
   * depends on synchronous emission delivery.
   */
  protected publicCachedObservable<T>(key: string, factory: () => Observable<T>): Observable<T>;
  /**
   * Wraps an observable so emissions are deferred to the microtask queue.
   *
   * Use ONLY for public-facing getters that expose a subject via
   * `.asObservable()` without going through `cachedObservable`.
   *
   * Do NOT use for observables consumed internally by the SDK.
   */
  protected deferEmission<T>(observable: Observable<T>): Observable<T>;
  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>;
  /**
   * 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 for starting a screen share. */
interface ScreenShareOptions {
  /**
   * Request the shared surface's audio. Defaults to `false`.
   *
   * Whether audio can actually be captured depends on the browser, the OS and
   * the surface the user picks — Chrome offers it for tabs and windows, and a
   * share the user grants without audio yields a video-only stream.
   */
  audio?: boolean;
}
/** Options controlling which media tracks to send and receive. */
interface MediaOptions {
  /** Enable audio input. Defaults to `true` when not specified. */
  audio?: boolean;
  /** Enable video input. Defaults to `false` when not specified. */
  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;
  /**
   * When local media can't be acquired (permission denied or device
   * unavailable), continue the call in receive-only mode instead of failing.
   * Defaults to `true`. Ignored when the call is not set to receive any media.
   */
  fallbackToReceiveOnly?: boolean;
}
//#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>);
  /** Stats polling interval in milliseconds. */
  get statsPollingInterval(): number;
  set statsPollingInterval(value: number);
  /** Number of baseline samples for stats monitoring. */
  get statsBaselineSamples(): number;
  set statsBaselineSamples(value: number);
  /** Duration in ms with no inbound packets before a critical issue is emitted. */
  get statsNoPacketThreshold(): number;
  set statsNoPacketThreshold(value: number);
  /** Multiplier for RTT spike detection relative to baseline. */
  get statsRttSpikeMultiplier(): number;
  set statsRttSpikeMultiplier(value: number);
  /** Packet loss fraction threshold (0-1) for issue detection. */
  get statsPacketLossThreshold(): number;
  set statsPacketLossThreshold(value: number);
  /** Multiplier for jitter spike detection relative to baseline. */
  get statsJitterSpikeMultiplier(): number;
  set statsJitterSpikeMultiplier(value: number);
  /** Number of seconds of metrics history to retain. */
  get statsHistorySize(): number;
  set statsHistorySize(value: number);
  /** Maximum keyframe requests in a burst window. */
  get keyframeMaxBurst(): number;
  set keyframeMaxBurst(value: number);
  /** Keyframe burst window duration in milliseconds. */
  get keyframeBurstWindow(): number;
  set keyframeBurstWindow(value: number);
  /** Cooldown period in ms after keyframe burst limit is reached. */
  get keyframeCooldown(): number;
  set keyframeCooldown(value: number);
  /** Minimum time in ms between re-INVITE attempts. */
  get reinviteDebounceTime(): number;
  set reinviteDebounceTime(value: number);
  /** Maximum re-INVITE attempts per call. */
  get reinviteMaxAttempts(): number;
  set reinviteMaxAttempts(value: number);
  /** Timeout in ms for a single re-INVITE attempt. */
  get reinviteTimeout(): number;
  set reinviteTimeout(value: number);
  /** Recovery signal debounce window in seconds. */
  get recoveryDebounceTime(): number;
  set recoveryDebounceTime(seconds: number);
  /** Cooldown period between recovery attempts in seconds. */
  get recoveryCooldown(): number;
  set recoveryCooldown(seconds: number);
  /** Grace period before treating ICE 'disconnected' as failure, in seconds. */
  get iceDisconnectedGracePeriod(): number;
  set iceDisconnectedGracePeriod(seconds: number);
  /** Timeout for a single ICE restart attempt in seconds. */
  get iceRestartTimeout(): number;
  set iceRestartTimeout(seconds: number);
  /** Maximum recovery attempts before giving up. */
  get maxRecoveryAttempts(): number;
  set maxRecoveryAttempts(value: number);
  /** Whether relay-only escalation is enabled as a last-resort recovery tier. */
  get enableRelayFallback(): boolean;
  set enableRelayFallback(value: boolean);
  /** Whether browser network change detection (online/offline) is enabled. */
  get enableNetworkChangeDetection(): boolean;
  set enableNetworkChangeDetection(value: boolean);
  /** Whether server-sent media-timeout hangups are intercepted for recovery. */
  get enableServerHangupInterception(): boolean;
  set enableServerHangupInterception(value: boolean);
  /** Whether device selections are persisted to storage. */
  get persistDeviceSelection(): boolean;
  set persistDeviceSelection(value: boolean);
  /** Whether device changes are auto-applied to active calls. */
  get syncDevicesToActiveCalls(): boolean;
  set syncDevicesToActiveCalls(value: boolean);
  /** Whether to auto-mute video when the tab becomes hidden. */
  get autoMuteVideoOnHidden(): boolean;
  set autoMuteVideoOnHidden(value: boolean);
  /** Whether to re-enumerate devices when the page becomes visible. */
  get refreshDevicesOnVisible(): boolean;
  set refreshDevicesOnVisible(value: boolean);
  /** Whether to check peer connection health when the page becomes visible. */
  get checkConnectionOnVisible(): boolean;
  set checkConnectionOnVisible(value: boolean);
  /** Default audio track constraints applied when no explicit constraints are provided. */
  get defaultAudioConstraints(): MediaTrackConstraints | undefined;
  set defaultAudioConstraints(value: MediaTrackConstraints | undefined);
  /** Default video track constraints applied when video is enabled without explicit constraints. */
  get defaultVideoConstraints(): MediaTrackConstraints | undefined;
  set defaultVideoConstraints(value: MediaTrackConstraints | undefined);
  /** Whether stereo Opus is enabled globally. */
  get stereoAudio(): boolean;
  set stereoAudio(value: boolean);
  /** Whether automatic video degradation on low bandwidth is enabled. */
  get enableAutoDegradation(): boolean;
  set enableAutoDegradation(value: boolean);
  /** Bitrate in kbps below which video is automatically disabled. */
  get degradationBitrateThreshold(): number;
  set degradationBitrateThreshold(value: number);
  /** Bitrate in kbps above which video is automatically re-enabled. */
  get degradationRecoveryThreshold(): number;
  set degradationRecoveryThreshold(value: number);
  /** Preferred video codecs in priority order. */
  get preferredVideoCodecs(): string[];
  set preferredVideoCodecs(value: string[]);
  /** Preferred audio codecs in priority order. */
  get preferredAudioCodecs(): string[];
  set preferredAudioCodecs(value: string[]);
  /** 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 extends Destroyable {
  private baseURL;
  private readonly getCredential;
  private static readonly defaultMaxRetries;
  private static readonly defaultRetryDelayMinMs;
  private static readonly defaultRetryDelayMaxMs;
  private static readonly defaultRequestTimeoutMs;
  /** Sensitive field names to mask in debug logs. */
  private static readonly SENSITIVE_BODY_FIELDS;
  private readonly maxRetries;
  private readonly retryDelayMin;
  private readonly retryDelayMax;
  private readonly requestTimeout;
  private _responses$;
  private _errors$;
  private _status$;
  constructor(baseURL: string, getCredential: () => 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;
  /**
   * Sanitizes a request body for debug logging by masking sensitive fields.
   */
  private sanitizeBody;
  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
 */
/** Raw address response from the SignalWire Fabric API. */
interface GetAddressResponse {
  /** Unique address identifier. */
  id: string;
  /** Human-readable display name. */
  display_name: string;
  /** Resource name (used as a URI for dialing). */
  name: string;
  /** URL for an avatar or preview image. */
  preview_url?: string;
  /** URL for a cover image. */
  cover_url?: string;
  /** Underlying resource identifier. */
  resource_id: string;
  /** Type of the underlying resource. */
  type: ResourceType;
  /** Available communication channels for this address. */
  channels: {
    /** Audio-only channel URI. */
    audio?: string;
    /** Messaging channel URI. */
    messaging?: string;
    /** Video channel URI. */
    video?: string;
  };
  /** Whether the address resource is currently locked. */
  locked: boolean;
  /** ISO 8601 timestamp when the address was created. */
  created_at: string;
}
//#endregion
//#region src/core/types/crypto.types.d.ts
/** Parameters for creating an HTTP DPoP proof (for Prime API endpoints). */
interface DPoPHttpProofParams {
  /** HTTP method (e.g., "POST"). */
  readonly method: string;
  /** Request URI — should be the full URL per RFC 9449 (e.g., "https://fabric.signalwire.com/api/..."). */
  readonly uri: string;
  /** Access token to bind via `ath` claim (SHA-256 hash). Used for resource endpoints, not token endpoints. */
  readonly accessToken?: string;
}
/** Parameters for creating an RPC DPoP proof (for switchblade WebSocket methods). */
interface DPoPRpcProofParams {
  /** RPC method name (e.g., "signalwire.connect" or "signalwire.reauthenticate"). */
  readonly method: string;
}
/** SAT claims returned by /api/fabric/subscriber/info. */
interface SATClaims {
  /** Token scopes (e.g., ["sat:refresh"]). */
  scope?: string[];
  /** Confirmation claim binding the token to a key. */
  cnf?: {
    jkt: string;
  };
  /** Token expiry timestamp in seconds since epoch. */
  expires_at?: number;
}
//#endregion
//#region src/core/types/user.types.d.ts
/** Raw user profile response from the SignalWire Fabric API. */
interface GetUserInfoResponse {
  /** Unique user identifier. */
  id: string;
  /** User's email address. */
  email: string;
  /** User's first name. */
  first_name?: string;
  /** User's last name. */
  last_name?: string;
  /** User's display name. */
  display_name?: string;
  /** User's job title. */
  job_title?: string;
  /** User's time zone offset. */
  time_zone?: number;
  /** User's country. */
  country?: string;
  /** User's region or state. */
  region?: string;
  /** User's company name. */
  company_name?: string;
  /** Key for push notification delivery. */
  push_notification_key: string;
  /** Application-level settings for this user. */
  app_settings?: {
    /** Display name configured at the application level. */
    display_name: string;
    /** Permission scopes granted to this user. */
    scopes: string[];
  };
  /** Fabric addresses associated with this user. */
  fabric_addresses: GetAddressResponse[];
  /** Filtered SAT claims (scope, cnf, expires_at) returned when the token has special capabilities. */
  sat_claims?: SATClaims;
}
//#endregion
//#region src/core/entities/User.d.ts
/** User online presence state. */
type UserPresence = 'online' | 'offline' | 'busy';
/**
 * Authenticated user profile.
 *
 * Fetched automatically when a {@link SignalWire} connects.
 * Contains identity, contact, and organization details.
 */
declare class User extends Fetchable<GetUserInfoResponse> {
  /** Unique user identifier. */
  id: string;
  /** User 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 user. */
  addresses: GetAddressResponse[];
  /** Filtered SAT claims when the token has special capabilities (e.g., refresh scope). */
  satClaims?: SATClaims;
  constructor(http: HTTPRequestController);
  protected populateInstance(data: GetUserInfoResponse): void;
}
//#endregion
//#region src/core/types/call.types.d.ts
/** SDP role for the peer connection negotiation. */
type RTCPeerConnectionType = 'offer' | 'answer';
/** Purpose of the peer connection (primary call, screen share, or additional device). */
type RTCPeerConnectionPropose = 'main' | 'screenshare' | 'additional-device';
/** States during call connection establishment. */
type CallConnectStates = 'connecting' | 'connected';
/** Lifecycle states of the signaling protocol for a call. */
type SignalingCallStates = 'created' | 'ringing' | 'answered' | 'ending' | 'ended';
/** Whether the call is inbound (received) or outbound (initiated). */
type CallDirection = 'inbound' | 'outbound';
/** Playback state of media being played into a call. */
type CallPlayState = 'playing' | 'paused' | 'finished';
/** Common parameters shared by all call device types. */
interface CallDeviceCommonParams {
  /** Optional SIP headers to include in the call setup. */
  headers?: unknown[];
}
/** Parameters for a WebRTC or SIP call device. */
interface CallDeviceWebRTCOrSIPParams extends CallDeviceCommonParams {
  /** Source address or URI for the call. */
  from: string;
  /** Destination address or URI for the call. */
  to: string;
}
/** Parameters for a phone (PSTN) call device. */
interface CallDevicePhoneParams extends CallDeviceCommonParams {
  /** Caller phone number (E.164 format). */
  from_number: string;
  /** Destination phone number (E.164 format). */
  to_number: string;
}
/** A WebRTC or SIP call device descriptor. */
interface CallDeviceWebRTCOrSIP {
  /** Transport type for the device. */
  type: 'webrtc' | 'sip';
  /** Connection parameters for the device. */
  params: CallDeviceWebRTCOrSIPParams;
}
/** A phone (PSTN) call device descriptor. */
interface CallDevicePhone {
  /** Transport type for the device. */
  type: 'phone';
  /** Connection parameters for the device. */
  params: CallDevicePhoneParams;
}
/** Discriminated union of call device types (WebRTC, SIP, or phone). */
type CallDevice = CallDeviceWebRTCOrSIP | CallDevicePhone;
/**
 * Feature capability string that controls what actions a participant can perform.
 *
 * Capabilities are organized into categories:
 * - **self.\*** — Actions the local participant can perform on themselves (mute, deaf, volume, position, meta).
 * - **member.\*** — Actions that can be performed on other participants.
 * - **layout.\*** — Layout management for the video canvas.
 * - **digit.\*** — DTMF digit sending.
 * - **vmuted.\*** — Visibility control for muted video participants.
 * - **lock.\*** — Room lock/unlock control.
 * - **device** / **screenshare** — Device and screen share capabilities.
 * - **end** — Permission to end the call or room.
 */
type Capability = 'self' | 'self.mute' | 'self.mute.audio' | 'self.mute.audio.on' | 'self.mute.audio.off' | 'self.mute.video' | 'self.mute.video.on' | 'self.mute.video.off' | 'self.deaf' | 'self.deaf.on' | 'self.deaf.off' | 'self.microphone' | 'self.microphone.volume.set' | 'self.microphone.sensitivity.set' | 'self.speaker' | 'self.speaker.volume.set' | 'self.position.set' | 'self.meta' | 'self.audioflags.set' | 'member' | 'member.mute' | 'member.mute.audio' | 'member.mute.audio.on' | 'member.mute.audio.off' | 'member.mute.video' | 'member.mute.video.on' | 'member.mute.video.off' | 'member.deaf' | 'member.deaf.on' | 'member.deaf.off' | 'member.microphone' | 'member.microphone.volume.set' | 'member.microphone.sensitivity.set' | 'member.speaker' | 'member.speaker.volume.set' | 'member.position.set' | 'member.meta' | 'member.audioflags.set' | 'layout' | 'layout.set' | 'digit' | 'digit.send' | 'vmuted' | 'vmuted.hide' | 'vmuted.hide.on' | 'vmuted.hide.off' | 'lock' | 'lock.on' | 'lock.off' | 'device' | 'screenshare' | 'end';
/**
 * Position of a participant's video within the layout canvas.
 *
 * - `'auto'` — Automatically positioned by the layout engine.
 * - `` `reserved-${number}` `` — A reserved slot in the layout (e.g., `'reserved-0'`).
 * - `` `standard-${number}` `` — A standard slot in the layout (e.g., `'standard-1'`).
 * - `'off-canvas'` — Participant is not visible in the layout.
 * - `'playback'` — Playback position for media streams.
 * - `'full-screen'` — Participant occupies the entire canvas.
 */
type VideoPosition = 'auto' | `reserved-${number}` | `standard-${number}` | 'off-canvas' | 'playback' | 'full-screen';
//#endregion
//#region src/core/RPCMessages/types/common.d.ts
interface MemberTarget {
  member_id: string;
  call_id: string;
  node_id: string;
}
interface Member {
  room_session_id: string;
  room_id: string;
  member_id: string;
  call_id: string;
  name: string;
  type: 'member' | 'screen' | 'device' | (string & {});
  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;
}
//#endregion
//#region src/core/RPCMessages/types/verto.d.ts
interface VertoParams {
  userVariables?: Record<string, unknown>;
}
//#endregion
//#region src/core/RPCMessages/types/events.d.ts
interface SignalwireAuthorizationStatePayload {
  authorization_state: string;
}
interface WebrtcMessagePayload {
  jsonrpc: '2.0';
  id: number;
  method: string;
  params: VertoParams;
}
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 RoomUpdatedPayload {
  room_session: RoomSession;
  room_id: string;
  room_session_id: string;
}
/**
 * Describes the peer (remote) call referenced from a call.state event.
 *
 * Mirrors the backend (relay.c) `peer` shape.
 */
interface CallStateRelatedCall {
  call_id?: string;
  node_id?: string;
}
interface CallStatePayload {
  call_id: string;
  node_id: string;
  segment_id: string;
  call_state: SignalingCallStates;
  direction: CallDirection;
  device: CallDevice;
  /**
   * Epoch timestamps for the call lifecycle. Optional because pre-answer
   * states (e.g. `created`, `ringing`) do not have an `answer_time`/`end_time`
   * and the backend reports them as `0` or omits them.
   */
  start_time?: number;
  answer_time?: number;
  end_time?: number;
  room_session_id: string;
  /** The peer (remote) call this call is connected to, if any. */
  peer?: CallStateRelatedCall;
  /** Application-defined tag associated with the call. */
  tag?: 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;
}
//#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?;
  hasMore$: Observable<boolean>;
  private collectionData;
  private observablesRegistry;
  private upsertData;
  private _loading$;
  private _values$;
  private _hasMore$;
  constructor(fetchController: FetchController<T>, update$: Observable<Partial<T>>, onError?: ((error: Error) => void) | undefined);
  get loading$(): Observable<boolean>;
  get loading(): boolean;
  get values$(): Observable<T[]>;
  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;
  private _values$?;
  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/core/entities/types/participant.types.d.ts
/** Options for selecting a media device. */
interface SelectDeviceOptions {
  savePreference?: boolean;
}
//#endregion
//#region src/controllers/RTCStatsMonitor.d.ts
interface NetworkIssue {
  type: 'no_inbound_audio' | 'no_inbound_video' | 'high_rtt' | 'high_packet_loss' | 'high_jitter' | 'ice_disconnected';
  severity: 'warning' | 'critical';
  timestamp: number;
  value?: number;
  threshold?: number;
}
interface NetworkMetrics {
  timestamp: number;
  audio: {
    packetsReceived: number;
    packetsLost: number;
    jitter: number;
  };
  video: {
    packetsReceived: number;
    packetsLost: number;
  };
  roundTripTime: number;
  availableOutgoingBitrate?: number;
}
//#endregion
//#region src/managers/types/verto-manager.types.d.ts
type ScreenShareStatus = 'none' | 'starting' | 'started' | 'stopping';
type SignalingStatus = Extract<CallStatus, 'trying' | 'ringing' | 'connecting' | 'connected' | 'disconnected' | 'failed'>;
interface TransferOptions {
  destination: string;
}
//#endregion
//#region src/core/errors.d.ts
declare class UnexpectedError extends Error {
  at?: string | undefined;
  constructor(at?: string | undefined, options?: ErrorOptions);
}
declare class InvalidCredentialsError extends Error {
  reason: string;
  constructor(reason?: string, options?: ErrorOptions);
}
/**
 * Semantic category of a call-lifecycle error.
 *
 * - `'media'`     – RTCPeerConnection / media device failure
 * - `'signaling'` – Verto / JSON-RPC protocol error
 * - `'timeout'`   – Call setup timed out waiting for a response
 * - `'rejected'`  – Remote side rejected the call
 * - `'network'`   – Transport lost during an active call
 * - `'internal'`  – Unexpected / unknown error
 */
type CallErrorKind = 'media' | 'signaling' | 'timeout' | 'rejected' | 'network' | 'internal';
/**
 * Structured error emitted on `call.errors$`.
 *
 * Provides actionable metadata so consumers can react without
 * resorting to `instanceof` checks on raw `Error` objects.
 */
interface CallError {
  /** Semantic category of the error. */
  readonly kind: CallErrorKind;
  /**
   * Whether the error terminates the call.
   * When `true`, the call will automatically transition to `'failed'`
   * and be destroyed — no further action is needed from the consumer.
   */
  readonly fatal: boolean;
  /** The underlying error. */
  readonly error: Error;
  /** ID of the call that produced this error. */
  readonly callId: string;
  /**
   * Which peer connection failed. Auxiliary legs are never fatal, so a consumer
   * can surface "screen share failed, call continues". Absent for call- and
   * session-level errors.
   */
  readonly leg?: RTCPeerConnectionPropose;
  /** `callId` is always the call's id, never the leg's. Use this for the leg. */
  readonly legId?: string;
}
declare class CallCreateError extends Error {
  message: string;
  error: unknown;
  direction: 'inbound' | 'outbound';
  constructor(message: string, error?: unknown, direction?: 'inbound' | 'outbound', options?: ErrorOptions);
}
declare class CallNotReadyError extends Error {
  callId: string;
  constructor(callId: string, options?: ErrorOptions);
}
declare class ParticipantNotReadyError extends Error {
  memberId: string;
  constructor(memberId: string, 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);
}
/**
 * An auxiliary leg did not connect within its budget. Typed rather than a bare
 * RxJS `TimeoutError` so the leg and cause survive.
 */
declare class AuxiliaryLegTimeoutError extends Error {
  readonly leg: RTCPeerConnectionPropose;
  readonly originalError?: Error | undefined;
  constructor(leg: RTCPeerConnectionPropose, originalError?: Error | undefined);
}
/**
 * An auxiliary leg was removed before it finished connecting.
 *
 * Typed rather than a bare resolve so a caller awaiting the start can tell a
 * cancel apart from a share that actually came up — the public methods return
 * `void`, so the promise is the only signal they have.
 */
declare class AuxiliaryLegCancelledError extends Error {
  readonly leg: RTCPeerConnectionPropose;
  constructor(leg: RTCPeerConnectionPropose);
}
declare class MediaTrackError extends Error {
  operation: string;
  kind: string;
  originalError: unknown;
  constructor(operation: string, kind: string, originalError: unknown);
}
/**
 * Failure to acquire local media (camera, microphone, or screen capture)
 * via `getUserMedia`/`getDisplayMedia`.
 *
 * Non-fatal by default: screenshare and additional-device failures never
 * end the call, and main-connection failures degrade to receive-only when
 * possible. The wrapping site sets `fatal` to `true` only when the call
 * cannot continue (receive-only fallback disabled or no receive intent).
 */
declare class MediaAccessError extends Error {
  /** The SDK operation that failed, e.g. `'acquireLocalMedia'`, `'startScreenShare'`, `'addInputDevice'`. */
  operation: string;
  /** The media being acquired: `'audio' | 'video' | 'audiovideo' | 'screen'`. */
  media: string;
  /** The raw `getUserMedia`/`getDisplayMedia` error (typically a `DOMException`). */
  originalError: unknown;
  /** Whether this failure terminates the call. */
  readonly fatal: boolean;
  constructor(/** The SDK operation that failed, e.g. `'acquireLocalMedia'`, `'startScreenShare'`, `'addInputDevice'`. */
  operation: string, /** The media being acquired: `'audio' | 'video' | 'audiovideo' | 'screen'`. */
  media: string, /** The raw `getUserMedia`/`getDisplayMedia` error (typically a `DOMException`). */
  originalError: unknown, /** Whether this failure terminates the call. */
  fatal?: boolean);
  /** True when the underlying failure is a permission denial (user or policy). */
  get denied(): boolean;
}
/**
 * Thrown by `startScreenShare()` when the call is already sharing a screen.
 *
 * A call carries at most one screen share. Accepting a second one would
 * overwrite the only reference the SDK holds to the first, leaving it
 * capturing and sending with no way to stop it — so the second request is
 * rejected and the live share is left untouched. Call `stopScreenShare()`
 * first to replace it.
 */
declare class ScreenShareAlreadyActiveError extends Error {
  /** Id of the screen share leg that is already active. */
  readonly screenShareId: string;
  constructor(/** Id of the screen share leg that is already active. */
  screenShareId: string, options?: ErrorOptions);
}
declare class DPoPInitError extends Error {
  originalError: unknown;
  constructor(originalError: unknown, message?: string);
}
/**
 * Error thrown when a recovery attempt fails.
 *
 * Carries the recovery action and attempt number for diagnostic purposes.
 */
declare class RecoveryError extends Error {
  action: string;
  attempt: number;
  originalError?: unknown | undefined;
  constructor(action: string, attempt: number, originalError?: unknown | undefined);
}
/**
 * Error thrown when getUserMedia fails with OverconstrainedError
 * and all fallback levels have been exhausted.
 */
declare class OverconstrainedFallbackError extends Error {
  deviceKind: string;
  originalError?: unknown | undefined;
  constructor(deviceKind: string, originalError?: unknown | undefined);
}
/**
 * Error thrown when the preflight connectivity test fails.
 */
declare class PreflightError extends Error {
  phase: string;
  originalError?: unknown | undefined;
  constructor(phase: string, originalError?: unknown | undefined);
}
declare class DeviceTokenError extends Error {
  originalError?: unknown | undefined;
  constructor(message: string, originalError?: unknown | undefined);
}
declare class TokenRefreshError extends Error {
  originalError?: unknown | undefined;
  constructor(message: string, originalError?: unknown | undefined);
}
//#endregion
//#region src/core/types/resilience.types.d.ts
/**
 * Types for SDK resilience, recovery, diagnostics, and quality monitoring.
 *
 * These types support:
 * - WebRTC stats monitoring (Section 1)
 * - Tiered recovery system (Section 2)
 * - Device recovery events (Section 5)
 * - Tab visibility handling (Section 4)
 * - Audio/video constraint management (Section 16)
 * - Network resilience & recovery pipeline (Section 19)
 * - Preflight connectivity test (Section 20)
 * - Call quality score (Section 21)
 * - Graceful degradation (Section 22)
 * - Platform capability detection (Section 24)
 * - Structured diagnostic log export (Section 26)
 */
/** Simplified quality level for UI indicators, derived from MOS score. */
type QualityLevel = 'excellent' | 'good' | 'fair' | 'poor' | 'critical';
/**
 * Extended call status that includes the 'recovering' state.
 *
 * Used when the SDK is attempting to recover a call after a network
 * disruption or media failure.
 */
type ResilienceCallStatus = 'new' | 'trying' | 'ringing' | 'connecting' | 'connected' | 'recovering' | 'disconnecting' | 'disconnected' | 'failed' | 'destroyed';
type NetworkMetrics$1 = NetworkMetrics;
/** Event emitted when a recovery action is taken on a call. */
interface RecoveryEvent {
  /** The recovery action that was taken. */
  readonly action: 'keyframe_requested' | 'reinvite_started' | 'reinvite_succeeded' | 'reinvite_failed' | 'reinvite_timeout' | 'max_attempts_reached' | 'call_recovering' | 'call_recovered' | 'call_recovery_failed' | 'signal_reconnect' | 'full_reconnect' | 'video_disabled' | 'video_restored';
  /** Human-readable description of why recovery was triggered. */
  readonly reason: string;
  /** Current attempt number (for multi-attempt recoveries). */
  readonly attempt?: number;
  /** Maximum number of attempts allowed. */
  readonly maxAttempts?: number;
  /** Timestamp when the event occurred (epoch ms). */
  readonly timestamp: number;
}
/** State of the recovery pipeline state machine (Section 19.7). */
type RecoveryState = 'idle' | 'debouncing' | 'recovering' | 'cooldown';
/** Event emitted when the SDK auto-switches a device. */
interface DeviceRecoveryEvent {
  /** The kind of device that was switched. */
  readonly kind: 'audioinput' | 'audiooutput' | 'videoinput';
  /** The device that was previously selected (null if none). */
  readonly previousDevice: MediaDeviceInfo | null;
  /** The device that was selected as a replacement (null if none available). */
  readonly newDevice: MediaDeviceInfo | null;
  /** The reason for the device switch. */
  readonly reason: 'device_disconnected' | 'device_reconnected' | 'session_restored' | 'fallback_to_default' | 'default_changed' | 'ambiguous_match';
}
/**
 * Serializable subset of MediaDeviceInfo for persistence.
 *
 * The browser's MediaDeviceInfo interface is not serializable.
 * This stores the fields needed for device recovery across sessions.
 */
interface StoredDevicePreference {
  /** The device ID. */
  readonly deviceId: string;
  /** The human-readable label. */
  readonly label: string;
  /** The device kind. */
  readonly kind: MediaDeviceKind;
  /** The group ID (identifies the physical device). */
  readonly groupId: string;
}
/** Result of a media permissions request (Section 5.10). */
interface PermissionResult {
  /** Whether audio permission was granted. */
  readonly audio: boolean;
  /** Whether video permission was granted. */
  readonly video: boolean;
  /** The audio device the user selected in the browser picker, if any. */
  readonly selectedAudioDevice?: MediaDeviceInfo;
  /** The video device the user selected in the browser picker, if any. */
  readonly selectedVideoDevice?: MediaDeviceInfo;
}
/** Event emitted when getUserMedia falls back to looser constraints. */
interface ConstraintFallbackEvent {
  /** The kind of input device. */
  readonly kind: 'audioinput' | 'videoinput';
  /** The device that was originally requested. */
  readonly requestedDevice: MediaDeviceInfo | null;
  /** The device that the browser actually provided. */
  readonly actualDevice: MediaDeviceInfo | null;
  /** The constraint level that succeeded. */
  readonly fallbackLevel: 'exact' | 'preferred' | 'default';
}
/** Browser/platform WebRTC capability flags. */
interface PlatformCapabilities {
  /** Whether screen sharing is supported. */
  readonly screenShare: boolean;
  /** Whether screen share can include system audio (Chrome-only). */
  readonly screenShareAudio: boolean;
  /** Whether simulcast is supported. */
  readonly simulcast: boolean;
  /** Whether insertable streams / encoded transforms are available. */
  readonly insertableStreams: boolean;
  /** Whether setSinkId (audio output selection) is supported. */
  readonly audioOutputSelection: boolean;
  /** List of supported video codecs. */
  readonly videoCodecs: readonly string[];
  /** List of supported audio codecs. */
  readonly audioCodecs: readonly string[];
  /** Whether the browser supports WebRTC at all. */
  readonly webrtc: boolean;
  /** Whether getUserMedia is available. */
  readonly getUserMedia: boolean;
  /** Whether getDisplayMedia is available. */
  readonly getDisplayMedia: boolean;
}
/** Options for the preflight connectivity test. */
interface PreflightOptions {
  /** How long to run the media test in seconds (default: 10). */
  readonly duration?: number;
  /** Skip the media/bandwidth test, only test signaling + TURN + devices. */
  readonly skipMediaTest?: boolean;
  /** Test a specific audio device instead of the currently selected one. */
  readonly audioDevice?: MediaDeviceInfo;
  /** Test a specific video device instead of the currently selected one. */
  readonly videoDevice?: MediaDeviceInfo;
}
/** Results of a preflight connectivity test. */
interface PreflightResult {
  /** Overall pass/fail. */
  readonly ok: boolean;
  /** Signaling server reachability. */
  readonly signaling: {
    readonly reachable: boolean;
    readonly rttMs: number;
  };
  /** ICE/TURN connectivity. */
  readonly connectivity: {
    /** 'direct' = host/srflx worked, 'relay' = only TURN relay, 'failed' = nothing. */
    readonly type: 'direct' | 'relay' | 'failed';
    /** Whether TURN servers are reachable. */
    readonly turnReachable: boolean;
    /** Whether STUN servers are reachable. */
    readonly stunReachable: boolean;
    /** RTT to media server in ms. */
    readonly rttMs: number;
  };
  /** Bandwidth estimation (null if skipMediaTest). */
  readonly bandwidth: {
    readonly uploadKbps: number;
    readonly downloadKbps: number;
  } | null;
  /** Device test results. */
  readonly devices: {
    readonly audioInput: {
      readonly working: boolean;
      readonly device: MediaDeviceInfo | null;
    };
    readonly videoInput: {
      readonly working: boolean;
      readonly device: MediaDeviceInfo | null;
    };
    readonly audioOutput: {
      readonly available: boolean;
      readonly device: MediaDeviceInfo | null;
    };
  };
  /** Human-readable warnings. */
  readonly warnings: readonly string[];
}
/** Event emitted when audio constraints change on a call. */
interface AudioConstraintsEvent {
  /** The new constraints applied. */
  readonly constraints: MediaTrackConstraints;
  /** How the constraints were applied. */
  readonly method: 'applyConstraints' | 'trackReplacement';
  /** Timestamp when the event occurred (epoch ms). */
  readonly timestamp: number;
}
/** Event emitted when the server pushes media params. */
interface MediaParamsEvent {
  /** Audio constraints pushed by the server, if any. */
  readonly audio?: MediaTrackConstraints;
  /** Video constraints pushed by the server, if any. */
  readonly video?: MediaTrackConstraints;
  /** Timestamp when the event occurred (epoch ms). */
  readonly timestamp: number;
  /**
   * `false` when the constraints did not reach every sender of a pushed kind:
   * the sender carries media the SDK did not capture, the browser refused the
   * constraints and re-acquisition failed, or the leg sends no media of that
   * kind at all. The event is emitted whether or not they were applied, but a
   * push naming a leg this call does not hold emits nothing at all — the event
   * carries no leg identity to report it against.
   */
  readonly applied: boolean;
}
/** Structured diagnostic bundle for a session. */
interface SessionDiagnostics {
  /** SDK version. */
  readonly sdkVersion: string;
  /** Browser/platform user agent string. */
  readonly userAgent: string;
  /** Platform capabilities detected at construction time. */
  readonly capabilities: PlatformCapabilities;
  /** Timeline of significant events during the session. */
  readonly events: readonly DiagnosticEvent[];
  /** Quality summary per call. */
  readonly calls: readonly CallDiagnosticSummary[];
  /** Device changes that occurred during the session. */
  readonly deviceChanges: readonly DeviceRecoveryEvent[];
  /** Current device list snapshot. */
  readonly devices: {
    readonly audioInput: readonly MediaDeviceInfo[];
    readonly audioOutput: readonly MediaDeviceInfo[];
    readonly videoInput: readonly MediaDeviceInfo[];
  };
}
/** A single diagnostic event in the session timeline. */
interface DiagnosticEvent {
  /** Timestamp when the event occurred (epoch ms). */
  readonly timestamp: number;
  /** Category of the event. */
  readonly category: 'connection' | 'call' | 'device' | 'recovery' | 'error';
  /** Event description string. */
  readonly event: string;
  /** Additional details about the event. */
  readonly details?: Readonly<Record<string, unknown>>;
}
/** Quality summary for a single call in the diagnostic bundle. */
interface CallDiagnosticSummary {
  /** Unique call ID. */
  readonly callId: string;
  /** Whether the call was inbound or outbound. */
  readonly direction: 'inbound' | 'outbound';
  /** The destination dialed, if outbound. */
  readonly destination?: string;
  /** Total call duration in seconds. */
  readonly duration: number;
  /** Final call status. */
  readonly status: string;
  /** Average MOS quality score over the call. */
  readonly avgQualityScore: number;
  /** Worst (minimum) MOS quality score during the call. */
  readonly minQualityScore: number;
  /** Number of recovery attempts made during the call. */
  readonly recoveryAttempts: number;
  /** ICE candidate types that were used. */
  readonly iceCandidateTypes: readonly string[];
  /** Final network metrics snapshot at call end. */
  readonly finalMetrics: NetworkMetrics$1;
}
//#endregion
//#region src/core/RPCMessages/RPCConnect.d.ts
interface Authorization {
  jti: string;
  project_id: string;
  data_zone?: string;
  scope?: string[];
  fabric_subscriber: {
    version: number;
    expires_at: number;
    subscriber_id: string;
    application_id: string | null;
    project_id: string;
    space_id: string;
  };
  cnf?: {
    jkt: 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;
  readonly denoise: boolean;
  readonly lowbitrate: 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/interfaces/DeviceController.d.ts
/**
 * Interface for media device management.
 *
 * Provides reactive access to available media devices, device selection,
 * and monitoring for device changes (connect/disconnect).
 */
interface DeviceController {
  /** Observable list of available audio input (microphone) devices. */
  readonly audioInputDevices$: Observable<MediaDeviceInfo[]>;
  /** Observable list of available audio output (speaker) devices. */
  readonly audioOutputDevices$: Observable<MediaDeviceInfo[]>;
  /** Observable list of available video input (camera) devices. */
  readonly videoInputDevices$: Observable<MediaDeviceInfo[]>;
  /** Observable of the currently selected audio input device, or `null` if none. */
  readonly selectedAudioInputDevice$: Observable<MediaDeviceInfo | null>;
  /** Observable of the currently selected audio output device, or `null` if none. */
  readonly selectedAudioOutputDevice$: Observable<MediaDeviceInfo | null>;
  /** Observable of the currently selected video input device, or `null` if none. */
  readonly selectedVideoInputDevice$: Observable<MediaDeviceInfo | null>;
  /** Currently selected audio input device, or `null` if none. */
  readonly selectedAudioInputDevice: MediaDeviceInfo | null;
  /** Currently selected audio output device, or `null` if none. */
  readonly selectedAudioOutputDevice: MediaDeviceInfo | null;
  /** Currently selected video input device, or `null` if none. */
  readonly selectedVideoInputDevice: MediaDeviceInfo | null;
  /** Current snapshot of available audio input devices. */
  readonly audioInputDevices: MediaDeviceInfo[];
  /** Current snapshot of available audio output devices. */
  readonly audioOutputDevices: MediaDeviceInfo[];
  /** Current snapshot of available video input devices. */
  readonly videoInputDevices: MediaDeviceInfo[];
  /** Media track constraints for the selected audio input device. Returns `false` when disabled. */
  readonly selectedAudioInputDeviceConstraints: MediaTrackConstraints | boolean;
  /** Media track constraints for the selected video input device. Returns `false` when disabled. */
  readonly selectedVideoInputDeviceConstraints: MediaTrackConstraints | boolean;
  /**
   * Converts a {@link MediaDeviceInfo} to track constraints suitable for `getUserMedia`.
   * @param deviceInfo - The device to convert, or `null` for default constraints.
   */
  deviceInfoToConstraints(deviceInfo: MediaDeviceInfo | null): MediaTrackConstraints;
  /**
   * Sets the preferred audio input device for future calls.
   * @param device - The device to select, or `null` to use the system default.
   */
  selectAudioInputDevice(device: MediaDeviceInfo | null): void;
  /**
   * Sets the preferred video input device for future calls.
   * @param device - The device to select, or `null` to use the system default.
   */
  selectVideoInputDevice(device: MediaDeviceInfo | null): void;
  /**
   * Sets the preferred audio output device for future calls.
   * @param device - The device to select, or `null` to use the system default.
   */
  selectAudioOutputDevice(device: MediaDeviceInfo | null): void;
  /** Starts monitoring for media device changes (connect/disconnect). */
  enableDeviceMonitoring(): void;
  /** Stops monitoring for media device changes. */
  disableDeviceMonitoring(): void;
  /**
   * Returns the capabilities of a media device.
   * @param deviceInfo - The device to query.
   * @returns The device capabilities, or `null` if unavailable.
   */
  getDeviceCapabilities(deviceInfo: MediaDeviceInfo): Promise<MediaTrackCapabilities | null>;
  /**
   * Checks whether a device is still available and usable.
   * @param deviceInfo - The device to validate, or `null`.
   * @returns `true` if the device is valid and available. Returns `false` for `null`, audio output devices, or unavailable devices.
   */
  isValidDevice(deviceInfo: MediaDeviceInfo | null): Promise<boolean>;
  /** Observable stream of errors from device enumeration and monitoring. */
  readonly errors$: Observable<Error>;
  /**
   * Observable that emits when the SDK auto-switches a device due to
   * disconnect, reconnect, or recovery.
   */
  readonly deviceRecovered$: Observable<DeviceRecoveryEvent>;
  /** Disables audio input (receive-only mode). No track will be acquired. */
  disableAudioInput(): void;
  /** Re-enables audio input, restoring the last selection or auto-selecting. */
  enableAudioInput(): void;
  /** Disables video input (receive-only mode). No track will be acquired. */
  disableVideoInput(): void;
  /** Re-enables video input, restoring the last selection or auto-selecting. */
  enableVideoInput(): void;
  /** Observable that emits `true` when video input is disabled (receive-only). */
  readonly videoInputDisabled$: Observable<boolean>;
  /** Observable that emits `true` when audio input is disabled (receive-only). */
  readonly audioInputDisabled$: Observable<boolean>;
  /** Whether video input is currently disabled. */
  readonly videoInputDisabled: boolean;
  /** Whether audio input is currently disabled. */
  readonly audioInputDisabled: boolean;
  /** Injects the storage manager for device persistence. */
  setStorageManager(storageManager: StorageManager): void;
  /** Clears all device state (history, selections, persisted prefs) and re-enumerates. */
  clearDeviceState(): Promise<void>;
  /** Force a device re-enumeration. */
  enumerateDevices(): Promise<void>;
}
//#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(options?: ScreenShareOptions): 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<boolean>;
  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 | MemberTarget, 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 {
  private callExecuteMethod;
  protected deviceController: DeviceController;
  /** Unique member ID of this participant. */
  readonly id: string;
  private _state$;
  constructor(id: string, callExecuteMethod: ExecuteMethod, deviceController: DeviceController);
  /** @internal */
  upnext(data: Partial<ParticipantState>): void;
  /** Observable of the participant's display name. */
  get name$(): Observable<string | undefined>;
  /** Observable of the participant type (e.g. `'member'`, `'screen'`). */
  get type$(): Observable<string | undefined>;
  /** Observable indicating whether the participant has raised their hand. */
  get handraised$(): Observable<boolean | undefined>;
  /** Observable indicating whether the participant is visible in the layout. */
  get visible$(): Observable<boolean | undefined>;
  /** Observable indicating whether the participant's audio is muted. */
  get audioMuted$(): Observable<boolean | undefined>;
  /** Observable indicating whether the participant's video is muted. */
  get videoMuted$(): Observable<boolean | undefined>;
  /** Observable indicating whether the participant is deafened. */
  get deaf$(): Observable<boolean | undefined>;
  /**
   * Observable of the participant's **server-side** microphone input volume
   * as reported by the mix engine. This is gain applied on the bridged audio
   * leg (FreeSWITCH channel read volume), NOT the local browser mic. For a
   * local PC mic control, see {@link Call.setLocalMicrophoneGain}.
   *
   * @see {@link setAudioInputVolume}
   */
  get inputVolume$(): Observable<number | undefined>;
  /**
   * Observable of the participant's **server-side** speaker output volume as
   * reported by the mix engine (FreeSWITCH channel write volume). NOT the
   * local HTML `<audio>` element volume — set that on your own element.
   *
   * @see {@link setAudioOutputVolume}
   */
  get outputVolume$(): Observable<number | undefined>;
  /**
   * Observable of the **conference-only** microphone energy/gate sensitivity
   * level for this member. Routes through the conferencing mix engine and has
   * no effect on 1:1 WebRTC calls. Populated from `member.updated` events for
   * conference members.
   *
   * @see {@link setAudioInputSensitivity}
   */
  get inputSensitivity$(): Observable<number | undefined>;
  /** Observable indicating whether echo cancellation is enabled. */
  get echoCancellation$(): Observable<boolean | undefined>;
  /** Observable indicating whether auto-gain control is enabled. */
  get autoGain$(): Observable<boolean | undefined>;
  /** Observable indicating whether noise suppression is enabled. */
  get noiseSuppression$(): Observable<boolean | undefined>;
  /** Observable indicating whether low-bitrate mode is active. */
  get lowbitrate$(): Observable<boolean | undefined>;
  /** Observable indicating whether noise reduction is active. */
  get denoise$(): Observable<boolean | undefined>;
  /** Observable of custom metadata for this participant. */
  get meta$(): Observable<Record<string, unknown> | undefined>;
  /** Observable of the participant's user ID. */
  get userId$(): Observable<string | undefined>;
  /** Observable of the participant's address ID. */
  get addressId$(): Observable<string | undefined>;
  /** Observable of the server node ID for this participant. */
  get nodeId$(): Observable<string | undefined>;
  /** Observable indicating whether the participant is currently speaking. */
  get isTalking$(): Observable<boolean | undefined>;
  /** 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;
  /** Whether the participant has raised their hand. */
  get handraised(): boolean;
  /** Whether the participant is visible in the layout. */
  get visible(): boolean;
  /** Whether the participant's audio is muted. */
  get audioMuted(): boolean;
  /** Whether the participant's video is muted. */
  get videoMuted(): boolean;
  /** Whether the participant is deafened (incoming audio muted). */
  get deaf(): boolean;
  /**
   * Current **server-side** microphone input volume as reported by the mix
   * engine, or `undefined` if not set. Not the local PC mic — see
   * {@link Call.setLocalMicrophoneGain} for browser-side control.
   */
  get inputVolume(): number | undefined;
  /**
   * Current **server-side** speaker output volume from the mix engine, or
   * `undefined` if not set. Not the local `<audio>` element volume.
   */
  get outputVolume(): number | undefined;
  /**
   * Current **conference-only** microphone sensitivity/gate level, or
   * `undefined` if not set. Applies only to conference members.
   */
  get inputSensitivity(): number | undefined;
  /** Whether echo cancellation is enabled. */
  get echoCancellation(): boolean;
  /** Whether automatic gain control is enabled. */
  get autoGain(): boolean;
  /** Whether noise suppression is enabled. */
  get noiseSuppression(): boolean;
  /** Whether low-bitrate mode is active. */
  get lowbitrate(): boolean;
  /** Whether noise reduction (denoise) is active. */
  get denoise(): boolean;
  /** Custom metadata for this participant, or `undefined` if not set. */
  get meta(): Record<string, unknown> | undefined;
  /** User ID of this participant, or `undefined` if not available. */
  get userId(): string | undefined;
  /** Address ID of this participant, or `undefined` if not available. */
  get addressId(): string | undefined;
  /** Server node ID for this participant, or `undefined` if not available. */
  get nodeId(): string | undefined;
  /** Call ID for this participant's leg, or `undefined` if not available. */
  get callId(): string | undefined;
  /** @internal */
  get value(): Partial<Member>;
  /**
   * Target triple for member RPCs, built from the participant's own state.
   * The backend locates the member's session by the target `call_id`/`node_id`,
   * so this must always be the participant's own call context — never the
   * local call's id (issue #19400).
   *
   * Reading it doubles as a readiness probe: it throws until the first full
   * member event (`member.joined`/`member.updated` or the `call.joined`
   * roster) arrives, and never regresses afterwards.
   *
   * @throws {ParticipantNotReadyError} If the member state has not been
   * received yet (e.g. a participant first seen via `member.talking`) — an
   * empty call context can never address the member, so fail fast instead of
   * sending a doomed RPC.
   */
  get target(): MemberTarget;
  /**
   * Executes a member RPC against this participant, injecting its own
   * {@link target} as the target.
   *
   * @throws {ParticipantNotReadyError} Via {@link target}, when the
   * member state has not been received yet.
   */
  protected executeMethod(method: string, args: Record<string, unknown>): Promise<JSONRPCResponse>;
  /** 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>;
  /** Toggles low-bitrate mode for this participant's media. */
  toggleLowbitrate(): Promise<void>;
  /**
   * Adjusts the **conference-only** microphone energy gate / sensitivity level
   * for this member. Routes through the conferencing mix engine
   * (`signalwire.conferencing member.set_input_sensitivity`) and has no effect
   * on 1:1 WebRTC calls — for those, use browser audio constraints via
   * {@link Call.setNoiseSuppression} / {@link Call.setAutoGainControl}.
   *
   * This is **not** a local PC mic gain control; it only changes how the
   * server-side mixer decides to open the mic gate on this participant.
   *
   * @param value - Sensitivity level as understood by the conference engine
   *   (integer, larger values are more sensitive).
   */
  setAudioInputSensitivity(value: number): Promise<void>;
  /**
   * Sets the **server-side** microphone volume on this participant's bridged
   * call leg. Applies a multiplier to the audio flowing through the mix
   * engine (FreeSWITCH channel read volume) — changes what other participants
   * hear, not what the local browser captures.
   *
   * For local PC mic gain, use {@link Call.setLocalMicrophoneGain} instead.
   *
   * @param value - Volume level (0-100).
   */
  setAudioInputVolume(value: number): Promise<void>;
  /**
   * Sets the **server-side** speaker volume on this participant's bridged call
   * leg (FreeSWITCH channel write volume) — what this participant hears from
   * the mix before it reaches their client.
   *
   * For local playback volume (the `<audio>` element the consumer attaches
   * `remoteStream` to), set `audioElement.volume` directly in the consumer's
   * code.
   *
   * @param value - Volume level (0-100).
   */
  setAudioOutputVolume(value: number): Promise<void>;
  /**
   * Sets the participant's position in the video layout.
   *
   * Requires the `member.position` capability. The gateway requires a
   * `targets` array of `{ target, position }` entries (issue #19400). A
   * resolved promise does not guarantee a visible change: the backend silently
   * returns `200` (no-op) for non-conference targets.
   *
   * @param value - The {@link VideoPosition} to assign (e.g. `'auto'`, `'reserved-0'`).
   */
  setPosition(value: VideoPosition): Promise<void>;
  /** Removes this participant from the call. */
  remove(): Promise<void>;
  /** Ends the call for this participant. */
  end(): Promise<void>;
  /**
   * Replaces custom metadata for this participant.
   * @param _meta - Metadata object to set.
   * @throws {UnimplementedError} Not yet implemented.
   */
  setMeta(_meta: Record<string, unknown>): Promise<void>;
  /**
   * Merges values into custom metadata (unlike {@link setMeta} which replaces).
   * @param _meta - Metadata to merge.
   * @throws {UnimplementedError} Not yet implemented.
   */
  updateMeta(_meta: Record<string, unknown>): Promise<void>;
  /** Destroys the participant, releasing all subscriptions and references. */
  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;
  /**
   * Studio audio mode state. When enabled, all audio processing
   * (echo cancellation, noise suppression, auto gain control) is disabled
   * to provide raw/unprocessed audio for musicians, podcasters, etc.
   */
  private _studioAudio$;
  /** @internal */
  constructor(id: string, callExecuteMethod: ExecuteMethod, vertoManager: VertoManager, deviceController: DeviceController);
  destroy(): void;
  /** Observable indicating whether studio audio (raw/unprocessed audio) mode is enabled. */
  get studioAudio$(): Observable<boolean>;
  /** Whether studio audio (raw/unprocessed audio) mode is currently enabled. */
  get studioAudio(): boolean;
  /**
   * Enables studio audio mode by disabling all audio processing.
   * Sets echoCancellation, noiseSuppression, and autoGainControl to false.
   */
  enableStudioAudio(): Promise<void>;
  /**
   * Disables studio audio mode by restoring all audio processing to enabled.
   * Sets echoCancellation, noiseSuppression, and autoGainControl to true.
   */
  disableStudioAudio(): Promise<void>;
  /**
   * Starts sharing the local screen.
   *
   * A call carries at most one screen share. Read `screenShareStatus` before
   * calling and treat `'starting'`/`'stopping'` as busy.
   *
   * The call is unaffected when acquisition fails.
   *
   * @param options - Pass `{ audio: true }` to also request the shared
   * surface's audio. Defaults to video only.
   * @throws {ScreenShareAlreadyActiveError} When this call is already
   * sharing a screen. Call {@link stopScreenShare} before starting another.
   * @throws {AuxiliaryLegCancelledError} When {@link stopScreenShare} removes
   * the share before its leg finishes connecting.
   * @throws The raw `getDisplayMedia` error. A dismissed picker or a
   * permission denial rejects with a `NotAllowedError` `DOMException` —
   * inspect `error.name` to tell benign cancels apart from real failures.
   */
  startScreenShare(options?: ScreenShareOptions): 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.
   *
   * The call is unaffected when acquisition fails.
   *
   * @throws {AuxiliaryLegCancelledError} When {@link removeAdditionalDevice}
   * removes the device before its leg finishes connecting.
   * @throws The raw `getUserMedia` error (e.g. `NotAllowedError` on
   * permission denial) — inspect `error.name` to decide how to react — or
   * `AuxiliaryLegTimeoutError` if the leg does not connect in time.
   */
  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.
   * @returns whether the constraints reached the media the call is sending.
   */
  setAudioInputDeviceConstraints(constraints: MediaTrackConstraints): Promise<boolean>;
  /**
   * Updates both audio and video input track constraints for the active call.
   * @returns whether both kinds took the constraints.
   */
  setInputDevicesConstraints(constraints: {
    audio: MediaTrackConstraints;
    video: MediaTrackConstraints;
  }): Promise<boolean>;
  /** 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.
   * @returns whether the constraints reached the media the call is sending.
   */
  setVideoInputDeviceConstraints(constraints: MediaTrackConstraints): Promise<boolean>;
  /** Selects the audio output device. Optionally saves as a preference. */
  selectAudioOutputDevice(device: MediaDeviceInfo, options?: SelectDeviceOptions): void;
  /**
   * Exits studio audio mode without restoring defaults.
   * Called internally before individual audio flag toggles.
   */
  private exitStudioModeIfActive;
  /** Toggles echo cancellation. Exits studio mode if active. */
  toggleEchoCancellation(): Promise<void>;
  /** Toggles automatic gain control. Exits studio mode if active. */
  toggleAudioInputAutoGain(): Promise<void>;
  /** Toggles noise suppression. Exits studio mode if active. */
  toggleNoiseSuppression(): Promise<void>;
  /** Mutes local audio. Falls back to local device mute if the server RPC fails. */
  mute(): Promise<void>;
  /** Unmutes local audio. Falls back to local device unmute if the server RPC fails. */
  unmute(): Promise<void>;
  /** Mutes local video. Falls back to local device mute if the server RPC fails. */
  muteVideo(): Promise<void>;
  /** Unmutes local video. Falls back to local device unmute if the server RPC fails. */
  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 | undefined>;
  readonly type$: Observable<string | undefined>;
  readonly handraised$: Observable<boolean | undefined>;
  readonly visible$: Observable<boolean | undefined>;
  readonly audioMuted$: Observable<boolean | undefined>;
  readonly videoMuted$: Observable<boolean | undefined>;
  readonly deaf$: Observable<boolean | undefined>;
  readonly inputVolume$: Observable<number | undefined>;
  readonly outputVolume$: Observable<number | undefined>;
  readonly inputSensitivity$: Observable<number | undefined>;
  readonly echoCancellation$: Observable<boolean | undefined>;
  readonly autoGain$: Observable<boolean | undefined>;
  readonly noiseSuppression$: Observable<boolean | undefined>;
  readonly lowbitrate$: Observable<boolean | undefined>;
  readonly denoise$: Observable<boolean | undefined>;
  readonly meta$: Observable<Record<string, unknown> | undefined>;
  readonly userId$: Observable<string | undefined>;
  readonly addressId$: Observable<string | undefined>;
  readonly nodeId$: Observable<string | undefined>;
  readonly isTalking$: Observable<boolean | undefined>;
  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 userId: string | undefined;
  readonly addressId: string | undefined;
  readonly nodeId: string | undefined;
  readonly callId: string | undefined;
  /** The member's own RPC target triple. Throws `ParticipantNotReadyError`
   *  until the member's call context has been received. */
  readonly target: MemberTarget;
  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<ScreenShareStatus>;
  readonly screenShareStatus: ScreenShareStatus;
  readonly studioAudio$: Observable<boolean>;
  readonly studioAudio: boolean;
  enableStudioAudio(): Promise<void>;
  disableStudioAudio(): Promise<void>;
  startScreenShare(options?: ScreenShareOptions): Promise<void>;
  stopScreenShare(): Promise<void>;
  selectAudioInputDevice(device: MediaDeviceInfo, options?: SelectDeviceOptions): void;
  selectVideoInputDevice(device: MediaDeviceInfo, options?: SelectDeviceOptions): void;
  selectAudioOutputDevice(device: MediaDeviceInfo, options?: SelectDeviceOptions): void;
  addAdditionalDevice(options: MediaOptions): Promise<void>;
  removeAdditionalDevice(id: string): Promise<void>;
  addAudioInputDevice(options?: {
    constraints?: MediaTrackConstraints;
    stream?: MediaStream;
  }): Promise<void>;
  addVideoInputDevice(options?: {
    constraints?: MediaTrackConstraints;
    stream?: MediaStream;
  }): Promise<void>;
  addInputDevices(options?: MediaOptions): Promise<void>;
  setAudioInputDeviceConstraints(constraints: MediaTrackConstraints): Promise<boolean>;
  setVideoInputDeviceConstraints(constraints: MediaTrackConstraints): Promise<boolean>;
  setInputDevicesConstraints(constraints: {
    audio: MediaTrackConstraints;
    video: MediaTrackConstraints;
  }): Promise<boolean>;
}
/**
 * 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' | 'recovering' | 'disconnecting' | 'disconnected' | 'failed' | 'destroyed';
/** Configuration options for creating a call. */
interface CallOptions extends MediaOptions {
  /**
   * Optional. Hint to the cluster about which node should host this call.
   * Used by reattach to pin to the original node; on fresh dials acts as a
   * steering preference (the server may ignore for placement reasons).
   * Leave undefined for normal load-balanced placement.
   */
  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>;
  /** Preferred video codecs for this call (overrides global preferences). */
  readonly preferredVideoCodecs?: string[];
  /** Preferred audio codecs for this call (overrides global preferences). */
  readonly preferredAudioCodecs?: string[];
  /** Enable stereo Opus for this call (overrides global preferences). */
  readonly stereo?: boolean;
}
/** 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<Capability[]>;
  readonly capabilities: Capability[];
  readonly mediaDirections$: Observable<MediaDirections>;
  readonly mediaDirections: MediaDirections;
  /** Withholds emission until self exists, so it never emits `null` — unlike {@link Call.self}. */
  readonly self$: Observable<CallSelfParticipant>;
  readonly self: CallSelfParticipant | null;
  readonly to?: string;
  readonly toName?: string;
  readonly from?: string;
  readonly fromName?: string;
  readonly direction: CallDirection;
  readonly layouts$: Observable<string[]>;
  readonly layouts: string[];
  readonly layout$: Observable<string>;
  readonly layout?: string;
  readonly layoutLayers$: Observable<LayoutLayer[]>;
  readonly layoutLayers: LayoutLayer[];
  /** Observable that emits only non-null MediaStreams (waits until the stream exists). */
  readonly localStream$: Observable<MediaStream>;
  /** Sync getter — returns null before the stream is created. */
  readonly localStream: MediaStream | null;
  /** Observable that emits only non-null MediaStreams (waits until the stream exists). */
  readonly remoteStream$: Observable<MediaStream>;
  readonly remoteStream: MediaStream | null;
  readonly rtcPeerConnection: RTCPeerConnection | undefined;
  readonly errors$: Observable<CallError>;
  readonly signalingEvent$: Observable<Record<string, unknown>>;
  readonly address?: CallAddress;
  readonly address$: Observable<CallAddress | undefined>;
  userVariables?: Record<string, unknown>;
  readonly userVariables$: Observable<Record<string, unknown>>;
  readonly networkIssues$: Observable<NetworkIssue[]>;
  readonly networkIssues: NetworkIssue[];
  readonly isNetworkHealthy$: Observable<boolean>;
  readonly isNetworkHealthy: boolean;
  readonly networkMetrics$: Observable<NetworkMetrics[]>;
  readonly networkMetrics: NetworkMetrics[];
  readonly qualityScore$: Observable<number>;
  readonly qualityLevel$: Observable<QualityLevel>;
  readonly recoveryState$: Observable<RecoveryState>;
  readonly recoveryEvent$: Observable<RecoveryEvent>;
  readonly bandwidthConstrained$: Observable<boolean>;
  readonly mediaParamsUpdated$: Observable<MediaParamsEvent>;
  requestKeyframe(): void;
  requestIceRestart(): Promise<void>;
  subscribe(eventType: string): Observable<Record<string, unknown>>;
  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(options?: MediaOptions): void;
  reject(): void;
  sendDigits(digits: string): Promise<void>;
  readonly localAudioLevel$: Observable<number>;
  readonly localSpeaking$: Observable<boolean>;
  readonly remoteAudioLevel$: Observable<number>;
  readonly localMicrophoneGain$: Observable<number>;
  setLocalMicrophoneGain(value: number): void;
  enablePushToTalk(): void;
  disablePushToTalk(): void;
  setPushToTalkActive(active: boolean): void;
  setEchoCancellation(enabled: boolean): Promise<boolean>;
  setNoiseSuppression(enabled: boolean): Promise<boolean>;
  setAutoGainControl(enabled: boolean): Promise<boolean>;
  executeMethod<T extends JSONRPCResponse = JSONRPCResponse>(target: string, method: string, args: Record<string, unknown>): Promise<T>;
  execute<T extends JSONRPCResponse = JSONRPCResponse>(request: JSONRPCRequest, options?: PendingRPCOptions): 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 selfId$: Observable<string | null>;
  readonly selfId: string | null;
  readonly nodeId$: Observable<string | null>;
  readonly nodeId: string | null;
  readonly answered$: Observable<boolean>;
  readonly answerMediaOptions?: MediaOptions;
  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;
  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.
 *
 * @template 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
 *
 * @template 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
 *
 * @template 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.
   *
   * @param text - The message text to send.
   *
   * @example
   * ```ts
   * await address.sendText('Hello!');
   * ```
   */
  sendText(text: string): Promise<void>;
  /**
   * Collection of text messages for this address, with pagination support.
   *
   * Returns `undefined` until {@link textMessages$} has been subscribed to (lazy-loaded).
   * Filters to `'chat'` subtype messages from the conversation.
   *
   * @see {@link textMessages$} to trigger lazy loading.
   * @see {@link sendText} to send a new message.
   */
  get textMessage(): EntityCollectionTransformed<GetConversationMessageResponse, TextMessage<Address>> | undefined;
  /**
   * Collection of call history entries for this address, with pagination support.
   *
   * Returns `undefined` until {@link history$} has been subscribed to (lazy-loaded).
   * Filters to `'log'` subtype messages including kind, status, start/end times.
   *
   * @see {@link history$} to trigger lazy loading.
   */
  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;
  nodeId?: string;
}
interface OutboundCallProvider {
  createOutboundCall(destination: string | Address, options?: CallOptions): Promise<Call>;
}
interface Attachment {
  destination: string;
  mediaDirections: MediaDirections;
  audioInputDevice: MediaDeviceInfo | null;
  videoInputDevice: MediaDeviceInfo | null;
  nodeId?: string;
  attachedAt: number;
}
declare class AttachManager {
  private readonly storage;
  private readonly deviceController;
  private readonly reconnectCallsTimeout;
  private attachKey;
  /**
   * Whether a credential recovery has been verified on this client — the
   * session reauthenticated with a fresh token AND the operation that
   * reauthentication was meant to unblock then succeeded. Gates attach-record
   * discard together with the failure kind: a record is dropped only when
   * this is true AND the reattach refusal was NOT a credential refusal
   * (-32003). See {@link reattachCalls}.
   */
  private readonly credentialRecovered;
  private session;
  private writeQueue;
  constructor(storage: StorageManager, deviceController: DeviceController, reconnectCallsTimeout: number, attachKey: string,
  /**
   * Whether a credential recovery has been verified on this client — the
   * session reauthenticated with a fresh token AND the operation that
   * reauthentication was meant to unblock then succeeded. Gates attach-record
   * discard together with the failure kind: a record is dropped only when
   * this is true AND the reattach refusal was NOT a credential refusal
   * (-32003). See {@link reattachCalls}.
   */
  credentialRecovered: () => boolean);
  detachAll(): Promise<void>;
  setSession(session: OutboundCallProvider): void;
  private readAttached;
  private writeAttached;
  /**
   * Serialize a read-modify-write operation against the attached-calls
   * storage. The mutator receives the current state and returns the new
   * state. Concurrent calls queue behind the in-flight one so writes never
   * interleave.
   */
  private mutate;
  attach(call: AttachableCall): Promise<void>;
  /**
   * Keep an already-stored call's reference alive and current — the periodic
   * refresh the `verto.ping` keepalive drives.
   *
   * Only ever updates: a call with no record is one nothing wants reattached,
   * and re-creating it here would undo a `detach`. That matters because a ping
   * can land in the window between `bye()` detaching and the call being torn
   * down, and a record revived there survives the hangup — so the next page
   * load dials a call nobody is on. The existence check and the write share
   * one {@link mutate} turn, so a concurrent detach cannot slip between them.
   */
  refresh(call: AttachableCall): Promise<void>;
  private buildAttachment;
  detach(call: AttachableCall): Promise<void>;
  flush(): Promise<void>;
  /**
   * Reattach to previously active calls by sending verto.invite with
   * reattaching: true.
   *
   * NOTE: This currently fails with INVALID_CALL_REFERENCE because the
   * server's jsock UUID check rejects the new connection's UUID. A
   * server-side fix is needed: when reattaching: true is explicitly set
   * in dialogParams, FreeSWITCH's attempt_reattach() should update the
   * call's jsock reference to the new connection's UUID instead of
   * rejecting. Once that fix is deployed, this will work for both
   * page reloads and WebSocket reconnects.
   *
   * A failed reattach does NOT generally cost the stored reference. It is
   * discarded only when the server denied the reattach on a session whose
   * credential it had already accepted — a verified reauthentication followed
   * by a refusal is the server saying the call is gone, and that is the one
   * refusal worth acting on. Until then the credential may be what is being
   * refused, and the record is the only way a later reload can try again;
   * keeping it costs nothing, since `detachExpired` reaps it once it is older
   * than `reconnectCallsTimeout`.
   */
  reattachCalls(): Promise<void>;
  /**
   * Build CallOptions from stored attachment data for a call being reattached.
   * Also used by the session-level verto.attach handler.
   */
  buildCallOptions(attachment: Attachment): CallOptions;
  /**
   * Look up stored attachment data for a call id and return CallOptions
   * suitable for rehydrating a reattached call. Returns undefined when no
   * matching entry exists in storage.
   *
   * Used by the session-level verto.attach handler when the server pushes
   * an attach event for a call the client doesn't have an object for yet
   * (e.g. after a reload).
   */
  consumePendingAttachment(callId: string): Promise<CallOptions | undefined>;
  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 socketStatus;
  private sessionAuthenticated;
  private heldRequests;
  private serverPingTimer?;
  private serverPingWatch;
  private ackEvent;
  private replySignalwirePing;
  /**
   * Filter that drops events from a previous session after reconnect.
   *
   * Compares the event's `event_channel` against the current protocol.
   * Events whose channel doesn't contain the current protocol are from
   * a stale session and are discarded. Events without an event_channel
   * (auth state events, RPC responses) always pass through.
   */
  private discardStaleEvents;
  private _currentProtocol;
  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>;
  get connectionStatus(): string;
  connect(): Promise<void>;
  reconnect(): void;
  execute<T extends JSONRPCResponse = JSONRPCResponse>(request: JSONRPCRequest, options?: PendingRPCOptions): Promise<T>;
  send(message: unknown): void;
  /**
   * Called by the session when signalwire.connect succeeds on the current
   * socket. Sends the requests held since the socket opened, in order.
   */
  setAuthenticated(): void;
  disconnect(): void;
  destroy(): void;
  private armServerPingWatchdog;
  /** Bumps the watch so a probe still in flight no longer acts on its result. */
  private clearServerPingWatchdog;
  private probeServer;
  private _loadProtocolFromStorage;
  private _updateProtocolInStorage;
  private _init;
}
//#endregion
//#region src/controllers/CryptoController.d.ts
/**
 * Controls DPoP (Demonstrating Proof-of-Possession) cryptographic operations.
 *
 * Generates an RSA-2048 key pair where the private key is non-extractable,
 * computes the JWK Thumbprint (RFC 7638) as the fingerprint, and creates
 * signed DPoP proof JWTs for both HTTP API requests and WebSocket RPC calls.
 *
 * The key pair is persisted in IndexedDB so the same fingerprint survives
 * page reloads. This keeps the Client Bound SAT and stored authorization_state
 * valid across reloads without needing to re-authenticate.
 *
 * @example
 * ```typescript
 * const crypto = new CryptoController();
 * await crypto.init();
 *
 * // Get fingerprint for SAT issuance
 * const fingerprint = crypto.fingerprint;
 *
 * // Create proof for HTTP endpoint
 * const httpProof = await crypto.createHttpProof({
 *   method: 'POST',
 *   uri: '/api/fabric/subscriber/devices/token'
 * });
 *
 * // Create proof for RPC call
 * const rpcProof = await crypto.createRpcProof({
 *   method: 'signalwire.connect'
 * });
 * ```
 */
declare class CryptoController {
  private _keyPair;
  private _publicJwk;
  private _fingerprint;
  private _initialized;
  /**
   * Initializes the DPoP key pair. Loads an existing key from IndexedDB
   * if available, otherwise generates a new one and persists it.
   *
   * The private key is non-extractable — IndexedDB stores the CryptoKey
   * handle via the structured clone algorithm without exposing key material.
   *
   * @returns The JWK Thumbprint (fingerprint) for the key.
   */
  init(): Promise<string>;
  /**
   * The JWK Thumbprint (RFC 7638) of the public key.
   * Used as the `fingerprint` parameter when requesting scoped SATs.
   *
   * @throws {DPoPInitError} If {@link init} has not been called.
   */
  get fingerprint(): string;
  /**
   * Whether the controller has been initialized with a key pair.
   */
  get initialized(): boolean;
  /**
   * Creates a DPoP proof JWT for an HTTP API request.
   *
   * Used for Prime API endpoints like `/api/fabric/subscriber/devices/token`
   * and `/api/fabric/subscriber/devices/refresh`.
   *
   * @param params - HTTP method and URI for the proof.
   * @returns Signed DPoP proof JWT string.
   */
  createHttpProof(params: DPoPHttpProofParams): Promise<string>;
  /**
   * Creates a DPoP proof JWT for a WebSocket RPC call.
   *
   * Used for switchblade RPC methods like `signalwire.connect` and
   * `signalwire.reauthenticate`.
   *
   * @param params - RPC method name for the proof.
   * @returns Signed DPoP proof JWT string.
   */
  createRpcProof(params: DPoPRpcProofParams): Promise<string>;
  /**
   * Releases the key pair references and removes the persisted key from IndexedDB.
   * After calling destroy, the controller must be re-initialized to be used again.
   */
  destroy(): void;
  private get publicJwk();
  private get privateKey();
  private signProof;
}
//#endregion
//#region src/controllers/NetworkMonitor.d.ts
interface NetworkChangeEvent {
  type: 'online' | 'offline' | 'connection_change';
  timestamp: number;
  networkType?: string;
}
//#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;
  /**
   * Emits true when the session is authenticated, false when not.
   * Used by Call to detect WebSocket reconnections (skip(1) + filter(true)
   * indicates a re-authentication after the initial connect).
   */
  readonly authenticated$: Observable<boolean>;
  /**
   * Control transport for every call in this session: `'routed'` (default) sends
   * call.* verbs on the client's session channel; `'in-dialog'` carries them on
   * each call's own signaling channel via `verto.info`. Set once as a client
   * config ({@link SignalWireOptions.callControl}) — it is session-wide, so a
   * reattached call reads it here rather than restoring it from persisted state.
   * Read by {@link Call.executeMethod}.
   */
  readonly callControl: 'routed' | 'in-dialog';
}
//#endregion
//#region src/controllers/LocalAudioPipeline.d.ts
/**
 * Options for {@link LocalAudioPipeline}.
 */
interface LocalAudioPipelineOptions {
  /** Factory for AudioContext — override for tests. Defaults to `new AudioContext()`. */
  audioContextFactory?: () => AudioContext;
  /** Initial gain (0..2, where 1 is unity). Defaults to 1. */
  initialGain?: number;
  /** RMS level [0..1] above which speaking$ emits true. Defaults to {@link VAD_THRESHOLD}. */
  speakingThreshold?: number;
  /**
   * Milliseconds of silence below the threshold before speaking$ flips back to
   * false. Prevents flicker on normal speech gaps. Defaults to {@link VAD_HOLD_MS}.
   */
  speakingHoldMs?: number;
  /** Polling interval for level$. Defaults to {@link AUDIO_LEVEL_POLL_INTERVAL_MS}. */
  pollIntervalMs?: number;
}
/**
 * Web Audio pipeline for the local microphone stream.
 *
 * Wraps the raw mic `MediaStreamTrack` in a graph of:
 *
 * ```
 *   MediaStreamAudioSourceNode  →  GainNode  →  AnalyserNode  →  MediaStreamAudioDestinationNode
 * ```
 *
 * The {@link outputTrack} from the destination node is what callers should
 * attach to the `RTCRtpSender` in place of the raw mic track. The same
 * destination track is reused across input changes (device switch, mute /
 * unmute track replacement) so the sender reference stays stable — only the
 * source end of the graph is rebuilt.
 *
 * The pipeline owns a single {@link AudioContext}. Callers must invoke
 * {@link destroy} to release it when the call ends.
 */
declare class LocalAudioPipeline extends Destroyable {
  private readonly _audioContext;
  private readonly _gainNode;
  private readonly _analyser;
  private readonly _destination;
  private readonly _analyserBuffer;
  private readonly _speakingThreshold;
  private readonly _speakingHoldMs;
  private readonly _pollIntervalMs;
  private _inputSource;
  private _inputStream;
  private _lastSpokeAt;
  private _gain$;
  /** 1 when audio should pass through, 0 when silenced by PTT. */
  private _pttMultiplier;
  constructor(options?: LocalAudioPipelineOptions);
  /** Observable of the current gain value (0..2). */
  get gain$(): Observable<number>;
  /** Current gain value (0..2). */
  get gain(): number;
  /**
   * Processed output track to attach to the RTCRtpSender. Stable reference
   * across input changes, so `sender.replaceTrack(pipeline.outputTrack)` only
   * needs to be called once.
   */
  get outputTrack(): MediaStreamTrack;
  /**
   * Root-mean-square audio level of the input signal, 0..1. Emits on a fixed
   * interval (~30fps by default).
   */
  get level$(): Observable<number>;
  /**
   * Boolean VAD derived from {@link level$}. True while level ≥ threshold or
   * during the hold window after the last frame that crossed the threshold.
   */
  get speaking$(): Observable<boolean>;
  /**
   * Set gain multiplier applied to the input signal. 0 = silence,
   * 1 = unity, 2 = 2x. Values are clamped to [0, 2]. The effective gain on
   * the graph also respects the current PTT state.
   */
  setGain(value: number): void;
  /**
   * Silence the graph when `active = false`, otherwise restore the configured
   * gain. Use this from a PTT handler: released → `false`, held → `true`.
   * Orthogonal to {@link setGain} — once PTT returns to active, the last
   * configured gain reappears.
   */
  setPTTActive(active: boolean): void;
  private applyEffectiveGain;
  /**
   * Wire a new raw mic track as the pipeline's input. Replaces any previous
   * input source and reconnects the graph so {@link outputTrack} continues
   * to emit the processed audio. Pass `null` to disconnect the input (the
   * output track stays alive but emits silence).
   *
   * Also resumes the underlying AudioContext on attach — Chrome creates it
   * in a suspended state and the graph won't process (the destination
   * track emits silence) until resume() succeeds.
   */
  setInputTrack(track: MediaStreamTrack | null): void;
  destroy(): void;
  private computeLevel;
  private evaluateSpeaking;
}
//#endregion
//#region src/controllers/RTCPeerConnectionController.d.ts
interface RTCPeerConnectionControllerOptions extends MediaOptions {
  callId?: string;
  rtcConfiguration?: RTCConfiguration;
  simulcast?: boolean;
  sfu?: boolean;
  msStreamsNumber?: number;
  propose: RTCPeerConnectionPropose;
  iceServers?: RTCIceServer[];
  disableUdpIceServers?: boolean;
  relayOnly?: boolean;
  iceCandidateTimeout?: number;
  iceGatheringTimeout?: number;
  webRTCApiProvider?: WebRTCApiProvider;
  /** Per-call preferred video codecs (overrides global preferences). */
  preferredVideoCodecs?: string[];
  /** Per-call preferred audio codecs (overrides global preferences). */
  preferredAudioCodecs?: string[];
  /** Per-call stereo Opus setting (overrides global preferences). */
  stereo?: boolean;
  /**
   * Request the shared surface's audio on a `'screenshare'` connection. Kept
   * apart from `audio`, which selects a microphone the share must not inherit.
   */
  screenShareAudio?: boolean;
}
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 _nodeId;
  private _type;
  private _iceConnectionState$;
  private _connectionState$;
  private _signalingState$;
  private _iceGatheringState$;
  private _errors$;
  private _iceCandidates$;
  /**
   * Emits once local media is settled: acquired, intentionally receive-only, or
   * failed and degraded. Separates the media and signalling phases of call
   * creation. Not `localStream$` — the receive-only paths never build a stream,
   * so that would hang exactly the calls with nothing to acquire.
   */
  private _localMediaSettled$;
  private _initialized$;
  private _remoteDescription$;
  private _remoteStream$;
  private _remoteOfferMediaDirections;
  private _localAudioPipeline;
  constructor(options?: RTCPeerConnectionControllerOptionsPartial, remoteSessionDescription?: string, deviceController?: DeviceController);
  private get iceGatheringController();
  private get shouldEmitLocalDescription();
  private removeConnectionTimer;
  setMemberId(memberId: string | null): void;
  get memberId(): string | null;
  /** The node this leg's invite landed on — auxiliary legs are placed independently. */
  setNodeId(nodeId: string | null): void;
  get nodeId(): string | null;
  stopTrackSender(kind: 'audio' | 'video' | 'both', options?: {
    updateTransceiverDirection: boolean;
  }): void;
  private stopRawAudioInputForPipeline;
  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>;
  /** Emits once local media is settled — acquired, or knowingly receive-only. */
  get localMediaSettled$(): Observable<void>;
  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 connectionState(): RTCPeerConnectionState | undefined;
  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>;
  /**
   * Accept an inbound call by creating the SDP answer.
   * Optionally override media options before the answer is generated.
   * Must be called after initialization for inbound (answer-type) connections.
   */
  acceptInbound(mediaOverrides?: MediaOptions): 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;
  /**
   * Trigger an ICE restart through the existing negotiation pipeline.
   *
   * This creates an offer with iceRestart: true and goes through the full
   * SDP pipeline (setLocalDescription → ICE gathering → localDescription$ emission).
   * The caller should NOT send the SDP manually — the existing
   * setupLocalDescriptionHandler in VertoManager will pick up the emission
   * from localDescription$ and send it as a verto.modify.
   *
   * Unlike calling pc.createOffer/setLocalDescription directly, this method:
   * - Sets _isNegotiating$ so ICEGatheringController arms its timers
   * - Waits for ICE gathering to complete before localDescription$ emits
   * - Goes through setLocalDescriptionBefore() for any SDP munging
   */
  triggerIceRestart(relayOnly?: boolean): Promise<void>;
  private restoreIceTransportPolicy;
  /**
   * Setup track handling for remote tracks.
   *
   * @returns `false` when the connection went away while local media was being
   * acquired — see {@link setupLocalTracks}.
   */
  private setupTrackHandling;
  /**
   * @returns `false` when the connection was torn down while getUserMedia was
   * in flight. The acquisition is not cancellable, so the caller must stop
   * rather than go on to touch a peer connection that is closed or gone.
   */
  private setupLocalTracks;
  /** True for a main connection with no local media to send. */
  private hasNoLocalMediaToSend;
  /** The media kinds this connection wants to send: 'audiovideo' | 'video' | 'audio'. */
  private get requestedMediaKinds();
  /**
   * Handle a local media acquisition failure with a typed, semantically
   * accurate MediaAccessError created at the acquisition site:
   * - Auxiliary connections (screenshare / additional-device) throw a
   *   non-fatal error — VertoManager surfaces it and the call is unaffected.
   * - The main connection degrades to receive-only when allowed (default),
   *   otherwise fails with a fatal error.
   */
  private handleLocalMediaFailure;
  /**
   * Negotiate receive-only m-lines when there are no local tracks to send.
   * Only offer-type connections add transceivers — answer-type connections
   * reuse the transceivers created from the remote offer.
   */
  private setupReceiveOnlyTransceivers;
  private getUserMedia;
  private getDisplayMedia;
  private setupRemoteTracks;
  restoreTrackSender(kind: 'audio' | 'video' | 'both'): Promise<void>;
  private restoreRawAudioInputForPipeline;
  /**
   * Capture the newly selected device, leaving the current capture running.
   *
   * A rejection must leave the current track sending, so nothing is released
   * until the replacement is in hand. The one exception is hardware that admits
   * a single opener — a phone's front and back cameras, typically — which
   * rejects the second capture until the first is closed.
   */
  private acquireInputTrack;
  private captureTrack;
  /** Best-effort return to the device that was released for an exclusive retry. */
  private restorePreviousInputTrack;
  private attachInputTrack;
  /**
   * Return the lazily-created {@link LocalAudioPipeline}, constructing it on
   * first access. On creation the current audio sender's track is routed
   * through the pipeline (input → gain → analyser → destination) and the
   * sender is switched to emit the processed track. Returns `null` when no
   * audio sender exists yet (pre-negotiation).
   */
  ensureLocalAudioPipeline(): LocalAudioPipeline | null;
  /** The active LocalAudioPipeline, or null if it hasn't been created yet. */
  get localAudioPipeline(): LocalAudioPipeline | null;
  private applyLocalAudioPipelineToSender;
  /**
   * 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;
  /**
   * @returns whether the constraints reached the media the leg is sending.
   *
   * With the pipeline engaged the audio sender carries the processed
   * destination track, so the sender scan would find nothing it may touch and
   * every audio constraint API would silently no-op. The constraints belong to
   * the pipeline's device source, which is the capture that sender ultimately
   * carries.
   */
  updateSendersConstraints(kind: 'audio' | 'video', constraints?: MediaTrackConstraints): Promise<boolean>;
  /**
   * Mirror of the sender path for a piped audio leg: same merge, same fallback
   * ladder, same device-capture invariant — but the swap target is the pipeline
   * input, so the sender keeps emitting the pipeline's output track and its
   * identity survives the change.
   */
  private applyPipelineSourceConstraints;
  /**
   * 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>;
  /** Separates the media phase of call creation from the signalling phase. */
  readonly localMediaSettled$: Observable<void>;
  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>;
  /**
   * Send a member-control op in-dialog via verto.info (no self/target member
   * tuple). The payload rides in the verto.info `params.command` body — a
   * sibling of `dialogParams`, same level as `dtmf` — matched to this call's
   * channel by `dialogParams.callID`, so control lands on the call's own channel
   * without relying on the {node_id,call_id,member_id} addressing the routed
   * transport uses.
   */
  sendCallControl(method: string, params: Record<string, unknown>): Promise<unknown>;
  hold(): Promise<void>;
  unhold(): Promise<void>;
  destroy(): void;
  transfer(options: TransferOptions): Promise<void>;
  /** Request a video keyframe via verto.modify. */
  requestKeyframe?: () => void;
  /** Request an ICE restart via verto.modify with iceRestart offer. */
  requestIceRestart?: (relayOnly?: boolean) => Promise<void>;
  /** Request an ICE restart on all active peer connections (multi-leg). */
  requestIceRestartAll?: (relayOnly?: boolean) => Promise<void>;
  /** Request keyframes on all video-receiving legs (skips send-only screen share). */
  requestKeyframeAll?: () => void;
  /** Lazily create (or return) the local audio pipeline for the main peer connection. */
  ensureLocalAudioPipeline(): LocalAudioPipeline | null;
  /** Current local audio pipeline, or null if it has not been created yet. */
  readonly localAudioPipeline: LocalAudioPipeline | null;
}
//#endregion
//#region src/managers/CallEventsManager.d.ts
interface WebRTCCallEventManagerOptions {}
/** @internal */
declare class CallEventsManager extends Destroyable {
  protected webRtcCallSession: CallManager;
  protected options: WebRTCCallEventManagerOptions;
  private selfId?;
  private originCallId?;
  private callIds;
  private roomSessionIds;
  private _participants$;
  private _self$;
  private _sessionState$;
  constructor(webRtcCallSession: CallManager, options?: WebRTCCallEventManagerOptions);
  get participants$(): Observable<CallParticipant[]>;
  get participants(): CallParticipant[];
  get self$(): Observable<CallSelfParticipant>;
  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<Capability[]>;
  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(): Capability[];
  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/managers/CallRecoveryManager.d.ts
type RecoveryState$1 = 'idle' | 'debouncing' | 'recovering' | 'cooldown';
interface RecoveryEvent$1 {
  action: 'keyframe_requested' | 'reinvite_started' | 'reinvite_succeeded' | 'reinvite_failed' | 'reinvite_timeout' | 'max_attempts_reached' | 'signal_reconnect' | 'full_reconnect' | 'video_disabled' | 'video_restored';
  reason: string;
  attempt?: number;
  maxAttempts?: number;
  timestamp: number;
}
//#endregion
//#region src/utils/qualityScore.d.ts
/**
 * MOS (Mean Opinion Score) quality computation based on the simplified
 * ITU-T G.107 E-model.
 *
 * Provides a single 1-5 number that applications can use for a
 * green / yellow / red quality indicator without understanding raw
 * jitter and packet-loss values.
 */
type QualityLevel$1 = 'excellent' | 'good' | 'fair' | 'poor' | 'critical';
//#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;
  /**
   * Network change events for feeding recovery pipeline
   */
  networkChange$?: Observable<NetworkChangeEvent>;
}
/**
 * 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, Call {
  clientSession: ClientSession;
  options: CallOptions;
  address?: Address | undefined;
  /** Unique identifier for this call. */
  readonly id: string;
  /** Destination URI this call was placed to. */
  to?: string;
  private vertoManager;
  private callEventsManager;
  private participantFactory;
  private _errors$;
  private _status$;
  private _lastMergedStatus;
  private _answered$;
  private _answerMediaOptions?;
  private _holdState;
  private _userVariables$;
  private _statsMonitor?;
  private _recoveryManager?;
  private _networkChange$?;
  private _networkIssues$;
  private _networkMetrics$;
  private _isNetworkHealthy$;
  private _qualityScore$;
  private _qualityLevel$;
  private _recoveryState$;
  private _recoveryEvent$;
  private _bandwidthConstrained$;
  private _mediaParamsUpdated$;
  private _customSubscriptions;
  private _pushToTalkEnabled;
  private _remoteAudioMeter;
  constructor(clientSession: ClientSession, options: CallOptions, initialization: CallInitialization, address?: Address | undefined);
  /** Observable stream of errors from media, signaling, and peer connection layers. */
  get errors$(): Observable<CallError>;
  /**
   * @internal Push an error to the call's error stream.
   * Fatal errors automatically transition the call to `'failed'` and destroy it.
   */
  emitError(callError: CallError): void;
  /** Notify the recovery manager that a verto.modify signaling exchange failed. */
  notifyModifyFailed(): 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(): Capability[];
  /** Current snapshot of all participants in the call. */
  get participants(): CallParticipant[];
  /** The local participant, or `null` if not yet joined. */
  get self(): CallSelfParticipant | null;
  /** Toggles the call lock state, preventing or allowing new participants from joining. */
  toggleLock(): Promise<void>;
  /**
   * Toggles the hold state of the call (pauses/resumes local media transmission).
   *
   * Distinct from {@link Participant.toggleMute} which mutes individual tracks.
   */
  toggleHold(): Promise<void>;
  /** @throws {UnimplementedError} Not yet implemented. Status tracked via {@link recording$}. */
  startRecording(): Promise<void>;
  /** @throws {UnimplementedError} Not yet implemented. Status tracked via {@link streaming$}. */
  startStreaming(): Promise<void>;
  /**
   * Replaces the call's custom metadata.
   * @param _meta - Metadata object to set.
   * @throws {UnimplementedError} Not yet implemented.
   */
  setMeta(_meta: Record<string, unknown>): Promise<void>;
  /**
   * Merges values into the call's custom metadata (unlike {@link setMeta} which replaces).
   * @param _meta - Metadata to merge.
   * @throws {UnimplementedError} Not yet implemented.
   */
  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.
   *
   * Constructs call context (node_id, call_id, member_id) and sends the RPC request.
   *
   * @param target - Target {@link MemberTarget} triple, or the local member's
   *   ID string for self-operations (any other string is rejected — a bare
   *   member id cannot carry the remote member's own call context).
   * @param method - Verto method name (e.g. `'call.mute'`, `'call.member.remove'`).
   * @param args - Parameters for the RPC method.
   * @returns The RPC response.
   * @throws {CallNotReadyError} If the call has no self member context yet.
   * @throws {InvalidParams} If a string target is not the local member's ID.
   * @throws {JSONRPCError} If the RPC call returns an error.
   */
  executeMethod<T extends JSONRPCResponse = JSONRPCResponse>(target: string | MemberTarget, method: string, args: Record<string, unknown>): Promise<T>;
  /**
   * `executeMethod` for a call opened with `callControl: 'in-dialog'`.
   *
   * Translates the routed transport's calling convention into the in-dialog one. No
   * `self` tuple is sent, but a `target` is — the same {call_id, member_id} the routed
   * transport puts in `target` (minus node_id), for self-ops and cross-member ops alike.
   *
   * Target shapes are per-verb and irregular, so they are centralised here rather
   * than left to callers: most verbs take a singular `target`, `call.member.remove`
   * takes a plural `targets` array, and `call.member.position.set` takes a flat
   * `targets` of `{call_id, position}` — the one verb keyed on call_id rather than
   * member_id, so the member triple `Participant.setPosition` built is unwrapped.
   */
  private executeMethodInDialog;
  /**
   * Sends a `call.*` control verb **in-dialog** via `verto.info`, as an alternative
   * to the routed {@link executeMethod} transport.
   *
   * Why both exist: `executeMethod` addresses the member with an explicit
   * `{node_id, call_id, member_id}` tuple, which does not resolve for every conference,
   * so the op can fail. An in-dialog frame carries the verb on the member's own
   * signaling channel instead, so control works without the client needing to know how
   * the conference is hosted.
   *
   * The trade-off is reach: the in-dialog transport is only accepted for calls that
   * join a conference over SWML (e.g. an SWML `join_conference`); use the routed
   * default otherwise.
   *
   * `params` are sent verbatim — nothing is built for you, which includes the target.
   * **A self-directed op still needs one**, or it is refused; name yourself explicitly:
   *
   * ```ts
   * const { call_id, member_id } = call.self.target;
   * await call.sendCommand('call.mute', { channels: ['audio'], target: { call_id, member_id } });
   * ```
   *
   * Never include `node_id` — only the two ids. The shapes are per-verb: most take a
   * singular `target`, `call.member.remove` takes a plural `targets` array, and
   * `call.member.position.set` takes a flat `targets: [{call_id, position}]` (the one
   * verb keyed on `call_id` rather than `member_id`). Verbs that act on the call as a
   * whole, or that the SDK does not wrap at all, take no target.
   *
   * For the typed alternative that handles all of this, create the client with
   * `callControl: 'in-dialog'` and use the ordinary `Call`/`Participant` methods.
   *
   * @internal Not part of the supported surface while the in-dialog transport is still
   * rolling out. `WebRTCCall` is exported from the package entry, so without this tag
   * TypeDoc publishes the method — and the example above — as public API.
   *
   * @param method - A `call.*` method name (e.g. `'call.mute'`).
   * @param params - Method parameters, sent verbatim.
   * @returns The method's own reply, unwrapped from the `verto.info` envelope.
   * @throws {JSONRPCError} If the control op fails.
   */
  sendCommand<T extends JSONRPCResponse = JSONRPCResponse>(method: string, params?: Record<string, unknown>): Promise<T>;
  /**
   * The local leg's member triple — sent as `self` in every member RPC
   * envelope, and as the `target` of call-scoped self-operations (e.g. lock,
   * layout).
   *
   * @throws {CallNotReadyError} Before `call.joined` delivers the self member
   * context (`selfId`/`nodeId`) — an RPC without it cannot be routed, so fail
   * fast instead of sending a doomed request.
   */
  private get callSelf();
  /** 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<Capability[]>;
  /** 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;
  /** Observable of custom user variables associated with the call. */
  get userVariables$(): Observable<Record<string, unknown>>;
  /** a copy of the current custom user variables of the call. */
  get userVariables(): Record<string, unknown>;
  /** Merge current custom user variables of the call. */
  set userVariables(variables: Record<string, unknown>);
  /** Observable of current network health issues (empty array = healthy). */
  get networkIssues$(): Observable<NetworkIssue[]>;
  /** Current snapshot of network issues. */
  get networkIssues(): NetworkIssue[];
  /** Simple boolean health indicator derived from stats monitor. */
  get isNetworkHealthy$(): Observable<boolean>;
  /** Whether the network is currently healthy. */
  get isNetworkHealthy(): boolean;
  /** Rolling history of raw network metrics (RTT, jitter, packet loss, bitrate). */
  get networkMetrics$(): Observable<NetworkMetrics[]>;
  /** Current snapshot of the metrics rolling window. */
  get networkMetrics(): NetworkMetrics[];
  /** Observable of MOS quality score (1-5) computed from stats metrics. */
  get qualityScore$(): Observable<number>;
  /** Observable of simplified quality level (excellent/good/fair/poor/critical). */
  get qualityLevel$(): Observable<QualityLevel$1>;
  /** Observable of the recovery pipeline state machine. */
  get recoveryState$(): Observable<RecoveryState$1>;
  /** Observable of recovery events (keyframe requested, ICE restart, etc.). */
  get recoveryEvent$(): Observable<RecoveryEvent$1>;
  /** Observable indicating whether the call is bandwidth-constrained. */
  get bandwidthConstrained$(): Observable<boolean>;
  /** Observable that emits when the server pushes media params. */
  get mediaParamsUpdated$(): Observable<MediaParamsEvent>;
  /**
   * @internal Emit a media params update event.
   * Called by the VertoManager when the server pushes media params.
   */
  emitMediaParamsUpdated(event: MediaParamsEvent): void;
  /** Request a video keyframe via RTCP PLI/FIR. */
  requestKeyframe(): void;
  /** Force an ICE restart / re-INVITE. */
  requestIceRestart(): Promise<void>;
  /**
   * @internal Initialize resilience subsystems when the call reaches 'connected'.
   * Called from within the status subscription to wire stats and recovery.
   */
  private initResilienceSubsystems;
  /**
   * Wait for the underlying RTCPeerConnection to reach 'connected' after
   * triggering an ICE restart. Resolves true on success, false on failure
   * or if the state doesn't transition within the configured timeout.
   *
   * Polls connectionState directly because the recovery manager already
   * wraps this call in its own withTimeout(); a separate listener-based
   * implementation would race the outer timeout in subtle ways.
   */
  private waitForPeerConnectionConnected;
  /**
   * @internal Stop and destroy resilience subsystems (on disconnect/destroy).
   * Clears references so they can be re-created on reconnect.
   */
  private stopResilienceSubsystems;
  /** @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.
   *
   * Lower-level than {@link executeMethod} — allows full control over the RPC request structure.
   *
   * @param request - Complete JSON-RPC request object.
   * @param options - Optional RPC execution options (timeout, etc.).
   * @returns The RPC response.
   * @throws {JSONRPCError} If the RPC call returns an error response.
   */
  execute<T extends JSONRPCResponse = JSONRPCResponse>(request: JSONRPCRequest, options?: PendingRPCOptions): Promise<T>;
  /** Observable of the local participant's member ID. */
  get selfId$(): Observable<string | null>;
  /** @internal Lets call creation bound the media and signalling phases apart. */
  get localMediaSettled$(): Observable<void>;
  /** 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, emitted when a remote participant joins the call. */
  get memberJoined$(): Observable<MemberJoinedPayload>;
  /** Observable of member-left events, emitted when a participant leaves the call. */
  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>>;
  /**
   * Subscribe to a custom signaling event type on this call.
   *
   * Returns a cached observable that filters `callSessionEvents$` for events
   * whose `event_type` matches the given string. The observable completes
   * when the call is destroyed.
   *
   * Unlike `signalingEvent$` (which only emits known call-level event types),
   * this method also matches custom/user-defined event types.
   *
   * The SDK does not validate event type strings --- the server decides
   * whether a given type is valid.
   *
   * @param eventType - The event type to subscribe to (e.g. `'my.custom.event'`).
   * @returns An observable that emits matching signaling events.
   *
   * @example
   * ```ts
   * call.subscribe('my.custom.event').subscribe(event => {
   *   console.log('Custom event:', event);
   * });
   * ```
   */
  subscribe(eventType: string): Observable<Record<string, unknown>>;
  get webrtcMessages$(): Observable<WebrtcMessagePayload>;
  get callEvent$(): Observable<WebrtcMessagePayload | CallJoinedPayload | CallLeftPayload | CallUpdatedPayload | CallStatePayload | CallPlayPayload | CallConnectPayload | RoomUpdatedPayload | MemberUpdatedPayload | MemberJoinedPayload | MemberLeftPayload | MemberTalkingPayload | LayoutChangedPayload | ConversationMessagePayload>;
  get layoutEvent$(): Observable<LayoutChangedPayload>;
  /**
   * Hangs up the call and releases all resources.
   *
   * Sends a Verto `bye` to the server, transitions status to `'disconnecting'`,
   * then destroys the call. After this, the call instance is no longer usable.
   *
   * @example
   * ```ts
   * await call.hangup();
   * ```
   */
  hangup(): Promise<void>;
  /**
   * Sends DTMF digits on the call.
   *
   * @param dtmf - The digit string to send (e.g. `'1234#'`).
   *
   * @example
   * ```ts
   * await call.sendDigits('1234#');
   * ```
   */
  sendDigits(dtmf: string): Promise<void>;
  /** Observable of WebRTC-specific signaling messages. */
  /** Observable of call-level signaling events. */
  /** Observable of layout-changed signaling events. */
  /**
   * Accepts an inbound call, optionally overriding media options for the answer.
   *
   * @param options - Optional media constraints for the answer (audio/video).
   *
   * @example
   * ```ts
   * // Accept with defaults
   * call.answer();
   *
   * // Accept audio-only
   * call.answer({ audio: true, video: false });
   * ```
   * @see {@link reject} to decline the call instead.
   * @see {@link answered$} to observe the acceptance state.
   */
  answer(options?: MediaOptions): void;
  /** Media options provided when answering. Used internally by the VertoManager. */
  get answerMediaOptions(): MediaOptions | undefined;
  /**
   * Rejects an inbound call, preventing media negotiation.
   *
   * @see {@link answer} to accept the call instead.
   * @see {@link answered$} to observe the rejection state.
   */
  reject(): void;
  /** Observable that emits `true` when answered, `false` when rejected. */
  get answered$(): Observable<boolean>;
  /**
   * Sets the call layout and, optionally, individual participant positions.
   *
   * The gateway `call.layout.set` DTO has **no** `positions` member, so when
   * `positions` is provided this method issues a `call.member.position.set`
   * request per member (via {@link Participant.setPosition}, which keys each
   * position by that member's own call context) alongside `call.layout.set`
   * (issue #19400, Flag #6).
   *
   * **These operations are NOT atomic.** The layout is applied first, then each
   * member position sequentially, so members may briefly flash into their
   * default slots before being moved to the requested positions. Targeted
   * members are validated upfront, though: when any of them has no
   * {@link Participant.target | member call context} yet, the whole call
   * rejects before any request is sent and the layout is left unchanged.
   *
   * @param layout - Layout name (must be one of {@link layouts}).
   * @param positions - Optional map of member IDs to {@link VideoPosition} values.
   *   When omitted or empty, only the layout is changed.
   * @throws {InvalidParams} If the layout is not in the available {@link layouts}.
   * @throws {ParticipantNotReadyError} If a targeted member's call context has
   *   not been received yet — thrown before any request is sent.
   *
   * @example
   * ```ts
   * await call.setLayout('grid-responsive', {
   *   [participantId]: 'reserved-0',
   * });
   * ```
   */
  setLayout(layout: string, positions?: Record<string, VideoPosition>): Promise<void>;
  /**
   * Transfers the call to another destination.
   *
   * @param options - Transfer configuration including the target destination.
   * @see {@link status$} to observe the transfer progress.
   */
  transfer(options: TransferOptions): Promise<void>;
  /**
   * Set the local microphone gain as a percentage applied before transmission.
   *
   *   - `0`   = silent
   *   - `100` = unity (no change, default)
   *   - `200` = 2× digital boost (max; expect clipping / noise amplification)
   *
   * Values are clamped to [0, 200]. Engages the local audio pipeline on
   * first use (one-time cost).
   *
   * Note: this is a **digital** multiplier applied in a Web Audio GainNode
   * between your mic track and the RTCRtpSender — it does not change the
   * physical mic's hardware sensitivity. Browsers' autoGainControl can
   * fight the setting; call {@link setAutoGainControl}(false) for
   * predictable behaviour.
   *
   * @param value - Gain percentage (0..200; 100 = unity).
   */
  setLocalMicrophoneGain(value: number): void;
  /** Observable of the current local microphone gain (0..200, where 100 = unity). */
  get localMicrophoneGain$(): Observable<number>;
  /**
   * Observable of the RMS audio level of the local microphone, 0..1.
   * Emits at ~30fps while a mic track is active. Engages the local audio
   * pipeline on first subscription.
   */
  get localAudioLevel$(): Observable<number>;
  /**
   * Observable that is `true` while the local participant is speaking
   * (RMS level above the VAD threshold, with hold time to avoid flicker).
   */
  get localSpeaking$(): Observable<boolean>;
  /**
   * Enable push-to-talk: while {@link setPushToTalkActive} has been called
   * with `false`, the microphone gain is forced to 0; calling
   * {@link setPushToTalkActive} with `true` restores the configured gain.
   * Use this instead of mute/unmute for instant talk/silence transitions
   * because it doesn't rebuild the track.
   *
   * This method installs the pipeline but does not attach any keyboard
   * listener — consumers bind the key themselves and call
   * {@link setPushToTalkActive} on keydown/keyup.
   */
  enablePushToTalk(): void;
  /** Disable push-to-talk; mic gain returns to the configured value. */
  disablePushToTalk(): void;
  /**
   * While push-to-talk is enabled, sets the talk state. `true` = transmitting,
   * `false` = silent. No-op if push-to-talk has not been enabled.
   */
  setPushToTalkActive(active: boolean): void;
  /**
   * Toggle echo cancellation on the local mic at runtime. Applied via
   * `track.applyConstraints`; browsers that don't honour runtime constraints
   * (notably iOS Safari) fall back to re-acquiring the track with the new
   * constraint set and plumbing the replacement through the local audio
   * pipeline if one is active.
   *
   * @returns whether the constraint reached the microphone. `false` is an
   * outcome rather than an error — a leg sending media the SDK did not capture
   * is left alone — so a UI that reflects the toggle must read it. Any failure
   * behind a `false` is also reported on {@link errors$}.
   */
  setEchoCancellation(enabled: boolean): Promise<boolean>;
  /**
   * Toggle browser noise suppression on the local mic at runtime.
   * @returns whether the constraint reached the microphone.
   */
  setNoiseSuppression(enabled: boolean): Promise<boolean>;
  /**
   * Toggle browser automatic gain control on the local mic at runtime.
   * @returns whether the constraint reached the microphone.
   */
  setAutoGainControl(enabled: boolean): Promise<boolean>;
  /**
   * Observable of the aggregate remote audio level, 0..1 RMS. The server
   * delivers a single mixed audio stream for all remote participants — this
   * meter reports that mix. Per-participant audio is not available client-side.
   *
   * Engages a shared AudioContext on first subscription (cheap — one
   * AnalyserNode, no GainNode, no destination) so it does not affect the
   * caller's audio element playback.
   */
  get remoteAudioLevel$(): Observable<number>;
  /** Destroys the call, releasing all resources and subscriptions. */
  destroy(): void;
  /**
   * @internal Send a verto.subscribe message to add an event type to the
   * server's subscription list for this call. Returns the underlying RPC
   * promise so callers can decide whether to cache the observable on success
   * or retry on failure.
   */
  private _sendVertoSubscribe;
}
//#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/SessionState.d.ts
/**
 * Extended session interface that adds call management and authentication
 * state on top of the narrow ClientSession contract.
 *
 * Accessible via `client.session`. Call and CallFactory continue to depend
 * only on the narrow ClientSession interface.
 */
interface SessionState extends ClientSession {
  /**
   * Observable stream of currently active inbound calls.
   * Filters `calls$` to only include calls with `direction === 'inbound'`.
   */
  readonly incomingCalls$: Observable<Call[]>;
  /**
   * Current snapshot of active inbound calls.
   */
  readonly incomingCalls: Call[];
  /**
   * Observable stream of all currently active calls (both inbound and outbound).
   */
  readonly calls$: Observable<Call[]>;
  /**
   * Current snapshot of all active calls.
   */
  readonly calls: Call[];
  /**
   * Observable that emits `true` once the session has been authenticated,
   * and `false` after disconnect.
   */
  readonly authenticated$: Observable<boolean>;
  /**
   * Current authentication state.
   * Returns `true` if the session is currently authenticated.
   */
  readonly authenticated: boolean;
}
//#endregion
//#region src/managers/ClientSessionManager.d.ts
/**
 * Discriminated union for session authentication state.
 * clientBound is tracked separately via _wasClientBound (sticky flag)
 * to avoid dual sources of truth.
 */
type SessionAuthState = {
  kind: 'unauthenticated';
} | {
  kind: 'authenticated';
};
declare class ClientSessionManager extends Destroyable implements SessionState {
  private readonly getCredential;
  private readonly transport;
  private readonly storage;
  private readonly authorizationStateKey;
  private readonly attachManager;
  private readonly dpopManager?;
  private callFactory;
  private readonly agent;
  private readonly eventAcks;
  initialized$: Observable<boolean>;
  private authorizationState$;
  private connectVersion;
  /**
   * Optional hook called before a fresh connect on reconnect.
   * Used by SignalWire to refresh expired credentials before re-authenticating.
   * @internal
   */
  onBeforeReconnect?: () => Promise<void>;
  /**
   * Called when the server refuses a fresh connect on authentication and no
   * re-minted credential is left to try; the session has stopped reconnecting.
   * @internal
   */
  onAuthenticationRejected?: () => void;
  /**
   * Session-wide call control transport (see {@link ClientSession.callControl}).
   * Set from {@link SignalWireOptions.callControl} by SignalWire after construction;
   * defaults to `'routed'`. Read by every Call, so it needs no per-call persistence.
   */
  callControl: 'routed' | 'in-dialog';
  private _authorization$;
  private _errors$;
  private _directory?;
  private _authState$;
  /** Sticky flag — once true, stays true for the session lifetime. */
  private _wasClientBound;
  private _lastFreshConnectReminted;
  private _remintBeforeNextFreshConnect;
  private _userInfo$;
  private _calls$;
  private _iceServers$;
  constructor(getCredential: () => SDKCredential, transport: TransportManager, storage: StorageManager, authorizationStateKey: string, deviceController: DeviceController, attachManager: AttachManager, webRTCApiProvider: WebRTCApiProvider, dpopManager?: CryptoController | undefined, networkChange$?: Observable<NetworkChangeEvent>);
  get incomingCalls$(): Observable<Call[]>;
  get incomingCalls(): Call[];
  get userInfo$(): Observable<Address | null>;
  get userInfo(): Address | null;
  get calls$(): Observable<Call[]>;
  get calls(): Call[];
  get iceServers(): RTCIceServer[] | undefined;
  get authorization$(): Observable<Authorization | undefined>;
  get authorization(): Authorization | undefined;
  get errors$(): Observable<Error>;
  get authenticated$(): Observable<boolean>;
  get authenticated(): boolean;
  /**
   * Whether this session is client-bound (using a Client Bound SAT).
   * When client-bound, DPoP proof creation failures are treated as
   * authentication errors rather than silently degraded.
   * @internal
   */
  get clientBound(): boolean;
  /** @internal Current auth state for debugging/testing. */
  get authState(): SessionAuthState;
  /**
   * 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<(Omit<{
    event_type: "webrtc.message";
    event_channel: EventChannel;
    timestamp: number;
    project_id?: string;
    node_id?: string;
    is_author?: boolean;
    params: WebrtcMessagePayload;
  }, "event_channel" | "project_id" | "node_id"> & {
    event_channel: string;
    project_id: string;
    node_id: string;
  }) | {
    event_type: "signalwire.authorization.state";
    params: SignalwireAuthorizationStatePayload;
  } | (Omit<{
    event_type: "call.joined";
    event_channel: EventChannel;
    timestamp: number;
    project_id?: string;
    node_id?: string;
    is_author?: boolean;
    params: CallJoinedPayload;
  }, "event_channel"> & {
    event_channel: string;
  }) | (Omit<{
    event_type: "call.left";
    event_channel: EventChannel;
    timestamp: number;
    project_id?: string;
    node_id?: string;
    is_author?: boolean;
    params: CallLeftPayload;
  }, "event_channel"> & {
    event_channel: string;
  }) | (Omit<{
    event_type: "call.updated";
    event_channel: EventChannel;
    timestamp: number;
    project_id?: string;
    node_id?: string;
    is_author?: boolean;
    params: CallUpdatedPayload;
  }, "event_channel"> & {
    event_channel: string;
  }) | (Omit<{
    event_type: "call.state";
    event_channel: EventChannel;
    timestamp: number;
    project_id?: string;
    node_id?: string;
    is_author?: boolean;
    params: CallStatePayload;
  }, "event_channel"> & {
    event_channel: string;
  }) | (Omit<{
    event_type: "call.play";
    event_channel: EventChannel;
    timestamp: number;
    project_id?: string;
    node_id?: string;
    is_author?: boolean;
    params: CallPlayPayload;
  }, "event_channel"> & {
    event_channel: string;
  }) | (Omit<{
    event_type: "call.connect";
    event_channel: EventChannel;
    timestamp: number;
    project_id?: string;
    node_id?: string;
    is_author?: boolean;
    params: CallConnectPayload;
  }, "event_channel"> & {
    event_channel: string;
  }) | (Omit<{
    event_type: "room.updated";
    event_channel: EventChannel;
    timestamp: number;
    project_id?: string;
    node_id?: string;
    is_author?: boolean;
    params: RoomUpdatedPayload;
  }, "event_channel"> & {
    event_channel: string;
  }) | Omit<{
    event_type: "member.updated";
    event_channel: EventChannel;
    timestamp: number;
    project_id?: string;
    node_id?: string;
    is_author?: boolean;
    params: MemberUpdatedPayload;
  }, never> | Omit<{
    event_type: "member.joined";
    event_channel: EventChannel;
    timestamp: number;
    project_id?: string;
    node_id?: string;
    is_author?: boolean;
    params: MemberJoinedPayload;
  }, never> | Omit<{
    event_type: "member.left";
    event_channel: EventChannel;
    timestamp: number;
    project_id?: string;
    node_id?: string;
    is_author?: boolean;
    params: MemberLeftPayload;
  }, never> | Omit<{
    event_type: "member.talking";
    event_channel: EventChannel;
    timestamp: number;
    project_id?: string;
    node_id?: string;
    is_author?: boolean;
    params: MemberTalkingPayload;
  }, never> | Omit<{
    event_type: "layout.changed";
    event_channel: EventChannel;
    timestamp: number;
    project_id?: string;
    node_id?: string;
    is_author?: boolean;
    params: LayoutChangedPayload;
  }, never> | (Omit<{
    event_type: "conversation.message";
    event_channel: EventChannel;
    timestamp: number;
    project_id?: string;
    node_id?: string;
    is_author?: boolean;
    params: ConversationMessagePayload;
  }, "event_channel" | "timestamp" | "is_author"> & {
    event_channel: string;
    timestamp: string;
    is_author: boolean;
  }) | (Omit<{
    event_type: "conversation.message.updated";
    event_channel: EventChannel;
    timestamp: number;
    project_id?: string;
    node_id?: string;
    is_author?: boolean;
    params: ConversationMessagePayload;
  }, "event_channel" | "timestamp" | "is_author"> & {
    event_channel: string;
    timestamp: string;
    is_author: boolean;
  })>;
  private get vertoInvite$();
  private get vertoAttach$();
  private get contexts();
  private get eventing();
  private get topics();
  private get authentication();
  connect(): Promise<void>;
  private handleAuthenticationError;
  /**
   * Clear the resume state (authorization_state + protocol) and ask the
   * transport to reconnect. The `connected` event re-triggers
   * `authenticate()`, which now has no stored state and so performs a fresh
   * connect.
   *
   * This is the stale-auth-state recovery helper used by handleAuthError:
   * the server rejected a reconnect, so the resume state is discarded and a
   * fresh connect follows. Attach records are deliberately preserved — the
   * session lives on through the reconnect and reattachCalls() needs the
   * stored call references afterwards. Do NOT add detachAll() here.
   *
   * Connect-time recovery only. A *request* refused on an already
   * authenticated session is never healed here: dropping the resume state
   * destroys the association between the socket and the previous session,
   * which is what reattach depends on. That path mints a fresh credential and
   * reauthenticates instead (see `SignalWire.recoverAndRetry`).
   *
   * For public teardown (disconnect/destroy), use {@link teardownSessionState}
   * instead, which clears the attach records as well.
   */
  private discardResumeStateAndReconnect;
  cleanupStoredConnectionParams(): Promise<void>;
  /**
   * Public-teardown helper for disconnect()/destroy(). Clears the resume
   * state (authorization_state + protocol) AND the attach records as one
   * atomic unit.
   *
   * The two stores are coupled: the backend only honors attach records
   * within the session identified by the resume state, so ending the
   * session must clear both. Clearing one without the other strands records
   * no future session can honor (disconnect) or revives a session the
   * developer explicitly ended (destroy).
   *
   * Distinct from {@link cleanupStoredConnectionParams}, which keeps the
   * attach records for the stale-auth-state recovery path.
   */
  teardownSessionState(): Promise<void>;
  protected updateAuthState(authorization_state: string): Promise<void>;
  reauthenticate(token: string, dpopToken?: string, options?: {
    clientBound?: boolean;
  }): Promise<void>;
  private authenticate;
  disconnect(): Promise<void>;
  private createInboundCall;
  /**
   * Handle a server-pushed verto.attach event at the session level.
   *
   * On page reload the server detects the reconnected session and pushes
   * verto.attach for any active calls. If a call object already exists
   * (network blip, no reload), the per-call handler in VertoManager deals
   * with it. This method only creates a new call object when no existing
   * one matches the callID.
   */
  private handleVertoAttach;
  createOutboundCall(destination: string | Address, options?: CallOptions): Promise<Call>;
  private createCall;
  destroy(): void;
}
declare class ClientSessionWrapper implements SessionState {
  private clientSessionManager;
  constructor(clientSessionManager: ClientSessionManager);
  get authenticated$(): Observable<boolean>;
  get authenticated(): boolean;
  /**
   * Whether the session is using a Client Bound SAT (DPoP). Sticky — set
   * when the binding is established or restored from a resumed session's
   * server authorization.
   */
  get clientBound(): boolean;
  get signalingEvent$(): Observable<(Omit<{
    event_type: "webrtc.message";
    event_channel: EventChannel;
    timestamp: number;
    project_id?: string;
    node_id?: string;
    is_author?: boolean;
    params: WebrtcMessagePayload;
  }, "event_channel" | "project_id" | "node_id"> & {
    event_channel: string;
    project_id: string;
    node_id: string;
  }) | {
    event_type: "signalwire.authorization.state";
    params: SignalwireAuthorizationStatePayload;
  } | (Omit<{
    event_type: "call.joined";
    event_channel: EventChannel;
    timestamp: number;
    project_id?: string;
    node_id?: string;
    is_author?: boolean;
    params: CallJoinedPayload;
  }, "event_channel"> & {
    event_channel: string;
  }) | (Omit<{
    event_type: "call.left";
    event_channel: EventChannel;
    timestamp: number;
    project_id?: string;
    node_id?: string;
    is_author?: boolean;
    params: CallLeftPayload;
  }, "event_channel"> & {
    event_channel: string;
  }) | (Omit<{
    event_type: "call.updated";
    event_channel: EventChannel;
    timestamp: number;
    project_id?: string;
    node_id?: string;
    is_author?: boolean;
    params: CallUpdatedPayload;
  }, "event_channel"> & {
    event_channel: string;
  }) | (Omit<{
    event_type: "call.state";
    event_channel: EventChannel;
    timestamp: number;
    project_id?: string;
    node_id?: string;
    is_author?: boolean;
    params: CallStatePayload;
  }, "event_channel"> & {
    event_channel: string;
  }) | (Omit<{
    event_type: "call.play";
    event_channel: EventChannel;
    timestamp: number;
    project_id?: string;
    node_id?: string;
    is_author?: boolean;
    params: CallPlayPayload;
  }, "event_channel"> & {
    event_channel: string;
  }) | (Omit<{
    event_type: "call.connect";
    event_channel: EventChannel;
    timestamp: number;
    project_id?: string;
    node_id?: string;
    is_author?: boolean;
    params: CallConnectPayload;
  }, "event_channel"> & {
    event_channel: string;
  }) | (Omit<{
    event_type: "room.updated";
    event_channel: EventChannel;
    timestamp: number;
    project_id?: string;
    node_id?: string;
    is_author?: boolean;
    params: RoomUpdatedPayload;
  }, "event_channel"> & {
    event_channel: string;
  }) | Omit<{
    event_type: "member.updated";
    event_channel: EventChannel;
    timestamp: number;
    project_id?: string;
    node_id?: string;
    is_author?: boolean;
    params: MemberUpdatedPayload;
  }, never> | Omit<{
    event_type: "member.joined";
    event_channel: EventChannel;
    timestamp: number;
    project_id?: string;
    node_id?: string;
    is_author?: boolean;
    params: MemberJoinedPayload;
  }, never> | Omit<{
    event_type: "member.left";
    event_channel: EventChannel;
    timestamp: number;
    project_id?: string;
    node_id?: string;
    is_author?: boolean;
    params: MemberLeftPayload;
  }, never> | Omit<{
    event_type: "member.talking";
    event_channel: EventChannel;
    timestamp: number;
    project_id?: string;
    node_id?: string;
    is_author?: boolean;
    params: MemberTalkingPayload;
  }, never> | Omit<{
    event_type: "layout.changed";
    event_channel: EventChannel;
    timestamp: number;
    project_id?: string;
    node_id?: string;
    is_author?: boolean;
    params: LayoutChangedPayload;
  }, never> | (Omit<{
    event_type: "conversation.message";
    event_channel: EventChannel;
    timestamp: number;
    project_id?: string;
    node_id?: string;
    is_author?: boolean;
    params: ConversationMessagePayload;
  }, "event_channel" | "timestamp" | "is_author"> & {
    event_channel: string;
    timestamp: string;
    is_author: boolean;
  }) | (Omit<{
    event_type: "conversation.message.updated";
    event_channel: EventChannel;
    timestamp: number;
    project_id?: string;
    node_id?: string;
    is_author?: boolean;
    params: ConversationMessagePayload;
  }, "event_channel" | "timestamp" | "is_author"> & {
    event_channel: string;
    timestamp: string;
    is_author: boolean;
  })>;
  get iceServers(): RTCIceServer[] | undefined;
  get callControl(): 'routed' | 'in-dialog';
  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/core/types/warnings.types.d.ts
/**
 * Non-fatal warning emitted via {@link SignalWire.warnings$ | client.warnings$}.
 *
 * Use to detect SDK behaviors that affect session liveness or developer-facing
 * contracts but do not warrant disconnection. Discriminated by `code`.
 *
 * Existing consumers of `errors$` are NOT notified — `warnings$` is a separate
 * channel so application code can react to warnings without triggering
 * error-handling code paths (e.g., disconnect cascades, user-facing toasts).
 */
type SDKWarning = CredentialRefreshFallbackWarning | CredentialNoRefreshHandlerWarning;
/**
 * Diagnostic detail for {@link CredentialRefreshFallbackWarning}. Stable
 * values, but treat unknown strings as "fell back for an unspecified cause" —
 * do not branch on this value for control flow. New values may be added in
 * future releases.
 */
type CredentialRefreshFallbackReason = 'no-scope' | 'no-dpop-support' | 'endpoint-failed' | 'activation-timeout' | (string & {});
/**
 * Emitted when the SDK falls back to the developer-provided
 * {@link CredentialProvider.refresh} because the Client Bound SAT path
 * could not take over.
 *
 * Common causes:
 * - The minted SAT lacks `sat:refresh` scope (`reason: 'no-scope'`).
 * - The `/devices/token` exchange failed transiently (`reason: 'endpoint-failed'`).
 *
 * Subscribe to this warning to detect:
 * - SDKs running with plain SATs that rely on developer-managed refresh
 * - Deployments expected to use bound tokens that silently downgraded to bearer
 *   (a security-relevant signal for fleet observability)
 */
interface CredentialRefreshFallbackWarning {
  code: 'credential_refresh_fallback';
  source: 'CredentialProvider';
  reason: CredentialRefreshFallbackReason;
  message: string;
}
/**
 * Emitted when a credential has an `expiry_at` but the provider supplies no
 * `refresh()` handler. The session will terminate at expiry with no fallback.
 *
 * Implementors who want long-lived sessions must provide a `refresh()` handler
 * or mint tokens with the `sat:refresh` scope (Client Bound SAT path).
 */
interface CredentialNoRefreshHandlerWarning {
  code: 'credential_no_refresh_handler';
  source: 'CredentialProvider';
  message: string;
  /** Token expiry timestamp (epoch milliseconds). */
  expiresAt: number;
}
//#endregion
//#region src/utils/logger.d.ts
/** Log level names supported by the SDK. */
type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'silent';
/**
 * Logger interface that consumers can implement to replace the built-in logger.
 * All methods accept variadic arguments matching the browser console API.
 */
interface SDKLogger {
  error(...args: unknown[]): void;
  warn(...args: unknown[]): void;
  info(...args: unknown[]): void;
  debug(...args: unknown[]): void;
  trace(...args: unknown[]): void;
}
/** Options for WebSocket traffic logging. */
interface WsTrafficOptions {
  type: 'send' | 'recv' | 'http';
  /** Parsed object or raw string — will be JSON.stringify'd for display if an object. */
  payload: unknown;
}
/**
 * Options for WebSocket traffic logging using raw strings.
 * The string is only parsed when logging is enabled, avoiding
 * unnecessary JSON.parse on every message.
 */
interface WsTrafficRawOptions {
  type: 'send' | 'recv';
  raw: string;
}
/** Debug options that control verbose SDK logging. */
interface DebugOptions {
  /** Log all WebSocket send/recv traffic to the console. */
  logWsTraffic?: boolean;
}
/** Extended logger with SDK-internal helpers (wsTraffic). */
interface InternalSDKLogger extends SDKLogger {
  wsTraffic: (options: WsTrafficOptions | WsTrafficRawOptions) => void;
}
/** Replace the built-in logger with a custom implementation. Pass `null` to restore defaults. */
declare const setLogger: (logger: SDKLogger | null) => void;
/** Configure debug options (e.g., `{ logWsTraffic: true }`). */
declare const setDebugOptions: (options: DebugOptions | null) => void;
/**
 * Set the log level for the built-in logger.
 * Has no effect when a custom logger is set via `setLogger()`.
 */
declare const setLogLevel: (level: LogLevel) => void;
declare const getLogger: () => InternalSDKLogger;
//#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 user registration on construction. */
  skipRegister?: boolean;
  /** Skip monitoring media device changes. */
  skipDeviceMonitoring?: boolean;
  /** Whether to reconnect to previously attached calls. */
  reconnectAttachedCalls?: boolean;
  /** Whether to save preferences. */
  savePreferences?: boolean;
  /**
   * Persist the session across page reloads.
   *
   * When `true`, credential, authorization state, and protocol are stored in
   * `localStorage` (survives reload). The DPoP key pair is persisted in
   * IndexedDB. On reload, the SDK restores the session from cache
   * without calling `credentialProvider.authenticate()`.
   *
   * When `false` (default), session data lives in `sessionStorage` and is
   * lost on reload.
   *
   * Both {@link SignalWire.disconnect | disconnect()} and
   * {@link SignalWire.destroy | destroy()} end the session and clear the
   * persisted resume state and attach records; credentials and device
   * preferences survive. Use `resetToDefaults()` for a full wipe, or
   * `unregister()` to temporarily stop receiving inbound calls while keeping
   * the session alive.
   */
  persistSession?: boolean;
  /** Custom storage implementation for persistence. */
  storageImplementation?: Storage;
  /** Custom WebSocket constructor */
  webSocketConstructor?: WebSocketAdapter | NodeSocketAdapter;
  /** Custom WebRTC API provider */
  webRTCApiProvider?: WebRTCApiProvider;
  /**
   * Custom logger implementation. Must implement the {@link SDKLogger} interface.
   * Pass `null` to restore the built-in logger.
   *
   * **Note:** Logger configuration is global — setting it on one instance affects all instances.
   */
  logger?: SDKLogger | null;
  /**
   * Log level for the built-in logger.
   * Default: `'warn'`. Set to `'debug'` for verbose SDK output.
   * Has no effect when a custom `logger` is provided.
   *
   * **Note:** Logger configuration is global — setting it on one instance affects all instances.
   */
  logLevel?: LogLevel;
  /** Debug options for verbose SDK diagnostics (e.g., `{ logWsTraffic: true }`). */
  debug?: DebugOptions;
  /**
   * Control transport for `call.*` verbs across ALL calls in this session:
   * - `'routed'` (default) sends them on the client's session channel.
   * - `'in-dialog'` carries them on each call's own signaling channel via `verto.info`,
   *   so control works without the client needing to know how the conference is hosted.
   *
   * `'in-dialog'` is opt-in because it does not reach everywhere `'routed'` does: use it
   * only for calls that join a conference over SWML (e.g. an SWML `join_conference`).
   *
   * It is a client-wide setting rather than per-`dial()` because the SDK issues some
   * control RPCs itself (fetching the layout list on join, for example), and those must
   * travel the same way as the app's own, or reads and writes land on different transports.
   *
   * @experimental A rollout switch, not a long-term part of the API. Expected to
   * disappear once `'in-dialog'` becomes the only transport, so it carries no semver
   * promise and application code should not depend on it.
   */
  callControl?: 'routed' | 'in-dialog';
}
/** Options for {@link SignalWire.dial}. Extends {@link MediaOptions} with dial-specific settings. */
interface DialOptions extends MediaOptions {
  /** Preferred video codecs for this call (overrides global preferences). */
  preferredVideoCodecs?: string[];
  /** Preferred audio codecs for this call (overrides global preferences). */
  preferredAudioCodecs?: string[];
  /** Enable stereo Opus for this call (overrides global preferences). */
  stereo?: boolean;
  /** Optional node ID for routing the call */
  nodeId?: string;
  /**
   * Custom variables sent with the Verto invite. Merged with
   * `client.preferences.userVariables` and any query-string variables on the
   * destination URI; values here take precedence.
   */
  userVariables?: Record<string, unknown>;
}
/**
 * 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 _user$;
  private _directory$;
  private _transport;
  private _clientSession;
  private _publicSession;
  private _deviceController;
  private _attachManager?;
  /**
   * Set once a credential recovery has been *verified* — reauthenticated and
   * then proven by the operation it was meant to unblock. Read by the attach
   * path, which may only discard an attach record when a reattach is refused
   * on a credential the server has already accepted.
   */
  private _credentialRecovered;
  private _isConnected$;
  private _isRegistered$;
  private _errors$;
  private _warnings$;
  private _options;
  private _dpopManager?;
  private _refreshCoordinator?;
  /** The refresh path's own HTTP controller — see resolveCredentials. */
  private _refreshHttp?;
  /** Host `_refreshHttp` was built against, so it can be rebuilt when the token's `ch` changes. */
  private _refreshHttpHost?;
  private _credentialProvider?;
  private _deps;
  private _networkMonitor?;
  private _visibilityController?;
  private _diagnosticsCollector?;
  private _platformCapabilities?;
  /**
   * Creates a new SignalWire client and begins connecting.
   *
   * @param credentialProvider - Provider that supplies authentication credentials.
   * @param options - Configuration options (connection, device monitoring, preferences).
   */
  constructor(credentialProvider: CredentialProvider | undefined, options?: SignalWireOptions);
  /**
   * Build the refresh path's own HTTP controller, against whatever host is current.
   *
   * Called on first use rather than up front, so `apiHost` already reflects the
   * token's `ch` claim. Same credential source as the container's controller — only
   * the instance, and therefore its observable streams, is separate.
   */
  private createRefreshHttpController;
  /**
   * Initializes DPoP if not already set up. Returns the fingerprint on success.
   */
  private initDPoP;
  /**
   * Resolves credentials using cache-first strategy when persistSession is enabled.
   *
   * 1. If persistSession → check localStorage for cached credential
   * 2. If cached and not expired → use it (skip provider.authenticate())
   * 3. If no cache or expired → call provider.authenticate()
   * 4. If no provider AND no cache → throw
   */
  private resolveCredentials;
  private validateCredentials;
  /**
   * Reauthenticate the currently-open session with a freshly obtained
   * credential so the new token takes effect on the live socket immediately —
   * not just on the next reconnect. No-op when the session is not
   * connected/authenticated or the credential carries no token (e.g. an
   * authorization-state-only refresh). Non-fatal: reauth failures surface on
   * `errors$` without aborting the refresh that triggered this.
   */
  private reauthenticateLiveSession;
  /**
   * Recover a session the server is refusing: mint a fresh credential,
   * reauthenticate the live session with it, and retry the operation.
   *
   * The connection is deliberately kept. A reload authenticates the new socket
   * against the persisted `authorization_state`, and that handshake is what
   * associates the socket with the previous session — the association reattach
   * depends on. `signalwire.reauthenticate` swaps the credential *on that same
   * session*, so recovery never touches the resume state. Discarding it would
   * heal the credential by destroying the very thing the caller is trying to
   * get back to.
   *
   * The operation is still the verdict, never the RPC. Reauthenticating with
   * the in-memory token is accepted by a resume even while requests stay
   * refused, because the persisted `authorization_state` short-circuits token
   * validation — and `signalwire.reauthenticate` with a *freshly minted* token
   * has also been observed accepted while `subscriber.online` keeps being
   * refused (staging run 33826974634). Both look like success and are not.
   *
   * @returns the operation's value, or the reason recovery could not deliver
   *   one. `error` is undefined when there was no way to mint at all.
   */
  private recoverAndRetry;
  /**
   * Re-mint a credential and adopt it only if the live session accepts it.
   *
   * The mechanism follows the binding: a client-bound session re-mints a bound
   * base SAT through `authenticate()` with the DPoP fingerprint, because the
   * developer refresh handler would hand back an unbound token and silently
   * degrade the session. An unbound session uses the refresh handler. Rotation
   * cost is not a reason to skip this — the only reason is having no mechanism.
   *
   * @returns whether the session is now running on a freshly accepted credential.
   */
  private remintAndReauthenticate;
  /**
   * Re-mint a credential via `provider.refresh()`, routed through the
   * coordinator's shared in-flight guard so concurrent re-mint paths (a
   * scheduled/resume refresh, -32003 recovery, and reconnect) never fire a
   * second `provider.refresh()` in parallel — which rotating one-time-use
   * refresh tokens reject. Falls back to a direct call only if the coordinator
   * has not been constructed yet.
   */
  private remintCredential;
  /**
   * Re-mint credentials before a fresh (re)connect (`onBeforeReconnect` hook).
   * The session invokes this only when it is client-bound OR the in-memory
   * token is expired. The re-mint mechanism depends on the binding:
   *   - Client-bound: `authenticate()` with the DPoP fingerprint to obtain a
   *     fresh base SAT the upcoming reconnect can re-bind (the
   *     DeviceTokenManager re-activates afterwards).
   *   - Unbound: the developer's non-interactive `refresh()` handler.
   *     `authenticate()` is deliberately NOT used here — it may be interactive
   *     (a login prompt) and must not fire on a background reconnect.
   *
   * Rejects on failure so the session aborts the reconnect rather than
   * replaying a stale token.
   */
  private refreshCredentialForReconnect;
  /** Persist credential to localStorage when persistSession is enabled. */
  private persistCredential;
  /**
   * Persist whether the session is client-bound, mirroring the credential's
   * storage scopes so it survives a reload. The preflight recovery reads it
   * before any session exists to decide whether to re-bind via `authenticate()`
   * or refresh an unbound token; the marker tracks the latest binding, so an
   * unbound reconnect clears a stale marker from an earlier client-bound login.
   */
  private persistClientBoundMarker;
  /** Read the persisted client-bound marker (see {@link persistClientBoundMarker}). */
  private wasClientBound;
  private init;
  private handleAttachments;
  /**
   * Fetch the authenticated user profile, recovering a stale credential.
   *
   * On a reload the persisted credential can be expired. Unlike the WS resume —
   * which the server accepts against the persisted `authorization_state` even
   * with an expired token — this REST preflight has no such short-circuit and is
   * refused (401). There is no session yet to reauthenticate, so recovery
   * re-mints the credential through the provider ({@link refreshCredentialForReconnect})
   * and retries with a FRESH {@link User}: Fetchable memoizes its result
   * (shareReplay), so reusing the instance would replay the 401 instead of
   * re-fetching with the new token. Without the user id the transport/session —
   * and the reattach a reload is trying to preserve — cannot even be addressed.
   */
  private fetchUserOrRecover;
  /**
   * 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 **0.1 s**).
   * - Each subsequent retry doubles the delay up to `reconnectDelayMax`
   *   (default **3 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 User} profile once fetched,
   * or `undefined` before authentication completes.
   *
   * @example
   * ```ts
   * client.user$.subscribe(u => {
   *   if (u) console.log('Logged in as', u.email);
   * });
   * ```
   */
  get user$(): Observable<User | undefined>;
  /** Current user snapshot, or `undefined` if not yet authenticated. */
  get user(): User | 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 user registration state changes. */
  get isRegistered$(): Observable<boolean>;
  /** Whether the user 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>;
  /**
   * Observable stream of non-fatal SDK warnings.
   *
   * Subscribe to detect SDK behaviors that affect session liveness or developer-facing
   * contracts but do not warrant disconnection — e.g., a fallback from Client Bound SAT
   * refresh to the developer-provided `refresh()` because the SAT lacks `sat:refresh`
   * scope. Discriminated by `code`.
   *
   * Independent from {@link errors$}: existing error consumers are not notified.
   */
  get warnings$(): Observable<SDKWarning>;
  /** Platform WebRTC capabilities detected at construction time. */
  get platformCapabilities(): PlatformCapabilities;
  /** Observable that emits when the SDK auto-switches a device. */
  get deviceRecovered$(): Observable<DeviceRecoveryEvent>;
  /**
   * Export a structured diagnostic bundle for support/debugging.
   * Includes connection events, call summaries, and device changes.
   */
  exportDiagnostics(): SessionDiagnostics;
  /**
   * Initialize resilience subsystems. Non-fatal: any failure is logged and
   * the SDK continues working without the failing subsystem.
   */
  private initResilienceSubsystems;
  /**
   * Disconnects the WebSocket and tears down the current session.
   *
   * Ends the session identified by the protocol and clears its persisted
   * resume state (`authorization_state` + protocol) and attach records
   * together — a later {@link connect} with the same credentials starts a
   * fresh session and cannot reattach to the ended session's calls.
   * Credentials and device preferences are preserved. To temporarily stop
   * receiving inbound calls while keeping the session alive, use
   * `unregister()` instead.
   *
   * The client can be reconnected by calling {@link connect} again,
   * which creates a fresh transport and session.
   */
  disconnect(): Promise<void>;
  /**
   * Tear down the current transport / session / attach manager. Safe to call
   * when nothing has been initialized yet (e.g. first connect()).
   */
  private teardownTransportAndSession;
  private waitAuthentication;
  /**
   * Registers the user as online to receive inbound calls and events.
   *
   * Waits for authentication to complete before sending the registration.
   * If the initial attempt fails, reauthentication is attempted automatically.
   *
   * @throws {InvalidCredentialsError} If registration and reauthentication both fail.
   */
  register(): Promise<void>;
  /**
   * Unregisters the user, going offline for inbound calls.
   *
   * The WebSocket connection remains open; use {@link disconnect} to fully close it.
   */
  unregister(): Promise<void>;
  /**
   * Places an outbound call to the given destination.
   *
   * Waits for authentication before dialing. Media options are merged from
   * saved preferences, destination query parameters (e.g. `?channel=video`),
   * and the provided `options` (highest priority).
   *
   * Returns a {@link Call} in `'ringing'` state. Subscribe to {@link Call.status$}
   * to track progression through `'connected'` → `'disconnected'`.
   *
   * Local media acquisition is deliberately unbounded: an unanswered permission
   * prompt leaves this promise pending indefinitely, so apply your own bound if
   * your UI needs one. The 12 s signaling budget starts only once acquisition
   * settles.
   *
   * @param destination - Address URI string (e.g. `'/public/my-room'`) or {@link Address} instance.
   * @param options - Media and dial options (audio/video, device constraints). Overrides defaults.
   * @returns The created {@link Call} instance.
   * @throws {Error} If authentication is not complete or call creation fails.
   *
   * @example
   * ```ts
   * const call = await client.dial('/public/conference', {
   *   audio: true,
   *   video: true,
   * });
   * call.status$.subscribe(status => console.log('Call:', status));
   * ```
   */
  dial(destination: string | Address, options?: DialOptions): Promise<Call>;
  /**
   * Runs a multi-phase connectivity test against the given destination.
   *
   * The test checks:
   *   1. **Signaling** -- WebSocket connected, RTT measurement
   *   2. **Devices** -- getUserMedia succeeds with selected (or specified) devices
   *   3. **ICE/TURN** -- gathers ICE candidates to verify STUN/TURN reachability
   *   4. **Media/bandwidth** (unless `skipMediaTest`) -- dials the destination,
   *      collects getStats() for `duration` seconds, computes bandwidth estimates
   *
   * @param destination - A destination to dial for the media test (e.g. `'/private/network-test'`).
   * @param options - Preflight options (duration, skipMediaTest, device overrides).
   * @returns A {@link PreflightResult} describing connectivity health.
   *
   * @example
   * ```ts
   * const result = await client.preflight('/private/network-test', { duration: 5 });
   * if (!result.ok) console.warn('Connectivity issues:', result.warnings);
   * ```
   */
  preflight(destination: string, options?: PreflightOptions): Promise<PreflightResult>;
  /** 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. Returns `false` when disabled. */
  get selectedAudioInputDeviceConstraints(): MediaTrackConstraints | boolean;
  /** Media track constraints for the selected video input device. Returns `false` when disabled. */
  get selectedVideoInputDeviceConstraints(): MediaTrackConstraints | boolean;
  /** 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;
  /**
   * Apply the currently selected audio output device to an HTMLMediaElement
   * (e.g. the `<audio>` or `<video>` element the consumer attached the
   * remote stream to). Uses `HTMLMediaElement.setSinkId` under the hood.
   * Returns a `Promise<boolean>`: `true` if the sink was applied,
   * `false` if the browser doesn't support `setSinkId` or no device is
   * selected.
   *
   * @example
   * ```ts
   * audioEl.srcObject = call.remoteStream;
   * await client.applySelectedAudioOutputDevice(audioEl);
   * ```
   */
  applySelectedAudioOutputDevice(element: HTMLMediaElement): Promise<boolean>;
  /** Starts monitoring for media device changes (connect/disconnect). */
  enableDeviceMonitoring(): void;
  /** Stops monitoring for media device changes. */
  disableDeviceMonitoring(): void;
  /**
   * Returns the capabilities of a media device.
   * @param deviceInfo - The device to query.
   * @returns The device capabilities, or `null` if unavailable.
   */
  getDeviceCapabilities(deviceInfo: MediaDeviceInfo): Promise<MediaTrackCapabilities | null>;
  /**
   * Checks whether a device is still available and usable.
   * @param deviceInfo - The device to validate, or `null`.
   * @returns `true` if the device is valid and available. Returns `false` for `null`, audio output devices, or unavailable devices.
   */
  isValidDevice(deviceInfo: MediaDeviceInfo | null): Promise<boolean>;
  /** Injects a storage manager into the device controller for persistence. */
  setStorageManager(storageManager: StorageManager): void;
  /** Clears all device state and re-enumerates. */
  clearDeviceState(): Promise<void>;
  /** Forces a device re-enumeration. */
  enumerateDevices(): Promise<void>;
  /** Disables audio input (receive-only mode). No audio track will be acquired. */
  disableAudioInput(): void;
  /** Re-enables audio input, restoring the last selection or auto-selecting. */
  enableAudioInput(): void;
  /** Disables video input (receive-only mode). No video track will be acquired. */
  disableVideoInput(): void;
  /** Re-enables video input, restoring the last selection or auto-selecting. */
  enableVideoInput(): void;
  /** Observable that emits `true` when video input is disabled (receive-only). */
  get videoInputDisabled$(): Observable<boolean>;
  /** Observable that emits `true` when audio input is disabled (receive-only). */
  get audioInputDisabled$(): Observable<boolean>;
  /** Whether video input is currently disabled. */
  get videoInputDisabled(): boolean;
  /** Whether audio input is currently disabled. */
  get audioInputDisabled(): boolean;
  /**
   * Triggers the browser's media permission dialog and captures the user's device selections.
   *
   * @param options - Which permissions to request.
   * @param options.audio - Whether to request audio permission.
   * @param options.video - Whether to request video permission.
   * @returns The permission result with selected devices.
   */
  requestMediaPermissions(options?: {
    audio?: boolean;
    video?: boolean;
  }): Promise<PermissionResult>;
  /**
   * Clears all SDK-persisted state and resets to defaults.
   *
   * This clears device preferences, device history, authorization state,
   * attached call IDs, and all SDK storage keys, then re-enumerates devices.
   */
  resetToDefaults(): Promise<void>;
  /**
   * Destroys the client, clearing timers and releasing all resources.
   *
   * Intentionally destroying the client ends its session: the resume state
   * (`authorization_state` + protocol) and the attach records are both
   * cleared. Credentials and device preferences are preserved — use
   * {@link resetToDefaults} for a full wipe. To temporarily stop receiving
   * inbound calls while keeping the session alive, use `unregister()`.
   */
  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/dependencies/EmbedTokenCredentialProvider.d.ts
/** Credential provider that exchanges an embed token for a SAT via the host's token endpoint. */
declare class EmbedTokenCredentialProvider implements CredentialProvider {
  private host;
  private embedToken;
  constructor(host: string, embedToken: string);
  private fetchSAT;
  authenticate(): Promise<{
    token: string;
    expiry_at: number;
  }>;
  refresh(): Promise<{
    token: string;
    expiry_at: number;
  }>;
}
//#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 AudioConstraintsEvent, type AuthenticateContext, AuxiliaryLegCancelledError, AuxiliaryLegTimeoutError, type Call, type CallAddress, type CallCapabilitiesState, CallCreateError, type CallDiagnosticSummary, type CallDirection, type CallError, type CallErrorKind, type NetworkIssue as CallNetworkIssue, type NetworkIssue, type NetworkMetrics as CallNetworkMetrics, type NetworkMetrics, CallNotReadyError, type CallOptions, type CallParticipant, type CallSelfParticipant, type CallState, type CallStatus, type Capability, ClientPreferences, CollectionFetchError, type ConstraintFallbackEvent, type CredentialNoRefreshHandlerWarning, type CredentialProvider, type CredentialRefreshFallbackReason, type CredentialRefreshFallbackWarning, DPoPInitError, type DebugOptions, type DeviceController, type DeviceRecoveryEvent, DeviceTokenError, type DiagnosticEvent, type DialOptions, type Directory, EmbedTokenCredentialProvider, type ExecuteMethod, InvalidCredentialsError, type JSONRPCErrorResponse, type JSONRPCRequest, type JSONRPCResponse, type JSONRPCSuccessResponse, type LayoutLayer, type LogLevel, MediaAccessError, type MediaDirection, type MediaDirections, type MediaOptions, type MediaParamsEvent, MediaTrackError, type MemberCapabilities, MessageParseError, type NodeSocketAdapter, type OnOffCapability, OverconstrainedFallbackError, Participant, ParticipantNotReadyError, type PendingRPCOptions, type PermissionResult, type PlatformCapabilities, PreflightError, type PreflightOptions, type PreflightResult, type QualityLevel, RecoveryError, type RecoveryEvent, type RecoveryState, type ResilienceCallStatus, type SATClaims, type SDKCredential, type SDKLogger, type SDKWarning, ScreenShareAlreadyActiveError, type ScreenShareOptions, type ScreenShareStatus, type SelectDeviceOptions, SelfCapabilities, SelfParticipant, type SessionDiagnostics, type SessionState, SignalWire, type SignalWireOptions, StaticCredentialProvider, type Storage, type StoredDevicePreference, type TextMessage, TokenRefreshError, type TransferOptions, UnexpectedError, User, type UserPresence, VertoPongError, type VideoPosition, type WebRTCApiProvider, WebRTCCall, type WebRTCMediaDevices, type WebSocketAdapter, embeddableCall, getLogger, isSelfParticipant, ready, setDebugOptions, setLogLevel, setLogger, version };
//# sourceMappingURL=index.d.cts.map