@formant/realtime-sdk 1.3.0 → 1.3.1

package/dist/realtime-sdk/src/config/index.d.ts

@@ -0,0 +1,2 @@
+export declare const namespace: string;
+export declare const app: string;

package/dist/realtime-sdk/src/index.d.ts

@@ -0,0 +1,18 @@
+export { AuthClient } from "../../client/AuthClient";
+export { RtcSignalingClient } from "../../client/RtcSignalingClient";
+export { Credentials } from "../../client/Credentials";
+export { SignalingPromiseClient } from "../../protos/api/signaling/v1/signaling_grpc_web_pb";
+export { RtcClient } from "../../rtc-client/RtcClient";
+export { RtcClientV1 } from "../../rtc-client/RtcClientV1";
+export { createRtcStreamMessage } from "../../rtc-client/utils/createRtcStreamMessage";
+export type { IRtcStream } from "../../model/IRtcStream";
+export type { IRtcPeer } from "../../model/IRtcPeer";
+export type { RtcStreamType } from "../../model/RtcStreamType";
+export type { IRtcClientConfigurationV1 } from "../../rtc-client/models-v1/IRtcClientConfigurationV1";
+export type { IRtcClientConfiguration } from "../../rtc-client/models/IRtcClientConfiguration";
+export type { IRtcConnectionStatsInfo } from "../../rtc-client/models/IRtcConnectionStatsInfo";
+export type { IRtcSendConfiguration } from "../../rtc-client/models/IRtcSendConfiguration";
+export type { IRtcSessionMetricsMessageCounts } from "../../rtc-client/models/IRtcSessionMetricsMessageCounts";
+export type { IRtcStreamMessage } from "../../rtc-client/models/IRtcStreamMessage";
+export type { IRtcStreamPayload } from "../../rtc-client/models/IRtcStreamPayload";
+export type { IStreamControl } from "../../rtc-client/models/IStreamControl";

package/dist/rtc-client/DeadlineEnforcer.d.ts

@@ -0,0 +1,4 @@
+export declare class DeadlineEnforcer {
+    private static readonly grpcCallDeadlineSlopMs;
+    static withDeadline<T>(request: Promise<T>, deadlineMs: number): Promise<T>;
+}

package/dist/rtc-client/DeadlineReachedError.d.ts

@@ -0,0 +1,3 @@
+export declare class DeadlineReachedError extends Error {
+    constructor(deadlineMs: number, slopMs: number);
+}

package/dist/rtc-client/IHasPeerConnection.d.ts

@@ -0,0 +1,3 @@
+export interface IHasPeerConnection {
+    peerConnection: RTCPeerConnection;
+}

package/dist/rtc-client/IHasRemoteDeviceId.d.ts

@@ -0,0 +1,4 @@
+import { Uuid } from "../model/Uuid";
+export interface IHasRemoteDeviceId {
+    getRemoteDeviceId(): Uuid | undefined;
+}

package/dist/rtc-client/RtcClient.d.ts

@@ -0,0 +1,71 @@
+import { IRtcInfo } from "../model/IRtcInfo";
+import { IRtcPeer } from "../model/IRtcPeer";
+import { RtcConnectionStatus } from "../model/RtcConnectionStatus";
+import { Timestamp } from "../model/Timestamp";
+import { Uuid } from "../model/Uuid";
+import { IPingInfo } from "./models/IPingInfo";
+import { IRtcClientConfiguration } from "./models/IRtcClientConfiguration";
+import { IRtcConnectionStatsInfo } from "./models/IRtcConnectionStatsInfo";
+import { IRtcSendConfiguration } from "./models/IRtcSendConfiguration";
+import { IRtcSessionMetricsMessageCounts } from "./models/IRtcSessionMetricsMessageCounts";
+import { IRtcStreamMessage } from "./models/IRtcStreamMessage";
+import { IStreamControl } from "./models/IStreamControl";
+import { RtcConnection } from "./RtcConnection";
+/**
+ * RtcClient to be used by browsers.
+ */
+export declare class RtcClient {
+    private config;
+    private readonly grpcCallDeadline;
+    private readonly refreshIntervalDelayMs;
+    private readonly iceServersTtl;
+    private localPeer?;
+    private iceServers?;
+    private iceServersLastUpdate?;
+    private receiveSignalStream?;
+    private refreshInterval;
+    private connections;
+    private localConnections;
+    private isConnectionInitiator;
+    private isOutgoingConnection;
+    private peerDataChannelListeners;
+    private rtcInstancesConstructed;
+    private statsLoopsExecuted;
+    constructor(config: IRtcClientConfiguration);
+    send(remotePeerId: Uuid, message: IRtcStreamMessage, config: IRtcSendConfiguration): void;
+    controlRemoteStream(remotePeerId: Uuid, streamControl: IStreamControl): void;
+    getLocalPeer(): Promise<IRtcPeer>;
+    /**
+     * Connects to a peer given its id.
+     * Returns the id of the session, if one is created.
+     */
+    connect(remotePeerId: Uuid, rtcInfo?: IRtcInfo): Promise<Uuid | undefined>;
+    connectLan(agentEndpoint: string): Promise<Uuid | false>;
+    getConnections(): RtcConnection[];
+    createCustomDataChannel(remotePeerId: Uuid, channelName: string, init: RTCDataChannelInit, isBinary: boolean, listener: (peerId: Uuid, channel: RTCDataChannel) => void): () => void;
+    private onCustomDataChannel;
+    getConnectionStatus(remotePeerId: Uuid): RtcConnectionStatus;
+    getConnectionStatsInfo(remotePeerId: Uuid): Promise<IRtcConnectionStatsInfo | undefined>;
+    disconnect(remotePeerId: Uuid): Promise<void>;
+    getPeers(): Promise<IRtcPeer[]>;
+    getSessions(): Promise<{
+        [key in string]: string[];
+    }>;
+    getPing(remotePeerId: Uuid): number | undefined;
+    getPingInfo(remotePeerId: Uuid): IPingInfo | undefined;
+    getLastMessageTimestamp(remotePeerId: Uuid): Timestamp | undefined;
+    getSessionMetricsMessageCounts(remotePeerId: Uuid): IRtcSessionMetricsMessageCounts | undefined;
+    isReady(): boolean;
+    shutdown(): Promise<void>;
+    private createPeer;
+    private createReceiveSignalStream;
+    private createRTCPeerConnection;
+    private closeConnections;
+    private getActiveConnection;
+    private update;
+    private gatherConnectionStats;
+    private reset;
+    private updateIceServers;
+    private setupHandlers;
+    private getMetadata;
+}

package/dist/rtc-client/RtcClientV1.d.ts

@@ -0,0 +1,52 @@
+import { IRtcPeer } from "../model/IRtcPeer";
+import { RtcConnectionStatus } from "../model/RtcConnectionStatus";
+import { Timestamp } from "../model/Timestamp";
+import { Uuid } from "../model/Uuid";
+import { IRtcClientConfigurationV1 } from "./models-v1/IRtcClientConfigurationV1";
+import { IIceMode } from "./models/IIceMode";
+import { IRtcSendConfiguration } from "./models/IRtcSendConfiguration";
+import { IRtcStreamMessage } from "./models/IRtcStreamMessage";
+import { IStreamControl } from "./models/IStreamControl";
+/**
+ * RtcClient to be used by browsers.
+ * Interacts with signaling API v1.
+ */
+export declare class RtcClientV1 {
+    private config;
+    private localPeer;
+    private updateInterval;
+    private connections;
+    private connectingSessions;
+    private rtcInstancesConstructed;
+    constructor(config: IRtcClientConfigurationV1);
+    send(peerId: Uuid, message: IRtcStreamMessage, config: IRtcSendConfiguration): void;
+    controlRemoteStream(peerId: Uuid, streamControl: IStreamControl): void;
+    /**
+     * Connects to a peer given its id.
+     * Returns the id of the session, if one is created.
+     */
+    connect(peerId: Uuid): Promise<Uuid | undefined>;
+    getConnectionStatus(peerId: Uuid): RtcConnectionStatus;
+    getIceMode(peerId: Uuid): IIceMode | undefined;
+    disconnect(peerId: Uuid): Promise<void>;
+    getLocalPeer(): Promise<IRtcPeer>;
+    getPeers(): Promise<IRtcPeer[]>;
+    getPing(peerId: Uuid): number | undefined;
+    getLastMessageTimestamp(remotePeerId: Uuid): Timestamp | undefined;
+    shutdown(): Promise<void>;
+    private closeConnection;
+    private getSessions;
+    private createPeer;
+    private createRTCPeerConnection;
+    private closeConnections;
+    private reset;
+    private getActiveConnection;
+    private update;
+    private handleSessions;
+    private syncConnectionsAndSessions;
+    private maintainConnection;
+    private connectToSession;
+    private setupHandlers;
+    private consumeSignals;
+    private sendSignal;
+}

package/dist/rtc-client/RtcConnection.d.ts

@@ -0,0 +1,95 @@
+import { Timestamp } from "../model/Timestamp";
+import { Uuid } from "../model/Uuid";
+import { Signal } from "../protos/api/signaling/v1/signaling_pb";
+import { IHasPeerConnection } from "./IHasPeerConnection";
+import { IHasRemoteDeviceId } from "./IHasRemoteDeviceId";
+import { IPingInfo } from "./models/IPingInfo";
+import { IRtcConnectionConfiguration } from "./models/IRtcConnectionConfiguration";
+import { IRtcConnectionStatsInfo } from "./models/IRtcConnectionStatsInfo";
+import { IRtcSendConfiguration } from "./models/IRtcSendConfiguration";
+import { IRtcSessionMetricsMessageCounts } from "./models/IRtcSessionMetricsMessageCounts";
+import { IRtcStreamMessage } from "./models/IRtcStreamMessage";
+import { IStreamControl } from "./models/IStreamControl";
+export declare class RtcConnection implements IHasPeerConnection, IHasRemoteDeviceId {
+    private iceServers;
+    private config;
+    private dataChannelNotifier;
+    private readonly connectTimeoutMs;
+    private readonly iceGatheringTimeoutMs;
+    private readonly pingUpdateTimeoutMs;
+    private readonly pingV2UpdateTimeoutMs;
+    private readonly pingV2MetricsGatherTimeoutMs;
+    private readonly streamsInfoUpdateTimeoutMs;
+    private readonly reassemblyTimeoutMs;
+    private readonly reassemblyTableCleanupMs;
+    private readonly heartbeatTimeoutMs;
+    private _peerConnection;
+    get peerConnection(): RTCPeerConnection;
+    private heartbeatChannel;
+    private latestTtlStreamChannel;
+    private reliableStreamChannel;
+    private latestReliableStreamChannel;
+    private latestTryOnceStreamChannel;
+    private streamLatestTimestamp;
+    private reassemblyTable;
+    private reassemblyTableLastTimestamp;
+    private pingTimeMs;
+    private lastMessageTimestamp;
+    private sessionMetrics;
+    private closeCalled;
+    private gotOffer;
+    private hasIceCandidate;
+    private pingV2Map;
+    private pingInfo;
+    private readonly reassemblyTableCleanupTimeout;
+    private readonly pingUpdateTimeout;
+    private readonly pingV2UpdateTimeout;
+    private readonly pingV2MetricsGatherTimeout;
+    private readonly streamsInfoUpdateTimeout;
+    private readonly heartbeatTimeout;
+    constructor(peerConnection: RTCPeerConnection, iceServers: RTCIceServer[], config: IRtcConnectionConfiguration, dataChannelNotifier: (channel: RTCDataChannel) => void);
+    handleSignal(signal: Signal): Promise<Signal | undefined>;
+    /**
+     * Sends a message to the remote peer.
+     */
+    send(message: IRtcStreamMessage, config: IRtcSendConfiguration): void;
+    controlRemoteStream(streamControl: IStreamControl): void;
+    isActive(): boolean;
+    /**
+     * Checks that the peerConnection is connected
+     * and all data channels exist and are open
+     */
+    isReady(): boolean;
+    close(): Promise<void>;
+    getPing(): number | undefined;
+    getPingInfo(): IPingInfo | undefined;
+    getLastMessageTimestamp(): Timestamp | undefined;
+    getSessionCreatedTimestamp(): Timestamp | undefined;
+    setSessionCreatedTimestamp(sessionCreatedTimestamp: Timestamp): void;
+    getSessionId(): Uuid | undefined;
+    setSessionId(sessionId: Uuid): void;
+    getRemotePeerId(): Uuid | undefined;
+    getRemoteDeviceId(): Uuid | undefined;
+    setRemoteDeviceId(deviceId: Uuid | undefined): void;
+    getSessionMetricsMessageCounts(): IRtcSessionMetricsMessageCounts | undefined;
+    getConnectionStatsInfo(): Promise<IRtcConnectionStatsInfo | undefined>;
+    private initializeChannels;
+    getOffer(): Promise<Signal | undefined>;
+    getLanOffer(): Promise<RTCSessionDescription | undefined>;
+    handleLanAnswer(answerSdp: RTCSessionDescription): Promise<void>;
+    private getChannelFromLabel;
+    private sendOnChannel;
+    private channelNotRecognized;
+    private setupChannel;
+    private receiveChannelMessage;
+    private receiveChannelMessageChunk;
+    /**
+     * Handles system messages (e.g., ping/pong).
+     * Returns true if the message is a system message.
+     */
+    private handleSystemMessage;
+    private sendSystemMessage;
+    private isLatestMessage;
+    private sendPingV2;
+    private gatherPingV2Metrics;
+}

package/dist/rtc-client/RtcConnectionV1.d.ts

@@ -0,0 +1,73 @@
+import { IRtcSignal } from "../model/IRtcSignal";
+import { IHasPeerConnection } from "./IHasPeerConnection";
+import { IRtcConnectionConfigurationV1 } from "./models-v1/IRtcConnectionConfigurationV1";
+import { IIceMode } from "./models/IIceMode";
+import { IRtcSendConfiguration } from "./models/IRtcSendConfiguration";
+import { IRtcStreamMessage } from "./models/IRtcStreamMessage";
+import { IStreamControl } from "./models/IStreamControl";
+export declare class RtcConnectionV1 implements IHasPeerConnection {
+    peerConnection: RTCPeerConnection;
+    private config;
+    iceMode?: IIceMode;
+    private readonly connectTimeoutMs;
+    private readonly gatherIceTimeoutMs;
+    private readonly pingUpdateTimeoutMs;
+    private latestTtlStreamChannel?;
+    private reliableStreamChannel?;
+    private latestReliableStreamChannel?;
+    private latestTryOnceStreamChannel?;
+    private streamLatestTimestamp;
+    private pingUpdateTimeout;
+    private pingTimeMs;
+    private lastMessageTimestamp;
+    private connectTimeout;
+    private gatherIceTimeout;
+    private sessionMetrics;
+    private closeCalled;
+    private connectCalled;
+    private sentOffer;
+    private receivedIceCandidate;
+    constructor(peerConnection: RTCPeerConnection, config: IRtcConnectionConfigurationV1);
+    connect(): Promise<void>;
+    handleSignal(signal: IRtcSignal): Promise<void>;
+    /**
+     * Sends a message to the remote peer.
+     */
+    send(message: IRtcStreamMessage, config: IRtcSendConfiguration): void;
+    controlRemoteStream(streamControl: IStreamControl): void;
+    isActive(): boolean;
+    /**
+     * Checks that the peerConnection is connected
+     * and all data channels exist and are open
+     */
+    isReady(): boolean;
+    /**
+     * Checks that the peerConnection is closed and all
+     * existing data channels are closed
+     */
+    isClosed(): boolean;
+    /**
+     * Checks that either the peerConnection is inactive
+     * or at least one of the the data channels exists and is inactive
+     */
+    needsClosing(): boolean | undefined;
+    close(): Promise<void>;
+    getPing(): number | undefined;
+    getLastMessageTimestamp(): number | undefined;
+    getSessionId(): string;
+    getRemotePeer(): import("src").IRtcPeer;
+    private initializeChannels;
+    private sendOffer;
+    private getChannelFromLabel;
+    private sendOnChannel;
+    private channelNotRecognized;
+    private setupChannel;
+    /**
+     * Handles system messages (e.g., ping/pong).
+     * Returns true if the message is a system message.
+     */
+    private handleSystemMessage;
+    private sendSystemMessage;
+    private hasCapabilities;
+    private isLatestMessage;
+}

package/dist/rtc-client/RtcSessionMetrics.d.ts

@@ -0,0 +1,17 @@
+import { Timestamp } from "../model/Timestamp";
+import { IHasPeerConnection } from "./IHasPeerConnection";
+import { IHasRemoteDeviceId } from "./IHasRemoteDeviceId";
+import { IRtcSessionMetricsMessageCounts } from "./models/IRtcSessionMetricsMessageCounts";
+import { IRtcStreamMessage } from "./models/IRtcStreamMessage";
+import { IRtcStreamsInfo } from "./models/IRtcStreamsInfo";
+export declare class RtcSessionMetrics {
+    counts: IRtcSessionMetricsMessageCounts;
+    private readonly sessionId;
+    private readonly connection;
+    constructor(sessionId: string, connection: IHasPeerConnection & IHasRemoteDeviceId);
+    updateRemoteMessagesCounts(message: IRtcStreamMessage): void;
+    getLocalStreamsInfo(timestamp: Timestamp): IRtcStreamsInfo;
+    incrementLocalSent(message: IRtcStreamMessage): void;
+    incrementLocalReceived(message: IRtcStreamMessage): void;
+    uploadMetrics(): Promise<void>;
+}

package/dist/rtc-client/RtcSessionMetricsV1.d.ts

@@ -0,0 +1,14 @@
+import { IHasPeerConnection } from "./IHasPeerConnection";
+import { IRtcStreamMessage } from "./models/IRtcStreamMessage";
+type IRtcConnectionV1 = IHasPeerConnection;
+export declare class RtcSessionMetricsV1 {
+    private readonly sentMessagesCounts;
+    private readonly receivedMessagesCounts;
+    private readonly sessionId;
+    private readonly connection;
+    constructor(sessionId: string, connection: IRtcConnectionV1);
+    incrementMessageSent(message: IRtcStreamMessage): void;
+    incrementMessageReceived(message: IRtcStreamMessage): void;
+    uploadMetrics(): Promise<void>;
+}
+export {};

package/dist/rtc-client/config/index.d.ts

@@ -0,0 +1,11 @@
+import { RtcChannelLabel } from "../models/RtcChannelLabel";
+export declare const latesTtlStreamLabel: RtcChannelLabel;
+export declare const latestTtlStreamConfig: RTCDataChannelInit;
+export declare const reliableStreamLabel: RtcChannelLabel;
+export declare const reliableStreamConfig: RTCDataChannelInit;
+export declare const latestReliableStreamLabel: RtcChannelLabel;
+export declare const latestReliableStreamConfig: RTCDataChannelInit;
+export declare const latestTryOnceStreamLabel: RtcChannelLabel;
+export declare const latestTryOnceStreamConfig: RTCDataChannelInit;
+export declare const heartbeatChannelLabel: RtcChannelLabel;
+export declare const heartbeatChannelConfig: RTCDataChannelInit;

package/dist/rtc-client/gatherPingMetrics.d.ts

@@ -0,0 +1,17 @@
+import { Timestamp } from "../model/Timestamp";
+import { Uuid } from "../model/Uuid";
+import { IPingInfo } from "./models/IPingInfo";
+export interface IPing {
+    sent: Timestamp;
+}
+export interface IPingPong {
+    sent: Timestamp;
+    received: Timestamp;
+}
+export type PingValue = IPing | IPingPong;
+export type PingMap = Map<Uuid, PingValue>;
+interface IGatherPingV2MetricsOptions {
+    temporalNow?: number;
+}
+export declare function gatherPingV2Metrics(pingMap: PingMap, options?: IGatherPingV2MetricsOptions): IPingInfo | null;
+export {};

package/dist/rtc-client/models/IIceMode.d.ts

@@ -0,0 +1 @@
+export type IIceMode = "local" | "STUN" | "TURN";

package/dist/rtc-client/models/IPingInfo.d.ts

@@ -0,0 +1,10 @@
+export interface IPingInfo {
+    pingsSent: number;
+    pongsReceived: number;
+    average: number;
+    standardDeviation: number;
+    jitter: number;
+    min: number;
+    max: number;
+    loss: number;
+}

package/dist/rtc-client/models/IPingPayload.d.ts

@@ -0,0 +1,6 @@
+import { Timestamp } from "../../model/Timestamp";
+import { Uuid } from "../../model/Uuid";
+export interface IPingPayload {
+    timestamp: Timestamp;
+    id: Uuid;
+}

package/dist/rtc-client/models/IRTCStatsIceCandidate.d.ts

@@ -0,0 +1,9 @@
+export interface IRTCStatsIceCandidate {
+    type: "local-candidate" | "remote-candidate";
+    candidateType: "host" | "srflx" | "prflx" | "relay";
+    transportId: string;
+    address: string;
+    port: number;
+    protocol: "udp" | "tcp";
+    relayProtocol?: "udp" | "tcp";
+}

package/dist/rtc-client/models/IRTCStatsIceCandidatePair.d.ts

@@ -0,0 +1,9 @@
+export interface IRTCStatsIceCandidatePair {
+    id: "candidatepair";
+    transportId: string;
+    localCandidateId: string;
+    remoteCandidateId: string;
+    nominated: boolean;
+    bytesReceived: number;
+    bytesSent: number;
+}

package/dist/rtc-client/models/IRTCStatsTransport.d.ts

@@ -0,0 +1,8 @@
+export interface IRTCStatsTransport {
+    id: "transport";
+    selectedCandidatePairId: string;
+    bytesSent: number;
+    bytesReceived: number;
+    packetsSent: number;
+    packetsReceived: number;
+}

package/dist/rtc-client/models/IRtcAgentInfo.d.ts

@@ -0,0 +1,3 @@
+export interface IRtcAgentInfo {
+    isLowBandwidthMode?: boolean;
+}

package/dist/rtc-client/models/IRtcClientConfiguration.d.ts

@@ -0,0 +1,18 @@
+import { Timestamp } from "../../model/Timestamp";
+import { Uuid } from "../../model/Uuid";
+import { SignalingPromiseClient } from "../../protos/api/signaling/v1/signaling_grpc_web_pb";
+import { SessionType } from "../../protos/api/signaling/v1/signaling_pb";
+import { IRtcStreamMessage } from "./IRtcStreamMessage";
+export type IRtcClientConfiguration = {
+    receive: (peerId: Uuid, message: IRtcStreamMessage) => void;
+    onStreamsInfoUpdate?: (peerId: Uuid, timestamp: Timestamp) => void;
+    alternateRTCPeerConnection?: typeof RTCPeerConnection;
+    sessionType?: SessionType;
+} & ({
+    lanOnlyMode: true;
+} | {
+    lanOnlyMode?: false;
+    getToken: () => Promise<string>;
+    signalingClient: SignalingPromiseClient;
+    track?: (event: string, properties?: object) => void;
+});

package/dist/rtc-client/models/IRtcConnectionBaseConfiguration.d.ts

@@ -0,0 +1,16 @@
+import { Timestamp } from "../../model/Timestamp";
+import { Uuid } from "../../model/Uuid";
+import { SessionType } from "../../protos/api/signaling/v1/signaling_pb";
+import { IRtcStreamMessage } from "./IRtcStreamMessage";
+export interface IRtcConnectionBaseConfiguration {
+    isOffer: boolean;
+    isLan: boolean;
+    localPeerId: Uuid;
+    remotePeerId: Uuid;
+    localUserId?: Uuid;
+    remoteDeviceId?: Uuid;
+    sessionType?: SessionType;
+    receive: (peerId: Uuid, message: IRtcStreamMessage) => void;
+    onStreamsInfoUpdate?: (peerId: Uuid, timestamp: Timestamp) => void;
+    track?: (event: string, properties?: object) => void;
+}

package/dist/rtc-client/models/IRtcConnectionConfiguration.d.ts

@@ -0,0 +1,6 @@
+import { IRtcConnectionBaseConfiguration } from "./IRtcConnectionBaseConfiguration";
+import { IRtcConnectionRemoteConfiguration } from "./IRtcConnectionRemoteConfiguration";
+export type IRtcConnectionConfiguration = {
+    baseConfig: IRtcConnectionBaseConfiguration;
+    remoteConfig?: IRtcConnectionRemoteConfiguration;
+};

package/dist/rtc-client/models/IRtcConnectionRemoteConfiguration.d.ts

@@ -0,0 +1,6 @@
+import { Timestamp } from "../../model/Timestamp";
+import { Uuid } from "../../model/Uuid";
+export interface IRtcConnectionRemoteConfiguration {
+    sessionId?: Uuid;
+    sessionCreatedTimestamp?: Timestamp;
+}

package/dist/rtc-client/models/IRtcConnectionStatsInfo.d.ts

@@ -0,0 +1,9 @@
+import { IRTCStatsIceCandidate } from "./IRTCStatsIceCandidate";
+import { IRTCStatsIceCandidatePair } from "./IRTCStatsIceCandidatePair";
+import { IRTCStatsTransport } from "./IRTCStatsTransport";
+export interface IRtcConnectionStatsInfo {
+    transport: IRTCStatsTransport;
+    localCandidate: IRTCStatsIceCandidate;
+    remoteCandidate: IRTCStatsIceCandidate;
+    candidatePair: IRTCStatsIceCandidatePair;
+}

package/dist/rtc-client/models/IRtcPointCloud.d.ts

@@ -0,0 +1,5 @@
+import { ITransform } from "../../model/ITransform";
+export interface IRtcPointCloud {
+    world_to_local?: ITransform;
+    data: string;
+}

package/dist/rtc-client/models/IRtcSendConfiguration.d.ts

@@ -0,0 +1,4 @@
+import { RtcChannelLabel } from "./RtcChannelLabel";
+export interface IRtcSendConfiguration {
+    channelLabel: RtcChannelLabel;
+}

package/dist/rtc-client/models/IRtcSessionMetricsMessageCounts.d.ts

@@ -0,0 +1,6 @@
+export interface IRtcSessionMetricsMessageCounts {
+    localSent: Map<string, number>;
+    localReceived: Map<string, number>;
+    remoteSent: Map<string, number>;
+    remoteReceived: Map<string, number>;
+}

package/dist/rtc-client/models/IRtcStreamCommunication.d.ts

@@ -0,0 +1,4 @@
+import { RtcCommunicationType } from "./RtcCommunicationType";
+export interface IRtcStreamCommunication<T = RtcCommunicationType> {
+    communicationType?: T;
+}

package/dist/rtc-client/models/IRtcStreamMessage.d.ts

@@ -0,0 +1,7 @@
+import { IRtcStreamCommunication } from "./IRtcStreamCommunication";
+import { IRtcStreamMessageHeader } from "./IRtcStreamMessageHeader";
+import { IRtcStreamPayload } from "./IRtcStreamPayload";
+export interface IRtcStreamMessage extends IRtcStreamCommunication<"message" | undefined> {
+    header: IRtcStreamMessageHeader;
+    payload: IRtcStreamPayload;
+}

package/dist/rtc-client/models/IRtcStreamMessageChunk.d.ts

@@ -0,0 +1,7 @@
+import { IRtcStreamCommunication } from "./IRtcStreamCommunication";
+export interface IRtcStreamMessageChunk extends IRtcStreamCommunication<"message-chunk"> {
+    id: number;
+    seq: number;
+    total: number;
+    part: string;
+}

package/dist/rtc-client/models/IRtcStreamMessageHeader.d.ts

@@ -0,0 +1,7 @@
+import { IRtcStream } from "../../model/IRtcStream";
+import { Timestamp } from "../../model/Timestamp";
+export interface IRtcStreamMessageHeader {
+    stream: IRtcStream;
+    created: Timestamp;
+    frameId?: string;
+}

package/dist/rtc-client/models/IRtcStreamPayload.d.ts

@@ -0,0 +1,55 @@
+import { IAudioChunk } from "../../model/IAudioChunk";
+import { ICompressedImage } from "../../model/ICompressedImage";
+import { IGoalID } from "../../model/IGoalID";
+import { IH264VideoFrame } from "../../model/IH264VideoFrame";
+import { IJointState } from "../../model/IJointState";
+import { IJoy } from "../../model/IJoy";
+import { IJsonString } from "../../model/IJsonString";
+import { IMarker3DArray } from "../../model/IMarker3DArray";
+import { IOdometry } from "../../model/IOdometry";
+import { IPoint } from "../../model/IPoint";
+import { IPoseWithCovariance } from "../../model/IPoseWithCovariance";
+import { ITransform } from "../../model/ITransform";
+import { ITwist } from "../../model/ITwist";
+import { Timestamp } from "../../model/Timestamp";
+import { IPingPayload } from "./IPingPayload";
+import { IRtcAgentInfo } from "./IRtcAgentInfo";
+import { IRtcPointCloud } from "./IRtcPointCloud";
+import { IRtcStreamsInfo } from "./IRtcStreamsInfo";
+import { IStreamControl } from "./IStreamControl";
+export interface IRtcStreamPayload {
+    ping?: Timestamp;
+    pong?: Timestamp;
+    pingV2?: IPingPayload;
+    pongV2?: IPingPayload;
+    streamControl?: IStreamControl;
+    streamsInfo?: IRtcStreamsInfo;
+    agentInfo?: IRtcAgentInfo;
+    numeric?: {
+        value: number;
+    };
+    boolean?: boolean;
+    bitset?: {
+        bits: {
+            key: string;
+            value: boolean;
+        }[];
+    };
+    twist?: ITwist;
+    compressedImage?: ICompressedImage;
+    pose?: ITransform;
+    goalID?: IGoalID;
+    h264VideoFrame?: IH264VideoFrame;
+    videoMetadata?: {
+        [key: string]: string;
+    };
+    audioChunk?: IAudioChunk;
+    jointState?: IJointState;
+    poseWithCovariance?: IPoseWithCovariance;
+    pointCloud?: IRtcPointCloud;
+    point?: IPoint;
+    markerArray?: IMarker3DArray;
+    jsonString?: IJsonString;
+    odometry?: IOdometry;
+    joy?: IJoy;
+}

package/dist/rtc-client/models/IRtcStreamsInfo.d.ts

@@ -0,0 +1,9 @@
+import { Timestamp } from "../../model/Timestamp";
+export interface IRtcStreamsInfo {
+    items: {
+        streamId: string;
+        sentCount: number;
+        receivedCount: number;
+    }[];
+    timestamp: Timestamp;
+}