import { Channel, Socket } from 'phoenix';

type Uuid = string;
type IsoDateTime = string;
interface Me {
    id: Uuid;
    tenant_id: Uuid;
    external_id: string;
    display_name: string | null;
    custom_data: Record<string, unknown>;
    is_blocked: boolean;
    inserted_at: IsoDateTime;
    updated_at: IsoDateTime;
}
type ConversationType = 'direct' | 'group';
interface Conversation {
    id: Uuid;
    tenant_id: Uuid;
    type: ConversationType;
    /** Display name (for group chats); null for unnamed conversations. */
    name: string | null;
    /** Public avatar URL; null when none uploaded. */
    avatar_url: string | null;
    /** User that created the conversation; null for system-created rows. */
    created_by_user_id: Uuid | null;
    /** Hard cap on memberships; null = unlimited (tenant default). */
    member_limit: number | null;
    /**
     * Customer-supplied free-form data — anything you want to attach to
     * the conversation that doesn't fit the schema (UI flags, tags, etc).
     * Server treats it as opaque JSON.
     */
    custom_data: Record<string, unknown>;
    /**
     * Server-defined behavioral knobs (notification rules, retention,
     * etc). Defaults to `{}` and is updateable.
     */
    settings: Record<string, unknown>;
    /** Most recent message's `inserted_at`; null until first message. */
    last_message_at: IsoDateTime | null;
    /**
     * Plaintext preview of the most recent message body, truncated to
     * 80 chars. Updated server-side by `send_message`. Null when the
     * conversation has no messages, or when the last message had no
     * body (in which case `"📎 Attachment"` etc is returned).
     *
     * Note: stored unencrypted on the server (deliberate denorm so
     * the conversation list doesn't pay a per-row decrypt). Apps with
     * full at-rest-encryption requirements should ignore this field
     * and render their own preview client-side.
     */
    last_message_preview: string | null;
    /** Monotonic per-conversation sequence counter (last message's `sequence`). */
    last_sequence: number;
    /**
     * Number of messages the caller hasn't read yet
     * (`last_sequence - sequence_of(my_last_read_message_id)`).
     * Populated only by `chat.conversations.list()` — undefined when the
     * conversation is fetched via other paths.
     */
    unread_count?: number;
    /**
     * Tenant `external_id`s of every member, in no particular order.
     * Populated by code paths that preload the memberships
     * (`chat.conversations.list()`); may be `[]` on responses where
     * memberships weren't preloaded (webhook payloads, some create
     * responses). Use this to render the other-party name on a direct
     * conversation row without a separate `useMembers` call.
     */
    member_external_ids?: string[];
    inserted_at: IsoDateTime;
    updated_at: IsoDateTime;
}
interface ConversationList {
    data: Conversation[];
}
interface ConversationCreateRequest {
    type: ConversationType;
    name?: string | null;
    avatar_url?: string | null;
    member_limit?: number | null;
    /**
     * Customer-side user IDs to add as members on creation — saves a
     * round-trip vs creating then calling `addMembers`.
     */
    member_external_ids?: string[];
    custom_data?: Record<string, unknown>;
    settings?: Record<string, unknown>;
}
interface ConversationUpdateRequest {
    name?: string | null;
    avatar_url?: string | null;
    member_limit?: number | null;
    custom_data?: Record<string, unknown>;
    settings?: Record<string, unknown>;
}
type MemberRole = 'owner' | 'admin' | 'member';
interface Membership {
    id: Uuid;
    conversation_id: Uuid;
    /** Internal poolse user id. Most consumer code uses `external_id` instead. */
    user_id: Uuid;
    /**
     * The tenant's own user identifier (the same string you pass as
     * `external_id` when minting JWTs or referencing users in
     * `member_external_ids`). Every user reference on the wire carries
     * this so the SDK's `userResolver(externalId)` is a complete API
     * — no need to maintain a `poolse_user_id` mapping on your side.
     */
    external_id: string;
    role: MemberRole;
    last_read_message_id: Uuid | null;
    last_read_sequence: number | null;
    last_read_at: IsoDateTime | null;
    inserted_at: IsoDateTime;
    updated_at: IsoDateTime;
}
interface MembershipList {
    data: Membership[];
}
/**
 * Server accepts a batch of `external_ids` (the customer's stable user
 * identifiers — what was passed to `POST /v1/users`). The server
 * resolves each to its internal user_id and creates a membership row
 * per external_id, all in one round-trip. Optional `role` defaults to
 * `"member"` server-side.
 *
 * Most callers use the higher-level
 * `chat.conversations.one(id).addMember(externalId)` /
 * `addMembers([externalIds])` methods which build this shape for you.
 */
interface MembershipCreateRequest {
    external_ids: string[];
    role?: MemberRole;
}
type MessageType = 'text' | 'system' | 'custom';
interface Message {
    id: Uuid;
    tenant_id: Uuid;
    conversation_id: Uuid;
    /** Internal poolse user id of the sender. Null for system messages. */
    sender_id: Uuid | null;
    /**
     * The tenant's own user identifier for the sender — passed straight
     * to `userResolver(externalId)` to render display name + avatar.
     * Null for system messages, and null on read paths that didn't
     * preload the sender (very rare; every client-facing path preloads).
     */
    sender_external_id: string | null;
    type: MessageType;
    body: string | null;
    reply_to_id: Uuid | null;
    thread_root_id: Uuid | null;
    /**
     * Number of replies in the thread rooted at this message. Server
     * populates on REST list + initial fetch; defaults to 0 for new
     * messages broadcast over realtime. SDK increments locally when a
     * new reply lands so the thread pill ("💬 N replies") updates live.
     */
    reply_count?: number;
    /**
     * Quote reply (WhatsApp-style): id of the message being quoted.
     * Independent of `reply_to_id` (which drives thread promotion).
     * Quoted replies stay in the main feed, NOT in a thread side-pane.
     */
    quoted_message_id?: Uuid | null;
    /**
     * Trimmed preview of the quoted message — server preloads on
     * REST list + realtime broadcast so the SDK can render the inline
     * quote card without a per-message lookup. `body` is truncated
     * to ~200 chars; null when the quoted message was deleted post-quote.
     */
    quoted_message?: QuotedMessagePreview | null;
    mentions: Uuid[];
    reactions: Record<string, Uuid[]>;
    /**
     * Attachments linked to this message. Server populates on send +
     * realtime broadcast; absent on partial responses (e.g. when the
     * client posted with attachment_ids but the server has yet to
     * resolve them).
     */
    attachments?: Attachment[];
    edited_at: IsoDateTime | null;
    deleted_at: IsoDateTime | null;
    sequence: number;
    inserted_at: IsoDateTime;
    updated_at: IsoDateTime;
}
/**
 * Customer-supplied user metadata — the SDK doesn't know your users'
 * names or where their avatars live. Customers wire a
 * `PoolseConfig.userResolver` that maps a poolse `Uuid` to whatever
 * their app already stores: a display name, an avatar URL.
 *
 * The SDK caches resolved profiles in-memory (deduplicating
 * concurrent lookups) so a 50-message render only fires one
 * resolver call per unique sender.
 */
interface PoolseUserProfile {
    /**
     * The name shown in sender labels, mention dropdowns, member
     * lists, and read-receipt tooltips. Customers usually pass their
     * app's `display_name` / `username` / `full_name`.
     */
    displayName: string;
    /**
     * Square avatar URL (any size — the UI scales). Null = render the
     * fallback `<Avatar>` with initials. Optional so customers that
     * don't track avatars can omit the field.
     */
    avatarUrl?: string | null;
}
/**
 * Compact preview of a quoted message, embedded on the quoting
 * message when `Message.quoted_message_id` is set. Just enough for
 * the UI to render the inline quote card.
 */
interface QuotedMessagePreview {
    id: Uuid;
    sender_id: Uuid | null;
    /** Same external-id story as `Message.sender_external_id`. */
    sender_external_id: string | null;
    /** Truncated to ~200 chars server-side; null when the original was deleted. */
    body: string | null;
    deleted_at: IsoDateTime | null;
    inserted_at: IsoDateTime;
}
interface MessageList {
    data: Message[];
}
interface MessageCreateRequest {
    /**
     * Plain-text body. Optional only when `attachment_ids` is non-empty
     * — a message with attachments AND no body is valid (just the
     * attachment renders). At least one of `body` or `attachment_ids`
     * must be present.
     */
    body?: string | null;
    type?: MessageType;
    reply_to_id?: Uuid;
    /**
     * Quote-reply target. The new message keeps `thread_root_id` null
     * (no thread promotion) and is delivered alongside other top-level
     * messages, with a preview card pointing at this id. Must reference
     * a message in the same conversation.
     */
    quoted_message_id?: Uuid;
    mentions?: Uuid[];
    /**
     * Attach previously-uploaded attachments to this message. Each id
     * must come from `chat.attachments.upload(...)` or the lower-level
     * `requestUpload(...)` flow and must belong to the same tenant.
     * The server links them in the same transaction as the insert, so
     * the broadcast and REST response both carry the resolved
     * `Attachment` rows in `message.attachments`.
     */
    attachment_ids?: Uuid[];
    /**
     * Client-supplied UUID for retry-safe sends. The SDK fills this in
     * automatically when not provided so the optimistic temp row and
     * the canonical server row share a single id (used for id-based
     * dedup in `useMessages`).
     */
    id?: Uuid;
}
interface MessageUpdateRequest {
    body: string;
}
interface ReadRequest {
    message_id: Uuid;
}
interface ReactionRequest {
    emoji: string;
}
type AttachmentStatus = 'pending' | 'ready';
interface Attachment {
    id: Uuid;
    tenant_id: Uuid;
    /** Linked message id; null while the attachment is still `:pending`. */
    message_id: Uuid | null;
    /** Uploader; null for system-created attachments. */
    sender_id: Uuid | null;
    content_type: string;
    byte_size: number;
    /** Server-computed SHA-256 of the uploaded bytes; populated after the PUT completes. */
    sha256: string | null;
    original_filename: string | null;
    status: AttachmentStatus;
    inserted_at: IsoDateTime;
    updated_at: IsoDateTime;
}
interface AttachmentUploadRequest {
    content_type: string;
    byte_size: number;
    original_filename?: string;
}
/** Presigned PUT payload returned by `POST /v1/attachments/upload-url`. */
interface AttachmentUploadResponse {
    attachment: Attachment;
    upload: {
        url: string;
        method: 'put';
        /** Headers the client MUST include on the PUT (signed into the URL). */
        headers: Record<string, string>;
    };
}
/** Presigned GET payload returned by `GET /v1/attachments/:id/download-url`. */
interface AttachmentDownloadResponse {
    url: string;
    method: 'get';
}
interface ErrorEnvelope {
    error: {
        code: string;
        message: string;
        doc_url: string;
        details?: Record<string, unknown>;
    };
}

/**
 * Hosted poolse API URL. Used as the default for `PoolseConfig.apiUrl`
 * when you don't pass one — appropriate for the vast majority of
 * integrations that target the official poolse cloud. Self-hosted /
 * staging deployments override via the `apiUrl` field.
 */
declare const POOLSE_API_URL = "https://api.poolse.dev";

/**
 * SDK configuration passed to `new Poolse(config)`.
 */
interface PoolseConfig {
    /**
     * Base URL of the poolse REST API. Defaults to the hosted endpoint
     * at `https://api.poolse.dev`. Override only for self-hosted /
     * staging deployments. MUST NOT include the `/v1` path — the SDK
     * adds that itself.
     */
    apiUrl?: string;
    /**
     * Async hook the SDK calls every time it needs an `Authorization:
     * Bearer <jwt>` header. Most apps refresh the JWT from their own
     * backend here — the SDK never talks to poolse's `POST
     * /v1/users/:user_id/tokens` itself (that endpoint is API-key-authed
     * and lives on the Customer's BACKEND, not the End User's device).
     *
     * Return `null` to deliberately make an unauthenticated request — the
     * server will reject it, but the SDK won't error inside `getToken`.
     */
    getToken: () => Promise<string | null> | string | null;
    /**
     * Optional fetch override. Browsers and Node 22+ both ship a global
     * `fetch`, but tests can inject a mock here; bundlers in restricted
     * environments can supply a polyfill.
     */
    fetch?: typeof globalThis.fetch;
    /**
     * Retry budget for transient failures (network + 5xx + 429). Defaults
     * to 3 attempts after the initial request. Set to 0 to disable.
     */
    maxRetries?: number;
    /**
     * Base for the exponential backoff, in milliseconds. Each retry waits
     * `min(maxBackoffMs, baseBackoffMs * 2^attempt)` plus jitter, OR honours
     * the `Retry-After` header if present. Default 250 ms.
     */
    baseBackoffMs?: number;
    /** Hard cap on a single retry delay. Default 30_000 ms. */
    maxBackoffMs?: number;
    /**
     * Override the idempotency-key generator. Defaults to
     * `crypto.randomUUID()`. Most apps don't need to override this — the
     * generator is exposed mainly for deterministic tests.
     */
    generateIdempotencyKey?: () => string;
    /**
     * Override the WebSocket URL. Defaults to `apiUrl` with `http(s)://`
     * swapped to `ws(s)://`, suitable when the realtime gateway shares
     * its origin with the REST API. Set explicitly for split-host
     * deployments (`https://api.example.com` REST + `wss://realtime.example.com` WS).
     */
    wsUrl?: string;
    /**
     * Path the WebSocket is mounted on. Defaults to `/socket` — matches
     * `CaasRealtimeWeb.UserSocket`'s mount point.
     */
    socketPath?: string;
    /**
     * Called when the underlying socket encounters a non-fatal error
     * (Phoenix retries internally). Useful for surfacing reconnect
     * banners in the UI without coupling to socket internals.
     */
    onSocketError?: (err: Error) => void;
    /**
     * Resolve the tenant's user identifier (`external_id` — same string
     * you pass when minting JWTs and referencing users in
     * `member_external_ids`) to the customer's own user metadata
     * (display name + avatar). Called by `chat.users.get(externalId)`
     * and the `useUser(externalId)` React hook whenever a UI component
     * needs to render a participant.
     *
     * The SDK caches results in-memory and dedupes concurrent calls,
     * so a busy chat with 50 messages from 5 senders fires the
     * resolver 5 times — once per unique sender — not 50.
     *
     * Customers hit their OWN backend / store here, keyed by **their own
     * user id** (no poolse uuid mapping required):
     *
     *   userResolver: async (externalId) => {
     *     const u = await fetch(`/api/users/${externalId}`).then((r) => r.json());
     *     return { displayName: u.full_name, avatarUrl: u.avatar_url };
     *   }
     *
     * Sync returns are fine when the data's already in memory:
     *
     *   userResolver: (externalId) => directory[externalId] ?? null
     *
     * Return `null` when the user can't be found — components fall back
     * to the external_id as a label and an initials avatar.
     */
    userResolver?: (externalId: string) => Promise<PoolseUserProfile | null> | PoolseUserProfile | null;
}
/** Internal resolved config — all the defaults filled in. */
interface ResolvedConfig {
    apiUrl: string;
    getToken: PoolseConfig['getToken'];
    fetch: typeof globalThis.fetch;
    maxRetries: number;
    baseBackoffMs: number;
    maxBackoffMs: number;
    generateIdempotencyKey: () => string;
    wsUrl: string | undefined;
    socketPath: string;
    onSocketError: ((err: Error) => void) | undefined;
    userResolver: PoolseConfig['userResolver'];
}

/**
 * Voice types shared by the room (Discord-style "join voice") and call
 * (WhatsApp-style ringing) surfaces.
 *
 * The WebRTC pieces are declared structurally rather than as the DOM's
 * concrete `RTCPeerConnection`, so React Native can hand us
 * `react-native-webrtc` — API-compatible, different classes — through
 * {@link WebRtcAdapter} without the SDK importing anything native.
 */
/** Connection lifecycle for a voice room. */
type VoiceStatus = 'idle' | 'connecting' | 'connected' | 'error';
/** Someone currently in a voice room, including yourself. */
interface VoiceParticipant {
    userId: string;
    muted: boolean;
    speaking: boolean;
    /** ms epoch from presence metadata; stable ordering key for rosters. */
    joinedAt: number;
    /** True for the local participant. */
    isSelf: boolean;
}
/** The subset of `MediaStreamTrack` the SDK touches. */
interface VoiceTrack {
    kind: string;
    enabled: boolean;
    stop(): void;
}
/** The subset of `MediaStream` the SDK touches. */
interface VoiceStream {
    id: string;
    getTracks(): VoiceTrack[];
    getAudioTracks(): VoiceTrack[];
}
/** Session description exchanged during negotiation. */
interface VoiceDescription {
    type: string;
    sdp?: string | undefined;
}
/** ICE candidate in its wire (JSON) form. */
interface VoiceCandidate {
    candidate?: string | undefined;
    sdpMid?: string | null | undefined;
    sdpMLineIndex?: number | null | undefined;
    usernameFragment?: string | null | undefined;
}
/** The subset of `RTCPeerConnection` the SDK drives. */
interface VoicePeerConnection {
    addTrack(track: VoiceTrack, stream: VoiceStream): unknown;
    createOffer(): Promise<VoiceDescription>;
    createAnswer(): Promise<VoiceDescription>;
    setLocalDescription(description: VoiceDescription): Promise<void>;
    setRemoteDescription(description: VoiceDescription): Promise<void>;
    addIceCandidate(candidate: VoiceCandidate): Promise<void>;
    close(): void;
    readonly remoteDescription: VoiceDescription | null;
    onicecandidate: ((event: {
        candidate: VoiceCandidate | null;
    }) => void) | null;
    ontrack: ((event: {
        streams: readonly VoiceStream[];
    }) => void) | null;
    onconnectionstatechange: (() => void) | null;
    readonly connectionState: string;
}
/**
 * Platform binding for WebRTC. The browser default is built in; React
 * Native supplies one backed by `react-native-webrtc`.
 */
interface WebRtcAdapter {
    createPeerConnection(iceServers: VoiceIceServer[]): VoicePeerConnection;
    getUserMedia(): Promise<VoiceStream>;
    /**
     * Attach a remote stream to a playback sink. The browser adapter
     * creates a hidden `<audio>` element; React Native returns the stream
     * URL for an `<RTCView>`. Returning a disposer keeps the room from
     * leaking sinks when a peer leaves.
     */
    playRemoteStream(peerId: string, stream: VoiceStream): () => void;
}
interface VoiceIceServer {
    urls: string | string[];
    username?: string;
    credential?: string;
}
interface VoiceRoomOptions {
    /**
     * ICE servers for peer connections. Defaults to a public STUN server,
     * which is enough when peers can reach each other directly — add a
     * TURN server for participants behind symmetric NAT.
     */
    iceServers?: VoiceIceServer[];
    /**
     * Resolve ICE servers just before connecting, overriding `iceServers`.
     *
     * TURN credentials expire, so they cannot be handed over once at
     * construction and reused for the life of the app — by the second call
     * they would be rejected. `PoolseRealtime` supplies a provider backed
     * by `GET /v1/ice-servers`, which is what makes TURN work without any
     * app wiring.
     *
     * Failures are non-fatal: the room falls back to `iceServers` (or the
     * default STUN) rather than refusing to connect. Degraded beats dead —
     * without TURN a call still works on most networks.
     */
    iceServersProvider?: () => Promise<VoiceIceServer[]>;
    /** Platform WebRTC binding. Defaults to the browser implementation. */
    webrtc?: WebRtcAdapter;
    /**
     * Disable local speaking detection. On by default; turn it off if the
     * host app drives the indicator itself.
     */
    detectSpeaking?: boolean;
}
/**
 * What a call carries.
 *
 * Fixed when the call is placed, and travelling with the ring rather
 * than the connection: CallKit shows a different answer button for a
 * video call and cannot be changed once the call is reported. Either
 * side can still turn their camera on or off mid-call — this is what
 * the call *opens* as.
 */
type CallMedia = 'audio' | 'video';
/** An inbound ring, delivered on the user's own channel. */
interface IncomingCall {
    callId: string;
    conversationId: string;
    callerUserId: string;
    /** Defaults to `'audio'` against a server that predates the field. */
    media: CallMedia;
}
/** The far side answered; both parties should now join the room. */
interface CallAccepted {
    callId: string;
    conversationId: string;
    /** Who accepted. */
    userId: string;
}
/** The far side declined. */
interface CallDeclined {
    callId: string;
    conversationId: string;
    userId: string;
}
/** The callee is already on another call. */
interface CallBusy {
    callId: string;
    conversationId: string;
    /** Who is busy. */
    userId: string;
}
/** The other side ended a call that was already connected. */
interface CallEnded {
    callId: string;
    conversationId: string;
    /** Who hung up. */
    userId: string;
}
/** The caller hung up before anyone answered. */
interface CallCancelled {
    callId: string;
    conversationId: string;
    callerUserId: string;
}
/** Result of placing a call. */
interface OutgoingCall {
    callId: string;
    conversationId: string;
    /** Everyone who was rung — the conversation's members, minus you. */
    calleeUserIds: string[];
    media: CallMedia;
}

/**
 * WhatsApp-style call invitations.
 *
 * {@link VoiceRoom} is room-shaped: you're only reachable once you've
 * already joined. Ringing somebody who is sitting idle needs a channel
 * they're always on, which is their own `user:<id>` topic — so that's
 * where the invite half of a call lives.
 *
 *     const call = await poolse.calls.invite(conversationId);
 *     // …callee's client fires onIncoming, shows a ring screen…
 *     poolse.calls.onAccepted(({ callId }) => {
 *       if (callId === call.callId) void room.join();
 *     });
 *
 * Media never touches this class. Once both sides have accepted they
 * join the voice room and negotiate exactly as the Discord-style flow
 * does.
 *
 * There is no ring timeout here on purpose: only the UI knows when it
 * gave up, and it can call {@link cancel} at that point.
 */

type Unsubscribe$3 = () => void;
declare class CallsResource {
    /** Resolves the user channel lazily — it may not be joined yet. */
    private readonly getChannel;
    private readonly incoming;
    private readonly accepted;
    private readonly declined;
    private readonly busy;
    private readonly cancelled;
    private readonly ended;
    private bound;
    constructor(getChannel: () => Channel);
    /**
     * Ring every other member of a conversation. Resolves once the server
     * has fanned the invite out, with the minted call id and who was rung
     * — not when anyone answers; that arrives via {@link onAccepted}.
     */
    invite(conversationId: string, media?: CallMedia): Promise<OutgoingCall>;
    /**
     * Answer a ringing call. This only tells the caller you picked up —
     * join the voice room yourself to actually connect audio.
     */
    accept(call: IncomingCall): Promise<void>;
    /** Reject a ringing call without joining the room. */
    decline(call: IncomingCall): Promise<void>;
    /**
     * Tell the caller you are already on another call.
     *
     * Distinct from {@link decline}: nobody chose anything, so clients
     * send this automatically when a ring arrives mid-call. `useCalls`
     * does it for you.
     */
    markBusy(call: IncomingCall): Promise<void>;
    /**
     * End a call that is already connected.
     *
     * Distinct from {@link cancel}, which withdraws an unanswered invite.
     * Without this a connected call has no end signal, so hanging up
     * leaves the other side sitting in the room with a call screen it has
     * no reason to close.
     */
    hangUp(call: {
        callId: string;
        conversationId: string;
    }): Promise<void>;
    /** Withdraw an invite you placed — hung up before anyone answered. */
    cancel(call: OutgoingCall): Promise<void>;
    /** Somebody is ringing you. */
    onIncoming(fn: (call: IncomingCall) => void): Unsubscribe$3;
    /** Your outbound call was answered — join the room now. */
    onAccepted(fn: (call: CallAccepted) => void): Unsubscribe$3;
    /** Your outbound call was rejected. */
    onDeclined(fn: (call: CallDeclined) => void): Unsubscribe$3;
    /** The person you called is already on another call. */
    onBusy(fn: (call: CallBusy) => void): Unsubscribe$3;
    /** The other side ended a connected call. */
    onEnded(fn: (call: CallEnded) => void): Unsubscribe$3;
    /** An inbound ring was withdrawn before you answered. */
    onCancelled(fn: (call: CallCancelled) => void): Unsubscribe$3;
    /**
     * One Phoenix binding per event regardless of listener count; we fan
     * out ourselves, matching how the conversation channels do it.
     */
    private bind;
    private request;
}

/**
 * A voice room bound to one conversation.
 *
 * Wraps poolse's `voice:conversation:<id>` channel and drives a WebRTC
 * mesh over it: one peer connection per participant, negotiated with
 * offer / answer / ICE relayed by the server.
 *
 * Two shapes are built on this:
 *
 *   * Discord-style — call `join()` directly and everyone in the room
 *     hears each other.
 *   * WhatsApp-style — ring first via `poolse.calls`, then both sides
 *     `join()` once the callee accepts.
 *
 * A mesh costs each participant N-1 upstreams, which is fine for small
 * rooms and wrong past roughly six concurrent speakers; that's where an
 * SFU belongs.
 */

type Unsubscribe$2 = () => void;
declare class VoiceRoom {
    readonly conversationId: string;
    private readonly socket;
    private readonly webrtc;
    private iceServers;
    private readonly iceServersProvider;
    private readonly detectSpeaking;
    private channel;
    private localStream;
    private selfId;
    private status;
    private muted;
    private readonly peers;
    private readonly sinks;
    /** Candidates that landed before their offer/answer did. */
    private readonly pendingIce;
    private readonly roster;
    /**
     * How many callers currently hold this room open.
     *
     * `PoolseRealtime` hands out ONE room per conversation, so a call
     * screen and an always-on voice bar for the same conversation share
     * this instance — which is correct, since a user is in one audio
     * session, not two. Without counting, whichever of them tore down
     * first would cut the audio out from under the other.
     */
    private holders;
    private speakingTimer;
    private stopSpeakingDetection;
    private readonly statusListeners;
    private readonly rosterListeners;
    private readonly errorListeners;
    constructor(conversationId: string, socket: Socket, opts?: VoiceRoomOptions);
    getStatus(): VoiceStatus;
    isMuted(): boolean;
    /** Everyone in the room, oldest join first. */
    getParticipants(): VoiceParticipant[];
    onStatus(fn: (status: VoiceStatus) => void): Unsubscribe$2;
    onParticipants(fn: (participants: VoiceParticipant[]) => void): Unsubscribe$2;
    onError(fn: (err: Error) => void): Unsubscribe$2;
    /** Acquire the mic, join the channel, and start negotiating. */
    join(): Promise<void>;
    /** Announce departure, then drop every peer connection and the mic. */
    leave(): void;
    /** Mute or unmute the local mic. Returns the new muted state. */
    setMuted(muted: boolean): boolean;
    toggleMute(): boolean;
    private bindChannel;
    /**
     * Refresh ICE servers from the provider, if there is one.
     *
     * Never throws. A room that refused to connect because the ICE
     * endpoint was briefly unreachable would be a worse outcome than one
     * that connects without TURN — which is exactly how calls behaved
     * before TURN existed, and works on most networks.
     */
    private resolveIceServers;
    /**
     * Glare control: both sides learn about each other simultaneously, so
     * without a rule both would offer at once. The lexicographically lower
     * user id offers and the higher answers — deterministic, no extra
     * round trip.
     */
    private shouldOffer;
    private startNegotiation;
    private ensurePeer;
    private handleSignal;
    private flushIce;
    /**
     * Every signal body travels under `data` — the server's
     * `validate_signal_data/1` rejects the push outright when that key is
     * missing or empty, and a rejected signal is never relayed.
     */
    private sendSignal;
    private startSpeakingDetection;
    private closePeer;
    private teardown;
    private patchParticipant;
    private setStatus;
    private emitRoster;
    private emitError;
}

type Fetcher = PoolseConfig['getToken'];
interface GetTokenOptions {
    /** Bypass the cache and force a fresh call to the consumer's `getToken`. */
    forceRefresh?: boolean;
}
declare class TokenCache {
    private readonly fetcher;
    private token;
    private expMs;
    private inFlight;
    constructor(fetcher: Fetcher);
    /**
     * Synchronously return the cached token without triggering a fetch.
     * Returns `null` if the cache is empty OR if the cached token is
     * within the refresh window (treating near-expiry tokens as stale
     * keeps the realtime layer from handshaking with an about-to-expire
     * JWT when a refresh is already due).
     *
     * Exists for callers like Phoenix.js's `params` callback that the
     * library invokes synchronously and does NOT await — see
     * `phoenix/priv/static/phoenix.mjs::endPointURL()`.
     */
    peekToken(): string | null;
    getToken(opts?: GetTokenOptions): Promise<string | null>;
    invalidate(): void;
    private fetchAndStore;
}

/** `message:new` / `message:updated` push payloads. */
type MessageNewEvent = Message;
type MessageUpdatedEvent = Message;
/** `message:deleted` push payload (just the tombstone, no body). */
interface MessageDeletedEvent {
    id: Uuid;
    conversation_id: Uuid;
    deleted_at: string | null;
}
/** `typing:start` / `typing:stop`. */
interface TypingEvent {
    /** Internal poolse user id. Most consumer code uses `external_id` instead. */
    user_id: Uuid;
    /** The tenant's own id — what your `userResolver` consumes. */
    external_id: string | null;
}
/** `reaction:added` / `reaction:removed`. */
interface ReactionEvent {
    message_id: Uuid;
    conversation_id: Uuid;
    emoji: string;
    user_id: Uuid;
}
/**
 * `member:read` — a conversation member advanced their read cursor.
 * Server broadcasts on `conversation:<id>` so the sender's
 * read-receipt glyph (check vs check-double) updates in real time
 * without needing to refetch the member list.
 */
interface MemberReadEvent {
    user_id: Uuid;
    conversation_id: Uuid;
    last_read_message_id: Uuid;
    last_read_at: string;
}
/** Per-user mention push on the `user:<id>` channel. */
interface MentionEvent {
    message_id: Uuid;
    conversation_id: Uuid;
    sender_id: Uuid | null;
}
/**
 * Pushed on `user:<id>` when the user is added to a conversation —
 * either as creator (via `POST /v1/conversations`) or as additional
 * member (via `POST /v1/conversations/:id/members`). Payload is the
 * full conversation row.
 */
type ConversationCreatedEvent = Conversation;
/**
 * Pushed on `user:<id>` whenever a conversation's surface state
 * changes — currently fires after every `send_message`. Lets the
 * conversation-list view update `last_message_preview` /
 * `last_message_at` / `last_sequence` and bump the unread badge
 * without a refetch.
 *
 * `by_user_id` is the message sender's internal id, so clients can
 * leave their own unread at 0 (the server already advanced their
 * read cursor in the same transaction).
 */
interface ConversationUpdatedEvent {
    conversation: Conversation;
    by_user_id: Uuid | null;
}
/** Phoenix Presence list shape. */
type PresenceSnapshot = Record<Uuid, {
    metas: Array<{
        phx_ref: string;
        online_at: number;
        external_id?: string;
    }>;
}>;
/**
 * Connection status. Reflects the underlying socket lifecycle plus
 * channel join state — easier for UIs than tracking both separately.
 */
type RealtimeStatus = 'idle' | 'connecting' | 'connected' | 'reconnecting' | 'closed';
/** Unsubscribe handle returned by `onX` listener registrations. */
type Unsubscribe$1 = () => void;

interface RealtimeOptions {
    /**
     * WebSocket endpoint path (mounted in caas_realtime). Defaults to
     * `'/socket'` — matches the path served by `CaasRealtimeWeb.UserSocket`.
     */
    socketPath?: string;
    /**
     * Override the Phoenix-derived WebSocket URL. Use when the realtime
     * gateway lives on a different host than the REST API (most common
     * in prod: `https://api.example.com` for REST, `wss://realtime.example.com`
     * for WebSocket). When unset, the WS URL is derived from `apiUrl` by
     * swapping http(s) → ws(s).
     */
    wsUrl?: string;
    /**
     * Resolves ICE servers for voice rooms. Wired by `Poolse` to
     * `GET /v1/ice-servers` so TURN reaches every room without the app
     * plumbing anything.
     */
    iceServersProvider?: () => Promise<VoiceIceServer[]>;
}
declare class PoolseRealtime {
    private readonly config;
    private readonly tokenCache;
    private readonly socketPath;
    private readonly iceServersProvider;
    private readonly wsUrl;
    private socket;
    private readonly conversations;
    private readonly voiceRooms;
    private userChannel;
    private callsResource;
    private status;
    private readonly statusListeners;
    constructor(config: ResolvedConfig, tokenCache: TokenCache, opts?: RealtimeOptions);
    /** Current connection status. */
    getStatus(): RealtimeStatus;
    /** Subscribe to connection-status changes. */
    onStatus(listener: (status: RealtimeStatus) => void): Unsubscribe$1;
    /**
     * Open the socket (idempotent). Synchronous construction so callers
     * can join a channel on the next line; the underlying WebSocket
     * connects on the next tick once the JWT pre-fetch resolves.
     *
     * Phoenix.js invokes the `params` callback SYNCHRONOUSLY on every
     * (re)connect and does NOT await its return value — see
     * `phoenix/priv/static/phoenix.mjs::endPointURL`. So `params` has
     * to read a token that's already in hand. We:
     *
     *   1. Construct the Socket immediately (sets `this.socket` so
     *      concurrent `conversation()` / `user()` callers can attach
     *      channels — Phoenix buffers joins until the socket opens).
     *   2. Pre-fetch the JWT through `TokenCache`, which fills its
     *      internal cache.
     *   3. Call `socket.connect()` so phoenix.js's first handshake reads
     *      a primed `peekToken()`.
     *
     * On reconnect, Phoenix calls `params()` again; the cache is still
     * warm (default JWT exp ~1h, refresh window 30s) so `peekToken()`
     * returns the live token. When the token genuinely expires, our
     * REST 401 path invalidates the cache; the next reconnect's
     * `peekToken()` is `null` and the handshake intentionally fails so
     * the cache can re-fill on the next iteration.
     */
    connect(): void;
    /** Close the socket and tear down every joined channel. */
    disconnect(): void;
    /**
     * Subscribe to a conversation. Returns a typed handle with
     * `onMessage`, `onTyping`, etc. Reusing the same `id` returns the
     * same handle — re-subscribing doesn't open a second channel.
     */
    conversation(conversationId: string): ConversationChannel;
    /**
     * Subscribe to the current user's `user:<id>` channel. Only the user
     * matching the JWT can join — poolse's UserChannel enforces this.
     */
    user(userId: string): UserChannel;
    /**
     * Voice room for a conversation — the Discord-style surface. Call
     * `join()` on the returned handle to acquire the mic and connect;
     * reusing the same id returns the same room rather than opening a
     * second one.
     *
     * Ringing somebody who hasn't joined is a separate concern; see
     * `poolse.calls`.
     */
    voice(conversationId: string, opts?: VoiceRoomOptions): VoiceRoom;
    /**
     * Call invitations for a user — the WhatsApp-style surface. Rides the
     * `user:<id>` topic, the one channel a client is always joined to, so
     * a ring reaches somebody who hasn't opened a voice room yet.
     *
     * Takes the user id explicitly, mirroring `user(userId)`; the SDK
     * never assumes whose token it is holding.
     */
    calls(userId: string): CallsResource;
    /** Drop a conversation handle and leave the channel. */
    leave(conversationId: string): void;
    private setStatus;
}
declare class ConversationChannel {
    readonly conversationId: string;
    private readonly channel;
    private readonly listeners;
    private presenceState;
    private presenceStateSeen;
    constructor(conversationId: string, channel: Channel);
    /** New message pushed to the conversation. */
    onMessage(fn: (msg: MessageNewEvent) => void): Unsubscribe$1;
    /** Existing message edited by its sender. */
    onMessageUpdated(fn: (msg: MessageUpdatedEvent) => void): Unsubscribe$1;
    /** Tombstone for a soft-deleted message. */
    onMessageDeleted(fn: (evt: MessageDeletedEvent) => void): Unsubscribe$1;
    onTypingStart(fn: (evt: TypingEvent) => void): Unsubscribe$1;
    onTypingStop(fn: (evt: TypingEvent) => void): Unsubscribe$1;
    onReactionAdded(fn: (evt: ReactionEvent) => void): Unsubscribe$1;
    onReactionRemoved(fn: (evt: ReactionEvent) => void): Unsubscribe$1;
    /**
     * A conversation member advanced their read cursor. Used to flip the
     * sender's read-receipt glyph from "sent" to "read" in real time.
     */
    onMemberRead(fn: (evt: MemberReadEvent) => void): Unsubscribe$1;
    onPresenceState(fn: (state: PresenceSnapshot) => void): Unsubscribe$1;
    onPresenceDiff(fn: (diff: PresenceSnapshot) => void): Unsubscribe$1;
    /** Current presence snapshot for sync access — usually used in tests. */
    getPresenceState(): PresenceSnapshot;
    /** Send a typing ping to the server. Debounced server-side. */
    sendTyping(): void;
    /** @internal — called by `PoolseRealtime.conversation/1`. */
    _join(): void;
    /** @internal — called when the consumer leaves this conversation. */
    _destroy(): void;
    private subscribe;
}
declare class UserChannel {
    readonly userId: string;
    private readonly channel;
    private readonly mentionListeners;
    private readonly conversationCreatedListeners;
    private readonly conversationUpdatedListeners;
    private mentionBound;
    private conversationCreatedBound;
    private conversationUpdatedBound;
    constructor(userId: string, channel: Channel);
    /**
     * The underlying Phoenix channel, for surfaces that push their own
     * events on this topic (the calls resource does).
     *
     * @internal
     */
    _channel(): Channel;
    onMention(fn: (evt: MentionEvent) => void): Unsubscribe$1;
    /**
     * Subscribe to "you've been added to a conversation" notifications.
     * Fires once per new membership — either because you created the
     * conversation, or because someone added you to an existing one.
     *
     * Payload is the full {@link Conversation} row so consumers can
     * prepend it to a local list without a refetch.
     */
    onConversationCreated(fn: (conv: ConversationCreatedEvent) => void): Unsubscribe$1;
    /**
     * Subscribe to "an existing conversation changed" notifications —
     * fires after every `send_message` in any conversation you're a
     * member of. Use this to update the conversation-list row's last
     * message preview, timestamp, and unread badge without polling.
     *
     * Compare `evt.by_user_id` to your own user id to decide whether
     * to increment a local unread counter; the server already keeps
     * your own outbound messages out of your unread count.
     */
    onConversationUpdated(fn: (evt: ConversationUpdatedEvent) => void): Unsubscribe$1;
    /** @internal */
    _join(): void;
    /** @internal */
    _destroy(): void;
}

type HttpMethod = 'GET' | 'POST' | 'PATCH' | 'PUT' | 'DELETE';
interface RequestOptions {
    method: HttpMethod;
    path: string;
    /** JSON-serialisable body for non-GETs. Omit for GET/DELETE. */
    body?: unknown;
    /** Query string params; values are stringified, nullish entries dropped. */
    query?: Record<string, string | number | boolean | null | undefined>;
    /**
     * Idempotency-Key override. Defaults to a fresh UUID for non-GETs.
     * Pass `null` to deliberately omit the header (e.g. when the caller's
     * own retry logic supplies a deterministic one).
     */
    idempotencyKey?: string | null;
    /**
     * Per-request override for total retry budget. Defaults to
     * `config.maxRetries`.
     */
    maxRetries?: number;
    /** AbortSignal for caller-driven cancellation. */
    signal?: AbortSignal;
}
declare class RestClient {
    private readonly config;
    private readonly tokenCache;
    constructor(config: ResolvedConfig, tokenCache: TokenCache);
    request<T>(opts: RequestOptions): Promise<T>;
    private buildUrl;
    private buildHeaders;
    private resolveIdempotencyKey;
    private backoffDelay;
}

/** Input accepted by {@link AttachmentsResource.upload}. */
interface AttachmentUploadInput {
    /**
     * The bytes to upload. Browser: pass a `File` or `Blob`. Node /
     * Workers / Deno: a `Uint8Array`, `ArrayBuffer`, or any
     * `BodyInit`-compatible value the runtime's `fetch` accepts as a
     * PUT body.
     */
    body: BodyInit;
    /**
     * MIME type. MUST match what you pass as `content_type` on the
     * upload-URL request (the storage backend signs it into the URL —
     * a mismatch makes the PUT fail with 403).
     */
    contentType: string;
    /** Total bytes — must match the bytes you actually PUT. */
    byteSize: number;
    /** Surfaced in download UX so saved files keep a sensible name. */
    filename?: string;
}
/** Options accepted by every attachment method. */
interface AttachmentOptions {
    signal?: AbortSignal;
    /**
     * Progress callback for `upload()`. Called periodically during the
     * PUT phase (NOT during the presigned-URL request — that's a small
     * JSON round-trip). When set, the SDK switches to XHR for the PUT
     * since the standard `fetch` doesn't expose upload progress events.
     *
     * Customers using a custom `config.fetch` (e.g. node-fetch polyfill)
     * lose progress reporting and the callback never fires — XHR is
     * a browser-only API.
     */
    onProgress?: (event: AttachmentProgressEvent) => void;
}
interface AttachmentProgressEvent {
    /** Bytes uploaded so far. */
    loaded: number;
    /** Total bytes — equals `input.byteSize` (passed back for convenience). */
    total: number;
}
/** Top-level `/v1/attachments` collection. */
declare class AttachmentsResource {
    private readonly client;
    private readonly fetchFn;
    /**
     * The PUT to the presigned URL bypasses the SDK's authenticated
     * REST client (presigned URLs encode their own auth and MUST NOT
     * receive an `Authorization` header). It still respects
     * `config.fetch` if the customer provided one — required for tests
     * with a mock fetch, and for runtimes where `globalThis.fetch` is
     * not the right transport.
     */
    constructor(client: RestClient, fetchFn: typeof globalThis.fetch);
    /**
     * Step 1 of an upload — request a presigned PUT URL. Use this when
     * you want to drive the PUT yourself (e.g. resumable uploads,
     * React Native FileSystem). For the common case prefer
     * {@link upload}, which does both steps for you.
     */
    requestUpload(attrs: AttachmentUploadRequest, opts?: AttachmentOptions): Promise<AttachmentUploadResponse>;
    /**
     * One-call upload: request a presigned URL, PUT the bytes to it,
     * return the attachment row. After this resolves the attachment is
     * ready to be referenced from a message send.
     *
     * ```ts
     * // Browser <input type="file">:
     * const file = inputEl.files![0]!;
     * const att = await chat.attachments.upload({
     *   body: file,
     *   contentType: file.type,
     *   byteSize: file.size,
     *   filename: file.name,
     * });
     * await chat.conversations.one(convId).messages.send({
     *   body: 'Look at this!',
     *   custom_data: { attachment_id: att.id },
     * });
     * ```
     *
     * Note: the PUT uses the runtime's bare `fetch` (NOT the SDK's
     * authenticated REST client) — presigned URLs already encode their
     * own auth and MUST NOT receive an `Authorization` header.
     */
    upload(input: AttachmentUploadInput, opts?: AttachmentOptions): Promise<Attachment>;
    /** Returns a handle for further operations on a single attachment. */
    one(id: Uuid): AttachmentHandle;
}
/** Wraps an attachment id for download-url + delete. */
declare class AttachmentHandle {
    private readonly client;
    readonly id: Uuid;
    constructor(client: RestClient, id: Uuid);
    /**
     * Request a presigned GET URL (~1h TTL). Conversation-member-gated
     * server-side. Useful when rendering files in chat: cache the URL
     * client-side until close to expiry, then re-fetch.
     */
    downloadUrl(opts?: AttachmentOptions): Promise<AttachmentDownloadResponse>;
    /**
     * Delete the attachment row + best-effort bucket object delete.
     * Authz: uploader (while still `:pending`) or message-sender / conv
     * owner-admin (once linked).
     */
    delete(opts?: AttachmentOptions): Promise<void>;
}

/** Per-conversation message collection: send, list, mark-read. */
declare class ConversationMessages {
    private readonly client;
    private readonly conversationId;
    constructor(client: RestClient, conversationId: Uuid);
    list(opts?: {
        limit?: number;
        before?: number;
    }, signal?: AbortSignal): Promise<MessageList>;
    /**
     * Send a message to this conversation.
     *
     * If `attrs.id` is omitted the SDK generates a v4 UUID and uses it
     * as both the wire-level idempotency key AND the literal message.id
     * the server stores. Two side-effects that make a real-time UI
     * trivial:
     *
     *   * Resending the same `id` (e.g. a network-retry) returns the
     *     ORIGINAL message instead of inserting a duplicate.
     *   * The realtime `message:new` broadcast carries this same id,
     *     so an optimistic UI can pre-render the row under the final id
     *     and dedup by id alone — no client/server id swap needed.
     *
     * Pass an explicit `attrs.id` only when you generated it yourself
     * upstream (e.g. you already render an optimistic row in your hook
     * and want the server to confirm under the same key).
     */
    send(attrs: MessageCreateRequest, signal?: AbortSignal): Promise<Message>;
    markRead(messageId: Uuid, signal?: AbortSignal): Promise<void>;
}
/** Per-message operations: edit, delete, react, list replies. */
declare class MessageHandle {
    private readonly client;
    readonly id: Uuid;
    constructor(client: RestClient, id: Uuid);
    update(attrs: MessageUpdateRequest, signal?: AbortSignal): Promise<Message>;
    delete(signal?: AbortSignal): Promise<void>;
    replies(opts?: {
        limit?: number;
        after?: number;
    }, signal?: AbortSignal): Promise<MessageList>;
    addReaction(emoji: string, signal?: AbortSignal): Promise<Message>;
    removeReaction(emoji: string, signal?: AbortSignal): Promise<Message>;
}
/** Top-level `/v1/messages` namespace — accessed via `chat.messages(id)`. */
declare class MessagesResource {
    private readonly client;
    constructor(client: RestClient);
    one(id: Uuid): MessageHandle;
}

/** Optional knobs accepted by every member-add call. */
interface AddMemberOptions {
    /** Membership role — defaults to `"member"` server-side. */
    role?: MemberRole;
    /** AbortSignal for caller-driven cancellation. */
    signal?: AbortSignal;
}
/** Wraps a single conversation by id — used as the entry point for sub-resources. */
declare class ConversationHandle {
    private readonly client;
    readonly id: Uuid;
    /**
     * Message ops scoped to this conversation: `list`, `send`, `markRead`.
     * Lazy: constructed on first access so an idle handle stays cheap.
     */
    readonly messages: ConversationMessages;
    constructor(client: RestClient, id: Uuid);
    show(signal?: AbortSignal): Promise<Conversation>;
    update(attrs: ConversationUpdateRequest, signal?: AbortSignal): Promise<Conversation>;
    listMembers(signal?: AbortSignal): Promise<MembershipList>;
    /**
     * Add multiple users to this conversation in one round-trip.
     *
     * `externalIds` are the stable customer-side identifiers you passed
     * to `POST /v1/users` when creating each user — the server resolves
     * them to internal user_ids and creates one membership row per id.
     *
     * Requires `:manage_members` on this conversation (owner or admin).
     *
     * ```ts
     * await chat.conversations.one(convId).addMembers(['alice', 'bob']);
     * ```
     */
    addMembers(externalIds: string[], opts?: AddMemberOptions): Promise<MembershipList>;
    /**
     * Add a single user. Convenience wrapper around {@link addMembers}
     * that unwraps the returned list to the single membership row.
     *
     * ```ts
     * const m = await chat.conversations.one(convId).addMember('alice');
     * ```
     */
    addMember(externalId: string, opts?: AddMemberOptions): Promise<Membership>;
    removeMember(userId: Uuid, signal?: AbortSignal): Promise<void>;
}
/** Top-level `/v1/conversations` collection. */
declare class ConversationsResource {
    private readonly client;
    constructor(client: RestClient);
    list(signal?: AbortSignal): Promise<ConversationList>;
    create(attrs: ConversationCreateRequest, signal?: AbortSignal): Promise<Conversation>;
    /** Returns a handle for further operations on a single conversation. */
    one(id: Uuid): ConversationHandle;
}

/** Which push service a token belongs to. */
type DevicePlatform = 'ios' | 'android';
/**
 * Which APNs environment issued the token. The two have disjoint token
 * spaces — a sandbox token is rejected by production APNs and vice
 * versa — so a debug build must say `sandbox` or its pushes vanish.
 */
type DeviceEnvironment = 'production' | 'sandbox';
interface RegisterDeviceRequest {
    /**
     * On iOS this MUST be the **PushKit VoIP token**, not the regular
     * APNs token. Apple issues them separately and a VoIP push aimed at a
     * normal token is discarded without an error.
     */
    token: string;
    platform: DevicePlatform;
    /** Defaults to `production` server-side. */
    environment?: DeviceEnvironment;
}
/** A registered device, minus the token itself. */
interface Device {
    id: string;
    tenant_id: string;
    user_id: string;
    platform: DevicePlatform;
    environment: DeviceEnvironment;
    last_registered_at: string | null;
    inserted_at: string;
    updated_at: string;
}
/**
 * `/v1/devices` — where a call should ring when the app isn't running.
 *
 * The realtime `call:incoming` event only reaches a live WebSocket, and
 * iOS suspends sockets on background and drops them on close. Registering
 * here is what lets the server wake the app with a VoIP push instead.
 */
declare class DevicesResource {
    private readonly client;
    constructor(client: RestClient);
    /**
     * POST /v1/devices
     *
     * Idempotent — PushKit hands the app a token on every launch, so call
     * this each time rather than trying to remember whether you already
     * did. Re-registering also refreshes the server's staleness clock.
     */
    register(body: RegisterDeviceRequest, signal?: AbortSignal): Promise<Device>;
    /**
     * DELETE /v1/devices/:token
     *
     * Call on sign-out, or the handset keeps ringing for a user who is no
     * longer on it.
     */
    unregister(token: string, signal?: AbortSignal): Promise<void>;
}

/** `/v1/me` — the End-User identity behind the presented JWT. */
declare class MeResource {
    private readonly client;
    constructor(client: RestClient);
    /** GET /v1/me */
    show(signal?: AbortSignal): Promise<Me>;
}

type Listener = () => void;
declare class UsersResource {
    private readonly config;
    private readonly cache;
    private readonly pending;
    private readonly listeners;
    constructor(config: ResolvedConfig);
    /**
     * Get the cached value if present. Returns `undefined` to mean
     * "not in cache yet" (different from `null`, which means "resolver
     * ran and the user wasn't found").
     */
    peek(externalId: string): PoolseUserProfile | null | undefined;
    /**
     * Resolve a user, hitting the customer's `userResolver` on cache
     * miss. Concurrent calls for the same external_id share one Promise.
     */
    get(externalId: string): Promise<PoolseUserProfile | null>;
    /**
     * Subscribe to changes for a single external_id. The listener fires
     * when the resolver lands (or when the entry is invalidated).
     * Returns an unsubscribe.
     *
     * `useUser` in @poolse/react uses this with `useSyncExternalStore`.
     */
    subscribe(externalId: string, listener: Listener): () => void;
    /** Drop a single cached entry — next `get` re-fetches via the resolver. */
    invalidate(externalId: string): void;
    /**
     * Drop the entire cache. Use after a sign-out, tenant swap, or any
     * other event that invalidates every cached profile (e.g., the
     * customer just renamed every user in bulk).
     */
    invalidateAll(): void;
    private notify;
}

/**
 * Structural types for `livekit-client`.
 *
 * Declared here rather than imported for the same reason `WebRtcAdapter`
 * exists: the module is passed IN by the app. tsup rewrites a literal
 * `require()` into `__require()`, which Metro cannot follow, so a
 * dependency this package imports for itself is absent from every React
 * Native bundle — development builds included. That failure already cost
 * us a release once with `react-native-webrtc`.
 *
 * Declaring the shape structurally also keeps the two platforms honest:
 * web passes `livekit-client`, React Native passes the same package with
 * `@livekit/react-native`'s globals registered, and neither has to match
 * a nominal type this package owns.
 *
 * Deliberately narrow — only what {@link CallRoom} actually touches.
 */
/**
 * A media track.
 *
 * Mostly opaque — the platform renderer consumes video. Audio is the
 * exception: {@link CallRoom} attaches it itself on the web, because
 * livekit-client does not play remote audio for you.
 */
interface LiveKitTrack {
    kind?: string;
    attach?: () => HTMLMediaElement;
    detach?: (element?: HTMLMediaElement) => unknown;
}
interface LiveKitPublication {
    track?: LiveKitTrack | null | undefined;
    isMuted?: boolean;
    isSubscribed?: boolean;
    /**
     * The same track typed as video, when it is one.
     *
     * Separate from `track` because only this side carries
     * `restartTrack`, which is how the camera is flipped: LiveKit
     * re-acquires the capture device under the existing publication, so
     * the far side sees the picture change without a renegotiation and
     * without the tile blanking.
     */
    videoTrack?: LiveKitLocalVideoTrack | null | undefined;
}
/** Which camera a video track is capturing from. */
type CameraFacing = 'user' | 'environment';
/**
 * A class of media device.
 *
 * Spelled out rather than reusing the DOM's `MediaDeviceKind` so the
 * type means the same thing on React Native, where there is no DOM but
 * `audiooutput` is still a real concept.
 */
type CallDeviceKind = 'videoinput' | 'audioinput' | 'audiooutput';
/** A selectable input or output. */
interface CallDevice {
    deviceId: string;
    kind: CallDeviceKind;
    /**
     * The browser's own label, e.g. "FaceTime HD Camera".
     *
     * Empty until the page holds a matching permission — the browser
     * withholds labels from sites that have never been granted the
     * device, precisely so they cannot be fingerprinted. In a call that
     * permission is already held, so labels are normally present.
     */
    label: string;
}
/** The slice of LiveKit's `LocalVideoTrack` used to flip the camera. */
interface LiveKitLocalVideoTrack {
    restartTrack?(constraints?: {
        facingMode?: CameraFacing;
        deviceId?: string;
    }): Promise<unknown>;
}
interface LiveKitParticipant {
    /** The poolse user id — we mint tokens with `sub` set to it. */
    identity: string;
    name?: string | undefined;
    isMicrophoneEnabled?: boolean;
    isCameraEnabled?: boolean;
    isSpeaking?: boolean;
    getTrackPublication(source: string): LiveKitPublication | undefined;
}
interface LiveKitLocalParticipant extends LiveKitParticipant {
    /**
     * `options` carries the capture constraints. It is how the call opens
     * on the front camera rather than whatever the OS picks by default,
     * which on Android is routinely the rear one.
     */
    setCameraEnabled(enabled: boolean, options?: {
        facingMode?: CameraFacing;
    }): Promise<unknown>;
    setMicrophoneEnabled(enabled: boolean): Promise<unknown>;
}
interface LiveKitRoomHandle {
    localParticipant: LiveKitLocalParticipant;
    /**
     * Move every track of `kind` onto another device.
     *
     * `audiooutput` is the web's answer to a speakerphone button: it
     * re-points every incoming audio element with `setSinkId`. Not every
     * browser implements it, which is why the result is a boolean rather
     * than a throw.
     */
    switchActiveDevice?(kind: string, deviceId: string, exact?: boolean): Promise<unknown>;
    getActiveDevice?(kind: string): string | undefined;
    /** Keyed by identity. `remoteParticipants` is the v2 name. */
    remoteParticipants: Map<string, LiveKitParticipant>;
    connect(url: string, token: string, options?: unknown): Promise<void>;
    disconnect(): Promise<void>;
    /**
     * Unblocks audio playback held back by a browser's autoplay policy.
     *
     * Optional because only the web needs it — React Native routes through
     * the native audio session and has nothing to unblock.
     */
    startAudio?(): Promise<void>;
    on(event: string, handler: (...args: never[]) => void): unknown;
    off(event: string, handler: (...args: never[]) => void): unknown;
}
/**
 * The `livekit-client` namespace, as imported by your app:
 *
 *     import * as livekit from 'livekit-client';
 *
 * Deliberately loose, for the same reason `NativeWebRtcModule` is.
 * Spelling the real signatures out here does NOT work: `Room`'s
 * constructor takes `RoomOptions`, and a constructor accepting
 * `RoomOptions` is not assignable to one accepting `unknown` —
 * parameters are contravariant. Declaring it precisely means no consumer
 * can pass `import * as livekit` in at all.
 *
 * {@link CheckedLiveKitModule} is the precise shape, narrowed once
 * inside `CallRoom` rather than at every call site.
 */
interface LiveKitModule {
    Room: new (...args: never[]) => unknown;
    RoomEvent: Record<string, string>;
    Track: {
        Source: Record<string, string>;
    };
}
/** The precise shape, used internally once the module has been checked. */
interface CheckedLiveKitModule {
    Room: (new (options?: {
        adaptiveStream?: boolean;
        dynacast?: boolean;
    }) => LiveKitRoomHandle) & {
        /**
         * Enumerates devices, prompting for permission if needed.
         *
         * Optional because it is a static on livekit-client's `Room`, and
         * `CallRoom` falls back to `navigator.mediaDevices` where it is
         * absent rather than losing the picker entirely.
         *
         * Typed as the raw device shape, NOT as {@link CallDevice}. These
         * are `MediaDeviceInfo` instances, whose fields are accessors on the
         * prototype — declaring them as plain objects invites the spread
         * that silently loses every id and label.
         */
        getLocalDevices?(kind?: string, requestPermissions?: boolean): Promise<readonly {
            deviceId?: string;
            kind?: string;
            label?: string;
        }[]>;
    };
    RoomEvent: Record<string, string>;
    Track: {
        Source: Record<string, string>;
    };
}
/**
 * A track plus the context a renderer needs to draw it.
 *
 * This is LiveKit's `TrackReference` shape, rebuilt structurally so the
 * SDK doesn't depend on `@livekit/components-react`. React Native's
 * `<VideoTrack trackRef={...}>` takes it directly; the web renderer
 * ignores it and attaches the track itself.
 *
 * Adaptive streaming is the reason the reference matters rather than
 * the bare track: LiveKit uses the publication to decide which quality
 * layer to send for the size the view is actually drawn at.
 */
interface LiveKitTrackReference {
    participant: LiveKitParticipant;
    publication: LiveKitPublication;
    source: string;
}
/** What `POST /v1/conversations/:id/call-token` returns. */
interface CallConnection {
    url: string;
    token: string;
    room: string;
    expires_at: number;
}
/** Connection lifecycle for a call's media. */
type CallRoomStatus = 'idle' | 'connecting' | 'connected' | 'error';
/** Somebody on the call, including yourself. */
interface CallParticipant {
    /** poolse user id. */
    userId: string;
    name?: string | undefined;
    isSelf: boolean;
    micEnabled: boolean;
    cameraEnabled: boolean;
    speaking: boolean;
    /**
     * The camera track, or null when their camera is off.
     *
     * Opaque on purpose — the web renderer attaches it to a `<video>`
     * element. Handing back a concrete type would force one platform's
     * renderer on the other.
     */
    videoTrack: LiveKitTrack | null;
    /**
     * The same camera track as a renderable reference, or null.
     *
     * React Native's `<VideoTrack>` needs this rather than the bare track:
     * it reads the publication to pick a quality layer matching the size
     * the view is drawn at.
     */
    videoTrackRef: LiveKitTrackReference | null;
}
interface CallRoomOptions {
    /**
     * `livekit-client`, imported by your app. Required — see the note at
     * the top of this file about why this package cannot import it.
     */
    livekit: LiveKitModule;
    /**
     * Resolves SFU credentials for this conversation.
     *
     * Returning `null` means the deployment has no SFU configured (the API
     * answers 503), which callers treat as "fall back to the mesh" rather
     * than as an error.
     */
    tokenProvider: () => Promise<CallConnection | null>;
    /** Publish the camera on join. Audio calls start with it off. */
    video?: boolean;
    /** Start muted. */
    muted?: boolean;
    /**
     * Which camera to open with. Defaults to the front one — a call is a
     * conversation, so the selfie camera is what anyone expects.
     */
    facing?: CameraFacing;
    /**
     * How long the last participant may sit alone before the call is
     * declared over, in milliseconds. Defaults to 1500. Pass `0` to
     * disable and keep the call open indefinitely.
     *
     * The delay is not cosmetic. Two people hanging up within a frame of
     * each other, or an SFU reconnect that briefly empties the roster,
     * would both otherwise trip an immediate check — and a call that ends
     * itself during a half-second blip is worse than one that lingers.
     */
    aloneGraceMs?: number;
}

/**
 * `/v1/conversations/:id/call-token` — SFU credentials for a call.
 *
 * This is the SFU's access control, not a convenience: LiveKit trusts
 * the token completely and checks no membership of its own, so the
 * server mints one only after verifying the caller is in the
 * conversation.
 */
declare class CallTokensResource {
    private readonly client;
    constructor(client: RestClient);
    /**
     * POST /v1/conversations/:conversationId/call-token
     *
     * Resolves `null` when the deployment has no SFU configured (503).
     * That is deliberately not an error — the caller falls back to the
     * peer-to-peer mesh, which is how every call worked before the SFU
     * existed. A 403 still throws: that one really is a refusal.
     */
    create(conversationId: string, signal?: AbortSignal): Promise<CallConnection | null>;
}

type Unsubscribe = () => void;
declare class CallRoom {
    private readonly livekit;
    private readonly tokenProvider;
    private readonly startWithVideo;
    private readonly startMuted;
    private readonly aloneGraceMs;
    private facing;
    private room;
    private status;
    private selfId;
    private holders;
    /**
     * Whether anyone else has ever been on this call.
     *
     * The whole point of the alone check is to end a call the other side
     * has vanished from, and "vanished" is only meaningful once they were
     * here. Without this flag the caller who connects first — alone, by
     * definition, for as long as it takes the callee to join — would end
     * their own call before it ever started.
     */
    private hasSeenPeer;
    /** Pending alone verdict, cleared the moment anyone shows up. */
    private aloneTimer;
    private readonly statusListeners;
    private readonly participantListeners;
    private readonly errorListeners;
    private readonly aloneListeners;
    private readonly deviceListeners;
    /** Bound once so `off()` in teardown removes the same references. */
    private readonly onRoomChange;
    /**
     * Hidden `<audio>` elements playing each remote audio track.
     *
     * livekit-client does NOT play remote audio for you on the web — that
     * is what `@livekit/components-react`'s `<RoomAudioRenderer />` exists
     * to do. Without this a call connects, the roster is right, video
     * flows, and nobody hears anything. The peer-to-peer mesh always did
     * this (see `webrtc-browser.ts`); the SFU path has to as well.
     *
     * Empty on React Native, where there is no DOM and LiveKit routes
     * audio through the native audio session instead.
     */
    private readonly audioSinks;
    constructor(opts: CallRoomOptions);
    getStatus(): CallRoomStatus;
    onStatus(fn: (status: CallRoomStatus) => void): Unsubscribe;
    onParticipants(fn: (participants: CallParticipant[]) => void): Unsubscribe;
    onError(fn: (error: Error) => void): Unsubscribe;
    /**
     * Everyone else has left and is not coming back.
     *
     * A call whose other participants hang up cleanly ends by signal:
     * `call:hangup` travels over poolse's own channel and the far side
     * closes its screen. This covers the case where no signal is ever
     * sent — the app was killed, the phone lost its network, the tab was
     * closed — where the only evidence is that the SFU roster emptied.
     *
     * Media is NOT torn down here. Whoever handles this owns hanging up,
     * because ending a call also means telling poolse about it, which is
     * a layer this class deliberately knows nothing about.
     */
    onAlone(fn: () => void): Unsubscribe;
    getParticipants(): CallParticipant[];
    /**
     * Connect to the SFU.
     *
     * Resolves `true` once media is flowing, `false` when the deployment
     * has no SFU — the caller should fall back to the mesh rather than
     * treat that as a failed call.
     */
    join(): Promise<boolean>;
    /** Release one holder; disconnects once none are left. */
    leave(): void;
    /**
     * Turn the camera on or off mid-call.
     *
     * Off genuinely stops publishing rather than sending black frames, so
     * the capture indicator goes out and the uplink is freed. LiveKit
     * renegotiates underneath.
     */
    setCameraEnabled(enabled: boolean): Promise<void>;
    /**
     * Swap between the front and rear cameras.
     *
     * `restartTrack` re-acquires the capture device under the *existing*
     * publication, so the far side's tile keeps rendering throughout.
     * Unpublishing and republishing instead would blank their view and
     * force a renegotiation for what is, to them, the same camera.
     *
     * No-ops when the camera is off — there is nothing to restart, and
     * the next `setCameraEnabled(true)` will open whichever lens is
     * selected anyway.
     */
    switchCamera(): Promise<void>;
    /** Which camera the local video track is capturing from. */
    getFacingMode(): CameraFacing;
    /**
     * Every device of a given kind that could carry this call.
     *
     * The web's equivalent of a phone's speaker button: a laptop has no
     * earpiece to switch to, but it does have three microphones and a
     * pair of headphones, and picking between them is the same job.
     *
     * Prefers livekit-client's own enumeration, which prompts for the
     * permission that makes labels visible, and falls back to the plain
     * browser API so a module without the static still lists something.
     */
    listDevices(kind: CallDeviceKind): Promise<CallDevice[]>;
    /** Which device of `kind` the call is currently using. */
    getActiveDevice(kind: CallDeviceKind): string | undefined;
    /**
     * Move the call onto another device.
     *
     * `audiooutput` re-points playback through `setSinkId`, which some
     * browsers do not implement — hence the boolean rather than a throw.
     * A refusal is reported as an error and leaves the call where it was.
     */
    setActiveDevice(kind: CallDeviceKind, deviceId: string): Promise<void>;
    /** Fires when devices are plugged in or removed. */
    onDevices(fn: () => void): Unsubscribe;
    /** Mute or unmute the microphone. */
    setMicrophoneEnabled(enabled: boolean): Promise<void>;
    isCameraEnabled(): boolean;
    isMicrophoneEnabled(): boolean;
    /**
     * Publish one capture device, surviving its absence.
     *
     * Split out from {@link withLocal} because this runs mid-join, before
     * the room is marked connected — emitting a roster here would
     * advertise a call that has not finished starting.
     */
    private publish;
    private withLocal;
    private bind;
    /**
     * Play a remote audio track through a hidden element.
     *
     * No-ops for video (the UI renders that) and on React Native, where
     * there is no `document` and the native audio session handles
     * playback.
     */
    private playAudio;
    /** Tear a sink down, so a departed peer stops holding an element. */
    private stopAudio;
    private toParticipant;
    private teardown;
    private setStatus;
    private emitParticipants;
    /**
     * Decide whether this client is the last one standing.
     *
     * Runs on every roster change. Three things have to be true before a
     * call is declared over: it is actually connected, somebody else was
     * here at some point, and nobody is here now — and even then the
     * verdict waits out {@link CallRoomOptions.aloneGraceMs}, so a
     * simultaneous hang-up or a momentary SFU reconnect does not read as
     * abandonment.
     */
    private checkAlone;
    private clearAloneTimer;
    private emitError;
    /** The local participant's poolse user id, once connected. */
    getSelfId(): string | null;
}

interface IceServerResponse {
    ice_servers: VoiceIceServer[];
    ttl_seconds: number;
}
/**
 * `/v1/ice-servers` — STUN, and TURN when the deployment has it.
 *
 * Fetched rather than configured because TURN credentials are
 * deliberately short-lived. A client that held a static one could not
 * refresh it, and a TURN password compiled into a mobile binary is
 * extractable by anyone who wants it.
 */
declare class IceServersResource {
    private readonly client;
    constructor(client: RestClient);
    /** GET /v1/ice-servers */
    list(signal?: AbortSignal): Promise<IceServerResponse>;
}

declare class Poolse {
    /** `/v1/me` — current End User. */
    readonly me: MeResource;
    /**
     * `/v1/devices` — push destinations, so an incoming call can ring a
     * phone whose app isn't running. Only meaningful on mobile.
     */
    readonly devices: DevicesResource;
    /** `/v1/conversations` collection + per-conversation handle factory. */
    readonly conversations: ConversationsResource;
    /** `/v1/messages/:id/*` — accessed via `chat.messages.one(id)`. */
    readonly messages: MessagesResource;
    /** `/v1/attachments/*` — presigned-URL uploads/downloads. */
    readonly attachments: AttachmentsResource;
    /**
     * Customer-supplied user metadata, cached + dedup'd.
     * `chat.users.get(userId)` returns `{ displayName, avatarUrl }`
     * via the optional `config.userResolver`. UI components
     * (`MessageBubble`, `MemberList`, `TypingIndicator`) pick this up
     * automatically via the `useUser` hook in `@poolse/react`.
     *
     * If no resolver is configured, `get` always returns `null` and
     * UI falls back to the userId slice + initials avatar.
     */
    readonly users: UsersResource;
    /**
     * Low-level REST client. Exposed for advanced use cases (custom endpoints,
     * raw retry/headers control). Most callers should use the resources above.
     */
    readonly rest: RestClient;
    /**
     * WebSocket / Phoenix Channels client. Lazily connects on the first
     * `poolse.realtime.conversation(id)` / `poolse.realtime.user(id)`
     * call — passing `config.apiUrl` (with `http(s)://` swapped to
     * `ws(s)://`) for the socket URL by default, overridable via
     * `config.wsUrl`.
     */
    readonly realtime: PoolseRealtime;
    /** STUN/TURN servers for WebRTC — see `IceServersResource`. */
    readonly iceServers: IceServersResource;
    /** SFU credentials for a call's media — see `CallTokensResource`. */
    readonly callTokens: CallTokensResource;
    private readonly resolved;
    private readonly tokenCache;
    constructor(config: PoolseConfig);
    /**
     * A call's media, carried by the SFU.
     *
     * Media only — ringing, presence, roster and mute state stay on
     * poolse's own channels, and a client joins both. See {@link CallRoom}.
     *
     * `livekit` is your app's `livekit-client` import. This package cannot
     * import it for you: tsup rewrites `require()` into `__require()`,
     * which Metro cannot follow, so a dependency required from in here is
     * absent from every React Native bundle.
     *
     *     import * as livekit from 'livekit-client';
     *     const call = poolse.call(conversationId, { livekit, video: true });
     *     const usingSfu = await call.join();   // false = no SFU, use the mesh
     */
    call(conversationId: string, opts: Omit<CallRoomOptions, 'tokenProvider'> & Partial<Pick<CallRoomOptions, 'tokenProvider'>>): CallRoom;
    /**
     * Tear down the SDK: close the WebSocket, drop all channels.
     * No-op for REST — fetch() doesn't keep persistent state.
     * Call this when the user signs out or the SDK instance is
     * being replaced.
     */
    destroy(): void;
}

/** Base for any error originating in the SDK. */
declare class PoolseError extends Error {
    readonly name: string;
    constructor(message: string);
}
/** fetch() rejected or the server returned no response at all. */
declare class NetworkError extends PoolseError {
    readonly name: string;
    readonly cause: unknown;
    constructor(message: string, cause: unknown);
}
/**
 * Server returned a non-2xx status with the canonical error envelope.
 * `code` is poolse's snake_case error code (e.g. `"invalid_user_token"`).
 */
declare class ApiError extends PoolseError {
    readonly name: string;
    readonly status: number;
    readonly code: string;
    readonly docUrl: string;
    readonly details: Record<string, unknown> | undefined;
    constructor(status: number, envelope: ErrorEnvelope['error']);
}
/**
 * 429 specifically. Surfaced as its own subclass so callers can back off
 * politely without parsing the generic ApiError.
 */
declare class RateLimitedError extends ApiError {
    readonly name: string;
    readonly retryAfterMs: number;
    constructor(envelope: ErrorEnvelope['error'], retryAfterMs: number);
}
/**
 * Auth failure (401, including expired/revoked tokens). Callers should
 * refresh the JWT (via `getToken`) and retry — the SDK does NOT do this
 * automatically, because the failure could also mean "the user signed
 * out on another tab" and silent re-auth would hide that.
 */
declare class AuthError extends ApiError {
    readonly name: string;
    constructor(envelope: ErrorEnvelope['error']);
}

/**
 * Browser WebRTC binding. Used automatically when no adapter is passed
 * to {@link VoiceRoom}; React Native supplies its own via
 * `@poolse/react-native`.
 */

/** True when this runtime can actually negotiate WebRTC. */
declare function isWebRtcAvailable(): boolean;
declare function createBrowserWebRtcAdapter(): WebRtcAdapter;

declare const version = "2.19.0";

declare function safeUuid(): string;

export { type AddMemberOptions, ApiError, type Attachment, type AttachmentDownloadResponse, AttachmentHandle, type AttachmentOptions, type AttachmentProgressEvent, type AttachmentStatus, type AttachmentUploadInput, type AttachmentUploadRequest, type AttachmentUploadResponse, AttachmentsResource, AuthError, type CallAccepted, type CallBusy, type CallCancelled, type CallConnection, type CallDeclined, type CallDevice, type CallDeviceKind, type CallEnded, type CallMedia, type CallParticipant, CallRoom, type CallRoomOptions, type CallRoomStatus, CallTokensResource, CallsResource, type CameraFacing, type CheckedLiveKitModule, type Conversation, ConversationChannel, type ConversationCreateRequest, type ConversationCreatedEvent, ConversationHandle, type ConversationList, ConversationMessages, type ConversationType, type ConversationUpdateRequest, type ConversationUpdatedEvent, ConversationsResource, type Device, type DeviceEnvironment, type DevicePlatform, DevicesResource, type ErrorEnvelope, type IceServerResponse, IceServersResource, type IncomingCall, type IsoDateTime, type LiveKitLocalVideoTrack, type LiveKitModule, type LiveKitParticipant, type LiveKitPublication, type LiveKitRoomHandle, type LiveKitTrack, type LiveKitTrackReference, type Me, MeResource, type MemberReadEvent, type MemberRole, type Membership, type MembershipCreateRequest, type MembershipList, type MentionEvent, type Message, type MessageCreateRequest, type MessageDeletedEvent, MessageHandle, type MessageList, type MessageNewEvent, type MessageType, type MessageUpdateRequest, type MessageUpdatedEvent, MessagesResource, NetworkError, type OutgoingCall, POOLSE_API_URL, Poolse, type PoolseConfig, PoolseError, PoolseRealtime, type PoolseUserProfile, type PresenceSnapshot, type QuotedMessagePreview, RateLimitedError, type ReactionEvent, type ReactionRequest, type ReadRequest, type RealtimeStatus, type RegisterDeviceRequest, type TypingEvent, type Unsubscribe$1 as Unsubscribe, UserChannel, UsersResource, type Uuid, type VoiceCandidate, type VoiceDescription, type VoiceIceServer, type VoiceParticipant, type VoicePeerConnection, VoiceRoom, type VoiceRoomOptions, type VoiceStatus, type VoiceStream, type VoiceTrack, type WebRtcAdapter, createBrowserWebRtcAdapter, isWebRtcAvailable, safeUuid, version };