@lakutata/webrtc 0.0.0-stage → 3.1.4

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

@@ -0,0 +1,18 @@
+import type { CipherContext } from '../../context/cipher.js';
+import type { DtlsContext } from '../../context/dtls.js';
+import { SrtpContext } from '../../context/srtp.js';
+import type { TransportContext } from '../../context/transport.js';
+import type { FragmentedHandshake } from '../../record/message/fragment.js';
+import { Flight } from '../flight.js';
+export declare class Flight5 extends Flight {
+    private cipher;
+    private srtp;
+    constructor(udp: TransportContext, dtls: DtlsContext, cipher: CipherContext, srtp: SrtpContext);
+    handleHandshake(handshake: FragmentedHandshake): void;
+    exec(): Promise<void>;
+    private sendCertificate;
+    private sendClientKeyExchange;
+    private sendCertificateVerify;
+    private sendChangeCipherSpec;
+    private sendFinished;
+}

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

@@ -0,0 +1,18 @@
+import type { DtlsContext } from '../context/dtls.js';
+import type { TransportContext } from '../context/transport.js';
+import type { Handshake } from '../typings/domain.js';
+type FlightType = 'PREPARING' | 'SENDING' | 'WAITING' | 'FINISHED';
+export declare abstract class Flight {
+    private transport;
+    dtls: DtlsContext;
+    private flight;
+    private nextFlight?;
+    state: FlightType;
+    static RetransmitCount: number;
+    constructor(transport: TransportContext, dtls: DtlsContext, flight: number, nextFlight?: number | undefined);
+    protected createPacket(handshakes: Handshake[]): import("../record/message/plaintext.js").DtlsPlaintext[];
+    protected transmit(buffers: Buffer[]): Promise<void>;
+    protected send: (buf: Buffer[]) => Promise<void[]>;
+    private setState;
+}
+export {};

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

@@ -0,0 +1,6 @@
+import type { CipherContext } from '../../context/cipher.js';
+import type { DtlsContext } from '../../context/dtls.js';
+import { SrtpContext } from '../../context/srtp.js';
+import type { TransportContext } from '../../context/transport.js';
+import type { ClientHello } from '../../handshake/message/client/hello.js';
+export declare const flight2: (udp: TransportContext, dtls: DtlsContext, cipher: CipherContext, srtp: SrtpContext) => (clientHello: ClientHello) => void;

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

@@ -0,0 +1,17 @@
+import type { CipherContext } from '../../context/cipher.js';
+import type { DtlsContext } from '../../context/dtls.js';
+import type { SrtpContext } from '../../context/srtp.js';
+import type { TransportContext } from '../../context/transport.js';
+import type { FragmentedHandshake } from '../../record/message/fragment.js';
+import { Flight } from '../flight.js';
+export declare class Flight4 extends Flight {
+    private cipher;
+    private srtp;
+    constructor(udp: TransportContext, dtls: DtlsContext, cipher: CipherContext, srtp: SrtpContext);
+    exec(clientHello: FragmentedHandshake, certificateRequest?: boolean): Promise<void>;
+    private sendServerHello;
+    private sendCertificate;
+    private sendServerKeyExchange;
+    private sendCertificateRequest;
+    private sendServerHelloDone;
+}

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

@@ -0,0 +1,13 @@
+import type { CipherContext } from '../../context/cipher.js';
+import type { DtlsContext } from '../../context/dtls.js';
+import type { TransportContext } from '../../context/transport.js';
+import type { FragmentedHandshake } from '../../record/message/fragment.js';
+import { Flight } from '../flight.js';
+export declare class Flight6 extends Flight {
+    private cipher;
+    constructor(udp: TransportContext, dtls: DtlsContext, cipher: CipherContext);
+    handleHandshake(handshake: FragmentedHandshake): void;
+    exec(): Promise<void>;
+    private sendChangeCipherSpec;
+    private sendFinished;
+}

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

@@ -0,0 +1,16 @@
+import { binaryData } from '../imports/common.js';
+export declare const ExtensionList: binaryData.DataType<{
+    type: number;
+    data: Buffer<ArrayBufferLike>;
+}[]>;
+export declare const ASN11Cert: binaryData.DataType<Buffer<ArrayBufferLike>>;
+export declare const ClientCertificateType: binaryData.NumberType;
+export declare const DistinguishedName: binaryData.DataType<string>;
+export declare const SignatureHashAlgorithm: {
+    hash: binaryData.NumberType;
+    signature: binaryData.NumberType;
+};
+export declare const ProtocolVersion: {
+    major: binaryData.NumberType;
+    minor: binaryData.NumberType;
+};

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

@@ -0,0 +1,13 @@
+export declare enum HandshakeType {
+    hello_request_0 = 0,
+    client_hello_1 = 1,
+    server_hello_2 = 2,
+    hello_verify_request_3 = 3,
+    certificate_11 = 11,
+    server_key_exchange_12 = 12,
+    certificate_request_13 = 13,
+    server_hello_done_14 = 14,
+    certificate_verify_15 = 15,
+    client_key_exchange_16 = 16,
+    finished_20 = 20
+}

package/dist/types/lib/dtls/handshake/extensions/ellipticCurves.d.ts

@@ -0,0 +1,17 @@
+import { binaryData } from '../../imports/common.js';
+import type { Extension } from '../../typings/domain.js';
+export declare class EllipticCurves {
+    static type: number;
+    static readonly spec: {
+        type: binaryData.NumberType;
+        data: binaryData.DataType<number[]>;
+    };
+    type: number;
+    data: number[];
+    constructor(props?: Partial<EllipticCurves>);
+    static createEmpty(): EllipticCurves;
+    static fromData(buf: Buffer): EllipticCurves;
+    static deSerialize(buf: Buffer): EllipticCurves;
+    serialize(): Buffer<ArrayBufferLike>;
+    get extension(): Extension;
+}

package/dist/types/lib/dtls/handshake/extensions/extendedMasterSecret.d.ts

@@ -0,0 +1,3 @@
+export declare class ExtendedMasterSecret {
+    static type: number;
+}

package/dist/types/lib/dtls/handshake/extensions/renegotiationIndication.d.ts

@@ -0,0 +1,18 @@
+import { binaryData } from '../../imports/common.js';
+export declare class RenegotiationIndication {
+    static type: number;
+    static readonly spec: {
+        type: binaryData.NumberType;
+        data: binaryData.NumberType;
+    };
+    type: number;
+    data: number;
+    constructor(props?: Partial<RenegotiationIndication>);
+    static createEmpty(): RenegotiationIndication;
+    static deSerialize(buf: Buffer): RenegotiationIndication;
+    serialize(): Buffer<ArrayBufferLike>;
+    get extension(): {
+        type: number;
+        data: Buffer<ArrayBuffer>;
+    };
+}

package/dist/types/lib/dtls/handshake/extensions/signature.d.ts

@@ -0,0 +1,26 @@
+import { binaryData } from '../../imports/common.js';
+import type { HashAlgorithms, SignatureAlgorithms } from '../../cipher/const.js';
+export declare class Signature {
+    static type: number;
+    static readonly spec: {
+        type: binaryData.NumberType;
+        data: binaryData.DataType<{
+            hash: number;
+            signature: number;
+        }[]>;
+    };
+    type: number;
+    data: {
+        hash: HashAlgorithms;
+        signature: SignatureAlgorithms;
+    }[];
+    constructor(props?: Partial<Signature>);
+    static createEmpty(): Signature;
+    static deSerialize(buf: Buffer): Signature;
+    serialize(): Buffer<ArrayBufferLike>;
+    static fromData(buf: Buffer): Signature;
+    get extension(): {
+        type: number;
+        data: Buffer<ArrayBuffer>;
+    };
+}

package/dist/types/lib/dtls/handshake/extensions/useSrtp.d.ts

@@ -0,0 +1,19 @@
+import { binaryData } from '../../imports/common.js';
+import type { Extension } from '../../typings/domain.js';
+export declare class UseSRTP {
+    static type: number;
+    static readonly spec: {
+        type: binaryData.NumberType;
+        data: binaryData.DataType<Buffer<ArrayBufferLike>>;
+    };
+    type: number;
+    data: Buffer;
+    profiles: number[];
+    mki: Buffer;
+    constructor(props?: Partial<UseSRTP>);
+    static create(profiles: number[], mki: Buffer): UseSRTP;
+    static deSerialize(buf: Buffer): UseSRTP;
+    serialize(): Buffer<ArrayBufferLike>;
+    static fromData(buf: Buffer): UseSRTP;
+    get extension(): Extension;
+}

package/dist/types/lib/dtls/handshake/message/alert.d.ts

@@ -0,0 +1,12 @@
+import { binaryData } from '../../imports/common.js';
+export declare class Alert {
+    level: number;
+    description: number;
+    static readonly spec: {
+        level: binaryData.NumberType;
+        description: binaryData.NumberType;
+    };
+    constructor(level: number, description: number);
+    static deSerialize(buf: Buffer): Alert;
+    serialize(): Buffer<ArrayBufferLike>;
+}

package/dist/types/lib/dtls/handshake/message/certificate.d.ts

@@ -0,0 +1,17 @@
+import { binaryData } from '../../imports/common.js';
+import { FragmentedHandshake } from '../../record/message/fragment.js';
+import type { Handshake } from '../../typings/domain.js';
+import { HandshakeType } from '../const.js';
+export declare class Certificate implements Handshake {
+    certificateList: Buffer[];
+    msgType: HandshakeType;
+    messageSeq?: number;
+    static readonly spec: {
+        certificateList: binaryData.DataType<Buffer<ArrayBufferLike>[]>;
+    };
+    constructor(certificateList: Buffer[]);
+    static createEmpty(): Certificate;
+    static deSerialize(buf: Buffer): Certificate;
+    serialize(): Buffer<ArrayBufferLike>;
+    toFragment(): FragmentedHandshake;
+}

package/dist/types/lib/dtls/handshake/message/changeCipherSpec.d.ts

@@ -0,0 +1,11 @@
+import { binaryData } from '../../imports/common.js';
+export declare class ChangeCipherSpec {
+    type: number;
+    static readonly spec: {
+        type: binaryData.NumberType;
+    };
+    constructor(type?: number);
+    static createEmpty(): ChangeCipherSpec;
+    static deSerialize(buf: Buffer): ChangeCipherSpec;
+    serialize(): Buffer<ArrayBufferLike>;
+}

package/dist/types/lib/dtls/handshake/message/client/certificateVerify.d.ts

@@ -0,0 +1,20 @@
+import { binaryData } from '../../../imports/common.js';
+import type { SignatureSchemes } from '../../../cipher/const.js';
+import { FragmentedHandshake } from '../../../record/message/fragment.js';
+import type { Handshake } from '../../../typings/domain.js';
+import { HandshakeType } from '../../const.js';
+export declare class CertificateVerify implements Handshake {
+    algorithm: SignatureSchemes;
+    signature: Buffer;
+    msgType: HandshakeType;
+    messageSeq?: number;
+    static readonly spec: {
+        algorithm: binaryData.NumberType;
+        signature: binaryData.DataType<Buffer<ArrayBufferLike>>;
+    };
+    constructor(algorithm: SignatureSchemes, signature: Buffer);
+    static createEmpty(): CertificateVerify;
+    static deSerialize(buf: Buffer): CertificateVerify;
+    serialize(): Buffer<ArrayBufferLike>;
+    toFragment(): FragmentedHandshake;
+}

package/dist/types/lib/dtls/handshake/message/client/hello.d.ts

@@ -0,0 +1,50 @@
+import { binaryData } from '../../../imports/common.js';
+import { FragmentedHandshake } from '../../../record/message/fragment.js';
+import type { Extension } from '../../../typings/domain.js';
+import { HandshakeType } from '../../const.js';
+export declare class ClientHello {
+    clientVersion: {
+        major: number;
+        minor: number;
+    };
+    random: {
+        gmt_unix_time: number;
+        random_bytes: Buffer;
+    };
+    sessionId: Buffer;
+    cookie: Buffer;
+    cipherSuites: number[];
+    compressionMethods: number[];
+    extensions: Extension[];
+    msgType: HandshakeType;
+    messageSeq: number;
+    static readonly spec: {
+        clientVersion: {
+            major: binaryData.NumberType;
+            minor: binaryData.NumberType;
+        };
+        random: {
+            gmt_unix_time: binaryData.NumberType;
+            random_bytes: binaryData.DataType<Buffer<ArrayBufferLike>>;
+        };
+        sessionId: binaryData.DataType<Buffer<ArrayBufferLike>>;
+        cookie: binaryData.DataType<Buffer<ArrayBufferLike>>;
+        cipherSuites: binaryData.DataType<number[]>;
+        compressionMethods: binaryData.DataType<number[]>;
+        extensions: binaryData.DataType<{
+            type: number;
+            data: Buffer<ArrayBufferLike>;
+        }[]>;
+    };
+    constructor(clientVersion: {
+        major: number;
+        minor: number;
+    }, random: {
+        gmt_unix_time: number;
+        random_bytes: Buffer;
+    }, sessionId: Buffer, cookie: Buffer, cipherSuites: number[], compressionMethods: number[], extensions: Extension[]);
+    static createEmpty(): ClientHello;
+    static deSerialize(buf: Buffer): ClientHello;
+    serialize(): Buffer<ArrayBufferLike>;
+    toFragment(): FragmentedHandshake;
+}

package/dist/types/lib/dtls/handshake/message/client/keyExchange.d.ts

@@ -0,0 +1,17 @@
+import { binaryData } from '../../../imports/common.js';
+import { FragmentedHandshake } from '../../../record/message/fragment.js';
+import type { Handshake } from '../../../typings/domain.js';
+import { HandshakeType } from '../../const.js';
+export declare class ClientKeyExchange implements Handshake {
+    publicKey: Buffer;
+    msgType: HandshakeType;
+    messageSeq?: number;
+    static readonly spec: {
+        publicKey: binaryData.DataType<Buffer<ArrayBufferLike>>;
+    };
+    constructor(publicKey: Buffer);
+    static createEmpty(): ClientKeyExchange;
+    static deSerialize(buf: Buffer): ClientKeyExchange;
+    serialize(): Buffer<ArrayBufferLike>;
+    toFragment(): FragmentedHandshake;
+}

package/dist/types/lib/dtls/handshake/message/finished.d.ts

@@ -0,0 +1,13 @@
+import { FragmentedHandshake } from '../../record/message/fragment.js';
+import type { Handshake } from '../../typings/domain.js';
+import { HandshakeType } from '../const.js';
+export declare class Finished implements Handshake {
+    verifyData: Buffer;
+    msgType: HandshakeType;
+    messageSeq?: number;
+    constructor(verifyData: Buffer);
+    static createEmpty(): Finished;
+    static deSerialize(buf: Buffer): Finished;
+    serialize(): Buffer<ArrayBufferLike>;
+    toFragment(): FragmentedHandshake;
+}

package/dist/types/lib/dtls/handshake/message/server/certificateRequest.d.ts

@@ -0,0 +1,31 @@
+import { binaryData } from '../../../imports/common.js';
+import type { HashAlgorithms, SignatureAlgorithms } from '../../../cipher/const.js';
+import { FragmentedHandshake } from '../../../record/message/fragment.js';
+import type { Handshake } from '../../../typings/domain.js';
+import { HandshakeType } from '../../const.js';
+export declare class ServerCertificateRequest implements Handshake {
+    certificateTypes: number[];
+    signatures: {
+        hash: HashAlgorithms;
+        signature: SignatureAlgorithms;
+    }[];
+    authorities: number[];
+    msgType: HandshakeType;
+    messageSeq?: number;
+    static readonly spec: {
+        certificateTypes: binaryData.DataType<number[]>;
+        signatures: binaryData.DataType<{
+            hash: number;
+            signature: number;
+        }[]>;
+        authorities: binaryData.DataType<string[]>;
+    };
+    constructor(certificateTypes: number[], signatures: {
+        hash: HashAlgorithms;
+        signature: SignatureAlgorithms;
+    }[], authorities: number[]);
+    static createEmpty(): ServerCertificateRequest;
+    static deSerialize(buf: Buffer): ServerCertificateRequest;
+    serialize(): Buffer<ArrayBufferLike>;
+    toFragment(): FragmentedHandshake;
+}

package/dist/types/lib/dtls/handshake/message/server/hello.d.ts

@@ -0,0 +1,33 @@
+import { binaryData } from '../../../imports/common.js';
+import type { CipherSuites } from '../../../cipher/const.js';
+import { FragmentedHandshake } from '../../../record/message/fragment.js';
+import type { Extension, Handshake, Random, Version } from '../../../typings/domain.js';
+import { HandshakeType } from '../../const.js';
+export declare class ServerHello implements Handshake {
+    serverVersion: Version;
+    random: Random;
+    sessionId: Buffer;
+    cipherSuite: CipherSuites;
+    compressionMethod: number;
+    extensions: Extension[];
+    msgType: HandshakeType;
+    messageSeq?: number;
+    static readonly spec: {
+        serverVersion: {
+            major: binaryData.NumberType;
+            minor: binaryData.NumberType;
+        };
+        random: {
+            gmt_unix_time: binaryData.NumberType;
+            random_bytes: binaryData.DataType<Buffer<ArrayBufferLike>>;
+        };
+        sessionId: binaryData.DataType<Buffer<ArrayBufferLike>>;
+        cipherSuite: binaryData.NumberType;
+        compressionMethod: binaryData.NumberType;
+    };
+    constructor(serverVersion: Version, random: Random, sessionId: Buffer, cipherSuite: CipherSuites, compressionMethod: number, extensions: Extension[]);
+    static createEmpty(): ServerHello;
+    static deSerialize(buf: Buffer): ServerHello;
+    serialize(): Buffer<ArrayBufferLike>;
+    toFragment(): FragmentedHandshake;
+}

package/dist/types/lib/dtls/handshake/message/server/helloDone.d.ts

@@ -0,0 +1,12 @@
+import { FragmentedHandshake } from '../../../record/message/fragment.js';
+import type { Handshake } from '../../../typings/domain.js';
+import { HandshakeType } from '../../const.js';
+export declare class ServerHelloDone implements Handshake {
+    msgType: HandshakeType;
+    messageSeq?: number;
+    static readonly spec: {};
+    static createEmpty(): ServerHelloDone;
+    static deSerialize(buf: Buffer): ServerHelloDone;
+    serialize(): Buffer<ArrayBufferLike>;
+    toFragment(): FragmentedHandshake;
+}

package/dist/types/lib/dtls/handshake/message/server/helloVerifyRequest.d.ts

@@ -0,0 +1,32 @@
+import { binaryData } from '../../../imports/common.js';
+import { FragmentedHandshake } from '../../../record/message/fragment.js';
+import type { Handshake } from '../../../typings/domain.js';
+import { HandshakeType } from '../../const.js';
+export declare class ServerHelloVerifyRequest implements Handshake {
+    serverVersion: {
+        major: number;
+        minor: number;
+    };
+    cookie: Buffer;
+    msgType: HandshakeType;
+    messageSeq?: number;
+    static readonly spec: {
+        serverVersion: {
+            major: binaryData.NumberType;
+            minor: binaryData.NumberType;
+        };
+        cookie: binaryData.DataType<Buffer<ArrayBufferLike>>;
+    };
+    constructor(serverVersion: {
+        major: number;
+        minor: number;
+    }, cookie: Buffer);
+    static createEmpty(): ServerHelloVerifyRequest;
+    static deSerialize(buf: Buffer): ServerHelloVerifyRequest;
+    serialize(): Buffer<ArrayBufferLike>;
+    get version(): {
+        major: number;
+        minor: number;
+    };
+    toFragment(): FragmentedHandshake;
+}

package/dist/types/lib/dtls/handshake/message/server/keyExchange.d.ts

@@ -0,0 +1,32 @@
+import { binaryData } from '../../../imports/common.js';
+import type { CurveTypes, NamedCurveAlgorithms } from '../../../cipher/const.js';
+import { FragmentedHandshake } from '../../../record/message/fragment.js';
+import type { Handshake } from '../../../typings/domain.js';
+import { HandshakeType } from '../../const.js';
+export declare class ServerKeyExchange implements Handshake {
+    ellipticCurveType: CurveTypes;
+    namedCurve: NamedCurveAlgorithms;
+    publicKeyLength: number;
+    publicKey: Buffer;
+    hashAlgorithm: number;
+    signatureAlgorithm: number;
+    signatureLength: number;
+    signature: Buffer;
+    msgType: HandshakeType;
+    messageSeq?: number;
+    static readonly spec: {
+        ellipticCurveType: binaryData.NumberType;
+        namedCurve: binaryData.NumberType;
+        publicKeyLength: binaryData.NumberType;
+        publicKey: binaryData.DataType<Buffer<ArrayBufferLike>>;
+        hashAlgorithm: binaryData.NumberType;
+        signatureAlgorithm: binaryData.NumberType;
+        signatureLength: binaryData.NumberType;
+        signature: binaryData.DataType<Buffer<ArrayBufferLike>>;
+    };
+    constructor(ellipticCurveType: CurveTypes, namedCurve: NamedCurveAlgorithms, publicKeyLength: number, publicKey: Buffer, hashAlgorithm: number, signatureAlgorithm: number, signatureLength: number, signature: Buffer);
+    static createEmpty(): ServerKeyExchange;
+    static deSerialize(buf: Buffer): ServerKeyExchange;
+    serialize(): Buffer<ArrayBufferLike>;
+    toFragment(): FragmentedHandshake;
+}

package/dist/types/lib/dtls/handshake/random.d.ts

@@ -0,0 +1,13 @@
+import { binaryData } from '../imports/common.js';
+export declare class DtlsRandom {
+    gmt_unix_time: number;
+    random_bytes: NonSharedBuffer;
+    static readonly spec: {
+        gmt_unix_time: binaryData.NumberType;
+        random_bytes: binaryData.DataType<Buffer<ArrayBufferLike>>;
+    };
+    constructor(gmt_unix_time?: number, random_bytes?: NonSharedBuffer);
+    static deSerialize(buf: Buffer): DtlsRandom;
+    static from(spec: binaryData.Decoded<typeof DtlsRandom.spec>): DtlsRandom;
+    serialize(): Buffer<ArrayBufferLike>;
+}

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

@@ -0,0 +1,4 @@
+export declare function enumerate<T>(arr: T[]): [number, T][];
+export declare function divide(from: string, split: string): [string, string];
+export declare const dumpBuffer: (data: Buffer) => string;
+export declare const getObjectSummary: (obj: any) => any;

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

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

package/dist/types/lib/dtls/imports/rtp.d.ts

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

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

@@ -0,0 +1,7 @@
+export * from './context/cipher.js';
+export * from './context/srtp.js';
+export * from './cipher/const.js';
+export * from './cipher/x509.js';
+export { DtlsClient } from './client.js';
+export { DtlsServer } from './server.js';
+export { DtlsSocket } from './socket.js';

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

@@ -0,0 +1,27 @@
+/**
+ * Provides protection against replay attacks by remembering received packets in a sliding window
+ */
+export declare class AntiReplayWindow {
+    private window;
+    private ceiling;
+    constructor();
+    /**
+   * Initializes the anti replay window to its default state
+   */
+    reset(): void;
+    /**
+   * Checks if the packet with the given sequence number may be received or has to be discarded
+   * @param seq_num - The sequence number of the packet to be checked
+   */
+    mayReceive(seq_num: number): boolean;
+    /**
+   * Checks if the packet with the given sequence number is marked as received
+   * @param seq_num - The sequence number of the packet to be checked
+   */
+    hasReceived(seq_num: number): boolean;
+    /**
+   * Marks the packet with the given sequence number as received
+   * @param seq_num - The sequence number of the packet
+   */
+    markAsReceived(seq_num: number): void;
+}

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

@@ -0,0 +1,9 @@
+import type { DtlsContext } from '../context/dtls.js';
+import type { Handshake } from '../typings/domain.js';
+import { DtlsPlaintext } from './message/plaintext.js';
+export type Message = {
+    type: number;
+    fragment: Buffer;
+};
+export declare const createFragments: (dtls: DtlsContext) => (handshakes: Handshake[]) => import("./message/fragment.js").FragmentedHandshake[];
+export declare const createPlaintext: (dtls: DtlsContext) => (fragments: Message[], recordSequenceNumber: number) => DtlsPlaintext[];

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

@@ -0,0 +1,33 @@
+export declare enum ContentType {
+    changeCipherSpec = 20,
+    alert = 21,
+    handshake = 22,
+    applicationData = 23
+}
+export declare enum AlertDesc {
+    CloseNotify = 0,
+    UnexpectedMessage = 10,
+    BadRecordMac = 20,
+    DecryptionFailed = 21,
+    RecordOverflow = 22,
+    DecompressionFailure = 30,
+    HandshakeFailure = 40,
+    NoCertificate = 41,
+    BadCertificate = 42,
+    UnsupportedCertificate = 43,
+    CertificateRevoked = 44,
+    CertificateExpired = 45,
+    CertificateUnknown = 46,
+    IllegalParameter = 47,
+    UnknownCa = 48,
+    AccessDenied = 49,
+    DecodeError = 50,
+    DecryptError = 51,
+    ExportRestriction = 60,
+    ProtocolVersion = 70,
+    InsufficientSecurity = 71,
+    InternalError = 80,
+    UserCanceled = 90,
+    NoRenegotiation = 100,
+    UnsupportedExtension = 110
+}

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

@@ -0,0 +1,26 @@
+import { binaryData } from '../../imports/common.js';
+import type { HandshakeType } from '../../handshake/const.js';
+export declare class FragmentedHandshake {
+    msg_type: number;
+    length: number;
+    message_seq: number;
+    fragment_offset: number;
+    fragment_length: number;
+    fragment: Buffer;
+    static readonly spec: {
+        msg_type: binaryData.NumberType;
+        length: binaryData.NumberType;
+        message_seq: binaryData.NumberType;
+        fragment_offset: binaryData.NumberType;
+        fragment_length: binaryData.NumberType;
+        fragment: binaryData.DataType<Buffer<ArrayBufferLike>>;
+    };
+    constructor(msg_type: number, length: number, message_seq: number, fragment_offset: number, fragment_length: number, fragment: Buffer);
+    get summary(): any;
+    static createEmpty(): FragmentedHandshake;
+    static deSerialize(buf: Buffer): FragmentedHandshake;
+    serialize(): Buffer<ArrayBufferLike>;
+    chunk(maxFragmentLength?: number): FragmentedHandshake[];
+    static assemble(messages: FragmentedHandshake[]): FragmentedHandshake;
+    static findAllFragments(fragments: FragmentedHandshake[], type: HandshakeType): FragmentedHandshake[];
+}