openrtc 2.3.1 → 2.5.1

package/dist/types-Cyc-mPjk.d.ts

@@ -0,0 +1,650 @@
+import { PeerNamespace, ChannelNamespace, DiagnosticsNamespace, DeviceNamespace } from './coreClient.js';
+import { R as RoomArchitectureMode, b as RoomArchitectureSnapshot, c as RoomAuthorityAssignment, C as ChannelDescriptor, P as PlutoIrohConfiguration, d as PlutoRTCConfiguration, e as PlutoMoQConfiguration, f as RouteOptimization, g as ProtocolName } from './Connection-CTpuImO-.js';
+
+interface AuthProvider {
+    /** Registered provider ID from the developer app capability manifest. */
+    readonly providerId?: string;
+    /**
+     * Stable, non-secret, local-only identifier for the currently signed-in
+     * principal. It changes on login, logout, or account switch, but never for
+     * an ordinary access-token refresh. OpenRTC hashes this value together
+     * with the app and installation-key thumbprint before persisting a lookup.
+     *
+     * Optional because assertion-only providers remain valid, though they
+     * cannot skip the assertion exchange on a cold process start.
+     */
+    getSessionKey?(): Promise<string | null>;
+    getAssertion(input: {
+        audience: 'https://api.openrtc.app/v2/assertions/exchange';
+        forceRefresh: boolean;
+        /**
+         * Stable OpenRTC installation ID being enrolled. Consumer backends
+         * may bind product admission (for example a paid device allowance) to
+         * this value in the signed assertion. It is supplied only for an
+         * enrollment/renewal assertion, never for hourly gateway refreshes.
+         */
+        deviceId: string;
+        /**
+         * Present only after OpenRTC receives the exact structured response
+         * indicating that this installation ID is enrolled with another
+         * public key. Consumer backends should require recent interactive
+         * authentication before authorizing the replacement.
+         */
+        recoveryReason?: 'device-key-rotation';
+    }): Promise<string | null>;
+    /**
+     * Optional identity-epoch observer. Notify only when the signed-in
+     * principal/session changes (login, logout, account switch, or explicit
+     * revocation). Do not notify for ordinary OAuth/Firebase access-token
+     * refreshes: OpenRTC refreshes its own avenue grant in place.
+     */
+    subscribe?(listener: (event: {
+        type: 'principal-changed';
+        sessionKey: string | null;
+    }) => void): () => void;
+}
+interface EnrolledDevice {
+    deviceId: string;
+    name?: string;
+    platform?: string;
+    enrolledAtMs: number | null;
+    lastGrantAtMs: number | null;
+    current: boolean;
+}
+/**
+ * Public, non-secret presentation metadata for one enrolled installation.
+ * OpenRTC derives a useful browser default when these fields are omitted;
+ * native hosts should pass the OS/device information reported by their host.
+ */
+interface DeviceProfile {
+    /** Human-readable label such as `Bryant's iPhone` or `Chrome on Android`. */
+    name?: string;
+    /** Raw OS/runtime label such as `ios`, `android`, `macos`, or `web`. */
+    platform?: string;
+    /** Optional application-owned public presence metadata, bounded to 4 KiB. */
+    metadata?: string;
+}
+interface AttestationProvider {
+    readonly kind: 'firebase-app-check' | 'apple-app-attest' | 'play-integrity' | `custom:${string}`;
+    /**
+     * Describes what the provider actually signs. Reusable app-integrity
+     * tokens (for example Firebase App Check) do not become request-bound just
+     * because OpenRTC supplies an enrollment challenge. The server derives and
+     * enforces the authoritative binding from the registered provider kind;
+     * this field keeps host integrations and diagnostics honest.
+     */
+    readonly evidenceBinding: 'app-session' | 'request-challenge';
+    getEvidence(input: {
+        challenge: string;
+        apiKey: string;
+    }): Promise<{
+        token: string;
+    }>;
+}
+/**
+ * Optional consumer-owned bot challenge. Core OpenRTC does not render a UI or
+ * load a CAPTCHA dependency; the host supplies a fresh token only when its
+ * developer manifest requires anonymous capability verification.
+ */
+interface BotVerificationProvider {
+    getToken(input: {
+        action: 'openrtc_capability';
+        apiKey: string;
+    }): Promise<string>;
+}
+interface UsageUpdate {
+    sessionCreditsUsd: number;
+    operation: string;
+    estimated: boolean;
+}
+interface UsageWarning extends UsageUpdate {
+    thresholdCreditsUsd: number;
+    kind: 'warning' | 'session-limit';
+}
+interface Transports {
+    iroh?: boolean | PlutoIrohConfiguration;
+    webrtc?: boolean | PlutoRTCConfiguration;
+    /**
+     * Allow relay mechanisms. Defaults to true; set false for direct-only P2P.
+     * The authenticated runtime tracks Iroh relay and managed TURN readiness
+     * independently; this option is intent, not proof that either is deployed.
+     */
+    relay?: boolean;
+    moq?: boolean | PlutoMoQConfiguration;
+    ble?: boolean;
+    /**
+     * Advanced privacy mode. `relay-only` suppresses direct Iroh addresses,
+     * local discovery, and host/srflx WebRTC candidates. It also requires the
+     * developer manifest's relay opt-in.
+     */
+    privacy?: 'direct' | 'relay-only';
+    /** Optimize eligible routes for stability/cost or measured latency. */
+    optimizeFor?: RouteOptimization;
+    /** Exact route order. Unsupported routes are skipped, never treated as failures. */
+    priority?: readonly ProtocolName[];
+}
+interface Options {
+    apiKey: string;
+    auth?: AuthProvider;
+    trust?: {
+        attestation?: AttestationProvider;
+        botVerification?: BotVerificationProvider;
+    };
+    usage?: {
+        warnAtSessionCreditsUsd?: number;
+        maxSessionCreditsUsd?: number;
+        onUsage?: (event: UsageUpdate) => void;
+        onWarning?: (warning: UsageWarning) => void;
+    };
+    transports?: Transports;
+}
+type AccessMode = 'capability' | 'authenticated';
+type Delivery = 'reliable' | 'latest-state';
+interface PeerStreamOptions {
+    /** Registered application protocol used by the single incoming classifier. */
+    protocol: string;
+    timeoutMs?: number;
+}
+interface PeerBidirectionalStream {
+    readonly protocol: string;
+    readonly readable: ReadableStream<Uint8Array>;
+    readonly writable: WritableStream<Uint8Array>;
+}
+interface IncomingPeerBidirectionalStream extends PeerBidirectionalStream {
+    readonly peerId: string;
+}
+interface IncomingPeerUnidirectionalStream {
+    readonly peerId: string;
+    readonly protocol: string;
+    readonly readable: ReadableStream<Uint8Array>;
+}
+interface PeerDatagramDuplexStream {
+    readonly maxDatagramSize: number;
+    /** Drop received datagrams older than this many milliseconds; `null` disables expiry. */
+    incomingMaxAge: number | null;
+    /** Drop queued outgoing datagrams older than this many milliseconds; `null` disables expiry. */
+    outgoingMaxAge: number | null;
+    /** Bounded application receive queue. */
+    incomingMaxBufferedDatagrams: number;
+    /** Bounded application send queue. */
+    outgoingMaxBufferedDatagrams: number;
+    readonly readable: ReadableStream<Uint8Array>;
+    readonly writable: WritableStream<Uint8Array>;
+    getStats(): PeerDatagramStats;
+}
+interface PeerDatagramStats {
+    received: number;
+    sent: number;
+    bytesReceived: number;
+    bytesSent: number;
+    droppedIncoming: number;
+    droppedOutgoing: number;
+    expiredIncoming: number;
+    expiredOutgoing: number;
+    sendFailures: number;
+    incomingBufferedDatagrams: number;
+    outgoingBufferedDatagrams: number;
+}
+interface PeerStreamTransport {
+    createBidirectionalStream(options: PeerStreamOptions): Promise<PeerBidirectionalStream>;
+    createUnidirectionalStream(options: PeerStreamOptions): Promise<WritableStream<Uint8Array>>;
+    readonly incomingBidirectionalStreams: ReadableStream<IncomingPeerBidirectionalStream>;
+    readonly incomingUnidirectionalStreams: ReadableStream<IncomingPeerUnidirectionalStream>;
+    readonly datagrams: PeerDatagramDuplexStream;
+}
+type MediaKind = 'audio' | 'video';
+interface MediaTrackOptions {
+    streams?: readonly MediaStream[];
+    /** Browser codec preference. Web Audio edges default to PCM; other browser audio defaults to Opus. */
+    codec?: string;
+    bitrate?: number;
+}
+/** Bounded local monotonic-clock samples; this is not cross-peer latency. */
+interface MediaLatencySummary {
+    samples: number;
+    p50Ms: number;
+    p95Ms: number;
+    p99Ms: number;
+    maxMs: number;
+}
+interface MediaSenderStats {
+    publicationId: string;
+    mediaGeneration: number;
+    accepted: number;
+    /** Encoded chunks currently waiting on the protected logical stream. */
+    queued: number;
+    /** Encoded payload bytes currently waiting on the protected logical stream. */
+    queuedBytes: number;
+    /** Age of the oldest currently queued encoded payload. */
+    queuedAgeMs: number;
+    transmitted: number;
+    dropped: number;
+    bytes: number;
+    maxQueued: number;
+    maxQueuedBytes: number;
+    maxQueuedAgeMs: number;
+    /** Most recent asynchronous encoder or protected-stream failure, if any. */
+    lastError?: string;
+    encodeLatency: MediaLatencySummary;
+    protectedWriteLatency: MediaLatencySummary;
+}
+interface MediaReceiverStats {
+    publicationId: string;
+    mediaGeneration: number;
+    received: number;
+    decoded: number;
+    rendered: number;
+    dropped: number;
+    integrityFailures: number;
+    malformedFrames: number;
+    replayDrops: number;
+    /** Successful resumptions on a video keyframe after corruption or loss. */
+    videoRecoveries: number;
+    /** Whether dependent video is currently being discarded until a keyframe. */
+    awaitingKeyframe: boolean;
+    /** Longest local receive-side wait for a recovery keyframe. */
+    maxVideoRecoveryMs: number;
+    bytes: number;
+    decoderQueued: number;
+    maxDecoderQueued: number;
+    renderQueued: number;
+    maxRenderQueued: number;
+    receiveToDecodeLatency: MediaLatencySummary;
+    renderWriteLatency: MediaLatencySummary;
+}
+interface MediaIncomingDemuxStats {
+    /** Whether this connection's protected peer-stream channel listener is installed. */
+    registered: boolean;
+    /** Existing public peers known to this capability router. */
+    peers: number;
+    /** Rust logical connection identities bound to those peers. */
+    boundConnections: number;
+    /** Protected streams offered to this capability router. */
+    observed: number;
+    /** Streams claimed by an existing public peer and protocol handler. */
+    accepted: number;
+    /** Streams this capability correctly left for another capability router. */
+    declined: number;
+    /** Most recent identifier-free ownership decision. */
+    lastResolution: 'none' | 'connection' | 'remote-peer' | 'peer-alias' | 'unbound-connection';
+}
+interface MediaStats {
+    senders: readonly MediaSenderStats[];
+    receivers: readonly MediaReceiverStats[];
+    /** Bounded receiver setup/runtime failures for streams that never produced a receiver. */
+    incomingFailures: readonly string[];
+    /** Number of protected publication streams delivered by protocol dispatch. */
+    incomingProtocolStreams: number;
+    /** Transport-agnostic protected-stream ownership diagnostics. */
+    incomingDemux: MediaIncomingDemuxStats;
+}
+interface MediaSender {
+    readonly id: string;
+    readonly track: MediaStreamTrack | null;
+    replaceTrack(track: MediaStreamTrack | null): Promise<void>;
+    setEnabled(enabled: boolean): Promise<void>;
+    stop(): Promise<void>;
+    getStats(): Promise<MediaSenderStats>;
+}
+interface MediaReceiver {
+    readonly id: string;
+    readonly track: MediaStreamTrack;
+    getStats(): Promise<MediaReceiverStats>;
+}
+interface MediaTrackEvent {
+    readonly track: MediaStreamTrack;
+    readonly receiver: MediaReceiver;
+    readonly streams: readonly MediaStream[];
+}
+interface MediaConnection {
+    addTrack(track: MediaStreamTrack, options?: MediaTrackOptions): Promise<MediaSender>;
+    removeTrack(sender: MediaSender): Promise<void>;
+    onTrack(callback: (event: MediaTrackEvent) => void): () => void;
+    senders(): readonly MediaSender[];
+    receivers(): readonly MediaReceiver[];
+    getStats(): Promise<MediaStats>;
+}
+interface Connection {
+    /** Stable logical peer identity. It does not change when Rust replaces a physical connection or carrier. */
+    readonly id: string;
+    readonly peerId: string;
+    readonly streams: PeerStreamTransport;
+    readonly media: MediaConnection;
+    send(message: unknown): Promise<void>;
+    onMessage<T = unknown>(callback: (message: T) => void): () => void;
+    onClose(callback: () => void): () => void;
+}
+interface Channel<T> {
+    send(message: T): Promise<void>;
+    sendTo(peerId: string, message: T): Promise<void>;
+    /**
+     * The event peerId is the authenticated device ID for sparse broadcasts;
+     * direct channels retain the connection peer ID.
+     */
+    onMessage(callback: (event: {
+        peerId: string;
+        message: T;
+    }) => void): () => void;
+}
+interface State<T> {
+    /** Replace the locally published value. Delivery is best-effort and coalesced. */
+    set(value: T): void;
+    /** A null value means the peer disconnected. */
+    watch(callback: (event: {
+        peerId: string;
+        value: T | null;
+    }) => void): () => void;
+}
+interface Avenue {
+    readonly kind: 'devices' | 'space' | 'room' | 'ticket';
+    readonly id: string;
+    readonly peers: PeerNamespace;
+    readonly channels: ChannelNamespace;
+    readonly diagnostics: DiagnosticsNamespace;
+    readonly closed: boolean;
+    state<T>(name: string): State<T>;
+    channel<T>(name: string): Channel<T>;
+    /** Observe current and future connections without taking lifecycle ownership. */
+    onConnection(callback: (connection: Connection) => void): () => void;
+    close(): Promise<void>;
+}
+interface Devices extends Avenue {
+    readonly kind: 'devices';
+    localId(): ReturnType<DeviceNamespace['localId']>;
+    localInfo(): ReturnType<DeviceNamespace['localInfo']>;
+    list(): ReturnType<DeviceNamespace['list']>;
+    listWithStatus(): ReturnType<DeviceNamespace['listWithStatus']>;
+    watch: DeviceNamespace['watch'];
+    connect: DeviceNamespace['connect'];
+    disconnect: DeviceNamespace['disconnect'];
+}
+interface Space extends Avenue {
+    readonly kind: 'space';
+    readonly delivery: Delivery;
+    leave(): Promise<void>;
+}
+interface Room extends Avenue {
+    readonly kind: 'room';
+    readonly membership: 'ephemeral' | 'durable';
+    /** Current room-wide architecture chosen by the gateway policy owner. */
+    architecture(): RoomArchitectureSnapshot;
+    /** Emits the current snapshot immediately, then later committed changes. */
+    onArchitectureChanged(callback: (snapshot: RoomArchitectureSnapshot) => void): () => void;
+    /** Current signed application-interest assignment, if authority mode has assigned this client. */
+    authorityAssignment(): RoomAuthorityAssignment | null;
+    /** Emits the current assignment immediately, then later admitted revisions. */
+    onAuthorityAssignmentChanged(callback: (assignment: RoomAuthorityAssignment | null) => void): () => void;
+    leave(): Promise<void>;
+}
+interface Ticket extends Avenue {
+    readonly kind: 'ticket';
+    /**
+     * Opaque, install-bound OpenRTC capability credential. This is not a
+     * transferable invitation or recipient redemption token. Do not display,
+     * log, persist, or send it to another installation.
+     * @deprecated This credential exposure is retained only for RC source
+     * compatibility and will not be part of the stable invitation workflow.
+     */
+    readonly token: string;
+}
+interface DeviceOptions {
+    auth?: AuthProvider;
+    autoConnect?: 'none' | 'online';
+    /**
+     * Durable device IDs that automatic discovery must not connect to.
+     * Load persisted exclusions before calling `devices.start()` so the Rust
+     * owner and the first coordination presence share one atomic policy.
+     */
+    autoConnectExcludedDeviceIds?: readonly string[];
+    /** Optional local profile; it does not alter the durable device identity. */
+    profile?: DeviceProfile;
+    maxPeers?: number;
+    /** Requires the app manifest's advanced-fanout opt-in. */
+    advancedFanout?: boolean;
+}
+interface SpaceOptions {
+    access?: 'capability';
+    /** Use a new memory-only identity for this OpenRTC client run. */
+    identity?: 'session';
+    payload?: Delivery;
+    maxPeers?: number;
+    /** Requires the app manifest's advanced-fanout opt-in. */
+    advancedFanout?: boolean;
+}
+interface RoomOptions {
+    access?: AccessMode;
+    membership?: 'ephemeral' | 'durable';
+    /** Use a new memory-only identity for this anonymous room client run. */
+    identity?: 'session';
+    auth?: AuthProvider;
+    maxPeers?: number;
+    /**
+     * Declares the room's delivery semantics for architecture selection.
+     * Reliable is the safe default. Sparse rooms require latest-state data.
+     */
+    payload?: Delivery;
+    /**
+     * Defaults to auto. A fixed mode is room-wide and may still fail safety or
+     * budget gates. Managed is reserved but unavailable in 2.5.
+     */
+    architecture?: RoomArchitectureMode;
+    /**
+     * Requires the app manifest's reviewed advanced-fanout opt-in. Rooms then
+     * use a four-neighbor sparse overlay with bounded named-channel gossip.
+     * @deprecated Use `architecture: 'sparse'`. Removed in the next major.
+     */
+    advancedFanout?: boolean;
+}
+interface TicketOptions {
+    /** Use a new memory-only identity for this ticket client run. */
+    identity?: 'session';
+    maxPeers?: number;
+    /** Requires the app manifest's advanced-fanout opt-in. */
+    advancedFanout?: boolean;
+}
+interface Channels {
+    register(descriptor: ChannelDescriptor): () => void;
+    list(): readonly ChannelDescriptor[];
+}
+interface Usage {
+    estimate(input: {
+        operation: string;
+        units?: number;
+    }): {
+        creditsUsd: number;
+        estimated: true;
+    };
+    estimateRoom(input: RoomUsageEstimateInput): RoomUsageEstimate;
+    readonly sessionCreditsUsd: number;
+}
+interface RoomUsageEstimateInput {
+    /** Managed quotes are unavailable in 2.5 and fail with `room-architecture-unavailable`. */
+    architecture?: RoomArchitectureMode;
+    maxMembers: number;
+    durationSeconds: number;
+    delivery: Delivery;
+    maxPayloadBytes: number;
+    maxMessagesPerSecond: number;
+}
+interface RoomUsageEstimate {
+    architecture: RoomArchitectureMode;
+    effectiveArchitecture: Exclude<RoomArchitectureMode, 'auto'>;
+    creditsUsd: number;
+    estimated: true;
+    expiresAtMs: number;
+    assumptions: readonly string[];
+}
+type OfflineAssurance = 'software' | 'hardware-backed' | 'manufacturer' | 'gateway';
+interface OfflineRuntimeSupport {
+    provisioning: boolean;
+    localMesh: boolean;
+    cloudRequired: false;
+    reason?: string;
+}
+interface OfflineEnrollmentRequest {
+    body: {
+        protocol: 'openrtc-offline-device/1';
+        trustDomain: string;
+        deviceId: string;
+        endpointId: string;
+        proofPublicKey: string;
+        enrollmentNonce: string;
+        requestedRoles: string[];
+        /** Informational request metadata; the fleet issuer certifies the credential assurance. */
+        requestedAssurance: OfflineAssurance;
+        createdAtMs: number;
+    };
+    proofSignature: string;
+}
+interface Offline {
+    support(): Promise<OfflineRuntimeSupport>;
+    /** Native Rust signs this request; private key bytes never enter JavaScript. */
+    createEnrollmentRequest(options: {
+        trustDomain: string;
+        requestedRoles: string[];
+    }): Promise<OfflineEnrollmentRequest>;
+}
+/** Opaque, short-lived, installation-bound broadcast authority. */
+type BroadcastGrant = string & {
+    readonly __openrtcBroadcastGrant: unique symbol;
+};
+/** Single-use bearer invitation. Send it only to the intended recipient. */
+type BroadcastInvite = string & {
+    readonly __openrtcBroadcastInvite: unique symbol;
+};
+type BroadcastRole = 'owner' | 'publisher' | 'subscriber' | 'processor';
+type BroadcastState = 'opening' | 'live' | 'retrying' | 'closed' | 'failed';
+interface BroadcastSource {
+    /** Anonymous slot such as `host-a`; never a device, endpoint, or provider ID. */
+    readonly id: string;
+    readonly alias?: string;
+}
+interface BroadcastTrackEvent extends MediaTrackEvent {
+    readonly source: BroadcastSource;
+}
+interface BroadcastMedia {
+    addTrack(track: MediaStreamTrack, options?: MediaTrackOptions): Promise<MediaSender>;
+    removeTrack(sender: MediaSender): Promise<void>;
+    onTrack(callback: (event: BroadcastTrackEvent) => void): () => void;
+    senders(): readonly MediaSender[];
+    receivers(): readonly MediaReceiver[];
+}
+interface BroadcastStats {
+    queuedMediaBytes: number;
+    droppedMediaObjects: number;
+    publishedBytes: number;
+    deliveredBytes: number;
+    retries: number;
+}
+/** Non-peer relay publication/subscription. It never exposes a carrier or provider handle. */
+interface BroadcastSession {
+    readonly id: string;
+    readonly role: BroadcastRole;
+    readonly state: BroadcastState;
+    readonly media: BroadcastMedia;
+    getStats(): Promise<BroadcastStats>;
+    close(): Promise<void>;
+}
+/**
+ * Runtime-owned publisher identity. Only its public verification key is
+ * exportable; the sign-only private key remains inside native Rust or WASM.
+ */
+interface BroadcastPublisher {
+    readonly verificationKey: Uint8Array;
+    open(grant: BroadcastGrant): Promise<BroadcastSession>;
+    close(): Promise<void>;
+}
+interface BroadcastCreateOptions {
+    /** Rust/WASM/native signer whose public key is bound into the owner grant. */
+    publisher: BroadcastPublisher;
+    auth?: AuthProvider;
+    sourceSlot?: string;
+    maxPublishers: number;
+    maxSubscribers: number;
+    maxBitrateBps: number;
+    maxDurationSeconds: number;
+    maxEgressBytes: number;
+    /** Actual initial owner publication reservation, not the broadcast ceiling. */
+    publisherBitrateBps: number;
+    /** Actual initial owner/viewer egress reservation, not the broadcast ceiling. */
+    reservedEgressBytes: number;
+}
+interface BroadcastInviteOptions {
+    role: 'publisher' | 'subscriber';
+    /** Required for publishers; obtained from that co-host's prepared signer. */
+    publicationVerificationKey?: Uint8Array;
+    /** Required and unique for publishers; omitted for subscribers. */
+    sourceSlot?: string;
+    bitrateBps: number;
+    durationSeconds: number;
+    reservedEgressBytes: number;
+}
+interface Client {
+    readonly offline: Offline;
+    readonly devices: {
+        /**
+         * Returns this installation's durable, app-scoped device ID without
+         * starting a capability or performing network work.
+         */
+        localId(): Promise<string>;
+        start(options?: DeviceOptions): Promise<Devices>;
+        listEnrolled(options?: {
+            auth?: AuthProvider;
+        }): Promise<EnrolledDevice[]>;
+        revoke(deviceId: string, options?: {
+            auth?: AuthProvider;
+        }): Promise<void>;
+        revokeAll(options?: {
+            auth?: AuthProvider;
+            exceptCurrent?: boolean;
+        }): Promise<void>;
+    };
+    readonly spaces: {
+        join(id: string, options?: SpaceOptions): Promise<Space>;
+    };
+    readonly rooms: {
+        join(id: string, options?: RoomOptions): Promise<Room>;
+    };
+    readonly tickets: {
+        issue(id: string, options?: TicketOptions): Promise<Ticket>;
+    };
+    readonly broadcasts: {
+        /** Reserve hard limits and mint a device/key-bound owner grant. */
+        create(options: BroadcastCreateOptions): Promise<BroadcastGrant>;
+        /** The signed grant decides the role; options cannot promote the caller. */
+        open(grant: BroadcastGrant): Promise<BroadcastSession>;
+        /** Familiar viewer alias for `open`; the grant still decides the role. */
+        subscribe(grant: BroadcastGrant): Promise<BroadcastSession>;
+        /** Prepare a runtime-owned signer before requesting a publisher grant. */
+        preparePublisher(): Promise<BroadcastPublisher>;
+        /** Renewal advances the grant generation; it never mutates in place. */
+        renew(grant: BroadcastGrant, options?: {
+            auth?: AuthProvider;
+        }): Promise<BroadcastGrant>;
+        /** Create a single-use role invitation; capacity is reserved on accept. */
+        invite(ownerGrant: BroadcastGrant, options: BroadcastInviteOptions & {
+            auth?: AuthProvider;
+        }): Promise<BroadcastInvite>;
+        /** Bind an invitation to this installation and mint its role grant. */
+        accept(invite: BroadcastInvite, options?: {
+            auth?: AuthProvider;
+        }): Promise<BroadcastGrant>;
+        /** Owner-only targeted revoke; the accepted invitation identifies one role/source. */
+        revoke(ownerGrant: BroadcastGrant, options: {
+            invite: BroadcastInvite;
+            auth?: AuthProvider;
+        }): Promise<void>;
+        /** Retire this installation's own role grant. */
+        leave(grant: BroadcastGrant, options?: {
+            auth?: AuthProvider;
+        }): Promise<void>;
+        close(grant: BroadcastGrant, options?: {
+            auth?: AuthProvider;
+        }): Promise<void>;
+    };
+    readonly channels: Channels;
+    readonly usage: Usage;
+    close(): Promise<void>;
+}
+
+export type { Space as $, AccessMode as A, BotVerificationProvider as B, Client as C, Delivery as D, EnrolledDevice as E, MediaReceiverStats as F, MediaSender as G, MediaSenderStats as H, IncomingPeerBidirectionalStream as I, MediaStats as J, MediaTrackEvent as K, MediaTrackOptions as L, MediaConnection as M, Offline as N, Options as O, OfflineAssurance as P, OfflineEnrollmentRequest as Q, OfflineRuntimeSupport as R, PeerBidirectionalStream as S, PeerDatagramDuplexStream as T, PeerDatagramStats as U, PeerStreamOptions as V, PeerStreamTransport as W, Room as X, RoomOptions as Y, RoomUsageEstimate as Z, RoomUsageEstimateInput as _, AttestationProvider as a, SpaceOptions as a0, State as a1, Ticket as a2, TicketOptions as a3, Transports as a4, Usage as a5, UsageUpdate as a6, UsageWarning as a7, AuthProvider as b, Avenue as c, BroadcastCreateOptions as d, BroadcastGrant as e, BroadcastInvite as f, BroadcastInviteOptions as g, BroadcastMedia as h, BroadcastPublisher as i, BroadcastRole as j, BroadcastSession as k, BroadcastSource as l, BroadcastState as m, BroadcastStats as n, BroadcastTrackEvent as o, Channel as p, Channels as q, Connection as r, DeviceOptions as s, DeviceProfile as t, Devices as u, IncomingPeerUnidirectionalStream as v, MediaIncomingDemuxStats as w, MediaKind as x, MediaLatencySummary as y, MediaReceiver as z };