@lakutata/webrtc 0.0.0-stage → 3.1.1

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

@@ -0,0 +1,210 @@
+import { type Chunk, DataChunk, ForwardTsnChunk } from './chunk.js';
+import { SCTP_STATE } from './const.js';
+import { type Unpacked } from './helper.js';
+import { Deque, Event } from './imports/common.js';
+import { OutgoingSSNResetRequestParam, type StreamParam } from './param.js';
+import type { Transport } from './transport.js';
+export declare const DEFAULT_SCTP_MTU = 1191;
+export interface SCTPOptions {
+    /** SCTP packet MTU used for outbound DATA chunk fragmentation. */
+    mtu?: number;
+}
+export declare function maxPayloadSizeForMtu(mtu: number, dataChunkHeaderSize?: number): number;
+export declare function validateSctpMtu(mtu: number): void;
+declare const SCTPConnectionStates: readonly ["new", "closed", "connected", "connecting"];
+type SCTPConnectionState = Unpacked<typeof SCTPConnectionStates>;
+export declare class SCTP {
+    transport: Transport;
+    port: number;
+    flush: Event<[void]>;
+    readonly stateChanged: {
+        [key in SCTPConnectionState]: Event<[]>;
+    };
+    readonly onReconfigStreams: Event<[number[]]>;
+    /**streamId: number, ppId: number, data: Buffer */
+    readonly onReceive: Event<[number, number, Buffer<ArrayBufferLike>]>;
+    onSackReceived: () => Promise<void>;
+    associationState: SCTP_STATE;
+    started: boolean;
+    state: SCTPConnectionState;
+    isServer: boolean;
+    private isStopping;
+    private isClosed;
+    private hmacKey;
+    private localPartialReliability;
+    private localPort;
+    private localVerificationTag;
+    remoteExtensions: number[];
+    remotePartialReliability: boolean;
+    private remotePort?;
+    private remoteVerificationTag;
+    private advertisedRwnd;
+    private lastAdvertisedRwnd;
+    private peerAdvertisedRwnd;
+    private get peerRwnd();
+    private inboundStreams;
+    _inboundStreamsCount: number;
+    _inboundStreamsMax: number;
+    private lastReceivedTsn?;
+    private highestReceivedTsn?;
+    private pendingChunks;
+    private sackDuplicates;
+    private sackMisOrdered;
+    private sackNeeded;
+    private sackPacketCount;
+    private sackHasNewDataInPacket;
+    private sackImmediate;
+    private sackTimeout;
+    private cwnd;
+    readonly mtu: number;
+    private readonly maxPayloadSize;
+    private fastRecoveryExit?;
+    private fastRecoveryTransmit;
+    private forwardTsnChunk?;
+    private flightSize;
+    outboundQueue: Deque<DataChunk>;
+    private outboundStreamSeq;
+    _outboundStreamsCount: number;
+    /**local transmission sequence number */
+    private localTsn;
+    private lastSackedTsn;
+    private advancedPeerAckTsn;
+    private partialBytesAcked;
+    private sentQueue;
+    /**some chunks of the sent queue are marked for retransmission: the queue is only walked then */
+    private retransmitPending;
+    /**called for each DATA chunk on its first transmission: the bytes leave the send buffer (bufferedAmount) */
+    onSent?: (streamId: number, ppId: number, bytes: number) => void;
+    private transmitting;
+    private transmitRequested;
+    private transmitScheduled;
+    /**初期TSNと同じ値に初期化される単調に増加する数です. これは、新しいre-configuration requestパラメーターを送信するたびに1ずつ増加します */
+    reconfigRequestSeq: number;
+    /**このフィールドは、incoming要求のre-configuration requestシーケンス番号を保持します. 他の場合では、次に予想されるre-configuration requestシーケンス番号から1を引いた値が保持されます */
+    reconfigResponseSeq: number;
+    reconfigRequest?: OutgoingSSNResetRequestParam;
+    reconfigQueue: number[];
+    private srtt?;
+    private rttvar?;
+    private rto;
+    /**t1 is wait for initAck or cookieAck */
+    private timer1Handle?;
+    private timer1Chunk?;
+    private timer1Failures;
+    /**t2 is wait for shutdown */
+    private timer2Handle?;
+    private timer2Chunk?;
+    private timer2Failures;
+    /**t3 is wait for data sack */
+    private timer3Handle?;
+    /**Re-configuration Timer */
+    private timerReconfigHandle?;
+    private timerReconfigFailures;
+    private timerHeartbeatHandle?;
+    private heartbeatInterval;
+    private ssthresh?;
+    constructor(transport: Transport, port?: number, options?: SCTPOptions);
+    private get isStopped();
+    get maxChannels(): number | undefined;
+    static client(transport: Transport, port?: number, options?: SCTPOptions): SCTP;
+    static server(transport: Transport, port?: number, options?: SCTPOptions): SCTP;
+    private handleData;
+    private scheduleSack;
+    private sendSack;
+    /**The SACK of what was received so far; the state of the pending SACK is reset, its timer cancelled */
+    private takeSack;
+    private receiveChunk;
+    private getExtensions;
+    private receiveReconfigParam;
+    private receiveDataChunk;
+    private receiveSackChunk;
+    receiveForwardTsnChunk(chunk: ForwardTsnChunk): void;
+    private updateRto;
+    private receive;
+    private getInboundStream;
+    private markReceived;
+    /**
+     * Keep bytes received out of the receive window while the application holds them (it passes them on later): the
+     * sender waits once the window is closed
+     * @param bytes
+     */
+    holdReceived(bytes: number): void;
+    /**
+     * Give back to the receive window bytes held; the sender is told at once when the window it knows is less than half
+     * of the window now
+     * @param bytes
+     */
+    releaseReceived(bytes: number): void;
+    send: (streamId: number, ppId: number, userData: Buffer, { expiry, maxRetransmits, ordered }?: {
+        expiry?: number | undefined;
+        maxRetransmits?: number | undefined;
+        ordered?: boolean;
+    }) => Promise<void>;
+    /**
+     * Transmit at the end of the current task, once: a burst of small messages fills packets, rather than going out
+     * one by one while the congestion window has room
+     */
+    private transmitSoon;
+    private transmit;
+    /**
+   * Sends what the windows allow: FORWARD TSN, then the retransmissions, then the queued DATA, bundled in packets of the
+   * MTU; a pending SACK goes in front of the first DATA. The packets are handed to the transport without waiting: the
+   * DTLS records are numbered and encrypted when sent, so their order holds
+   */
+    private transmitOnce;
+    /**One packet of chunks, handed to the transport without waiting for it */
+    private sendChunks;
+    transmitReconfigRequest(): Promise<void>;
+    sendReconfigParam(param: StreamParam): Promise<void>;
+    private sendResetRequest;
+    private flightSizeIncrease;
+    private flightSizeDecrease;
+    /**t1 is wait for initAck or cookieAck */
+    private timer1Start;
+    private timer1Expired;
+    private timer1Cancel;
+    /**t2 is wait for shutdown */
+    private t2Start;
+    private timer2Expired;
+    private timer2Cancel;
+    /**t3 is wait for data sack */
+    private timer3Start;
+    private timer3Restart;
+    private timer3Expired;
+    private timer3Cancel;
+    /**Re-configuration Timer */
+    private timerReconfigHandleStart;
+    private timerReconfigHandleExpired;
+    private timerReconfigCancel;
+    private heartbeatStart;
+    private heartbeatRestart;
+    private heartbeatCancel;
+    private timerHeartbeatExpired;
+    setHeartbeatInterval(interval: number): void;
+    private updateAdvancedPeerAckPoint;
+    private maybeAbandon;
+    static getCapabilities(): RTCSctpCapabilities;
+    setRemotePort(port: number): void;
+    start(remotePort?: number): Promise<void>;
+    private init;
+    private setExtensions;
+    sendChunk(chunk: Chunk): Promise<void>;
+    setState(state: SCTP_STATE): void;
+    setConnectionState(state: SCTPConnectionState): void;
+    stop(): Promise<void>;
+    abort(): Promise<void>;
+    private removeAllListeners;
+}
+export declare class InboundStream {
+    reassembly: DataChunk[];
+    streamSequenceNumber: number;
+    constructor();
+    addChunk(chunk: DataChunk): void;
+    popMessages(): Generator<[number, number, Buffer]>;
+    pruneChunks(tsn: number): number;
+}
+export declare class RTCSctpCapabilities {
+    maxMessageSize: number;
+    constructor(maxMessageSize: number);
+}
+export {};

package/dist/types/lib/sctp/transport.d.ts

@@ -0,0 +1,15 @@
+import type { RemoteInfo, Socket } from 'node:dgram';
+export interface Transport {
+    onData?: (buf: Buffer) => void;
+    send: (buf: Buffer) => Promise<void>;
+    close: () => void;
+}
+export declare class UdpTransport implements Transport {
+    private upd;
+    private rinfo;
+    constructor(upd: Socket, rinfo: Partial<RemoteInfo>);
+    onData?: (buf: Buffer) => void;
+    send: (buf: Buffer) => Promise<void>;
+    close(): void;
+}
+export declare const createUdpTransport: (socket: Socket, rinfo?: Partial<RemoteInfo>) => UdpTransport;

package/dist/types/lib/turn/index.d.ts

@@ -0,0 +1,9 @@
+export * from './protocol.js';
+export * from './node/server.js';
+export * from './node/turnServer.js';
+export * from './stun/attributes.js';
+export * from './stun/const.js';
+export * from './stun/message.js';
+export * from './turn/auth.js';
+export * from './turn/frame.js';
+export * from './turn/protocol.js';

package/dist/types/lib/turn/node/server.d.ts

@@ -0,0 +1,21 @@
+import { type SocketType } from 'node:dgram';
+import { type Address } from '../../common/index.js';
+import { StunServerProtocol, type StunServerProtocolOptions } from '../protocol.js';
+export interface NodeStunServerOptions extends StunServerProtocolOptions {
+    host?: string;
+    port?: number;
+    type?: SocketType;
+}
+export declare class NodeStunServer {
+    readonly protocol: StunServerProtocol;
+    private socket?;
+    private readonly host;
+    private readonly port;
+    private readonly type;
+    constructor(options?: NodeStunServerOptions);
+    get address(): Address | undefined;
+    listen(): Promise<void>;
+    close(): Promise<void>;
+    private handleMessage;
+}
+export declare function createNodeStunServer(options?: NodeStunServerOptions): Promise<NodeStunServer>;

package/dist/types/lib/turn/node/turnServer.d.ts

@@ -0,0 +1,91 @@
+import { type TLSSocket, type TlsOptions } from 'node:tls';
+import { type Address } from '../../common/index.js';
+import { TurnServerProtocol, type TurnServerProtocolOptions } from '../turn/protocol.js';
+export interface NodeTurnServerTlsOptions extends TlsOptions {
+    external?: boolean;
+    port?: number;
+}
+export interface NodeTurnServerAttachTlsSocketOptions {
+    initialData?: Buffer;
+    localAddress?: Address;
+}
+export interface NodeTurnServerOptions extends TurnServerProtocolOptions {
+    host?: string;
+    port?: number;
+    relayAddress?: string;
+    relayBindAddress?: string;
+    /**the UDP ports of the relays (the firewall or the container publishes this range); any free port by default */
+    relayPortRange?: [number, number];
+    credentials?: Record<string, string>;
+    udp?: boolean;
+    tcp?: boolean;
+    tls?: NodeTurnServerTlsOptions;
+    /**the listeners bound with SO_REUSEPORT, to share their ports with the servers of other threads (Linux): the system
+     * keeps each client on one of them */
+    reusePort?: boolean;
+}
+export declare class NodeTurnServer {
+    readonly protocol: TurnServerProtocol;
+    private udpSocket?;
+    private tcpServer?;
+    private tlsServer?;
+    private readonly tcpConnections;
+    private readonly tlsConnections;
+    private readonly relaySockets;
+    private readonly relayBoundByPort;
+    private readonly relayPorts;
+    private interfaceAddresses?;
+    private timer?;
+    private closed;
+    private readonly host;
+    private readonly port;
+    private readonly udpEnabled;
+    private readonly tcpEnabled;
+    private readonly tlsEnabled;
+    private readonly tlsExternal;
+    private readonly tlsOptions?;
+    private readonly tlsPort;
+    private readonly relayAddress;
+    private readonly relayBindAddress;
+    private readonly relayPortRange?;
+    private boundPort?;
+    private boundTlsPort?;
+    private readonly reusePort;
+    constructor(options?: NodeTurnServerOptions);
+    get address(): Address | undefined;
+    get tlsAddress(): Address | undefined;
+    listen(): Promise<void>;
+    private listenTransports;
+    attachTlsSocket(socket: TLSSocket, options?: NodeTurnServerAttachTlsSocketOptions): void;
+    close(): Promise<void>;
+    private closeListeners;
+    private listenUdp;
+    private listenTcp;
+    private listenTls;
+    private executeActions;
+    private sendClient;
+    private sendRelay;
+    private bindRelaySocket;
+    private bindRelay;
+    private closeRelay;
+    private closeClient;
+    private updateTimer;
+    /**
+     * Run the timer of the protocol at a time
+     * @param nextTimeoutAt
+     */
+    private setTimer;
+    private normalizeRelayRemoteAddress;
+    private isRelaySocketAddress;
+    private isLocalInterfaceAddress;
+    /**
+     * A relay closed: its port is not one of a relay any more
+     * @param relayId
+     */
+    private forgetRelayPort;
+    private socketType;
+    private handleStreamConnection;
+    private getStreamClient;
+    private resolveStreamLocalAddress;
+}
+export declare function createNodeTurnServer(options?: NodeTurnServerOptions): Promise<NodeTurnServer>;

package/dist/types/lib/turn/protocol.d.ts

@@ -0,0 +1,47 @@
+import type { Address } from '../common/index.js';
+import type { AttributePair } from './stun/attributes.js';
+import { Message } from './stun/message.js';
+export type StunTransport = 'udp' | 'tcp' | 'tls' | 'dtls';
+export interface StunServerDatagram {
+    data: Buffer;
+    remoteAddress: Address;
+    localAddress?: Address;
+    transport: StunTransport;
+}
+export type StunServerAction = {
+    type: 'send';
+    data: Buffer;
+    remoteAddress: Address;
+} | {
+    type: 'ignore';
+    reason: 'non-stun' | 'malformed' | 'binding-indication' | 'non-request' | 'unsupported-method';
+};
+export interface StunRequestContext extends StunServerDatagram {
+    message: Message;
+}
+export type StunRequestAuthResult = {
+    ok: true;
+    attributes?: AttributePair[];
+} | {
+    ok: false;
+    errorCode: number;
+    reason: string;
+    attributes?: AttributePair[];
+};
+export interface StunServerProtocolOptions {
+    software?: string;
+    fingerprint?: 'never' | 'if-present' | 'always';
+    authenticateRequest?: (context: StunRequestContext) => StunRequestAuthResult;
+}
+export declare class StunServerProtocol {
+    private readonly software?;
+    private readonly fingerprint;
+    private readonly authenticateRequest?;
+    constructor(options?: StunServerProtocolOptions);
+    handleDatagram(input: StunServerDatagram): StunServerAction[];
+    private sendAction;
+    private successResponse;
+    private errorResponse;
+    private addDefaultAttributes;
+    private shouldAddFingerprint;
+}

package/dist/types/lib/turn/stun/attributes.d.ts

@@ -0,0 +1,37 @@
+import type { Address } from '../../common/index.js';
+import { type AttributeKeys } from './const.js';
+export declare function unpackErrorCode(data: Buffer): [number, string];
+export declare function unpackXorAddress(data: Buffer, transactionId: Buffer): Address;
+export declare function packErrorCode(value: [number, string]): Buffer<ArrayBuffer>;
+export declare function packUnknownAttributes(value: number[]): Buffer<ArrayBuffer>;
+export declare function unpackUnknownAttributes(data: Buffer): number[];
+export declare function packXorAddress(value: Address, transactionId: Buffer): Buffer<ArrayBuffer>;
+export type ATTRIBUTE = [
+    number,
+    AttributeKey,
+    (...args: any[]) => Buffer,
+    (...args: any[]) => any
+];
+export type RawAttribute = {
+    type: number;
+    length?: number;
+    value: Buffer;
+};
+export declare class AttributeRepository {
+    protected attributes: AttributePair[];
+    constructor(attributes?: AttributePair[]);
+    getAttributes(): AttributePair[];
+    setAttribute(key: AttributeKey, value: any): this;
+    getAttributeValue(key: AttributeKey): any;
+    get attributesKeys(): AttributeKey[];
+    removeAttribute(key: AttributeKey): this;
+    clear(): void;
+}
+export type AttributeKey = (typeof AttributeKeys)[number];
+export type AttributePair = [AttributeKey, any];
+export declare const ATTRIBUTES_BY_TYPE: {
+    [key: string]: ATTRIBUTE;
+};
+export declare const ATTRIBUTES_BY_NAME: {
+    [key: string]: ATTRIBUTE;
+};

package/dist/types/lib/turn/stun/const.d.ts

@@ -0,0 +1,28 @@
+export declare const COOKIE = 554869826;
+export declare const FINGERPRINT_LENGTH = 8;
+export declare const FINGERPRINT_XOR = 1398035790;
+export declare const HEADER_LENGTH = 20;
+export declare const INTEGRITY_LENGTH = 24;
+export declare const IPV4_PROTOCOL = 1;
+export declare const IPV6_PROTOCOL = 2;
+export declare const RETRY_MAX = 6;
+export declare const RETRY_RTO = 50;
+export declare const AttributeKeys: readonly ["FINGERPRINT", "MESSAGE-INTEGRITY", "MESSAGE-INTEGRITY-SHA256", "CHANGE-REQUEST", "PRIORITY", "USERNAME", "USERHASH", "ICE-CONTROLLING", "SOURCE-ADDRESS", "USE-CANDIDATE", "ICE-CONTROLLED", "ERROR-CODE", "UNKNOWN-ATTRIBUTES", "XOR-MAPPED-ADDRESS", "CHANGED-ADDRESS", "LIFETIME", "REQUESTED-TRANSPORT", "NONCE", "REALM", "REQUESTED-ADDRESS-FAMILY", "EVEN-PORT", "PASSWORD-ALGORITHM", "PASSWORD-ALGORITHMS", "XOR-RELAYED-ADDRESS", "RESERVATION-TOKEN", "CHANNEL-NUMBER", "XOR-PEER-ADDRESS", "DATA", "SOFTWARE", "MAPPED-ADDRESS", "ALTERNATE-DOMAIN", "ALTERNATE-SERVER", "RESPONSE-ORIGIN", "OTHER-ADDRESS"];
+export declare enum classes {
+    REQUEST = 0,
+    INDICATION = 16,
+    RESPONSE = 256,
+    ERROR = 272
+}
+export declare enum methods {
+    BINDING = 1,
+    SHARED_SECRET = 2,
+    ALLOCATE = 3,
+    REFRESH = 4,
+    SEND = 6,
+    DATA = 7,
+    CREATE_PERMISSION = 8,
+    CHANNEL_BIND = 9
+}
+export declare function isComprehensionRequiredAttribute(type: number): boolean;
+export declare function isStunMessage(data: Buffer): boolean;

package/dist/types/lib/turn/stun/ip.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Convert an IPv4 / IPv6 text address to the STUN wire binary form.
+ * IPv4 → 4 bytes, IPv6 → 16 bytes (supports :: compression and IPv4-mapped).
+ */
+export declare function ipAddressToBuffer(address: string): Buffer;
+/**
+ * Convert STUN address bytes (4 or 16) back to a text IP address.
+ * IPv6 uses the same zero-run compression style as the previous `ip` helper.
+ */
+export declare function bufferToIpAddress(buf: Buffer): string;
+export declare function isIpV4Address(address: string): boolean;
+export declare function isIpV6Address(address: string): boolean;

package/dist/types/lib/turn/stun/message.d.ts

@@ -0,0 +1,37 @@
+import { type AttributePair, AttributeRepository, type RawAttribute } from './attributes.js';
+import { type classes, type methods } from './const.js';
+export declare function parseMessage(data: Buffer, integrityKey?: Buffer): Message | undefined;
+export declare class Message extends AttributeRepository {
+    messageMethod: methods;
+    messageClass: classes;
+    transactionId: Buffer;
+    rawAttributes: RawAttribute[];
+    constructor(messageMethod: methods, messageClass: classes, transactionId?: Buffer, attributes?: AttributePair[], rawAttributes?: RawAttribute[]);
+    toJSON(): {
+        messageMethod: methods;
+        messageClass: classes;
+        attributes: AttributePair[];
+        rawAttributes: {
+            type: number;
+            length: number;
+        }[];
+    };
+    get json(): {
+        messageMethod: methods;
+        messageClass: classes;
+        attributes: AttributePair[];
+        rawAttributes: {
+            type: number;
+            length: number;
+        }[];
+    };
+    get transactionIdHex(): string;
+    appendRawAttribute(type: number, value: Buffer): this;
+    get unknownAttributeTypes(): number[];
+    get bytes(): Buffer<ArrayBuffer>;
+    addMessageIntegrity(key: Buffer): this;
+    messageIntegrity(key: Buffer): Buffer<ArrayBuffer>;
+    addFingerprint(): this;
+    private get serializedAttributes();
+}
+export declare function paddingLength(length: number): number;

package/dist/types/lib/turn/turn/auth.d.ts

@@ -0,0 +1 @@
+export declare function makeTurnIntegrityKey(username: string, realm: string, password: string): NonSharedBuffer;

package/dist/types/lib/turn/turn/frame.d.ts

@@ -0,0 +1,13 @@
+export interface ChannelDataMessage {
+    channelNumber: number;
+    data: Buffer;
+}
+export declare function isChannelData(data: Buffer): boolean;
+export declare function encodeChannelData(channelNumber: number, data: Buffer): Buffer<ArrayBuffer>;
+export declare function decodeChannelData(data: Buffer): ChannelDataMessage | undefined;
+export declare function padTurnFrame(data: Buffer): Buffer<ArrayBufferLike>;
+export declare function splitTurnTcpFrames(buffer: Buffer): {
+    frames: Buffer<ArrayBufferLike>[];
+    malformed: boolean;
+    rest: Buffer<ArrayBufferLike>;
+};

package/dist/types/lib/turn/turn/protocol.d.ts

@@ -0,0 +1,147 @@
+import type { Address } from '../../common/index.js';
+import { type StunServerDatagram, StunServerProtocol, type StunServerProtocolOptions, type StunTransport } from '../protocol.js';
+export interface TurnServerClientPacket extends StunServerDatagram {
+    clientId: string;
+}
+export interface TurnServerTcpChunk {
+    clientId: string;
+    data: Buffer;
+    remoteAddress: Address;
+    localAddress?: Address;
+    transport: Extract<StunTransport, 'tcp' | 'tls'>;
+}
+export interface TurnServerRelayPacket {
+    relayId: string;
+    data: Buffer;
+    remoteAddress: Address;
+    localAddress: Address;
+}
+export interface TurnServerRelayBound {
+    allocationId: string;
+    relayId: string;
+    relayedAddress: Address;
+}
+export interface TurnServerRelayBindFailure {
+    allocationId: string;
+    errorCode?: number;
+    reason?: string;
+}
+export interface TurnServerClientClosed {
+    clientId: string;
+}
+export type TurnServerAction = {
+    type: 'send-client';
+    clientId: string;
+    transport: StunTransport;
+    remoteAddress: Address;
+    data: Buffer;
+} | {
+    type: 'send-relay';
+    relayId: string;
+    remoteAddress: Address;
+    data: Buffer;
+} | {
+    type: 'bind-relay';
+    allocationId: string;
+    relayId: string;
+} | {
+    type: 'close-relay';
+    relayId: string;
+} | {
+    type: 'close-client';
+    clientId: string;
+} | {
+    type: 'schedule-timeout';
+    at: number;
+} | {
+    type: 'ignore';
+    reason: 'binding-indication' | 'malformed' | 'non-request' | 'non-stun' | 'unknown-channel' | 'unknown-client' | 'unknown-relay' | 'unsupported-indication' | 'unsupported-method';
+};
+export interface TurnServerProtocolOptions extends Pick<StunServerProtocolOptions, 'fingerprint' | 'software'> {
+    realm?: string;
+    allocationLifetime?: number;
+    permissionLifetime?: number;
+    channelLifetime?: number;
+    nonceLifetime?: number;
+    maxAllocations?: number;
+    /**the allocations counted with the servers of other threads, in place of maxAllocations: reserve one before it
+     * is made (false when refused), release it once deleted */
+    allocationGate?: {
+        reserve(): boolean;
+        release(): void;
+    };
+    getPassword?: (username: string, realm: string) => string | undefined;
+    now?: () => number;
+}
+export declare class TurnServerProtocol {
+    readonly realm: string;
+    readonly bindingProtocol: StunServerProtocol;
+    private readonly fingerprint;
+    private readonly software?;
+    private readonly allocationLifetime;
+    private readonly permissionLifetime;
+    private readonly channelLifetime;
+    private readonly nonceLifetime;
+    private readonly maxAllocations;
+    private readonly allocationGate?;
+    private readonly getPassword;
+    private readonly nowProvider?;
+    private readonly allocations;
+    private readonly allocationIdByClientId;
+    private readonly allocationIdByRelayId;
+    private readonly nonces;
+    private readonly tcpBuffers;
+    constructor(options?: TurnServerProtocolOptions);
+    /**the allocations in use */
+    get allocationCount(): number;
+    get nextTimeoutAt(): number | undefined;
+    handleClientDatagram(input: TurnServerClientPacket): TurnServerAction[];
+    handleTcpChunk(input: TurnServerTcpChunk): TurnServerAction[];
+    handleRelayPacket(input: TurnServerRelayPacket): TurnServerAction[];
+    handleRelayBound(input: TurnServerRelayBound): TurnServerAction[];
+    handleRelayBindFailure(input: TurnServerRelayBindFailure): TurnServerAction[];
+    handleClientClosed(input: TurnServerClientClosed): TurnServerAction[];
+    handleTimer(now?: number): TurnServerAction[];
+    private handleClientPacket;
+    private handleBindingRequest;
+    private handleAllocateRequest;
+    private handleRefreshRequest;
+    private handleCreatePermissionRequest;
+    private handleChannelBindRequest;
+    private handleSendIndication;
+    private authenticateRequest;
+    private unauthorizedResponse;
+    private successResponse;
+    private errorResponse;
+    private addResponseAttributes;
+    private shouldAddFingerprint;
+    private issueNonce;
+    private sendClient;
+    private mapBindingAction;
+    private clientEndpoint;
+    /**
+     * Data of a client on a channel: relayed to the peer of the binding while the allocation and the binding last
+     * @param input
+     * @param now
+     */
+    private handleChannelData;
+    /**
+     * An allocation still alive: one expired is deleted now (the timer would delete it later)
+     * @param allocation
+     * @param now
+     * @param actions What deleting it takes.
+     */
+    private liveAllocation;
+    private getClientAllocation;
+    private getRelayAllocation;
+    private setPermission;
+    private getPermission;
+    private getChannelBinding;
+    private removeChannelBinding;
+    private deleteAllocation;
+    private cleanupExpired;
+    private computeNextTimeoutAt;
+    private finalizeActions;
+    private clampLifetime;
+    private now;
+}