livekit-client 2.22.2 → 2.22.4

package/dist/ts4.2/room/data-track/packet/errors.d.ts

@@ -1,40 +1,40 @@
-import { LivekitReasonedError } from '../../errors';
-import type { DataTrackHandleError } from '../handle';
-export declare enum DataTrackDeserializeErrorReason {
-    TooShort = 0,
-    HeaderOverrun = 1,
-    MissingExtWords = 2,
-    UnsupportedVersion = 3,
-    InvalidHandle = 4,
-    MalformedExt = 5
-}
-export declare class DataTrackDeserializeError<Reason extends DataTrackDeserializeErrorReason = DataTrackDeserializeErrorReason> extends LivekitReasonedError<DataTrackDeserializeErrorReason> {
-    readonly name = "DataTrackDeserializeError";
-    reason: Reason;
-    reasonName: string;
-    cause?: Reason extends DataTrackDeserializeErrorReason.InvalidHandle ? DataTrackHandleError : never;
-    constructor(message: string, reason: Reason, options?: {
-        cause?: unknown;
-    });
-    static tooShort(): DataTrackDeserializeError<DataTrackDeserializeErrorReason.TooShort>;
-    static headerOverrun(): DataTrackDeserializeError<DataTrackDeserializeErrorReason.HeaderOverrun>;
-    static missingExtWords(): DataTrackDeserializeError<DataTrackDeserializeErrorReason.MissingExtWords>;
-    static unsupportedVersion(version: number): DataTrackDeserializeError<DataTrackDeserializeErrorReason.UnsupportedVersion>;
-    static invalidHandle(cause: DataTrackHandleError): DataTrackDeserializeError<DataTrackDeserializeErrorReason.InvalidHandle>;
-    static malformedExt(tag: number): DataTrackDeserializeError<DataTrackDeserializeErrorReason.MalformedExt>;
-}
-export declare enum DataTrackSerializeErrorReason {
-    TooSmallForHeader = 0,
-    TooSmallForPayload = 1
-}
-export declare class DataTrackSerializeError<Reason extends DataTrackSerializeErrorReason = DataTrackSerializeErrorReason> extends LivekitReasonedError<DataTrackSerializeErrorReason> {
-    readonly name = "DataTrackSerializeError";
-    reason: Reason;
-    reasonName: string;
-    constructor(message: string, reason: Reason, options?: {
-        cause?: unknown;
-    });
-    static tooSmallForHeader(): DataTrackSerializeError<DataTrackSerializeErrorReason.TooSmallForHeader>;
-    static tooSmallForPayload(): DataTrackSerializeError<DataTrackSerializeErrorReason.TooSmallForPayload>;
-}
-//# sourceMappingURL=errors.d.ts.map
+import { LivekitReasonedError } from '../../errors';
+import type { DataTrackHandleError } from '../handle';
+export declare enum DataTrackDeserializeErrorReason {
+    TooShort = 0,
+    HeaderOverrun = 1,
+    MissingExtWords = 2,
+    UnsupportedVersion = 3,
+    InvalidHandle = 4,
+    MalformedExt = 5
+}
+export declare class DataTrackDeserializeError<Reason extends DataTrackDeserializeErrorReason = DataTrackDeserializeErrorReason> extends LivekitReasonedError<DataTrackDeserializeErrorReason> {
+    readonly name = "DataTrackDeserializeError";
+    reason: Reason;
+    reasonName: string;
+    cause?: Reason extends DataTrackDeserializeErrorReason.InvalidHandle ? DataTrackHandleError : never;
+    constructor(message: string, reason: Reason, options?: {
+        cause?: unknown;
+    });
+    static tooShort(): DataTrackDeserializeError<DataTrackDeserializeErrorReason.TooShort>;
+    static headerOverrun(): DataTrackDeserializeError<DataTrackDeserializeErrorReason.HeaderOverrun>;
+    static missingExtWords(): DataTrackDeserializeError<DataTrackDeserializeErrorReason.MissingExtWords>;
+    static unsupportedVersion(version: number): DataTrackDeserializeError<DataTrackDeserializeErrorReason.UnsupportedVersion>;
+    static invalidHandle(cause: DataTrackHandleError): DataTrackDeserializeError<DataTrackDeserializeErrorReason.InvalidHandle>;
+    static malformedExt(tag: number): DataTrackDeserializeError<DataTrackDeserializeErrorReason.MalformedExt>;
+}
+export declare enum DataTrackSerializeErrorReason {
+    TooSmallForHeader = 0,
+    TooSmallForPayload = 1
+}
+export declare class DataTrackSerializeError<Reason extends DataTrackSerializeErrorReason = DataTrackSerializeErrorReason> extends LivekitReasonedError<DataTrackSerializeErrorReason> {
+    readonly name = "DataTrackSerializeError";
+    reason: Reason;
+    reasonName: string;
+    constructor(message: string, reason: Reason, options?: {
+        cause?: unknown;
+    });
+    static tooSmallForHeader(): DataTrackSerializeError<DataTrackSerializeErrorReason.TooSmallForHeader>;
+    static tooSmallForPayload(): DataTrackSerializeError<DataTrackSerializeErrorReason.TooSmallForPayload>;
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/ts4.2/room/data-track/packet/extensions.d.ts

@@ -1,69 +1,69 @@
-import type { Throws } from '@livekit/throws-transformer/throws';
-import type { NonSharedUint8Array } from '../../../type-polyfills/non-shared-typed-arrays';
-import { DataTrackDeserializeError, DataTrackDeserializeErrorReason } from './errors';
-import Serializable from './serializable';
-export declare enum DataTrackExtensionTag {
-    UserTimestamp = 2,
-    E2ee = 1
-}
-declare abstract class DataTrackExtension extends Serializable {
-    static tag: DataTrackExtensionTag;
-    static lengthBytes: number;
-}
-export declare class DataTrackUserTimestampExtension extends DataTrackExtension {
-    static tag: DataTrackExtensionTag;
-    static lengthBytes: number;
-    timestamp: bigint;
-    constructor(timestamp: bigint);
-    toBinaryLengthBytes(): number;
-    toBinaryInto(dataView: DataView): Throws<number, never>;
-    toJSON(): {
-        tag: number;
-        lengthBytes: number;
-        timestamp: bigint;
-    };
-}
-export declare class DataTrackE2eeExtension extends DataTrackExtension {
-    static tag: DataTrackExtensionTag;
-    static lengthBytes: number;
-    keyIndex: number;
-    iv: NonSharedUint8Array;
-    constructor(keyIndex: number, iv: NonSharedUint8Array);
-    toBinaryLengthBytes(): number;
-    toBinaryInto(dataView: DataView): Throws<number, never>;
-    toJSON(): {
-        tag: number;
-        lengthBytes: number;
-        keyIndex: number;
-        iv: Uint8Array<ArrayBuffer>;
-    };
-}
-export declare class DataTrackExtensions extends Serializable {
-    userTimestamp?: DataTrackUserTimestampExtension;
-    e2ee?: DataTrackE2eeExtension;
-    constructor(opts?: {
-        userTimestamp?: DataTrackUserTimestampExtension;
-        e2ee?: DataTrackE2eeExtension;
-    });
-    toBinaryLengthBytes(): number;
-    toBinaryInto(dataView: DataView): Throws<number, never>;
-    static fromBinary<Input extends DataView | ArrayBuffer | Uint8Array>(input: Input): Throws<[
-        extensions: DataTrackExtensions,
-        byteLength: number
-    ], DataTrackDeserializeError<DataTrackDeserializeErrorReason.MalformedExt>>;
-    toJSON(): {
-        userTimestamp: {
-            tag: number;
-            lengthBytes: number;
-            timestamp: bigint;
-        } | null;
-        e2ee: {
-            tag: number;
-            lengthBytes: number;
-            keyIndex: number;
-            iv: Uint8Array<ArrayBuffer>;
-        } | null;
-    };
-}
-export {};
-//# sourceMappingURL=extensions.d.ts.map
+import type { Throws } from '@livekit/throws-transformer/throws';
+import type { NonSharedUint8Array } from '../../../type-polyfills/non-shared-typed-arrays';
+import { DataTrackDeserializeError, DataTrackDeserializeErrorReason } from './errors';
+import Serializable from './serializable';
+export declare enum DataTrackExtensionTag {
+    UserTimestamp = 2,
+    E2ee = 1
+}
+declare abstract class DataTrackExtension extends Serializable {
+    static tag: DataTrackExtensionTag;
+    static lengthBytes: number;
+}
+export declare class DataTrackUserTimestampExtension extends DataTrackExtension {
+    static tag: DataTrackExtensionTag;
+    static lengthBytes: number;
+    timestamp: bigint;
+    constructor(timestamp: bigint);
+    toBinaryLengthBytes(): number;
+    toBinaryInto(dataView: DataView): Throws<number, never>;
+    toJSON(): {
+        tag: number;
+        lengthBytes: number;
+        timestamp: bigint;
+    };
+}
+export declare class DataTrackE2eeExtension extends DataTrackExtension {
+    static tag: DataTrackExtensionTag;
+    static lengthBytes: number;
+    keyIndex: number;
+    iv: NonSharedUint8Array;
+    constructor(keyIndex: number, iv: NonSharedUint8Array);
+    toBinaryLengthBytes(): number;
+    toBinaryInto(dataView: DataView): Throws<number, never>;
+    toJSON(): {
+        tag: number;
+        lengthBytes: number;
+        keyIndex: number;
+        iv: Uint8Array;
+    };
+}
+export declare class DataTrackExtensions extends Serializable {
+    userTimestamp?: DataTrackUserTimestampExtension;
+    e2ee?: DataTrackE2eeExtension;
+    constructor(opts?: {
+        userTimestamp?: DataTrackUserTimestampExtension;
+        e2ee?: DataTrackE2eeExtension;
+    });
+    toBinaryLengthBytes(): number;
+    toBinaryInto(dataView: DataView): Throws<number, never>;
+    static fromBinary<Input extends DataView | ArrayBuffer | Uint8Array>(input: Input): Throws<[
+        extensions: DataTrackExtensions,
+        byteLength: number
+    ], DataTrackDeserializeError<DataTrackDeserializeErrorReason.MalformedExt>>;
+    toJSON(): {
+        userTimestamp: {
+            tag: number;
+            lengthBytes: number;
+            timestamp: bigint;
+        } | null;
+        e2ee: {
+            tag: number;
+            lengthBytes: number;
+            keyIndex: number;
+            iv: Uint8Array;
+        } | null;
+    };
+}
+export {};
+//# sourceMappingURL=extensions.d.ts.map

package/dist/ts4.2/room/data-track/packet/index.d.ts

@@ -1,98 +1,98 @@
-import type { Throws } from '@livekit/throws-transformer/throws';
-import type { NonSharedUint8Array } from '../../../type-polyfills/non-shared-typed-arrays';
-import { DataTrackHandle } from '../handle';
-import { DataTrackTimestamp, U16_MAX_SIZE, WrapAroundUnsignedInt } from '../utils';
-import { DataTrackDeserializeError, DataTrackSerializeError, DataTrackSerializeErrorReason } from './errors';
-import { DataTrackExtensions } from './extensions';
-import Serializable from './serializable';
-/** A class for serializing / deserializing data track packet header sections. */
-export declare class DataTrackPacketHeader extends Serializable {
-    marker: FrameMarker;
-    trackHandle: DataTrackHandle;
-    sequence: WrapAroundUnsignedInt<typeof U16_MAX_SIZE>;
-    frameNumber: WrapAroundUnsignedInt<typeof U16_MAX_SIZE>;
-    timestamp: DataTrackTimestamp<90000>;
-    extensions: DataTrackExtensions;
-    constructor(opts: {
-        marker: FrameMarker;
-        trackHandle: DataTrackHandle;
-        sequence: WrapAroundUnsignedInt<typeof U16_MAX_SIZE>;
-        frameNumber: WrapAroundUnsignedInt<typeof U16_MAX_SIZE>;
-        timestamp: DataTrackTimestamp<90000>;
-        extensions?: DataTrackExtensions;
-    });
-    private extensionsMetrics;
-    toBinaryLengthBytes(): number;
-    toBinaryInto(dataView: DataView): Throws<number, DataTrackSerializeError<DataTrackSerializeErrorReason.TooSmallForHeader>>;
-    static fromBinary<Input extends DataView | ArrayBuffer | Uint8Array>(input: Input): Throws<[
-        header: DataTrackPacketHeader,
-        byteLength: number
-    ], DataTrackDeserializeError>;
-    toJSON(): {
-        marker: FrameMarker;
-        trackHandle: number;
-        sequence: number;
-        frameNumber: number;
-        timestamp: number;
-        extensions: {
-            userTimestamp: {
-                tag: number;
-                lengthBytes: number;
-                timestamp: bigint;
-            } | null;
-            e2ee: {
-                tag: number;
-                lengthBytes: number;
-                keyIndex: number;
-                iv: Uint8Array<ArrayBuffer>;
-            } | null;
-        };
-    };
-}
-/** Marker indicating a packet's position in relation to a frame. */
-export declare enum FrameMarker {
-    /** Packet is the first in a frame. */
-    Start = 0,
-    /** Packet is within a frame. */
-    Inter = 1,
-    /** Packet is the last in a frame. */
-    Final = 2,
-    /** Packet is the only one in a frame. */
-    Single = 3
-}
-/** A class for serializing / deserializing data track packets. */
-export declare class DataTrackPacket extends Serializable {
-    header: DataTrackPacketHeader;
-    payload: NonSharedUint8Array;
-    constructor(header: DataTrackPacketHeader, payload: NonSharedUint8Array);
-    toBinaryLengthBytes(): number;
-    toBinaryInto(dataView: DataView): Throws<number, DataTrackSerializeError>;
-    static fromBinary<Input extends DataView | ArrayBuffer | Uint8Array>(input: Input): Throws<[
-        packet: DataTrackPacket,
-        byteLength: number
-    ], DataTrackDeserializeError>;
-    toJSON(): {
-        header: {
-            marker: FrameMarker;
-            trackHandle: number;
-            sequence: number;
-            frameNumber: number;
-            timestamp: number;
-            extensions: {
-                userTimestamp: {
-                    tag: number;
-                    lengthBytes: number;
-                    timestamp: bigint;
-                } | null;
-                e2ee: {
-                    tag: number;
-                    lengthBytes: number;
-                    keyIndex: number;
-                    iv: Uint8Array<ArrayBuffer>;
-                } | null;
-            };
-        };
-        payload: Uint8Array<ArrayBuffer>;
-    };
-}
-//# sourceMappingURL=index.d.ts.map
+import type { Throws } from '@livekit/throws-transformer/throws';
+import type { NonSharedUint8Array } from '../../../type-polyfills/non-shared-typed-arrays';
+import { DataTrackHandle } from '../handle';
+import { DataTrackTimestamp, U16_MAX_SIZE, WrapAroundUnsignedInt } from '../utils';
+import { DataTrackDeserializeError, DataTrackSerializeError, DataTrackSerializeErrorReason } from './errors';
+import { DataTrackExtensions } from './extensions';
+import Serializable from './serializable';
+/** A class for serializing / deserializing data track packet header sections. */
+export declare class DataTrackPacketHeader extends Serializable {
+    marker: FrameMarker;
+    trackHandle: DataTrackHandle;
+    sequence: WrapAroundUnsignedInt<typeof U16_MAX_SIZE>;
+    frameNumber: WrapAroundUnsignedInt<typeof U16_MAX_SIZE>;
+    timestamp: DataTrackTimestamp<90000>;
+    extensions: DataTrackExtensions;
+    constructor(opts: {
+        marker: FrameMarker;
+        trackHandle: DataTrackHandle;
+        sequence: WrapAroundUnsignedInt<typeof U16_MAX_SIZE>;
+        frameNumber: WrapAroundUnsignedInt<typeof U16_MAX_SIZE>;
+        timestamp: DataTrackTimestamp<90000>;
+        extensions?: DataTrackExtensions;
+    });
+    private extensionsMetrics;
+    toBinaryLengthBytes(): number;
+    toBinaryInto(dataView: DataView): Throws<number, DataTrackSerializeError<DataTrackSerializeErrorReason.TooSmallForHeader>>;
+    static fromBinary<Input extends DataView | ArrayBuffer | Uint8Array>(input: Input): Throws<[
+        header: DataTrackPacketHeader,
+        byteLength: number
+    ], DataTrackDeserializeError>;
+    toJSON(): {
+        marker: FrameMarker;
+        trackHandle: number;
+        sequence: number;
+        frameNumber: number;
+        timestamp: number;
+        extensions: {
+            userTimestamp: {
+                tag: number;
+                lengthBytes: number;
+                timestamp: bigint;
+            } | null;
+            e2ee: {
+                tag: number;
+                lengthBytes: number;
+                keyIndex: number;
+                iv: Uint8Array;
+            } | null;
+        };
+    };
+}
+/** Marker indicating a packet's position in relation to a frame. */
+export declare enum FrameMarker {
+    /** Packet is the first in a frame. */
+    Start = 0,
+    /** Packet is within a frame. */
+    Inter = 1,
+    /** Packet is the last in a frame. */
+    Final = 2,
+    /** Packet is the only one in a frame. */
+    Single = 3
+}
+/** A class for serializing / deserializing data track packets. */
+export declare class DataTrackPacket extends Serializable {
+    header: DataTrackPacketHeader;
+    payload: NonSharedUint8Array;
+    constructor(header: DataTrackPacketHeader, payload: NonSharedUint8Array);
+    toBinaryLengthBytes(): number;
+    toBinaryInto(dataView: DataView): Throws<number, DataTrackSerializeError>;
+    static fromBinary<Input extends DataView | ArrayBuffer | Uint8Array>(input: Input): Throws<[
+        packet: DataTrackPacket,
+        byteLength: number
+    ], DataTrackDeserializeError>;
+    toJSON(): {
+        header: {
+            marker: FrameMarker;
+            trackHandle: number;
+            sequence: number;
+            frameNumber: number;
+            timestamp: number;
+            extensions: {
+                userTimestamp: {
+                    tag: number;
+                    lengthBytes: number;
+                    timestamp: bigint;
+                } | null;
+                e2ee: {
+                    tag: number;
+                    lengthBytes: number;
+                    keyIndex: number;
+                    iv: Uint8Array;
+                } | null;
+            };
+        };
+        payload: Uint8Array;
+    };
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/ts4.2/room/data-track/packet/serializable.d.ts

@@ -1,13 +1,13 @@
-import type { Throws } from '@livekit/throws-transformer/throws';
-import type { NonSharedUint8Array } from '../../../type-polyfills/non-shared-typed-arrays';
-import { DataTrackSerializeError } from './errors';
-/** An abstract class implementing common behavior related to data track binary serialization. */
-export default abstract class Serializable {
-    /** Returns the expected length of the serialized output in bytes */
-    abstract toBinaryLengthBytes(): number;
-    /** Given a DataView, serialize the instance inside and return the number of bytes written. */
-    abstract toBinaryInto(dataView: DataView): Throws<number, DataTrackSerializeError>;
-    /** Encodes the instance as binary and returns the data as a Uint8Array. */
-    toBinary(): Throws<NonSharedUint8Array, DataTrackSerializeError>;
-}
-//# sourceMappingURL=serializable.d.ts.map
+import type { Throws } from '@livekit/throws-transformer/throws';
+import type { NonSharedUint8Array } from '../../../type-polyfills/non-shared-typed-arrays';
+import { DataTrackSerializeError } from './errors';
+/** An abstract class implementing common behavior related to data track binary serialization. */
+export default abstract class Serializable {
+    /** Returns the expected length of the serialized output in bytes */
+    abstract toBinaryLengthBytes(): number;
+    /** Given a DataView, serialize the instance inside and return the number of bytes written. */
+    abstract toBinaryInto(dataView: DataView): Throws<number, DataTrackSerializeError>;
+    /** Encodes the instance as binary and returns the data as a Uint8Array. */
+    toBinary(): Throws<NonSharedUint8Array, DataTrackSerializeError>;
+}
+//# sourceMappingURL=serializable.d.ts.map

package/dist/ts4.2/room/data-track/packetizer.d.ts

@@ -1,43 +1,43 @@
-import type { Throws } from '@livekit/throws-transformer/throws';
-import { LivekitReasonedError } from '../errors';
-import type { DataTrackFrameInternal } from './frame';
-import { DataTrackHandle } from './handle';
-import { DataTrackPacket, FrameMarker } from './packet';
-import { DataTrackTimestamp } from './utils';
-type PacketizeOptions = {
-    /** "now" timestamp to use as a base when generating new packet timestamps. If not specified,
-     * defaults to the return value of {@link DataTrackClock#now}. */
-    now?: DataTrackTimestamp<90000>;
-};
-export declare class DataTrackPacketizerError<Reason extends DataTrackPacketizerReason = DataTrackPacketizerReason> extends LivekitReasonedError<Reason> {
-    readonly name = "DataTrackPacketizerError";
-    reason: Reason;
-    reasonName: string;
-    constructor(message: string, reason: Reason, options?: {
-        cause?: unknown;
-    });
-    static mtuTooShort(): DataTrackPacketizerError<DataTrackPacketizerReason>;
-}
-export declare enum DataTrackPacketizerReason {
-    MtuTooShort = 0
-}
-/** A packetizer takes a {@link DataTrackFrameInternal} as input and generates a series
- * of {@link DataTrackPacket}s for transmission to other clients over webrtc. */
-export default class DataTrackPacketizer {
-    private handle;
-    private mtuSizeBytes;
-    private sequence;
-    private frameNumber;
-    private clock;
-    constructor(trackHandle: DataTrackHandle, mtuSizeBytes: number);
-    /** @internal */
-    static computeFrameMarker(index: number, packetCount: number): FrameMarker;
-    /** Generates a series of packets for the specified {@link DataTrackFrameInternal}.
-     *
-     * NOTE: The return value of this function is a generator, so it can be lazily ran if desired,
-     * or converted to an array with {@link Array.from}.
-     */
-    packetize(frame: DataTrackFrameInternal, options?: PacketizeOptions): Throws<Generator<DataTrackPacket>, DataTrackPacketizerError>;
-}
-export {};
-//# sourceMappingURL=packetizer.d.ts.map
+import type { Throws } from '@livekit/throws-transformer/throws';
+import { LivekitReasonedError } from '../errors';
+import type { DataTrackFrameInternal } from './frame';
+import { DataTrackHandle } from './handle';
+import { DataTrackPacket, FrameMarker } from './packet';
+import { DataTrackTimestamp } from './utils';
+type PacketizeOptions = {
+    /** "now" timestamp to use as a base when generating new packet timestamps. If not specified,
+     * defaults to the return value of {@link DataTrackClock#now}. */
+    now?: DataTrackTimestamp<90000>;
+};
+export declare class DataTrackPacketizerError<Reason extends DataTrackPacketizerReason = DataTrackPacketizerReason> extends LivekitReasonedError<Reason> {
+    readonly name = "DataTrackPacketizerError";
+    reason: Reason;
+    reasonName: string;
+    constructor(message: string, reason: Reason, options?: {
+        cause?: unknown;
+    });
+    static mtuTooShort(): DataTrackPacketizerError<DataTrackPacketizerReason>;
+}
+export declare enum DataTrackPacketizerReason {
+    MtuTooShort = 0
+}
+/** A packetizer takes a {@link DataTrackFrameInternal} as input and generates a series
+ * of {@link DataTrackPacket}s for transmission to other clients over webrtc. */
+export default class DataTrackPacketizer {
+    private handle;
+    private mtuSizeBytes;
+    private sequence;
+    private frameNumber;
+    private clock;
+    constructor(trackHandle: DataTrackHandle, mtuSizeBytes: number);
+    /** @internal */
+    static computeFrameMarker(index: number, packetCount: number): FrameMarker;
+    /** Generates a series of packets for the specified {@link DataTrackFrameInternal}.
+     *
+     * NOTE: The return value of this function is a generator, so it can be lazily ran if desired,
+     * or converted to an array with {@link Array.from}.
+     */
+    packetize(frame: DataTrackFrameInternal, options?: PacketizeOptions): Throws<Generator<DataTrackPacket>, DataTrackPacketizerError>;
+}
+export {};
+//# sourceMappingURL=packetizer.d.ts.map

package/dist/ts4.2/room/data-track/track-interfaces.d.ts

@@ -1,23 +1,23 @@
-import type { DataTrackInfo } from './types';
-export declare const TrackSymbol: symbol;
-export interface ITrack {
-    readonly trackSymbol: typeof TrackSymbol;
-}
-/** An interface representing a track (of any type) which is local and sending data to the SFU. */
-export interface ILocalTrack extends ITrack {
-    readonly isLocal: true;
-    isPublished(): boolean;
-}
-export declare const RemoteTrackSymbol: symbol;
-/** An interface representing a track (of any type) which is remote and receiving data from the SFU. */
-export interface IRemoteTrack extends ITrack {
-    readonly isLocal: false;
-}
-export declare const DataTrackSymbol: symbol;
-/** An interface representing a data track, either local or remote. */
-export interface IDataTrack extends ITrack {
-    readonly typeSymbol: typeof DataTrackSymbol;
-    readonly info?: DataTrackInfo;
-}
-export declare function isDataTrack(subject: unknown): subject is IDataTrack;
-//# sourceMappingURL=track-interfaces.d.ts.map
+import type { DataTrackInfo } from './types';
+export declare const TrackSymbol: symbol;
+export interface ITrack {
+    readonly trackSymbol: typeof TrackSymbol;
+}
+/** An interface representing a track (of any type) which is local and sending data to the SFU. */
+export interface ILocalTrack extends ITrack {
+    readonly isLocal: true;
+    isPublished(): boolean;
+}
+export declare const RemoteTrackSymbol: symbol;
+/** An interface representing a track (of any type) which is remote and receiving data from the SFU. */
+export interface IRemoteTrack extends ITrack {
+    readonly isLocal: false;
+}
+export declare const DataTrackSymbol: symbol;
+/** An interface representing a data track, either local or remote. */
+export interface IDataTrack extends ITrack {
+    readonly typeSymbol: typeof DataTrackSymbol;
+    readonly info?: DataTrackInfo;
+}
+export declare function isDataTrack(subject: unknown): subject is IDataTrack;
+//# sourceMappingURL=track-interfaces.d.ts.map

package/dist/ts4.2/room/data-track/types.d.ts

@@ -1,22 +1,22 @@
-import { DataTrackInfo as ProtocolDataTrackInfo } from '@livekit/protocol';
-import type { DataTrackHandle } from './handle';
-export type DataTrackSid = string;
-/** Information about a published data track. */
-export type DataTrackInfo = {
-    sid: DataTrackSid;
-    pubHandle: DataTrackHandle;
-    name: string;
-    usesE2ee: boolean;
-};
-export type RemoteDataTrackPipelineOptions = {
-    /** Set the maximum number of in-flight partial frames the depacketizer will track
-     * concurrently for this track. Higher values give more out-of-order tolerance for
-     * high-frequency senders. Defaults to 1.
-     */
-    maxPartialFrames?: number;
-};
-export declare const DataTrackInfo: {
-    from(protocolInfo: ProtocolDataTrackInfo): DataTrackInfo;
-    toProtobuf(info: DataTrackInfo): ProtocolDataTrackInfo;
-};
-//# sourceMappingURL=types.d.ts.map
+import { DataTrackInfo as ProtocolDataTrackInfo } from '@livekit/protocol';
+import type { DataTrackHandle } from './handle';
+export type DataTrackSid = string;
+/** Information about a published data track. */
+export type DataTrackInfo = {
+    sid: DataTrackSid;
+    pubHandle: DataTrackHandle;
+    name: string;
+    usesE2ee: boolean;
+};
+export type RemoteDataTrackPipelineOptions = {
+    /** Set the maximum number of in-flight partial frames the depacketizer will track
+     * concurrently for this track. Higher values give more out-of-order tolerance for
+     * high-frequency senders. Defaults to 1.
+     */
+    maxPartialFrames?: number;
+};
+export declare const DataTrackInfo: {
+    from(protocolInfo: ProtocolDataTrackInfo): DataTrackInfo;
+    toProtobuf(info: DataTrackInfo): ProtocolDataTrackInfo;
+};
+//# sourceMappingURL=types.d.ts.map