livekit-client 2.22.3 → 2.22.4

package/dist/ts4.2/e2ee/E2eeManager.d.ts

@@ -1,111 +1,111 @@
-import type TypedEventEmitter from 'typed-emitter';
-import type RTCEngine from '../room/RTCEngine';
-import type Room from '../room/Room';
-import type { NonSharedUint8Array } from '../type-polyfills/non-shared-typed-arrays';
-import type { E2EEManagerCallbacks } from './events';
-import type { DecryptDataResponseMessage, E2EEManagerOptions, EncryptDataResponseMessage } from './types';
-export interface BaseE2EEManager {
-    setup(room: Room): void;
-    setupEngine(engine: RTCEngine): void;
-    isEnabled: boolean;
-    isDataChannelEncryptionEnabled: boolean;
-    setParticipantCryptorEnabled(enabled: boolean, participantIdentity: string): void;
-    setSifTrailer(trailer: NonSharedUint8Array): void;
-    encryptData(data: NonSharedUint8Array): Promise<EncryptDataResponseMessage['data']>;
-    handleEncryptedData(payload: NonSharedUint8Array, iv: NonSharedUint8Array, participantIdentity: string, keyIndex: number): Promise<DecryptDataResponseMessage['data']>;
-    on<E extends keyof E2EEManagerCallbacks>(event: E, listener: E2EEManagerCallbacks[E]): this;
-    dispose?(): void;
-}
-declare const E2EEManager_base: new () => TypedEventEmitter<E2EEManagerCallbacks>;
-/**
- * @experimental
- */
-export declare class E2EEManager extends E2EEManager_base implements BaseE2EEManager {
-    protected worker: Worker;
-    protected room?: Room;
-    private encryptionEnabled;
-    private keyProvider;
-    private decryptDataRequests;
-    private encryptDataRequests;
-    private dataChannelEncryptionEnabled;
-    private unsubscribeLogLevel?;
-    private log;
-    get logContext(): {
-        room: string | undefined;
-        participant: string | undefined;
-    };
-    /**
-     * Runs a cleanup callback once this manager is garbage collected. Lets the
-     * log-level listener (held in a module-global Set on the main-thread logger)
-     * fall out of scope even when the consumer forgets to call `dispose()`.
-     */
-    private static disposeRegistry;
-    constructor(options: E2EEManagerOptions, dcEncryptionEnabled: boolean);
-    get isEnabled(): boolean;
-    get isDataChannelEncryptionEnabled(): boolean;
-    /**
-     * @internal
-     */
-    setup(room: Room): void;
-    /**
-     * Subscribe the current worker to main-thread `workerLogger` level changes,
-     * without strongly retaining `this` or `this.worker` from the module-global
-     * listener Set on the logger. See {@link disposeRegistry}.
-     */
-    private subscribeToLogLevelChanges;
-    /**
-     * @internal
-     * Release the log-level subscription, reject any pending encrypt/decrypt
-     * futures, and detach the worker message handlers. The worker itself is
-     * caller-owned and is not terminated. Idempotent.
-     */
-    dispose(): void;
-    /**
-     * @internal
-     */
-    setParticipantCryptorEnabled(enabled: boolean, participantIdentity: string): void;
-    /**
-     * @internal
-     */
-    setSifTrailer(trailer: NonSharedUint8Array): void;
-    private onWorkerMessage;
-    private onWorkerError;
-    private handleFrameMetadata;
-    setupEngine(engine: RTCEngine): void;
-    private setupEventListeners;
-    encryptData(data: NonSharedUint8Array): Promise<EncryptDataResponseMessage['data']>;
-    handleEncryptedData(payload: NonSharedUint8Array, iv: NonSharedUint8Array, participantIdentity: string, keyIndex: number): Promise<{
-        uuid: string;
-        payload: NonSharedUint8Array;
-    } & {
-        readonly __throws?: Error | undefined;
-    }>;
-    private postRatchetRequest;
-    private postKey;
-    private postEnable;
-    private postRTPMap;
-    private postSifTrailer;
-    /**
-     * Derive the participant's encryption state from one of its publications.
-     * Publications without trackInfo are skipped rather than thrown on: throwing
-     * inside the forEach above would leave every remaining participant without an
-     * encryption state, and a cryptor with unknown state can no longer decrypt.
-     */
-    private setParticipantCryptorEnabledForPublication;
-    private setupE2EEReceiver;
-    private setupE2EESender;
-    /**
-     * Handles the given {@code RTCRtpReceiver} by creating a {@code TransformStream} which will inject
-     * a frame decoder.
-     *
-     */
-    private handleReceiver;
-    /**
-     * Handles the given {@code RTCRtpSender} by creating a {@code TransformStream} which will inject
-     * a frame encoder.
-     *
-     */
-    private handleSender;
-}
-export {};
-//# sourceMappingURL=E2eeManager.d.ts.map
+import type TypedEventEmitter from 'typed-emitter';
+import type RTCEngine from '../room/RTCEngine';
+import type Room from '../room/Room';
+import type { NonSharedUint8Array } from '../type-polyfills/non-shared-typed-arrays';
+import type { E2EEManagerCallbacks } from './events';
+import type { DecryptDataResponseMessage, E2EEManagerOptions, EncryptDataResponseMessage } from './types';
+export interface BaseE2EEManager {
+    setup(room: Room): void;
+    setupEngine(engine: RTCEngine): void;
+    isEnabled: boolean;
+    isDataChannelEncryptionEnabled: boolean;
+    setParticipantCryptorEnabled(enabled: boolean, participantIdentity: string): void;
+    setSifTrailer(trailer: NonSharedUint8Array): void;
+    encryptData(data: NonSharedUint8Array): Promise<EncryptDataResponseMessage['data']>;
+    handleEncryptedData(payload: NonSharedUint8Array, iv: NonSharedUint8Array, participantIdentity: string, keyIndex: number): Promise<DecryptDataResponseMessage['data']>;
+    on<E extends keyof E2EEManagerCallbacks>(event: E, listener: E2EEManagerCallbacks[E]): this;
+    dispose?(): void;
+}
+declare const E2EEManager_base: new () => TypedEventEmitter<E2EEManagerCallbacks>;
+/**
+ * @experimental
+ */
+export declare class E2EEManager extends E2EEManager_base implements BaseE2EEManager {
+    protected worker: Worker;
+    protected room?: Room;
+    private encryptionEnabled;
+    private keyProvider;
+    private decryptDataRequests;
+    private encryptDataRequests;
+    private dataChannelEncryptionEnabled;
+    private unsubscribeLogLevel?;
+    private log;
+    get logContext(): {
+        room: string | undefined;
+        participant: string | undefined;
+    };
+    /**
+     * Runs a cleanup callback once this manager is garbage collected. Lets the
+     * log-level listener (held in a module-global Set on the main-thread logger)
+     * fall out of scope even when the consumer forgets to call `dispose()`.
+     */
+    private static disposeRegistry;
+    constructor(options: E2EEManagerOptions, dcEncryptionEnabled: boolean);
+    get isEnabled(): boolean;
+    get isDataChannelEncryptionEnabled(): boolean;
+    /**
+     * @internal
+     */
+    setup(room: Room): void;
+    /**
+     * Subscribe the current worker to main-thread `workerLogger` level changes,
+     * without strongly retaining `this` or `this.worker` from the module-global
+     * listener Set on the logger. See {@link disposeRegistry}.
+     */
+    private subscribeToLogLevelChanges;
+    /**
+     * @internal
+     * Release the log-level subscription, reject any pending encrypt/decrypt
+     * futures, and detach the worker message handlers. The worker itself is
+     * caller-owned and is not terminated. Idempotent.
+     */
+    dispose(): void;
+    /**
+     * @internal
+     */
+    setParticipantCryptorEnabled(enabled: boolean, participantIdentity: string): void;
+    /**
+     * @internal
+     */
+    setSifTrailer(trailer: NonSharedUint8Array): void;
+    private onWorkerMessage;
+    private onWorkerError;
+    private handleFrameMetadata;
+    setupEngine(engine: RTCEngine): void;
+    private setupEventListeners;
+    encryptData(data: NonSharedUint8Array): Promise<EncryptDataResponseMessage['data']>;
+    handleEncryptedData(payload: NonSharedUint8Array, iv: NonSharedUint8Array, participantIdentity: string, keyIndex: number): Promise<{
+        uuid: string;
+        payload: NonSharedUint8Array;
+    } & {
+        readonly __throws?: Error | undefined;
+    }>;
+    private postRatchetRequest;
+    private postKey;
+    private postEnable;
+    private postRTPMap;
+    private postSifTrailer;
+    /**
+     * Derive the participant's encryption state from one of its publications.
+     * Publications without trackInfo are skipped rather than thrown on: throwing
+     * inside the forEach above would leave every remaining participant without an
+     * encryption state, and a cryptor with unknown state can no longer decrypt.
+     */
+    private setParticipantCryptorEnabledForPublication;
+    private setupE2EEReceiver;
+    private setupE2EESender;
+    /**
+     * Handles the given {@code RTCRtpReceiver} by creating a {@code TransformStream} which will inject
+     * a frame decoder.
+     *
+     */
+    private handleReceiver;
+    /**
+     * Handles the given {@code RTCRtpSender} by creating a {@code TransformStream} which will inject
+     * a frame encoder.
+     *
+     */
+    private handleSender;
+}
+export {};
+//# sourceMappingURL=E2eeManager.d.ts.map

package/dist/ts4.2/e2ee/KeyProvider.d.ts

@@ -1,54 +1,54 @@
-import type TypedEventEmitter from 'typed-emitter';
-import type { KeyProviderCallbacks } from './events';
-import type { KeyInfo, KeyProviderOptions, RatchetResult } from './types';
-declare const BaseKeyProvider_base: new () => TypedEventEmitter<KeyProviderCallbacks>;
-/**
- * @experimental
- */
-export declare class BaseKeyProvider extends BaseKeyProvider_base {
-    private keyInfoMap;
-    private readonly options;
-    private latestManuallySetKeyIndex;
-    constructor(options?: Partial<KeyProviderOptions>);
-    /**
-     * callback to invoke once a key has been set for a participant
-     * @param key
-     * @param participantIdentity
-     * @param keyIndex
-     */
-    protected onSetEncryptionKey(key: CryptoKey, participantIdentity?: string, keyIndex?: number): void;
-    /**
-     * Callback being invoked after a key has been ratcheted.
-     * Can happen when:
-     * - A decryption failure occurs and the key is auto-ratcheted
-     * - A ratchet request is sent (see {@link ratchetKey()})
-     * @param ratchetResult Contains the ratcheted chain key (exportable to other participants) and the derived new key material.
-     * @param participantId
-     * @param keyIndex
-     */
-    protected onKeyRatcheted: (ratchetResult: RatchetResult, participantId?: string, keyIndex?: number) => void;
-    getKeys(): KeyInfo[];
-    getLatestManuallySetKeyIndex(): number;
-    getOptions(): KeyProviderOptions;
-    ratchetKey(participantIdentity?: string, keyIndex?: number): void;
-}
-/**
- * A basic KeyProvider implementation intended for a single shared
- * passphrase between all participants
- * @experimental
- */
-export declare class ExternalE2EEKeyProvider extends BaseKeyProvider {
-    ratchetInterval: number | undefined;
-    constructor(options?: Partial<Omit<KeyProviderOptions, 'sharedKey'>>);
-    /**
-     * Accepts a passphrase that's used to create the crypto keys.
-     * When passing in a string, PBKDF2 is used. (recommended for maximum compatibility across SDKs)
-     * When passing in an ArrayBuffer of cryptographically random numbers, HKDF is used.
-     *
-     * Note: Not all client SDKS support HKDF.
-     * @param key
-     */
-    setKey(key: string | ArrayBuffer): Promise<void>;
-}
-export {};
-//# sourceMappingURL=KeyProvider.d.ts.map
+import type TypedEventEmitter from 'typed-emitter';
+import type { KeyProviderCallbacks } from './events';
+import type { KeyInfo, KeyProviderOptions, RatchetResult } from './types';
+declare const BaseKeyProvider_base: new () => TypedEventEmitter<KeyProviderCallbacks>;
+/**
+ * @experimental
+ */
+export declare class BaseKeyProvider extends BaseKeyProvider_base {
+    private keyInfoMap;
+    private readonly options;
+    private latestManuallySetKeyIndex;
+    constructor(options?: Partial<KeyProviderOptions>);
+    /**
+     * callback to invoke once a key has been set for a participant
+     * @param key
+     * @param participantIdentity
+     * @param keyIndex
+     */
+    protected onSetEncryptionKey(key: CryptoKey, participantIdentity?: string, keyIndex?: number): void;
+    /**
+     * Callback being invoked after a key has been ratcheted.
+     * Can happen when:
+     * - A decryption failure occurs and the key is auto-ratcheted
+     * - A ratchet request is sent (see {@link ratchetKey()})
+     * @param ratchetResult Contains the ratcheted chain key (exportable to other participants) and the derived new key material.
+     * @param participantId
+     * @param keyIndex
+     */
+    protected onKeyRatcheted: (ratchetResult: RatchetResult, participantId?: string, keyIndex?: number) => void;
+    getKeys(): KeyInfo[];
+    getLatestManuallySetKeyIndex(): number;
+    getOptions(): KeyProviderOptions;
+    ratchetKey(participantIdentity?: string, keyIndex?: number): void;
+}
+/**
+ * A basic KeyProvider implementation intended for a single shared
+ * passphrase between all participants
+ * @experimental
+ */
+export declare class ExternalE2EEKeyProvider extends BaseKeyProvider {
+    ratchetInterval: number | undefined;
+    constructor(options?: Partial<Omit<KeyProviderOptions, 'sharedKey'>>);
+    /**
+     * Accepts a passphrase that's used to create the crypto keys.
+     * When passing in a string, PBKDF2 is used. (recommended for maximum compatibility across SDKs)
+     * When passing in an ArrayBuffer of cryptographically random numbers, HKDF is used.
+     *
+     * Note: Not all client SDKS support HKDF.
+     * @param key
+     */
+    setKey(key: string | ArrayBuffer): Promise<void>;
+}
+export {};
+//# sourceMappingURL=KeyProvider.d.ts.map

package/dist/ts4.2/e2ee/constants.d.ts

@@ -1,21 +1,21 @@
-import type { KeyProviderOptions } from './types';
-export declare const ENCRYPTION_ALGORITHM = "AES-GCM";
-export declare const DECRYPTION_FAILURE_TOLERANCE = 10;
-export declare const UNENCRYPTED_BYTES: {
-    readonly key: 10;
-    readonly delta: 3;
-    readonly audio: 1;
-    readonly empty: 0;
-};
-export declare const IV_LENGTH = 12;
-export declare const E2EE_FLAG = "lk_e2ee";
-/**
- * trackId a receiver's/sender's encoded stream pipeline was last set up for.
- * Needed to recover the right cryptor when a transceiver gets reused.
- */
-export declare const E2EE_TRACK_ID = "lk_e2ee_track_id";
-export declare const SALT = "LKFrameEncryptionKey";
-export declare const KEY_PROVIDER_DEFAULTS: KeyProviderOptions;
-export declare const MAX_SIF_COUNT = 100;
-export declare const MAX_SIF_DURATION = 2000;
-//# sourceMappingURL=constants.d.ts.map
+import type { KeyProviderOptions } from './types';
+export declare const ENCRYPTION_ALGORITHM = "AES-GCM";
+export declare const DECRYPTION_FAILURE_TOLERANCE = 10;
+export declare const UNENCRYPTED_BYTES: {
+    readonly key: 10;
+    readonly delta: 3;
+    readonly audio: 1;
+    readonly empty: 0;
+};
+export declare const IV_LENGTH = 12;
+export declare const E2EE_FLAG = "lk_e2ee";
+/**
+ * trackId a receiver's/sender's encoded stream pipeline was last set up for.
+ * Needed to recover the right cryptor when a transceiver gets reused.
+ */
+export declare const E2EE_TRACK_ID = "lk_e2ee_track_id";
+export declare const SALT = "LKFrameEncryptionKey";
+export declare const KEY_PROVIDER_DEFAULTS: KeyProviderOptions;
+export declare const MAX_SIF_COUNT = 100;
+export declare const MAX_SIF_DURATION = 2000;
+//# sourceMappingURL=constants.d.ts.map

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

@@ -1,12 +1,12 @@
-import { LivekitError } from '../room/errors';
-export declare enum CryptorErrorReason {
-    InvalidKey = 0,
-    MissingKey = 1,
-    InternalError = 2
-}
-export declare class CryptorError extends LivekitError {
-    reason: CryptorErrorReason;
-    participantIdentity?: string;
-    constructor(message?: string, reason?: CryptorErrorReason, participantIdentity?: string);
-}
-//# sourceMappingURL=errors.d.ts.map
+import { LivekitError } from '../room/errors';
+export declare enum CryptorErrorReason {
+    InvalidKey = 0,
+    MissingKey = 1,
+    InternalError = 2
+}
+export declare class CryptorError extends LivekitError {
+    reason: CryptorErrorReason;
+    participantIdentity?: string;
+    constructor(message?: string, reason?: CryptorErrorReason, participantIdentity?: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/ts4.2/e2ee/events.d.ts

@@ -1,39 +1,39 @@
-import type Participant from '../room/participant/Participant';
-import type { CryptorError } from './errors';
-import type { KeyInfo, RatchetResult } from './types';
-export declare enum KeyProviderEvent {
-    SetKey = "setKey",
-    /** Event for requesting to ratchet the key used to encrypt the stream */
-    RatchetRequest = "ratchetRequest",
-    /** Emitted when a key is ratcheted. Could be after auto-ratcheting on decryption failure or
-     *  following a `RatchetRequest`, will contain the ratcheted key material */
-    KeyRatcheted = "keyRatcheted"
-}
-export type KeyProviderCallbacks = {
-    [KeyProviderEvent.SetKey]: (keyInfo: KeyInfo, updateCurrentKeyIndex: boolean) => void;
-    [KeyProviderEvent.RatchetRequest]: (participantIdentity?: string, keyIndex?: number) => void;
-    [KeyProviderEvent.KeyRatcheted]: (ratchetedResult: RatchetResult, participantIdentity?: string, keyIndex?: number) => void;
-};
-export declare enum KeyHandlerEvent {
-    /** Emitted when a key has been ratcheted. Is emitted when any key has been ratcheted
-     * i.e. when the FrameCryptor tried to ratchet when decryption is failing  */
-    KeyRatcheted = "keyRatcheted"
-}
-export type ParticipantKeyHandlerCallbacks = {
-    [KeyHandlerEvent.KeyRatcheted]: (ratchetResult: RatchetResult, participantIdentity: string, keyIndex?: number) => void;
-};
-export declare enum EncryptionEvent {
-    ParticipantEncryptionStatusChanged = "participantEncryptionStatusChanged",
-    EncryptionError = "encryptionError"
-}
-export type E2EEManagerCallbacks = {
-    [EncryptionEvent.ParticipantEncryptionStatusChanged]: (enabled: boolean, participant: Participant) => void;
-    [EncryptionEvent.EncryptionError]: (error: Error, participantIdentity?: string) => void;
-};
-export type CryptorCallbacks = {
-    [CryptorEvent.Error]: (error: CryptorError) => void;
-};
-export declare enum CryptorEvent {
-    Error = "cryptorError"
-}
-//# sourceMappingURL=events.d.ts.map
+import type Participant from '../room/participant/Participant';
+import type { CryptorError } from './errors';
+import type { KeyInfo, RatchetResult } from './types';
+export declare enum KeyProviderEvent {
+    SetKey = "setKey",
+    /** Event for requesting to ratchet the key used to encrypt the stream */
+    RatchetRequest = "ratchetRequest",
+    /** Emitted when a key is ratcheted. Could be after auto-ratcheting on decryption failure or
+     *  following a `RatchetRequest`, will contain the ratcheted key material */
+    KeyRatcheted = "keyRatcheted"
+}
+export type KeyProviderCallbacks = {
+    [KeyProviderEvent.SetKey]: (keyInfo: KeyInfo, updateCurrentKeyIndex: boolean) => void;
+    [KeyProviderEvent.RatchetRequest]: (participantIdentity?: string, keyIndex?: number) => void;
+    [KeyProviderEvent.KeyRatcheted]: (ratchetedResult: RatchetResult, participantIdentity?: string, keyIndex?: number) => void;
+};
+export declare enum KeyHandlerEvent {
+    /** Emitted when a key has been ratcheted. Is emitted when any key has been ratcheted
+     * i.e. when the FrameCryptor tried to ratchet when decryption is failing  */
+    KeyRatcheted = "keyRatcheted"
+}
+export type ParticipantKeyHandlerCallbacks = {
+    [KeyHandlerEvent.KeyRatcheted]: (ratchetResult: RatchetResult, participantIdentity: string, keyIndex?: number) => void;
+};
+export declare enum EncryptionEvent {
+    ParticipantEncryptionStatusChanged = "participantEncryptionStatusChanged",
+    EncryptionError = "encryptionError"
+}
+export type E2EEManagerCallbacks = {
+    [EncryptionEvent.ParticipantEncryptionStatusChanged]: (enabled: boolean, participant: Participant) => void;
+    [EncryptionEvent.EncryptionError]: (error: Error, participantIdentity?: string) => void;
+};
+export type CryptorCallbacks = {
+    [CryptorEvent.Error]: (error: CryptorError) => void;
+};
+export declare enum CryptorEvent {
+    Error = "cryptorError"
+}
+//# sourceMappingURL=events.d.ts.map

package/dist/ts4.2/e2ee/index.d.ts

@@ -1,6 +1,6 @@
-export * from './KeyProvider';
-export * from './utils';
-export * from './types';
-export * from './events';
-export * from './errors';
-//# sourceMappingURL=index.d.ts.map
+export * from './KeyProvider';
+export * from './utils';
+export * from './types';
+export * from './events';
+export * from './errors';
+//# sourceMappingURL=index.d.ts.map