@afterrealism/dendri-client 2.3.7

package/dist/serializer.msgpack.d.cts

@@ -0,0 +1,936 @@
+import { EventEmitter, ValidEventTypes } from 'eventemitter3';
+
+interface EventsWithError<ErrorType extends string> {
+    error: (error: DendriError<`${ErrorType}`>) => void;
+}
+declare class EventEmitterWithError<ErrorType extends string, Events extends EventsWithError<ErrorType>> extends EventEmitter<Events, never> {
+    /**
+     * Emits a typed error message.
+     *
+     * @internal
+     */
+    emitError(type: ErrorType, err: string | Error, retryable?: boolean): void;
+}
+/**
+ * A DendriError is emitted whenever an error occurs.
+ * It always has a `.type`, which can be used to identify the error.
+ */
+declare class DendriError<T extends string> extends Error {
+    type: T;
+    /** Whether the operation that caused this error can be retried. */
+    retryable: boolean;
+    /** Structured context about the error. */
+    details?: Record<string, unknown>;
+    /**
+     * @internal
+     */
+    constructor(type: T, err: Error | string);
+    /** Set the retryable flag (fluent API). */
+    setRetryable(retryable: boolean): this;
+    /** Set structured details (fluent API). */
+    setDetails(details: Record<string, unknown>): this;
+}
+
+declare enum ConnectionType {
+    Data = "data",
+    Media = "media"
+}
+declare enum DendriErrorType {
+    /**
+     * The client's browser does not support some or all WebRTC features that you are trying to use.
+     */
+    BrowserIncompatible = "browser-incompatible",
+    /**
+     * You've already disconnected this peer from the server and can no longer make any new connections on it.
+     */
+    Disconnected = "disconnected",
+    /**
+     * The ID passed into the Peer constructor contains illegal characters.
+     */
+    InvalidID = "invalid-id",
+    /**
+     * The API key passed into the Peer constructor contains illegal characters or is not in the system (cloud server only).
+     */
+    InvalidKey = "invalid-key",
+    /**
+     * Lost or cannot establish a connection to the signalling server.
+     */
+    Network = "network",
+    /**
+     * The peer you're trying to connect to does not exist.
+     */
+    PeerUnavailable = "peer-unavailable",
+    /**
+     * Dendri is being used securely, but the cloud server does not support SSL. Use a custom DendriServer.
+     */
+    SslUnavailable = "ssl-unavailable",
+    /**
+     * Unable to reach the server.
+     */
+    ServerError = "server-error",
+    /**
+     * An error from the underlying socket.
+     */
+    SocketError = "socket-error",
+    /**
+     * The underlying socket closed unexpectedly.
+     */
+    SocketClosed = "socket-closed",
+    /**
+     * The ID passed into the Peer constructor is already taken.
+     *
+     * :::caution
+     * This error is not fatal if your peer has open peer-to-peer connections.
+     * This can happen if you attempt to {@apilink Dendri.reconnect} a peer that has been disconnected from the server,
+     * but its old ID has now been taken.
+     * :::
+     */
+    UnavailableID = "unavailable-id",
+    /**
+     * Native WebRTC errors.
+     */
+    WebRTC = "webrtc"
+}
+declare enum BaseConnectionErrorType {
+    NegotiationFailed = "negotiation-failed",
+    ConnectionClosed = "connection-closed"
+}
+declare enum DataConnectionErrorType {
+    NotOpenYet = "not-open-yet",
+    MessageTooBig = "message-too-big",
+    /** @deprecated Use {@link MessageTooBig} instead */
+    MessageToBig = "message-too-big"
+}
+declare enum SocketEventType {
+    Message = "message",
+    Disconnected = "disconnected",
+    Error = "error",
+    Close = "close",
+    Reconnected = "reconnected",
+    ReconnectAttempt = "reconnect-attempt"
+}
+declare enum ServerMessageType {
+    Heartbeat = "HEARTBEAT",
+    Candidate = "CANDIDATE",
+    Offer = "OFFER",
+    Answer = "ANSWER",
+    Open = "OPEN",// The connection to the server is open.
+    Error = "ERROR",// Server error.
+    IdTaken = "ID-TAKEN",// The selected ID is taken.
+    InvalidKey = "INVALID-KEY",// The given API key cannot be found.
+    Leave = "LEAVE",// Another peer has closed its connection to this peer.
+    Expire = "EXPIRE",// The offer sent to a peer has expired without response.
+    Data = "DATA",// Relayed data message via WebSocket.
+    Ack = "ACK",// Server acknowledgement with sequence number.
+    RoomJoin = "ROOM-JOIN",// A peer joined a room.
+    RoomLeave = "ROOM-LEAVE",// A peer left a room.
+    RoomPeers = "ROOM-PEERS",// List of peers in a room.
+    HostMigrate = "HOST-MIGRATE",// Host migration notification.
+    PresenceUpdate = "PRESENCE-UPDATE",// Presence data broadcast.
+    KeyExchange = "KEY-EXCHANGE"
+}
+declare enum TransportMode {
+    WebRTC = "webrtc",
+    WebSocketRelay = "ws-relay",
+    Reconnecting = "reconnecting"
+}
+declare enum ConnectionState {
+    /** Initial state, not yet connected */
+    Initialized = "initialized",
+    /** Attempting to connect to signaling server */
+    Connecting = "connecting",
+    /** Connected and ready */
+    Connected = "connected",
+    /** Temporarily disconnected, will auto-reconnect */
+    Disconnected = "disconnected",
+    /** Extended offline, slower retry schedule */
+    Suspended = "suspended",
+    /** Explicitly closed by user */
+    Closed = "closed",
+    /** Unrecoverable error */
+    Failed = "failed"
+}
+declare enum ConnectionQuality {
+    Excellent = "excellent",
+    Good = "good",
+    Poor = "poor",
+    Unknown = "unknown"
+}
+
+interface ServerMessage {
+    type: ServerMessageType;
+    payload: any;
+    src: string;
+    /** Server-assigned sequence number for reliable ordering / replay. */
+    seq?: number;
+    /** Room name associated with this message. */
+    room?: string;
+    /** Server-assigned timestamp (epoch ms). */
+    timestamp?: number;
+    /** ACK identifier for delivery confirmation. */
+    ackId?: string;
+    /** Optional topic for data multiplexing / filtering. */
+    topic?: string;
+}
+
+interface BaseConnectionEvents<ErrorType extends string = BaseConnectionErrorType> extends EventsWithError<ErrorType> {
+    /**
+     * Emitted when either you or the remote peer closes the connection.
+     *
+     * ```ts
+     * connection.on('close', () => { ... });
+     * ```
+     */
+    close: () => void;
+    /**
+     * ```ts
+     * connection.on('error', (error) => { ... });
+     * ```
+     */
+    error: (error: DendriError<`${ErrorType}`>) => void;
+    iceStateChanged: (state: RTCIceConnectionState) => void;
+}
+declare abstract class BaseConnection<SubClassEvents extends ValidEventTypes, ErrorType extends string = never> extends EventEmitterWithError<ErrorType | BaseConnectionErrorType, SubClassEvents & BaseConnectionEvents<BaseConnectionErrorType | ErrorType>> {
+    /**
+     * The ID of the peer on the other end of this connection.
+     */
+    readonly peer: string;
+    provider: Dendri | null;
+    readonly options: any;
+    protected _open: boolean;
+    /**
+     * Any type of metadata associated with the connection,
+     * passed in by whoever initiated the connection.
+     */
+    readonly metadata: any;
+    connectionId: string;
+    peerConnection: RTCPeerConnection | null;
+    dataChannel: RTCDataChannel | null;
+    abstract get type(): ConnectionType;
+    /**
+     * The optional label passed in or assigned by Dendri when the connection was initiated.
+     */
+    label: string;
+    /**
+     * Whether the media connection is active (e.g. your call has been answered).
+     * You can check this if you want to set a maximum wait time for a one-sided call.
+     */
+    get open(): boolean;
+    protected constructor(
+    /**
+     * The ID of the peer on the other end of this connection.
+     */
+    peer: string, provider: Dendri | null, options: any);
+    abstract close(): void;
+    /**
+     * @internal
+     */
+    abstract handleMessage(message: ServerMessage): void;
+    /**
+     * Called by the Negotiator when the DataChannel is ready.
+     * @internal
+     * */
+    abstract _initializeDataChannel(dc: RTCDataChannel): void;
+}
+
+interface DataConnectionEvents extends EventsWithError<DataConnectionErrorType | BaseConnectionErrorType>, BaseConnectionEvents<DataConnectionErrorType | BaseConnectionErrorType> {
+    /**
+     * Emitted when data is received from the remote peer.
+     */
+    data: (data: unknown) => void;
+    /**
+     * Emitted when the connection is established and ready-to-use.
+     */
+    open: () => void;
+}
+/**
+ * Wraps a DataChannel between two Peers.
+ */
+declare abstract class DataConnection extends BaseConnection<DataConnectionEvents, DataConnectionErrorType> {
+    protected static readonly ID_PREFIX = "dc_";
+    protected static readonly MAX_BUFFERED_AMOUNT: number;
+    private _negotiator;
+    abstract readonly serialization: string;
+    readonly reliable: boolean;
+    get type(): ConnectionType;
+    constructor(peerId: string, provider: Dendri, options: any);
+    /** Called by the Negotiator when the DataChannel is ready. */
+    _initializeDataChannel(dc: RTCDataChannel): void;
+    /**
+     * Exposed functionality for users.
+     */
+    private _flushCloseTimeout;
+    /** Allows user to close connection. */
+    close(options?: {
+        flush?: boolean;
+    }): void;
+    protected abstract _send(data: any, chunked: boolean): void | Promise<void>;
+    /** Allows user to send data. */
+    send(data: any, chunked?: boolean): void | Promise<void>;
+    handleMessage(message: ServerMessage): Promise<void>;
+}
+
+/**
+ * ACK-based message delivery confirmation manager.
+ *
+ * Tracks outgoing messages that expect an acknowledgement and resolves/rejects
+ * the corresponding promise when the ACK arrives or the timeout fires.
+ */
+declare class AckManager {
+    private readonly _pending;
+    private _counter;
+    /** Generate a unique ack ID. */
+    nextId(): string;
+    /**
+     * Register a pending ACK with timeout. When `peerId` is supplied, the
+     * ACK can be rejected early by {@link rejectAllForPeer} when that peer
+     * disconnects, so callers don't wait out the full timeout after the
+     * transport layer already knows the target is gone.
+     */
+    waitForAck(ackId: string, timeoutMs?: number, peerId?: string): Promise<void>;
+    /** Handle an incoming ACK message. Returns true if the ackId was pending. */
+    handleAck(ackId: string): boolean;
+    /**
+     * Reject every pending ACK whose `peerId` matches. Called from the
+     * close path of a per-peer connection so broadcastWithAck promises
+     * resolve with a clear error immediately instead of stalling until
+     * the timeout.
+     */
+    rejectAllForPeer(peerId: string): number;
+    /** Clean up all pending ACKs (e.g. on disconnect). */
+    clear(): void;
+    /** Number of ACKs currently awaiting confirmation. */
+    get pendingCount(): number;
+}
+
+interface AnswerOption {
+    /**
+     * Function which runs before create answer to modify sdp answer message.
+     */
+    sdpTransform?: (sdp: string) => string;
+}
+interface DendriOption {
+    key?: string;
+    host?: string;
+    port?: number;
+    path?: string;
+    secure?: boolean;
+    token?: string;
+    config?: RTCConfiguration;
+    debug?: number;
+    referrerPolicy?: ReferrerPolicy;
+    /** Auto-fetch TURN credentials from the signaling server's GET /turn endpoint. */
+    fetchTurnCredentials?: boolean;
+    /** Optional JWT for authenticated connections. */
+    jwt?: string;
+    /** Enable WebSocket relay fallback when WebRTC is unavailable. */
+    enableRelay?: boolean;
+    /** Optional function to validate connection metadata before accepting. */
+    validateMetadata?: (metadata: unknown) => boolean;
+    /** Signaling transport: 'websocket' (default), 'sse', 'polling', or 'auto' (tries WS then SSE then polling) */
+    signalingTransport?: "websocket" | "sse" | "polling" | "auto";
+}
+interface DendriConnectOption {
+    /**
+     * A unique label by which you want to identify this data connection.
+     * If left unspecified, a label will be generated at random.
+     *
+     * Can be accessed with {@apilink DataConnection.label}
+     */
+    label?: string;
+    /**
+     * Metadata associated with the connection, passed in by whoever initiated the connection.
+     *
+     * Can be accessed with {@apilink DataConnection.metadata}.
+     * Can be any serializable type.
+     */
+    metadata?: any;
+    serialization?: string;
+    reliable?: boolean;
+}
+interface HybridConnectionOption {
+    /** Milliseconds before falling back to WebSocket relay (default 10000). */
+    iceTimeout?: number;
+    /** Periodically retry WebRTC when on relay (default true). */
+    autoUpgrade?: boolean;
+    /** Milliseconds between upgrade attempts (default 60000). */
+    upgradeInterval?: number;
+    /** Max consecutive upgrade failures before stopping (default 5). */
+    maxUpgradeAttempts?: number;
+    /** Poll getStats() for connection quality metrics (default false). */
+    enableMetrics?: boolean;
+    /** Encrypt relay (WebSocket) messages with ECDH + AES-256-GCM (default true). */
+    encryptRelay?: boolean;
+}
+interface CallOption {
+    /**
+     * Metadata associated with the connection, passed in by whoever initiated the connection.
+     *
+     * Can be accessed with {@apilink MediaConnection.metadata}.
+     * Can be any serializable type.
+     */
+    metadata?: any;
+    /**
+     * Function which runs before create offer to modify sdp offer message.
+     */
+    sdpTransform?: (sdp: string) => string;
+}
+
+/** Options accepted by {@link HybridConnection.send}. */
+interface HybridSendOptions {
+    /** When set, the message is tagged with this topic string. */
+    readonly topic?: string;
+}
+interface HybridConnectionEvents {
+    open: () => void;
+    data: (data: unknown) => void;
+    close: () => void;
+    error: (err: Error) => void;
+    transportChanged: (mode: TransportMode) => void;
+    qualityChanged: (quality: ConnectionQuality) => void;
+}
+/**
+ * Wraps both a WebRTC DataConnection and a WebSocket relay,
+ * switching transparently between them.
+ *
+ * - Attempts WebRTC first; falls back to WS relay on ICE timeout.
+ * - Periodically retries WebRTC upgrade when on relay.
+ * - Emits `transportChanged` whenever the active transport switches.
+ */
+declare class HybridConnection extends EventEmitter<HybridConnectionEvents> {
+    readonly peer: string;
+    private readonly _provider;
+    private readonly _options;
+    private _dataConnection;
+    private _mode;
+    private _iceTimer;
+    private _upgradeTimer;
+    private _upgradeAttempts;
+    private _open;
+    private _closed;
+    private readonly _ackManager;
+    private readonly _topics;
+    private readonly _encryption;
+    private readonly _encryptRelay;
+    private _keyExchangeSent;
+    private _pendingRelayQueue;
+    private _expectedSeq;
+    private _reorderBuffer;
+    private readonly _reorderTimeout;
+    private _reorderTimers;
+    constructor(peer: string, provider: Dendri, options?: HybridConnectionOption);
+    get mode(): TransportMode;
+    get open(): boolean;
+    /** Start connection: try WebRTC first, fall back to WS relay on timeout. */
+    start(): void;
+    /** Send data through the best available transport, optionally tagged with a topic. */
+    send(data: unknown, options?: HybridSendOptions): void;
+    /**
+     * Send data with delivery confirmation (at-least-once guarantee).
+     * Resolves when the remote peer ACKs, rejects on timeout.
+     */
+    sendWithAck(data: unknown, timeoutMs?: number): Promise<void>;
+    /**
+     * @internal
+     * Expose the AckManager so the Dendri instance can route incoming ACKs.
+     */
+    get ackManager(): AckManager;
+    /**
+     * Subscribe to messages on a specific topic.
+     * Returns an unsubscribe function.
+     */
+    subscribe(topic: string, handler: (data: unknown, peerId: string) => void): () => void;
+    /**
+     * Subscribe to all incoming data regardless of topic.
+     * Returns an unsubscribe function.
+     */
+    onData(handler: (data: unknown, peerId: string) => void): () => void;
+    /**
+     * Handle a DATA message received via WebSocket relay.
+     * Called by Dendri._handleMessage when routing relay data.
+     *
+     * @param payload - The message payload.
+     * @param seq - Optional server-assigned sequence number for ordering.
+     */
+    handleRelayData(payload: unknown, seq?: number): void;
+    /** Close connection and clean up all resources. */
+    close(): void;
+    /**
+     * Initiate the ECDH key exchange by generating a key pair and sending
+     * the public key to the remote peer via signaling.
+     */
+    initiateKeyExchange(): void;
+    /**
+     * Handle an incoming KEY_EXCHANGE message from the remote peer.
+     * Derives the shared secret and sends our public key back if we haven't yet.
+     */
+    handleKeyExchange(payload: {
+        publicKey: JsonWebKey;
+    }): void;
+    /**
+     * Send a payload via WebSocket relay, encrypting it if encryption is ready.
+     * If encryption is enabled but not yet ready, the message is queued.
+     */
+    private _sendRelay;
+    /** Flush messages that were queued while waiting for key exchange. */
+    private _flushPendingRelayQueue;
+    /**
+     * Enforce ordered delivery for sequenced relay messages.
+     * Messages without a seq or when not in relay mode are delivered immediately.
+     */
+    private _deliverInOrder;
+    /** Flush consecutive messages from the reorder buffer. */
+    private _flushReorderBuffer;
+    /**
+     * Force-flush the reorder buffer when a timeout fires.
+     * Skips past any gaps by advancing _expectedSeq to the lowest buffered
+     * sequence, then delivers all consecutive messages from there.
+     */
+    private _forceFlushReorderBuffer;
+    /**
+     * Route an incoming payload through the TopicManager (if applicable)
+     * and emit the generic `data` event.
+     *
+     * If the payload is a topic envelope, the inner data is extracted and
+     * dispatched to topic-specific handlers. The raw `data` event always fires
+     * with the unwrapped payload so legacy listeners still work.
+     */
+    private _dispatchIncoming;
+    /** Attempt a WebRTC connection with ICE timeout. */
+    private _attemptWebRTC;
+    /** Switch to WebSocket relay and optionally schedule periodic upgrade attempts. */
+    private _fallbackToRelay;
+    /** Update the transport mode and emit if changed. */
+    private _setMode;
+    private _clearIceTimer;
+    private _clearUpgradeTimer;
+    /**
+     * Periodically retry WebRTC when on relay.
+     * Respects `autoUpgrade`, `upgradeInterval`, and `maxUpgradeAttempts` options.
+     */
+    private _scheduleUpgrade;
+}
+
+declare enum LogLevel {
+    /**
+     * Prints no logs.
+     */
+    Disabled = 0,
+    /**
+     * Prints only errors.
+     */
+    Errors = 1,
+    /**
+     * Prints errors and warnings.
+     */
+    Warnings = 2,
+    /**
+     * Prints all logs.
+     */
+    All = 3
+}
+
+interface MediaConnectionEvents extends BaseConnectionEvents<never> {
+    /**
+     * Emitted when a connection to the Dendri server is established.
+     *
+     * ```ts
+     * mediaConnection.on('stream', (stream) => { ... });
+     * ```
+     */
+    stream: (stream: MediaStream) => void;
+    /**
+     * Emitted when the auxiliary data channel is established.
+     * After this event, hanging up will close the connection cleanly on the remote peer.
+     * @beta
+     */
+    willCloseOnRemote: () => void;
+}
+/**
+ * Wraps WebRTC's media streams.
+ * To get one, use {@apilink Dendri.call} or listen for the {@apilink DendriEvents | `call`} event.
+ */
+declare class MediaConnection extends BaseConnection<MediaConnectionEvents> {
+    private static readonly ID_PREFIX;
+    readonly label: string;
+    private _negotiator;
+    private _localStream;
+    private _remoteStream;
+    /**
+     * For media connections, this is always 'media'.
+     */
+    get type(): ConnectionType;
+    get localStream(): MediaStream | null | undefined;
+    get remoteStream(): MediaStream | null;
+    constructor(peerId: string, provider: Dendri, options: any);
+    /** Called by the Negotiator when the DataChannel is ready. */
+    _initializeDataChannel(dc: RTCDataChannel): void;
+    addStream(remoteStream: MediaStream): void;
+    /**
+     * @internal
+     */
+    handleMessage(message: ServerMessage): void;
+    /**
+     * When receiving a {@apilink DendriEvents | `call`} event on a peer, you can call
+     * `answer` on the media connection provided by the callback to accept the call
+     * and optionally send your own media stream.
+
+     *
+     * @param stream A WebRTC media stream.
+     * @param options
+     * @returns
+     */
+    answer(stream?: MediaStream, options?: AnswerOption): void;
+    /**
+     * Exposed functionality for users.
+     */
+    /**
+     * Closes the media connection.
+     */
+    close(): void;
+}
+
+/**
+ * Events emitted by all signaling transports.
+ */
+interface TransportEvents {
+    [SocketEventType.Message]: (data: any) => void;
+    [SocketEventType.Disconnected]: () => void;
+    [SocketEventType.Error]: (error: string) => void;
+    [SocketEventType.Reconnected]: () => void;
+    [SocketEventType.ReconnectAttempt]: (attempt: number) => void;
+}
+/**
+ * Abstract signaling transport. WebSocket, SSE+POST, and Long Polling
+ * all implement this interface so the Dendri class is transport-agnostic.
+ */
+declare abstract class SignalingTransport extends EventEmitter<TransportEvents> {
+    abstract start(id: string, token: string): void;
+    abstract send(data: any): void;
+    abstract close(): void;
+    abstract get reconnectAttempt(): number;
+}
+
+declare class DendriOptions implements DendriOption {
+    /**
+     * Prints log messages depending on the debug level passed in.
+     */
+    debug?: LogLevel;
+    /**
+     * Server host for your Dendri signaling server.
+     * Also accepts `'/'` to signify relative hostname.
+     */
+    host: string;
+    /**
+     * Server port. Defaults to `443`.
+     */
+    port?: number;
+    /**
+     * The path where your self-hosted Dendri server is running. Defaults to `'/'`
+     */
+    path?: string;
+    /**
+     * API key for the Dendri server.
+     * This is not used anymore.
+     * @deprecated
+     */
+    key?: string;
+    token?: string;
+    /**
+     * Configuration hash passed to RTCPeerConnection.
+     * This hash contains any custom ICE/TURN server configuration.
+     *
+     * Defaults to {@apilink util.defaultConfig}
+     */
+    config?: any;
+    /**
+     * Set to true `true` if you're using TLS.
+     * :::danger
+     * If possible *always use TLS*
+     * :::
+     */
+    secure?: boolean;
+    pingInterval?: number;
+    referrerPolicy?: ReferrerPolicy;
+    logFunction?: (logLevel: LogLevel, ...rest: any[]) => void;
+    serializers?: SerializerMapping;
+    /** Auto-fetch TURN credentials from the signaling server's GET /turn endpoint. */
+    fetchTurnCredentials?: boolean;
+    /** Optional JWT for authenticated connections. */
+    jwt?: string;
+    /** Enable WebSocket relay fallback when WebRTC is unavailable. */
+    enableRelay?: boolean;
+    /** Optional function to validate connection metadata before accepting. */
+    validateMetadata?: (metadata: unknown) => boolean;
+    /** Signaling transport: 'websocket' (default), 'sse', 'polling', or 'auto' (tries WS then SSE then polling) */
+    signalingTransport?: "websocket" | "sse" | "polling" | "auto";
+}
+
+interface SerializerMapping {
+    [key: string]: new (peerId: string, provider: Dendri, options: any) => DataConnection;
+}
+interface DendriEvents {
+    /**
+     * Emitted when a connection to the Dendri server is established.
+     *
+     * You may use the peer before this is emitted, but messages to the server will be queued. <code>id</code> is the brokering ID of the peer (which was either provided in the constructor or assigned by the server).<span class='tip'>You should not wait for this event before connecting to other peers if connection speed is important.</span>
+     */
+    open: (id: string) => void;
+    /**
+     * Emitted when a new data connection is established from a remote peer.
+     */
+    connection: (dataConnection: DataConnection) => void;
+    /**
+     * Emitted when a remote peer attempts to call you.
+     */
+    call: (mediaConnection: MediaConnection) => void;
+    /**
+     * Emitted when the peer is destroyed and can no longer accept or create any new connections.
+     */
+    close: () => void;
+    /**
+     * Emitted when the peer is disconnected from the signalling server
+     */
+    disconnected: (currentId: string) => void;
+    /**
+     * Errors on the peer are almost always fatal and will destroy the peer.
+     *
+     * Errors from the underlying socket and PeerConnections are forwarded here.
+     */
+    error: (error: DendriError<`${DendriErrorType}`>) => void;
+    /**
+     * Emitted when the server sends a ROOM_PEERS message with the current
+     * list of peers in a room.
+     */
+    roomPeers: (room: string, peers: string[]) => void;
+    /**
+     * Emitted when the connection state machine transitions to a new state.
+     */
+    connectionStateChanged: (state: ConnectionState, previousState: ConnectionState) => void;
+    /**
+     * Emitted when a PRESENCE_UPDATE message is received from the server.
+     */
+    presenceUpdate: (peerId: string, room: string, data: unknown) => void;
+    /**
+     * Emitted when the underlying signaling socket finishes a successful
+     * reconnection. Consumers (e.g. Room) should re-send server-side
+     * state (joinRoom, presence) so it survives server-side state loss
+     * such as a Durable Object hibernation + wake-up cycle.
+     */
+    reconnected: () => void;
+}
+/**
+ * A peer who can initiate connections with other peers.
+ */
+declare class Dendri extends EventEmitterWithError<DendriErrorType, DendriEvents> {
+    private static readonly DEFAULT_KEY;
+    protected readonly _serializers: SerializerMapping;
+    private readonly _options;
+    private readonly _api;
+    private readonly _socket;
+    private _id;
+    private _lastServerId;
+    private _connectionState;
+    /** Number of consecutive reconnection failures that triggers the Suspended state. */
+    private static readonly SUSPEND_THRESHOLD;
+    private readonly _connections;
+    private readonly _lostMessages;
+    private readonly _lostMessageGeneration;
+    private readonly _hybridConnections;
+    /**
+     * The brokering ID of this peer
+     *
+     * If no ID was specified in {@apilink Dendri | the constructor},
+     * this will be `undefined` until the {@apilink DendriEvents | `open`} event is emitted.
+     */
+    get id(): string | null;
+    get options(): DendriOptions;
+    /**
+     * The current connection state of this peer.
+     */
+    get connectionState(): ConnectionState;
+    get open(): boolean;
+    /**
+     * @internal
+     */
+    get socket(): SignalingTransport;
+    /**
+     * A hash of all connections associated with this peer, keyed by the remote peer's ID.
+     * @deprecated
+     * Return type will change from Object to Map<string,[]>
+     */
+    get connections(): Object;
+    /**
+     * true if this peer and all of its connections can no longer be used.
+     */
+    get destroyed(): boolean;
+    /**
+     * false if there is an active connection to the Dendri server.
+     *
+     * Also returns true for terminal states (Closed/Failed) to preserve
+     * backward compatibility: the original boolean was set during
+     * disconnect() and never cleared by destroy().
+     */
+    get disconnected(): boolean;
+    /**
+     * A peer can connect to other peers and listen for connections.
+     */
+    constructor(options: DendriOptions);
+    /**
+     * A peer can connect to other peers and listen for connections.
+     * @param id Other peers can connect to this peer using the provided ID.
+     *     If no ID is given, one will be generated by the brokering server.
+     * The ID must start and end with an alphanumeric character (lower or upper case character or a digit). In the middle of the ID spaces, dashes (-) and underscores (_) are allowed. Use {@apilink DendriOptions.metadata } to send identifying information.
+     * @param options for specifying details about Dendri server
+     */
+    constructor(id: string, options?: DendriOptions);
+    /**
+     * Transition to a new connection state. Invalid transitions are logged and ignored.
+     */
+    private _setState;
+    private static _isValidTransition;
+    private _createServerConnection;
+    /** Initialize a connection with the server. */
+    private _initialize;
+    /** Handles messages from the server. */
+    private _handleMessage;
+    private static readonly MAX_LOST_MESSAGES;
+    private static readonly LOST_MESSAGE_TTL;
+    /** Stores messages without a set up connection, to be claimed later. */
+    private _storeMessage;
+    /**
+     * Retrieve messages from lost message store
+     * @internal
+     */
+    _getMessages(connectionId: string): ServerMessage[];
+    /**
+     * Connects to the remote peer specified by id and returns a data connection.
+     * @param peer The brokering ID of the remote peer (their {@apilink Dendri.id}).
+     * @param options for specifying details about the data connection
+     */
+    connect(peer: string, options?: DendriConnectOption): DataConnection | undefined;
+    /**
+     * Calls the remote peer specified by id and returns a media connection.
+     * @param peer The brokering ID of the remote peer (their peer.id).
+     * @param stream The caller's media stream
+     * @param options Metadata associated with the connection, passed in by whoever initiated the connection.
+     */
+    call(peer: string, stream: MediaStream, options?: CallOption): MediaConnection | undefined;
+    /**
+     * Create a hybrid connection that uses WebRTC when possible
+     * and transparently falls back to WebSocket relay.
+     *
+     * @param peer The brokering ID of the remote peer.
+     * @param options HybridConnection-specific options (ICE timeout, upgrade behaviour, etc.)
+     */
+    connectHybrid(peer: string, options?: HybridConnectionOption): HybridConnection | undefined;
+    /**
+     * Join a room on the signaling server.
+     * The server will respond with a ROOM_PEERS message listing current members.
+     */
+    joinRoom(roomName: string): void;
+    /**
+     * Leave a room on the signaling server.
+     */
+    leaveRoom(roomName: string): void;
+    /** Auto-fetch TURN credentials when the option is enabled. */
+    private _fetchTurnIfEnabled;
+    /** Add a data/media connection to this peer. */
+    private _addConnection;
+    _removeConnection(connection: DataConnection | MediaConnection): void;
+    /** Retrieve a data/media connection for this peer. */
+    getConnection(peerId: string, connectionId: string): null | DataConnection | MediaConnection;
+    /** Error types that indicate an unrecoverable problem. */
+    private static readonly FATAL_ERROR_TYPES;
+    private _delayedAbort;
+    /**
+     * Emits an error message and destroys the Dendri instance.
+     * The Dendri instance is not destroyed if it's in a disconnected state, in which case
+     * it retains its disconnected state and its existing connections.
+     */
+    private _abort;
+    /**
+     * Destroys the Dendri instance: closes all active connections as well as the connection
+     * to the server.
+     *
+     * :::caution
+     * This cannot be undone; the respective peer object will no longer be able
+     * to create or receive any connections, its ID will be forfeited on the server,
+     * and all of its data and media connections will be closed.
+     * :::
+     */
+    destroy(): void;
+    /** Internal destroy that transitions to the given terminal state. */
+    private _destroyWithState;
+    /** Disconnects every connection on this peer. */
+    private _cleanup;
+    /** Closes all connections to this peer. */
+    private _cleanupPeer;
+    /**
+     * Disconnects the Dendri instance's connection to the Dendri server. Does not close any
+     *  active connections.
+     * Warning: The peer can no longer create or accept connections after being
+     *  disconnected. It also cannot reconnect to the server.
+     */
+    disconnect(): void;
+    /** Attempts to reconnect with the same ID.
+     *
+     * Only {@apilink Dendri.disconnect | disconnected peers} can be reconnected.
+     * Destroyed peers cannot be reconnected.
+     * If the connection fails (as an example, if the peer's old ID is now taken),
+     * the peer's existing connections will not close, but any associated errors events will fire.
+     */
+    reconnect(): void;
+    /**
+     * Get a list of available peer IDs. If you're running your own server, you'll
+     * want to set allow_discovery: true in the Dendri server options.
+     */
+    listAllPeers(cb?: (_: any[]) => void): void;
+    /** Returns a snapshot of the current connection state for debugging. */
+    diagnostics(): {
+        peerId: string | null;
+        connectionState: ConnectionState;
+        serverConnected: boolean;
+        connections: Array<{
+            peerId: string;
+            type: string;
+            open: boolean;
+        }>;
+        hybridConnections: Array<{
+            peerId: string;
+            mode: TransportMode;
+            open: boolean;
+        }>;
+        socket: {
+            connected: boolean;
+            autoReconnect: boolean;
+            reconnectAttempt: number;
+            lastSeq: number;
+        };
+        pendingMessages: number;
+    };
+}
+
+declare abstract class StreamConnection extends DataConnection {
+    private _CHUNK_SIZE;
+    private _splitStream;
+    private _rawSendStream;
+    protected writer: WritableStreamDefaultWriter<Uint8Array<ArrayBufferLike>>;
+    private _readStreamMessageHandler;
+    private _readStreamController;
+    protected _rawReadStream: ReadableStream<ArrayBuffer>;
+    protected constructor(peerId: string, provider: Dendri, options: any);
+    _initializeDataChannel(dc: RTCDataChannel): void;
+    close(options?: {
+        flush?: boolean;
+    }): void;
+}
+
+declare class MsgPack extends StreamConnection {
+    readonly serialization = "MsgPack";
+    private _encoder;
+    constructor(peerId: string, provider: Dendri, options: any);
+    protected _send(data: unknown): Promise<void>;
+}
+
+export { MsgPack };