moqtail 0.7.0

package/dist/byte_buffer-BOK6VPTF.d.cts

@@ -0,0 +1,864 @@
+/**
+ * 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.
+ * - `WithoutExtensions`: Object datagram without extensions.
+ * - `WithExtensions`: Object datagram with extensions.
+ */
+declare enum ObjectDatagramStatusType {
+    WithoutExtensions = 2,
+    WithExtensions = 3
+}
+/**
+ * @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;
+}
+/**
+ * @public
+ * Object datagram types for MOQT objects.
+ * - `WithoutExtensions`: Object datagram without extensions.
+ * - `WithExtensions`: Object datagram with extensions.
+ */
+declare enum ObjectDatagramType {
+    WithoutExtensions = 0,
+    WithExtensions = 1
+}
+/**
+ * @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;
+}
+/**
+ * @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.
+ */
+
+declare class DatagramObject {
+    readonly type: ObjectDatagramType;
+    readonly publisherPriority: number;
+    readonly extensionHeaders: KeyValuePair[] | null;
+    readonly payload: Uint8Array;
+    readonly trackAlias: bigint;
+    readonly location: Location;
+    private constructor();
+    get groupId(): bigint;
+    get objectId(): bigint;
+    static newWithExtensions(trackAlias: bigint, groupId: bigint, objectId: bigint, publisherPriority: number, extensionHeaders: KeyValuePair[], payload: Uint8Array): DatagramObject;
+    static newWithoutExtensions(trackAlias: bigint, groupId: bigint, objectId: bigint, publisherPriority: number, payload: Uint8Array): 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.
+ */
+
+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;
+    static withExtensions(trackAlias: bigint | number, location: Location, publisherPriority: number, extensionHeaders: KeyValuePair[], objectStatus: ObjectStatus): DatagramStatus;
+    static newWithoutExtensions(trackAlias: bigint | number, location: Location, publisherPriority: number, objectStatus: ObjectStatus): DatagramStatus;
+    serialize(): FrozenByteBuffer;
+    static deserialize(buf: BaseByteBuffer): DatagramStatus;
+}
+
+/**
+ * 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;
+    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;
+    tryIntoDatagramObject(trackAlias: bigint | number): DatagramObject;
+    tryIntoDatagramStatus(trackAlias: bigint | number): DatagramStatus;
+    tryIntoFetchObject(): FetchObject;
+    tryIntoSubgroupObject(): 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 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;
+}
+
+export { BaseByteBuffer as B, DatagramObject as D, FrozenByteBuffer as F, KeyValuePair as K, Location as L, MAX_REASON_PHRASE_LEN as M, ObjectDatagramStatusType as O, ReasonPhrase as R, SubgroupHeaderType as S, TupleField as T, ByteBuffer as a, isBytes as b, Tuple as c, ObjectDatagramType as d, FetchHeaderType as e, ObjectForwardingPreference as f, ObjectStatus as g, DatagramStatus as h, isVarInt as i, FetchObject as j, MAX_NAMESPACE_TUPLE_COUNT as k, MAX_FULL_TRACK_NAME_LENGTH as l, FullTrackName as m, MoqtObject as n, SubgroupObject as o };