livekit-client 2.22.2 → 2.22.4

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