/**
 * @file chunks.ts
 * @description SCTP common header and chunk encode/parse (RFC 4960 + RFC 8260
 * for I-DATA is NOT used; classic DATA only). Scoped to the WebRTC profile.
 * @module sctp/chunks
 */
export declare const CHUNK_TYPE: Readonly<{
    DATA: 0;
    INIT: 1;
    INIT_ACK: 2;
    SACK: 3;
    HEARTBEAT: 4;
    HEARTBEAT_ACK: 5;
    ABORT: 6;
    SHUTDOWN: 7;
    SHUTDOWN_ACK: 8;
    ERROR: 9;
    COOKIE_ECHO: 10;
    COOKIE_ACK: 11;
    SHUTDOWN_COMPLETE: 14;
    FORWARD_TSN: 192;
}>;
export declare const PARAM_TYPE: Readonly<{
    HEARTBEAT_INFO: 1;
    STATE_COOKIE: 7;
    UNRECOGNIZED_PARAM: 8;
    COOKIE_PRESERVATIVE: 9;
    SUPPORTED_ADDR_TYPES: 11;
    FORWARD_TSN_SUPPORTED: 49152;
    SUPPORTED_EXTENSIONS: 32776;
}>;
export declare const PPID: Readonly<{
    DCEP: 50;
    STRING: 51;
    BINARY: 53;
    STRING_EMPTY: 56;
    BINARY_EMPTY: 57;
    STRING_PARTIAL: 54;
    BINARY_PARTIAL: 52;
}>;
export interface CommonHeader {
    srcPort: number;
    dstPort: number;
    verificationTag: number;
    checksum: number;
}
export interface ParsedChunk {
    type: number;
    flags: number;
    length: number;
    body: Buffer;
}
export interface ParsedParam {
    type: number;
    length: number;
    value: Buffer;
}
export interface InitBodyParams {
    initiateTag: number;
    a_rwnd: number;
    outStreams: number;
    inStreams: number;
    initialTSN: number;
}
export interface ParsedInitBody {
    initiateTag: number;
    a_rwnd: number;
    outStreams: number;
    inStreams: number;
    initialTSN: number;
    params: ParsedParam[];
}
export interface DataBodyParams {
    tsn: number;
    streamId: number;
    streamSeq: number;
    ppid: number;
    userData: Buffer;
    unordered?: boolean;
    beginning?: boolean;
    ending?: boolean;
}
export interface EncodedDataBody {
    flags: number;
    body: Buffer;
}
export interface ParsedDataBody {
    unordered: boolean;
    beginning: boolean;
    ending: boolean;
    tsn: number;
    streamId: number;
    streamSeq: number;
    ppid: number;
    userData: Buffer;
}
export interface SackBodyParams {
    cumulativeTSNAck: number;
    a_rwnd: number;
    gapBlocks?: Array<[number, number]>;
    dupTSNs?: number[];
}
export interface ParsedSackBody {
    cumulativeTSNAck: number;
    a_rwnd: number;
    gapBlocks: Array<[number, number]>;
    dupTSNs: number[];
}
/** Round a length up to the next 4-byte boundary. */
export declare function pad4(n: number): number;
/**
 * Encode the 12-byte SCTP common header (checksum left as 0; filled by crc32c).
 * @param {number} srcPort
 * @param {number} dstPort
 * @param {number} verificationTag
 * @returns {Buffer}
 */
export declare function encodeCommonHeader(srcPort: number, dstPort: number, verificationTag: number): Buffer;
/**
 * Parse the common header.
 * @param {Buffer} packet
 * @returns {{srcPort:number,dstPort:number,verificationTag:number,checksum:number}}
 */
export declare function parseCommonHeader(packet: Buffer): CommonHeader;
/**
 * Wrap a chunk body with the 4-byte chunk header, padded to 4 bytes.
 * @param {number} type
 * @param {number} flags
 * @param {Buffer} body
 * @returns {Buffer}
 */
export declare function encodeChunk(type: number, flags: number, body: Buffer): Buffer;
/**
 * Parse all chunks out of an SCTP packet (after the 12-byte common header).
 * @param {Buffer} packet
 * @returns {Array<{type:number,flags:number,length:number,body:Buffer}>}
 */
export declare function parseChunks(packet: Buffer): ParsedChunk[];
/**
 * Encode a TLV parameter, padded to 4 bytes.
 * @param {number} type
 * @param {Buffer} value
 * @returns {Buffer}
 */
export declare function encodeParam(type: number, value: Buffer): Buffer;
/**
 * Parse TLV parameters from a buffer.
 * @param {Buffer} buf
 * @returns {Array<{type:number,length:number,value:Buffer}>}
 */
export declare function parseParams(buf: Buffer): ParsedParam[];
/**
 * Build an INIT or INIT_ACK fixed body (without parameters).
 * @param {Object} p
 * @param {number} p.initiateTag
 * @param {number} p.a_rwnd - advertised receiver window
 * @param {number} p.outStreams
 * @param {number} p.inStreams
 * @param {number} p.initialTSN
 * @returns {Buffer}
 */
export declare function encodeInitBody({ initiateTag, a_rwnd, outStreams, inStreams, initialTSN }: InitBodyParams): Buffer;
/**
 * Parse an INIT/INIT_ACK body.
 * @param {Buffer} body
 * @returns {{initiateTag:number,a_rwnd:number,outStreams:number,inStreams:number,initialTSN:number,params:Array}}
 */
export declare function parseInitBody(body: Buffer): ParsedInitBody;
/**
 * Encode a DATA chunk body (RFC 4960 §3.3.1).
 * @param {Object} p
 * @param {number} p.tsn
 * @param {number} p.streamId
 * @param {number} p.streamSeq
 * @param {number} p.ppid
 * @param {Buffer} p.userData
 * @returns {{flags:number, body:Buffer}}
 */
export declare function encodeDataBody({ tsn, streamId, streamSeq, ppid, userData, unordered, beginning, ending }: DataBodyParams): EncodedDataBody;
/**
 * Parse a DATA chunk body.
 * @param {number} flags
 * @param {Buffer} body
 */
export declare function parseDataBody(flags: number, body: Buffer): ParsedDataBody;
/**
 * Encode a SACK chunk body (cumulative ack only, no gap/dup for simplicity but
 * gap blocks supported via params).
 * @param {Object} p
 * @param {number} p.cumulativeTSNAck
 * @param {number} p.a_rwnd
 * @param {Array<[number,number]>} [p.gapBlocks] - [start,end] offsets from cumAck+1
 * @param {Array<number>} [p.dupTSNs]
 * @returns {Buffer}
 */
export declare function encodeSackBody({ cumulativeTSNAck, a_rwnd, gapBlocks, dupTSNs }: SackBodyParams): Buffer;
/**
 * Parse a SACK chunk body.
 */
export declare function parseSackBody(body: Buffer): ParsedSackBody;