moqtail 0.7.0

package/dist/client/index.d.ts

@@ -0,0 +1,1665 @@
+import { w as ControlMessage, U as SubscribeOk, Q as SubscribeError, S as Subscribe, V as SubscribeUpdate, q as PublishDoneStatusCode, x as Fetch, b as PublishNamespaceOk, a as PublishNamespaceError, P as PublishNamespace, A as FetchOk, z as FetchError, J as SubscribeNamespaceOk, I as SubscribeNamespaceError, H as SubscribeNamespace, a5 as SetupParameters, G as GroupOrder, F as FilterType, a7 as VersionSpecificParameters, h as FetchType, a2 as RequestIdMap, Z as PublishNamespaceDone, B as GoAway, a1 as SubgroupHeader, a0 as FetchHeader, E as ServerSetup, c as PublishNamespaceCancel, $ as UnsubscribeNamespace, a3 as Header } from '../version_parameter-CgEPNuUt.js';
+import { n as MoqtObject, L as Location, m as FullTrackName, f as ObjectForwardingPreference, K as KeyValuePair, D as DatagramObject, h as DatagramStatus, c as Tuple, o as SubgroupObject, j as FetchObject } from '../byte_buffer-BOK6VPTF.js';
+
+/**
+ * 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 ControlStream {
+    #private;
+    readonly stream: ReadableStream<ControlMessage>;
+    onMessageSent?: (msg: ControlMessage) => void;
+    onMessageReceived?: (msg: ControlMessage) => void;
+    private constructor();
+    static new(bidirectionalStream: WebTransportBidirectionalStream, partialMessageTimeoutMs?: number, onMessageSent?: (msg: ControlMessage) => void, onMessageReceived?: (msg: ControlMessage) => void): ControlStream;
+    send(message: ControlMessage): Promise<void>;
+    close(): Promise<void>;
+}
+
+/**
+ * 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.
+ */
+
+/**
+ * In‑memory index of {@link MoqtObject} instances keyed by their {@link Location} (group/subgroup/object),
+ * providing ordered insertion and range queries.
+ *
+ * Implementations MUST keep objects sorted ascending by (groupId, objectId) so binary searches can
+ * locate insertion points / range bounds efficiently. Subgroup ordinality is currently ignored for ordering
+ * (adjust if protocol semantics require finer granularity later).
+ *
+ * @example Typical usage
+ * ```ts
+ * const cache: ObjectCache = new MemoryObjectCache()
+ * cache.add(obj)
+ * const window = cache.getRange(startLoc, endLoc)
+ * const exact = cache.getByLocation(loc)
+ * ```
+ *
+ * Concurrency: Implementations here are not thread‑safe; callers avoid concurrent mutation from workers.
+ */
+interface ObjectCache {
+    /** Insert a new {@link MoqtObject}, preserving sorted order (duplicates allowed or replaced impl‑defined). */
+    add(obj: MoqtObject): void;
+    /** Return a shallow copy array of objects whose Location is \>= start and \< end (end exclusive). */
+    getRange(start?: Location, end?: Location): MoqtObject[];
+    /** Return the object whose Location exactly matches (group & object) or undefined if absent. */
+    getByLocation(location: Location): MoqtObject | undefined;
+    /** Current number of cached objects. */
+    size(): number;
+    /** Remove all cached objects. */
+    clear(): void;
+}
+declare class MemoryObjectCache implements ObjectCache {
+    private objects;
+    add(obj: MoqtObject): void;
+    getRange(start?: Location, end?: Location): MoqtObject[];
+    getByLocation(location: Location): MoqtObject | undefined;
+    size(): number;
+    clear(): void;
+    private _findInsertIndex;
+    private _findIndex;
+}
+declare class RingBufferObjectCache implements ObjectCache {
+    private buffer;
+    private maxSize;
+    constructor(maxSize?: number);
+    add(obj: MoqtObject): void;
+    getRange(start?: Location, end?: Location): MoqtObject[];
+    getByLocation(location: Location): MoqtObject | undefined;
+    size(): number;
+    clear(): void;
+    private _findInsertIndex;
+    private _findIndex;
+}
+
+/**
+ * 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.
+ */
+
+/**
+ * Source of already-produced (historical) objects for a track.
+ * Backed by an {@link ObjectCache} allowing range retrieval using protocol {@link Location}s.
+ * Implementations MUST return objects in ascending location order and MAY return an empty array
+ * if the requested window is outside the cached range.
+ */
+interface PastObjectSource {
+    /** Underlying cache from which objects are served */
+    readonly cache: ObjectCache;
+    /**
+     * Fetch a (closed) range of objects. `start`/`end` are inclusive when provided.
+     * Omitted bounds mean: from earliest cached (when `start` undefined) or up to latest cached (when `end` undefined).
+     */
+    getRange(start?: Location, end?: Location): Promise<MoqtObject[]>;
+}
+/**
+ * Push-oriented live object feed. Wraps a {@link https://developer.mozilla.org/docs/Web/API/ReadableStream | ReadableStream} plus lightweight event subscription helpers.
+ * Implementations advance {@link LiveObjectSource.largestLocation | largestLocation} monotonically as objects arrive.
+ */
+interface LiveObjectSource {
+    /** Continuous stream yielding objects as they are produced */
+    readonly stream: ReadableStream<MoqtObject>;
+    /** Highest (latest) location observed so far; undefined until first object */
+    readonly largestLocation: Location | undefined;
+    /** Register a listener invoked (async) for each new object. Returns an unsubscribe function. */
+    onNewObject(listener: (obj: MoqtObject) => void): () => void;
+    /** Register a listener invoked when the live stream ends (normal or error). Returns an unsubscribe function. */
+    onDone(listener: () => void): () => void;
+    /** Stop ingestion and release underlying reader (idempotent). */
+    stop(): void;
+}
+/**
+ * Aggregates optional historical (`past`) and (`live`) sources for a single track.
+ * Either facet may be omitted:
+ * - VOD / static content: supply only {@link TrackSource.past | past}
+ * - Pure live: supply only {@link TrackSource.live | live}
+ * - Hybrid (catch-up + live tail): supply both.
+ *
+ * Priority handling note: publisher priority is defined on the Track metadata (see `Track.publisherPriority`).
+ * The library rounds non-integer values and clamps priority into [0,255] there; this interface simply
+ * expresses what content is available, independent of priority semantics.
+ */
+interface TrackSource {
+    /** Historical object access (optional) */
+    readonly past?: PastObjectSource;
+    /** Live object feed (optional) */
+    readonly live?: LiveObjectSource;
+}
+declare class StaticTrackSource implements PastObjectSource {
+    readonly cache: ObjectCache;
+    constructor(cache: ObjectCache);
+    getRange(start?: Location, end?: Location): Promise<MoqtObject[]>;
+}
+declare class LiveTrackSource implements LiveObjectSource {
+    #private;
+    readonly stream: ReadableStream<MoqtObject>;
+    constructor(stream: ReadableStream<MoqtObject>);
+    get largestLocation(): Location | undefined;
+    onNewObject(listener: (obj: MoqtObject) => void): () => void;
+    onDone(listener: () => void): () => void;
+    stop(): void;
+}
+declare class HybridTrackSource implements TrackSource {
+    readonly past: PastObjectSource;
+    readonly live: LiveObjectSource;
+    constructor(cache: ObjectCache, stream: ReadableStream<MoqtObject>);
+}
+
+/**
+ * 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.
+ */
+
+/**
+ * Describes a media/data track known to the client (either published locally or subscribed to).
+ *
+ *
+ * @example Live only track
+ * ```ts
+ * const liveStream: ReadableStream<MoqtObject> = buildCameraStream()
+ * const track: Track = {
+ *   fullTrackName,
+ *   forwardingPreference: ObjectForwardingPreference.Latest,
+ *   trackSource: { live: liveStream },
+ *   publisherPriority: 0
+ * }
+ * client.addOrUpdateTrack(track)
+ * ```
+ *
+ * @example Past only track (pre‑recorded cache)
+ * ```ts
+ * const cache = new MemoryObjectCache()
+ * recording.forEach(obj => cache.add(obj))
+ * const track: Track = {
+ *   fullTrackName,
+ *   forwardingPreference: ObjectForwardingPreference.All,
+ *   trackSource: { past: cache },
+ *   publisherPriority: 64
+ * }
+ * client.addOrUpdateTrack(track)
+ * ```
+ *
+ * @example Hybrid (cache + live)
+ * ```ts
+ * const cache = new MemoryObjectCache()
+ * const liveStream = buildLiveReadableStream()
+ * const track: Track = {
+ *   fullTrackName,
+ *   forwardingPreference: ObjectForwardingPreference.Latest,
+ *   trackSource: { past: cache, live: liveStream },
+ *   publisherPriority: 8
+ * }
+ * client.addOrUpdateTrack(track)
+ * ```
+ */
+type Track = {
+    /**
+     * Globally unique identifier for the track.
+     */
+    fullTrackName: FullTrackName;
+    /**
+     * Hint controlling which objects SHOULD be forwarded / prioritized.
+     */
+    forwardingPreference: ObjectForwardingPreference;
+    /**
+     * Accessors for live and/or past objects belonging to this track.
+     */
+    trackSource: TrackSource;
+    /**
+     * 0 (highest) .. 255 (lowest) priority advertised with objects.
+     * Values are rounded to nearest integer then clamped between 0 and 255.
+     */
+    publisherPriority: number;
+    /**
+     * Optional compact numeric alias assigned during protocol negotiation.
+     */
+    trackAlias?: bigint;
+};
+
+/**
+ * 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 SubscribeRequest implements PromiseLike<SubscribeOk | SubscribeError> {
+    #private;
+    requestId: bigint;
+    fullTrackName: FullTrackName;
+    isCanceled: boolean;
+    startLocation: Location | undefined;
+    endGroup: bigint | undefined;
+    priority: number;
+    forward: boolean;
+    subscribeParameters: KeyValuePair[];
+    largestLocation: Location | undefined;
+    streamsAccepted: bigint;
+    expectedStreams: bigint | undefined;
+    readonly controller: ReadableStreamDefaultController<MoqtObject>;
+    readonly stream: ReadableStream<MoqtObject>;
+    constructor(msg: Subscribe);
+    update(msg: SubscribeUpdate): void;
+    switch(newTrackName: FullTrackName, newParameters: KeyValuePair[]): void;
+    unsubscribe(): void;
+    resolve(value: SubscribeOk | SubscribeError | PromiseLike<SubscribeOk | SubscribeError>): void;
+    reject(reason?: any): void;
+    then<TResult1 = SubscribeOk | SubscribeError, TResult2 = never>(onfulfilled?: ((value: SubscribeOk | SubscribeError) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): PromiseLike<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<SubscribeOk | SubscribeError | TResult>;
+    finally(onfinally?: (() => void) | undefined | null): Promise<SubscribeOk | SubscribeError>;
+}
+
+/**
+ * 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
+ * Manages the publication of MOQT objects to a subscriber for a specific track.
+ * Handles live object streaming, subscription lifecycle, and stream management.
+ */
+declare class SubscribePublication {
+    #private;
+    private readonly client;
+    readonly track: Track;
+    private readonly subscribeMsg;
+    /**
+     * The latest location that was published to the subscriber.
+     */
+    latestLocation: Location | undefined;
+    /**
+     * Creates a new SubscribePublication instance.
+     * @param client - The MOQT client managing the subscription.
+     * @param track - The track being published.
+     * @param subscribeMsg - The subscribe message containing subscription details.
+     * @param largestLocation - The largest location seen so far, used for determining start location.
+     */
+    constructor(client: MOQtailClient, track: Track, subscribeMsg: Subscribe, largestLocation?: Location);
+    /**
+     * Cancels the publication and cleans up resources.
+     * Removes the publication from the client's publication map.
+     */
+    cancel(): void;
+    /**
+     * Marks the publication as done and sends a PublishDone message to the client.
+     * @param statusCode - The status code indicating why the publication ended.
+     * @throws :{@link InternalError} If sending the message fails.
+     */
+    done(statusCode: PublishDoneStatusCode): Promise<void>;
+    /**
+     * Updates the subscription parameters and locations based on a SubscribeUpdate message.
+     * @param msg - The update message containing new subscription details.
+     */
+    update(msg: SubscribeUpdate): void;
+    /**
+     * Publishes MOQT objects to the subscriber as they become available.
+     * Handles stream creation, object writing, and stream closure based on subscription parameters.
+     * @throws :{@link InternalError} If the track does not support live content.
+     */
+    publish(): Promise<void>;
+}
+
+/**
+ * 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 FetchPublication {
+    #private;
+    constructor(client: MOQtailClient, track: Track, fetchRequest: Fetch);
+    cancel(): void;
+    publish(): Promise<void>;
+}
+
+/**
+ * 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 PublishNamespaceRequest implements PromiseLike<PublishNamespaceOk | PublishNamespaceError> {
+    readonly requestId: bigint;
+    readonly message: PublishNamespace;
+    private _resolve;
+    private _reject;
+    private promise;
+    constructor(requestId: bigint, message: PublishNamespace);
+    resolve(value: PublishNamespaceOk | PublishNamespaceError | PromiseLike<PublishNamespaceOk | PublishNamespaceError>): void;
+    reject(reason?: any): void;
+    then<TResult1 = PublishNamespaceOk | PublishNamespaceError, TResult2 = never>(onfulfilled?: ((value: PublishNamespaceOk | PublishNamespaceError) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): PromiseLike<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<PublishNamespaceOk | PublishNamespaceError | TResult>;
+    finally(onfinally?: (() => void) | undefined | null): Promise<PublishNamespaceOk | PublishNamespaceError>;
+}
+
+/**
+ * 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 FetchRequest implements PromiseLike<FetchOk | FetchError> {
+    readonly requestId: bigint;
+    readonly message: Fetch;
+    private _resolve;
+    private _reject;
+    private promise;
+    controller?: ReadableStreamDefaultController<MoqtObject>;
+    stream: ReadableStream<MoqtObject>;
+    isActive: boolean;
+    isResolved: boolean;
+    constructor(message: Fetch);
+    resolve(value: FetchOk | FetchError | PromiseLike<FetchOk | FetchError>): void;
+    reject(reason?: any): void;
+    then<TResult1 = FetchOk | FetchError, TResult2 = never>(onfulfilled?: ((value: FetchOk | FetchError) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): PromiseLike<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<FetchOk | FetchError | TResult>;
+    finally(onfinally?: (() => void) | undefined | null): Promise<FetchOk | FetchError>;
+}
+
+/**
+ * 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 SubscribeNamespaceRequest implements PromiseLike<SubscribeNamespaceOk | SubscribeNamespaceError> {
+    readonly requestId: bigint;
+    readonly message: SubscribeNamespace;
+    private _resolve;
+    private _reject;
+    private promise;
+    constructor(requestId: bigint, message: SubscribeNamespace);
+    resolve(value: SubscribeNamespaceOk | SubscribeNamespaceError | PromiseLike<SubscribeNamespaceOk | SubscribeNamespaceError>): void;
+    reject(reason?: any): void;
+    then<TResult1 = SubscribeNamespaceOk | SubscribeNamespaceError, TResult2 = never>(onfulfilled?: ((value: SubscribeNamespaceOk | SubscribeNamespaceError) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): PromiseLike<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<SubscribeNamespaceOk | SubscribeNamespaceError | TResult>;
+    finally(onfinally?: (() => void) | undefined | null): Promise<SubscribeNamespaceOk | SubscribeNamespaceError>;
+}
+
+/**
+ * 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.
+ */
+
+/**
+ * Discriminated union of every in‑flight MOQ‑tail control request tracked by the {@link MOQtailClient}.
+ *
+ * Each concrete request type encapsulates the original control message plus coordination primitives
+ * (e.g. a {@link https://developer.mozilla.org/docs/Web/API/Promise | Promise} facade / stream controller) that resolve when a terminal protocol response
+ * (OK / ERROR / CANCEL) is received.
+ *
+ * Used internally in maps like `MOQtailClient.requests` to look up state by request id without needing
+ * multiple heterogeneous collections.
+ *
+ * Variants:
+ * - {@link PublishNamespaceRequest} – pending PUBLISH_NAMESPACE / PUBLISH_NAMESPACE_OK / PUBLISH_NAMESPACE_ERROR.
+ * - {@link SubscribeNamespaceRequest} – pending SUBSCRIBE_NAMESPACE sequence.
+ * - {@link FetchRequest} – pending FETCH handshake producing a data stream.
+ * - {@link SubscribeRequest} – pending SUBSCRIBE producing subgroup object streams.
+ 
+*
+ * @example Looking up a request by id
+ * ```ts
+ * function isActive(requests: Map<bigint, MOQtailRequest>, id: bigint) {
+ *   const req = requests.get(id)
+ *   if (!req) return false
+ *   // Narrow by instanceof, e.g. FetchRequest
+ *   if (req instanceof FetchRequest) {
+ *     console.log('Fetch still pending for', req.message.requestId)
+ *   }
+ *   return true
+ * }
+ * ```
+ */
+type MOQtailRequest = PublishNamespaceRequest | SubscribeNamespaceRequest | FetchRequest | SubscribeRequest;
+/**
+ * Options for {@link MOQtailClient.new} controlling connection target, protocol negotiation, timeouts,
+ * and lifecycle callbacks.
+ *
+ * @example Minimal
+ * ```ts
+ * const opts: MOQtailClientOptions = {
+ *   url: 'https://relay.example.com/moq',
+ *   supportedVersions: [0xff00000b]
+ * }
+ * const client = await MOQtailClient.new(opts)
+ * ```
+ * @example With callbacks & timeouts
+ * ```ts
+ * const client = await MOQtailClient.new({
+ *   url: relayUrl,
+ *   supportedVersions: [0xff00000b],
+ *   dataStreamTimeoutMs: 5000,
+ *   controlStreamTimeoutMs: 1500,
+ *   callbacks: {
+ *     onMessageSent: m => logOutbound(m),
+ *     onMessageReceived: m => logInbound(m),
+ *     onSessionTerminated: r => console.warn('terminated', r)
+ *   }
+ * })
+ * ```
+ */
+type MOQtailClientOptions = {
+    /** Relay / server endpoint for the underlying {@link https://developer.mozilla.org/docs/Web/API/WebTransport | WebTransport} session (can be absolute {@link https://developer.mozilla.org/en-US/docs/Web/API/URL | URL} or string).*/
+    url: string | URL;
+    /** Ordered preference list of MOQT protocol version numbers (e.g. `0xff00000b`).   */
+    supportedVersions: number[];
+    /**  {@link SetupParameters} customizations; if omitted a default instance is built.*/
+    setupParameters?: SetupParameters;
+    /**  Passed directly to the browser's {@link https://developer.mozilla.org/docs/Web/API/WebTransport | WebTransport} constructor for {@link https://developer.mozilla.org/docs/Web/API/WebTransportOptions | WebTransportOptions}. */
+    transportOptions?: WebTransportOptions;
+    /** Per *data* uni-stream idle timeout in milliseconds. */
+    dataStreamTimeoutMs?: number;
+    /** Control stream read timeout in milliseconds. */
+    controlStreamTimeoutMs?: number;
+    /** If true, enables datagram support for the session. */
+    enableDatagrams: boolean;
+    /** callbacks for observability and logging purposes: */
+    callbacks?: {
+        /** Called after a control message is successfully written to the {@link ControlStream}. */
+        onMessageSent?: (msg: ControlMessage) => void;
+        /** Called for each incoming control message before protocol handling. */
+        onMessageReceived?: (msg: ControlMessage) => void;
+        /** Fired once when the session ends (normal or error). Receives the reason passed to {@link MOQtailClient.disconnect | disconnect}. */
+        onSessionTerminated?: (reason?: unknown) => void;
+        /** Invoked for each decoded datagram object/status arriving. */
+        onDatagramReceived?: (data: DatagramObject | DatagramStatus) => void;
+        /** Invoked after enqueuing each outbound datagram object/status. */
+        onDatagramSent?: (data: DatagramObject | DatagramStatus) => void;
+    };
+};
+/**
+ * Parameters for {@link MOQtailClient.subscribe | subscribing} to a track's live objects.
+ *
+ * @example Latest object
+ * ```ts
+ * await client.subscribe({
+ *   fullTrackName,
+ *   priority: 0,
+ *   groupOrder: GroupOrder.Original,
+ *   forward: true,
+ *   filterType: FilterType.LatestObject
+ * })
+ * ```
+ * @example Absolute range
+ * ```ts
+ * await client.subscribe({
+ *   fullTrackName,
+ *   priority: 32,
+ *   groupOrder: GroupOrder.Original,
+ *   forward: true,
+ *   filterType: FilterType.AbsoluteRange,
+ *   startLocation: { group: 100n, subgroup: 0n, object: 0n },
+ *   endGroup: 120n
+ * })
+ * ```
+ */
+type SubscribeOptions = {
+    /** Fully qualified track identifier ({@link FullTrackName}). */
+    fullTrackName: FullTrackName;
+    /** Subscriber priority (0 = highest, 255 = lowest). Values outside range are clamped. Fractional values are rounded. */
+    priority: number;
+    /** Desired {@link GroupOrder} (e.g. {@link GroupOrder.Original}) specifying delivery ordering semantics. */
+    groupOrder: GroupOrder;
+    /** If true, deliver objects forward (ascending); if false, reverse/backward semantics (implementation dependent). */
+    forward: boolean;
+    /** {@link FilterType} variant controlling starting subset (e.g. {@link FilterType.LatestObject}). */
+    filterType: FilterType;
+    /** Optional extension {@link VersionSpecificParameters} appended to the SUBSCRIBE control message. */
+    parameters?: VersionSpecificParameters;
+    /** Required for {@link FilterType.AbsoluteStart} / {@link FilterType.AbsoluteRange}; earliest {@link Location} to include. */
+    startLocation?: Location;
+    /** Required for {@link FilterType.AbsoluteRange}; exclusive upper group boundary (coerced to bigint if number provided). */
+    endGroup?: bigint | number;
+};
+/**
+ * Narrowing update constraints applied to an existing SUBSCRIBE via {@link MOQtailClient.subscribeUpdate}.
+ *
+ * Rules: start can only move forward (increase) and endGroup can only move backward (decrease) narrowing the window.
+ *
+ * @example Narrowing a live window
+ * ```ts
+ * await client.subscribeUpdate({
+ *   requestId,
+ *   startLocation: { group: 200n, subgroup: 0n, object: 0n },
+ *   endGroup: 210n,
+ *   priority: 16,
+ *   forward: true
+ * })
+ * ```
+ */
+type SubscribeUpdateOptions = {
+    /** The original SUBSCRIBE request id (bigint) being updated. */
+    subscriptionRequestId: bigint;
+    /** New narrowed {@link Location} start. */
+    startLocation: Location;
+    /** New narrowed end group (inclusive / protocol defined) must be \> start group. */
+    endGroup: bigint;
+    /** Updated subscriber priority (same constraints as initial subscribe). 0 is highest, 255 is lowest. */
+    priority: number;
+    /** Updated direction flag. */
+    forward: boolean;
+    /** Optional additional {@link VersionSpecificParameters}; existing parameters persist if omitted. */
+    parameters?: VersionSpecificParameters;
+};
+/**
+ * Parameters for {@link MOQtailClient.switch | switching} an existing SUBSCRIBE to a new track.
+ *
+ * @example Switching subscription to a new track
+ * ```ts
+ * await client.switch({
+ *   fullTrackName: newFullTrackName,
+ *   subscriptionRequestId
+ * })
+ * ```
+ */
+type SwitchOptions = {
+    /** Fully qualified track identifier to switch to ({@link FullTrackName}). */
+    fullTrackName: FullTrackName;
+    /** The original SUBSCRIBE request id (bigint) being updated. */
+    subscriptionRequestId: bigint;
+    /** Optional additional {@link VersionSpecificParameters}; existing parameters persist if omitted. */
+    parameters?: VersionSpecificParameters;
+};
+/**
+ * Options for {@link MOQtailClient.fetch | performing a FETCH} operation for historical or relative object ranges.
+ *
+ * @example Standalone fetch
+ * ```ts
+ * const { requestId, stream } = await client.fetch({
+ *   priority: 64,
+ *   groupOrder: GroupOrder.Original,
+ *   typeAndProps: {
+ *     type: FetchType.StandAlone,
+ *     props: { fullTrackName, startLocation, endLocation }
+ *   }
+ * })
+ * ```
+ * @example Relative fetch joining a subscription
+ * ```ts
+ * const { requestId: subId } = await client.subscribe({
+ *   fullTrackName,
+ *   priority: 0,
+ *   groupOrder: GroupOrder.Original,
+ *   forward: true,
+ *   filterType: FilterType.LatestObject
+ * })
+ * const fetchRes = await client.fetch({
+ *   priority: 32,
+ *   groupOrder: GroupOrder.Original,
+ *   typeAndProps: {
+ *     type: FetchType.Relative,
+ *     props: { joiningRequestId: subId, joiningStart: 0n }
+ *   }
+ * })
+ * ```
+ */
+type FetchOptions = {
+    /** Request priority (0 = highest, 255 = lowest). Rounded & clamped. */
+    priority: number;
+    /** {@link GroupOrder} governing sequencing. */
+    groupOrder: GroupOrder;
+    /**
+     * Discriminated union selecting the {@link FetchType} mode and its specific properties:
+     * - StandAlone: full explicit range on a {@link FullTrackName} with start/end {@link Location}s.
+     * - Relative / Absolute: join an existing {@link SubscribeRequest} (identified by `joiningRequestId`) with starting position `joiningStart`.
+     */
+    typeAndProps: {
+        /** Standalone historical/segment fetch for a specific {@link FullTrackName}. */
+        type: FetchType.StandAlone;
+        /** Properties for standalone fetch: explicit track and range. */
+        props: {
+            fullTrackName: FullTrackName;
+            startLocation: Location;
+            endLocation: Location;
+        };
+    } | {
+        /** Fetch a range relative to an existing {@link SubscribeRequest} identified by `joiningRequestId`. */
+        type: FetchType.Relative;
+        /** Properties for relative fetch: subscription id and starting position. */
+        props: {
+            joiningRequestId: bigint;
+            joiningStart: bigint;
+        };
+    } | {
+        /** Fetch an absolute group/object range relative to a {@link SubscribeRequest}. */
+        type: FetchType.Absolute;
+        /** Properties for absolute fetch: subscription id and starting position. */
+        props: {
+            joiningRequestId: bigint;
+            joiningStart: bigint;
+        };
+    };
+    /** Optional {@link VersionSpecificParameters} block. */
+    parameters?: VersionSpecificParameters;
+};
+
+/**
+ * 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.
+ */
+
+/**
+ * Sends MoqtObjects as WebTransport datagrams.
+ * Parallel to SendStream but for datagram-based delivery.
+ *
+ * @example
+ * ```ts
+ * const sender = new SendDatagramStream(client.webTransport.datagrams.writable, trackAlias);
+ * await sender.write(moqtObject);
+ * ```
+ */
+declare class SendDatagramStream {
+    #private;
+    readonly onDataSent?: (data: DatagramObject | DatagramStatus) => void;
+    constructor(writer: WritableStreamDefaultWriter<Uint8Array>, trackAlias: bigint, onDataSent?: (data: DatagramObject | DatagramStatus) => void);
+    /**
+     * Create a new datagram sender for a specific track.
+     *
+     * @param writeStream - WebTransport datagram writable stream
+     * @param trackAlias - Track alias for this datagram stream
+     * @param onDataSent - Optional callback fired when datagram is sent
+     * @returns SendDatagramStream instance
+     */
+    static new(writeStream: WritableStream<Uint8Array>, trackAlias: bigint, onDataSent?: (data: DatagramObject | DatagramStatus) => void): Promise<SendDatagramStream>;
+    /**
+     * Create a datagram sender using an existing shared writer.
+     * Use this when multiple senders need to share a single writer.
+     *
+     * @param writer - Existing WritableStreamDefaultWriter
+     * @param trackAlias - Track alias for this datagram stream
+     * @param onDataSent - Optional callback fired when datagram is sent
+     * @returns SendDatagramStream instance
+     */
+    static fromWriter(writer: WritableStreamDefaultWriter<Uint8Array>, trackAlias: bigint, onDataSent?: (data: DatagramObject | DatagramStatus) => void): SendDatagramStream;
+    /**
+     * Write a MoqtObject as a datagram.
+     * Converts to DatagramObject or DatagramStatus automatically.
+     *
+     * @param object - MoqtObject to send (must have Datagram forwarding preference)
+     * @throws ProtocolViolationError if object is not datagram-compatible
+     */
+    write(object: MoqtObject): Promise<void>;
+    /**
+     * Close the datagram writer.
+     */
+    close(): Promise<void>;
+    /**
+     * Release the writer lock without closing.
+     */
+    releaseLock(): void;
+}
+/**
+ * Receives and parses WebTransport datagrams as MoqtObjects.
+ * Parallel to RecvStream but for datagram-based delivery.
+ *
+ * Automatically handles:
+ * - DatagramObject parsing (objects with payloads)
+ * - DatagramStatus parsing (status-only objects)
+ * - Track alias to full track name resolution
+ *
+ * @example
+ * ```ts
+ * const receiver = new RecvDatagramStream(
+ *   client.webTransport.datagrams.readable,
+ *   (trackAlias) => client.requestIdMap.getNameByTrackAlias(trackAlias)
+ * );
+ *
+ * for await (const object of receiver.stream) {
+ *   console.log('Received:', object);
+ * }
+ * ```
+ */
+declare class RecvDatagramStream {
+    #private;
+    readonly stream: ReadableStream<MoqtObject>;
+    readonly onDataReceived?: (data: DatagramObject | DatagramStatus) => void;
+    private constructor();
+    /**
+     * Create a new datagram receiver.
+     *
+     * @param readStream - WebTransport datagram readable stream
+     * @param trackAliasResolver - Function to resolve track alias to full track name
+     * @param onDataReceived - Optional callback fired when datagram is received
+     * @returns RecvDatagramStream instance
+     */
+    static new(readStream: ReadableStream<Uint8Array>, trackAliasResolver: (trackAlias: bigint) => FullTrackName, onDataReceived?: (data: DatagramObject | DatagramStatus) => void): Promise<RecvDatagramStream>;
+    /**
+     * Cancel the datagram reader.
+     */
+    cancel(): Promise<void>;
+    /**
+     * Release the reader lock without canceling.
+     */
+    releaseLock(): void;
+}
+
+/**
+ * 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 Media Over QUIC Transport (MOQT) client session.
+ *
+ * Use {@link MOQtailClient.new} to establish a connection and perform MOQT operations such as subscribing to tracks,
+ * fetching historical data, announcing tracks for publication, and managing session lifecycle.
+ *
+ * Once initialized, the client provides high-level methods for MOQT requests and publishing. If a protocol violation
+ * occurs, the client will terminate and must be re-initialized.
+ *
+ * ## Usage
+ *
+ * ### Connect and Subscribe to a Track
+ * ```ts
+ * const client = await MOQtailClient.new({ url, supportedVersions: [0xff00000b] });
+ * const result = await client.subscribe({
+ *   fullTrackName,
+ *   filterType: FilterType.LatestObject,
+ *   forward: true,
+ *   groupOrder: GroupOrder.Original,
+ *   priority: 0
+ * });
+ * if (!(result instanceof SubscribeError)) {
+ *   for await (const object of result.stream) {
+ *     // Consume MOQT objects
+ *   }
+ * }
+ * ```
+ *
+ * ### Publish a namespace for Publishing
+ * ```ts
+ * const client = await MOQtailClient.new({ url, supportedVersions: [0xff00000b] });
+ * const publishNamespaceResult = await client.publishNamespace(["camera", "main"]);
+ * if (!(publishNamespaceResult instanceof PublishNamespaceError)) {
+ *   // Ready to publish objects under this namespace
+ * }
+ * ```
+ *
+ * ### Graceful Shutdown
+ * ```ts
+ * await client.disconnect();
+ * ```
+ */
+declare class MOQtailClient {
+    #private;
+    /**
+     * Namespace prefixes (tuples) the peer has requested announce notifications for via SUBSCRIBE_NAMESPACE.
+     * Used to decide which locally issued ANNOUNCE messages should be forwarded (future optimization: prefix trie).
+     */
+    readonly peerSubscribeNamespace: Set<Tuple>;
+    /**
+     * Namespace prefixes this client has subscribed to (issued SUBSCRIBE_NAMESPACE). Enables automatic filtering
+     * of incoming PUBLISH_NAMESPACE / PUBLISH_NAMESPACE_DONE. Maintained locally; no dedupe of overlapping / shadowing prefixes yet.
+     */
+    readonly subscribedAnnounces: Set<Tuple>;
+    /**
+     * Track namespaces this client has successfully announced (received ANNOUNCE_OK). Source of truth for
+     * deciding what to PUBLISH_NAMESPACE_DONE on teardown or targeted withdrawal.(future optimization: prefix trie).
+     */
+    readonly announcedNamespaces: Set<Tuple>;
+    /**
+     * Locally registered track definitions keyed by full track name string. Populated via addOrUpdateTrack.
+     * Does not imply the track has been announced or has active publications.
+     */
+    readonly trackSources: Map<string, Track>;
+    /**
+     * All in‑flight request objects keyed by requestId (SUBSCRIBE, FETCH, ANNOUNCE, etc). Facilitates lookup
+     * when responses / data arrive. Entries are removed on completion or error.
+     */
+    readonly requests: Map<bigint, MOQtailRequest>;
+    /**
+     * Active publications (SUBSCRIBE or FETCH) keyed by requestId to manage object stream controllers and lifecycle.
+     * Subset / specialization view of `requests`.
+     */
+    readonly publications: Map<bigint, SubscribePublication | FetchPublication>;
+    /**
+     * Active SUBSCRIBE request wrappers keyed by track alias for rapid alias -\> subscription resolution during
+     * incoming unidirectional data handling.
+     */
+    readonly subscriptions: Map<bigint, SubscribeRequest>;
+    /**
+     * Bidirectional track alias \<-\> subscription requestId mapping
+     */
+    readonly subscriptionAliasMap: Map<bigint, bigint>;
+    /**
+     * Bidirectional requestId \<-\> full track name mapping to reconstruct metadata for incoming objects.
+     */
+    readonly requestIdMap: RequestIdMap;
+    /**
+     * Maps track aliases to full track names for quick resolution during data handling.
+     */
+    readonly aliasFullTrackNameMap: Map<bigint, FullTrackName>;
+    /**
+     * Pending state updates keyed by requestId and applied once a new track alias is seen.
+     * Used to avoid premature state updates.
+     */
+    readonly pendingStateUpdates: Map<bigint, (newTrackAlias: bigint) => boolean>;
+    /** Underlying WebTransport session (set after successful construction in MOQtailClient.new). */
+    webTransport: WebTransport;
+    /** Outgoing / incoming control message bidirectional stream wrapper. */
+    controlStream: ControlStream;
+    /** Timeout (ms) applied to reading incoming data streams; undefined =\> no explicit timeout. */
+    dataStreamTimeoutMs?: number;
+    /** Timeout (ms) for control stream read operations; undefined =\> no explicit timeout. */
+    controlStreamTimeoutMs?: number;
+    /** Optional highest request id allowed (enforced externally / via configuration). */
+    maxRequestId?: bigint;
+    /**
+     * TODO: onNamespaceAnnounced may be a better name
+     * Fired when an PUBLISH_NAMESPACE control message is processed for a track namespace.
+     * Use to update UI or trigger discovery logic.
+     * Discovery event.
+     */
+    onNamespacePublished?: (msg: PublishNamespace) => void;
+    /**
+     * Fired when an PUBLISH_NAMESPACE_DONE control message is processed for a namespace.
+     * Use to remove tracks from UI or stop discovery.
+     * Discovery event.
+     */
+    onNamespaceDone?: (msg: PublishNamespaceDone) => void;
+    /**
+     * Fired on GOAWAY reception signaling graceful session wind-down.
+     * Use to prepare for disconnect or cleanup.
+     * Lifecycle handler.
+     */
+    onGoaway?: (msg: GoAway) => void;
+    /**
+     * Fired if the underlying WebTransport session fails (ready → closed prematurely).
+     * Use to log or alert on transport errors.
+     * Lifecycle/error handler.
+     */
+    onWebTransportFail?: () => void;
+    /**
+     * Fired exactly once when the client transitions to terminated (disconnect).
+     * Use to clean up resources or notify user.
+     * Lifecycle handler.
+     */
+    onSessionTerminated?: (reason?: unknown) => void;
+    /**
+     * Invoked after each outbound control message is sent.
+     * Use for logging or analytics.
+     * Informational event.
+     */
+    onMessageSent?: (msg: ControlMessage) => void;
+    /**
+     * Invoked upon receiving each inbound control message before handling.
+     * Use for logging or debugging.
+     * Informational event.
+     */
+    onMessageReceived?: (msg: ControlMessage) => void;
+    /**
+     * Invoked for each decoded data object/header arriving on a uni stream (fetch or subgroup).
+     * Use to process or display incoming media/data.
+     * Informational event.
+     */
+    onDataReceived?: (data: SubgroupObject | SubgroupHeader | FetchObject | FetchHeader) => void;
+    /**
+     * Invoked after enqueuing each outbound data object/header.
+     * Reserved for future use.
+     * Informational event.
+     */
+    onDataSent?: (data: SubgroupObject | SubgroupHeader | FetchObject | FetchHeader) => void;
+    /**
+     * General-purpose error callback for surfaced exceptions not thrown to caller synchronously.
+     * Use to log or display errors.
+     * Error handler.
+     */
+    onError?: (er: unknown) => void;
+    /** Invoked for each decoded datagram object/status arriving. */
+    onDatagramReceived?: (data: DatagramObject | DatagramStatus) => void;
+    /** Invoked after enqueuing each outbound datagram object/status. */
+    onDatagramSent?: (data: DatagramObject | DatagramStatus) => void;
+    /**
+     * Stream of all received MoqtObjects from datagrams across all tracks
+     * Consumer should filter by fullTrackName as needed
+     *
+     * WARNING: Only one reader should be active. For multiple subscribers,
+     * use subscribeToTrackDatagrams() instead
+     */
+    readonly receivedDatagramObjects: ReadableStream<MoqtObject>;
+    /**
+     * Gets the current server setup configuration.
+     *
+     * @returns The {@link ServerSetup} instance associated with this client.
+     */
+    get serverSetup(): ServerSetup;
+    /**
+     * Returns true if datagram support is currently active
+     */
+    get isDatagramsEnabled(): boolean;
+    private constructor();
+    /**
+     * Establishes a new {@link MOQtailClient} session over WebTransport and performs the MOQT setup handshake.
+     *
+     * @param args - {@link MOQtailClientOptions}
+     *
+     * @returns Promise resolving to a ready {@link MOQtailClient} instance.
+     *
+     * @throws :{@link ProtocolViolationError} If the server sends an unexpected or invalid message during setup.
+     *
+     * @example Minimal connection
+     * ```ts
+     * const client = await MOQtailClient.new({
+     *   url: 'https://relay.example.com/transport',
+     *   supportedVersions: [0xff00000b]
+     * });
+     * ```
+     *
+     * @example With callbacks and options
+     * ```ts
+     * const client = await MOQtailClient.new({
+     *   url,
+     *   supportedVersions: [0xff00000b],
+     *   setupParameters: new SetupParameters().addMaxRequestId(1000),
+     *   transportOptions: { congestionControl: 'default' },
+     *   dataStreamTimeoutMs: 5000,
+     *   controlStreamTimeoutMs: 2000,
+     *   enableDatagrams: true,
+     *   callbacks: {
+     *     onMessageSent: msg => console.log('Sent:', msg),
+     *     onMessageReceived: msg => console.log('Received:', msg),
+     *     onSessionTerminated: reason => console.warn('Session ended:', reason),
+     *     onDatagramReceived: data => console.log('Datagram:', data),
+     *   }
+     * });
+     * ```
+     */
+    static new(args: MOQtailClientOptions): Promise<MOQtailClient>;
+    /**
+     * Start receiving datagrams from the WebTransport connection.
+     * Must be called before datagrams can be received (unless enableDatagrams: true was set in options).
+     *
+     * @throws MOQtailError if client is destroyed or datagrams already started
+     */
+    startDatagrams(): Promise<void>;
+    /**
+     * Stop receiving datagrams and release resources.
+     * Idempotent - safe to call multiple times.
+     */
+    stopDatagrams(): Promise<void>;
+    /**
+     * Subscribe to receive datagrams for a specific track.
+     * Multiple tracks can have separate handlers that run concurrently.
+     *
+     * @param trackAlias - Track alias to subscribe to
+     * @param handler - Function called for each received MoqtObject on this track
+     * @returns Unsubscribe function to remove the handler
+     *
+     * @example
+     * ```ts
+     * const unsubscribe = client.subscribeToTrackDatagrams(trackAlias, (obj) => {
+     *   console.log('Received datagram:', obj.payload);
+     * });
+     * // Later: unsubscribe();
+     * ```
+     */
+    subscribeToTrackDatagrams(trackAlias: bigint, handler: (obj: MoqtObject) => void): () => void;
+    /**
+     * Unsubscribe from datagram delivery for a specific track.
+     *
+     * @param trackAlias - Track alias to unsubscribe from
+     */
+    unsubscribeFromTrackDatagrams(trackAlias: bigint): void;
+    /**
+     * Create a datagram sender for a specific track.
+     *
+     * @param trackAlias - Track alias for outgoing datagrams
+     * @returns SendDatagramStream for writing MoqtObjects as datagrams
+     * @throws MOQtailError if datagram writer not initialized (call startDatagrams() first)
+     *
+     * @example
+     * ```ts
+     * const sender = client.createDatagramSender(trackAlias);
+     * await sender.write(moqtObject);
+     * ```
+     */
+    createDatagramSender(trackAlias: bigint): SendDatagramStream;
+    /**
+     * Send a single MoqtObject as a datagram.
+     * Convenience method for one-off datagram sends.
+     *
+     * @param trackAlias - Track alias for this object
+     * @param object - MoqtObject to send
+     * @throws MOQtailError if datagram writer not initialized
+     *
+     * @example
+     * ```ts
+     * await client.sendDatagram(trackAlias, moqtObject);
+     * ```
+     */
+    sendDatagram(trackAlias: bigint, object: MoqtObject): Promise<void>;
+    /**
+     * Gracefully terminates this {@link MOQtailClient} session and releases underlying {@link https://developer.mozilla.org/docs/Web/API/WebTransport | WebTransport} resources.
+     *
+     * @param reason - Optional application-level reason (string or error) recorded and wrapped in an {@link InternalError}
+     * passed to the {@link MOQtailClient.onSessionTerminated | onSessionTerminated} callback.
+     *
+     * @returns Promise that resolves once shutdown logic completes. Subsequent calls are safe no-ops.
+     *
+     * @example Basic usage
+     * ```ts
+     * await client.disconnect();
+     * ```
+     *
+     * @example With reason
+     * ```ts
+     * await client.disconnect('user logout');
+     * ```
+     *
+     * @example Idempotent double call
+     * ```ts
+     * await client.disconnect();
+     * await client.disconnect(); // no error
+     * ```
+     *
+     * @example Page unload safety
+     * ```ts
+     * window.addEventListener('beforeunload', () => {
+     *   client.disconnect('page unload');
+     * });
+     * ```
+     */
+    disconnect(reason?: unknown): Promise<void>;
+    /**
+     * Registers or updates a {@link Track} definition for local publishing or serving.
+     *
+     * A {@link Track} describes a logical media/data stream, identified by a unique name and namespace.
+     * - If `trackSource.live` is present, the track can be served to subscribers in real-time.
+     * - If `trackSource.past` is present, the track can be fetched for historical data.
+     * - If both are present, the track supports both live and historical access.
+     *
+     * @param track - The {@link Track} instance to add or update. See {@link TrackSource} for live/past source options.
+     * @returns void
+     * @throws : {@link MOQtailError} If the client has been destroyed.
+     *
+     * @example Create a live video track from getUserMedia
+     * ```ts
+     * const stream = await navigator.mediaDevices.getUserMedia({ video: true });
+     * const videoTrack = stream.getVideoTracks()[0];
+     *
+     * // Convert video frames to MoqtObject instances using your chosen scheme (e.g. WARP, CMAF, etc.)
+     * // This part is application-specific and not provided by MOQtail:
+     * const liveReadableStream: ReadableStream<MoqtObject> = ...
+     *
+     * // Register the track for live subscription
+     * client.addOrUpdateTrack({
+     *   fullTrackName: { namespace: ["camera"], name: "main" },
+     *   forwardingPreference: ObjectForwardingPreference.Latest,
+     *   trackSource: { live: liveReadableStream },
+     *   publisherPriority: 0 // highest priority
+     * });
+     *
+     * // For a hybrid track (live + past):
+     * import { MemoryObjectCache } from './track/object_cache';
+     * const cache = new MemoryObjectCache(); // Caches are not yet fully supported
+     * client.addOrUpdateTrack({
+     *   fullTrackName: { namespace: ["camera"], name: "main" },
+     *   forwardingPreference: ObjectForwardingPreference.Latest,
+     *   trackSource: { live: liveReadableStream, past: cache },
+     *   publisherPriority: 8
+     * });
+     * ```
+     */
+    addOrUpdateTrack(track: Track): void;
+    /**
+     * Removes a previously registered {@link Track} from this client's local catalog.
+     *
+     * This deletes the in-memory entry inserted via {@link MOQtailClient.addOrUpdateTrack}, so future lookups by its {@link Track.fullTrackName} will fail.
+     * Does **not** automatically:
+     * - Send an {@link PublishNamespaceDone} (call {@link MOQtailClient.publishNamespaceDone} separately if you want to inform peers)
+     * - Cancel active subscriptions or fetches (they continue until normal completion)
+     * - Affect already-sent objects.
+     *
+     * If the track was not present, the call is a silent no-op (idempotent removal).
+     *
+     * @param track - The exact {@link Track} instance (its canonical name is used as the key).
+     * @throws : {@link MOQtailError} If the client has been destroyed.
+     *
+     * @example
+     * ```ts
+     * // Register a track
+     * client.addOrUpdateTrack(track);
+     *
+     * // Later, when no longer publishing:
+     * client.removeTrack(track);
+     *
+     * // Optionally, inform peers that the namespace is no longer available:
+     * await client.publishNamespaceDone(track.fullTrackName.namespace);
+     * ```
+     */
+    removeTrack(track: Track): void;
+    /**
+     * Subscribes to a track and returns a stream of {@link MoqtObject}s matching the requested window and relay forwarding mode.
+     *
+     * - `forward: true` tells the relay to forward objects to this subscriber as they arrive.
+     * - `forward: false` means the relay subscribes upstream but buffers objects locally, not forwarding them to you.
+     * - `filterType: AbsoluteStart` lets you specify a start position in the future; the stream waits for that object. If the start location is \< the latest object
+     * observed at the publisher then it behaves as `filterType: LatestObject`
+     * - `filterType: AbsoluteRange` lets you specify a start and end group, both of should be in the future; the stream waits for those objects. If the start location is \< the latest object
+     * observed at the publisher then it behaves as `filterType: LatestObject`.
+     *
+     * The method returns either a {@link SubscribeError} (on refusal) or an object with the subscription `requestId` and a `ReadableStream` of {@link MoqtObject}s.
+     * Use the `requestId` for {@link MOQtailClient.unsubscribe} or {@link MOQtailClient.subscribeUpdate}. Use the `stream` to decode and display objects.
+     *
+     * @param args - {@link SubscribeOptions} describing the subscription window and relay forwarding behavior.
+     * @returns Either a {@link SubscribeError} or `{ requestId, stream }` for consuming objects.
+     * @throws : {@link MOQtailError} If the client is destroyed.
+     * @throws : {@link ProtocolViolationError} If required fields are missing or inconsistent.
+     * @throws : {@link InternalError} On transport/protocol failure (disconnect is triggered before rethrow).
+     *
+     * @example Subscribe to the latest object and receive future objects as they arrive
+     * ```ts
+     * const result = await client.subscribe({
+     *   fullTrackName,
+     *   filterType: FilterType.LatestObject,
+     *   forward: true,
+     *   groupOrder: GroupOrder.Original,
+     *   priority: 32
+     * });
+     * if (!(result instanceof SubscribeError)) {
+     *   for await (const obj of result.stream) {
+     *     // decode and display obj
+     *   }
+     * }
+     * ```
+     *
+     * @example Subscribe to a future range (waits for those objects to arrive)
+     * ```ts
+     * const result = await client.subscribe({
+     *   fullTrackName,
+     *   filterType: FilterType.AbsoluteRange,
+     *   startLocation: futureStart,
+     *   endGroup: futureEnd,
+     *   forward: true,
+     *   groupOrder: GroupOrder.Original,
+     *   priority: 128
+     * });
+     * ```
+     */
+    subscribe(args: SubscribeOptions): Promise<SubscribeError | {
+        requestId: bigint;
+        stream: ReadableStream<MoqtObject>;
+    }>;
+    /**
+     * Stops an active subscription identified by its original SUBSCRIBE `requestId`.
+     *
+     * Sends an {@link Unsubscribe} control frame if the subscription is still active. If the id is unknown or already
+     * cleaned up, the call is a silent no-op (hence multiple calls are idempotent).
+     *
+     * Use this when you no longer want incoming objects for a track (e.g. user navigated away, switching quality).
+     * Canceling the consumer stream reader does **not** auto-unsubscribe; call this explicitly for prompt cleanup.
+     *
+     * @param requestId - The id returned from {@link MOQtailClient.subscribe}.
+     * @returns Promise that resolves when the unsubscribe control frame is sent.
+     * @throws :{@link MOQtailError} If the client is destroyed.
+     * @throws :{@link InternalError} Wrapped lower-level failure while attempting to send (session will be disconnected first).
+     *
+     * @remarks
+     * - Only targets SUBSCRIBE requests, not fetches. Passing a fetch request id is ignored (no-op).
+     * - Safe to call multiple times; extra calls have no effect.
+     *
+     * @example Subscribe and later unsubscribe
+     * ```ts
+     * const sub = await client.subscribe({ fullTrackName, filterType: FilterType.LatestObject, forward: true, groupOrder: GroupOrder.Original, priority: 0 });
+     * if (!(sub instanceof SubscribeError)) {
+     *   // ...consume objects...
+     *   await client.unsubscribe(sub.requestId);
+     * }
+     * ```
+     *
+     * @example Idempotent usage
+     * ```ts
+     * await client.unsubscribe(123n);
+     * await client.unsubscribe(123n); // no error
+     * ```
+     */
+    unsubscribe(requestId: bigint | number): Promise<void>;
+    /**
+     * Narrows or updates an active subscription window and/or relay forwarding behavior.
+     *
+     * Use this to:
+     * - Move the start of the subscription forward (trim history or future window).
+     * - Move the end group earlier (shorten the window).
+     * - Change relay forwarding (`forward: false` stops forwarding new objects, `true` resumes).
+     * - Adjust subscriber priority.
+     *
+     * Only narrowing is allowed: you cannot move the start earlier or the end group later than the original subscription.
+     * Forwarding and priority can be changed at any time.
+     *
+     * @param args - {@link SubscribeUpdateOptions} referencing the original subscription `requestId` and new bounds.
+     * @returns Promise that resolves when the update control frame is sent.
+     * @throws :{@link MOQtailError} If the client is destroyed.
+     * @throws :{@link ProtocolViolationError} If the update would widen the window (earlier start, later end group, or invalid ordering).
+     * @throws :{@link InternalError} On transport/control failure (disconnect is triggered before rethrow).
+     *
+     * @remarks
+     * - Only applies to active SUBSCRIBE requests; ignored if the request is not a subscription.
+     * - Omitting a parameter (e.g. `priority`) leaves the previous value unchanged.
+     * - Setting `forward: false` stops relay forwarding new objects after the current window drains.
+     * - Safe to call multiple times; extra calls with unchanged bounds have no effect.
+     *
+     * @example Trim start forward
+     * ```ts
+     * await client.subscribeUpdate({ requestId, startLocation: laterLoc, endGroup, forward: true, priority });
+     * ```
+     *
+     * @example Convert tailing subscription into bounded slice
+     * ```ts
+     * await client.subscribeUpdate({ requestId, startLocation: origStart, endGroup: cutoffGroup, forward: false, priority });
+     * ```
+     *
+     * @example Lower priority only
+     * ```ts
+     * await client.subscribeUpdate({ requestId, startLocation: currentStart, endGroup: currentEnd, forward: true, priority: 200 });
+     * ```
+     */
+    subscribeUpdate(args: SubscribeUpdateOptions): Promise<void>;
+    /**
+     * Switches an active subscription to a different track while retaining the same subscription parameters.
+     *
+     * Use this to change the subscribed track without tearing down and re-establishing a new subscription.
+     *
+     * @param args - {@link SwitchOptions} referencing the original subscription `requestId` and new track name.
+     * @returns Promise that resolves when the switch control frame is sent.
+     * @throws :{@link MOQtailError} If the client is destroyed.
+     * @throws :{@link InternalError} On transport/control failure (disconnect is triggered before rethrow).
+     *
+     * @remarks
+     * - Only applies to active SUBSCRIBE requests; ignored if the request is not a subscription.
+     * - All other subscription parameters (window, forwarding, priority) remain unchanged.
+     *
+     * @example Switch to a different track
+     * ```ts
+     * await client.switch({ subscriptionRequestId, fullTrackName: newTrackName });
+     * ```
+     */
+    switch(args: SwitchOptions): Promise<SubscribeError | {
+        requestId: bigint;
+        stream: ReadableStream<MoqtObject>;
+    }>;
+    /**
+     * One-shot retrieval of a bounded object span, optionally anchored to an existing subscription, returning a stream of {@link MoqtObject}s.
+     *
+     * Choose a fetch type via `typeAndProps.type`:
+     * - StandAlone: Historical slice of a specific {@link FullTrackName} independent of active subscriptions.
+     * - Relative: Range relative to the JOINING subscription's current (largest) location; use when you want "N groups back" from live.
+     * - Absolute: Absolute group/object offsets tied to an existing subscription (stable anchor) even if that subscription keeps forwarding.
+     *
+     * Field highlights (in {@link FetchOptions}):
+     * - priority: 0 (highest) .. 255 (lowest); out-of-range rejected; non-integers rounded by caller expectation.
+     * - groupOrder: {@link GroupOrder.Original} to preserve publisher order; or reorder ascending/descending if supported by server.
+     * - typeAndProps: Discriminated union carrying parameters specific to each fetch mode (see examples).
+     * - parameters: Optional version-specific extension block.
+     *
+     * Returns either a {@link FetchError} (refusal / invalid request at protocol level) or `{ requestId, stream }` whose `stream`
+     * ends naturally after the bounded range completes (no explicit cancel needed for normal completion).
+     *
+     * Use cases:
+     * - Grab a historical window for scrubbing UI while a separate live subscription tails.
+     * - Late joiner fetching a short back-buffer then discarding the stream.
+     * - Analytics batch job pulling a fixed slice without subscribing long-term.
+     *
+     * @throws MOQtailError If client is destroyed.
+     * @throws ProtocolViolationError Priority out of [0-255] or missing/invalid joining subscription id for Relative/Absolute.
+     * @throws InternalError Transport/control failure (the client disconnects first) then rethrows original error.
+     *
+     * @remarks
+     * - Relative / Absolute require an existing active SUBSCRIBE `joiningRequestId`; if not found a {@link ProtocolViolationError} is thrown.
+     * - Result stream is finite; reader close occurs automatically when last object delivered.
+     * - Use {@link MOQtailClient.fetchCancel} only for early termination (not yet fully implemented: see TODO in code).
+     *
+     * @example Standalone window
+     * ```ts
+     * const r = await client.fetch({
+     *   priority: 64,
+     *   groupOrder: GroupOrder.Original,
+     *   typeAndProps: {
+     *     type: FetchType.StandAlone,
+     *     props: { fullTrackName, startLocation, endLocation }
+     *   }
+     * })
+     * if (!(r instanceof FetchError)) {
+     *   for await (const obj of r.stream as any) {
+     *     // consume objects then stream ends automatically
+     *   }
+     * }
+     * ```
+     *
+     * @example Relative to live subscription (e.g. last 5 groups)
+     * ```ts
+     * const sub = await client.subscribe({ fullTrackName, filterType: FilterType.LatestObject, forward: true, groupOrder: GroupOrder.Original, priority: 0 })
+     * if (!(sub instanceof SubscribeError)) {
+     *   const slice = await client.fetch({
+     *     priority: 32,
+     *     groupOrder: GroupOrder.Original,
+     *     typeAndProps: { type: FetchType.Relative, props: { joiningRequestId: sub.requestId, joiningStart: 0n } }
+     *   })
+     * }
+     * ```
+     */
+    fetch(args: FetchOptions): Promise<FetchError | {
+        requestId: bigint;
+        stream: ReadableStream<MoqtObject>;
+    }>;
+    /**
+     * Request early termination of an in‑flight FETCH identified by its `requestId`.
+     *
+     * Use when the consumer no longer needs the remaining objects (user scrubbed away, UI panel closed, replaced by a new fetch).
+     * Sends a {@link FetchCancel} control frame if the id currently maps to an active fetch; otherwise silent no-op (idempotent).
+     *
+     * Parameter semantics:
+     * - requestId: bigint returned from {@link MOQtailClient.fetch}. Numbers auto-converted to bigint.
+     *
+     * Current behavior / limitations:
+     * - Data stream closure after cancel is TODO (objects may still arrive briefly).
+     * - Unknown / already finished request: ignored without error.
+     * - Only targets FETCH requests (not subscriptions).
+     *
+     * @throws MOQtailError If client is destroyed.
+     * @throws InternalError Failure while sending the cancel (client disconnects first).
+     *
+     * @remarks
+     * Follow-up improvement planned: actively close associated readable stream controller immediately upon acknowledgment.
+     *
+     * @example Cancel shortly after starting
+     * ```ts
+     * const r = await client.fetch({ priority: 32, groupOrder: GroupOrder.Original, typeAndProps: { type: FetchType.StandAlone, props: { fullTrackName, startLocation, endLocation } } })
+     * if (!(r instanceof FetchError)) {
+     *   // user navigated away
+     *   await client.fetchCancel(r.requestId)
+     * }
+     * ```
+     *
+     * @example Idempotent double cancel
+     * ```ts
+     * await client.fetchCancel(456n)
+     * await client.fetchCancel(456n) // no error
+     * ```
+     */
+    fetchCancel(requestId: bigint | number): Promise<void>;
+    /**
+     * Declare (publish) a track namespace to the peer so subscribers using matching prefixes (via {@link MOQtailClient.subscribeNamespace})
+     * can discover and begin subscribing/fetching its tracks.
+     *
+     * Typical flow (publisher side):
+     * 1. Prepare / register one or more {@link Track} objects locally (see {@link MOQtailClient.addOrUpdateTrack}).
+     * 2. Call `publishNamespace(namespace)` once per namespace prefix to expose those tracks.
+     * 3. Later, call {@link MOQtailClient.publishNamespaceDone} when no longer publishing under that namespace.
+     *
+     * Parameter semantics:
+     * - trackNamespace: Tuple representing the namespace prefix (e.g. ["camera","main"]). All tracks whose full names start with this tuple are considered within the announce scope.
+     * - parameters: Optional {@link VersionSpecificParameters}; omitted =\> default instance.
+     *
+     * Returns: {@link PublishNamespaceOk} on success (namespace added to `announcedNamespaces`) or {@link PublishNamespaceError} explaining refusal.
+     *
+     * Use cases:
+     * - Make a camera or sensor namespace available before any objects are pushed.
+     * - Dynamically expose a newly created room / session namespace.
+     * - Re-announce after reconnect to repopulate discovery state.
+     *
+     * @throws MOQtailError If client is destroyed.
+     * @throws InternalError Transport/control failure while sending or awaiting response (client disconnects first).
+     *
+     * @remarks
+     * - Duplicate announce detection is TODO (currently a second call will still send another PUBLISH_NAMESPACE; receiver behavior may vary).
+     * - Successful announces are tracked in `announcedNamespaces`; manual removal occurs via {@link MOQtailClient.publishNamespaceDone}.
+     * - Discovery subscribers (those who issued {@link MOQtailClient.subscribeNamespace}) will receive the resulting {@link PublishNamespace} message.
+     *
+     * @example Minimal announce
+     * ```ts
+     * const res = await client.publishNamespace(["camera","main"])
+     * if (res instanceof PublishNamespaceOk) {
+     *   // ready to publish objects under tracks with this namespace prefix
+     * }
+     * ```
+     *
+     * @example PublishNamespace with parameters block
+     * ```ts
+     * const params = new VersionSpecificParameters().setSomeExtensionFlag(true)
+     * const resp = await client.publishNamespace(["room","1234"], params)
+     * ```
+     */
+    publishNamespace(trackNamespace: Tuple, parameters?: VersionSpecificParameters): Promise<PublishNamespaceError | PublishNamespaceOk>;
+    /**
+     * Withdraw a previously announced namespace so new subscribers no longer discover its tracks.
+     *
+     * Use when shutting down publishing for a logical scope (camera offline, room closed, session ended).
+     * Removes the namespace from `announcedNamespaces` locally and sends an {@link PublishNamespaceDone} control frame.
+     *
+     * Parameter semantics:
+     * - trackNamespace: Exact tuple used during {@link MOQtailClient.publishNamespace}. Must match to be removed from internal set.
+     *
+     * Behavior:
+     * - Does not delete locally registered {@link Track} objects (they remain in `trackSources`).
+     * - Does not forcibly end active subscriptions that were already established; peers simply stop discovering it for new ones.
+     * - Silent if the namespace was not currently recorded (idempotent style).
+     *
+     * @throws MOQtailError If client is destroyed before sending.
+     * @throws (rethrows original error) Any lower-level failure while sending results in a disconnect (unwrapped TODO: future wrap with InternalError for consistency).
+     *
+     * @remarks
+     * Peers that issued {@link MOQtailClient.subscribeNamespace} for a matching prefix should receive the resulting {@link PublishNamespaceDone}.
+     * Consider calling this before {@link MOQtailClient.disconnect} to give consumers prompt notice.
+     *
+     * @example Basic usage
+     * ```ts
+     * await client.publishNamespaceDone(["camera","main"])
+     * ```
+     *
+     * @example Idempotent
+     * ```ts
+     * await client.publishNamespaceDone(["camera","main"]) // first time
+     * await client.publishNamespaceDone(["camera","main"]) // no error, already removed
+     * ```
+     */
+    publishNamespaceDone(trackNamespace: Tuple): Promise<void>;
+    /**
+     * Send an {@link PublishNamespaceCancel} to abort a previously issued ANNOUNCE before (or after) the peer fully processes it.
+     *
+     * Use when an announce was sent prematurely (e.g. validation failed locally, namespace no longer needed) and you want
+     * to retract it without waiting for normal announce lifecycle or before publishing any objects.
+     *
+     * Parameter semantics:
+     * - msg: Pre-constructed {@link PublishNamespaceCancel} referencing the original announce request id / namespace (builder provided elsewhere).
+     *
+     * Behavior:
+     * - Simply forwards the control frame; does not modify `announcedNamespaces` (call {@link MOQtailClient.publishNamespaceDone} for local bookkeeping removal).
+     * - Safe to send even if the announce already succeeded; peer may ignore duplicates per spec guidance.
+     *
+     * @throws MOQtailError If client is destroyed.
+     * @throws InternalError Wrapped transport/control send failure (client disconnects first) then rethrows.
+     *
+     * @remarks
+     * Use in tandem with internal tracking if you want to prevent subsequent object publication until a new announce is issued.
+     *
+     * @example Cancel immediately after a mistaken announce
+     * ```ts
+     * const publishNamespaceResp = await client.publishNamespace(["camera","temp"]) // wrong namespace
+     * // Assume you kept the original announce requestId (e.g. from PublishNamespaceRequest)
+     * const cancelMsg = new PublishNamespaceCancel(publishNamespaceResp.requestId as bigint)
+     * await client.publishNamespaceCancel(cancelMsg)
+     * ```
+     */
+    publishNamespaceCancel(msg: PublishNamespaceCancel): Promise<void>;
+    subscribeNamespace(msg: SubscribeNamespace): Promise<void>;
+    unsubscribeNamespace(msg: UnsubscribeNamespace): Promise<void>;
+}
+
+/**
+ * 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 SendStream {
+    #private;
+    readonly header: Header;
+    readonly onDataSent?: (data: SubgroupObject | SubgroupHeader | FetchObject | FetchHeader) => void;
+    private constructor();
+    static new(writeStream: WritableStream<Uint8Array>, header: Header, onDataSent?: (data: SubgroupObject | SubgroupHeader | FetchObject | FetchHeader) => void): Promise<SendStream>;
+    write(object: FetchObject | SubgroupObject): Promise<void>;
+    close(): Promise<void>;
+}
+declare class RecvStream {
+    #private;
+    readonly header: Header;
+    readonly stream: ReadableStream<FetchObject | SubgroupObject>;
+    readonly onDataReceived?: (data: SubgroupObject | SubgroupHeader | FetchObject | FetchHeader) => void;
+    private constructor();
+    static new(readStream: ReadableStream<Uint8Array>, partialDataTimeout?: number, onDataReceived?: (data: SubgroupObject | SubgroupHeader | FetchObject | FetchHeader) => void): Promise<RecvStream>;
+}
+
+export { ControlStream, type FetchOptions, FetchPublication, FetchRequest, HybridTrackSource, type LiveObjectSource, LiveTrackSource, MOQtailClient, type MOQtailClientOptions, type MOQtailRequest, MemoryObjectCache, type ObjectCache, type PastObjectSource, PublishNamespaceRequest, RecvDatagramStream, RecvStream, RingBufferObjectCache, SendDatagramStream, SendStream, StaticTrackSource, SubscribeNamespaceRequest, type SubscribeOptions, SubscribePublication, SubscribeRequest, type SubscribeUpdateOptions, type SwitchOptions, type Track, type TrackSource };