@lakutata/webrtc 0.0.0-stage → 3.1.4

package/dist/types/lib/dtls/record/message/header.d.ts

@@ -0,0 +1,38 @@
+import { binaryData } from '../../imports/common.js';
+export interface DtlsPlaintextHeader {
+    contentType: number;
+    protocolVersion: {
+        major: number;
+        minor: number;
+    };
+    epoch: number;
+    sequenceNumber: number;
+    contentLen: number;
+}
+export declare class MACHeader {
+    epoch: number;
+    sequenceNumber: number;
+    contentType: number;
+    protocolVersion: {
+        major: number;
+        minor: number;
+    };
+    contentLen: number;
+    static readonly spec: {
+        epoch: binaryData.NumberType;
+        sequenceNumber: binaryData.NumberType;
+        contentType: binaryData.NumberType;
+        protocolVersion: {
+            major: binaryData.NumberType;
+            minor: binaryData.NumberType;
+        };
+        contentLen: binaryData.NumberType;
+    };
+    constructor(epoch: number, sequenceNumber: number, contentType: number, protocolVersion: {
+        major: number;
+        minor: number;
+    }, contentLen: number);
+    static createEmpty(): MACHeader;
+    static deSerialize(buf: Buffer): MACHeader;
+    serialize(): Buffer<ArrayBufferLike>;
+}

package/dist/types/lib/dtls/record/message/plaintext.d.ts

@@ -0,0 +1,14 @@
+import { type DtlsPlaintextHeader } from './header.js';
+export declare class DtlsPlaintext {
+    recordLayerHeader: DtlsPlaintextHeader;
+    fragment: Buffer;
+    constructor(recordLayerHeader: DtlsPlaintextHeader, fragment: Buffer);
+    get summary(): {
+        header: DtlsPlaintextHeader;
+        fragment: string;
+    };
+    static createEmpty(): DtlsPlaintext;
+    static deSerialize(buf: Buffer): DtlsPlaintext;
+    serialize(): Buffer<ArrayBuffer>;
+    computeMACHeader(): Buffer<ArrayBufferLike>;
+}

package/dist/types/lib/dtls/record/receive.d.ts

@@ -0,0 +1,9 @@
+import type { CipherContext } from '../context/cipher.js';
+import type { DtlsContext } from '../context/dtls.js';
+import { ContentType } from './const.js';
+import { DtlsPlaintext } from './message/plaintext.js';
+export declare const parsePacket: (data: Buffer) => DtlsPlaintext[];
+export declare const parsePlainText: (dtls: DtlsContext, cipher: CipherContext) => (plain: DtlsPlaintext) => {
+    type: ContentType;
+    data: any;
+}[];

package/dist/types/lib/dtls/server.d.ts

@@ -0,0 +1,6 @@
+import { DtlsSocket, type Options } from './socket.js';
+export declare class DtlsServer extends DtlsSocket {
+    constructor(options: Options);
+    private flight6?;
+    private handleHandshakes;
+}

package/dist/types/lib/dtls/socket.d.ts

@@ -0,0 +1,52 @@
+import { type Address, Event, type Transport } from './imports/common.js';
+import { type SignatureHash } from './cipher/const.js';
+import { type SessionTypes } from './cipher/suites/abstract.js';
+import { CipherContext } from './context/cipher.js';
+import { DtlsContext } from './context/dtls.js';
+import { SrtpContext } from './context/srtp.js';
+import { TransportContext } from './context/transport.js';
+import type { SrtpProfile } from './imports/rtp.js';
+import { FragmentedHandshake } from './record/message/fragment.js';
+import type { Extension } from './typings/domain.js';
+export declare class DtlsSocket {
+    options: Options;
+    sessionType: SessionTypes;
+    readonly onConnect: Event<any[]>;
+    readonly onData: Event<[Buffer<ArrayBufferLike>]>;
+    readonly onError: Event<[Error]>;
+    readonly onClose: Event<any[]>;
+    readonly transport: TransportContext;
+    cipher: CipherContext;
+    dtls: DtlsContext;
+    srtp: SrtpContext;
+    connected: boolean;
+    extensions: Extension[];
+    onHandleHandshakes: (assembled: FragmentedHandshake[]) => Promise<void>;
+    private bufferFragmentedHandshakes;
+    constructor(options: Options, sessionType: SessionTypes);
+    renegotiation(): void;
+    private udpOnMessage;
+    private setupExtensions;
+    protected waitForReady: (condition: () => boolean) => Promise<void>;
+    handleFragmentHandshake(messages: FragmentedHandshake[]): FragmentedHandshake[];
+    /**send application data */
+    send: (buf: Buffer, addr?: Address) => Promise<void>;
+    close(): void;
+    extractSessionKeys(keyLength: number, saltLength: number): {
+        localKey: Buffer<ArrayBufferLike>;
+        localSalt: Buffer<ArrayBufferLike>;
+        remoteKey: Buffer<ArrayBufferLike>;
+        remoteSalt: Buffer<ArrayBufferLike>;
+    };
+    exportKeyingMaterial(label: string, length: number): Buffer<ArrayBuffer>;
+    get remoteCertificate(): Buffer<ArrayBufferLike> | undefined;
+}
+export interface Options {
+    transport: Transport;
+    srtpProfiles?: SrtpProfile[];
+    cert?: string;
+    key?: string;
+    signatureHash?: SignatureHash;
+    certificateRequest?: boolean;
+    extendedMasterSecret?: boolean;
+}

package/dist/types/lib/dtls/typings/domain.d.ts

@@ -0,0 +1,20 @@
+import type { HandshakeType } from '../handshake/const.js';
+import type { FragmentedHandshake } from '../record/message/fragment.js';
+export type Version = {
+    major: number;
+    minor: number;
+};
+export type Random = {
+    gmt_unix_time: number;
+    random_bytes: Buffer;
+};
+export type Handshake = {
+    msgType: HandshakeType;
+    messageSeq?: number;
+    serialize: () => Buffer;
+    toFragment: () => FragmentedHandshake;
+};
+export type Extension = {
+    type: number;
+    data: Buffer;
+};

package/dist/types/lib/dtls/util/binary.d.ts

@@ -0,0 +1,2 @@
+import { binaryData } from '../imports/common.js';
+export declare function encodeBuffer(obj: object, spec: binaryData.Schema): Buffer<ArrayBufferLike>;

package/dist/types/lib/ice/candidate.d.ts

@@ -0,0 +1,35 @@
+export type TcpCandidateType = 'active' | 'passive' | 'so';
+export declare class Candidate {
+    foundation: string;
+    component: number;
+    transport: string;
+    priority: number;
+    host: string;
+    port: number;
+    type: string;
+    relatedAddress?: string | undefined;
+    relatedPort?: number | undefined;
+    tcptype?: string | undefined;
+    generation?: number | undefined;
+    ufrag?: string | undefined;
+    id: string;
+    constructor(foundation: string, component: number, transport: string, priority: number, host: string, port: number, type: string, relatedAddress?: string | undefined, relatedPort?: number | undefined, tcptype?: string | undefined, generation?: number | undefined, ufrag?: string | undefined);
+    refreshId(): void;
+    static fromSdp(sdp: string): Candidate;
+    canPairWith(other: Candidate): boolean;
+    toSdp(): string;
+}
+export declare function candidateLocalPreference({ candidateType, transport, tcptype, otherPreference }: {
+    candidateType: string;
+    transport?: string;
+    tcptype?: string;
+    otherPreference?: number;
+}): number;
+export declare function candidateFoundation(candidateType: string, candidateTransport: string, baseAddress: string, server?: string): string;
+export declare function candidatePriority(candidateType: string, options?: number | {
+    transport?: string;
+    tcptype?: string;
+    localPreference?: number;
+    otherPreference?: number;
+}): number;
+export declare function remoteTcpTypeForIncoming(localTcpType?: string): TcpCandidateType;

package/dist/types/lib/ice/dns/lookup.d.ts

@@ -0,0 +1,16 @@
+import * as worker_thread from 'node:worker_threads';
+import { MulticastDns } from './mdns.js';
+export declare class MdnsLookup {
+    cache: Map<string, Promise<string>>;
+    mdnsInstance: MulticastDns;
+    constructor();
+    lookup(host: string): Promise<string>;
+    close(): void;
+}
+export declare class DnsLookup {
+    thread: worker_thread.Worker;
+    cache: Map<string, Promise<string>>;
+    constructor();
+    lookup(host: string): Promise<string>;
+    close(): Promise<number>;
+}

package/dist/types/lib/ice/dns/mdns.d.ts

@@ -0,0 +1,38 @@
+import { type RemoteInfo } from 'node:dgram';
+import { EventEmitter } from 'node:events';
+/**
+ * A record of an mDNS answer
+ */
+export interface MdnsAnswer {
+    name: string;
+    type: 'A' | 'AAAA' | number;
+    ttl: number;
+    data: string | Buffer;
+}
+/**
+ * The answers (and additional records) of an mDNS response; undefined when the packet is a query or malformed
+ */
+export declare function parseMdnsResponse(packet: Buffer): MdnsAnswer[] | undefined;
+/**
+ * A query of one name: no id, no flags, one question of class IN
+ */
+export declare function encodeMdnsQuery(name: string, type: 'A' | 'AAAA'): Buffer;
+/**
+ * A client of multicast DNS (RFC 6762) that only queries: it joins the group on port 5353 (shared with the other
+ * responders of the host) and emits the answers of every response it hears
+ */
+export declare class MulticastDns extends EventEmitter<{
+    response: [MdnsAnswer[], RemoteInfo];
+    error: [Error];
+}> {
+    #private;
+    constructor();
+    /**
+     * Sends a query of a name to the group
+     */
+    query(name: string, type?: 'A' | 'AAAA'): Promise<void>;
+    /**
+     * Leaves the group and closes the socket
+     */
+    destroy(): void;
+}

package/dist/types/lib/ice/exceptions.d.ts

@@ -0,0 +1,24 @@
+import type { Address } from './imports/common.js';
+import type { Message } from './stun/message.js';
+export declare class TransactionError extends Error {
+    response?: Message;
+    addr?: Address;
+}
+export declare class TransactionFailed extends TransactionError {
+    response: Message;
+    addr: Address;
+    constructor(response: Message, addr: Address);
+    get str(): string;
+}
+export declare class TransactionTimeout extends TransactionError {
+    get str(): string;
+}
+/**
+ * The request target is an IP literal of a different family than the socket
+ * that would carry it, so it can never be delivered.
+ */
+export declare class AddressFamilyMismatch extends Error {
+    addr: Address;
+    socketFamily: 4 | 6;
+    constructor(addr: Address, socketFamily: 4 | 6);
+}

package/dist/types/lib/ice/helper.d.ts

@@ -0,0 +1,17 @@
+import { Event } from './imports/common.js';
+export declare function randomString(length: number): string;
+export declare function randomTransactionId(): NonSharedBuffer;
+export declare function bufferXor(a: Buffer, b: Buffer): Buffer;
+export declare function difference<T>(x: Set<T>, y: Set<T>): Set<T>;
+export declare class PQueue<T> {
+    private queue;
+    private wait;
+    put(v: Promise<T>): void;
+    get(): Promise<T>;
+}
+export declare const cancelable: <T>(ex: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void, onCancel: Event<[any]>) => Promise<void>) => {
+    awaitable: Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+};
+export type Cancelable<T> = ReturnType<typeof cancelable<T>>;

package/dist/types/lib/ice/ice.d.ts

@@ -0,0 +1,182 @@
+import { type Address, Event } from './imports/common.js';
+import { Candidate } from './candidate.js';
+import { MdnsLookup } from './dns/lookup.js';
+import { CandidatePair, type IceConnection, type IceOptions, type IceState } from './iceBase.js';
+import { Message } from './stun/message.js';
+import type { Protocol } from './types/model.js';
+export declare class Connection implements IceConnection {
+    private _iceControlling;
+    localUsername: string;
+    localPassword: string;
+    remoteIsLite: boolean;
+    remotePassword: string;
+    remoteUsername: string;
+    checkList: CandidatePair[];
+    localCandidates: Candidate[];
+    stunServer?: Address;
+    turnServer?: Address;
+    options: IceOptions;
+    private stunServers;
+    private relayServers;
+    /**the relays by the host of their TURN server */
+    private relays;
+    remoteCandidatesEnd: boolean;
+    localCandidatesEnd: boolean;
+    generation: number;
+    userHistory: {
+        [username: string]: string;
+    };
+    private readonly tieBreaker;
+    state: IceState;
+    lookup?: MdnsLookup;
+    private _remoteCandidates;
+    nominated?: CandidatePair;
+    private nominating;
+    private checkListDone;
+    private checkListState;
+    private earlyChecks;
+    private earlyChecksDone;
+    private localCandidatesStart;
+    private protocols;
+    private queryConsentHandle?;
+    /** RFC 7675 consent-to-send: application data may use the selected pair. */
+    private consentFresh;
+    /** Invalidates in-flight consent callbacks on restart / close / replace / expire. */
+    private consentSessionId;
+    private consentExpiryTimer?;
+    private consentRequestAbort?;
+    private resolvingRemoteCandidates;
+    private noPairDeadline;
+    readonly onData: Event<[Buffer<ArrayBufferLike>]>;
+    readonly stateChanged: Event<[IceState]>;
+    readonly onIceCandidate: Event<[Candidate]>;
+    constructor(_iceControlling: boolean, options?: Partial<IceOptions>);
+    /**
+   * Replace STUN/TURN servers after construction.
+   * Server-related fields are replaced (not partial-merged) so that removing
+   * TURN clears residual credentials. W3C setConfiguration replaces the ICE
+   * server list rather than merging additively.
+   *
+   * Used when servers are learned after the gatherer was built (e.g. WHIP
+   * Link headers) and must take effect before the next gather pass.
+   */
+    setIceServers(options: Partial<IceOptions>): void;
+    /**
+   * Derive Connection.stunServer / turnServer from this.options.
+   * Shared by the constructor and setIceServers so both paths validate and
+   * default identically.
+   */
+    private applyStunTurnServersFromOptions;
+    get iceControlling(): boolean;
+    set iceControlling(value: boolean);
+    get iceLite(): boolean;
+    restart(): Promise<void>;
+    resetNominatedPair(): void;
+    setRemoteParams({ iceLite, usernameFragment, password }: {
+        iceLite: boolean;
+        usernameFragment: string;
+        password: string;
+    }): void;
+    gatherCandidates(): Promise<void>;
+    private appendLocalCandidate;
+    /**
+   * Whether a candidate with the same address and base was gathered already
+   * (RFC 8445, section 5.1.3): a server reflexive address that is a host
+   * address, or that another STUN server gave too.
+   */
+    private isRedundant;
+    /**
+   * A relay candidate from each TURN server. An ICE restart keeps the
+   * allocation of a server when the server still has it; the relays of the
+   * servers no longer configured are closed.
+   */
+    private gatherRelayCandidates;
+    /**
+   * Allocate a relay on a TURN server: its transports are tried in order, the
+   * next one when the one before fails or has not answered within
+   * RELAY_ATTEMPT_DELAY; the first allocation made is kept, a later one is
+   * deleted.
+   */
+    private allocateRelay;
+    /** Stop using a relay and delete its allocation. */
+    private dropRelay;
+    private ensureProtocol;
+    /**
+   * RFC 6544: the selected TCP connection is the only path for this component;
+   * once it is closed no application data or consent check can reach the peer,
+   * so fail the same way as a consent expiry instead of waiting for it.
+   */
+    private handleConnectionClosed;
+    private getCandidatePromises;
+    connect(): Promise<void>;
+    private unfreezeInitial;
+    private schedulingChecks;
+    /**
+   * Stop consent request cadence, expiry timer, and outstanding transactions.
+   * Does not change ICE state by itself.
+   */
+    private stopConsentLifecycle;
+    /**
+   * ICE-lite interop only (not required by RFC 7675): mirror libwebrtc
+   * semi-aggressive nomination — attach USE-CANDIDATE when we are controlling,
+   * the remote is ICE-lite, and the target is the current selected pair.
+   */
+    private shouldNominateConsentRequest;
+    private canSendApplicationData;
+    private abortableDelay;
+    private queryConsent;
+    close(): Promise<void>;
+    private setState;
+    addRemoteCandidate(remoteCandidate: Candidate | undefined): Promise<void>;
+    /**
+     * Resolve the mDNS name of a remote candidate, then add it, unless ICE restarted or closed meanwhile
+     * @param remoteCandidate
+     */
+    private resolveRemoteCandidate;
+    /**
+     * Add a remote candidate with an address, and pair it
+     * @param remoteCandidate
+     */
+    private addResolvedRemoteCandidate;
+    send: (data: Buffer) => Promise<void>;
+    getDefaultCandidate(): Candidate;
+    set remoteCandidates(value: Candidate[]);
+    get remoteCandidates(): Candidate[];
+    get candidatePairs(): CandidatePair[];
+    private sortCheckList;
+    private findPair;
+    private applyIceControlling;
+    private switchRole;
+    private checkComplete;
+    checkStart: (pair: CandidatePair) => {
+        awaitable: Promise<void>;
+        resolve: (value: void | PromiseLike<void>) => void;
+        reject: (reason?: any) => void;
+    };
+    private isTcpPair;
+    /**
+   * Aggressive nomination lets each side settle on whichever TCP connection
+   * finished first; the two sides can then pick different connections and
+   * pruning destroys the peer's choice. For TCP the controlling agent instead
+   * nominates exactly one valid pair (RFC 8445 §8.1.1 regular nomination).
+   */
+    private usesTcpRegularNomination;
+    private checkRequestOptions;
+    /**
+   * Controlling side: nominate the highest-priority TCP pair once every
+   * higher-priority TCP pair has finished its check, so the choice does not
+   * depend on which connection happened to complete first.
+   */
+    private nominateTcpPairIfReady;
+    private nominateTcpPair;
+    /** The agent was closed or restarted while the nomination was in flight. */
+    private isStaleNomination;
+    private addPair;
+    checkIncoming(message: Message, addr: Address, protocol: Protocol): void;
+    private tryPair;
+    private pairLocalProtocol;
+    private pairRemoteCandidate;
+    private buildRequest;
+    private pruneTcpConnections;
+    private respondError;
+}

package/dist/types/lib/ice/iceBase.d.ts

@@ -0,0 +1,214 @@
+import { Candidate } from './candidate.js';
+import type { MdnsLookup } from './dns/lookup.js';
+import type { Cancelable } from './helper.js';
+import { type Address, type Event, type InterfaceAddresses, type TlsConnectionOptions } from './imports/common.js';
+import { Message } from './stun/message.js';
+import type { Protocol } from './types/model.js';
+export interface IceConnection {
+    iceLite: boolean;
+    iceControlling: boolean;
+    localUsername: string;
+    localPassword: string;
+    remotePassword: string;
+    remoteUsername: string;
+    remoteIsLite: boolean;
+    checkList: CandidatePair[];
+    localCandidates: Candidate[];
+    remoteCandidates: Candidate[];
+    candidatePairs: CandidatePair[];
+    stunServer?: Address;
+    turnServer?: Address;
+    generation: number;
+    options: IceOptions;
+    remoteCandidatesEnd: boolean;
+    localCandidatesEnd: boolean;
+    state: IceState;
+    lookup?: MdnsLookup;
+    nominated?: CandidatePair;
+    readonly onData: Event<[Buffer]>;
+    readonly stateChanged: Event<[IceState]>;
+    readonly onIceCandidate: Event<[Candidate]>;
+    restart(): Promise<void>;
+    setIceServers(options: Partial<IceOptions>): void;
+    setRemoteParams(params: {
+        iceLite: boolean;
+        usernameFragment: string;
+        password: string;
+    }): void;
+    gatherCandidates(): Promise<void>;
+    connect(): Promise<void>;
+    close(): Promise<void>;
+    addRemoteCandidate(remoteCandidate: Candidate | undefined): Promise<void>;
+    send(data: Buffer): Promise<void>;
+    getDefaultCandidate(): Candidate | undefined;
+    resetNominatedPair(): void;
+}
+export interface CandidatePairStats {
+    packetsSent: number;
+    packetsReceived: number;
+    bytesSent: number;
+    bytesReceived: number;
+    rtt?: number;
+    totalRoundTripTime: number;
+    roundTripTimeMeasurements: number;
+    requestsReceived: number;
+    requestsSent: number;
+    responsesReceived: number;
+    responsesSent: number;
+    retransmissionsReceived: number;
+    retransmissionsSent: number;
+    consentRequestsSent: number;
+}
+export declare class CandidatePair implements CandidatePairStats {
+    protocol: Protocol;
+    remoteCandidate: Candidate;
+    iceControlling: boolean;
+    readonly id: string;
+    handle?: Cancelable<void>;
+    nominated: boolean;
+    remoteNominated: boolean;
+    private _state;
+    get state(): CandidatePairState;
+    packetsSent: number;
+    packetsReceived: number;
+    bytesSent: number;
+    bytesReceived: number;
+    rtt?: number;
+    totalRoundTripTime: number;
+    roundTripTimeMeasurements: number;
+    requestsReceived: number;
+    requestsSent: number;
+    responsesReceived: number;
+    responsesSent: number;
+    retransmissionsReceived: number;
+    retransmissionsSent: number;
+    consentRequestsSent: number;
+    private readonly requestTransactionIds;
+    toJSON(): {
+        protocol: string;
+        localCandidate: string;
+        remoteCandidate: string;
+    };
+    get json(): {
+        protocol: string;
+        localCandidate: string;
+        remoteCandidate: string;
+    };
+    constructor(protocol: Protocol, remoteCandidate: Candidate, iceControlling: boolean);
+    updateState(state: CandidatePairState): void;
+    get localCandidate(): Candidate;
+    get remoteAddr(): Address;
+    get component(): number;
+    get priority(): number;
+    get foundation(): string;
+    noteIncomingRequest(transactionId: string): boolean;
+}
+export declare const ICE_COMPLETED: 1;
+export declare const ICE_FAILED: 2;
+/** Basic consent check period in seconds (RFC 7675). Actual interval is 0.8–1.2× this. */
+export declare const CONSENT_INTERVAL = 5;
+/**
+ * @deprecated Consent expiry is based on {@link CONSENT_TIMEOUT} (30s after the
+ * last valid response), not a consecutive failure count. Kept for API compatibility.
+ */
+export declare const CONSENT_FAILURES = 6;
+/** RFC 7675: consent expires this many seconds after the last valid response. */
+export declare const CONSENT_TIMEOUT = 30;
+/**
+ * Default single-shot response wait for consent requests (ms) when RTT is unknown.
+ * Independent of retransmission count. Downstream ICE-lite peers typically
+ * answer in 150–300ms; 1s is a conservative default used by interop patches.
+ */
+export declare const CONSENT_RESPONSE_TIMEOUT = 1000;
+/** RFC 8445 §14.3: ICE RTO must not be less than 500ms. */
+export declare const CONSENT_RESPONSE_TIMEOUT_MIN = 500;
+/**
+ * Compute consent response wait from pair RTT (seconds).
+ * Uses 2×RTT + 200ms jitter margin, floored at {@link CONSENT_RESPONSE_TIMEOUT_MIN}.
+ * Falls back to {@link CONSENT_RESPONSE_TIMEOUT} when RTT is unavailable.
+ */
+export declare function consentResponseTimeoutMs(rttSeconds?: number): number;
+export declare enum CandidatePairState {
+    FROZEN = 0,
+    WAITING = 1,
+    IN_PROGRESS = 2,
+    SUCCEEDED = 3,
+    FAILED = 4
+}
+export type IceState = 'disconnected' | 'closed' | 'completed' | 'new' | 'connected' | 'failed';
+export interface IceOptions {
+    /** Advertise and operate as an ICE lite agent. */
+    iceLite: boolean;
+    useTcp: boolean;
+    /**
+   * Gather passive TCP host candidates (opens a listening TCP server per
+   * interface). Defaults to true. Send-only agents that never accept inbound
+   * connections can set this false to avoid the listener while still gathering
+   * active TCP candidates.
+   */
+    tcpPassive?: boolean;
+    /**
+   * Seconds to wait for server-reflexive candidates while gathering.
+   * Defaults to 5. Where UDP is blocked these STUN queries are never answered,
+   * so the wait always runs to the timeout; agents that must not stall on such
+   * networks can lower it.
+   */
+    stunGatherTimeout?: number;
+    /**
+   * Seconds to wait for a TURN TCP/TLS connection to be established.
+   * Defaults to 8.
+   */
+    turnConnectTimeout?: number;
+    stunServer?: Address;
+    turnServer?: Address;
+    turnUsername?: string;
+    turnPassword?: string;
+    turnTransport?: 'udp' | 'tcp' | 'tls';
+    /**
+   * More STUN servers, queried as stunServer is: each one that answers gives
+   * a server reflexive candidate (the same address only once).
+   */
+    stunServers?: Address[];
+    /**
+   * More TURN servers, used as turnServer is: one relay candidate per server.
+   * The entries of a host are the transports of one server, tried in order.
+   */
+    turnServers?: TurnServerOptions[];
+    turnTlsOptions?: TlsConnectionOptions;
+    /**
+   * Preferred IP family of the TURN/UDP socket, applied only when turnServer
+   * is a hostname. Ignored for an IP literal turnServer, whose own family
+   * always selects the socket. Defaults to 4.
+   */
+    turnUdpFamily?: 4 | 6;
+    forceTurn?: boolean;
+    localPasswordPrefix?: string;
+    useIpv4: boolean;
+    useIpv6: boolean;
+    useLinkLocalAddress?: boolean;
+    portRange?: [number, number];
+    interfaceAddresses?: InterfaceAddresses;
+    additionalHostAddresses?: string[];
+    filterStunResponse?: (message: Message, addr: Address, protocol: Protocol) => boolean;
+    filterCandidatePair?: (pair: CandidatePair) => boolean;
+}
+/** A TURN server, reached with one transport. */
+export interface TurnServerOptions {
+    address: Address;
+    username: string;
+    password: string;
+    /** UDP when undefined, with TCP when UDP fails. */
+    transport?: 'udp' | 'tcp' | 'tls';
+}
+export declare const defaultOptions: IceOptions;
+export declare function validateRemoteCandidate(candidate: Candidate): Candidate;
+export declare function sortCandidatePairs(pairs: {
+    localCandidate: Pick<Candidate, 'priority'>;
+    remoteCandidate: Pick<Candidate, 'priority'>;
+}[], iceControlling: boolean): {
+    localCandidate: Pick<Candidate, "priority">;
+    remoteCandidate: Pick<Candidate, "priority">;
+}[];
+export declare function candidatePairPriority(local: Pick<Candidate, 'priority'>, remote: Pick<Candidate, 'priority'>, iceControlling: boolean): number;
+export declare function serverReflexiveCandidate(protocol: Protocol, stunServer: Address): Promise<Candidate | undefined>;
+export declare function validateAddress(addr?: Address): Address | undefined;

package/dist/types/lib/ice/imports/common.d.ts

@@ -0,0 +1 @@
+export * from '../../common/index.js';