@dialstack/sdk-native 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,2367 @@
+import React from 'react';
+import { CountryCode } from 'libphonenumber-js';
+
+/** The minimal list-envelope shape auto-pagination needs. */
+interface Page<I> {
+    data: I[];
+    next_page_url: string | null;
+}
+/** Item type carried by a page envelope. */
+type PageItem<P> = P extends Page<infer I> ? I : never;
+/**
+ * A promise of the first page, augmented with auto-pagination iterators that
+ * lazily fetch subsequent pages by following `next_page_url`.
+ */
+interface PaginatedList<P extends Page<unknown>> extends Promise<P> {
+    autoPagingEach(): AsyncIterableIterator<PageItem<P>>;
+    autoPagingToArray(options?: {
+        limit?: number;
+    }): Promise<PageItem<P>[]>;
+}
+
+/**
+ * WebRTC platform primitives + types the call/signaling core builds on.
+ *
+ * There is no longer a `.native` counterpart to this module. The core is written
+ * to the standard browser WebRTC surface (`globalThis.RTCPeerConnection`,
+ * `MediaStream`, `navigator.mediaDevices`); React Native makes that surface exist
+ * at runtime by calling `react-native-webrtc`'s `registerGlobals()` at app
+ * startup (see the RN example apps). The two genuinely-RN-only gaps — ringback
+ * audio (WebAudio vs InCallManager) and key/value persistence (localStorage vs a
+ * host store) — are NOT resolved here; they are injected by the caller
+ * (`PhoneOptions.ringback` / `PhoneOptions.storage`).
+ *
+ * The factory functions read the relevant global *lazily* (at call time, not at
+ * module load) so a test harness that swaps `globalThis.RTCPeerConnection` /
+ * `MediaStream` / `navigator` in a `beforeEach` still takes effect — capturing
+ * the constructors in module-scope `const`s would bind whatever existed when
+ * this module was first imported (often `undefined` under jsdom).
+ *
+ * WebRTC TYPES are re-exported here so the core imports them from `./platform`
+ * rather than depending on the ambient `lib.dom.d.ts` names directly.
+ */
+type RTCPeerConnection = globalThis.RTCPeerConnection;
+type MediaStream = globalThis.MediaStream;
+type RTCIceServer$1 = globalThis.RTCIceServer;
+type RTCSessionDescriptionInit = globalThis.RTCSessionDescriptionInit;
+/**
+ * Synchronous key/value persistence for the E911 address id. This web default is
+ * backed by `localStorage`, guarded so the core also works in non-browser hosts
+ * (Node/tests) where `localStorage` is absent — there, persistence is a no-op and
+ * the app supplies `PhoneOptions.emergencyAddressId` itself. React Native has no
+ * `localStorage`, so the RN softphone provider injects a host-backed adapter via
+ * `PhoneOptions.storage` (MMKV/AsyncStorage); this default is never reached there.
+ */
+interface PlatformStorage {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+}
+
+/**
+ * Outbound ringback contract the call core drives. The core never guards the
+ * call site, so implementations must be idempotent and no-op silently when their
+ * audio backend is unavailable. Web is `RingbackTone` (WebAudio); React Native
+ * supplies its own (InCallManager-backed) via `PhoneOptions.ringback`, because
+ * WebAudio's `AudioContext` doesn't exist there.
+ */
+interface Ringback {
+    readonly isPlaying: boolean;
+    start(): void;
+    stop(): void;
+    /**
+     * Route the tone to a specific output device, or null for the OS default.
+     *
+     * OPTIONAL: an implementation whose backend has no per-device routing simply
+     * omits it (React Native routes audio through InCallManager, not per-device),
+     * and the core calls it as `ringback.setSinkId?.(id)` so an omission is a no-op
+     * rather than a crash. Like start/stop, an implementation that has it must
+     * no-op instead of throwing when its backend can't honor the request.
+     */
+    setSinkId?(deviceId: string | null): void;
+}
+
+type PhoneErrorCode = 'auth_failed' | 'auth_expired' | 'invalid_message' | 'call_failed' | 'call_not_found' | 'emergency_address_required' | 'session_limit' | 'session_replaced' | 'session_revoked' | 'rate_limited' | 'presence_unavailable' | 'reachability_unavailable' | 'internal_error' | 'going_away' | 'idle_timeout' | 'slow_consumer' | 'transport_closed' | 'ice_fetch_failed' | 'mic_permission_denied' | 'audio_device_unavailable' | 'audio_device_in_use';
+declare class PhoneError extends Error {
+    readonly code: PhoneErrorCode;
+    readonly callId: string | null;
+    readonly fatal: boolean;
+    constructor(opts: {
+        code: PhoneErrorCode;
+        message: string;
+        callId?: string | null;
+        fatal?: boolean;
+    });
+}
+
+type CallState = 'trying' | 'ringing' | 'active' | 'held' | 'ended';
+type CallDirection = 'inbound' | 'outbound';
+type CallEndReason = 'hangup' | 'no-answer' | 'busy' | 'failed' | 'transferred' | 'rejected';
+type RejectReason = 'busy' | 'decline';
+type HeldBy = 'local' | 'remote';
+type PresenceStatus = 'available' | 'on_call' | 'dnd' | 'away' | 'offline';
+type SettablePresenceStatus = 'available' | 'dnd' | 'away';
+interface PhoneOptions {
+    token: string;
+    apiBaseUrl?: string;
+    /**
+     * Base URL of the signaling server the phone opens its WebSocket to, e.g.
+     * `wss://webrtc.dialstack.ai`. The signaling host is separate from
+     * `apiBaseUrl` (the REST API) and is served by region-aware infrastructure,
+     * so latency-based DNS routes each client to the nearest region
+     * automatically — no client-side region selection is needed.
+     *
+     * When omitted, it defaults to the standard signaling host derived from
+     * `apiBaseUrl` (the `api.` hostname label becomes `webrtc.`). Override only
+     * for self-hosting, staging, or a proxy. `ws`/`wss` and `http`/`https` are
+     * accepted; `http(s)` is upgraded to `ws(s)`. A trailing `/v1/webrtc` path
+     * is appended automatically if absent.
+     */
+    signalingBaseUrl?: string;
+    onTokenExpiring?: () => Promise<string>;
+    autoReconnect?: boolean;
+    iceServers?: RTCIceServer[];
+    /**
+     * The emergency-address resource id (emerg_…) this softphone uses for E911.
+     * Presented on the authenticate handshake so the server can bind
+     * it to the current network. When omitted, a previously persisted id (see
+     * `setEmergencyAddress`) is loaded from `storage` if available.
+     */
+    emergencyAddressId?: string;
+    /**
+     * Synchronous key/value store used to persist the selected E911 address id
+     * across launches. Optional at this layer: it defaults to the platform seam's
+     * store — `localStorage` on web, an in-memory (non-persisting) store on React
+     * Native. On React Native the softphone provider requires the host to supply a
+     * real store (e.g. an AsyncStorage- or MMKV-backed adapter), because the SDK
+     * takes no persistence dependency of its own.
+     */
+    storage?: PlatformStorage;
+    /**
+     * Outbound ringback tone. Defaults to the WebAudio `RingbackTone`. React Native
+     * has no `AudioContext`, so the RN softphone provider supplies an
+     * `InCallManager`-backed implementation here. One instance is shared across
+     * calls (outbound ringback plays one call at a time).
+     */
+    ringback?: Ringback;
+    /**
+     * Opens the signaling WebSocket. Defaults to a bare `new WebSocket(url,
+     * protocols)`. React Native supplies a variant that attaches a `User-Agent`
+     * header (the signaling ingress 403s a handshake without one, and iOS's
+     * WebSocket sends none by default); browsers forbid overriding it, so web uses
+     * the default.
+     */
+    createSignalingSocket?: SignalingSocketFactory;
+    /**
+     * Subscribe to "the app/tab returned to the foreground". Defaults to the web
+     * DOM lifecycle events (`visibilitychange`/`focus`/`online`/`pageshow`); React
+     * Native has no `document`, so the RN softphone provider supplies an
+     * `AppState`-backed variant here. On resume the transport actively re-verifies
+     * the connection (a backgrounded tab's throttled event loop may never have
+     * processed the socket's close), reconnecting if it's dead.
+     */
+    onAppResume?: AppResumeSubscribe;
+    /**
+     * Microphone `deviceId` for new calls; omitted means the OS default. Held for the
+     * phone's lifetime and NOT persisted — remembering a device is the host's call, so
+     * pass a saved value back in on construction (the React softphone does).
+     *
+     * An id that no longer resolves falls back to the default rather than failing the
+     * call, since ids are origin-scoped and rotate.
+     */
+    audioInputDeviceId?: string;
+    /**
+     * Speaker `deviceId` for the ringback tone only; not persisted. Remote call audio
+     * plays through a media element the host owns, and only its owner can route it.
+     */
+    audioOutputDeviceId?: string;
+}
+/** One selectable audio device, as reported by the host. */
+interface AudioDevice {
+    /** Opaque, origin-scoped id to pass to `setAudioInputDevice` / `setSinkId`. */
+    deviceId: string;
+    /** Name, or `''` when the page has no mic permission yet. */
+    label: string;
+    /** Shared by the input and output halves of one physical device. */
+    groupId: string;
+    /** True for the entry whose id is literally 'default'. */
+    isDefault: boolean;
+}
+/** The host's audio devices, split by direction. */
+interface AudioDeviceList {
+    inputs: AudioDevice[];
+    outputs: AudioDevice[];
+    /** False when devices exist but their names are withheld pending mic permission. */
+    labelsAvailable: boolean;
+    /** False when the host can't enumerate at all — distinct from "no devices". */
+    supported: boolean;
+}
+/**
+ * Civic address submitted to register an emergency (E911) location. Validated
+ * against the carrier MSAG; an invalid address is rejected.
+ */
+interface EmergencyAddressInput {
+    address_number?: string;
+    street: string;
+    unit?: string;
+    city: string;
+    state: string;
+    postal_code: string;
+    country?: string;
+}
+/** A registered emergency address resource. */
+interface EmergencyAddress {
+    id: string;
+    address: EmergencyAddressDetails;
+    /** Network this address is bound to, or null when not yet registered. */
+    registered_ip: string | null;
+    created_at: string;
+}
+/** Normalized civic address fields returned on an EmergencyAddress. */
+interface EmergencyAddressDetails {
+    address_number?: string;
+    street?: string;
+    unit?: string;
+    city: string;
+    state: string;
+    postal_code: string;
+    country: string;
+    formatted_address?: string;
+    latitude?: number;
+    longitude?: number;
+}
+/** ListResponse envelope (the only place `object: "list"` appears). */
+interface ListResponse<T> {
+    object: 'list';
+    url: string;
+    next_page_url: string | null;
+    previous_page_url: string | null;
+    data: T[];
+}
+interface PresenceEntry {
+    userId: string;
+    name: string;
+    status: PresenceStatus;
+    /**
+     * Whether the user has server-side Do Not Disturb enabled. A separate axis
+     * from `status`: a user can be `available` but decline calls because DND is on.
+     *
+     * The two answer different questions. DND is configuration — it persists until
+     * someone changes it. `status` is a lossy summary of currently observed
+     * signals, reduced to one value by the precedence on_call > available >
+     * offline, so a user on a call reports `on_call` even with no registered
+     * device. DND is never reported as a `status` value.
+     */
+    doNotDisturb: boolean;
+    statusText: string | null;
+    updatedAt: string;
+}
+interface PresenceUpdate {
+    userId: string;
+    name: string;
+    status: PresenceStatus;
+    /**
+     * Whether the user has server-side Do Not Disturb enabled. A separate axis
+     * from `status`: a user can be `available` but decline calls because DND is on.
+     *
+     * The two answer different questions. DND is configuration — it persists until
+     * someone changes it. `status` is a lossy summary of currently observed
+     * signals, reduced to one value by the precedence on_call > available >
+     * offline, so a user on a call reports `on_call` even with no registered
+     * device. DND is never reported as a `status` value.
+     */
+    doNotDisturb: boolean;
+    statusText: string | null;
+    updatedAt: string;
+}
+interface DirectoryEntry {
+    /** The colleague's user id (`user_…`). */
+    user: string;
+    /** Display name to show. */
+    displayName: string;
+}
+type ClientMessage = {
+    type: 'authenticate';
+    req_id?: string;
+    token: string;
+    emergency_address_id?: string;
+} | {
+    type: 'auth.refresh';
+    req_id?: string;
+    token: string;
+} | {
+    type: 'ping';
+    req_id?: string;
+} | {
+    type: 'call.create';
+    req_id?: string;
+    destination: string;
+    sdp: string;
+} | {
+    type: 'call.answer';
+    call_id: string;
+} | {
+    type: 'call.reject';
+    call_id: string;
+    reason?: RejectReason;
+} | {
+    type: 'call.hangup';
+    call_id: string;
+} | {
+    type: 'call.hold';
+    call_id: string;
+} | {
+    type: 'call.resume';
+    call_id: string;
+} | {
+    type: 'call.mute';
+    call_id: string;
+} | {
+    type: 'call.transfer';
+    call_id: string;
+    destination: string;
+} | {
+    type: 'call.transfer.attended';
+    req_id?: string;
+    call_id: string;
+    step: 'consult' | 'complete';
+    destination?: string;
+    sdp?: string;
+} | {
+    type: 'call.unmute';
+    call_id: string;
+} | {
+    type: 'sdp.offer';
+    call_id: string;
+    sdp: string;
+} | {
+    type: 'sdp.answer';
+    call_id: string;
+    sdp: string;
+} | {
+    type: 'ice.candidate';
+    call_id: string;
+    candidate: string;
+    sdp_mid: string | null;
+    sdp_m_line_index: number | null;
+} | {
+    type: 'ice.done';
+    call_id: string;
+} | {
+    type: 'presence.subscribe';
+    req_id?: string;
+    users: string[];
+};
+interface PresenceEntryWire {
+    user_id: string;
+    name: string;
+    status: PresenceStatus;
+    do_not_disturb?: boolean;
+    status_text?: string | null;
+    updated_at: string;
+}
+type ServerMessage = {
+    type: 'authenticated';
+    req_id?: string | null;
+    user_id: string;
+    account_id: string;
+    reconnected?: boolean;
+} | {
+    type: 'auth.refreshed';
+    req_id?: string | null;
+} | {
+    type: 'pong';
+    req_id?: string | null;
+} | {
+    type: 'network.changed';
+} | {
+    type: 'error';
+    code: string;
+    message: string;
+    req_id?: string | null;
+    call_id?: string | null;
+    fatal?: boolean;
+    context?: {
+        users?: string[];
+    };
+} | {
+    type: 'call.trying';
+    call_id: string;
+    req_id?: string | null;
+} | {
+    type: 'call.ringing';
+    call_id: string;
+} | {
+    type: 'call.incoming';
+    call_id: string;
+    from: string;
+    from_name: string | null;
+    to: string;
+} | {
+    type: 'call.answered';
+    call_id: string;
+    answered_at?: string;
+} | {
+    type: 'call.ended';
+    call_id: string;
+    reason: CallEndReason;
+    duration_seconds: number | null;
+} | {
+    type: 'call.restored';
+    call_id: string;
+    state: 'ringing' | 'active' | 'held';
+    from: string;
+    from_name: string | null;
+    to: string;
+    direction: CallDirection;
+    answered_at: string | null;
+} | {
+    type: 'call.held';
+    call_id: string;
+    held_by: HeldBy;
+} | {
+    type: 'call.resumed';
+    call_id: string;
+} | {
+    type: 'sdp.offer';
+    call_id: string;
+    sdp: string;
+} | {
+    type: 'sdp.pranswer';
+    call_id: string;
+    sdp: string;
+} | {
+    type: 'sdp.answer';
+    call_id: string;
+    sdp: string;
+} | {
+    type: 'ice.candidate';
+    call_id: string;
+    candidate: string;
+    sdp_mid: string | null;
+    sdp_m_line_index: number | null;
+} | {
+    type: 'ice.done';
+    call_id: string;
+} | {
+    type: 'presence.list';
+    req_id?: string | null;
+    users: PresenceEntryWire[];
+} | ({
+    type: 'presence.update';
+} & PresenceEntryWire);
+
+/**
+ * Opens the signaling WebSocket. Defaults to a bare `new WebSocket(url,
+ * protocols)` (web). React Native needs a variant that attaches a `User-Agent`
+ * header — the signaling ingress 403s a handshake without one, and iOS's
+ * WebSocket sends none by default — so the RN softphone provider supplies its
+ * own factory here. Browsers forbid overriding `User-Agent`, so web never does.
+ */
+type SignalingSocketFactory = (url: string, protocols: string[]) => WebSocket;
+/**
+ * Subscribe to "the environment came back to the foreground / regained the
+ * network" and return an unsubscribe fn. Injected like the socket factory: web
+ * uses the default below (DOM lifecycle events); React Native supplies an
+ * AppState-backed variant (there is no `document` on RN). The transport uses
+ * this to actively re-verify a connection the browser may have silently dropped
+ * while backgrounded.
+ */
+type AppResumeSubscribe = (cb: () => void) => () => void;
+type TransportEvents = {
+    open: () => void;
+    message: (msg: ServerMessage) => void;
+    closed: (reason: {
+        fatal: boolean;
+        error?: PhoneError;
+    }) => void;
+    reconnecting: (attempt: number, delayMs: number) => void;
+};
+declare class Transport {
+    private ws;
+    private url;
+    private listeners;
+    private reconnectAttempts;
+    private closedByUser;
+    private autoReconnect;
+    private createSocket;
+    private subscribeResume;
+    private terminalError;
+    private unsubscribeResume;
+    private probeTimer;
+    private probeInFlight;
+    private reconnectPending;
+    private stopped;
+    constructor(url: string, autoReconnect: boolean, createSocket?: SignalingSocketFactory, subscribeResume?: AppResumeSubscribe);
+    on<E extends keyof TransportEvents>(event: E, handler: TransportEvents[E]): void;
+    connect(): void;
+    /** True when the socket is open and a send() would succeed. */
+    isOpen(): boolean;
+    send(msg: ClientMessage): void;
+    /**
+     * Best-effort send for messages emitted on their own async timeline (ICE
+     * candidates fire from the peer connection, and can arrive while the socket is
+     * mid-reconnect or closed). Silently drops when the socket isn't open rather
+     * than throwing an uncaught error into an event handler. Trickle ICE tolerates
+     * loss, and a closed socket means the call is already tearing down.
+     */
+    trySend(msg: ClientMessage): void;
+    close(): void;
+    private openSocket;
+    private scheduleReconnect;
+    private onWake;
+    private forceReconnect;
+    private clearProbe;
+}
+
+type CallEventMap = {
+    trying: () => void;
+    ringing: () => void;
+    answered: () => void;
+    held: (by: HeldBy) => void;
+    resumed: () => void;
+    ended: (reason: CallEndReason) => void;
+    audioInputChanged: (deviceId: string | null) => void;
+    audioInputLost: () => void;
+};
+type Listener$1<K extends keyof CallEventMap> = CallEventMap[K];
+interface CallInit {
+    id: string;
+    direction: CallDirection;
+    from: string;
+    fromName: string | null;
+    to: string;
+    initialState: CallState;
+    transport: Transport;
+    iceServers: RTCIceServer$1[];
+    startConsult: (parent: Call, destination: string) => Promise<Call>;
+    ringback?: Ringback;
+    audioInputDeviceId?: string;
+    audioOutputDeviceId?: string;
+}
+declare class Call {
+    id: string;
+    readonly direction: CallDirection;
+    readonly from: string;
+    readonly fromName: string | null;
+    readonly to: string;
+    state: CallState;
+    isMuted: boolean;
+    duration: number;
+    readonly peerConnection: RTCPeerConnection;
+    get isHeld(): boolean;
+    /**
+     * Whether the call is a live, connected conversation — answered and not ended.
+     * Hold is a media modifier, not a separate lifecycle, so BOTH `active` and
+     * `held` count as connected; `trying`/`ringing` (not yet up) and `ended` do
+     * not. This is the single source of truth for "is this call
+     * transferable / bridgeable / controllable" — every such gate (transfer,
+     * completeTransfer, the in-call control row, isCallActive) reads it so the
+     * rule can't drift between call sites.
+     */
+    get isConnected(): boolean;
+    /**
+     * Whether DTMF can be sent on this call — the gate the softphone UI uses for
+     * its in-call keypad. False when the audio sender exposes no `.dtmf` (e.g. a
+     * connected call that never got a usable sender). Only meaningful once the
+     * call is active — the sender is attached during answer/offer negotiation
+     * (attachDtmfSender). `sendDtmf()` still throws if called anyway. Both web and
+     * native go through the same sender: web via the browser RTCDTMFSender, native
+     * via react-native-webrtc's `RTCRtpSender.dtmf` (provided by the DialStack fork).
+     */
+    get canSendDtmf(): boolean;
+    private transport;
+    private readonly startConsult;
+    private localStream;
+    private remoteStream;
+    private dtmfSender;
+    private durationTimer;
+    private answeredAt;
+    private listeners;
+    private endedSettled;
+    private pendingAnswerSdp;
+    private answerSent;
+    private wantsAnswer;
+    private localMediaReady;
+    private pendingRemoteCandidates;
+    private remoteDescriptionSet;
+    private readonly gatheringAborts;
+    private readonly ringback;
+    private remoteAudioFlowing;
+    private audioInputDeviceId_;
+    private switchChain;
+    constructor(init: CallInit);
+    whenLocalMediaReady(): Promise<void>;
+    private acquireLocalMedia;
+    /** The selected mic, or null for the OS default. */
+    get audioInputDeviceId(): string | null;
+    /**
+     * The device actually captured. May differ from `audioInputDeviceId` at acquisition,
+     * where the constraint is `ideal` — how a caller detects a substitution.
+     */
+    get effectiveAudioInputDeviceId(): string | null;
+    /** Internal — the phone-level setter broadcasts this to every live call. */
+    setAudioInputDevice(deviceId: string | null): Promise<void>;
+    private switchAudioInput;
+    /** Route this call's ringback tone to `deviceId` (null = OS default). */
+    setAudioOutputDevice(deviceId: string | null): void;
+    private watchCaptureTrack;
+    private get isFinished();
+    on<K extends keyof CallEventMap>(event: K, handler: Listener$1<K>): void;
+    off<K extends keyof CallEventMap>(event: K, handler?: Listener$1<K>): void;
+    answer(): void;
+    private sendAnswer;
+    reject(reason?: RejectReason): void;
+    hangup(): void;
+    hold(): void;
+    resume(): void;
+    mute(): void;
+    unmute(): void;
+    sendDtmf(digits: string, duration?: number, interToneGap?: number): void;
+    /**
+     * Blind transfer: immediately redirect the remote party to `destination`.
+     * Fire-and-forget — on success the call ends with reason 'transferred';
+     * on failure a non-fatal error is emitted and the call stays active.
+     * The call must be active.
+     */
+    transfer(destination: string): void;
+    /**
+     * Attended (consultative) transfer, step 1: hold this call and dial
+     * `destination` as a consult leg. Resolves with the consult Call. Once the
+     * consult party answers, call `completeTransfer()` on THIS call to bridge
+     * them; or hang up the consult and `resume()` to abandon the transfer.
+     */
+    attendedTransfer(destination: string): Promise<Call>;
+    /**
+     * Attended transfer, step 2: bridge the remote party to the consult leg's
+     * party. Valid once the consult call (started via `attendedTransfer`) is
+     * answered; this call is held at that point. On success both calls end
+     * with reason 'transferred'.
+     */
+    completeTransfer(): void;
+    private assertTransferable;
+    get remoteMediaStream(): MediaStream;
+    startOutbound(): Promise<RTCSessionDescriptionInit>;
+    prepareAnswerForOffer(sdp: string): Promise<void>;
+    private buildAnswer;
+    acceptRemoteProvisionalAnswer(sdp: string): Promise<boolean>;
+    acceptRemoteAnswer(sdp: string): Promise<void>;
+    addRemoteCandidate(candidate: string, sdpMid: string | null, sdpMLineIndex: number | null): Promise<void>;
+    private flushPendingRemoteCandidates;
+    handleServerMessage(msg: ServerMessage): void;
+    dispose(): void;
+    private settleEnded;
+    private releaseMedia;
+    private onRemoteAudioFlowing;
+    private wirePeerConnection;
+    private waitForIceGatheringComplete;
+    private abortIceGathering;
+    private hasLocalCandidate;
+    private localDescriptionOr;
+    private attachDtmfSender;
+    private startDurationTimer;
+    private stopDurationTimer;
+    private emit;
+}
+
+type PhoneEventMap = {
+    connected: () => void;
+    disconnected: (error?: PhoneError) => void;
+    reconnected: () => void;
+    reconnecting: (attempt: number, delayMs: number) => void;
+    incoming: (call: Call) => void;
+    presenceList: (entries: PresenceEntry[]) => void;
+    presenceUpdate: (update: PresenceUpdate) => void;
+    'network.changed': () => void;
+    audioDevicesChanged: (devices: AudioDeviceList) => void;
+    error: (err: PhoneError) => void;
+};
+type Listener<K extends keyof PhoneEventMap> = PhoneEventMap[K];
+declare class DialStackPhone {
+    isConnected: boolean;
+    readonly activeCalls: Call[];
+    private token;
+    private apiBaseUrl;
+    private signalingUrl;
+    private autoReconnect;
+    private iceServersOverride;
+    private onTokenExpiring;
+    private ringback;
+    private createSignalingSocket;
+    private onAppResume;
+    private transport;
+    private readonly handshake;
+    private iceServers;
+    private listeners;
+    private pendingOutbound;
+    private pendingCall;
+    private hasConnectedOnce;
+    private reqSeq;
+    private tokenRefreshTimer;
+    private pendingRefresh;
+    private emergencyAddressId;
+    private presentedEmergencyAddressId_;
+    private storageUserId;
+    private storage;
+    private audioInputDeviceId_;
+    private audioOutputDeviceId_;
+    private deviceChangeUnsubscribe;
+    constructor(options: PhoneOptions);
+    /** The microphone `deviceId` new calls capture, or null for the OS default. */
+    get audioInputDeviceId(): string | null;
+    /** The speaker `deviceId` the ringback plays through, or null for the OS default. */
+    get audioOutputDeviceId(): string | null;
+    /**
+     * Record a microphone preference WITHOUT acquiring it — for a host restoring a saved
+     * selection at construction time. `setAudioInputDevice` probes the device, which
+     * prompts for permission when no call is up; this doesn't, so a returning user isn't
+     * asked for the mic on page load. An id that no longer resolves falls back to the
+     * default at the next call's acquisition.
+     */
+    seedAudioInputDevice(deviceId: string | null): void;
+    /**
+     * Select the microphone: seeds future calls and live-switches calls already up. Held
+     * for this phone's lifetime only — saving the choice across sessions is the host's
+     * (the React softphone does it). Rejects without recording the id when the device
+     * can't be acquired. A single live call's failure surfaces on `error` rather than
+     * rejecting, so one bad call can't leave the others behind.
+     */
+    setAudioInputDevice(deviceId: string | null): Promise<void>;
+    /**
+     * Select the speaker for the ringback tone. Does NOT route remote call audio — that
+     * plays through a media element the host owns, and only its owner can call
+     * `setSinkId`. Void-returning because nothing here is verified or awaited.
+     */
+    setAudioOutputDevice(deviceId: string | null): void;
+    /**
+     * The available audio devices. Deliberately does not prompt for mic access — opening
+     * a picker shouldn't spring a permission dialog — so names stay hidden until
+     * permission has been granted once (`labelsAvailable: false`).
+     */
+    listAudioDevices(): Promise<AudioDeviceList>;
+    on<K extends keyof PhoneEventMap>(event: K, handler: Listener<K>): void;
+    off<K extends keyof PhoneEventMap>(event: K, handler?: Listener<K>): void;
+    /**
+     * Reference-counted off the existing listener set.
+     *
+     * Deliberately NOT tied to connect/disconnect: `reconnect()` calls `disconnect()`, so
+     * releasing there would permanently kill device events after any reconnect.
+     */
+    private syncDeviceChangeSubscription;
+    connect(): Promise<void>;
+    disconnect(): void;
+    /**
+     * Tear down and reconnect, re-running the `authenticate` handshake. The new
+     * session presents the current `emergencyAddressId`, which is where the server
+     * binds the emergency address to the connection's network — so this is how an
+     * app applies a just-selected/created address (or re-binds after a network
+     * move). Safe to call while idle; any live calls are torn down.
+     */
+    reconnect(): Promise<void>;
+    /**
+     * Re-present a chosen `emergencyAddressId` on a fresh authenticate handshake, in
+     * one call. Rebinding requires a fresh socket (the server binds E911 once per
+     * connection, after REGISTER), so this tears down and reconnects like
+     * `reconnect()`; resolves once the server confirms the new binding.
+     */
+    reconnectWithEmergency(emergencyAddressId: string): Promise<void>;
+    call(destination: string): Promise<Call>;
+    private startConsult;
+    private placeOutbound;
+    getCall(callId: string): Call | undefined;
+    /**
+     * Subscribe to presence (BLF) for an explicit, bounded set of users. The
+     * watch set is required and non-empty — there is no whole-account default —
+     * and is capped at {@link MAX_PRESENCE_TARGETS}; both bounds mirror the
+     * server, which rejects a bad list with a non-fatal `invalid_message` error.
+     *
+     * The server replies with a `presence.list` snapshot (emitted as
+     * `presenceList`), always before any `presence.update` delta
+     * (`presenceUpdate`) for the users that snapshot introduces. Deltas follow as
+     * those users' status changes.
+     *
+     * A status is `available`, `on_call`, or `offline` — `offline` meaning the user
+     * has no registered device and so cannot currently receive calls. The first
+     * delta after a snapshot may restate a status the snapshot already reported, so
+     * key the roster by `userId` and upsert.
+     *
+     * Users whose subscription can't be established are omitted from the snapshot
+     * and named in a non-fatal `presence_unavailable` error (its `PhoneError`
+     * carries no user list; listen on `error` for the code).
+     */
+    subscribePresence(userIds: string[]): void;
+    setPresence(_status: SettablePresenceStatus, _statusText?: string): Promise<void>;
+    /**
+     * Register and validate an emergency (E911) address. Creates the
+     * resource via the REST API (validated against the carrier MSAG), persists
+     * its id, and presents it on the next connect so the server binds it to the
+     * device's network. This does not alter an already-authenticated session. To
+     * apply a new address there (e.g. responding to a `network.changed` event),
+     * pass the returned id to `reconnectWithEmergency()`.
+     *
+     * Rejects with a `PhoneError` (code `invalid_message`) when the address
+     * can't be validated.
+     */
+    setEmergencyAddress(address: EmergencyAddressInput): Promise<EmergencyAddress>;
+    /**
+     * Select an already-saved emergency address to present on the next
+     * (re)connect (sets + persists it). The server binds it at the authenticate
+     * handshake, so call `reconnect()` afterwards for it to take effect.
+     */
+    selectEmergencyAddress(id: string): void;
+    /**
+     * The emergency-address id actually sent in the CURRENT socket's authenticate
+     * frame (latched at send time), or null. This is what the E911 gate keys off —
+     * a saved address's `registered_ip`, or a selection made without a reconnect,
+     * does NOT mean this session bound it.
+     */
+    get presentedEmergencyAddressId(): string | null;
+    /** Fetch a saved emergency address (defaults to the one this phone uses). */
+    getEmergencyAddress(id?: string): Promise<EmergencyAddress>;
+    /**
+     * List the user's saved emergency addresses (location profiles).
+     *
+     * Auto-paginating: `await` it for the first page envelope, or iterate the
+     * full collection with `autoPagingEach()` / `autoPagingToArray()` —
+     * subsequent pages are fetched lazily.
+     */
+    listEmergencyAddresses(): PaginatedList<ListResponse<EmergencyAddress>>;
+    /**
+     * List the account directory — the colleagues this user may see, by name
+     * (`GET /v1/me/directory`). Resolved from the session token alone (no account
+     * context needed), so a softphone can discover who to watch for presence, or
+     * populate a contact / transfer picker, without its backend supplying the set.
+     *
+     * Auto-paginates the whole directory and returns a flat list. To watch every
+     * colleague's presence: `phone.subscribePresence((await phone.listDirectory()).map(e => e.user))`.
+     * Note presence subscription accepts at most 100 users at once, so watching a
+     * very large directory means subscribing to a subset.
+     */
+    listDirectory(): Promise<DirectoryEntry[]>;
+    /** Delete a saved emergency address. Clears the local selection if it matched. */
+    deleteEmergencyAddress(id: string): Promise<void>;
+    /**
+     * Clear an address's network binding (registered_ip) via the REST API. The
+     * next connect re-registers the current network. Useful after a move so the
+     * address re-binds where the device now is.
+     */
+    clearEmergencyAddressRegisteredIp(id: string): Promise<void>;
+    private nextReqId;
+    private adoptToken;
+    private scheduleTokenRefresh;
+    private fireTokenRefresh;
+    private clearTokenRefreshTimer;
+    private apiRequest;
+    private fetchIceServers;
+    private handleMessage;
+    private handleIncoming;
+    private emit;
+}
+
+/**
+ * `usePhone` — sole owner of the softphone's `DialStackPhone` instance and its
+ * connection lifecycle, web and React Native.
+ *
+ * It constructs the phone from credentials, subscribes to the connection events
+ * (connected / reconnecting / disconnected / fatal error / network.changed),
+ * maps them to a single `connection` state, and tears the phone down on unmount /
+ * credential change. It does NOT know about call legs — call state lives in
+ * `useCalls(phone, ...)`, and E911 provisioning in `useEmergencyBinding(phone, ...)`.
+ * Both are handed the live `phone` this hook owns.
+ *
+ * It is platform-agnostic: it imports only the headless core (`../../webrtc`),
+ * never the DOM or React Native.
+ */
+
+/** Connection lifecycle surfaced to the softphone UI. */
+type SoftphoneConnectionState = 'idle' | 'connecting' | 'connected' | 'reconnecting' | 'disconnected' | 'error';
+
+/**
+ * `useCallActions` — platform-agnostic per-call imperative actions, shared
+ * web ↔ RN.
+ *
+ * Wraps the foreground `Call`'s imperative actions (answer / reject / hangup /
+ * mute / hold / DTMF / transfer) so both softphones call them identically, with
+ * the same `PhoneError` → `onError` normalization. This is call CONTROL only —
+ * no view-state. In-call presentation state (the keypad/transfer overlay flags of
+ * the built-in `OngoingCall`) lives in `useCallOverlays`, so a consumer building a
+ * custom layout gets these actions without any built-in-UI plumbing. It
+ * deliberately does NOT render anything — it returns plain callbacks the platform
+ * UI binds to its own controls.
+ */
+
+/**
+ * The imperative actions for one specific call, with core throws contained via
+ * `onError`. This is the per-call subset shared by every call surface (the
+ * foreground in-call controls AND an incoming/held card): each card binds these
+ * to a specific `Call` rather than only the foreground one.
+ */
+interface CallActions {
+    answer: () => void;
+    reject: () => void;
+    hangup: () => void;
+    toggleMute: () => void;
+    toggleHold: () => void;
+    /** Send a DTMF digit (no-op when no call). */
+    sendDtmf: (digit: string) => void;
+}
+interface UseCallActions extends CallActions {
+    /**
+     * Blind-transfer the active call to `destination`. Returns `true` when the
+     * transfer was *initiated* (so the UI can close its transfer overlay), `false`
+     * on empty input or a synchronous failure routed to `onError`. `true` means
+     * initiated, not confirmed — the core call is fire-and-forget, so the outcome
+     * arrives later as the call ending ('transferred') or an `onError`.
+     */
+    transfer: (destination: string) => boolean;
+    /**
+     * Build the per-call action subset for a SPECIFIC call — used by the
+     * incoming/held cards, which act on a call that isn't the foreground one. The
+     * foreground actions above are exactly `callActionsFor(activeCall)`.
+     */
+    callActionsFor: (call: Call | null) => CallActions;
+}
+
+/**
+ * `useCallOverlays` — the in-call overlay flags, shared web ↔ RN.
+ *
+ * These are presentation state for ONE screen (the built-in `OngoingCall`): the
+ * DTMF keypad panel, the blind-transfer input, the add-call dial input, and the
+ * audio-device picker, which are mutually exclusive.
+ * They are deliberately kept OUT of `useCallActions` (which is platform-agnostic
+ * call control) so a consumer building a custom layout gets call control without
+ * this built-in-UI plumbing. It's a shared hook rather than local `OngoingCall`
+ * state only so web and React Native can't drift on WHEN the overlays reset.
+ */
+
+interface UseCallOverlays {
+    /** Whether the in-call DTMF keypad overlay is showing. */
+    showKeypad: boolean;
+    /** Whether the in-call transfer input overlay is showing. */
+    showTransfer: boolean;
+    /** Whether the in-call audio-device picker is showing. */
+    showDevices: boolean;
+    /** Whether the in-call add-call dial input is showing. */
+    showAddCall: boolean;
+    /** Toggle the DTMF keypad (closes the other overlays — they're exclusive). */
+    toggleKeypad: () => void;
+    /** Toggle the transfer input (closes the other overlays). */
+    toggleTransfer: () => void;
+    /** Toggle the audio-device picker (closes the other overlays). */
+    toggleDevices: () => void;
+    /** Toggle the add-call dial input (closes the other overlays). */
+    toggleAddCall: () => void;
+    /** Close the transfer overlay (e.g. after a transfer is handed off). */
+    closeTransfer: () => void;
+    /** Close the add-call overlay (e.g. once the second call is placed). */
+    closeAddCall: () => void;
+}
+
+/**
+ * `useEmergencyBinding` — the Softphone's built-in E911 provisioning logic.
+ *
+ * Model: "always send it, the server decides." The server binds the presented
+ * emergency address to the connection's network at the `authenticate` handshake
+ * and is the authority on whether it's valid here — it rejects a mismatch via
+ * the `network.changed` signal.
+ *
+ *   - On connect, if the session has a saved address but presented none (fresh
+ *     browser), auto-present it (select + reconnect once). Same network → the
+ *     server binds it silently (reused). Different network → the server denies
+ *     (network.changed) → we prompt.
+ *   - `bound` is true unless the server denied (network.changed) or there is no
+ *     saved address to present at all.
+ *
+ * When the host supplies `emergencyAddressId`, it manages E911 itself and this
+ * hook stays dormant (`disabled`). 911/933 are never gated by any of this.
+ *
+ * It talks to the `DialStackPhone` (owned by `usePhone`) DIRECTLY via a narrow
+ * interface — the subset of phone methods E911 needs. That interface is the
+ * hook's testable seam: a test passes a small phone-shaped stub, no full mock.
+ */
+
+interface UseEmergencyBinding {
+    /** True until the first post-connect status resolves. */
+    loading: boolean;
+    /**
+     * True when outbound PSTN is usable for this session — the server accepted the
+     * presented address for the current network. False when it denied
+     * (network.changed) or there's no saved address → show the prompt.
+     */
+    bound: boolean;
+    /** Saved addresses to offer as "Are you here?" choices. */
+    savedAddresses: EmergencyAddress[];
+    /** True while an address submit (confirm/create, which forces a reconnect) is in flight. */
+    submitting: boolean;
+    /** Last error (e.g. a carrier rejection). */
+    error: string | null;
+    /** Called from the Softphone when the phone emits `network.changed` (denied). */
+    onNetworkChanged: () => void;
+    /** Confirm an existing saved address for this network (selects + reconnects). */
+    confirm: (id: string) => Promise<void>;
+    /** Create + validate a new address, then bind it (reconnect). */
+    create: (input: EmergencyAddressInput) => Promise<void>;
+}
+
+/**
+ * Appearance and theming types for DialStack SDK
+ */
+/**
+ * Theme variant for components
+ */
+type Theme = 'light' | 'dark' | 'auto';
+/**
+ * CSS variable definitions for theming
+ *
+ * All values should be valid CSS values (colors, sizes, etc.)
+ */
+interface AppearanceVariables {
+    colorPrimary?: string;
+    colorPrimaryHover?: string;
+    colorBackground?: string;
+    colorText?: string;
+    colorTextSecondary?: string;
+    /** Placeholder text in inputs. Defaults to `colorTextSecondary` at 50% so it
+     *  reads dimmer than real secondary text; override to control independently. */
+    colorPlaceholder?: string;
+    colorDanger?: string;
+    colorSuccess?: string;
+    colorWarning?: string;
+    colorSurfaceSubtle?: string;
+    colorBorder?: string;
+    colorBorderSubtle?: string;
+    /** Fill for form inputs. Defaults to `colorBackground`; set separately when
+     *  the input fill should differ from the surface the component sits on. */
+    colorInputBackground?: string;
+    fontFamily?: string;
+    fontSizeBase?: string;
+    fontSizeSmall?: string;
+    fontSizeLarge?: string;
+    fontSizeXLarge?: string;
+    fontWeightNormal?: string;
+    fontWeightMedium?: string;
+    fontWeightBold?: string;
+    lineHeight?: string;
+    spacingUnit?: string;
+    spacingXs?: string;
+    spacingSm?: string;
+    spacingMd?: string;
+    spacingLg?: string;
+    spacingXl?: string;
+    borderRadius?: string;
+    borderRadiusSmall?: string;
+    borderRadiusLarge?: string;
+    transitionDuration?: string;
+    focusRingColor?: string;
+    focusRingWidth?: string;
+    /** Gap between the control edge and the focus ring. Defaults to `0` (flush). */
+    focusRingOffset?: string;
+    /** Height of form controls (inputs, tabs, pagination buttons). Defaults to
+     *  `auto` (font-derived); set to a fixed value for consistent control heights. */
+    controlHeight?: string;
+    iconSize?: string;
+    iconSizeSmall?: string;
+    playerButtonSize?: string;
+    playerProgressHeight?: string;
+    playerProgressHandleSize?: string;
+    unreadIndicatorSize?: string;
+    spinnerSize?: string;
+    timeDisplayWidth?: string;
+}
+/**
+ * Appearance options for theming components
+ */
+interface AppearanceOptions$1 {
+    /**
+     * Theme variant
+     */
+    theme?: Theme;
+    /**
+     * Custom variables for styling
+     */
+    variables?: AppearanceVariables;
+}
+
+/**
+ * Shared design tokens for the DialStack Softphone.
+ *
+ * This module is intentionally framework-agnostic (no DOM, no React Native) so
+ * that BOTH the web Softphone (Web Component, consumes these as CSS values) and the
+ * React Native Softphone (consumes these in a StyleSheet) render from a single
+ * source of truth — that is what makes the two look identical by default.
+ *
+ * Colors resolve from the same `AppearanceOptions` surface the rest of the SDK
+ * uses (theme + variables), so theming through `DialstackComponentsProvider` /
+ * the `appearance` prop flows through identically on both platforms.
+ */
+
+/** Flat color set the Softphone paints from, after appearance is resolved. */
+interface SoftphonePalette {
+    /** Component background. */
+    background: string;
+    /** Dial-pad key / control surface fill. */
+    surface: string;
+    /** Surface fill while pressed/active. */
+    surfaceActive: string;
+    /** Primary text (digits, destination, peer name). */
+    text: string;
+    /** Secondary text (letter sub-labels, call state, hints). */
+    textSecondary: string;
+    /** Hairline borders/dividers. */
+    border: string;
+    /** Accent (links, focus ring, keypad/secondary control highlight). */
+    accent: string;
+    /** Call / Answer (green) action color. */
+    success: string;
+    /** Hang up / Decline (red) action color. */
+    danger: string;
+    /** Warning / caution (amber) — used by the E911 banner. */
+    warning: string;
+    /** Foreground used on top of accent/success/danger fills. */
+    onAccent: string;
+}
+/**
+ * Resolve the final palette from appearance: theme picks the base set, then any
+ * `appearance.variables` overrides (the same keys other SDK components honor)
+ * are layered on top. Unrecognized/absent variables fall back to the theme
+ * default, so a bare `{ theme: 'dark' }` and a fully-specified palette both work.
+ */
+declare function resolveSoftphonePalette(appearance?: AppearanceOptions$1): SoftphonePalette;
+
+/**
+ * English locale strings for DialStack SDK components
+ */
+declare const en: {
+    common: {
+        loading: string;
+        error: string;
+        noResults: string;
+        delete: string;
+        call: string;
+        cancel: string;
+        confirm: string;
+        previous: string;
+        next: string;
+        perPage: string;
+        showing: string;
+        play: string;
+        pause: string;
+    };
+    softphone: {
+        title: string;
+        destinationPlaceholder: string;
+        call: string;
+        backspace: string;
+        connecting: string;
+        reconnecting: string;
+        disconnected: string;
+        connectionError: string;
+        callError: string;
+        micPermissionError: string;
+        dismiss: string;
+        unknownCaller: string;
+        incomingCall: string;
+        answer: string;
+        decline: string;
+        hangUp: string;
+        mute: string;
+        unmute: string;
+        hold: string;
+        resume: string;
+        keypad: string;
+        transfer: string;
+        transferPlaceholder: string;
+        transferSend: string;
+        transferNow: string;
+        transferConsult: string;
+        transferComplete: string;
+        transferConsulting: string;
+        transferOriginalOnHold: string;
+        addCall: string;
+        addCallPlaceholder: string;
+        addCallSend: string;
+        cancel: string;
+        stateTrying: string;
+        stateRinging: string;
+        stateActive: string;
+        stateHeld: string;
+        stateEnded: string;
+        done: string;
+        audioDevices: string;
+        audioMicrophone: string;
+        audioSpeaker: string;
+        audioSystemDefault: string;
+        audioUnnamedDevice: string;
+        audioLabelsHidden: string;
+        audioDevicesUnsupported: string;
+        audioSpeakerUnsupported: string;
+        audioMicrophoneLost: string;
+        switchToCall: string;
+        heldCallsLabel: string;
+        callWaiting: string;
+        emergencyPrompt: string;
+        emergencyHint: string;
+        emergencyConfirm: string;
+        emergencyNewLocation: string;
+        emergencyUseLocation: string;
+        emergencyLocating: string;
+        emergencyNumber: string;
+        emergencyStreet: string;
+        emergencyUnit: string;
+        emergencyCity: string;
+        emergencyState: string;
+        emergencyPostalCode: string;
+        emergencySave: string;
+        emergencySaving: string;
+        emergencyBack: string;
+    };
+    aiAgent: {
+        loading: string;
+        loadFailed: string;
+        fields: {
+            name: string;
+            namePlaceholder: string;
+            nameHint: string;
+            extensionNumber: string;
+            extensionNumberPlaceholder: string;
+            extensionNumberHint: string;
+            extensionChecking: string;
+            personaName: string;
+            personaNamePlaceholder: string;
+            personaNameHint: string;
+            greetingName: string;
+            greetingNamePlaceholder: string;
+            greetingNameHintWithName: string;
+            greetingNameHintGeneric: string;
+            instructions: string;
+            instructionsPlaceholder: string;
+            instructionsHint: string;
+            faq: string;
+            faqEmpty: string;
+            faqEntry: string;
+            faqQuestion: string;
+            faqAnswer: string;
+            faqQuestionLabel: string;
+            faqAnswerLabel: string;
+            faqRemove: string;
+            faqRemoveLabel: string;
+            faqAdd: string;
+            scheduling: string;
+            schedulingHint: string;
+            webhookUrl: string;
+            webhookUrlHint: string;
+            webhookUrlPlaceholder: string;
+            secret: string;
+            secretHint: string;
+            copySecret: string;
+            rotateSecret: string;
+        };
+        save: string;
+        saving: string;
+        saved: string;
+        errors: {
+            nameRequired: string;
+            nameMaxLength: string;
+            personaNameMaxLength: string;
+            greetingNameMaxLength: string;
+            instructionsMaxLength: string;
+            faqMaxItems: string;
+            faqIncompleteEntry: string;
+            faqFieldMaxLength: string;
+            extensionNumeric: string;
+            extensionUnavailable: string;
+            schedulingUrlMaxLength: string;
+            schedulingUrlHttpsRequired: string;
+            hostCreateRequired: string;
+            hostSaveRequired: string;
+        };
+    };
+    voicemails: {
+        title: string;
+        loading: string;
+        empty: string;
+        noUserId: string;
+        transcription: string;
+        summary: string;
+        sentiment: string;
+        sentimentPositive: string;
+        sentimentNeutral: string;
+        sentimentNegative: string;
+        sentimentMixed: string;
+        transcript: string;
+        transcriptLoading: string;
+        transcriptNotAvailable: string;
+        deleteConfirm: string;
+        deleteTitle: string;
+        progress: string;
+    };
+    callLogs: {
+        title: string;
+        loading: string;
+        empty: string;
+        columns: {
+            date: string;
+            direction: string;
+            from: string;
+            to: string;
+            duration: string;
+            status: string;
+            quality: string;
+        };
+        directions: {
+            inbound: string;
+            outbound: string;
+            internal: string;
+        };
+        routedTo: string;
+        calledBy: string;
+        statuses: {
+            completed: string;
+            noAnswer: string;
+            busy: string;
+            failed: string;
+            voicemail: string;
+        };
+        quality: {
+            good: string;
+            fair: string;
+            poor: string;
+            unavailable: string;
+            unavailableTooltip: string;
+        };
+    };
+    callHistory: {
+        title: string;
+        loading: string;
+        empty: string;
+        noPhoneNumber: string;
+        error: string;
+        clickToCall: string;
+        summaryNotAvailable: string;
+        relativeTime: {
+            justNow: string;
+            minuteAgo: string;
+            minutesAgo: string;
+            hourAgo: string;
+            hoursAgo: string;
+            yesterday: string;
+        };
+    };
+    phoneNumberOrdering: {
+        title: string;
+        steps: {
+            search: string;
+            select: string;
+            confirm: string;
+            route: string;
+            done: string;
+            stepOf: string;
+        };
+        search: {
+            title: string;
+            subtitle: string;
+            searchType: string;
+            areaCode: string;
+            zip: string;
+            areaCodeLabel: string;
+            areaCodePlaceholder: string;
+            zipLabel: string;
+            zipPlaceholder: string;
+            numberOfResults: string;
+            search: string;
+        };
+        results: {
+            title: string;
+            phoneNumber: string;
+            state: string;
+            selectAll: string;
+            selected: string;
+            noResults: string;
+            continue: string;
+            backToSearch: string;
+        };
+        confirm: {
+            title: string;
+            subtitleOne: string;
+            subtitleOther: string;
+            description: string;
+            placeOrder: string;
+            continue: string;
+            back: string;
+            billing: {
+                label: string;
+                headline: string;
+                detail: string;
+                detail_one: string;
+                detail_other: string;
+                timing: string;
+                taxesAndFees: string;
+                noPrice: string;
+                noPrice_one: string;
+                noPrice_other: string;
+                notBilled: string;
+            };
+        };
+        route: {
+            title: string;
+            subtitle: string;
+            later: string;
+            laterHint: string;
+            noTargets: string;
+            unnamed: string;
+            extension: string;
+            back: string;
+            type: {
+                user: string;
+                dial_plan: string;
+                voice_app: string;
+                queue: string;
+                ring_group: string;
+                shared_voicemail: string;
+            };
+        };
+        ordering: {
+            title: string;
+        };
+        complete: {
+            titlePendingOne: string;
+            titlePendingOther: string;
+            titleCompleteOne: string;
+            titleCompleteOther: string;
+            titlePartialOne: string;
+            titlePartialOther: string;
+            descriptionPendingOne: string;
+            descriptionPendingOther: string;
+            descriptionCompleteOne: string;
+            descriptionCompleteOther: string;
+            descriptionPartialOne: string;
+            descriptionPartialOther: string;
+            checking: string;
+            assignmentHint: string;
+            orderMore: string;
+        };
+        error: {
+            title: string;
+            description: string;
+            tryAgain: string;
+        };
+        statuses: {
+            pending: string;
+            complete: string;
+            partial: string;
+            failed: string;
+        };
+    };
+    phoneNumbers: {
+        title: string;
+        loading: string;
+        empty: string;
+        filterLabel: string;
+        search: {
+            placeholder: string;
+            noResults: string;
+        };
+        filters: {
+            active: string;
+            in_progress: string;
+            cancelled: string;
+        };
+        columns: {
+            phoneNumber: string;
+            status: string;
+            callerID: string;
+            callerIDPrefix: string;
+            outbound: string;
+            carrier: string;
+            transferDate: string;
+            routingTarget: string;
+            cancelledDate: string;
+        };
+        statuses: {
+            active: string;
+            inactive: string;
+            released: string;
+            ordering: string;
+            orderFailed: string;
+            portingDraft: string;
+            portingApproved: string;
+            portingSubmitted: string;
+            portingException: string;
+            portingFoc: string;
+        };
+        badges: {
+            temporary: string;
+        };
+        outbound: {
+            enabled: string;
+            disabled: string;
+            fax: string;
+        };
+        routingTarget: {
+            notSet: string;
+            setAction: string;
+            faxNotApplicable: string;
+        };
+        routingTargetTypes: {
+            user: string;
+            dialPlan: string;
+            voiceApp: string;
+            ringGroup: string;
+        };
+    };
+    accountOnboarding: {
+        billing: {
+            label: string;
+            headline: string;
+            detail: {
+                userSeat: {
+                    one: string;
+                    other: string;
+                };
+                phoneNumber: {
+                    one: string;
+                    other: string;
+                };
+            };
+            noPrice: {
+                userSeat: {
+                    one: string;
+                    other: string;
+                };
+                phoneNumber: {
+                    one: string;
+                    other: string;
+                };
+            };
+            rateHeadline: {
+                userSeat: string;
+                phoneNumber: string;
+            };
+            rateDetail: {
+                userSeat: string;
+                phoneNumber: string;
+            };
+            noPriceRate: {
+                userSeat: string;
+                phoneNumber: string;
+            };
+            startsOnActivation: string;
+            taxesAndFees: string;
+            notBilled: string;
+        };
+        title: string;
+        breadcrumbAriaLabel: string;
+        loading: string;
+        error: {
+            title: string;
+            description: string;
+            retry: string;
+        };
+        steps: {
+            account: string;
+            numbers: string;
+            hardware: string;
+            complete: string;
+        };
+        sidebar: {
+            businessDetails: string;
+            businessDetailsDesc: string;
+            teamMembers: string;
+            teamMembersDesc: string;
+            numberOptions: string;
+            numberOptionsDesc: string;
+            callerId: string;
+            callerIdDesc: string;
+            directoryListing: string;
+            directoryListingDesc: string;
+            numberSetup: string;
+            numberSetupDesc: string;
+            verification: string;
+            verificationDesc: string;
+            deviceAssignment: string;
+            deviceAssignmentDesc: string;
+        };
+        account: {
+            title: string;
+            subtitle: string;
+            details: {
+                heading: string;
+                companyNameLabel: string;
+                companyNamePlaceholder: string;
+                companyNameRequired: string;
+                emailLabel: string;
+                emailPlaceholder: string;
+                emailRequired: string;
+                emailInvalid: string;
+                phoneLabel: string;
+                phonePlaceholder: string;
+                phoneRequired: string;
+                phoneInvalid: string;
+                primaryContactLabel: string;
+                primaryContactPlaceholder: string;
+                primaryContactRequired: string;
+                regionLabel: string;
+                regionPlaceholder: string;
+                timezoneLabel: string;
+                timezonePlaceholder: string;
+                timezoneRequired: string;
+            };
+            users: {
+                heading: string;
+                description: string;
+                nameLabel: string;
+                namePlaceholder: string;
+                nameRequired: string;
+                emailLabel: string;
+                emailPlaceholder: string;
+                extensionLabel: string;
+                extensionPlaceholder: string;
+                addUser: string;
+                removeUser: string;
+                noUsers: string;
+                atLeastOne: string;
+                duplicateEmail: string;
+            };
+            location: {
+                heading: string;
+                description: string;
+                nameLabel: string;
+                namePlaceholder: string;
+                nameRequired: string;
+                addressLabel: string;
+                searchPlaceholder: string;
+                searching: string;
+                noResults: string;
+                enterManually: string;
+                searchInstead: string;
+                edit: string;
+                addressRequired: string;
+                houseNumberLabel: string;
+                houseNumberPlaceholder: string;
+                streetLabel: string;
+                streetPlaceholder: string;
+                cityLabel: string;
+                cityPlaceholder: string;
+                stateLabel: string;
+                statePlaceholder: string;
+                postalCodeLabel: string;
+                postalCodePlaceholder: string;
+            };
+            saving: string;
+            saveError: string;
+        };
+        numbers: {
+            title: string;
+            subtitle: string;
+            defaultDialPlanName: string;
+            callerId: {
+                title: string;
+                subtitle: string;
+                inputLabel: string;
+                inputPlaceholder: string;
+                inputHelp: string;
+                charCount: string;
+                submit: string;
+                submitting: string;
+                submittingAll: string;
+                submitted: string;
+                alreadySet: string;
+                submitAll: string;
+                skipCallerId: string;
+                partialError: string;
+                validation: {
+                    required: string;
+                    tooLong: string;
+                    invalidChars: string;
+                };
+                error: {
+                    submitFailed: string;
+                    conflict: string;
+                };
+                directoryListing: {
+                    title: string;
+                    info: string;
+                };
+                noDIDs: string;
+            };
+            directoryListing: {
+                title: string;
+                subtitle: string;
+                selectPrompt: string;
+                noneOption: string;
+                noDIDs: string;
+                businessName: string;
+                businessNamePlaceholder: string;
+                businessNameHelp: string;
+                validation: {
+                    nameRequired: string;
+                };
+            };
+            overview: {
+                heading: string;
+                empty: string;
+                requestNew: string;
+                requestNewDesc: string;
+                portExisting: string;
+                portExistingDesc: string;
+                phoneNumber: string;
+                type: string;
+                status: string;
+                source: string;
+                temporaryBanner: string;
+                loadError: string;
+                retry: string;
+            };
+            status: {
+                active: string;
+                inactive: string;
+                released: string;
+                ordering: string;
+                order_failed: string;
+                porting_draft: string;
+                porting_submitted: string;
+                porting_exception: string;
+                porting_foc: string;
+                porting_approved: string;
+            };
+            source: {
+                did: string;
+                didTemporary: string;
+                number_order: string;
+                port_order: string;
+            };
+            order: {
+                searchTitle: string;
+                searchSubtitle: string;
+                searchByAreaCode: string;
+                searchByZip: string;
+                areaCodeLabel: string;
+                areaCodePlaceholder: string;
+                zipLabel: string;
+                zipPlaceholder: string;
+                quantityLabel: string;
+                search: string;
+                searching: string;
+                resultsTitle: string;
+                resultsSubtitle: string;
+                noResults: string;
+                selectAll: string;
+                deselectAll: string;
+                selected: string;
+                state: string;
+                confirmTitle: string;
+                confirmSubtitle: string;
+                confirmSubtitle_one: string;
+                confirmSubtitle_other: string;
+                carrierNote: string;
+                placeOrder: string;
+                placing: string;
+                ordering: string;
+                statusTitle: string;
+                statusPending: string;
+                statusStalled: string;
+                statusComplete: string;
+                statusFailed: string;
+                statusPartial: string;
+                done: string;
+                orderMore: string;
+                continue: string;
+                error: string;
+            };
+            port: {
+                numbersTitle: string;
+                numbersSubtitle: string;
+                phoneLabel: string;
+                phonePlaceholder: string;
+                addAnother: string;
+                numberLabel: string;
+                removeNumber: string;
+                duplicateOfRow: string;
+                pasteHint: string;
+                readyCountZero: string;
+                readyCountOne: string;
+                readyCountOther: string;
+                needsAttentionOne: string;
+                needsAttentionOther: string;
+                reasonInvalid: string;
+                reasonNotUs: string;
+                reasonTollFree: string;
+                reasonAmbiguous: string;
+                reasonHasExtension: string;
+                maxPerOrder: string;
+                notPortableWithDetail: string;
+                accountLimit: string;
+                numbersUnavailable: string;
+                conflictAlreadyOnAccount: string;
+                conflictInServiceElsewhere: string;
+                checkEligibility: string;
+                checking: string;
+                eligibilityTitle: string;
+                eligibilitySubtitle: string;
+                portable: string;
+                notPortable: string;
+                carrier: string;
+                wireless: string;
+                wirelessYes: string;
+                wirelessNo: string;
+                accountRequired: string;
+                continueWithPortable: string;
+                noPortable: string;
+                subscriberTitle: string;
+                subscriberSubtitle: string;
+                btnLabel: string;
+                btnPlaceholder: string;
+                businessNameLabel: string;
+                businessNamePlaceholder: string;
+                approverNameLabel: string;
+                approverNamePlaceholder: string;
+                accountNumberLabel: string;
+                accountNumberPlaceholder: string;
+                pinLabel: string;
+                pinPlaceholder: string;
+                addressHeading: string;
+                houseNumberLabel: string;
+                houseNumberPlaceholder: string;
+                streetNameLabel: string;
+                streetNamePlaceholder: string;
+                line2Label: string;
+                line2Placeholder: string;
+                cityLabel: string;
+                cityPlaceholder: string;
+                stateLabel: string;
+                statePlaceholder: string;
+                zipLabel: string;
+                zipPlaceholder: string;
+                focTitle: string;
+                focSubtitle: string;
+                focDateLabel: string;
+                focTimeLabel: string;
+                focTimePlaceholder: string;
+                documentsTitle: string;
+                documentsSubtitle: string;
+                billCopyLabel: string;
+                billCopyDesc: string;
+                billCopyRequired: string;
+                csrLabel: string;
+                csrDesc: string;
+                csrOptional: string;
+                uploadFile: string;
+                fileSelected: string;
+                noFileSelected: string;
+                uploading: string;
+                reviewTitle: string;
+                reviewSubtitle: string;
+                numbersSection: string;
+                subscriberSection: string;
+                focSection: string;
+                documentsSection: string;
+                signatureLabel: string;
+                signaturePlaceholder: string;
+                signatureHelp: string;
+                approve: string;
+                submitting: string;
+                submittedTitle: string;
+                submittedSubtitle: string;
+                submittedStatus: string;
+                backToOverview: string;
+                carrierGroupsTitle: string;
+                carrierGroupsSubtitle: string;
+                carrierStart: string;
+                carrierContinue: string;
+                carrierSubmitted: string;
+                numberSingular: string;
+                numberPlural: string;
+            };
+            validation: {
+                areaCodeRequired: string;
+                areaCodeFormat: string;
+                cityRequired: string;
+                stateRequired: string;
+                zipRequired: string;
+                zipFormat: string;
+                selectAtLeastOne: string;
+                phoneRequired: string;
+                phoneInvalid: string;
+                phoneDuplicate: string;
+                btnRequired: string;
+                btnInvalid: string;
+                businessNameRequired: string;
+                approverNameRequired: string;
+                houseNumberRequired: string;
+                streetNameRequired: string;
+                focDateRequired: string;
+                focDateTooSoon: string;
+                focDateTooFar: string;
+                focTimeRequired: string;
+                billCopyRequired: string;
+                signatureRequired: string;
+                eligibilityError: string;
+                submitError: string;
+            };
+            nav: {
+                back: string;
+                next: string;
+                cancel: string;
+                backToSearch: string;
+                confirm: string;
+            };
+            gate: {
+                noDIDsAvailable: string;
+                primaryRequired: string;
+            };
+        };
+        hardware: {
+            title: string;
+            shippingAddress: string;
+            subtitle: string;
+            noUsers: string;
+            noDevices: string;
+            isDectBase: string;
+            userLabel: string;
+            selectUser: string;
+            selectUserRequired: string;
+            macLabel: string;
+            macPlaceholder: string;
+            invalidMac: string;
+            ipeiLabel: string;
+            ipeiPlaceholder: string;
+            invalidIpei: string;
+            ipeiNotMac: string;
+            removeDevice: string;
+            unsupportedVendor: string;
+            duplicateMac: string;
+            deviceNotFound: string;
+            handset: string;
+            handsets: string;
+            addDeviceButton: string;
+            addHandsetButton: string;
+            save: string;
+            saving: string;
+            cancel: string;
+            dectBase: string;
+            removeBaseFailed: string;
+            tableHeaderName: string;
+            tableHeaderExtension: string;
+            tableHeaderDevice: string;
+            availableDevices: string;
+            allAssigned: string;
+            dragDropHint: string;
+            clickToAssign: string;
+            submitOrder: string;
+            assignAndComplete: string;
+            unassign: string;
+            deskPhone: string;
+            cordless: string;
+            submitting: string;
+            gate: {
+                noDevices: string;
+            };
+        };
+        complete: {
+            title: string;
+            subtitle: string;
+            e911: {
+                loading: string;
+                pollingStatus: string;
+                verified: string;
+                processing: string;
+                pendingAfterPolling: string;
+                addressStandardized: string;
+                primaryAssigned: string;
+                errorTitle: string;
+                errorDescription: string;
+                retryButton: string;
+                deferred: string;
+            };
+        };
+        stepComplete: {
+            title: string;
+            subtitle: string;
+            done: string;
+        };
+        nav: {
+            next: string;
+            skip: string;
+            back: string;
+            exit: string;
+        };
+        legal: {
+            prefix: string;
+            and: string;
+            termsOfService: string;
+            recipientTerms: string;
+            privacyPolicy: string;
+        };
+        ssa: {
+            title: string;
+            intro: string;
+            pricingTitle: string;
+            perUser: string;
+            perNumber: string;
+            perAiLocation: string;
+            perMonthSuffix: string;
+            agreementLabel: string;
+            openInNewTab: string;
+            accept: string;
+            submitting: string;
+            notPermitted: string;
+            errors: {
+                stale: string;
+                pricingMissing: string;
+                generic: string;
+                retry: string;
+            };
+            loadError: {
+                title: string;
+                description: string;
+                retry: string;
+                retrying: string;
+            };
+        };
+    };
+    onboardingPortal: {
+        onboardingFlows: string;
+        saveAndExit: string;
+        back: string;
+        helpSupport: string;
+        onboardingComplete: string;
+        rates: {
+            title: string;
+            subtitle: string;
+            perUser: string;
+            perPhoneNumber: string;
+            perVoiceAiLocation: string;
+            perMonth: string;
+            rateNotSet: string;
+            pendingRate: string;
+            pendingNote: string;
+            taxesAndFees: string;
+            notBilled: string;
+            noRates: string;
+            unavailable: string;
+        };
+        overview: {
+            label: string;
+            title: string;
+            subtitle: string;
+            progressTitle: string;
+            flowsComplete: string;
+            stepsTitle: string;
+            complete: string;
+            progress: string;
+            completeSetup: string;
+            continueSetup: string;
+            review: string;
+            needHelp: string;
+            needHelpSubtitle: string;
+            scheduleCall: string;
+            viewDocs: string;
+            accountDesc: string;
+            numbersDesc: string;
+            hardwareDesc: string;
+            phoneStatusTitle: string;
+            phoneStatusSubtitle: string;
+            phoneStatusNumber: string;
+            phoneStatusType: string;
+            phoneStatusStatus: string;
+            phoneStatusTypeNew: string;
+            phoneStatusTypePort: string;
+            phoneStatusProcessing: string;
+            phoneStatusComplete: string;
+            phoneStatusTemporary: string;
+        };
+        splash: {
+            title: string;
+            subtitle: string;
+            start: string;
+            step1: string;
+            step2: string;
+            step3: string;
+        };
+    };
+    dialPlan: {
+        title: string;
+        loading: string;
+        error: string;
+        empty: string;
+        nodeTypes: {
+            start: string;
+            schedule: string;
+            internalDial: string;
+            voicemail: string;
+            externalDial: string;
+            voiceApp: string;
+            menu: string;
+            audioClip: string;
+            hangUp: string;
+        };
+        nodeDescriptions: {
+            menu: string;
+            audioClip: string;
+            hangUp: string;
+        };
+        exits: {
+            open: string;
+            closed: string;
+            holiday: string;
+            next: string;
+            timeout: string;
+            invalid: string;
+        };
+        configLabels: {
+            promptClip: string;
+            audioClip: string;
+            digit: string;
+            options: string;
+            addOption: string;
+            removeOption: string;
+            optionLabel: string;
+            optionLabelPlaceholder: string;
+            routeHolidaySeparately: string;
+            routeHolidaySeparatelyHint: string;
+        };
+        resourceGroups: {
+            audioClips: string;
+        };
+    };
+};
+
+/**
+ * Locale types and exports for DialStack SDK
+ */
+
+/**
+ * Locale type derived from the English locale structure
+ */
+type Locale = typeof en;
+
+/**
+ * Shared core of the softphone provider — the wiring both the web and native
+ * providers reuse so it can't drift between them. It provides the context and
+ * renders `children`; each platform supplies its own side-effects (web:
+ * `<style>`/`<audio>`/ringtone; native: InCallManager) as ordinary child
+ * components that read the context via `useSoftphoneBase`.
+ *
+ * Must stay DOM- and React-Native-free: it's part of the shared headless core
+ * (src/react/softphone/core) that @dialstack/sdk-native inlines at build time.
+ */
+
+/** Context fields both platforms expose. Platforms add their own via `extra`. */
+interface SoftphoneContextBase {
+    connection: SoftphoneConnectionState;
+    /**
+     * The live WebRTC phone, or null before the first one is constructed. For the
+     * phone-scoped settings that aren't per-call — audio device selection, which
+     * must work whether or not a call is up. Per-call actions belong on `actions`.
+     */
+    webrtcPhone: DialStackPhone | null;
+    calls: Call[];
+    activeCall: Call | null;
+    incomingCalls: Call[];
+    /** True while an unanswered inbound call should be audibly ringing. */
+    incomingRinging: boolean;
+    heldCalls: Call[];
+    answerCall: (call: Call) => void;
+    switchToCall: (call: Call) => void;
+    actions: UseCallActions;
+    /**
+     * Internal built-in-UI machinery: the mutually-exclusive keypad/transfer
+     * overlay flags the bundled `OngoingCall` renders. Not part of the public
+     * softphone API — a custom layout owns its own presentation state and ignores
+     * this. Kept on the shared context (rather than local to `OngoingCall`) only so
+     * web and React Native can't drift on when the overlays reset.
+     */
+    overlays: UseCallOverlays;
+    duration: string;
+    consultCall: Call | null;
+    transferOriginal: Call | null;
+    startAttendedTransfer: (destination: string) => Promise<void>;
+    completeAttendedTransfer: () => void;
+    cancelAttendedTransfer: () => void;
+    placeCall: (destination: string) => Promise<void>;
+    emergency: UseEmergencyBinding;
+    emergencyManagedByHost: boolean;
+    lastError: {
+        code: string;
+        message: string;
+    } | null;
+    clearError: () => void;
+    t: (key: keyof Locale['softphone']) => string;
+    displayNumber: (value: string) => string;
+    /** Resolved theme palette — computed on both platforms so mobile themes like web. */
+    palette: SoftphonePalette;
+}
+
+/**
+ * SoftphoneProvider (React Native), same API as the web provider. Shared wiring
+ * lives in SoftphoneProviderBase (from `@dialstack/sdk-react/core`); this
+ * file adds only the native bits: the required `storage` adapter,
+ * `locationProvider`, `appearance`/`defaultCountry`, and the InCallManager audio
+ * session + ringtone.
+ */
+
+type AppearanceOptions = Parameters<typeof resolveSoftphonePalette>[0];
+type ConnectionState = SoftphoneConnectionState;
+interface SoftphoneProviderProps {
+    /** WebRTC user session token. */
+    token: string;
+    /**
+     * Persistence for the selected E911 address id, so it survives app restarts.
+     * REQUIRED on React Native: the SDK takes no persistence dependency of its own
+     * (react-native-mmkv and AsyncStorage vary by version/architecture and can't be
+     * defaulted safely), so the host supplies a small `PlatformStorage` adapter —
+     * typically MMKV- or AsyncStorage-backed. See the example apps for reference
+     * adapters; a synchronous in-memory adapter is also valid if you don't need
+     * persistence. It only stores the E911 id, nothing sensitive.
+     */
+    storage: PlatformStorage;
+    /** API base URL (defaults to the SDK's production endpoint). */
+    apiBaseUrl?: string;
+    /**
+     * Called shortly before the session token expires (about 60 seconds ahead).
+     * Return a fresh token minted by your backend; the SDK delivers it in-band over
+     * the existing connection — no reconnect and no call disruption. If it rejects,
+     * the SDK keeps the (still-valid) connection open and surfaces an `error`.
+     */
+    onTokenExpiring?: () => Promise<string>;
+    /** Emergency (E911) address id to present on connect; when supplied the host
+     *  manages E911 and the built-in prompt is disabled. */
+    emergencyAddressId?: string;
+    /**
+     * Optional device-location source for the E911 form. When provided, the
+     * built-in emergency-address form shows a "Use my current location" action
+     * that calls this to prefill the address fields; the host owns the location
+     * permission prompt, geolocation, and reverse-geocoding. Omit for manual entry.
+     */
+    locationProvider?: () => Promise<EmergencyAddressInput>;
+    /** Connect automatically once mounted (default: true). */
+    autoConnect?: boolean;
+    /** Theming — the shared appearance surface (same as the web softphone). */
+    appearance?: AppearanceOptions;
+    /** Locale for UI strings (defaults to English), same surface as the web softphone. */
+    locale?: Locale;
+    /** Default country for number formatting. */
+    defaultCountry?: CountryCode;
+    onConnectionStateChange?: (event: {
+        state: ConnectionState;
+    }) => void;
+    onIncomingCall?: (event: {
+        from: string;
+        fromName: string | null;
+    }) => void;
+    onCallStarted?: (event: {
+        direction: 'inbound' | 'outbound';
+        peer: string;
+    }) => void;
+    onCallEnded?: (event: {
+        reason: CallEndReason;
+    }) => void;
+    onError?: (event: {
+        code: string;
+        message: string;
+    }) => void;
+    children: React.ReactNode;
+}
+/**
+ * The native softphone context: the shared base plus the native-only
+ * `locationProvider`. (`palette` is on the base — computed identically to web.)
+ */
+interface SoftphoneContextValue extends SoftphoneContextBase {
+    /** Host-supplied device-location source for the E911 form, or undefined. */
+    locationProvider: (() => Promise<EmergencyAddressInput>) | undefined;
+}
+declare function SoftphoneProvider({ token, storage, apiBaseUrl, onTokenExpiring, emergencyAddressId, locationProvider, autoConnect, appearance, locale, defaultCountry, onConnectionStateChange, onIncomingCall, onCallStarted, onCallEnded, onError, children, }: SoftphoneProviderProps): React.JSX.Element;
+/** Access the full softphone context. Throws when used outside the provider. */
+declare function useSoftphone(): SoftphoneContextValue;
+/** The active foreground call + its actions (build-your-own convenience). */
+declare function useActiveCall(): {
+    activeCall: Call | null;
+    actions: UseCallActions;
+};
+/** The currently-ringing inbound call, or null. */
+declare function useIncomingCall(): Call | null;
+
+/**
+ * Softphone (RN) — the batteries-included softphone: dial pad, incoming-call
+ * answer/decline, and in-call controls, switching between them based on call
+ * state. The RN sibling of the web <Softphone>: a pure consumer of
+ * <SoftphoneProvider>, which owns the connection and the `token` (the single
+ * credential/connection entry point). Render it under a provider:
+ *
+ * ```tsx
+ * <SoftphoneProvider token={webrtcToken} apiBaseUrl={apiBaseUrl}>
+ *   <Softphone />
+ * </SoftphoneProvider>
+ * ```
+ *
+ * For a bespoke UI, compose <DialPad> / <IncomingCall> / <OngoingCall> yourself
+ * under the same provider.
+ */
+
+interface SoftphoneProps {
+    autoFocusDestination?: boolean;
+}
+declare function Softphone({ autoFocusDestination }: SoftphoneProps): React.JSX.Element;
+
+/**
+ * DialPad (RN) — the idle/outbound screen: connection status chip, a destination
+ * field, the keypad, and the call button. Reads connection + placeCall from the
+ * softphone context; owns its own destination.
+ *
+ * The E911 prompt is NOT rendered here — <EmergencyBanner> is a separate
+ * component so a modular consumer can place it anywhere (or omit it when the host
+ * manages E911). The batteries-included <Softphone> renders the banner above this
+ * pad itself, so its look is unchanged.
+ *
+ * Must be rendered inside a <SoftphoneProvider>.
+ */
+
+interface DialPadProps {
+    /** Autofocus the destination field on mount. */
+    autoFocusDestination?: boolean;
+}
+declare function DialPad({ autoFocusDestination }: DialPadProps): React.JSX.Element;
+
+/**
+ * IncomingCall / IncomingStack (RN) — the ringing inbound UI.
+ *
+ * `IncomingCall` is the single full-screen incoming screen (idle, one caller);
+ * it renders the first ringing call as a full-size card, nothing when none is
+ * ringing. `IncomingStack` renders ALL ringing calls, compact when >1 — what the
+ * RN <Softphone> layers over the base for call-waiting / multiple inbound.
+ *
+ * Both read from context and must be rendered inside a <SoftphoneProvider>.
+ */
+
+declare function IncomingCall(): React.JSX.Element | null;
+
+/**
+ * OngoingCall (RN) — the in-call screen: peer + state + duration, optional DTMF
+ * keypad / transfer / add-call overlays, the control row (mute/hold/keypad/
+ * transfer/add call), and hang up. Renders nothing when there is no active call.
+ * Owns its transient transfer + add-call text; reads the call/actions/duration
+ * from context.
+ *
+ * Must be rendered inside a <SoftphoneProvider>.
+ */
+
+declare function OngoingCall(): React.JSX.Element | null;
+
+/**
+ * EmergencyBanner (RN) — the built-in "set your emergency location" (E911)
+ * prompt shown above the dial pad while the session's emergency address is
+ * unbound. A compact banner opens a mobile Modal form (the web's cramped inline
+ * two-column layout is unusable on a phone under the keyboard).
+ *
+ * Hidden when the host manages E911, while binding is loading, or once bound.
+ * Reads the E911 flow from the softphone context; owns only its modal/form state.
+ *
+ * If the host passed a `locationProvider`, the form offers "Use my current
+ * location" to prefill the address (the host owns the permission + geolocation +
+ * reverse-geocode; the SDK takes no geolocation dependency).
+ */
+
+declare function EmergencyBanner(): React.JSX.Element | null;
+
+export { Call, DialPad, EmergencyBanner, IncomingCall, OngoingCall, Softphone, SoftphoneProvider, useActiveCall, useIncomingCall, useSoftphone };
+export type { CallEndReason, CallState, ConnectionState, DialPadProps, EmergencyAddressInput, PlatformStorage, SoftphoneContextValue, SoftphoneProps, SoftphoneProviderProps, UseCallActions };