@lakutata/webrtc 0.0.0-stage → 3.1.1

package/dist/cjs/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;
+}