@lakutata/webrtc 0.0.0-stage → 3.1.4

package/dist/types/lib/common/log.d.ts

@@ -0,0 +1,47 @@
+export declare class WeriftError extends Error {
+    message: string;
+    payload?: object;
+    path?: string;
+    constructor(props: Pick<WeriftError, 'message' | 'payload' | 'path'>);
+    toJSON(): {
+        message: string;
+        payload: any;
+        path: string | undefined;
+    };
+}
+/**
+ * Receives the debug messages of the WebRTC implementation: the namespace of the module (`webrtc/ice/ice`,
+ * `webrtc/sctp/sctp`…), then the arguments given to the logging function (a format string first, as with
+ * `util.format`). The messages of the worker threads of a media server or of a TURN server (`SFU` or `TURNServer` with
+ * `workers`) come already formatted, as one string starting with the number of the thread (`[thread 0] …`).
+ */
+export type DebugHandler = (namespace: string, args: unknown[]) => void;
+/**
+ * Told when a handler is set or removed (the worker threads of the media server and of the TURN server send their
+ * messages to the handler of the main thread while there is one)
+ */
+export declare const debugHandlerWatchers: Set<(set: boolean) => void>;
+/**
+ * Whether a handler is set
+ */
+export declare function hasDebugHandler(): boolean;
+/**
+ * Send the debug messages of the WebRTC implementation (ICE, DTLS, SCTP, TURN), including those of the worker threads of
+ * a media server or of a TURN server, to a handler, to find out why a connection fails; they are dropped by default.
+ * @param handler The handler, or undefined to drop them again.
+ * @example
+ * ```typescript
+ * import {format} from 'node:util'
+ * import {setDebugHandler} from '@lakutata/webrtc'
+ *
+ * //The messages of ICE only
+ * setDebugHandler((namespace: string, args: unknown[]): void => {
+ *     if (namespace.startsWith('webrtc/ice')) console.debug(namespace, format(...args))
+ * })
+ * ```
+ */
+export declare function setDebugHandler(handler: DebugHandler | undefined): void;
+/**
+ * The logging function of a module: it does nothing while no handler is set
+ */
+export declare function debug(namespace: string): (...args: unknown[]) => void;

package/dist/types/lib/common/network.d.ts

@@ -0,0 +1,10 @@
+import { type SocketType } from 'node:dgram';
+export type InterfaceAddresses = {
+    [K in SocketType]?: string;
+};
+export declare const interfaceAddress: (type: SocketType, interfaceAddresses: InterfaceAddresses | undefined) => string | undefined;
+export declare function randomPort(protocol?: SocketType, interfaceAddresses?: InterfaceAddresses): Promise<number>;
+export declare function randomPorts(num: number, protocol?: SocketType, interfaceAddresses?: InterfaceAddresses): Promise<number[]>;
+export declare function findPort(min: number, max: number, protocol?: SocketType, interfaceAddresses?: InterfaceAddresses): Promise<number>;
+export type Address = Readonly<[string, number]>;
+export declare function normalizeFamilyNodeV18(family: string | number): 4 | 6;

package/dist/types/lib/common/number.d.ts

@@ -0,0 +1,13 @@
+export declare function uint8Add(a: number, b: number): number;
+export declare function uint16Add(a: number, b: number): number;
+export declare function uint32Add(a: number, b: number): number;
+export declare function uint24(v: number): number;
+/**Return a > b */
+export declare function uint16Gt(a: number, b: number): boolean;
+/**Return a >= b */
+export declare function uint16Gte(a: number, b: number): boolean;
+/**Return a > b */
+export declare function uint32Gt(a: number, b: number): boolean;
+/**Return a >= b */
+export declare function uint32Gte(a: number, b: number): boolean;
+export declare const int: (n: number) => number;

package/dist/types/lib/common/promise.d.ts

@@ -0,0 +1,21 @@
+export declare class PromiseQueue {
+    queue: {
+        promise: () => Promise<unknown>;
+        done: (...args: any[]) => void;
+        failed: (...args: any[]) => void;
+    }[];
+    running: boolean;
+    push: <T>(promise: () => Promise<T>) => Promise<T>;
+    private run;
+    cancel(): void;
+}
+/**
+ * Runs a function that may return a promise without waiting for it: a failure, thrown or rejected, goes to onError.
+ * For the callbacks of the applications and the tasks started in the background, whose failures must not become
+ * unhandled rejections
+ */
+export declare function runDetached(fn: () => unknown, onError: (error: unknown) => void): void;
+/**
+ * A function for an event or a timer: it runs fn without waiting for it, a failure going to onError
+ */
+export declare function detached<A extends unknown[]>(fn: (...args: A) => unknown, onError: (error: unknown) => void): (...args: A) => void;

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

@@ -0,0 +1,104 @@
+import { type RemoteInfo, type Socket, type SocketType } from 'node:dgram';
+import * as net from 'node:net';
+import * as tls from 'node:tls';
+import { type AddressInfo } from 'node:net';
+import { type Address, type InterfaceAddresses } from './network.js';
+export type TlsConnectionOptions = Omit<tls.ConnectionOptions, 'host' | 'port' | 'socket'>;
+export interface StreamTransportOptions {
+    /** Maximum time to wait for TCP/TLS connection establishment, in milliseconds. */
+    connectTimeoutMs?: number;
+}
+/**
+ * Grow the receive buffer of a bound UDP socket to 4 MiB, as far as the system allows (net.core.rmem_max on Linux); a
+ * buffer larger already is kept
+ * @param socket
+ */
+export declare function growReceiveBuffer(socket: Socket): void;
+export declare class UdpTransport implements Transport {
+    private socketType;
+    private options;
+    readonly type = "udp";
+    readonly socket: Socket;
+    rinfo?: Partial<Pick<RemoteInfo, 'address' | 'port'>>;
+    onData: (data: Buffer, addr: Address) => void;
+    closed: boolean;
+    private connected?;
+    private connectOnReceive?;
+    private connecting?;
+    private waiting?;
+    private constructor();
+    static init(type: SocketType, options?: {
+        portRange?: [number, number];
+        port?: number;
+        interfaceAddresses?: InterfaceAddresses;
+    }): Promise<UdpTransport>;
+    private init;
+    /**
+     * Send only to an address from now on (the other side of the pair ICE selected), once application data comes from
+     * it: the other side sends its data on the pair then (a reply to a check does not tell it). Connected, the socket
+     * sends without the lookup and the routing of the address of each packet, and drops what it is asked to send
+     * elsewhere; the system drops the packets of the other addresses
+     * @param addr An IP address
+     */
+    connectTo(addr: Address): void;
+    /**
+     * Send to any address again
+     */
+    disconnect(): void;
+    private connectNow;
+    send: (data: Buffer, addr?: Address) => Promise<void>;
+    get address(): net.AddressInfo;
+    /** IP family of the bound socket: 4 for udp4, 6 for udp6. */
+    get addressFamily(): IpAddressFamily;
+    get host(): string;
+    get port(): number;
+    close: () => Promise<void>;
+}
+export declare class TcpTransport implements Transport {
+    readonly type: "tcp";
+    private readonly stream;
+    private constructor();
+    static init(addr: Address, options?: StreamTransportOptions): Promise<TcpTransport>;
+    private init;
+    get address(): net.AddressInfo;
+    get remoteAddress(): readonly [string, number] | undefined;
+    get closed(): boolean;
+    get onData(): (data: Buffer, addr: Address) => void;
+    set onData(handler: (data: Buffer, addr: Address) => void);
+    send: (data: Buffer, addr?: Address) => Promise<void>;
+    close: () => Promise<void>;
+}
+export declare class TlsTransport implements Transport {
+    readonly type: "tls";
+    private readonly stream;
+    private constructor();
+    static init(addr: Address, options?: TlsConnectionOptions, streamOptions?: StreamTransportOptions): Promise<TlsTransport>;
+    private init;
+    get address(): net.AddressInfo;
+    get remoteAddress(): readonly [string, number] | undefined;
+    get closed(): boolean;
+    get onData(): (data: Buffer, addr: Address) => void;
+    set onData(handler: (data: Buffer, addr: Address) => void);
+    send: (data: Buffer, addr?: Address) => Promise<void>;
+    close: () => Promise<void>;
+}
+export type IpAddressFamily = 4 | 6;
+export interface Transport {
+    type: string;
+    address: AddressInfo;
+    closed: boolean;
+    onData: (data: Buffer, addr: Address) => void;
+    send: (data: Buffer, addr?: Address) => Promise<void>;
+    close: () => Promise<void>;
+    /**
+   * IP family of a datagram socket. A datagram transport can only reach
+   * addresses of this family. Built-in UDP transports always set it; a custom
+   * transport that leaves it unset gets no family preference.
+   */
+    addressFamily?: IpAddressFamily;
+    /**
+   * The peer a connected (stream) transport is talking to. Responses arrive
+   * from this address. Built-in TCP/TLS transports set it once connected.
+   */
+    remoteAddress?: Address;
+}

package/dist/types/lib/common/type.d.ts

@@ -0,0 +1,3 @@
+export type RequireAtLeastOne<T> = {
+    [K in keyof T]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<keyof T, K>>>;
+}[keyof T];

package/dist/types/lib/dtls/cipher/const.d.ts

@@ -0,0 +1,42 @@
+export declare const SignatureAlgorithm: {
+    readonly rsa_1: 1;
+    readonly ecdsa_3: 3;
+};
+export type SignatureAlgorithms = (typeof SignatureAlgorithm)[keyof typeof SignatureAlgorithm];
+export declare const HashAlgorithm: {
+    readonly sha256_4: 4;
+};
+export type HashAlgorithms = (typeof HashAlgorithm)[keyof typeof HashAlgorithm];
+export type SignatureHash = {
+    hash: HashAlgorithms;
+    signature: SignatureAlgorithms;
+};
+export declare const CipherSuite: {
+    readonly TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256_49195: 49195;
+    readonly TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256_49199: 49199;
+};
+export type CipherSuites = (typeof CipherSuite)[keyof typeof CipherSuite];
+export declare const CipherSuiteList: CipherSuites[];
+export declare const NamedCurveAlgorithm: {
+    readonly x25519_29: 29;
+    readonly secp256r1_23: 23;
+};
+export type NamedCurveAlgorithms = (typeof NamedCurveAlgorithm)[keyof typeof NamedCurveAlgorithm];
+export declare const NamedCurveAlgorithmList: NamedCurveAlgorithms[];
+export declare const CurveType: {
+    readonly named_curve_3: 3;
+};
+export type CurveTypes = (typeof CurveType)[keyof typeof CurveType];
+export declare const SignatureScheme: {
+    readonly rsa_pkcs1_sha256: 1025;
+    readonly ecdsa_secp256r1_sha256: 1027;
+};
+export type SignatureSchemes = (typeof SignatureScheme)[keyof typeof SignatureScheme];
+export declare const certificateTypes: number[];
+export declare const signatures: ({
+    hash: 4;
+    signature: 1;
+} | {
+    hash: 4;
+    signature: 3;
+})[];

package/dist/types/lib/dtls/cipher/create.d.ts

@@ -0,0 +1,21 @@
+import type { CipherGCMTypes } from 'node:crypto';
+import { type KeyExchange } from './key-exchange.js';
+import AEADCipher from './suites/aead.js';
+/**
+ * Convert cipher value to cipher instance.
+ * @param {number} cipher
+ */
+export declare function createCipher(cipher: number): AEADCipher;
+/**
+ * @param {number} id An internal id of cipher suite.
+ * @param {string} name A valid cipher suite name.
+ * @param {string} block A valid nodejs cipher name.
+ * @param {KeyExchange} kx Key exchange type.
+ * @param {Object} constants Cipher specific constants.
+ * @param {string} hash
+ * @returns {AEADCipher}
+ */
+export declare function createAEADCipher(id: number, name: string, block: CipherGCMTypes, kx: KeyExchange, constants: {
+    K_LEN: number;
+    N_MAX: number;
+}, hash?: string): AEADCipher;

package/dist/types/lib/dtls/cipher/ec.d.ts

@@ -0,0 +1,28 @@
+/**
+ * A key pair of P-256 for ECDHE: the private scalar (32 bytes) and the uncompressed public point (65 bytes)
+ */
+export declare const p256Keypair: () => {
+    privateKey: Buffer;
+    publicKey: Buffer;
+};
+/**
+ * The premaster secret of ECDHE on P-256: the x coordinate of the shared point
+ */
+export declare const p256PreMasterSecret: ({ publicKey, privateKey }: {
+    publicKey: Buffer;
+    privateKey: Buffer;
+}) => Buffer;
+/**
+ * A key pair of X25519: both keys as their raw 32 bytes
+ */
+export declare const x25519Keypair: () => {
+    privateKey: Buffer;
+    publicKey: Buffer;
+};
+/**
+ * The premaster secret of X25519 from the raw keys
+ */
+export declare const x25519PreMasterSecret: ({ publicKey, privateKey }: {
+    publicKey: Buffer;
+    privateKey: Buffer;
+}) => Buffer;

package/dist/types/lib/dtls/cipher/key-exchange.d.ts

@@ -0,0 +1,43 @@
+/**
+ * This class represent type of key exchange mechanism.
+ */
+export declare class KeyExchange {
+    id: number;
+    name?: string;
+    signType?: number;
+    keyType?: number;
+    /**
+   * @returns {string}
+   */
+    toString(): string | undefined;
+}
+/**
+ * Creates `RSA` key exchange.
+ * @returns {KeyExchange}
+ */
+export declare function createRSAKeyExchange(): KeyExchange;
+/**
+ * Creates `ECDHE_RSA` key exchange.
+ * @returns {KeyExchange}
+ */
+export declare function createECDHERSAKeyExchange(): KeyExchange;
+/**
+ * Creates `ECDHE_ECDSA` key exchange.
+ * @returns {KeyExchange}
+ */
+export declare function createECDHEECDSAKeyExchange(): KeyExchange;
+/**
+ * Creates `NULL` key exchange.
+ * @returns {KeyExchange}
+ */
+export declare function createNULLKeyExchange(): KeyExchange;
+/**
+ * Creates `PSK` key exchange.
+ * @returns {KeyExchange}
+ */
+export declare function createPSKKeyExchange(): KeyExchange;
+/**
+ * Creates `ECDHE_PSK` key exchange.
+ * @returns {KeyExchange}
+ */
+export declare function createECDHEPSKKeyExchange(): KeyExchange;

package/dist/types/lib/dtls/cipher/namedCurve.d.ts

@@ -0,0 +1,7 @@
+import { type NamedCurveAlgorithms } from './const.js';
+export interface NamedCurveKeyPair {
+    curve: NamedCurveAlgorithms;
+    publicKey: Buffer;
+    privateKey: Buffer;
+}
+export declare function generateKeyPair(namedCurve: NamedCurveAlgorithms): NamedCurveKeyPair;

package/dist/types/lib/dtls/cipher/prf.d.ts

@@ -0,0 +1,17 @@
+import { type NamedCurveAlgorithms } from './const.js';
+export declare function prfPreMasterSecret(publicKey: Buffer, privateKey: Buffer, curve: NamedCurveAlgorithms): Buffer<ArrayBufferLike>;
+export declare function hmac(algorithm: string, secret: Buffer, data: Buffer): NonSharedBuffer;
+export declare function prfPHash(secret: Buffer, seed: Buffer, requestedLegth: number, algorithm?: string): Buffer<ArrayBuffer>;
+export declare function prfMasterSecret(preMasterSecret: Buffer, clientRandom: Buffer, serverRandom: Buffer): Buffer<ArrayBuffer>;
+export declare function prfExtendedMasterSecret(preMasterSecret: Buffer, handshakes: Buffer): Buffer<ArrayBuffer>;
+export declare function exportKeyingMaterial(label: string, length: number, masterSecret: Buffer, localRandom: Buffer, remoteRandom: Buffer, isClient: boolean): Buffer<ArrayBuffer>;
+export declare function hash(algorithm: string, data: Buffer): NonSharedBuffer;
+export declare function prfVerifyData(masterSecret: Buffer, handshakes: Buffer, label: string, size?: number): Buffer<ArrayBuffer>;
+export declare function prfVerifyDataClient(masterSecret: Buffer, handshakes: Buffer): Buffer<ArrayBuffer>;
+export declare function prfVerifyDataServer(masterSecret: Buffer, handshakes: Buffer): Buffer<ArrayBuffer>;
+export declare function prfEncryptionKeys(masterSecret: Buffer, clientRandom: Buffer, serverRandom: Buffer, prfKeyLen: number, prfIvLen: number, prfNonceLen: number, algorithm?: string): {
+    clientWriteKey: Buffer<ArrayBufferLike>;
+    serverWriteKey: Buffer<ArrayBufferLike>;
+    clientNonce: Buffer<ArrayBuffer>;
+    serverNonce: Buffer<ArrayBuffer>;
+};

package/dist/types/lib/dtls/cipher/suites/abstract.d.ts

@@ -0,0 +1,40 @@
+import type { CipherGCMTypes } from 'node:crypto';
+import type { KeyExchange } from '../key-exchange.js';
+export type CipherHeader = {
+    type: number;
+    version: number;
+    epoch: number;
+    sequenceNumber: number;
+};
+export declare const SessionType: {
+    readonly CLIENT: 1;
+    readonly SERVER: 2;
+};
+export type SessionTypes = (typeof SessionType)[keyof typeof SessionType];
+export default abstract class AbstractCipher {
+    id: number;
+    name?: string;
+    hashAlgorithm?: string;
+    verifyDataLength: number;
+    blockAlgorithm?: CipherGCMTypes;
+    kx?: KeyExchange;
+    /**
+   * Init cipher.
+   * @abstract
+   */
+    init(..._args: any): void;
+    /**
+   * Encrypts data.
+   * @abstract
+   */
+    encrypt(..._args: any): Buffer;
+    /**
+   * Decrypts data.
+   * @abstract
+   */
+    decrypt(..._args: any): Buffer;
+    /**
+   * @returns {string}
+   */
+    toString(): string | undefined;
+}

package/dist/types/lib/dtls/cipher/suites/aead.d.ts

@@ -0,0 +1,28 @@
+import Cipher, { type CipherHeader, type SessionTypes } from './abstract.js';
+/**
+ * This class implements AEAD cipher family.
+ */
+export default class AEADCipher extends Cipher {
+    keyLength: number;
+    nonceLength: number;
+    ivLength: number;
+    authTagLength: number;
+    nonceImplicitLength: number;
+    nonceExplicitLength: number;
+    clientWriteKey?: Buffer;
+    serverWriteKey?: Buffer;
+    clientNonce?: Buffer;
+    serverNonce?: Buffer;
+    constructor();
+    get summary(): any;
+    init(masterSecret: Buffer, serverRandom: Buffer, clientRandom: Buffer): void;
+    /**
+   * Encrypt message.
+   */
+    encrypt(type: SessionTypes, data: Buffer, header: CipherHeader): Buffer<ArrayBuffer>;
+    encodeAdditionalBuffer(header: CipherHeader, dataLength: number): Buffer<ArrayBuffer>;
+    /**
+   * Decrypt message.
+   */
+    decrypt(type: SessionTypes, data: Buffer, header: CipherHeader): Buffer<ArrayBuffer>;
+}

package/dist/types/lib/dtls/cipher/suites/null.d.ts

@@ -0,0 +1,24 @@
+import Cipher from './abstract.js';
+/**
+ * Default passthrough cipher.
+ */
+export default class NullCipher extends Cipher {
+    /**
+   * @class NullCipher
+   */
+    constructor();
+    /**
+   * Encrypts data.
+   * @param {AbstractSession} session
+   * @param {Buffer} data Content to encryption.
+   * @returns {Buffer}
+   */
+    encrypt(session: any, data: Buffer): Buffer<ArrayBufferLike>;
+    /**
+   * Decrypts data.
+   * @param {AbstractSession} session
+   * @param {Buffer} data Content to encryption.
+   * @returns {Buffer}
+   */
+    decrypt(session: any, data: Buffer): Buffer<ArrayBufferLike>;
+}

package/dist/types/lib/dtls/cipher/utils.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Culculates HMAC using provided hash.
+ * @param {string} algorithm - Hash algorithm.
+ * @param {Buffer} secret - Hmac seed.
+ * @param {Buffer} data - Input data.
+ * @returns {Buffer}
+ */
+declare function hmac(algorithm: string, secret: Buffer, data: Buffer): NonSharedBuffer;
+/**
+ * A data expansion function for PRF.
+ * @param {number} bytes - The number of bytes required by PRF.
+ * @param {string} algorithm - Hmac hash algorithm.
+ * @param {Buffer} secret - Hmac secret.
+ * @param {Buffer} seed - Input data.
+ * @returns {Buffer}
+ */
+declare function pHash(bytes: number, algorithm: string, secret: Buffer, seed: Buffer): Buffer<ArrayBuffer>;
+export { hmac, pHash };

package/dist/types/lib/dtls/cipher/x509.d.ts

@@ -0,0 +1,33 @@
+import { type KeyObject } from 'node:crypto';
+/**
+ * The algorithm of the key of a self-signed certificate: ECDSA on P-256, or RSA (2048 bits)
+ */
+export type CertificateKeyType = 'ecdsa' | 'rsa';
+/**
+ * A certificate and its private key, both in PEM
+ */
+export interface CertificatePem {
+    certPem: string;
+    keyPem: string;
+}
+/**
+ * Creates a self-signed X.509 certificate for DTLS: the peers of WebRTC check it against the fingerprint in the SDP,
+ * not against a certificate authority, so it only has to be well formed
+ * @param keyType The algorithm of the key; ECDSA on P-256 by default, as the browsers use
+ * @param name The common name of the subject and the issuer
+ * @param days How long the certificate is valid, from a day before now
+ * @returns The certificate and its private key (PKCS #8), in PEM
+ */
+export declare function createDtlsCertificate(keyType?: CertificateKeyType, name?: string, days?: number): CertificatePem;
+/**
+ * Wraps DER in PEM, 64 characters of base64 per line
+ */
+export declare function toPem(derBytes: Buffer, label: string): string;
+/**
+ * The DER of the first certificate of a PEM text
+ */
+export declare function certificateDer(pem: string): Buffer;
+/**
+ * The private key of a PEM text (PKCS #8, PKCS #1 or SEC 1)
+ */
+export declare function privateKeyFromPem(pem: string): KeyObject;

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

@@ -0,0 +1,7 @@
+import { DtlsSocket, type Options } from './socket.js';
+export declare class DtlsClient extends DtlsSocket {
+    constructor(options: Options);
+    connect(): Promise<void>;
+    private flight5?;
+    private handleHandshakes;
+}

package/dist/types/lib/dtls/context/cipher.d.ts

@@ -0,0 +1,42 @@
+import { type KeyObject } from 'node:crypto';
+import { type CipherSuites, type NamedCurveAlgorithms, type SignatureHash } from '../cipher/const.js';
+import type { NamedCurveKeyPair } from '../cipher/namedCurve.js';
+import { type SessionTypes } from '../cipher/suites/abstract.js';
+import type AEADCipher from '../cipher/suites/aead.js';
+import type { DtlsRandom } from '../handshake/random.js';
+import type { DtlsPlaintext } from '../record/message/plaintext.js';
+export declare class CipherContext {
+    sessionType: SessionTypes;
+    certPem?: string | undefined;
+    keyPem?: string | undefined;
+    localRandom: DtlsRandom;
+    remoteRandom: DtlsRandom;
+    cipherSuite: CipherSuites;
+    remoteCertificate?: Buffer;
+    remoteKeyPair: Partial<NamedCurveKeyPair>;
+    localKeyPair: NamedCurveKeyPair;
+    masterSecret: Buffer;
+    cipher: AEADCipher;
+    namedCurve: NamedCurveAlgorithms;
+    signatureHashAlgorithm?: SignatureHash;
+    localCert: Buffer;
+    localPrivateKey: KeyObject;
+    constructor(sessionType: SessionTypes, certPem?: string | undefined, keyPem?: string | undefined, signatureHashAlgorithm?: SignatureHash);
+    /**
+   *
+   * @param signatureHash
+   * @param namedCurveAlgorithm necessary when use ecdsa
+   */
+    static createSelfSignedCertificateWithKey: (signatureHash: SignatureHash, _namedCurveAlgorithm?: NamedCurveAlgorithms) => Promise<{
+        certPem: string;
+        keyPem: string;
+        signatureHash: SignatureHash;
+    }>;
+    encryptPacket(pkt: DtlsPlaintext): DtlsPlaintext;
+    decryptPacket(pkt: DtlsPlaintext): Buffer<ArrayBuffer>;
+    verifyData(buf: Buffer): Buffer<ArrayBuffer>;
+    signatureData(data: Buffer, hash: string): NonSharedBuffer;
+    generateKeySignature(hashAlgorithm: string): NonSharedBuffer;
+    parseX509(certPem: string, keyPem: string, signatureHash: SignatureHash): void;
+    private valueKeySignature;
+}

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

@@ -0,0 +1,38 @@
+import type { HashAlgorithms, SignatureAlgorithms } from '../cipher/const.js';
+import type { SessionTypes } from '../cipher/suites/abstract.js';
+import type { FragmentedHandshake } from '../record/message/fragment.js';
+import type { Options } from '../socket.js';
+import type { Handshake } from '../typings/domain.js';
+export declare class DtlsContext {
+    options: Options;
+    sessionType: SessionTypes;
+    version: {
+        major: number;
+        minor: number;
+    };
+    lastFlight: Handshake[];
+    lastMessage: Buffer[];
+    recordSequenceNumber: number;
+    sequenceNumber: number;
+    epoch: number;
+    flight: number;
+    handshakeCache: {
+        [flight: number]: {
+            isLocal: boolean;
+            data: FragmentedHandshake[];
+            flight: number;
+        };
+    };
+    cookie?: Buffer;
+    requestedCertificateTypes: number[];
+    requestedSignatureAlgorithms: {
+        hash: HashAlgorithms;
+        signature: SignatureAlgorithms;
+    }[];
+    remoteExtendedMasterSecret: boolean;
+    constructor(options: Options, sessionType: SessionTypes);
+    get sessionId(): string;
+    get sortedHandshakeCache(): FragmentedHandshake[];
+    checkHandshakesExist: (handshakes: number[]) => boolean;
+    bufferHandshakeCache(handshakes: FragmentedHandshake[], isLocal: boolean, flight: number): void;
+}

package/dist/types/lib/dtls/context/srtp.d.ts

@@ -0,0 +1,5 @@
+import type { SrtpProfile } from '../imports/rtp.js';
+export declare class SrtpContext {
+    srtpProfile?: SrtpProfile;
+    static findMatchingSRTPProfile(remote: SrtpProfile[], local: SrtpProfile[]): 1 | 7 | undefined;
+}

package/dist/types/lib/dtls/context/transport.d.ts

@@ -0,0 +1,8 @@
+import type { Address, Transport } from '../imports/common.js';
+export declare class TransportContext {
+    socket: Transport;
+    readonly closing: AbortController;
+    constructor(socket: Transport);
+    readonly send: (buf: Buffer, addr?: Address) => Promise<void>;
+    close(): void;
+}

package/dist/types/lib/dtls/flight/client/flight1.d.ts

@@ -0,0 +1,10 @@
+import type { CipherContext } from '../../context/cipher.js';
+import type { DtlsContext } from '../../context/dtls.js';
+import type { TransportContext } from '../../context/transport.js';
+import type { Extension } from '../../typings/domain.js';
+import { Flight } from '../flight.js';
+export declare class Flight1 extends Flight {
+    private cipher;
+    constructor(udp: TransportContext, dtls: DtlsContext, cipher: CipherContext);
+    exec(extensions: Extension[]): Promise<void>;
+}

package/dist/types/lib/dtls/flight/client/flight3.d.ts

@@ -0,0 +1,8 @@
+import type { DtlsContext } from '../../context/dtls.js';
+import type { TransportContext } from '../../context/transport.js';
+import type { ServerHelloVerifyRequest } from '../../handshake/message/server/helloVerifyRequest.js';
+import { Flight } from '../flight.js';
+export declare class Flight3 extends Flight {
+    constructor(udp: TransportContext, dtls: DtlsContext);
+    exec(verifyReq: ServerHelloVerifyRequest): Promise<void>;
+}