livekit-client 2.22.3 → 2.23.0

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

@@ -1,60 +1,60 @@
-export declare const U16_MAX_SIZE = 65535;
-export declare const U32_MAX_SIZE = 4294967295;
-/**
- * A number of fields withing the data tracks packet specification assume wrap around behavior when
- * an unsigned type is incremented beyond its max size (ie, the packet `sequence` field). This
- * wrapper type manually reimplements this wrap around behavior given javascript's lack of fixed
- * size integer types.
- */
-export declare class WrapAroundUnsignedInt<MaxSize extends number> {
-    value: number;
-    private maxSize;
-    static u16(raw: number): WrapAroundUnsignedInt<65535>;
-    static u32(raw: number): WrapAroundUnsignedInt<4294967295>;
-    constructor(raw: number, maxSize: MaxSize);
-    /** Manually clamp the given containing value according to the wrap around max size bounds. Use
-     * this after out of bounds modification to the contained value by external code. */
-    clamp(): void;
-    clone(): WrapAroundUnsignedInt<MaxSize>;
-    /** When called, maps the containing value to a new containing value. After mapping, the wrap
-     * around external max size bounds are applied. Note that this is a mutative operation. */
-    update(updateFn: (value: number) => number): void;
-    /** Increments the given `n` to the inner value. Note that this is a mutative operation. */
-    increment(n?: number): void;
-    /** Decrements the given `n` from the inner value. Note that this is a mutative operation. */
-    decrement(n?: number): void;
-    getThenIncrement(): WrapAroundUnsignedInt<MaxSize>;
-    /** Returns true if {@link this} is before the passed other {@link WrapAroundUnsignedInt}. */
-    isBefore(other: WrapAroundUnsignedInt<MaxSize>): boolean;
-}
-export declare class DataTrackTimestamp<RateInHz extends number> {
-    rateInHz: RateInHz;
-    timestamp: WrapAroundUnsignedInt<typeof U32_MAX_SIZE>;
-    static fromRtpTicks(rtpTicks: number): DataTrackTimestamp<90000>;
-    /** Generates a timestamp initialized to a non cryptographically secure random value, so that
-     * different streams are more difficult to correlate in packet capture. */
-    static rtpRandom(): DataTrackTimestamp<90000>;
-    private constructor();
-    asTicks(): number;
-    clone(): DataTrackTimestamp<RateInHz>;
-    wrappingAdd(n: number): void;
-    /** Returns true if {@link this} is before the passed other {@link DataTrackTimestamp}. */
-    isBefore(other: DataTrackTimestamp<RateInHz>): boolean;
-}
-export declare class DataTrackClock<RateInHz extends number> {
-    epoch: Date;
-    base: DataTrackTimestamp<RateInHz>;
-    previous: DataTrackTimestamp<RateInHz>;
-    rateInHz: RateInHz;
-    private constructor();
-    static startingNow<RateInHz extends number>(base: DataTrackTimestamp<RateInHz>, rateInHz: RateInHz): DataTrackClock<RateInHz>;
-    static startingAtTime<RateInHz extends number>(epoch: Date, base: DataTrackTimestamp<RateInHz>, rateInHz: RateInHz): DataTrackClock<RateInHz>;
-    static rtpStartingNow(base: DataTrackTimestamp<90000>): DataTrackClock<90000>;
-    static rtpStartingAtTime(epoch: Date, base: DataTrackTimestamp<90000>): DataTrackClock<90000>;
-    now(): DataTrackTimestamp<RateInHz>;
-    at(timestamp: Date): DataTrackTimestamp<RateInHz>;
-    /** Convert a duration since the epoch into clock ticks. */
-    static durationInMsToTicks(durationMilliseconds: number, rateInHz: number): number;
-}
-export declare function coerceToDataView<Input extends DataView | ArrayBuffer | Uint8Array>(input: Input): DataView;
-//# sourceMappingURL=utils.d.ts.map
+export declare const U16_MAX_SIZE = 65535;
+export declare const U32_MAX_SIZE = 4294967295;
+/**
+ * A number of fields withing the data tracks packet specification assume wrap around behavior when
+ * an unsigned type is incremented beyond its max size (ie, the packet `sequence` field). This
+ * wrapper type manually reimplements this wrap around behavior given javascript's lack of fixed
+ * size integer types.
+ */
+export declare class WrapAroundUnsignedInt<MaxSize extends number> {
+    value: number;
+    private maxSize;
+    static u16(raw: number): WrapAroundUnsignedInt<65535>;
+    static u32(raw: number): WrapAroundUnsignedInt<4294967295>;
+    constructor(raw: number, maxSize: MaxSize);
+    /** Manually clamp the given containing value according to the wrap around max size bounds. Use
+     * this after out of bounds modification to the contained value by external code. */
+    clamp(): void;
+    clone(): WrapAroundUnsignedInt<MaxSize>;
+    /** When called, maps the containing value to a new containing value. After mapping, the wrap
+     * around external max size bounds are applied. Note that this is a mutative operation. */
+    update(updateFn: (value: number) => number): void;
+    /** Increments the given `n` to the inner value. Note that this is a mutative operation. */
+    increment(n?: number): void;
+    /** Decrements the given `n` from the inner value. Note that this is a mutative operation. */
+    decrement(n?: number): void;
+    getThenIncrement(): WrapAroundUnsignedInt<MaxSize>;
+    /** Returns true if {@link this} is before the passed other {@link WrapAroundUnsignedInt}. */
+    isBefore(other: WrapAroundUnsignedInt<MaxSize>): boolean;
+}
+export declare class DataTrackTimestamp<RateInHz extends number> {
+    rateInHz: RateInHz;
+    timestamp: WrapAroundUnsignedInt<typeof U32_MAX_SIZE>;
+    static fromRtpTicks(rtpTicks: number): DataTrackTimestamp<90000>;
+    /** Generates a timestamp initialized to a non cryptographically secure random value, so that
+     * different streams are more difficult to correlate in packet capture. */
+    static rtpRandom(): DataTrackTimestamp<90000>;
+    private constructor();
+    asTicks(): number;
+    clone(): DataTrackTimestamp<RateInHz>;
+    wrappingAdd(n: number): void;
+    /** Returns true if {@link this} is before the passed other {@link DataTrackTimestamp}. */
+    isBefore(other: DataTrackTimestamp<RateInHz>): boolean;
+}
+export declare class DataTrackClock<RateInHz extends number> {
+    epoch: Date;
+    base: DataTrackTimestamp<RateInHz>;
+    previous: DataTrackTimestamp<RateInHz>;
+    rateInHz: RateInHz;
+    private constructor();
+    static startingNow<RateInHz extends number>(base: DataTrackTimestamp<RateInHz>, rateInHz: RateInHz): DataTrackClock<RateInHz>;
+    static startingAtTime<RateInHz extends number>(epoch: Date, base: DataTrackTimestamp<RateInHz>, rateInHz: RateInHz): DataTrackClock<RateInHz>;
+    static rtpStartingNow(base: DataTrackTimestamp<90000>): DataTrackClock<90000>;
+    static rtpStartingAtTime(epoch: Date, base: DataTrackTimestamp<90000>): DataTrackClock<90000>;
+    now(): DataTrackTimestamp<RateInHz>;
+    at(timestamp: Date): DataTrackTimestamp<RateInHz>;
+    /** Convert a duration since the epoch into clock ticks. */
+    static durationInMsToTicks(durationMilliseconds: number, rateInHz: number): number;
+}
+export declare function coerceToDataView<Input extends DataView | ArrayBuffer | Uint8Array>(input: Input): DataView;
+//# sourceMappingURL=utils.d.ts.map

package/dist/ts4.2/room/debounce.d.ts

@@ -1,11 +1,11 @@
-export type Options<Result> = {
-    isImmediate?: boolean;
-    maxWait?: number;
-    callback?: (data: Result) => void;
-};
-export interface DebouncedFunction<Args extends any[], F extends (...args: Args) => any> {
-    (this: ThisParameterType<F>, ...args: Args & Parameters<F>): Promise<ReturnType<F>>;
-    cancel: (reason?: any) => void;
-}
-export declare function debounce<Args extends any[], F extends (...args: Args) => any>(func: F, waitMilliseconds?: number, options?: Options<ReturnType<F>>): DebouncedFunction<Args, F>;
-//# sourceMappingURL=debounce.d.ts.map
+export type Options<Result> = {
+    isImmediate?: boolean;
+    maxWait?: number;
+    callback?: (data: Result) => void;
+};
+export interface DebouncedFunction<Args extends any[], F extends (...args: Args) => any> {
+    (this: ThisParameterType<F>, ...args: Args & Parameters<F>): Promise<ReturnType<F>>;
+    cancel: (reason?: any) => void;
+}
+export declare function debounce<Args extends any[], F extends (...args: Args) => any>(func: F, waitMilliseconds?: number, options?: Options<ReturnType<F>>): DebouncedFunction<Args, F>;
+//# sourceMappingURL=debounce.d.ts.map

package/dist/ts4.2/room/defaults.d.ts

@@ -1,9 +1,9 @@
-import type { InternalRoomConnectOptions, InternalRoomOptions } from '../options';
-import type { AudioCaptureOptions, TrackPublishDefaults, VideoCaptureOptions } from './track/options';
-export declare const defaultVideoCodec = "vp8";
-export declare const publishDefaults: TrackPublishDefaults;
-export declare const audioDefaults: AudioCaptureOptions;
-export declare const videoDefaults: VideoCaptureOptions;
-export declare const roomOptionDefaults: InternalRoomOptions;
-export declare const roomConnectOptionDefaults: InternalRoomConnectOptions;
-//# sourceMappingURL=defaults.d.ts.map
+import type { InternalRoomConnectOptions, InternalRoomOptions } from '../options';
+import type { AudioCaptureOptions, TrackPublishDefaults, VideoCaptureOptions } from './track/options';
+export declare const defaultVideoCodec = "vp8";
+export declare const publishDefaults: TrackPublishDefaults;
+export declare const audioDefaults: AudioCaptureOptions;
+export declare const videoDefaults: VideoCaptureOptions;
+export declare const roomOptionDefaults: InternalRoomOptions;
+export declare const roomConnectOptionDefaults: InternalRoomConnectOptions;
+//# sourceMappingURL=defaults.d.ts.map

package/dist/ts4.2/room/errors.d.ts

@@ -1,162 +1,180 @@
-import { DisconnectReason, RequestResponse_Reason } from '@livekit/protocol';
-/** Base error that all LiveKit specific custom errors inherit from. */
-export declare class LivekitError extends Error {
-    code: number;
-    cause?: unknown;
-    constructor(code: number, message?: string, options?: {
-        cause?: unknown;
-    });
-}
-/**
- * LiveKit specific error type representing an error with an associated set of reasons.
- * Use this to represent an error with multiple different but contextually related variants.
- * */
-export declare abstract class LivekitReasonedError<Reason> extends LivekitError {
-    abstract reason: Reason;
-    abstract reasonName: string;
-}
-export declare class SimulatedError extends LivekitError {
-    readonly name = "simulated";
-    constructor(message?: string);
-}
-export declare enum ConnectionErrorReason {
-    NotAllowed = 0,
-    ServerUnreachable = 1,
-    InternalError = 2,
-    Cancelled = 3,
-    LeaveRequest = 4,
-    Timeout = 5,
-    WebSocket = 6,
-    ServiceNotFound = 7
-}
-type NotAllowed = {
-    reason: ConnectionErrorReason.NotAllowed;
-    status: number;
-    context?: unknown;
-};
-type InternalError = {
-    reason: ConnectionErrorReason.InternalError;
-    status: never;
-    context?: {
-        status?: number;
-        statusText?: string;
-    };
-};
-type ConnectionTimeout = {
-    reason: ConnectionErrorReason.Timeout;
-    status: never;
-    context: never;
-};
-type LeaveRequest = {
-    reason: ConnectionErrorReason.LeaveRequest;
-    status: never;
-    context: DisconnectReason;
-};
-type Cancelled = {
-    reason: ConnectionErrorReason.Cancelled;
-    status: never;
-    context: never;
-};
-type ServerUnreachable = {
-    reason: ConnectionErrorReason.ServerUnreachable;
-    status?: number;
-    context?: never;
-};
-type WebSocket = {
-    reason: ConnectionErrorReason.WebSocket;
-    status?: number;
-    context?: string;
-};
-type ServiceNotFound = {
-    reason: ConnectionErrorReason.ServiceNotFound;
-    status: never;
-    context: string;
-};
-type ConnectionErrorVariants = NotAllowed | ConnectionTimeout | LeaveRequest | InternalError | Cancelled | ServerUnreachable | WebSocket | ServiceNotFound;
-export declare class ConnectionError<Variant extends ConnectionErrorVariants = ConnectionErrorVariants> extends LivekitReasonedError<Variant['reason']> {
-    status?: Variant['status'];
-    context: Variant['context'];
-    reason: Variant['reason'];
-    reasonName: string;
-    readonly name = "ConnectionError";
-    protected constructor(message: string, reason: Variant['reason'], status?: Variant['status'], context?: Variant['context']);
-    static notAllowed(message: string, status: number, context?: unknown): ConnectionError<NotAllowed>;
-    static timeout(message: string): ConnectionError<ConnectionTimeout>;
-    static leaveRequest(message: string, context: DisconnectReason): ConnectionError<LeaveRequest>;
-    static internal(message: string, context?: {
-        status?: number;
-        statusText?: string;
-    }): ConnectionError<InternalError>;
-    static cancelled(message: string): ConnectionError<Cancelled>;
-    static serverUnreachable(message: string, status?: number): ConnectionError<ServerUnreachable>;
-    static websocket(message: string, status?: number, reason?: string): ConnectionError<WebSocket>;
-    static serviceNotFound(message: string, serviceName: 'v0-rtc'): ConnectionError<ServiceNotFound>;
-}
-export declare class DeviceUnsupportedError extends LivekitError {
-    readonly name = "DeviceUnsupportedError";
-    constructor(message?: string);
-}
-export declare class TrackInvalidError extends LivekitError {
-    readonly name = "TrackInvalidError";
-    constructor(message?: string);
-}
-export declare class UnsupportedServer extends LivekitError {
-    readonly name = "UnsupportedServer";
-    constructor(message?: string);
-}
-export declare class UnexpectedConnectionState extends LivekitError {
-    readonly name = "UnexpectedConnectionState";
-    constructor(message?: string);
-}
-export declare class NegotiationError extends LivekitError {
-    readonly name = "NegotiationError";
-    constructor(message?: string);
-}
-export declare class PublishDataError extends LivekitError {
-    readonly name = "PublishDataError";
-    constructor(message?: string);
-}
-export declare class PublishTrackError extends LivekitError {
-    readonly name = "PublishTrackError";
-    status: number;
-    constructor(message: string, status: number);
-}
-export type RequestErrorReason = Exclude<RequestResponse_Reason, RequestResponse_Reason.OK> | 'TimeoutError';
-export declare class SignalRequestError extends LivekitReasonedError<RequestErrorReason> {
-    readonly name = "SignalRequestError";
-    reason: RequestErrorReason;
-    reasonName: string;
-    constructor(message: string, reason: RequestErrorReason);
-}
-export declare enum DataStreamErrorReason {
-    AlreadyOpened = 0,
-    AbnormalEnd = 1,
-    DecodeFailed = 2,
-    LengthExceeded = 3,
-    Incomplete = 4,
-    HandlerAlreadyRegistered = 7,
-    EncryptionTypeMismatch = 8,
-    HeaderTooLarge = 9,
-    PayloadTooLarge = 10
-}
-export declare class DataStreamError extends LivekitReasonedError<DataStreamErrorReason> {
-    readonly name = "DataStreamError";
-    reason: DataStreamErrorReason;
-    reasonName: string;
-    constructor(message: string, reason: DataStreamErrorReason);
-}
-export declare class SignalReconnectError extends LivekitError {
-    readonly name = "SignalReconnectError";
-    constructor(message?: string);
-}
-export declare enum MediaDeviceFailure {
-    PermissionDenied = "PermissionDenied",
-    NotFound = "NotFound",
-    DeviceInUse = "DeviceInUse",
-    Other = "Other"
-}
-export declare namespace MediaDeviceFailure {
-    function getFailure(error: any): MediaDeviceFailure | undefined;
-}
-export {};
-//# sourceMappingURL=errors.d.ts.map
+import { DisconnectReason, RequestResponse_Reason } from '@livekit/protocol';
+/** Base error that all LiveKit specific custom errors inherit from. */
+export declare class LivekitError extends Error {
+    code: number;
+    cause?: unknown;
+    constructor(code: number, message?: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * LiveKit specific error type representing an error with an associated set of reasons.
+ * Use this to represent an error with multiple different but contextually related variants.
+ * */
+export declare abstract class LivekitReasonedError<Reason> extends LivekitError {
+    abstract reason: Reason;
+    abstract reasonName: string;
+}
+export declare class SimulatedError extends LivekitError {
+    readonly name = "simulated";
+    constructor(message?: string);
+}
+export declare enum ConnectionErrorReason {
+    NotAllowed = 0,
+    ServerUnreachable = 1,
+    InternalError = 2,
+    Cancelled = 3,
+    LeaveRequest = 4,
+    Timeout = 5,
+    WebSocket = 6,
+    ServiceNotFound = 7
+}
+type NotAllowed = {
+    reason: ConnectionErrorReason.NotAllowed;
+    status: number;
+    context?: unknown;
+};
+type InternalError = {
+    reason: ConnectionErrorReason.InternalError;
+    status: never;
+    context?: {
+        status?: number;
+        statusText?: string;
+    };
+};
+type ConnectionTimeout = {
+    reason: ConnectionErrorReason.Timeout;
+    status: never;
+    context: never;
+};
+type LeaveRequest = {
+    reason: ConnectionErrorReason.LeaveRequest;
+    status: never;
+    context: DisconnectReason;
+};
+type Cancelled = {
+    reason: ConnectionErrorReason.Cancelled;
+    status: never;
+    context: never;
+};
+type ServerUnreachable = {
+    reason: ConnectionErrorReason.ServerUnreachable;
+    status?: number;
+    context?: never;
+};
+type WebSocket = {
+    reason: ConnectionErrorReason.WebSocket;
+    status?: number;
+    context?: string;
+};
+type ServiceNotFound = {
+    reason: ConnectionErrorReason.ServiceNotFound;
+    status: never;
+    context: string;
+};
+type ConnectionErrorVariants = NotAllowed | ConnectionTimeout | LeaveRequest | InternalError | Cancelled | ServerUnreachable | WebSocket | ServiceNotFound;
+export declare class ConnectionError<Variant extends ConnectionErrorVariants = ConnectionErrorVariants> extends LivekitReasonedError<Variant['reason']> {
+    status?: Variant['status'];
+    context: Variant['context'];
+    reason: Variant['reason'];
+    reasonName: string;
+    readonly name = "ConnectionError";
+    protected constructor(message: string, reason: Variant['reason'], status?: Variant['status'], context?: Variant['context']);
+    static notAllowed(message: string, status: number, context?: unknown): ConnectionError<NotAllowed>;
+    static timeout(message: string): ConnectionError<ConnectionTimeout>;
+    static leaveRequest(message: string, context: DisconnectReason): ConnectionError<LeaveRequest>;
+    static internal(message: string, context?: {
+        status?: number;
+        statusText?: string;
+    }): ConnectionError<InternalError>;
+    static cancelled(message: string): ConnectionError<Cancelled>;
+    static serverUnreachable(message: string, status?: number): ConnectionError<ServerUnreachable>;
+    static websocket(message: string, status?: number, reason?: string): ConnectionError<WebSocket>;
+    static serviceNotFound(message: string, serviceName: 'v0-rtc'): ConnectionError<ServiceNotFound>;
+}
+/**
+ * Whether a failed connection attempt may be retried against a different LiveKit Cloud region.
+ *
+ * LiveKit Cloud signals project-level region pinning by returning 403 on the RTC paths when the
+ * project is not allowed in the region the client geo-routed to. `/settings/regions` is
+ * deliberately left reachable so the client can discover its allowed regions and connect there, so
+ * a 403 must not be treated as terminal.
+ *
+ * A 401 stays terminal: no other region will accept a token this one rejected. So does the 404
+ * "requested room does not exist" case, which is also reported as `NotAllowed`.
+ *
+ * We key on the status rather than the server's error message because that message is an
+ * unversioned human-readable string; matching it would let a copy edit break already-shipped
+ * clients. If a 403 really was a permissions failure rather than region pinning, every region
+ * attempt fails the same way and the original error still surfaces — at the cost of one extra
+ * region lookup.
+ */
+export declare function canFailOverToAnotherRegion(error: ConnectionError): boolean;
+export declare class DeviceUnsupportedError extends LivekitError {
+    readonly name = "DeviceUnsupportedError";
+    constructor(message?: string);
+}
+export declare class TrackInvalidError extends LivekitError {
+    readonly name = "TrackInvalidError";
+    constructor(message?: string);
+}
+export declare class UnsupportedServer extends LivekitError {
+    readonly name = "UnsupportedServer";
+    constructor(message?: string);
+}
+export declare class UnexpectedConnectionState extends LivekitError {
+    readonly name = "UnexpectedConnectionState";
+    constructor(message?: string);
+}
+export declare class NegotiationError extends LivekitError {
+    readonly name = "NegotiationError";
+    constructor(message?: string);
+}
+export declare class PublishDataError extends LivekitError {
+    readonly name = "PublishDataError";
+    constructor(message?: string);
+}
+export declare class PublishTrackError extends LivekitError {
+    readonly name = "PublishTrackError";
+    status: number;
+    constructor(message: string, status: number);
+}
+export type RequestErrorReason = Exclude<RequestResponse_Reason, RequestResponse_Reason.OK> | 'TimeoutError';
+export declare class SignalRequestError extends LivekitReasonedError<RequestErrorReason> {
+    readonly name = "SignalRequestError";
+    reason: RequestErrorReason;
+    reasonName: string;
+    constructor(message: string, reason: RequestErrorReason);
+}
+export declare enum DataStreamErrorReason {
+    AlreadyOpened = 0,
+    AbnormalEnd = 1,
+    DecodeFailed = 2,
+    LengthExceeded = 3,
+    Incomplete = 4,
+    HandlerAlreadyRegistered = 7,
+    EncryptionTypeMismatch = 8,
+    HeaderTooLarge = 9,
+    PayloadTooLarge = 10
+}
+export declare class DataStreamError extends LivekitReasonedError<DataStreamErrorReason> {
+    readonly name = "DataStreamError";
+    reason: DataStreamErrorReason;
+    reasonName: string;
+    constructor(message: string, reason: DataStreamErrorReason);
+}
+export declare class SignalReconnectError extends LivekitError {
+    readonly name = "SignalReconnectError";
+    constructor(message?: string);
+}
+export declare enum MediaDeviceFailure {
+    PermissionDenied = "PermissionDenied",
+    NotFound = "NotFound",
+    DeviceInUse = "DeviceInUse",
+    Other = "Other"
+}
+export declare namespace MediaDeviceFailure {
+    function getFailure(error: any): MediaDeviceFailure | undefined;
+}
+export {};
+//# sourceMappingURL=errors.d.ts.map