moqtail 0.8.0 → 0.9.0

package/dist/{version_parameter-BpmuiMQj.d.cts → version_parameter-DXBOBueW.d.cts}

@@ -1,4 +1,703 @@
-import { e as FetchHeaderType, F as FrozenByteBuffer, B as BaseByteBuffer, S as SubgroupHeaderType, m as FullTrackName, c as Tuple, K as KeyValuePair, L as Location, R as ReasonPhrase } from './byte_buffer-BM4uNj4n.cjs';
+/**
+ * Copyright 2025 The MOQtail Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @public
+ * Represents a key-value pair for MOQT protocol parameters.
+ *
+ * - If `typeValue` is **even**, the value is a varint (`bigint`).
+ * - If `typeValue` is **odd**, the value is a binary blob (`Uint8Array`) with a maximum length of 65535 bytes.
+ *
+ * Use {@link KeyValuePair.tryNewVarInt} for varint pairs and {@link KeyValuePair.tryNewBytes} for blob pairs.
+ */
+declare class KeyValuePair {
+    /**
+     * The key/type identifier for this pair.
+     * - Even: value is a varint.
+     * - Odd: value is a blob.
+     */
+    readonly typeValue: bigint;
+    /**
+     * The value for this pair.
+     * - If `typeValue` is even: a varint (`bigint`).
+     * - If `typeValue` is odd: a binary blob (`Uint8Array`).
+     */
+    readonly value: bigint | Uint8Array;
+    /**
+     * Constructs a new KeyValuePair.
+     * @param typeValue - The key/type identifier.
+     * @param value - The value (varint or blob).
+     * @internal Use static factory methods instead.
+     */
+    private constructor();
+    /**
+     * Creates a new varint KeyValuePair.
+     * @param typeValue - Must be even.
+     * @param value - The varint value.
+     * @returns A KeyValuePair with varint value.
+     * @throws KeyValueFormattingError if typeValue is not even.
+     */
+    static tryNewVarInt(typeValue: bigint | number, value: bigint | number): KeyValuePair;
+    /**
+     * Creates a new blob KeyValuePair.
+     * @param typeValue - Must be odd.
+     * @param value - The binary blob value.
+     * @returns A KeyValuePair with blob value.
+     * @throws KeyValueFormattingError if typeValue is not odd.
+     * @throws LengthExceedsMaxError if value length exceeds 65535 bytes.
+     */
+    static tryNewBytes(typeValue: bigint | number, value: Uint8Array): KeyValuePair;
+    /**
+     * Serializes this key-value pair to a frozen byte buffer.
+     * @returns The serialized buffer.
+     */
+    serialize(): FrozenByteBuffer;
+    /**
+     * Deserializes a KeyValuePair from a buffer.
+     * @param buf - The buffer to read from.
+     * @returns The deserialized KeyValuePair.
+     * @throws LengthExceedsMaxError if blob length exceeds 65535 bytes.
+     * @throws NotEnoughBytesError if buffer does not contain enough bytes.
+     */
+    static deserialize(buf: BaseByteBuffer): KeyValuePair;
+    /**
+     * Checks if this pair is equal to another.
+     * @param other - The other KeyValuePair.
+     * @returns True if both type and value are equal.
+     */
+    equals(other: KeyValuePair): boolean;
+}
+/**
+ * Checks if the KeyValuePair is a varint pair (even typeValue).
+ * @param pair - The KeyValuePair to check.
+ * @returns True if value is a varint.
+ */
+declare function isVarInt(pair: KeyValuePair): pair is KeyValuePair & {
+    value: bigint;
+};
+/**
+ * Checks if the KeyValuePair is a blob pair (odd typeValue).
+ * @param pair - The KeyValuePair to check.
+ * @returns True if value is a Uint8Array.
+ */
+declare function isBytes(pair: KeyValuePair): pair is KeyValuePair & {
+    value: Uint8Array;
+};
+
+/**
+ * Copyright 2025 The MOQtail Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @public
+ * Represents a position in a MOQT track, consisting of a group and object index.
+ *
+ * Used for specifying start/end positions in subscription and fetch requests.
+ * - `group`: The group index (e.g. segment, GOP, or logical group).
+ * - `object`: The object index within the group (e.g. frame, chunk).
+ */
+declare class Location {
+    /**
+     * The group index for this location.
+     */
+    readonly group: bigint;
+    /**
+     * The object index within the group for this location.
+     */
+    readonly object: bigint;
+    /**
+     * Constructs a new Location.
+     * @param group - The group index (number or bigint).
+     * @param object - The object index (number or bigint).
+     */
+    constructor(group: bigint | number, object: bigint | number);
+    /**
+     * Serializes this Location to a FrozenByteBuffer.
+     * @returns The serialized buffer.
+     * @throws CastingError if group or object is negative.
+     * @throws VarIntOverflowError if group or object exceeds varint encoding limits.
+     */
+    serialize(): FrozenByteBuffer;
+    /**
+     * Deserializes a Location from a buffer.
+     * @param buf - The buffer to read from.
+     * @returns The deserialized Location.
+     * @throws NotEnoughBytesError if buffer does not contain enough bytes.
+     */
+    static deserialize(buf: BaseByteBuffer): Location;
+    /**
+     * Checks if this Location is equal to another.
+     * @param other - The other Location to compare.
+     * @returns True if both group and object are equal.
+     */
+    equals(other: Location): boolean;
+    /**
+     * Compares this Location to another for ordering.
+     * @param other - The other Location to compare.
+     * @returns -1 if this \< other, 1 if this \> other, 0 if equal.
+     */
+    compare(other: Location): number;
+}
+
+/**
+ * Copyright 2025 The MOQtail Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @public
+ * Represents a single field in a Tuple, storing a value as a UTF-8 encoded byte array.
+ *
+ * Used for path segments or protocol fields in MOQT.
+ */
+declare class TupleField {
+    readonly value: Uint8Array;
+    /**
+     * The raw value of the field as a byte array.
+     */
+    constructor(value: Uint8Array);
+    /**
+     * Creates a TupleField from a UTF-8 string.
+     * @param str - The string to encode.
+     * @returns A new TupleField containing the encoded value.
+     */
+    static fromUtf8(str: string): TupleField;
+    /**
+     * Decodes the field value to a UTF-8 string.
+     * @returns The decoded string.
+     */
+    toUtf8(): string;
+    /**
+     * Serializes this field to a length-prefixed byte array.
+     * @returns The serialized bytes.
+     */
+    serialize(): Uint8Array;
+    /**
+     * Deserializes a TupleField from a buffer.
+     * @param buf - The buffer to read from.
+     * @returns The deserialized TupleField.
+     * @throws CastingError if the length cannot be safely cast to number.
+     * @throws NotEnoughBytesError if buffer does not contain enough bytes.
+     */
+    static deserialize(buf: BaseByteBuffer): TupleField;
+}
+/**
+ * @public
+ * Represents a sequence of TupleFields, typically used for hierarchical paths or protocol tuples in MOQT.
+ */
+declare class Tuple {
+    readonly fields: TupleField[];
+    /**
+     * The ordered list of fields in this tuple.
+     */
+    constructor(fields?: TupleField[]);
+    /**
+     * Creates a Tuple from a path string, splitting on '/'.
+     * @param path - The path string (e.g. '/foo/bar').
+     * @returns A Tuple with each segment as a field.
+     */
+    static fromUtf8Path(path: string): Tuple;
+    /**
+     * Converts the tuple to a path string, joining fields with '/'.
+     * @returns The path string (e.g. '/foo/bar').
+     */
+    toUtf8Path(): string;
+    /**
+     * Adds a field to the tuple.
+     * @param field - The TupleField to add.
+     */
+    add(field: TupleField): void;
+    /**
+     * Gets the field at the specified index.
+     * @param index - The field index.
+     * @returns The TupleField at the index.
+     * @throws Error if no field exists at the index.
+     */
+    get(index: number): TupleField;
+    /**
+     * Sets the field at the specified index.
+     * @param index - The field index.
+     * @param field - The TupleField to set.
+     */
+    set(index: number, field: TupleField): void;
+    /**
+     * Clears all fields from the tuple.
+     */
+    clear(): void;
+    /**
+     * Serializes the tuple to a FrozenByteBuffer.
+     * @returns The serialized buffer.
+     */
+    serialize(): FrozenByteBuffer;
+    /**
+     * Deserializes a Tuple from a buffer.
+     * @param buf - The buffer to read from.
+     * @returns The deserialized Tuple.
+     * @throws CastingError if the count cannot be safely cast to number.
+     * @throws NotEnoughBytesError if buffer does not contain enough bytes.
+     */
+    static deserialize(buf: BaseByteBuffer): Tuple;
+    /**
+     * Checks if this tuple is equal to another.
+     * @param other - The other Tuple to compare.
+     * @returns True if all fields are equal.
+     */
+    equals(other: Tuple): boolean;
+}
+
+/**
+ * Copyright 2025 The MOQtail Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * The maximum allowed length (in bytes) for a ReasonPhrase.
+ * @public
+ */
+declare const MAX_REASON_PHRASE_LEN = 1024;
+/**
+ * Represents a protocol ReasonPhrase, a short UTF-8 string used for error or status reporting.
+ * Enforces a maximum byte length and validates encoding.
+ *
+ * @public
+ */
+declare class ReasonPhrase {
+    #private;
+    /**
+     * Constructs a ReasonPhrase, validating UTF-8 encoding and length.
+     *
+     * @param phrase - The string to use as the reason phrase.
+     * @throws {@link InvalidUTF8Error} if encoding fails.
+     * @throws {@link LengthExceedsMaxError} if the encoded phrase exceeds {@link MAX_REASON_PHRASE_LEN} bytes.
+     * @public
+     */
+    constructor(phrase: string);
+    /**
+     * Returns the phrase string.
+     * @public
+     */
+    get phrase(): string;
+    /**
+     * Serializes the ReasonPhrase into a {@link FrozenByteBuffer} containing:
+     * varint(length_of_phrase_bytes) || phrase_bytes
+     *
+     * @returns The serialized buffer.
+     * @public
+     */
+    serialize(): FrozenByteBuffer;
+    /**
+     * Deserializes a ReasonPhrase from the given buffer.
+     * Reads varint(length) || utf8‑bytes.
+     *
+     * @param buf - The buffer to read from.
+     * @returns The deserialized ReasonPhrase.
+     * @throws :{@link CastingError} if the length cannot be safely cast to a number.
+     * @throws :{@link LengthExceedsMaxError} if the length exceeds {@link MAX_REASON_PHRASE_LEN}.
+     * @throws :{@link NotEnoughBytesError} if the buffer does not contain enough bytes.
+     * @throws :{@link InvalidUTF8Error} if decoding fails.
+     * @public
+     */
+    static deserialize(buf: BaseByteBuffer): ReasonPhrase;
+}
+
+/**
+ * Copyright 2025 The MOQtail Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * @public
+ * Object datagram status types for MOQT objects (Draft-14).
+ * Status datagrams use types 0x20-0x21.
+ *
+ * Type bit layout:
+ * - Bit 0: Extensions Present (0 = no, 1 = yes)
+ *
+ * | Type | Extensions Present | Object ID Present |
+ * |------|-------------------|------------------|
+ * | 0x20 | No                | Yes              |
+ * | 0x21 | Yes               | Yes              |
+ */
+declare enum ObjectDatagramStatusType {
+    /** Status without extensions (0x20) */
+    WithoutExtensions = 32,
+    /** Status with extensions (0x21) */
+    WithExtensions = 33
+}
+/**
+ * @public
+ * Namespace for ObjectDatagramStatusType utilities.
+ */
+declare namespace ObjectDatagramStatusType {
+    /**
+     * Converts a number or bigint to ObjectDatagramStatusType.
+     * @param value - The value to convert.
+     * @returns The corresponding ObjectDatagramStatusType.
+     * @throws Error if the value is not valid.
+     */
+    function tryFrom(value: number | bigint): ObjectDatagramStatusType;
+    /**
+     * Returns true if the type has extensions.
+     * @param t - The ObjectDatagramStatusType.
+     */
+    function hasExtensions(t: ObjectDatagramStatusType): boolean;
+}
+/**
+ * @public
+ * Object datagram types for MOQT objects (Draft-14).
+ *
+ * Type bit layout for 0x00-0x07:
+ * - Bit 0: Extensions Present (0 = no, 1 = yes)
+ * - Bit 1: End of Group (0 = no, 1 = yes)
+ * - Bit 2: Object ID Present (0 = Object ID omitted & is 0, 1 = Object ID present)
+ *
+ * Note: Bit 2 is inverted - when set, Object ID is ABSENT (and assumed 0)
+ *
+ * | Type | End of Group | Extensions | Object ID Present | Content |
+ * |------|-------------|------------|------------------|--------|
+ * | 0x00 | No          | No         | Yes              | Payload |
+ * | 0x01 | No          | Yes        | Yes              | Payload |
+ * | 0x02 | Yes         | No         | Yes              | Payload |
+ * | 0x03 | Yes         | Yes        | Yes              | Payload |
+ * | 0x04 | No          | No         | No (ID=0)        | Payload |
+ * | 0x05 | No          | Yes        | No (ID=0)        | Payload |
+ * | 0x06 | Yes         | No         | No (ID=0)        | Payload |
+ * | 0x07 | Yes         | Yes        | No (ID=0)        | Payload |
+ */
+declare enum ObjectDatagramType {
+    /** No End of Group, No Extensions, Object ID Present (0x00) */
+    Type0x00 = 0,
+    /** No End of Group, With Extensions, Object ID Present (0x01) */
+    Type0x01 = 1,
+    /** End of Group, No Extensions, Object ID Present (0x02) */
+    Type0x02 = 2,
+    /** End of Group, With Extensions, Object ID Present (0x03) */
+    Type0x03 = 3,
+    /** No End of Group, No Extensions, Object ID = 0 (0x04) */
+    Type0x04 = 4,
+    /** No End of Group, With Extensions, Object ID = 0 (0x05) */
+    Type0x05 = 5,
+    /** End of Group, No Extensions, Object ID = 0 (0x06) */
+    Type0x06 = 6,
+    /** End of Group, With Extensions, Object ID = 0 (0x07) */
+    Type0x07 = 7
+}
+/**
+ * @public
+ * Namespace for ObjectDatagramType utilities.
+ */
+declare namespace ObjectDatagramType {
+    /**
+     * Converts a number or bigint to ObjectDatagramType.
+     * @param value - The value to convert.
+     * @returns The corresponding ObjectDatagramType.
+     * @throws Error if the value is not valid.
+     */
+    function tryFrom(value: number | bigint): ObjectDatagramType;
+    /**
+     * Returns true if the type has extensions (bit 0 set).
+     * @param t - The ObjectDatagramType.
+     */
+    function hasExtensions(t: ObjectDatagramType): boolean;
+    /**
+     * Returns true if the type indicates End of Group (bit 1 set).
+     * @param t - The ObjectDatagramType.
+     */
+    function isEndOfGroup(t: ObjectDatagramType): boolean;
+    /**
+     * Returns true if Object ID is present in the wire format.
+     * When bit 2 is set (0x04-0x07), Object ID is ABSENT and assumed to be 0.
+     * @param t - The ObjectDatagramType.
+     */
+    function hasObjectId(t: ObjectDatagramType): boolean;
+    /**
+     * Determines the appropriate type for given properties.
+     * @param hasExtensions - Whether extensions are present.
+     * @param endOfGroup - Whether this is the last object in the group.
+     * @param objectIdIsZero - Whether the objectId is 0.
+     */
+    function fromProperties(hasExtensions: boolean, endOfGroup: boolean, objectIdIsZero: boolean): ObjectDatagramType;
+}
+/**
+ * @public
+ * Fetch header types for MOQT fetch requests.
+ */
+declare enum FetchHeaderType {
+    Type0x05 = 5
+}
+/**
+ * Namespace for FetchHeaderType utilities.
+ */
+declare namespace FetchHeaderType {
+    /**
+     * Converts a number or bigint to FetchHeaderType.
+     * @param value - The value to convert.
+     * @returns The corresponding FetchHeaderType.
+     * @throws Error if the value is not valid.
+     */
+    function tryFrom(value: number | bigint): FetchHeaderType;
+}
+/**
+ * @public
+ * Subgroup header types for MOQT subgroups.
+ */
+declare enum SubgroupHeaderType {
+    Type0x10 = 16,
+    Type0x11 = 17,
+    Type0x12 = 18,
+    Type0x13 = 19,
+    Type0x14 = 20,
+    Type0x15 = 21,
+    Type0x18 = 24,
+    Type0x19 = 25,
+    Type0x1A = 26,
+    Type0x1B = 27,
+    Type0x1C = 28,
+    Type0x1D = 29
+}
+/**
+ * Namespace for SubgroupHeaderType utilities.
+ */
+declare namespace SubgroupHeaderType {
+    /**
+     * Returns true if the header type has an explicit subgroup ID.
+     * @param t - The SubgroupHeaderType.
+     */
+    function hasExplicitSubgroupId(t: SubgroupHeaderType): boolean;
+    /**
+     * Returns true if the header type implies a subgroup ID of zero.
+     * @param t - The SubgroupHeaderType.
+     */
+    function isSubgroupIdZero(t: SubgroupHeaderType): boolean;
+    /**
+     * Returns true if the header type has extensions.
+     * @param t - The SubgroupHeaderType.
+     */
+    function hasExtensions(t: SubgroupHeaderType): boolean;
+    /**
+     * Converts a number or bigint to SubgroupHeaderType.
+     * @param value - The value to convert.
+     * @returns The corresponding SubgroupHeaderType.
+     * @throws Error if the value is not valid.
+     */
+    function tryFrom(value: number | bigint): SubgroupHeaderType;
+}
+/**
+ * @public
+ * Publisher's preferred object delivery mechanism for a track.
+ * - `Subgroup`: Use ordered subgroups (reliable).
+ * - `Datagram`: Use unreliable datagrams when feasible.
+ *
+ * The preference is advisory: the relay/transport layer MAY override based on negotiated capabilities.
+ */
+declare enum ObjectForwardingPreference {
+    Subgroup = "Subgroup",
+    Datagram = "Datagram"
+}
+/**
+ * Namespace for ObjectForwardingPreference utilities.
+ */
+declare namespace ObjectForwardingPreference {
+    /**
+     * Converts a number, bigint, or string to ObjectForwardingPreference.
+     * @param value - The value to convert.
+     * @returns The corresponding ObjectForwardingPreference.
+     * @throws Error if the value is not valid.
+     */
+    function tryFrom(value: number | bigint | string): ObjectForwardingPreference;
+}
+/**
+ * @public
+ * Object status codes for MOQT objects.
+ * - `Normal`: Object exists and is available.
+ * - `DoesNotExist`: Object does not exist.
+ * - `EndOfGroup`: End of group marker.
+ * - `EndOfTrack`: End of track marker.
+ */
+declare enum ObjectStatus {
+    Normal = 0,
+    DoesNotExist = 1,
+    EndOfGroup = 3,
+    EndOfTrack = 4
+}
+/**
+ * Namespace for ObjectStatus utilities.
+ */
+declare namespace ObjectStatus {
+    /**
+     * Converts a number or bigint to ObjectStatus.
+     * @param value - The value to convert.
+     * @returns The corresponding ObjectStatus.
+     * @throws Error if the value is not valid.
+     */
+    function tryFrom(value: number | bigint): ObjectStatus;
+}
+
+/**
+ * Copyright 2025 The MOQtail Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Represents an OBJECT_DATAGRAM message (Draft-14).
+ *
+ * Type values 0x00-0x07 indicate payload datagrams with varying properties:
+ * - Bit 0: Extensions Present
+ * - Bit 1: End of Group
+ * - Bit 2: Object ID NOT present (when set, Object ID is 0)
+ */
+declare class DatagramObject {
+    readonly type: ObjectDatagramType;
+    readonly publisherPriority: number;
+    readonly extensionHeaders: KeyValuePair[] | null;
+    readonly payload: Uint8Array;
+    readonly endOfGroup: boolean;
+    readonly trackAlias: bigint;
+    readonly location: Location;
+    private constructor();
+    get groupId(): bigint;
+    get objectId(): bigint;
+    /**
+     * Create a new DatagramObject with all properties specified.
+     * The type is automatically determined based on extensions, endOfGroup, and objectId.
+     */
+    static new(trackAlias: bigint, groupId: bigint, objectId: bigint, publisherPriority: number, extensionHeaders: KeyValuePair[] | null, payload: Uint8Array, endOfGroup?: boolean): DatagramObject;
+    /**
+     * Create a DatagramObject with extensions.
+     * @deprecated Use DatagramObject.new() instead for Draft-14 compliance.
+     */
+    static newWithExtensions(trackAlias: bigint, groupId: bigint, objectId: bigint, publisherPriority: number, extensionHeaders: KeyValuePair[], payload: Uint8Array, endOfGroup?: boolean): DatagramObject;
+    /**
+     * Create a DatagramObject without extensions.
+     * @deprecated Use DatagramObject.new() instead for Draft-14 compliance.
+     */
+    static newWithoutExtensions(trackAlias: bigint, groupId: bigint, objectId: bigint, publisherPriority: number, payload: Uint8Array, endOfGroup?: boolean): DatagramObject;
+    serialize(): FrozenByteBuffer;
+    static deserialize(buf: BaseByteBuffer): DatagramObject;
+}
+
+/**
+ * Copyright 2025 The MOQtail Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Represents an OBJECT_DATAGRAM with status (Draft-14).
+ *
+ * Type values 0x20-0x21 indicate status datagrams:
+ * - 0x20: Without extensions, Object ID present
+ * - 0x21: With extensions, Object ID present
+ *
+ * Status datagrams always have Object ID present (unlike payload datagrams
+ * which can omit Object ID when it's 0).
+ */
+declare class DatagramStatus {
+    readonly type: ObjectDatagramStatusType;
+    readonly publisherPriority: number;
+    readonly extensionHeaders: KeyValuePair[] | null;
+    readonly objectStatus: ObjectStatus;
+    readonly trackAlias: bigint;
+    readonly location: Location;
+    private constructor();
+    get groupId(): bigint;
+    get objectId(): bigint;
+    /**
+     * Create a new DatagramStatus with all properties specified.
+     * The type is automatically determined based on whether extensions are present.
+     */
+    static new(trackAlias: bigint | number, location: Location, publisherPriority: number, extensionHeaders: KeyValuePair[] | null, objectStatus: ObjectStatus): DatagramStatus;
+    /**
+     * Create a DatagramStatus with extensions.
+     * @deprecated Use DatagramStatus.new() instead for Draft-14 compliance.
+     */
+    static withExtensions(trackAlias: bigint | number, location: Location, publisherPriority: number, extensionHeaders: KeyValuePair[], objectStatus: ObjectStatus): DatagramStatus;
+    /**
+     * Create a DatagramStatus without extensions.
+     * @deprecated Use DatagramStatus.new() instead for Draft-14 compliance.
+     */
+    static newWithoutExtensions(trackAlias: bigint | number, location: Location, publisherPriority: number, objectStatus: ObjectStatus): DatagramStatus;
+    serialize(): FrozenByteBuffer;
+    static deserialize(buf: BaseByteBuffer): DatagramStatus;
+}
 
 /**
  * Copyright 2025 The MOQtail Authors
@@ -24,6 +723,205 @@ declare class FetchHeader {
     static deserialize(buf: BaseByteBuffer): FetchHeader;
 }
 
+/**
+ * Copyright 2025 The MOQtail Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+declare class FetchObject {
+    readonly publisherPriority: number;
+    readonly extensionHeaders: KeyValuePair[] | null;
+    readonly objectStatus: ObjectStatus | null;
+    readonly payload: Uint8Array | null;
+    readonly location: Location;
+    readonly subgroupId: bigint;
+    private constructor();
+    get groupId(): bigint;
+    get objectId(): bigint;
+    static newWithStatus(groupId: bigint | number, subgroupId: bigint | number, objectId: bigint | number, publisherPriority: number, extensionHeaders: KeyValuePair[] | null, objectStatus: ObjectStatus): FetchObject;
+    static newWithPayload(groupId: bigint | number, subgroupId: bigint | number, objectId: bigint | number, publisherPriority: number, extensionHeaders: KeyValuePair[] | null, payload: Uint8Array): FetchObject;
+    serialize(_previousObjectId?: BigInt): FrozenByteBuffer;
+    static deserialize(buf: BaseByteBuffer): FetchObject;
+}
+
+/**
+ * Copyright 2025 The MOQtail Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+declare const MAX_NAMESPACE_TUPLE_COUNT = 32;
+declare const MAX_FULL_TRACK_NAME_LENGTH = 4096;
+/**
+ * Fully-qualified track identifier = hierarchical namespace (tuple) + leaf name bytes.
+ *
+ * Constraints enforced (throws {@link TrackNameError}):
+ * - Namespace tuple field count: 1 .. {@link MAX_NAMESPACE_TUPLE_COUNT} (must not be empty).
+ * - Total serialized length (namespace tuple + raw name bytes) less than or equals {@link MAX_FULL_TRACK_NAME_LENGTH} bytes.
+ *
+ * Namespace input may be:
+ * - `string` path with segments separated by `/` (converted via {@link Tuple.fromUtf8Path}). Empty segments are preserved
+ *   except leading/trailing slashes are treated as empty fields and will be rejected by the length check if result is 0.
+ * - Existing {@link Tuple} instance.
+ *
+ * Name input may be:
+ * - UTF-8 string (encoded)
+ * - Raw `Uint8Array` (used directly)
+ *
+ * Instances are created via {@link FullTrackName.tryNew} (validates) or {@link FullTrackName.deserialize}.
+ * Use {@link FullTrackName.serialize} for wire encoding and {@link FullTrackName.toString} for a human friendly
+ * diagnostic format: `namespace/segments:hexname` (name rendered as lowercase hex, no 0x prefix).
+ *
+ * The string form is intended for logs/debug only; do not parse it for protocol operations.
+ */
+declare class FullTrackName {
+    readonly namespace: Tuple;
+    readonly name: Uint8Array;
+    private constructor();
+    /**
+     * Human-readable representation: `\<namespace path joined by '/'\>:\<name as lowercase hex\>`.
+     * If the underlying {@link Tuple} exposes `toUtf8Path`, it's used; otherwise the raw fields are joined.
+     * This is lossy only in the sense that name bytes are hex encoded; round-tripping requires serialization.
+     */
+    toString(): string;
+    /**
+     * Construct a validated full track name.
+     *
+     * Validation steps:
+     * 1. Convert namespace string -\> {@link Tuple} (split on '/') if needed.
+     * 2. Reject if namespace tuple field count is 0 or \> {@link MAX_NAMESPACE_TUPLE_COUNT}.
+     * 3. Encode name string to UTF-8 if needed.
+     * 4. Reject if total serialized length (namespace tuple + name bytes) \> {@link MAX_FULL_TRACK_NAME_LENGTH}.
+     *
+     * @throws :{@link TrackNameError} on any constraint violation.
+     * @example
+     * ```ts
+     * const full = FullTrackName.tryNew('media/video', 'keyframe')
+     * console.log(full.toString()) // media/video:6b65796672616d65
+     * ```
+     */
+    static tryNew(namespace: string | Tuple, name: string | Uint8Array): FullTrackName;
+    /**
+     * Serialize to a frozen buffer: tuple (namespace) followed by length‑prefixed name bytes.
+     * Consumers needing raw bytes should call `.toUint8Array()` on the returned {@link FrozenByteBuffer}.
+     */
+    serialize(): FrozenByteBuffer;
+    /**
+     * Parse a serialized full track name. Performs the same validations as {@link FullTrackName.tryNew}.
+     * The provided buffer's read cursor advances accordingly.
+     * @throws :{@link TrackNameError} if constraints are violated.
+     */
+    static deserialize(buf: BaseByteBuffer): FullTrackName;
+}
+
+/**
+ * Copyright 2025 The MOQtail Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+declare class SubgroupObject {
+    readonly extensionHeaders: KeyValuePair[] | null;
+    readonly objectStatus: ObjectStatus | null;
+    readonly payload: Uint8Array | null;
+    readonly objectId: bigint;
+    private constructor();
+    static newWithStatus(objectId: bigint | number, extensionHeaders: KeyValuePair[] | null, objectStatus: ObjectStatus): SubgroupObject;
+    static newWithPayload(objectId: bigint | number, extensionHeaders: KeyValuePair[] | null, payload: Uint8Array): SubgroupObject;
+    serialize(previousObjectId: bigint | undefined): FrozenByteBuffer;
+    static deserialize(buf: BaseByteBuffer, hasExtensions: boolean, previousObjectId: bigint | undefined): SubgroupObject;
+}
+
+/**
+ * Copyright 2025 The MOQtail Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+declare class MoqtObject {
+    readonly fullTrackName: FullTrackName;
+    readonly publisherPriority: number;
+    readonly objectForwardingPreference: ObjectForwardingPreference;
+    readonly objectStatus: ObjectStatus;
+    readonly extensionHeaders: KeyValuePair[] | null;
+    readonly payload: Uint8Array | null;
+    readonly location: Location;
+    readonly subgroupId: bigint | null;
+    private constructor();
+    get groupId(): bigint;
+    get objectId(): bigint;
+    getSubgroupHeaderType(containsEnd: boolean): SubgroupHeaderType;
+    isDatagram(): boolean;
+    isSubgroup(): boolean;
+    isEndOfGroup(): boolean;
+    isEndOfTrack(): boolean;
+    doesNotExist(): boolean;
+    hasPayload(): boolean;
+    hasStatus(): boolean;
+    static newWithPayload(fullTrackName: FullTrackName, location: Location, publisherPriority: number, objectForwardingPreference: ObjectForwardingPreference, subgroupId: bigint | number | null, extensionHeaders: KeyValuePair[] | null, payload: Uint8Array): MoqtObject;
+    static newWithStatus(fullTrackName: FullTrackName, location: Location, publisherPriority: number, objectForwardingPreference: ObjectForwardingPreference, subgroupId: bigint | number | null, extensionHeaders: KeyValuePair[] | null, objectStatus: ObjectStatus): MoqtObject;
+    static fromDatagramObject(datagramObject: DatagramObject, fullTrackName: FullTrackName): MoqtObject;
+    /**
+     * Returns the endOfGroup flag from the source DatagramObject.
+     * This is separate from ObjectStatus.EndOfGroup - the flag indicates
+     * this is the last object in the group even with Normal status.
+     */
+    static isDatagramEndOfGroup(datagramObject: DatagramObject): boolean;
+    static fromDatagramStatus(datagramStatus: DatagramStatus, fullTrackName: FullTrackName): MoqtObject;
+    static fromFetchObject(fetchObject: FetchObject, fullTrackName: FullTrackName): MoqtObject;
+    static fromSubgroupObject(subgroupObject: SubgroupObject, groupId: bigint | number, publisherPriority: number, subgroupId: bigint | number, fullTrackName: FullTrackName): MoqtObject;
+    /**
+     * Convert to DatagramObject for wire transmission.
+     * @param trackAlias - The track alias to use
+     * @param endOfGroup - Draft-14: Whether this is the last object in the group
+     */
+    tryIntoDatagramObject(trackAlias: bigint | number, endOfGroup?: boolean): DatagramObject;
+    tryIntoDatagramStatus(trackAlias: bigint | number): DatagramStatus;
+    tryIntoFetchObject(): FetchObject;
+    tryIntoSubgroupObject(): SubgroupObject;
+}
+
 /**
  * Copyright 2025 The MOQtail Authors
  *
@@ -163,6 +1061,92 @@ declare namespace Header {
     function deserialize(buf: BaseByteBuffer): Header;
 }
 
+/**
+ * Copyright 2025 The MOQtail Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+declare abstract class BaseByteBuffer {
+    protected buf: Uint8Array;
+    protected view: DataView;
+    protected _offset: number;
+    protected _checkpoint: number;
+    constructor(buf: Uint8Array);
+    get offset(): number;
+    abstract get length(): number;
+    get remaining(): number;
+    /**
+     * Save current read position for potential rollback
+     */
+    checkpoint(): void;
+    /**
+     * Restore read position to last checkpoint
+     */
+    restore(): void;
+    toUint8Array(): Uint8Array;
+    getU8(): number;
+    getU16(): number;
+    getVI(): bigint;
+    getNumberVI(): number;
+    getBytes(len: number): Uint8Array;
+    getLengthPrefixedBytes(): Uint8Array;
+    getKeyValuePair(): KeyValuePair;
+    getReasonPhrase(): ReasonPhrase;
+    getLocation(): Location;
+    getTuple(): Tuple;
+    getFullTrackName(): FullTrackName;
+}
+declare class ByteBuffer extends BaseByteBuffer {
+    private _length;
+    constructor(initialSize?: number);
+    get length(): number;
+    /**
+     * Clear all data and reset all positions
+     */
+    clear(): void;
+    /**
+     * Drop all data before current offset and reset positions
+     * This is the key method for memory management - removes processed data
+     */
+    commit(): void;
+    private ensureCapacity;
+    putU8(v: number): void;
+    putU16(v: number): void;
+    /**
+     * Write a variable-length integer (QUIC-style varint)
+     * Encoding:
+     * - 2 MSB = 00: 1 byte (6 bits) for values 0-63
+     * - 2 MSB = 01: 2 bytes (14 bits) for values 0-16383
+     * - 2 MSB = 10: 4 bytes (30 bits) for values 0-1073741823
+     * - 2 MSB = 11: 8 bytes (62 bits) for values 0-4611686018427387903
+     */
+    putVI(v: bigint | number): void;
+    putBytes(src: Uint8Array): void;
+    putLengthPrefixedBytes(src: Uint8Array): void;
+    putKeyValuePair(pair: KeyValuePair): void;
+    putReasonPhrase(reason: ReasonPhrase): void;
+    toUint8Array(): Uint8Array;
+    freeze(): FrozenByteBuffer;
+    putLocation(loc: Location): void;
+    putTuple(tuple: Tuple): void;
+    putFullTrackName(fullTrackName: FullTrackName): void;
+}
+declare class FrozenByteBuffer extends BaseByteBuffer {
+    constructor(buf: Uint8Array);
+    get length(): number;
+}
+
 /**
  * Copyright 2025 The MOQtail Authors
  *
@@ -1656,4 +2640,4 @@ declare class VersionSpecificParameters {
     static fromKeyValuePairs(kvps: KeyValuePair[]): VersionSpecificParameter[];
 }
 
-export { UnsubscribeNamespace as $, FetchOk as A, GoAway as B, ClientSetup as C, DRAFT_14 as D, ServerSetup as E, FilterType as F, GroupOrder as G, SubscribeNamespace as H, SubscribeNamespaceError as I, SubscribeNamespaceOk as J, PublishDone as K, Publish as L, MaxRequestId$1 as M, PublishError as N, PublishOk as O, PublishNamespace as P, SubscribeError as Q, RequestsBlocked as R, Subscribe as S, TrackStatusCode as T, SubscribeOk as U, SubscribeUpdate as V, TrackStatus as W, TrackStatusError as X, TrackStatusOk as Y, PublishNamespaceDone as Z, Unsubscribe as _, PublishNamespaceError as a, FetchHeader as a0, SubgroupHeader as a1, RequestIdMap as a2, Header as a3, SetupParameter as a4, SetupParameters as a5, VersionSpecificParameter as a6, VersionSpecificParameters as a7, type Parameter as a8, CommonType as a9, commonTypeFromNumber as aa, SetupParameterType as ab, setupParameterTypeFromNumber as ac, VersionSpecificParameterType as ad, versionSpecificParameterTypeFromNumber as ae, TokenAliasType as af, tokenAliasTypeFromNumber as ag, type AuthTokenVariant as ah, AuthorizationToken as ai, MaxRequestId as aj, Path as ak, MaxAuthTokenCacheSize as al, DeliveryTimeout as am, MaxCacheDuration as an, PublishNamespaceOk as b, PublishNamespaceCancel as c, ControlMessageType as d, controlMessageTypeFromBigInt as e, PublishNamespaceErrorCode as f, filterTypeFromBigInt as g, FetchType as h, fetchTypeFromBigInt as i, groupOrderFromNumber as j, SubscribeErrorCode as k, FetchErrorCode as l, fetchErrorCodeFromBigInt as m, SubscribeNamespaceErrorCode as n, subscribeNamespaceErrorCodeFromBigInt as o, publishNamespaceErrorCodeFromBigInt as p, PublishDoneStatusCode as q, publishDoneStatusCodeFromBigInt as r, subscribeErrorCodeFromBigInt as s, trackStatusCodeFromBigInt as t, PublishErrorCode as u, publishErrorCodeFromBigInt as v, ControlMessage as w, Fetch as x, FetchCancel as y, FetchError as z };
+export { PublishNamespaceOk as $, type AuthTokenVariant as A, BaseByteBuffer as B, ClientSetup as C, DRAFT_14 as D, MoqtObject as E, Fetch as F, GoAway as G, Header as H, ObjectDatagramType as I, ObjectForwardingPreference as J, KeyValuePair as K, Location as L, MAX_FULL_TRACK_NAME_LENGTH as M, ObjectStatus as N, ObjectDatagramStatusType as O, type Parameter as P, Path as Q, Publish as R, PublishDone as S, PublishDoneStatusCode as T, PublishError as U, PublishErrorCode as V, PublishNamespace as W, PublishNamespaceCancel as X, PublishNamespaceDone as Y, PublishNamespaceError as Z, PublishNamespaceErrorCode as _, AuthorizationToken as a, PublishOk as a0, ReasonPhrase as a1, RequestIdMap as a2, RequestsBlocked as a3, ServerSetup as a4, SetupParameter as a5, SetupParameterType as a6, SetupParameters as a7, SubgroupHeader as a8, SubgroupHeaderType as a9, filterTypeFromBigInt as aA, groupOrderFromNumber as aB, isBytes as aC, isVarInt as aD, publishDoneStatusCodeFromBigInt as aE, publishErrorCodeFromBigInt as aF, publishNamespaceErrorCodeFromBigInt as aG, setupParameterTypeFromNumber as aH, subscribeErrorCodeFromBigInt as aI, subscribeNamespaceErrorCodeFromBigInt as aJ, tokenAliasTypeFromNumber as aK, trackStatusCodeFromBigInt as aL, versionSpecificParameterTypeFromNumber as aM, SubgroupObject as aa, Subscribe as ab, SubscribeError as ac, SubscribeErrorCode as ad, SubscribeNamespace as ae, SubscribeNamespaceError as af, SubscribeNamespaceErrorCode as ag, SubscribeNamespaceOk as ah, SubscribeOk as ai, SubscribeUpdate as aj, TokenAliasType as ak, TrackStatus as al, TrackStatusCode as am, TrackStatusError as an, TrackStatusOk as ao, Tuple as ap, TupleField as aq, Unsubscribe as ar, UnsubscribeNamespace as as, VersionSpecificParameter as at, VersionSpecificParameterType as au, VersionSpecificParameters as av, commonTypeFromNumber as aw, controlMessageTypeFromBigInt as ax, fetchErrorCodeFromBigInt as ay, fetchTypeFromBigInt as az, ByteBuffer as b, CommonType as c, ControlMessage as d, ControlMessageType as e, DatagramObject as f, DatagramStatus as g, DeliveryTimeout as h, FetchCancel as i, FetchError as j, FetchErrorCode as k, FetchHeader as l, FetchHeaderType as m, FetchObject as n, FetchOk as o, FetchType as p, FilterType as q, FrozenByteBuffer as r, FullTrackName as s, GroupOrder as t, MAX_NAMESPACE_TUPLE_COUNT as u, MAX_REASON_PHRASE_LEN as v, MaxAuthTokenCacheSize as w, MaxCacheDuration as x, MaxRequestId$1 as y, MaxRequestId as z };