livekit-client 2.22.3 → 2.23.0

package/dist/ts4.2/room/rpc/client/RpcClientManager.d.ts

@@ -1,43 +1,43 @@
-import type TypedEmitter from 'typed-emitter';
-import type { StructuredLogger } from '../../../logger';
-import type { TextStreamReader } from '../../data-stream/incoming/StreamReader';
-import type OutgoingDataStreamManager from '../../data-stream/outgoing/OutgoingDataStreamManager';
-import type Participant from '../../participant/Participant';
-import type { PerformRpcParams } from '../utils';
-import { RpcError } from '../utils';
-import type { RpcClientManagerCallbacks } from './events';
-declare const RpcClientManager_base: new () => TypedEmitter<RpcClientManagerCallbacks>;
-/**
- * Manages the client (caller) side of RPC: sending requests, tracking pending
- * ack/response state, and handling incoming ack/response packets.
- * @internal
- */
-export default class RpcClientManager extends RpcClientManager_base {
-    private log;
-    private outgoingDataStreamManager;
-    private getRemoteParticipantClientProtocol;
-    private getServerVersion;
-    private pendingAcks;
-    private pendingResponses;
-    constructor(log: StructuredLogger, outgoingDataStreamManager: OutgoingDataStreamManager, getRemoteParticipantClientProtocol: (identity: Participant['identity']) => number, getServerVersion: () => string | undefined);
-    performRpc({ destinationIdentity, method, payload, responseTimeout: responseTimeoutMs, }: PerformRpcParams): Promise<[
-        id: string,
-        completionPromise: Promise<string>
-    ]>;
-    private publishRpcRequest;
-    /**
-     * Handle an incoming data stream containing an RPC response payload.
-     * @internal
-     */
-    handleIncomingDataStream(reader: TextStreamReader, senderIdentity: Participant['identity'], attributes: Record<string, string>): Promise<void>;
-    /** @internal */
-    handleIncomingRpcResponseSuccess(requestId: string, payload: string): void;
-    /** @internal */
-    handleIncomingRpcResponseFailure(requestId: string, error: RpcError): void;
-    /** @internal */
-    handleIncomingRpcAck(requestId: string): void;
-    /** @internal */
-    handleParticipantDisconnected(participantIdentity: string): void;
-}
-export {};
-//# sourceMappingURL=RpcClientManager.d.ts.map
+import type TypedEmitter from 'typed-emitter';
+import type { StructuredLogger } from '../../../logger';
+import type { TextStreamReader } from '../../data-stream/incoming/StreamReader';
+import type OutgoingDataStreamManager from '../../data-stream/outgoing/OutgoingDataStreamManager';
+import type Participant from '../../participant/Participant';
+import type { PerformRpcParams } from '../utils';
+import { RpcError } from '../utils';
+import type { RpcClientManagerCallbacks } from './events';
+declare const RpcClientManager_base: new () => TypedEmitter<RpcClientManagerCallbacks>;
+/**
+ * Manages the client (caller) side of RPC: sending requests, tracking pending
+ * ack/response state, and handling incoming ack/response packets.
+ * @internal
+ */
+export default class RpcClientManager extends RpcClientManager_base {
+    private log;
+    private outgoingDataStreamManager;
+    private getRemoteParticipantClientProtocol;
+    private getServerVersion;
+    private pendingAcks;
+    private pendingResponses;
+    constructor(log: StructuredLogger, outgoingDataStreamManager: OutgoingDataStreamManager, getRemoteParticipantClientProtocol: (identity: Participant['identity']) => number, getServerVersion: () => string | undefined);
+    performRpc({ destinationIdentity, method, payload, responseTimeout: responseTimeoutMs, }: PerformRpcParams): Promise<[
+        id: string,
+        completionPromise: Promise<string>
+    ]>;
+    private publishRpcRequest;
+    /**
+     * Handle an incoming data stream containing an RPC response payload.
+     * @internal
+     */
+    handleIncomingDataStream(reader: TextStreamReader, senderIdentity: Participant['identity'], attributes: Record<string, string>): Promise<void>;
+    /** @internal */
+    handleIncomingRpcResponseSuccess(requestId: string, payload: string): void;
+    /** @internal */
+    handleIncomingRpcResponseFailure(requestId: string, error: RpcError): void;
+    /** @internal */
+    handleIncomingRpcAck(requestId: string): void;
+    /** @internal */
+    handleParticipantDisconnected(participantIdentity: string): void;
+}
+export {};
+//# sourceMappingURL=RpcClientManager.d.ts.map

package/dist/ts4.2/room/rpc/client/events.d.ts

@@ -1,8 +1,8 @@
-import type { DataPacket } from '@livekit/protocol';
-export type EventSendDataPacket = {
-    packet: DataPacket;
-};
-export type RpcClientManagerCallbacks = {
-    sendDataPacket: (event: EventSendDataPacket) => void;
-};
-//# sourceMappingURL=events.d.ts.map
+import type { DataPacket } from '@livekit/protocol';
+export type EventSendDataPacket = {
+    packet: DataPacket;
+};
+export type RpcClientManagerCallbacks = {
+    sendDataPacket: (event: EventSendDataPacket) => void;
+};
+//# sourceMappingURL=events.d.ts.map

package/dist/ts4.2/room/rpc/index.d.ts

@@ -1,7 +1,7 @@
-export { default as RpcClientManager } from './client/RpcClientManager';
-export type { RpcClientManagerCallbacks } from './client/events';
-export { default as RpcServerManager } from './server/RpcServerManager';
-export type { RpcServerManagerCallbacks } from './server/events';
-export type { PerformRpcParams, RpcInvocationData } from './utils';
-export { RPC_REQUEST_DATA_STREAM_TOPIC, RPC_RESPONSE_DATA_STREAM_TOPIC, RpcRequestAttrs, RpcError, byteLength, truncateBytes } from './utils';
-//# sourceMappingURL=index.d.ts.map
+export { default as RpcClientManager } from './client/RpcClientManager';
+export type { RpcClientManagerCallbacks } from './client/events';
+export { default as RpcServerManager } from './server/RpcServerManager';
+export type { RpcServerManagerCallbacks } from './server/events';
+export type { PerformRpcParams, RpcInvocationData } from './utils';
+export { RPC_REQUEST_DATA_STREAM_TOPIC, RPC_RESPONSE_DATA_STREAM_TOPIC, RpcRequestAttrs, RpcError, byteLength, truncateBytes } from './utils';
+//# sourceMappingURL=index.d.ts.map

package/dist/ts4.2/room/rpc/server/RpcServerManager.d.ts

@@ -1,44 +1,44 @@
-import { RpcRequest } from '@livekit/protocol';
-import type TypedEmitter from 'typed-emitter';
-import type { StructuredLogger } from '../../../logger';
-import type { TextStreamReader } from '../../data-stream/incoming/StreamReader';
-import type OutgoingDataStreamManager from '../../data-stream/outgoing/OutgoingDataStreamManager';
-import type Participant from '../../participant/Participant';
-import type { RpcInvocationData } from '../utils';
-import type { RpcServerManagerCallbacks } from './events';
-declare const RpcServerManager_base: new () => TypedEmitter<RpcServerManagerCallbacks>;
-/**
- * Manages the server (handler) side of RPC: processing incoming requests,
- * managing registered method handlers, and sending responses.
- * @internal
- */
-export default class RpcServerManager extends RpcServerManager_base {
-    private log;
-    private outgoingDataStreamManager;
-    private getRemoteParticipantClientProtocol;
-    private rpcHandlers;
-    constructor(log: StructuredLogger, outgoingDataStreamManager: OutgoingDataStreamManager, getRemoteParticipantClientProtocol: (identity: Participant['identity']) => number);
-    registerRpcMethod(method: string, handler: (data: RpcInvocationData) => Promise<string>): void;
-    unregisterRpcMethod(method: string): void;
-    /**
-     * Handle an incoming RPCRequest message containing a payload.
-     * This handles "version 1" of rpc requests.
-     * @internal
-     */
-    handleIncomingRpcRequest(callerIdentity: string, rpcRequest: RpcRequest): Promise<void>;
-    /**
-     * Handle an incoming data stream containing a RPC request payload.
-     * This handles "version 2" of rpc requests.
-     * @internal
-     */
-    handleIncomingDataStream(reader: TextStreamReader, callerIdentity: Participant['identity'], dataStreamAttrs: Record<string, string>): Promise<void>;
-    private publishRpcAck;
-    private publishRpcResponsePacket;
-    /**
-     * Send a successful RPC response payload, choosing the transport based on
-     * the caller's client protocol version.
-     */
-    private publishRpcResponse;
-}
-export {};
-//# sourceMappingURL=RpcServerManager.d.ts.map
+import { RpcRequest } from '@livekit/protocol';
+import type TypedEmitter from 'typed-emitter';
+import type { StructuredLogger } from '../../../logger';
+import type { TextStreamReader } from '../../data-stream/incoming/StreamReader';
+import type OutgoingDataStreamManager from '../../data-stream/outgoing/OutgoingDataStreamManager';
+import type Participant from '../../participant/Participant';
+import type { RpcInvocationData } from '../utils';
+import type { RpcServerManagerCallbacks } from './events';
+declare const RpcServerManager_base: new () => TypedEmitter<RpcServerManagerCallbacks>;
+/**
+ * Manages the server (handler) side of RPC: processing incoming requests,
+ * managing registered method handlers, and sending responses.
+ * @internal
+ */
+export default class RpcServerManager extends RpcServerManager_base {
+    private log;
+    private outgoingDataStreamManager;
+    private getRemoteParticipantClientProtocol;
+    private rpcHandlers;
+    constructor(log: StructuredLogger, outgoingDataStreamManager: OutgoingDataStreamManager, getRemoteParticipantClientProtocol: (identity: Participant['identity']) => number);
+    registerRpcMethod(method: string, handler: (data: RpcInvocationData) => Promise<string>): void;
+    unregisterRpcMethod(method: string): void;
+    /**
+     * Handle an incoming RPCRequest message containing a payload.
+     * This handles "version 1" of rpc requests.
+     * @internal
+     */
+    handleIncomingRpcRequest(callerIdentity: string, rpcRequest: RpcRequest): Promise<void>;
+    /**
+     * Handle an incoming data stream containing a RPC request payload.
+     * This handles "version 2" of rpc requests.
+     * @internal
+     */
+    handleIncomingDataStream(reader: TextStreamReader, callerIdentity: Participant['identity'], dataStreamAttrs: Record<string, string>): Promise<void>;
+    private publishRpcAck;
+    private publishRpcResponsePacket;
+    /**
+     * Send a successful RPC response payload, choosing the transport based on
+     * the caller's client protocol version.
+     */
+    private publishRpcResponse;
+}
+export {};
+//# sourceMappingURL=RpcServerManager.d.ts.map

package/dist/ts4.2/room/rpc/server/events.d.ts

@@ -1,8 +1,8 @@
-import type { DataPacket } from '@livekit/protocol';
-export type EventSendDataPacket = {
-    packet: DataPacket;
-};
-export type RpcServerManagerCallbacks = {
-    sendDataPacket: (event: EventSendDataPacket) => void;
-};
-//# sourceMappingURL=events.d.ts.map
+import type { DataPacket } from '@livekit/protocol';
+export type EventSendDataPacket = {
+    packet: DataPacket;
+};
+export type RpcServerManagerCallbacks = {
+    sendDataPacket: (event: EventSendDataPacket) => void;
+};
+//# sourceMappingURL=events.d.ts.map

package/dist/ts4.2/room/rpc/utils.d.ts

@@ -1,131 +1,131 @@
-import { RpcError as RpcError_Proto } from '@livekit/protocol';
-/** Parameters for initiating an RPC call */
-export interface PerformRpcParams {
-    /** The `identity` of the destination participant */
-    destinationIdentity: string;
-    /** The method name to call */
-    method: string;
-    /** The method payload */
-    payload: string;
-    /**
-     * Timeout for receiving a response after the initial connection (milliseconds).
-     * If a value less than 8000ms is provided, it will be automatically clamped to 8000ms
-     * to ensure sufficient time for round-trip latency buffering.
-     * Default: 15000ms.
-     */
-    responseTimeout?: number;
-}
-/**
- * Data passed to method handler for incoming RPC invocations
- */
-export interface RpcInvocationData {
-    /**
-     * The unique request ID. Will match at both sides of the call, useful for debugging or logging.
-     */
-    requestId: string;
-    /**
-     * The unique participant identity of the caller.
-     */
-    callerIdentity: string;
-    /**
-     * The payload of the request. User-definable format, typically JSON.
-     */
-    payload: string;
-    /**
-     * The maximum time the caller will wait for a response.
-     */
-    responseTimeout: number;
-}
-/**
- * Specialized error handling for RPC methods.
- *
- * Instances of this type, when thrown in a method handler, will have their `message`
- * serialized and sent across the wire. The sender will receive an equivalent error on the other side.
- *
- * Built-in types are included but developers may use any string, with a max length of 256 bytes.
- */
-export declare class RpcError extends Error {
-    static MAX_MESSAGE_BYTES: number;
-    static MAX_DATA_BYTES: number;
-    code: number;
-    data?: string;
-    cause?: unknown;
-    /**
-     * Creates an error object with the given code and message, plus an optional data payload.
-     *
-     * If thrown in an RPC method handler, the error will be sent back to the caller.
-     *
-     * Error codes 1001-1999 are reserved for built-in errors (see RpcError.ErrorCode for their meanings).
-     */
-    constructor(code: number, message: string, data?: string, options?: {
-        cause?: unknown;
-    });
-    /**
-     * @internal
-     */
-    static fromProto(proto: RpcError_Proto): RpcError;
-    /**
-     * @internal
-     */
-    toProto(): RpcError_Proto;
-    static ErrorCode: {
-        readonly APPLICATION_ERROR: 1500;
-        readonly CONNECTION_TIMEOUT: 1501;
-        readonly RESPONSE_TIMEOUT: 1502;
-        readonly RECIPIENT_DISCONNECTED: 1503;
-        readonly RESPONSE_PAYLOAD_TOO_LARGE: 1504;
-        readonly SEND_FAILED: 1505;
-        readonly UNSUPPORTED_METHOD: 1400;
-        readonly RECIPIENT_NOT_FOUND: 1401;
-        readonly REQUEST_PAYLOAD_TOO_LARGE: 1402;
-        readonly UNSUPPORTED_SERVER: 1403;
-        readonly UNSUPPORTED_VERSION: 1404;
-    };
-    /**
-     * @internal
-     */
-    static ErrorMessage: Record<keyof typeof RpcError.ErrorCode, string>;
-    /**
-     * Creates an error object from the code, with an auto-populated message.
-     *
-     * @internal
-     */
-    static builtIn(key: keyof typeof RpcError.ErrorCode, data?: string, options?: {
-        cause?: unknown;
-    }): RpcError;
-}
-export declare const MAX_V1_PAYLOAD_BYTES = 15360;
-/**
- * Topic used for v2 RPC request data streams.
- * @internal
- */
-export declare const RPC_REQUEST_DATA_STREAM_TOPIC = "lk.rpc_request";
-/**
- * Topic used for v2 RPC response data streams.
- * @internal
- */
-export declare const RPC_RESPONSE_DATA_STREAM_TOPIC = "lk.rpc_response";
-/** @internal */
-export declare enum RpcRequestAttrs {
-    RPC_REQUEST_ID = "lk.rpc_request_id",
-    RPC_REQUEST_METHOD = "lk.rpc_request_method",
-    RPC_REQUEST_RESPONSE_TIMEOUT_MS = "lk.rpc_request_response_timeout_ms",
-    RPC_REQUEST_VERSION = "lk.rpc_request_version"
-}
-/** Initial version of rpc which uses RpcRequest / RpcResponse messages.
- * @internal
- **/
-export declare const RPC_VERSION_V1 = 1;
-/** Rpc version backed by data streams instead of RpcRequest / RpcResponse.
- * @internal
- **/
-export declare const RPC_VERSION_V2 = 2;
-/**
- * @internal
- */
-export declare function byteLength(str: string): number;
-/**
- * @internal
- */
-export declare function truncateBytes(str: string, maxBytes: number): string;
-//# sourceMappingURL=utils.d.ts.map
+import { RpcError as RpcError_Proto } from '@livekit/protocol';
+/** Parameters for initiating an RPC call */
+export interface PerformRpcParams {
+    /** The `identity` of the destination participant */
+    destinationIdentity: string;
+    /** The method name to call */
+    method: string;
+    /** The method payload */
+    payload: string;
+    /**
+     * Timeout for receiving a response after the initial connection (milliseconds).
+     * If a value less than 8000ms is provided, it will be automatically clamped to 8000ms
+     * to ensure sufficient time for round-trip latency buffering.
+     * Default: 15000ms.
+     */
+    responseTimeout?: number;
+}
+/**
+ * Data passed to method handler for incoming RPC invocations
+ */
+export interface RpcInvocationData {
+    /**
+     * The unique request ID. Will match at both sides of the call, useful for debugging or logging.
+     */
+    requestId: string;
+    /**
+     * The unique participant identity of the caller.
+     */
+    callerIdentity: string;
+    /**
+     * The payload of the request. User-definable format, typically JSON.
+     */
+    payload: string;
+    /**
+     * The maximum time the caller will wait for a response.
+     */
+    responseTimeout: number;
+}
+/**
+ * Specialized error handling for RPC methods.
+ *
+ * Instances of this type, when thrown in a method handler, will have their `message`
+ * serialized and sent across the wire. The sender will receive an equivalent error on the other side.
+ *
+ * Built-in types are included but developers may use any string, with a max length of 256 bytes.
+ */
+export declare class RpcError extends Error {
+    static MAX_MESSAGE_BYTES: number;
+    static MAX_DATA_BYTES: number;
+    code: number;
+    data?: string;
+    cause?: unknown;
+    /**
+     * Creates an error object with the given code and message, plus an optional data payload.
+     *
+     * If thrown in an RPC method handler, the error will be sent back to the caller.
+     *
+     * Error codes 1001-1999 are reserved for built-in errors (see RpcError.ErrorCode for their meanings).
+     */
+    constructor(code: number, message: string, data?: string, options?: {
+        cause?: unknown;
+    });
+    /**
+     * @internal
+     */
+    static fromProto(proto: RpcError_Proto): RpcError;
+    /**
+     * @internal
+     */
+    toProto(): RpcError_Proto;
+    static ErrorCode: {
+        readonly APPLICATION_ERROR: 1500;
+        readonly CONNECTION_TIMEOUT: 1501;
+        readonly RESPONSE_TIMEOUT: 1502;
+        readonly RECIPIENT_DISCONNECTED: 1503;
+        readonly RESPONSE_PAYLOAD_TOO_LARGE: 1504;
+        readonly SEND_FAILED: 1505;
+        readonly UNSUPPORTED_METHOD: 1400;
+        readonly RECIPIENT_NOT_FOUND: 1401;
+        readonly REQUEST_PAYLOAD_TOO_LARGE: 1402;
+        readonly UNSUPPORTED_SERVER: 1403;
+        readonly UNSUPPORTED_VERSION: 1404;
+    };
+    /**
+     * @internal
+     */
+    static ErrorMessage: Record<keyof typeof RpcError.ErrorCode, string>;
+    /**
+     * Creates an error object from the code, with an auto-populated message.
+     *
+     * @internal
+     */
+    static builtIn(key: keyof typeof RpcError.ErrorCode, data?: string, options?: {
+        cause?: unknown;
+    }): RpcError;
+}
+export declare const MAX_V1_PAYLOAD_BYTES = 15360;
+/**
+ * Topic used for v2 RPC request data streams.
+ * @internal
+ */
+export declare const RPC_REQUEST_DATA_STREAM_TOPIC = "lk.rpc_request";
+/**
+ * Topic used for v2 RPC response data streams.
+ * @internal
+ */
+export declare const RPC_RESPONSE_DATA_STREAM_TOPIC = "lk.rpc_response";
+/** @internal */
+export declare enum RpcRequestAttrs {
+    RPC_REQUEST_ID = "lk.rpc_request_id",
+    RPC_REQUEST_METHOD = "lk.rpc_request_method",
+    RPC_REQUEST_RESPONSE_TIMEOUT_MS = "lk.rpc_request_response_timeout_ms",
+    RPC_REQUEST_VERSION = "lk.rpc_request_version"
+}
+/** Initial version of rpc which uses RpcRequest / RpcResponse messages.
+ * @internal
+ **/
+export declare const RPC_VERSION_V1 = 1;
+/** Rpc version backed by data streams instead of RpcRequest / RpcResponse.
+ * @internal
+ **/
+export declare const RPC_VERSION_V2 = 2;
+/**
+ * @internal
+ */
+export declare function byteLength(str: string): number;
+/**
+ * @internal
+ */
+export declare function truncateBytes(str: string, maxBytes: number): string;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -1,71 +1,71 @@
-export declare const monitorFrequency = 2000;
-interface SenderStats {
-    /** number of packets sent */
-    packetsSent?: number;
-    /** number of bytes sent */
-    bytesSent?: number;
-    /** jitter as perceived by remote */
-    jitter?: number;
-    /** packets reported lost by remote */
-    packetsLost?: number;
-    /** RTT reported by remote */
-    roundTripTime?: number;
-    /** ID of the outbound stream */
-    streamId?: string;
-    timestamp: number;
-}
-export interface AudioSenderStats extends SenderStats {
-    type: 'audio';
-}
-export interface VideoSenderStats extends SenderStats {
-    type: 'video';
-    firCount: number;
-    pliCount: number;
-    nackCount: number;
-    rid: string;
-    frameWidth: number;
-    frameHeight: number;
-    framesPerSecond: number;
-    framesSent: number;
-    qualityLimitationReason?: string;
-    qualityLimitationDurations?: Record<string, number>;
-    qualityLimitationResolutionChanges?: number;
-    retransmittedPacketsSent?: number;
-    targetBitrate: number;
-}
-interface ReceiverStats {
-    jitterBufferDelay?: number;
-    /** packets reported lost by remote */
-    packetsLost?: number;
-    /** number of packets sent */
-    packetsReceived?: number;
-    bytesReceived?: number;
-    streamId?: string;
-    jitter?: number;
-    timestamp: number;
-}
-export interface AudioReceiverStats extends ReceiverStats {
-    type: 'audio';
-    concealedSamples?: number;
-    concealmentEvents?: number;
-    silentConcealedSamples?: number;
-    silentConcealmentEvents?: number;
-    totalAudioEnergy?: number;
-    totalSamplesDuration?: number;
-}
-export interface VideoReceiverStats extends ReceiverStats {
-    type: 'video';
-    framesDecoded: number;
-    framesDropped: number;
-    framesReceived: number;
-    frameWidth?: number;
-    frameHeight?: number;
-    firCount?: number;
-    pliCount?: number;
-    nackCount?: number;
-    decoderImplementation?: string;
-    mimeType?: string;
-}
-export declare function computeBitrate<T extends ReceiverStats | SenderStats>(currentStats: T, prevStats?: T): number;
-export {};
-//# sourceMappingURL=stats.d.ts.map
+export declare const monitorFrequency = 2000;
+interface SenderStats {
+    /** number of packets sent */
+    packetsSent?: number;
+    /** number of bytes sent */
+    bytesSent?: number;
+    /** jitter as perceived by remote */
+    jitter?: number;
+    /** packets reported lost by remote */
+    packetsLost?: number;
+    /** RTT reported by remote */
+    roundTripTime?: number;
+    /** ID of the outbound stream */
+    streamId?: string;
+    timestamp: number;
+}
+export interface AudioSenderStats extends SenderStats {
+    type: 'audio';
+}
+export interface VideoSenderStats extends SenderStats {
+    type: 'video';
+    firCount: number;
+    pliCount: number;
+    nackCount: number;
+    rid: string;
+    frameWidth: number;
+    frameHeight: number;
+    framesPerSecond: number;
+    framesSent: number;
+    qualityLimitationReason?: string;
+    qualityLimitationDurations?: Record<string, number>;
+    qualityLimitationResolutionChanges?: number;
+    retransmittedPacketsSent?: number;
+    targetBitrate: number;
+}
+interface ReceiverStats {
+    jitterBufferDelay?: number;
+    /** packets reported lost by remote */
+    packetsLost?: number;
+    /** number of packets sent */
+    packetsReceived?: number;
+    bytesReceived?: number;
+    streamId?: string;
+    jitter?: number;
+    timestamp: number;
+}
+export interface AudioReceiverStats extends ReceiverStats {
+    type: 'audio';
+    concealedSamples?: number;
+    concealmentEvents?: number;
+    silentConcealedSamples?: number;
+    silentConcealmentEvents?: number;
+    totalAudioEnergy?: number;
+    totalSamplesDuration?: number;
+}
+export interface VideoReceiverStats extends ReceiverStats {
+    type: 'video';
+    framesDecoded: number;
+    framesDropped: number;
+    framesReceived: number;
+    frameWidth?: number;
+    frameHeight?: number;
+    firCount?: number;
+    pliCount?: number;
+    nackCount?: number;
+    decoderImplementation?: string;
+    mimeType?: string;
+}
+export declare function computeBitrate<T extends ReceiverStats | SenderStats>(currentStats: T, prevStats?: T): number;
+export {};
+//# sourceMappingURL=stats.d.ts.map