livekit-client 2.22.3 → 2.23.0

package/dist/ts4.2/test/signalToken.d.ts

@@ -1,26 +1,26 @@
-/**
- * Mint a LiveKit access token for the mock test-server (HS256, dev secret).
- *
- * The mock's signal behavior mode is selected via a participant attribute
- * under the reserved key `lk.mock` (dot notation, matching LiveKit's internal
- * attribute convention), whose value is the JSON control object
- * `{"signal":"<mode>"}` — mirroring the X-Lk-Mock header protocol. Attributes
- * are a standard AccessToken field (a string map), so a dedicated `lk-mock`
- * key coexists with any real metadata/attributes and needs no bespoke token
- * construction. The room name is just a room; it no longer encodes behavior.
- */
-export interface TokenOptions {
-    /** Mock behavior mode (e.g. 'no_pong'); omitted → the mock defaults to 'happy'. */
-    signal?: string;
-    /** LeaveRequest action the leave modes should send (0=DISCONNECT,1=RESUME,2=RECONNECT). */
-    leaveAction?: number;
-    room?: string;
-    identity?: string;
-    apiKey?: string;
-    secret?: string;
-    ttlSeconds?: number;
-}
-export declare function createToken(opts?: TokenOptions): Promise<string>;
-/** A syntactically-valid token signed with the WRONG secret — for 401 tests. */
-export declare function createInvalidToken(): Promise<string>;
-//# sourceMappingURL=signalToken.d.ts.map
+/**
+ * Mint a LiveKit access token for the mock test-server (HS256, dev secret).
+ *
+ * The mock's signal behavior mode is selected via a participant attribute
+ * under the reserved key `lk.mock` (dot notation, matching LiveKit's internal
+ * attribute convention), whose value is the JSON control object
+ * `{"signal":"<mode>"}` — mirroring the X-Lk-Mock header protocol. Attributes
+ * are a standard AccessToken field (a string map), so a dedicated `lk-mock`
+ * key coexists with any real metadata/attributes and needs no bespoke token
+ * construction. The room name is just a room; it no longer encodes behavior.
+ */
+export interface TokenOptions {
+    /** Mock behavior mode (e.g. 'no_pong'); omitted → the mock defaults to 'happy'. */
+    signal?: string;
+    /** LeaveRequest action the leave modes should send (0=DISCONNECT,1=RESUME,2=RECONNECT). */
+    leaveAction?: number;
+    room?: string;
+    identity?: string;
+    apiKey?: string;
+    secret?: string;
+    ttlSeconds?: number;
+}
+export declare function createToken(opts?: TokenOptions): Promise<string>;
+/** A syntactically-valid token signed with the WRONG secret — for 401 tests. */
+export declare function createInvalidToken(): Promise<string>;
+//# sourceMappingURL=signalToken.d.ts.map

package/dist/ts4.2/type-polyfills/non-shared-typed-arrays.d.ts

@@ -1,2 +1,2 @@
-export type NonSharedUint8Array = ReturnType<typeof Uint8Array.from>;
-//# sourceMappingURL=non-shared-typed-arrays.d.ts.map
+export type NonSharedUint8Array = ReturnType<typeof Uint8Array.from>;
+//# sourceMappingURL=non-shared-typed-arrays.d.ts.map

package/dist/ts4.2/utils/AsyncQueue.d.ts

@@ -1,23 +1,23 @@
-type QueueTask<T> = () => PromiseLike<T>;
-declare enum QueueTaskStatus {
-    WAITING = 0,
-    RUNNING = 1,
-    COMPLETED = 2
-}
-type QueueTaskInfo = {
-    id: number;
-    enqueuedAt: number;
-    executedAt?: number;
-    status: QueueTaskStatus;
-};
-export declare class AsyncQueue {
-    private pendingTasks;
-    private taskMutex;
-    private nextTaskIndex;
-    constructor();
-    run<T>(task: QueueTask<T>): Promise<T>;
-    flush(): Promise<void>;
-    snapshot(): QueueTaskInfo[];
-}
-export {};
-//# sourceMappingURL=AsyncQueue.d.ts.map
+type QueueTask<T> = () => PromiseLike<T>;
+declare enum QueueTaskStatus {
+    WAITING = 0,
+    RUNNING = 1,
+    COMPLETED = 2
+}
+type QueueTaskInfo = {
+    id: number;
+    enqueuedAt: number;
+    executedAt?: number;
+    status: QueueTaskStatus;
+};
+export declare class AsyncQueue {
+    private pendingTasks;
+    private taskMutex;
+    private nextTaskIndex;
+    constructor();
+    run<T>(task: QueueTask<T>): Promise<T>;
+    flush(): Promise<void>;
+    snapshot(): QueueTaskInfo[];
+}
+export {};
+//# sourceMappingURL=AsyncQueue.d.ts.map

package/dist/ts4.2/utils/TypedPromise.d.ts

@@ -1,17 +1,17 @@
-type InferErrors<T> = T extends TypedPromise<any, infer E> ? E : never;
-export default class TypedPromise<T, E extends Error> extends Promise<T> {
-    constructor(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason: E) => void) => void);
-    catch<TResult = never>(onrejected?: ((reason: E) => TResult | PromiseLike<TResult>) | null | undefined): TypedPromise<T | TResult, E>;
-    static resolve: {
-        (): TypedPromise<void, never>;
-        <V>(value: V): TypedPromise<Awaited<V>, never>;
-    };
-    static reject<E extends Error>(reason: E): TypedPromise<never, E>;
-    static all<T extends readonly unknown[] | [
-    ]>(values: T): TypedPromise<{
-        -readonly [P in keyof T]: Awaited<T[P]>;
-    }, InferErrors<T[number]>>;
-    static race<T extends readonly (TypedPromise<any, any> | any)[]>(values: T): TypedPromise<T[number] extends TypedPromise<infer U, any> ? U : T[number] extends PromiseLike<infer U> ? U : Awaited<T[number]>, InferErrors<T[number]>>;
-}
-export {};
-//# sourceMappingURL=TypedPromise.d.ts.map
+type InferErrors<T> = T extends TypedPromise<any, infer E> ? E : never;
+export default class TypedPromise<T, E extends Error> extends Promise<T> {
+    constructor(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason: E) => void) => void);
+    catch<TResult = never>(onrejected?: ((reason: E) => TResult | PromiseLike<TResult>) | null | undefined): TypedPromise<T | TResult, E>;
+    static resolve: {
+        (): TypedPromise<void, never>;
+        <V>(value: V): TypedPromise<Awaited<V>, never>;
+    };
+    static reject<E extends Error>(reason: E): TypedPromise<never, E>;
+    static all<T extends readonly unknown[] | [
+    ]>(values: T): TypedPromise<{
+        -readonly [P in keyof T]: Awaited<T[P]>;
+    }, InferErrors<T[number]>>;
+    static race<T extends readonly (TypedPromise<any, any> | any)[]>(values: T): TypedPromise<T[number] extends TypedPromise<infer U, any> ? U : T[number] extends PromiseLike<infer U> ? U : Awaited<T[number]>, InferErrors<T[number]>>;
+}
+export {};
+//# sourceMappingURL=TypedPromise.d.ts.map

package/dist/ts4.2/utils/abort-signal-polyfill.d.ts

@@ -1,13 +1,13 @@
-/**
- * Implementation of AbortSignal.any
- * Creates a signal that will be aborted when any of the given signals is aborted.
- * @link https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/any
- */
-export declare function abortSignalAny(signals: Array<AbortSignal>): AbortSignal;
-/**
- * Implementation of AbortSignal.timeout
- * Creates a signal that will be aborted after the specified timeout.
- * @link https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/timeout
- */
-export declare function abortSignalTimeout(ms: number): AbortSignal;
-//# sourceMappingURL=abort-signal-polyfill.d.ts.map
+/**
+ * Implementation of AbortSignal.any
+ * Creates a signal that will be aborted when any of the given signals is aborted.
+ * @link https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/any
+ */
+export declare function abortSignalAny(signals: Array<AbortSignal>): AbortSignal;
+/**
+ * Implementation of AbortSignal.timeout
+ * Creates a signal that will be aborted after the specified timeout.
+ * @link https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/timeout
+ */
+export declare function abortSignalTimeout(ms: number): AbortSignal;
+//# sourceMappingURL=abort-signal-polyfill.d.ts.map

package/dist/ts4.2/utils/browserParser.d.ts

@@ -1,13 +1,13 @@
-export type DetectableBrowser = 'Chrome' | 'Firefox' | 'Safari';
-export type DetectableOS = 'iOS' | 'macOS';
-export type BrowserDetails = {
-    name: DetectableBrowser;
-    version: string;
-    os?: DetectableOS;
-    osVersion?: string;
-};
-/**
- * @internal
- */
-export declare function getBrowser(userAgent?: string, force?: boolean): BrowserDetails | undefined;
-//# sourceMappingURL=browserParser.d.ts.map
+export type DetectableBrowser = 'Chrome' | 'Firefox' | 'Safari';
+export type DetectableOS = 'iOS' | 'macOS';
+export type BrowserDetails = {
+    name: DetectableBrowser;
+    version: string;
+    os?: DetectableOS;
+    osVersion?: string;
+};
+/**
+ * @internal
+ */
+export declare function getBrowser(userAgent?: string, force?: boolean): BrowserDetails | undefined;
+//# sourceMappingURL=browserParser.d.ts.map

package/dist/ts4.2/utils/camelToSnakeCase.d.ts

@@ -1,8 +1,8 @@
-export type CamelToSnakeCase<Str extends string> = Str extends `${infer First}${infer Rest}` ? `${First extends Capitalize<First> ? '_' : ''}${Lowercase<First>}${CamelToSnakeCase<Rest>}` : Str;
-type ArrayValuesToSnakeCase<Item> = Array<ValueToSnakeCase<Item>>;
-type ObjectKeysToSnakeCase<Obj> = {
-    [Key in keyof Obj as CamelToSnakeCase<string & Key>]: NonNullable<ValueToSnakeCase<Obj[Key]>>;
-};
-export type ValueToSnakeCase<Value> = Value extends Array<infer Item> ? ArrayValuesToSnakeCase<Item> : Value extends object ? ObjectKeysToSnakeCase<Value> : Value;
-export {};
-//# sourceMappingURL=camelToSnakeCase.d.ts.map
+export type CamelToSnakeCase<Str extends string> = Str extends `${infer First}${infer Rest}` ? `${First extends Capitalize<First> ? '_' : ''}${Lowercase<First>}${CamelToSnakeCase<Rest>}` : Str;
+type ArrayValuesToSnakeCase<Item> = Array<ValueToSnakeCase<Item>>;
+type ObjectKeysToSnakeCase<Obj> = {
+    [Key in keyof Obj as CamelToSnakeCase<string & Key>]: NonNullable<ValueToSnakeCase<Obj[Key]>>;
+};
+export type ValueToSnakeCase<Value> = Value extends Array<infer Item> ? ArrayValuesToSnakeCase<Item> : Value extends object ? ObjectKeysToSnakeCase<Value> : Value;
+export {};
+//# sourceMappingURL=camelToSnakeCase.d.ts.map

package/dist/ts4.2/utils/cloneDeep.d.ts

@@ -1,2 +1,2 @@
-export declare function cloneDeep<T>(value: T): T;
-//# sourceMappingURL=cloneDeep.d.ts.map
+export declare function cloneDeep<T>(value: T): T;
+//# sourceMappingURL=cloneDeep.d.ts.map

package/dist/ts4.2/utils/dataPacketBuffer.d.ts

@@ -1,34 +1,34 @@
-import type { NonSharedUint8Array } from '../type-polyfills/non-shared-typed-arrays';
-export interface DataPacketItem {
-    data: NonSharedUint8Array;
-    sequence: number;
-    /**
-     * Whether the packet has been handed to the data channel. Unsent packets are queued for the
-     * resume replay (e.g. sends that landed in a reconnect window) and must never be trimmed by
-     * {@link DataPacketBuffer.alignBufferedAmount}, which reasons about the channel's buffered
-     * bytes — those only ever contain sent packets.
-     */
-    sent: boolean;
-}
-export declare class DataPacketBuffer {
-    private buffer;
-    private _totalSize;
-    private _sentSize;
-    push(item: DataPacketItem): void;
-    pop(): DataPacketItem | undefined;
-    getAll(): DataPacketItem[];
-    /** Every queued packet not yet handed to the channel, in sequence order. */
-    getUnsent(): DataPacketItem[];
-    /** Marks a single queued packet as handed to the channel. */
-    markSent(item: DataPacketItem): void;
-    /**
-     * Marks every queued packet as not-yet-sent. Used at the start of a resume replay: whatever is
-     * still buffered was sent on the previous channel (or deferred) and must be re-handed to the
-     * current one, so none of it counts as sent until the replay actually transmits it.
-     */
-    markAllUnsent(): void;
-    popToSequence(sequence: number): void;
-    alignBufferedAmount(bufferedAmount: number): void;
-    get length(): number;
-}
-//# sourceMappingURL=dataPacketBuffer.d.ts.map
+import type { NonSharedUint8Array } from '../type-polyfills/non-shared-typed-arrays';
+export interface DataPacketItem {
+    data: NonSharedUint8Array;
+    sequence: number;
+    /**
+     * Whether the packet has been handed to the data channel. Unsent packets are queued for the
+     * resume replay (e.g. sends that landed in a reconnect window) and must never be trimmed by
+     * {@link DataPacketBuffer.alignBufferedAmount}, which reasons about the channel's buffered
+     * bytes — those only ever contain sent packets.
+     */
+    sent: boolean;
+}
+export declare class DataPacketBuffer {
+    private buffer;
+    private _totalSize;
+    private _sentSize;
+    push(item: DataPacketItem): void;
+    pop(): DataPacketItem | undefined;
+    getAll(): DataPacketItem[];
+    /** Every queued packet not yet handed to the channel, in sequence order. */
+    getUnsent(): DataPacketItem[];
+    /** Marks a single queued packet as handed to the channel. */
+    markSent(item: DataPacketItem): void;
+    /**
+     * Marks every queued packet as not-yet-sent. Used at the start of a resume replay: whatever is
+     * still buffered was sent on the previous channel (or deferred) and must be re-handed to the
+     * current one, so none of it counts as sent until the replay actually transmits it.
+     */
+    markAllUnsent(): void;
+    popToSequence(sequence: number): void;
+    alignBufferedAmount(bufferedAmount: number): void;
+    get length(): number;
+}
+//# sourceMappingURL=dataPacketBuffer.d.ts.map

package/dist/ts4.2/utils/deferrable-map.d.ts

@@ -1,32 +1,32 @@
-import type { Throws } from '@livekit/throws-transformer/throws';
-/** An error which is thrown if a {@link DeferrableMap#getDeferred} call is aborted midway
- * through. */
-export declare class DeferrableMapAbortError extends DOMException {
-    reason: unknown;
-    constructor(message: string, reason?: unknown);
-}
-/**
- * A Map-like container keyed by unique strings that supports the ability to wait
- * for future keys to show up in the map.
- *
- * @example
- * // An already existing key:
- * const value = map.get("key");
- * // Wait for a key which will be added soon:
- * const value = await map.getDeferred("key");
- */
-export declare class DeferrableMap<K, V> extends Map<K, V> {
-    private pending;
-    set(key: K, value: V): this;
-    get [Symbol.toStringTag](): string;
-    /**
-     * Returns the value for `key` immediately if it exists, otherwise returns a
-     * promise that resolves once `set(key, value)` is called.
-     *
-     * If an `AbortSignal` is provided and it is aborted before the key appears,
-     * the returned promise rejects with an {@link DeferrableMapAbortError}.
-     */
-    getDeferred(key: K): Promise<V>;
-    getDeferred(key: K, signal: AbortSignal): Promise<Throws<V, DeferrableMapAbortError>>;
-}
-//# sourceMappingURL=deferrable-map.d.ts.map
+import type { Throws } from '@livekit/throws-transformer/throws';
+/** An error which is thrown if a {@link DeferrableMap#getDeferred} call is aborted midway
+ * through. */
+export declare class DeferrableMapAbortError extends DOMException {
+    reason: unknown;
+    constructor(message: string, reason?: unknown);
+}
+/**
+ * A Map-like container keyed by unique strings that supports the ability to wait
+ * for future keys to show up in the map.
+ *
+ * @example
+ * // An already existing key:
+ * const value = map.get("key");
+ * // Wait for a key which will be added soon:
+ * const value = await map.getDeferred("key");
+ */
+export declare class DeferrableMap<K, V> extends Map<K, V> {
+    private pending;
+    set(key: K, value: V): this;
+    get [Symbol.toStringTag](): string;
+    /**
+     * Returns the value for `key` immediately if it exists, otherwise returns a
+     * promise that resolves once `set(key, value)` is called.
+     *
+     * If an `AbortSignal` is provided and it is aborted before the key appears,
+     * the returned promise rejects with an {@link DeferrableMapAbortError}.
+     */
+    getDeferred(key: K): Promise<V>;
+    getDeferred(key: K, signal: AbortSignal): Promise<Throws<V, DeferrableMapAbortError>>;
+}
+//# sourceMappingURL=deferrable-map.d.ts.map

package/dist/ts4.2/utils/machineInspector.d.ts

@@ -1,54 +1,54 @@
-/**
- * Opt-in registry that lets a development tool observe the state machines driving the connection
- * layer.
- *
- * The machines are private to the objects that own them and, more importantly, do not outlive them:
- * a full reconnect replaces the whole engine along with its `SignalClient`, so anything watching a
- * single machine reference goes blind exactly when the interesting part starts. Machines therefore
- * announce themselves here as they are constructed, and a subscriber sees the whole succession.
- *
- * Nothing is recorded until {@link enableMachineInspector} is called, which no shipping code does —
- * with the registry off, announcing is a comparison and a return.
- */
-/**
- * The slice of machina's `Fsm` surface an inspector needs. Structural rather than machina's own
- * type so that any machine satisfies it regardless of its state and input unions.
- */
-export interface InspectableMachine {
-    readonly id: string;
-    readonly initialState: string;
-    readonly states: Record<string, Record<string, unknown>>;
-    readonly context?: unknown;
-    currentState(): string;
-    canHandle(input: string): boolean;
-    on(eventName: string, callback: (data: any) => void): {
-        off(): void;
-    };
-}
-export interface MachineAnnouncement {
-    /** What the machine drives, e.g. `signal`. Not unique: each new `SignalClient` announces one. */
-    label: string;
-    /** How many machines have been announced before this one, so successive instances are tellable apart. */
-    seq: number;
-    /**
-     * When the machine was constructed. Carried on the announcement because subscribers receive the
-     * recorded ones on subscribe, and stamping those at replay time would date them all to whenever
-     * the tool happened to open.
-     */
-    at: number;
-    machine: InspectableMachine;
-}
-/**
- * Starts recording machine announcements. Call before the machines of interest are constructed —
- * for the signal machine that means before the `Room` is created.
- */
-export declare function enableMachineInspector(): void;
-export declare function isMachineInspectorEnabled(): boolean;
-/** Announces a machine to whatever is watching. A no-op unless the inspector was enabled. */
-export declare function announceMachine(label: string, machine: InspectableMachine): void;
-/**
- * Subscribes to machine announcements, replaying the ones already recorded so that a panel opened
- * after connecting still sees the machine currently in charge. Returns an unsubscribe function.
- */
-export declare function onMachineAnnounced(callback: (announcement: MachineAnnouncement) => void): () => void;
-//# sourceMappingURL=machineInspector.d.ts.map
+/**
+ * Opt-in registry that lets a development tool observe the state machines driving the connection
+ * layer.
+ *
+ * The machines are private to the objects that own them and, more importantly, do not outlive them:
+ * a full reconnect replaces the whole engine along with its `SignalClient`, so anything watching a
+ * single machine reference goes blind exactly when the interesting part starts. Machines therefore
+ * announce themselves here as they are constructed, and a subscriber sees the whole succession.
+ *
+ * Nothing is recorded until {@link enableMachineInspector} is called, which no shipping code does —
+ * with the registry off, announcing is a comparison and a return.
+ */
+/**
+ * The slice of machina's `Fsm` surface an inspector needs. Structural rather than machina's own
+ * type so that any machine satisfies it regardless of its state and input unions.
+ */
+export interface InspectableMachine {
+    readonly id: string;
+    readonly initialState: string;
+    readonly states: Record<string, Record<string, unknown>>;
+    readonly context?: unknown;
+    currentState(): string;
+    canHandle(input: string): boolean;
+    on(eventName: string, callback: (data: any) => void): {
+        off(): void;
+    };
+}
+export interface MachineAnnouncement {
+    /** What the machine drives, e.g. `signal`. Not unique: each new `SignalClient` announces one. */
+    label: string;
+    /** How many machines have been announced before this one, so successive instances are tellable apart. */
+    seq: number;
+    /**
+     * When the machine was constructed. Carried on the announcement because subscribers receive the
+     * recorded ones on subscribe, and stamping those at replay time would date them all to whenever
+     * the tool happened to open.
+     */
+    at: number;
+    machine: InspectableMachine;
+}
+/**
+ * Starts recording machine announcements. Call before the machines of interest are constructed —
+ * for the signal machine that means before the `Room` is created.
+ */
+export declare function enableMachineInspector(): void;
+export declare function isMachineInspectorEnabled(): boolean;
+/** Announces a machine to whatever is watching. A no-op unless the inspector was enabled. */
+export declare function announceMachine(label: string, machine: InspectableMachine): void;
+/**
+ * Subscribes to machine announcements, replaying the ones already recorded so that a panel opened
+ * after connecting still sees the machine currently in charge. Returns an unsubscribe function.
+ */
+export declare function onMachineAnnounced(callback: (announcement: MachineAnnouncement) => void): () => void;
+//# sourceMappingURL=machineInspector.d.ts.map

package/dist/ts4.2/utils/serializer.d.ts

@@ -1,48 +1,48 @@
-declare const SerializerSymbol: unique symbol;
-/**
- * A bidirectional data format descriptor for message payloads.
- *
- * - `parse(raw)` decodes an incoming wire string into `Input` (used by handlers)
- * - `serialize(val)` encodes an `Output` value to a wire string (used by handlers)
- *
- * For symmetric serializers (`serializers.raw`), `Input === Output === string`.
- * For `serializers.json`, both default to `any` so each handler can annotate its own types.
- * Use `serializers.custom` to supply your own `parse`/`serialize` pair.
- *
- * @beta
- */
-export type Serializer<Input, Output> = {
-    symbol: typeof SerializerSymbol;
-    parse: (raw: string) => Input;
-    serialize: (val: Output) => string;
-};
-export declare function isSerializer(v: unknown): v is Serializer<any, any>;
-export type SerializerInput<S> = S extends Serializer<infer Input, any> ? Input : any;
-export type SerializerOutput<S> = S extends Serializer<any, infer Output> ? Output : any;
-/**
- * JSON serializer — `JSON.parse` on the way in, `JSON.stringify` on the way out.
- * Defaults to `any` so individual handlers can annotate their own payload types.
- */
-declare function json<Input = any, Output = any>(): Serializer<Input, Output>;
-/** Raw string serializer — passes payloads through as plain strings with no encoding. */
-declare function raw(): Serializer<string, string>;
-/** Custom serializer - allows custom defined parse and serialize functions */
-declare function custom<Input = any, Output = any>(params: Omit<Serializer<Input, Output>, 'symbol'>): Serializer<Input, Output>;
-/**
- * Serializer helpers for message payload encoding.
- *
- * @example
- * ```ts
- * const a = serializers.raw(); // Serializer<string, string>
- * const b = serializer.json<{ foo: string }, { bar: string }>(); // Serializer<{ foo: string }, { bar: string }>
- * ```
- *
- * @beta
- */
-export declare const serializers: {
-    json: typeof json;
-    raw: typeof raw;
-    custom: typeof custom;
-};
-export {};
-//# sourceMappingURL=serializer.d.ts.map
+declare const SerializerSymbol: unique symbol;
+/**
+ * A bidirectional data format descriptor for message payloads.
+ *
+ * - `parse(raw)` decodes an incoming wire string into `Input` (used by handlers)
+ * - `serialize(val)` encodes an `Output` value to a wire string (used by handlers)
+ *
+ * For symmetric serializers (`serializers.raw`), `Input === Output === string`.
+ * For `serializers.json`, both default to `any` so each handler can annotate its own types.
+ * Use `serializers.custom` to supply your own `parse`/`serialize` pair.
+ *
+ * @beta
+ */
+export type Serializer<Input, Output> = {
+    symbol: typeof SerializerSymbol;
+    parse: (raw: string) => Input;
+    serialize: (val: Output) => string;
+};
+export declare function isSerializer(v: unknown): v is Serializer<any, any>;
+export type SerializerInput<S> = S extends Serializer<infer Input, any> ? Input : any;
+export type SerializerOutput<S> = S extends Serializer<any, infer Output> ? Output : any;
+/**
+ * JSON serializer — `JSON.parse` on the way in, `JSON.stringify` on the way out.
+ * Defaults to `any` so individual handlers can annotate their own payload types.
+ */
+declare function json<Input = any, Output = any>(): Serializer<Input, Output>;
+/** Raw string serializer — passes payloads through as plain strings with no encoding. */
+declare function raw(): Serializer<string, string>;
+/** Custom serializer - allows custom defined parse and serialize functions */
+declare function custom<Input = any, Output = any>(params: Omit<Serializer<Input, Output>, 'symbol'>): Serializer<Input, Output>;
+/**
+ * Serializer helpers for message payload encoding.
+ *
+ * @example
+ * ```ts
+ * const a = serializers.raw(); // Serializer<string, string>
+ * const b = serializer.json<{ foo: string }, { bar: string }>(); // Serializer<{ foo: string }, { bar: string }>
+ * ```
+ *
+ * @beta
+ */
+export declare const serializers: {
+    json: typeof json;
+    raw: typeof raw;
+    custom: typeof custom;
+};
+export {};
+//# sourceMappingURL=serializer.d.ts.map

package/dist/ts4.2/utils/subscribeToEvents.d.ts

@@ -1,15 +1,15 @@
-import type { EventMap } from 'typed-emitter';
-import type TypedEventEmitter from 'typed-emitter';
-/** A test helper to listen to events received by an event emitter and allow them to be imperatively
- * queried after the fact. */
-export declare function subscribeToEvents<Callbacks extends EventMap, EventNames extends keyof Callbacks = keyof Callbacks>(eventEmitter: TypedEventEmitter<Callbacks>, eventNames: Array<EventNames>): {
-    /** Listen for the next occurrance of an event to be emitted, or return the last event that was
-     * buffered (but hasn't been processed yet). */
-    waitFor<EventPayload extends Parameters<Callbacks[EventName]>[0], EventName extends EventNames = EventNames>(eventName: EventName): Promise<EventPayload>;
-    /** Are there events of the given name which are waiting to be processed? Use this to assert
-     * that no unexpected events have been emitted. */
-    areThereBufferedEvents<EventPayload extends Parameters<Callbacks[EventName]>[0], EventName extends EventNames = EventNames>(eventName: EventName): boolean;
-    /** Cleanup any lingering subscriptions. */
-    unsubscribe: () => void;
-};
-//# sourceMappingURL=subscribeToEvents.d.ts.map
+import type { EventMap } from 'typed-emitter';
+import type TypedEventEmitter from 'typed-emitter';
+/** A test helper to listen to events received by an event emitter and allow them to be imperatively
+ * queried after the fact. */
+export declare function subscribeToEvents<Callbacks extends EventMap, EventNames extends keyof Callbacks = keyof Callbacks>(eventEmitter: TypedEventEmitter<Callbacks>, eventNames: Array<EventNames>): {
+    /** Listen for the next occurrance of an event to be emitted, or return the last event that was
+     * buffered (but hasn't been processed yet). */
+    waitFor<EventPayload extends Parameters<Callbacks[EventName]>[0], EventName extends EventNames = EventNames>(eventName: EventName): Promise<EventPayload>;
+    /** Are there events of the given name which are waiting to be processed? Use this to assert
+     * that no unexpected events have been emitted. */
+    areThereBufferedEvents<EventPayload extends Parameters<Callbacks[EventName]>[0], EventName extends EventNames = EventNames>(eventName: EventName): boolean;
+    /** Cleanup any lingering subscriptions. */
+    unsubscribe: () => void;
+};
+//# sourceMappingURL=subscribeToEvents.d.ts.map

package/dist/ts4.2/utils/ttlmap.d.ts

@@ -1,20 +1,20 @@
-export declare class TTLMap<K, V> {
-    private _map;
-    private ttl;
-    private _lastCleanup;
-    /**
-     * @param ttl ttl of the key (ms)
-     */
-    constructor(ttl: number);
-    set(key: K, value: V): this;
-    get(key: K): V | undefined;
-    has(key: K): boolean;
-    delete(key: K): boolean;
-    clear(): void;
-    cleanup(): void;
-    get size(): number;
-    forEach(callback: (value: V, key: K, map: Map<K, V>) => void): void;
-    map<U>(callback: (value: V, key: K, map: Map<K, V>) => U): U[];
-    private asValueMap;
-}
-//# sourceMappingURL=ttlmap.d.ts.map
+export declare class TTLMap<K, V> {
+    private _map;
+    private ttl;
+    private _lastCleanup;
+    /**
+     * @param ttl ttl of the key (ms)
+     */
+    constructor(ttl: number);
+    set(key: K, value: V): this;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    delete(key: K): boolean;
+    clear(): void;
+    cleanup(): void;
+    get size(): number;
+    forEach(callback: (value: V, key: K, map: Map<K, V>) => void): void;
+    map<U>(callback: (value: V, key: K, map: Map<K, V>) => U): U[];
+    private asValueMap;
+}
+//# sourceMappingURL=ttlmap.d.ts.map