livekit-client 2.22.3 → 2.23.0

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

@@ -1,126 +1,126 @@
-import type { Throws } from '@livekit/throws-transformer/throws';
-import type TypedEmitter from 'typed-emitter';
-import type { BaseE2EEManager } from '../../../e2ee/E2eeManager';
-import { Future } from '../../utils';
-import type { DataTrackFrameInternal } from '../frame';
-import { DataTrackHandle } from '../handle';
-import type { DataTrackInfo } from '../types';
-import { DataTrackPublishError, DataTrackPushFrameError, DataTrackPushFrameErrorReason } from './errors';
-import DataTrackOutgoingPipeline from './pipeline';
-import type { DataTrackOptions, EventPacketAvailable, EventPacketsFlushedChange, EventSfuPublishRequest, EventSfuUnpublishRequest, EventTrackPublished, EventTrackUnpublished, SfuPublishResponseResult } from './types';
-export type PendingDescriptor = {
-    type: 'pending';
-    /** Resolves when the descriptor is fully published. */
-    completionFuture: Future<void, DataTrackPublishError>;
-};
-export type ActiveDescriptor = {
-    type: 'active';
-    info: DataTrackInfo;
-    publishState: 'published' | 'republishing' | 'unpublished';
-    pipeline: DataTrackOutgoingPipeline;
-    /** Resolves when the descriptor is unpublished. */
-    unpublishingFuture: Future<void, never>;
-};
-export type Descriptor = PendingDescriptor | ActiveDescriptor;
-export declare const Descriptor: {
-    pending(): PendingDescriptor;
-    active(info: DataTrackInfo, e2eeManager: BaseE2EEManager | null): ActiveDescriptor;
-};
-export type DataTrackOutgoingManagerCallbacks = {
-    /** Request sent to the SFU to publish a track. */
-    sfuPublishRequest: (event: EventSfuPublishRequest) => void;
-    /** Request sent to the SFU to unpublish a track. */
-    sfuUnpublishRequest: (event: EventSfuUnpublishRequest) => void;
-    /** A serialized packet is ready to be sent over the transport. */
-    packetAvailable: (event: EventPacketAvailable) => void;
-    /** A new {@link LocalDataTrack} has been published */
-    trackPublished: (event: EventTrackPublished) => void;
-    /** A {@link LocalDataTrack} has been unpublished */
-    trackUnpublished: (event: EventTrackUnpublished) => void;
-    /** A {@link LocalDataTrack} has had all of its in flight packets sent via the rtc data channel. */
-    packetsFlushedChange: (event: EventPacketsFlushedChange) => void;
-    /** The manager has been reset and all state has been cleared in preparation for the next room
-     * connection. */
-    reset: () => void;
-};
-type OutgoingDataTrackManagerOptions = {
-    /**
-     * Provider to use for encrypting outgoing frame payloads.
-     *
-     * If null, end-to-end encryption will be disabled for all published tracks.
-     */
-    e2eeManager?: BaseE2EEManager;
-};
-declare const OutgoingDataTrackManager_base: new () => TypedEmitter<DataTrackOutgoingManagerCallbacks>;
-export default class OutgoingDataTrackManager extends OutgoingDataTrackManager_base {
-    private e2eeManager;
-    private handleAllocator;
-    private descriptors;
-    /** Number of packets for each data track which have been emitted via the `packetAvailable` event
-     * and which have not yet been sent via the rtc data channel yet. Once this goes to 0, then
-     * all in flight packets have been delivered, and the data tracks is "flushed". */
-    private inFlightPacketCounter;
-    constructor(options?: OutgoingDataTrackManagerOptions);
-    static withDescriptors(descriptors: Map<DataTrackHandle, Descriptor>): OutgoingDataTrackManager;
-    /** @internal */
-    updateE2eeManager(e2eeManager: BaseE2EEManager | null): void;
-    /**
-     * Used by attached {@link LocalDataTrack} instances to query their associated descriptor info.
-     * @internal
-     */
-    getDescriptor(handle: DataTrackHandle): Descriptor | null;
-    /** Used by attached {@link LocalDataTrack} instances to broadcast data track packets to other
-     * subscribers.
-     * @internal
-     */
-    tryProcessAndSend(handle: DataTrackHandle, frame: DataTrackFrameInternal): Promise<Throws<void, DataTrackPushFrameError<DataTrackPushFrameErrorReason.Dropped> | DataTrackPushFrameError<DataTrackPushFrameErrorReason.TrackUnpublished>>>;
-    /** The client has sent a packet over the rtc data channel. This signal is used for determining
-     * once all packets are sent and a data track has been "flushed".
-     *
-     * @internal */
-    handlePacketSendComplete(handle: DataTrackHandle): void;
-    /**
-     * Client requested to publish a track.
-     *
-     * If the LiveKit server is too old and doesn't support data tracks, a
-     * {@link DataTrackPublishError#timeout} will be thrown.
-     *
-     * @internal
-     **/
-    publishRequest(options: DataTrackOptions, signal?: AbortSignal): Promise<Throws<DataTrackHandle, DataTrackPublishError>>;
-    /**
-     * Get information about all currently published tracks.
-     * @internal
-     **/
-    queryPublished(): DataTrackInfo[];
-    /**
-     * Client request to unpublish a track.
-     * @internal
-     **/
-    unpublishRequest(handle: DataTrackHandle): Promise<void>;
-    /**
-     * SFU responded to a request to publish a data track.
-     * @internal
-     **/
-    receivedSfuPublishResponse(handle: DataTrackHandle, result: SfuPublishResponseResult): void;
-    /**
-     * SFU notification that a track has been unpublished.
-     * @internal
-     **/
-    receivedSfuUnpublishResponse(handle: DataTrackHandle): void;
-    /** Republish all tracks.
-     *
-     * This must be sent after a full reconnect in order for existing publications
-     * to be recognized by the SFU. Each republished track will be assigned a new SID.
-     * @internal
-     */
-    sfuWillRepublishTracks(): void;
-    /**
-     * Reset's the state of the manager and all associated tracks. Run on room disconnect to get
-     * the manager ready for the next room connection.
-     * @internal
-     **/
-    reset(): Promise<void>;
-}
-export {};
-//# sourceMappingURL=OutgoingDataTrackManager.d.ts.map
+import type { Throws } from '@livekit/throws-transformer/throws';
+import type TypedEmitter from 'typed-emitter';
+import type { BaseE2EEManager } from '../../../e2ee/E2eeManager';
+import { Future } from '../../utils';
+import type { DataTrackFrameInternal } from '../frame';
+import { DataTrackHandle } from '../handle';
+import type { DataTrackInfo } from '../types';
+import { DataTrackPublishError, DataTrackPushFrameError, DataTrackPushFrameErrorReason } from './errors';
+import DataTrackOutgoingPipeline from './pipeline';
+import type { DataTrackOptions, EventPacketAvailable, EventPacketsFlushedChange, EventSfuPublishRequest, EventSfuUnpublishRequest, EventTrackPublished, EventTrackUnpublished, SfuPublishResponseResult } from './types';
+export type PendingDescriptor = {
+    type: 'pending';
+    /** Resolves when the descriptor is fully published. */
+    completionFuture: Future<void, DataTrackPublishError>;
+};
+export type ActiveDescriptor = {
+    type: 'active';
+    info: DataTrackInfo;
+    publishState: 'published' | 'republishing' | 'unpublished';
+    pipeline: DataTrackOutgoingPipeline;
+    /** Resolves when the descriptor is unpublished. */
+    unpublishingFuture: Future<void, never>;
+};
+export type Descriptor = PendingDescriptor | ActiveDescriptor;
+export declare const Descriptor: {
+    pending(): PendingDescriptor;
+    active(info: DataTrackInfo, e2eeManager: BaseE2EEManager | null): ActiveDescriptor;
+};
+export type DataTrackOutgoingManagerCallbacks = {
+    /** Request sent to the SFU to publish a track. */
+    sfuPublishRequest: (event: EventSfuPublishRequest) => void;
+    /** Request sent to the SFU to unpublish a track. */
+    sfuUnpublishRequest: (event: EventSfuUnpublishRequest) => void;
+    /** A serialized packet is ready to be sent over the transport. */
+    packetAvailable: (event: EventPacketAvailable) => void;
+    /** A new {@link LocalDataTrack} has been published */
+    trackPublished: (event: EventTrackPublished) => void;
+    /** A {@link LocalDataTrack} has been unpublished */
+    trackUnpublished: (event: EventTrackUnpublished) => void;
+    /** A {@link LocalDataTrack} has had all of its in flight packets sent via the rtc data channel. */
+    packetsFlushedChange: (event: EventPacketsFlushedChange) => void;
+    /** The manager has been reset and all state has been cleared in preparation for the next room
+     * connection. */
+    reset: () => void;
+};
+type OutgoingDataTrackManagerOptions = {
+    /**
+     * Provider to use for encrypting outgoing frame payloads.
+     *
+     * If null, end-to-end encryption will be disabled for all published tracks.
+     */
+    e2eeManager?: BaseE2EEManager;
+};
+declare const OutgoingDataTrackManager_base: new () => TypedEmitter<DataTrackOutgoingManagerCallbacks>;
+export default class OutgoingDataTrackManager extends OutgoingDataTrackManager_base {
+    private e2eeManager;
+    private handleAllocator;
+    private descriptors;
+    /** Number of packets for each data track which have been emitted via the `packetAvailable` event
+     * and which have not yet been sent via the rtc data channel yet. Once this goes to 0, then
+     * all in flight packets have been delivered, and the data tracks is "flushed". */
+    private inFlightPacketCounter;
+    constructor(options?: OutgoingDataTrackManagerOptions);
+    static withDescriptors(descriptors: Map<DataTrackHandle, Descriptor>): OutgoingDataTrackManager;
+    /** @internal */
+    updateE2eeManager(e2eeManager: BaseE2EEManager | null): void;
+    /**
+     * Used by attached {@link LocalDataTrack} instances to query their associated descriptor info.
+     * @internal
+     */
+    getDescriptor(handle: DataTrackHandle): Descriptor | null;
+    /** Used by attached {@link LocalDataTrack} instances to broadcast data track packets to other
+     * subscribers.
+     * @internal
+     */
+    tryProcessAndSend(handle: DataTrackHandle, frame: DataTrackFrameInternal): Promise<Throws<void, DataTrackPushFrameError<DataTrackPushFrameErrorReason.Dropped> | DataTrackPushFrameError<DataTrackPushFrameErrorReason.TrackUnpublished>>>;
+    /** The client has sent a packet over the rtc data channel. This signal is used for determining
+     * once all packets are sent and a data track has been "flushed".
+     *
+     * @internal */
+    handlePacketSendComplete(handle: DataTrackHandle): void;
+    /**
+     * Client requested to publish a track.
+     *
+     * If the LiveKit server is too old and doesn't support data tracks, a
+     * {@link DataTrackPublishError#timeout} will be thrown.
+     *
+     * @internal
+     **/
+    publishRequest(options: DataTrackOptions, signal?: AbortSignal): Promise<Throws<DataTrackHandle, DataTrackPublishError>>;
+    /**
+     * Get information about all currently published tracks.
+     * @internal
+     **/
+    queryPublished(): DataTrackInfo[];
+    /**
+     * Client request to unpublish a track.
+     * @internal
+     **/
+    unpublishRequest(handle: DataTrackHandle): Promise<void>;
+    /**
+     * SFU responded to a request to publish a data track.
+     * @internal
+     **/
+    receivedSfuPublishResponse(handle: DataTrackHandle, result: SfuPublishResponseResult): void;
+    /**
+     * SFU notification that a track has been unpublished.
+     * @internal
+     **/
+    receivedSfuUnpublishResponse(handle: DataTrackHandle): void;
+    /** Republish all tracks.
+     *
+     * This must be sent after a full reconnect in order for existing publications
+     * to be recognized by the SFU. Each republished track will be assigned a new SID.
+     * @internal
+     */
+    sfuWillRepublishTracks(): void;
+    /**
+     * Reset's the state of the manager and all associated tracks. Run on room disconnect to get
+     * the manager ready for the next room connection.
+     * @internal
+     **/
+    reset(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=OutgoingDataTrackManager.d.ts.map

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

@@ -1,74 +1,74 @@
-import { LivekitReasonedError } from '../../errors';
-import { DataTrackPacketizerError } from '../packetizer';
-export declare enum DataTrackPublishErrorReason {
-    /**
-     * Local participant does not have permission to publish data tracks.
-     *
-     * Ensure the participant's token contains the `canPublishData` grant.
-     */
-    NotAllowed = 0,
-    /** A track with the same name is already published by the local participant. */
-    DuplicateName = 1,
-    /** Request to publish the track took long to complete. */
-    Timeout = 2,
-    /** No additional data tracks can be published by the local participant. */
-    LimitReached = 3,
-    /** Cannot publish data track when the room is disconnected. */
-    Disconnected = 4,
-    Cancelled = 5,
-    /** The name requested is not able to be used when creating the data track. */
-    InvalidName = 6,
-    /** There was an error publishing, but it was not something that could be sorted into a known
-     * category. */
-    Unknown = 7
-}
-export declare class DataTrackPublishError<Reason extends DataTrackPublishErrorReason = DataTrackPublishErrorReason> extends LivekitReasonedError<Reason> {
-    readonly name = "DataTrackPublishError";
-    reason: Reason;
-    reasonName: string;
-    /** Underling message from the SFU, if one was provided */
-    rawMessage?: string;
-    constructor(message: string, reason: Reason, options?: {
-        rawMessage?: string;
-        cause?: unknown;
-    });
-    static notAllowed(rawMessage?: string): DataTrackPublishError<DataTrackPublishErrorReason.NotAllowed>;
-    static duplicateName(rawMessage?: string): DataTrackPublishError<DataTrackPublishErrorReason.DuplicateName>;
-    static invalidName(rawMessage?: string): DataTrackPublishError<DataTrackPublishErrorReason.InvalidName>;
-    static timeout(): DataTrackPublishError<DataTrackPublishErrorReason.Timeout>;
-    static limitReached(rawMessage?: string): DataTrackPublishError<DataTrackPublishErrorReason.LimitReached>;
-    static unknown(reason: number, message: string): DataTrackPublishError<DataTrackPublishErrorReason.Unknown>;
-    static disconnected(): DataTrackPublishError<DataTrackPublishErrorReason.Disconnected>;
-    static cancelled(): DataTrackPublishError<DataTrackPublishErrorReason.Cancelled>;
-}
-export declare enum DataTrackPushFrameErrorReason {
-    /** Track is no longer published. */
-    TrackUnpublished = 0,
-    /** Frame was dropped. */
-    Dropped = 1
-}
-export declare class DataTrackPushFrameError<Reason extends DataTrackPushFrameErrorReason = DataTrackPushFrameErrorReason> extends LivekitReasonedError<Reason> {
-    readonly name = "DataTrackPushFrameError";
-    reason: Reason;
-    reasonName: string;
-    constructor(message: string, reason: Reason, options?: {
-        cause?: unknown;
-    });
-    static trackUnpublished(): DataTrackPushFrameError<DataTrackPushFrameErrorReason.TrackUnpublished>;
-    static dropped(cause?: unknown): DataTrackPushFrameError<DataTrackPushFrameErrorReason.Dropped>;
-}
-export declare enum DataTrackOutgoingPipelineErrorReason {
-    Packetizer = 0,
-    Encryption = 1
-}
-export declare class DataTrackOutgoingPipelineError<Reason extends DataTrackOutgoingPipelineErrorReason = DataTrackOutgoingPipelineErrorReason> extends LivekitReasonedError<Reason> {
-    readonly name = "DataTrackOutgoingPipelineError";
-    reason: Reason;
-    reasonName: string;
-    constructor(message: string, reason: Reason, options?: {
-        cause?: unknown;
-    });
-    static packetizer(cause: DataTrackPacketizerError): DataTrackOutgoingPipelineError<DataTrackOutgoingPipelineErrorReason.Packetizer>;
-    static encryption(cause: unknown): DataTrackOutgoingPipelineError<DataTrackOutgoingPipelineErrorReason.Encryption>;
-}
-//# sourceMappingURL=errors.d.ts.map
+import { LivekitReasonedError } from '../../errors';
+import { DataTrackPacketizerError } from '../packetizer';
+export declare enum DataTrackPublishErrorReason {
+    /**
+     * Local participant does not have permission to publish data tracks.
+     *
+     * Ensure the participant's token contains the `canPublishData` grant.
+     */
+    NotAllowed = 0,
+    /** A track with the same name is already published by the local participant. */
+    DuplicateName = 1,
+    /** Request to publish the track took long to complete. */
+    Timeout = 2,
+    /** No additional data tracks can be published by the local participant. */
+    LimitReached = 3,
+    /** Cannot publish data track when the room is disconnected. */
+    Disconnected = 4,
+    Cancelled = 5,
+    /** The name requested is not able to be used when creating the data track. */
+    InvalidName = 6,
+    /** There was an error publishing, but it was not something that could be sorted into a known
+     * category. */
+    Unknown = 7
+}
+export declare class DataTrackPublishError<Reason extends DataTrackPublishErrorReason = DataTrackPublishErrorReason> extends LivekitReasonedError<Reason> {
+    readonly name = "DataTrackPublishError";
+    reason: Reason;
+    reasonName: string;
+    /** Underling message from the SFU, if one was provided */
+    rawMessage?: string;
+    constructor(message: string, reason: Reason, options?: {
+        rawMessage?: string;
+        cause?: unknown;
+    });
+    static notAllowed(rawMessage?: string): DataTrackPublishError<DataTrackPublishErrorReason.NotAllowed>;
+    static duplicateName(rawMessage?: string): DataTrackPublishError<DataTrackPublishErrorReason.DuplicateName>;
+    static invalidName(rawMessage?: string): DataTrackPublishError<DataTrackPublishErrorReason.InvalidName>;
+    static timeout(): DataTrackPublishError<DataTrackPublishErrorReason.Timeout>;
+    static limitReached(rawMessage?: string): DataTrackPublishError<DataTrackPublishErrorReason.LimitReached>;
+    static unknown(reason: number, message: string): DataTrackPublishError<DataTrackPublishErrorReason.Unknown>;
+    static disconnected(): DataTrackPublishError<DataTrackPublishErrorReason.Disconnected>;
+    static cancelled(): DataTrackPublishError<DataTrackPublishErrorReason.Cancelled>;
+}
+export declare enum DataTrackPushFrameErrorReason {
+    /** Track is no longer published. */
+    TrackUnpublished = 0,
+    /** Frame was dropped. */
+    Dropped = 1
+}
+export declare class DataTrackPushFrameError<Reason extends DataTrackPushFrameErrorReason = DataTrackPushFrameErrorReason> extends LivekitReasonedError<Reason> {
+    readonly name = "DataTrackPushFrameError";
+    reason: Reason;
+    reasonName: string;
+    constructor(message: string, reason: Reason, options?: {
+        cause?: unknown;
+    });
+    static trackUnpublished(): DataTrackPushFrameError<DataTrackPushFrameErrorReason.TrackUnpublished>;
+    static dropped(cause?: unknown): DataTrackPushFrameError<DataTrackPushFrameErrorReason.Dropped>;
+}
+export declare enum DataTrackOutgoingPipelineErrorReason {
+    Packetizer = 0,
+    Encryption = 1
+}
+export declare class DataTrackOutgoingPipelineError<Reason extends DataTrackOutgoingPipelineErrorReason = DataTrackOutgoingPipelineErrorReason> extends LivekitReasonedError<Reason> {
+    readonly name = "DataTrackOutgoingPipelineError";
+    reason: Reason;
+    reasonName: string;
+    constructor(message: string, reason: Reason, options?: {
+        cause?: unknown;
+    });
+    static packetizer(cause: DataTrackPacketizerError): DataTrackOutgoingPipelineError<DataTrackOutgoingPipelineErrorReason.Packetizer>;
+    static encryption(cause: unknown): DataTrackOutgoingPipelineError<DataTrackOutgoingPipelineErrorReason.Encryption>;
+}
+//# sourceMappingURL=errors.d.ts.map

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

@@ -1,23 +1,23 @@
-import type { Throws } from '@livekit/throws-transformer/throws';
-import type { BaseE2EEManager } from '../../../e2ee/E2eeManager';
-import type { DataTrackFrameInternal } from '../frame';
-import { DataTrackPacket } from '../packet';
-import type { DataTrackInfo } from '../types';
-import { DataTrackOutgoingPipelineError, DataTrackOutgoingPipelineErrorReason } from './errors';
-type Options = {
-    info: DataTrackInfo;
-    e2eeManager: BaseE2EEManager | null;
-};
-/** Processes outgoing frames into final packets for distribution to the SFU. */
-export default class DataTrackOutgoingPipeline {
-    private e2eeManager;
-    private packetizer;
-    /** Maximum transmission unit (MTU) of the transport. */
-    private static TRANSPORT_MTU_BYTES;
-    constructor(options: Options);
-    updateE2eeManager(e2eeManager: BaseE2EEManager | null): void;
-    processFrame(frame: DataTrackFrameInternal): Throws<AsyncGenerator<DataTrackPacket>, DataTrackOutgoingPipelineError>;
-    encryptIfNeeded(frame: DataTrackFrameInternal): Promise<Throws<DataTrackFrameInternal, DataTrackOutgoingPipelineError<DataTrackOutgoingPipelineErrorReason.Encryption>>>;
-}
-export {};
-//# sourceMappingURL=pipeline.d.ts.map
+import type { Throws } from '@livekit/throws-transformer/throws';
+import type { BaseE2EEManager } from '../../../e2ee/E2eeManager';
+import type { DataTrackFrameInternal } from '../frame';
+import { DataTrackPacket } from '../packet';
+import type { DataTrackInfo } from '../types';
+import { DataTrackOutgoingPipelineError, DataTrackOutgoingPipelineErrorReason } from './errors';
+type Options = {
+    info: DataTrackInfo;
+    e2eeManager: BaseE2EEManager | null;
+};
+/** Processes outgoing frames into final packets for distribution to the SFU. */
+export default class DataTrackOutgoingPipeline {
+    private e2eeManager;
+    private packetizer;
+    /** Maximum transmission unit (MTU) of the transport. */
+    private static TRANSPORT_MTU_BYTES;
+    constructor(options: Options);
+    updateE2eeManager(e2eeManager: BaseE2EEManager | null): void;
+    processFrame(frame: DataTrackFrameInternal): Throws<AsyncGenerator<DataTrackPacket>, DataTrackOutgoingPipelineError>;
+    encryptIfNeeded(frame: DataTrackFrameInternal): Promise<Throws<DataTrackFrameInternal, DataTrackOutgoingPipelineError<DataTrackOutgoingPipelineErrorReason.Encryption>>>;
+}
+export {};
+//# sourceMappingURL=pipeline.d.ts.map

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

@@ -1,48 +1,48 @@
-import type { NonSharedUint8Array } from '../../../type-polyfills/non-shared-typed-arrays';
-import type LocalDataTrack from '../LocalDataTrack';
-import type { DataTrackHandle } from '../handle';
-import type { DataTrackInfo, DataTrackSid } from '../types';
-import type { DataTrackPublishError, DataTrackPublishErrorReason } from './errors';
-/** Options for publishing a data track. */
-export type DataTrackOptions = {
-    name: string;
-};
-/** Encodes whether a data track publish request to the SFU has been successful or not. */
-export type SfuPublishResponseResult = {
-    type: 'ok';
-    data: DataTrackInfo;
-} | {
-    type: 'error';
-    error: DataTrackPublishError<DataTrackPublishErrorReason.NotAllowed> | DataTrackPublishError<DataTrackPublishErrorReason.DuplicateName> | DataTrackPublishError<DataTrackPublishErrorReason.InvalidName> | DataTrackPublishError<DataTrackPublishErrorReason.LimitReached> | DataTrackPublishError<DataTrackPublishErrorReason.Unknown>;
-};
-/** Request sent to the SFU to publish a track. */
-export type EventSfuPublishRequest = {
-    handle: DataTrackHandle;
-    name: string;
-    usesE2ee: boolean;
-};
-/** Request sent to the SFU to unpublish a track. */
-export type EventSfuUnpublishRequest = {
-    handle: DataTrackHandle;
-};
-/** A serialized packet is ready to be sent over the transport. */
-export type EventPacketAvailable = {
-    /** The handle associated with the data track which this packet bytes belong to. */
-    handle: DataTrackHandle;
-    bytes: NonSharedUint8Array;
-};
-/** A track has been created by a local participant and is available to be
- * subscribed to. */
-export type EventTrackPublished = {
-    track: LocalDataTrack;
-};
-/** A track has been unpublished by a remote participant and can no longer be subscribed to. */
-export type EventTrackUnpublished = {
-    sid: DataTrackSid;
-};
-/** A track has had all of its in flight packets sent via the rtc data channel. */
-export type EventPacketsFlushedChange = {
-    handle: DataTrackHandle;
-    isFlushed: boolean;
-};
-//# sourceMappingURL=types.d.ts.map
+import type { NonSharedUint8Array } from '../../../type-polyfills/non-shared-typed-arrays';
+import type LocalDataTrack from '../LocalDataTrack';
+import type { DataTrackHandle } from '../handle';
+import type { DataTrackInfo, DataTrackSid } from '../types';
+import type { DataTrackPublishError, DataTrackPublishErrorReason } from './errors';
+/** Options for publishing a data track. */
+export type DataTrackOptions = {
+    name: string;
+};
+/** Encodes whether a data track publish request to the SFU has been successful or not. */
+export type SfuPublishResponseResult = {
+    type: 'ok';
+    data: DataTrackInfo;
+} | {
+    type: 'error';
+    error: DataTrackPublishError<DataTrackPublishErrorReason.NotAllowed> | DataTrackPublishError<DataTrackPublishErrorReason.DuplicateName> | DataTrackPublishError<DataTrackPublishErrorReason.InvalidName> | DataTrackPublishError<DataTrackPublishErrorReason.LimitReached> | DataTrackPublishError<DataTrackPublishErrorReason.Unknown>;
+};
+/** Request sent to the SFU to publish a track. */
+export type EventSfuPublishRequest = {
+    handle: DataTrackHandle;
+    name: string;
+    usesE2ee: boolean;
+};
+/** Request sent to the SFU to unpublish a track. */
+export type EventSfuUnpublishRequest = {
+    handle: DataTrackHandle;
+};
+/** A serialized packet is ready to be sent over the transport. */
+export type EventPacketAvailable = {
+    /** The handle associated with the data track which this packet bytes belong to. */
+    handle: DataTrackHandle;
+    bytes: NonSharedUint8Array;
+};
+/** A track has been created by a local participant and is available to be
+ * subscribed to. */
+export type EventTrackPublished = {
+    track: LocalDataTrack;
+};
+/** A track has been unpublished by a remote participant and can no longer be subscribed to. */
+export type EventTrackUnpublished = {
+    sid: DataTrackSid;
+};
+/** A track has had all of its in flight packets sent via the rtc data channel. */
+export type EventPacketsFlushedChange = {
+    handle: DataTrackHandle;
+    isFlushed: boolean;
+};
+//# sourceMappingURL=types.d.ts.map

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

@@ -1,20 +1,20 @@
-export declare const U8_LENGTH_BYTES = 1;
-export declare const U16_LENGTH_BYTES = 2;
-export declare const U32_LENGTH_BYTES = 4;
-export declare const U64_LENGTH_BYTES = 8;
-export declare const SUPPORTED_VERSION = 0;
-export declare const BASE_HEADER_LEN = 12;
-export declare const VERSION_SHIFT = 5;
-export declare const VERSION_MASK = 7;
-export declare const FRAME_MARKER_SHIFT = 3;
-export declare const FRAME_MARKER_MASK = 3;
-export declare const FRAME_MARKER_START = 2;
-export declare const FRAME_MARKER_FINAL = 1;
-export declare const FRAME_MARKER_INTER = 0;
-export declare const FRAME_MARKER_SINGLE = 3;
-export declare const EXT_WORDS_INDICATOR_SIZE = 2;
-export declare const EXT_FLAG_SHIFT = 2;
-export declare const EXT_FLAG_MASK = 1;
-export declare const EXT_MARKER_LEN = 4;
-export declare const EXT_TAG_PADDING = 0;
-//# sourceMappingURL=constants.d.ts.map
+export declare const U8_LENGTH_BYTES = 1;
+export declare const U16_LENGTH_BYTES = 2;
+export declare const U32_LENGTH_BYTES = 4;
+export declare const U64_LENGTH_BYTES = 8;
+export declare const SUPPORTED_VERSION = 0;
+export declare const BASE_HEADER_LEN = 12;
+export declare const VERSION_SHIFT = 5;
+export declare const VERSION_MASK = 7;
+export declare const FRAME_MARKER_SHIFT = 3;
+export declare const FRAME_MARKER_MASK = 3;
+export declare const FRAME_MARKER_START = 2;
+export declare const FRAME_MARKER_FINAL = 1;
+export declare const FRAME_MARKER_INTER = 0;
+export declare const FRAME_MARKER_SINGLE = 3;
+export declare const EXT_WORDS_INDICATOR_SIZE = 2;
+export declare const EXT_FLAG_SHIFT = 2;
+export declare const EXT_FLAG_MASK = 1;
+export declare const EXT_MARKER_LEN = 4;
+export declare const EXT_TAG_PADDING = 0;
+//# sourceMappingURL=constants.d.ts.map