@livedigital/client 3.40.0-test-rejoins.2 → 3.40.0

package/dist/constants/common.d.ts

@@ -55,3 +55,5 @@ export declare enum HttpStatusCode {
     ServiceUnavailable = 503,
     GatewayTimeout = 504
 }
+export declare const CHANNEL_MESSAGES_DATA_PRODUCER = "channel-messages-data-producer";
+export declare const UI_BLOCKING_THRESHOLD_MS = 50;

package/dist/constants/common.ts

@@ -83,3 +83,7 @@ export enum HttpStatusCode {
   ServiceUnavailable = 503,
   GatewayTimeout = 504,
 }
+
+export const CHANNEL_MESSAGES_DATA_PRODUCER = 'channel-messages-data-producer';
+
+export const UI_BLOCKING_THRESHOLD_MS = 50;

package/dist/constants/events.d.ts

@@ -2,6 +2,8 @@ export declare const CHANNEL_EVENTS: {
     readonly channelEvent: "channel.event";
     readonly channelJoin: "channel.join";
     readonly channelGetPeers: "channel.getPeers";
+    readonly channelTriggerStateEvent: "channel.triggerStateEvent";
+    readonly channelState: "channel.state";
     readonly channelLeave: "peer.disconnected";
     readonly updatePeerAppData: "peer.updateAppData";
     readonly activityConfirm: "channel.confirmActivity";
@@ -9,8 +11,6 @@ export declare const CHANNEL_EVENTS: {
     readonly activityConfirmationRequired: "channel.activityConfirmationRequired";
     readonly activityConfirmationExpired: "channel.activityConfirmationExpired";
     readonly getAudioObserverProducer: "channel.getAudioObserverProducer";
-    readonly getGeneralDataProducer: "channel.getGeneralDataProducer";
-    readonly getChannelStateSyncDataProducer: "channel.getChannelStateSyncDataProducer";
     readonly changeProducePermissions: "channel.changeProducePermissions";
     readonly deleteProducePermissions: "channel.deleteProducePermissions";
     readonly changePeerProducePermissions: "peer.changeProducePermissions";
@@ -18,6 +18,7 @@ export declare const CHANNEL_EVENTS: {
     readonly removePeerProducePermissions: "peer.removeProducePermissions";
     readonly changePeerGroups: "peer.groupsChanged";
     readonly ping: "peer.ping";
+    readonly audioObserverMessage: "audioObserver.message";
 };
 export declare const CLIENT_EVENTS: {
     readonly channelEvent: "channel-event";
@@ -38,6 +39,7 @@ export declare const CLIENT_EVENTS: {
     readonly forcedDisconnect: "forced-disconnect";
     readonly rejectUnauthorized: "reject-unauthorized";
     readonly denoiserInitializing: "denoiser-initializing";
+    readonly channelStateSynced: "channel-state-synced";
     readonly denoiserEnabled: "denoiser-enabled";
     readonly denoiserDisabled: "denoiser-disabled";
     readonly denoiserFallback: "denoiser-fallback";

package/dist/constants/events.ts

@@ -2,6 +2,8 @@ export const CHANNEL_EVENTS = {
   channelEvent: 'channel.event',
   channelJoin: 'channel.join',
   channelGetPeers: 'channel.getPeers',
+  channelTriggerStateEvent: 'channel.triggerStateEvent',
+  channelState: 'channel.state',
   channelLeave: 'peer.disconnected',
   updatePeerAppData: 'peer.updateAppData',
   activityConfirm: 'channel.confirmActivity',
@@ -9,8 +11,6 @@ export const CHANNEL_EVENTS = {
   activityConfirmationRequired: 'channel.activityConfirmationRequired',
   activityConfirmationExpired: 'channel.activityConfirmationExpired',
   getAudioObserverProducer: 'channel.getAudioObserverProducer',
-  getGeneralDataProducer: 'channel.getGeneralDataProducer',
-  getChannelStateSyncDataProducer: 'channel.getChannelStateSyncDataProducer',
   changeProducePermissions: 'channel.changeProducePermissions',
   deleteProducePermissions: 'channel.deleteProducePermissions',
   changePeerProducePermissions: 'peer.changeProducePermissions',
@@ -18,6 +18,7 @@ export const CHANNEL_EVENTS = {
   removePeerProducePermissions: 'peer.removeProducePermissions',
   changePeerGroups: 'peer.groupsChanged',
   ping: 'peer.ping',
+  audioObserverMessage: 'audioObserver.message',
 } as const;
 
 export const CLIENT_EVENTS = {
@@ -39,6 +40,7 @@ export const CLIENT_EVENTS = {
   forcedDisconnect: 'forced-disconnect',
   rejectUnauthorized: 'reject-unauthorized',
   denoiserInitializing: 'denoiser-initializing',
+  channelStateSynced: 'channel-state-synced',
   denoiserEnabled: 'denoiser-enabled',
   denoiserDisabled: 'denoiser-disabled',
   denoiserFallback: 'denoiser-fallback',

package/dist/engine/ChannelStateSynchronizer/ChannelStateSynchronizer.d.ts

@@ -6,6 +6,7 @@ import EnhancedEventEmitter from '../../EnhancedEventEmitter';
 import EventsQueue from '../EventsQueue';
 import Logger from '../Logger';
 import { RestoreChannelStateResult } from './types';
+import { ChannelState } from '../../proto/generated/channel/channel_state';
 declare class ChannelStateSynchronizer {
     #private;
     private readonly network;
@@ -14,10 +15,13 @@ declare class ChannelStateSynchronizer {
     private readonly eventsQueue;
     private readonly clientEventEmitter;
     private readonly peers;
-    readonly debouncedRestoreState: (this: ChannelStateSynchronizer, ...args: Parameters<() => Promise<void>>) => void | Promise<void>;
+    readonly debouncedTriggerChannelStateEvent: (this: ChannelStateSynchronizer) => void;
     constructor(network: Network, media: Media, myPeer: MyPeer, eventsQueue: EventsQueue, clientEventEmitter: EnhancedEventEmitter, peers: Peers, loggerFactory: (namespace: string) => Logger);
+    handleChannelStateEvent(channelState: ChannelState): void;
     private watchNetworkState;
-    restoreState(): Promise<RestoreChannelStateResult>;
+    triggerChannelStateEvent(): Promise<void>;
+    loadChannelState(channelState: ChannelState): void;
+    restoreState(channelState: ChannelState): Promise<RestoreChannelStateResult>;
     private restoreRemoteProducersState;
     private removeUnnecessaryPeers;
     private setMissingPeers;

package/dist/engine/EventsQueue.d.ts

@@ -1,16 +1,21 @@
 import { DataConsumer } from 'mediasoup-client/lib/DataConsumer';
 import { Logger } from '../types/common';
+import { ChannelEvent } from '../proto/generated/channel_message/channel_event';
+import { MediaEvent } from '../proto/generated/channel_message/media_event';
 export default class EventsQueue {
     #private;
     constructor(loggerFactory: (namespace: string) => Logger);
+    setMediaEventHandler(handler: (event: MediaEvent) => void): void;
+    setChannelEventHandler(handler: (event: ChannelEvent) => void): void;
     subscribe(dataChannel: DataConsumer): void;
-    on(event: string, handler: (...args: any[]) => void | Promise<void>): void;
-    removeListener(event: string): void;
-    removeListeners(events: string[], emitter?: DataConsumer): void;
     private push;
     private process;
-    private emit;
+    private processMessageChunk;
+    private parseMessageChunkHeader;
+    private isPendingMessageFullyReceived;
+    private finalizeMessageBytes;
     pause(): void;
     size(): number;
     resume(): void;
+    isMessageReceived(messageId: number): boolean;
 }

package/dist/engine/PeerProducer.d.ts

@@ -8,8 +8,8 @@ declare class PeerProducer {
     readonly label: TrackLabel;
     paused: boolean;
     readonly encodings: RtpEncodingParameters[];
-    readonly trackTransformParams: TrackTransformParams;
     readonly maxSpatialLayer: number;
+    readonly trackTransformParams?: TrackTransformParams;
     constructor(params: ProducerData);
 }
 export default PeerProducer;

package/dist/engine/Peers.d.ts

@@ -5,6 +5,7 @@ import { MyPeer } from './MyPeer';
 import Network from './network';
 import Peer from './Peer';
 import PeerConsumer from './PeerConsumer';
+import PeersStorage from './PeersStorage';
 export interface IPeersService {
     has: (id: Peer['id']) => boolean;
     get: (id: Peer['id']) => Peer | undefined;
@@ -16,7 +17,6 @@ export interface IPeersService {
     load: (role?: Role) => Promise<void>;
     add: (peerData: PeerResponse, emit: boolean) => Peer;
     isModerator: (id: Peer['id'] | undefined) => boolean;
-    setActiveSpeaker: (peer?: Peer) => void;
 }
 export interface CreatePeerParams {
     id: string;
@@ -39,8 +39,7 @@ export declare class Peers implements IPeersService {
     private readonly peerFactory;
     private readonly clientEventEmitter;
     private readonly peersStorage;
-    private activePeerId?;
-    constructor(myPeer: MyPeer, network: Network, peerFactory: PeerFactory, clientEventEmitter: EnhancedEventEmitter);
+    constructor(myPeer: MyPeer, network: Network, peerFactory: PeerFactory, clientEventEmitter: EnhancedEventEmitter, peersStorage: PeersStorage);
     has(id: Peer['id']): boolean;
     private set;
     get(id: Peer['id']): Peer | undefined;
@@ -53,5 +52,4 @@ export declare class Peers implements IPeersService {
     load(role?: Role): Promise<void>;
     add(peerData: PeerResponse, emit?: boolean): Peer;
     isModerator(id: Peer['id'] | undefined): boolean;
-    setActiveSpeaker(peer?: Peer): void;
 }

package/dist/engine/PeersStorage.d.ts

@@ -0,0 +1,13 @@
+import Peer from './Peer';
+declare class PeersStorage {
+    private readonly peers;
+    has(id: Peer['id']): boolean;
+    set(id: Peer['id'], peer: Peer): void;
+    get(id: Peer['id']): Peer | undefined;
+    delete(id: Peer['id']): boolean;
+    all(): Peer[];
+    hosts(): Peer[];
+    audience(): Peer[];
+    clear(): void;
+}
+export default PeersStorage;

package/dist/engine/handlers/ChannelAudioObserverEventHandler.d.ts

@@ -1,16 +1,17 @@
 import EnhancedEventEmitter from '../../EnhancedEventEmitter';
 import Logger from '../Logger';
-import { Peers } from '../Peers';
+import PeersStorage from '../PeersStorage';
 declare class ChannelAudioObserverEventHandler {
     #private;
-    private readonly peers;
+    private readonly peersStorage;
     private readonly clientEventEmitter;
-    constructor(peers: Peers, clientEventEmitter: EnhancedEventEmitter, loggerFactory: (namespace: string) => Logger);
+    constructor(peersStorage: PeersStorage, clientEventEmitter: EnhancedEventEmitter, loggerFactory: (namespace: string) => Logger);
     handle(data: string): void;
     private handleDominantSpeaker;
     private handlePeerVolumes;
     private handleSilence;
     private watchPeersLeave;
+    private setActiveSpeaker;
     private static validateEventPayload;
     static throwInvalidPayload(): void;
 }

package/dist/engine/handlers/ChannelEventHandler.d.ts

@@ -1,17 +1,29 @@
 import EnhancedEventEmitter from '../../EnhancedEventEmitter';
-import EventsQueue from '../EventsQueue';
 import Logger from '../Logger';
 import { Peers } from '../Peers';
-import DataChannelsManager from '../network/DataChannelsManager';
+import ChannelStateSyncEventHandler from './ChannelStateSyncEventHandler';
+import type { ChannelEvent } from '../../proto/generated/channel_message/channel_event';
+import ChannelStateSynchronizer from '../ChannelStateSynchronizer/ChannelStateSynchronizer';
 declare class ChannelEventHandler {
     #private;
-    private readonly eventsQueue;
-    private readonly dataChannelsManager;
     private readonly peers;
     private readonly clientEventEmitter;
-    constructor(eventsQueue: EventsQueue, dataChannelsManager: DataChannelsManager, peers: Peers, clientEventEmitter: EnhancedEventEmitter, loggerFactory: (namespace: string) => Logger);
-    subscribeToEvents(): void;
-    private removeEventListeners;
-    reset(): void;
+    private readonly channelStateSyncEventHandler;
+    private readonly channelStateSynchronizer;
+    constructor(peers: Peers, clientEventEmitter: EnhancedEventEmitter, loggerFactory: (namespace: string) => Logger, channelStateSyncEventHandler: ChannelStateSyncEventHandler, channelStateSynchronizer: ChannelStateSynchronizer);
+    handleChannelEvent(event: ChannelEvent): void;
+    private handleChannelManagementEvent;
+    private handlePeerJoined;
+    private handlePeerLeft;
+    private handleChannelState;
+    private handleChannelStateShort;
+    private handlePeerAppDataChanged;
+    private handlePeerGroupsChanged;
+    private handleChannelActivityConfirmationExpired;
+    private handleChannelActivityConfirmationAcquired;
+    private handleChannelActivityConfirmationRequired;
+    private handleChannelProducePermissionsChanged;
+    private handlePeerProducePermissionsChanged;
+    private handleChannelProducePermissionsDeleted;
 }
 export default ChannelEventHandler;

package/dist/engine/handlers/ChannelStateSyncEventHandler/ChannelStateConsistencyChecker.d.ts

@@ -1,8 +1,8 @@
-import type { ChannelState } from '../../../types/channelStateSyncronizer';
+import type { ChannelStateShort } from '../../../proto/generated/channel/channel_state_short';
 import ChannelStateConsistencyCheckResult from './ChannelStateConsistencyCheckResult';
 interface ChannelStateConsistencyCheckerParams {
-    localState: ChannelState;
-    remoteState: ChannelState;
+    localState: ChannelStateShort;
+    remoteState: ChannelStateShort;
 }
 declare class ChannelStateConsistencyChecker {
     private readonly localState;

package/dist/engine/handlers/ChannelStateSyncEventHandler/index.d.ts

@@ -1,22 +1,22 @@
 import WebRTCIssueDetector from 'webrtc-issue-detector';
 import Network from '../../network';
 import SocketIO from '../../network/Socket';
-import { Peers } from '../../Peers';
 import EnhancedEventEmitter from '../../../EnhancedEventEmitter';
-import ChannelStateSynchronizer from '../../ChannelStateSynchronizer/ChannelStateSynchronizer';
 import Logger from '../../Logger';
 import { CallState } from '../../CallState';
+import PeersStorage from '../../PeersStorage';
+import { ChannelStateShort } from '../../../proto/generated/channel/channel_state_short';
 declare class ChannelStateSyncEventHandler {
     #private;
-    private readonly channelStateSynchronizer;
     private readonly network;
     private readonly callState;
     private readonly socket;
-    private readonly peers;
+    private readonly peersStorage;
     private readonly clientEventEmitter;
     private readonly webRtcIssueDetector?;
-    constructor(channelStateSynchronizer: ChannelStateSynchronizer, loggerFactory: (namespace: string) => Logger, network: Network, callState: CallState, socket: SocketIO, peers: Peers, clientEventEmitter: EnhancedEventEmitter, webRtcIssueDetector?: WebRTCIssueDetector | undefined);
-    handle(payload: Buffer): Promise<void>;
+    readonly debouncedHandleChannelStateEvent: (remoteState: ChannelStateShort) => Promise<void>;
+    constructor(loggerFactory: (namespace: string) => Logger, network: Network, callState: CallState, socket: SocketIO, peersStorage: PeersStorage, clientEventEmitter: EnhancedEventEmitter, webRtcIssueDetector?: WebRTCIssueDetector | undefined);
+    handleChannelStateShort(data: ChannelStateShort): Promise<void>;
     private handleChannelStateEvent;
     private getLastInconsistencyCheckResult;
     private handleConfirmedInconsistencyResult;
@@ -30,7 +30,6 @@ declare class ChannelStateSyncEventHandler {
     private getConfirmedConsumersWithInconsistencState;
     private getConfirmedProducersWithInconsistencState;
     private getConfirmedPeersWithInconsistentAppData;
-    private parseChannelStateSyncEventPayload;
     private getLocalState;
     private getIsConnectionActive;
     private listenNetworkScoresUpdatedEvents;

package/dist/engine/handlers/MediaEventHandler.d.ts

@@ -0,0 +1,27 @@
+import Media from '../media';
+import EnhancedEventEmitter from '../../EnhancedEventEmitter';
+import { Logger } from '../../types/common';
+import PeersStorage from '../PeersStorage';
+import { MediaEvent } from '../../proto/generated/channel_message/media_event';
+declare class MediaEventHandler {
+    #private;
+    private readonly media;
+    private readonly internalEventEmitter;
+    private readonly peersStorage;
+    private readonly clientEventEmitter;
+    constructor(media: Media, internalEventEmitter: EnhancedEventEmitter, peersStorage: PeersStorage, clientEventEmitter: EnhancedEventEmitter, loggerFactory: (namespace: string) => Logger);
+    handleMediaEvent(event: MediaEvent): void;
+    private handleProducerCreated;
+    private handleProducerClosed;
+    private handleProducerPaused;
+    private handleProducerResumed;
+    private handleProducerMaxSpatialLayerChanged;
+    private handleProducerRequestMaxSpatialLayer;
+    private handleProducerForciblyClosed;
+    private handleConsumerClosed;
+    private handleConsumerResumed;
+    private handleConsumerPaused;
+    private handleConsumerPreferredLayersChanged;
+    private handleTransportConnectionTimeout;
+}
+export default MediaEventHandler;

package/dist/engine/index.d.ts

@@ -5,10 +5,9 @@ import type { PeerTrackFactory } from '../types/container';
 import { ClientObserverEvents, InternalObserverEvents } from '../types/engine';
 import { AudioTrack, BaseTrack, Track } from '../types/media';
 import { CallState } from './CallState';
-import ChannelStateSynchronizer from './ChannelStateSynchronizer/ChannelStateSynchronizer';
 import EventsQueue from './EventsQueue';
 import ChannelEventHandler from './handlers/ChannelEventHandler';
-import MediaSoupEventHandler from './handlers/MediaSoupEventHandler';
+import MediaEventHandler from './handlers/MediaEventHandler';
 import { IntegrationsService } from './IntegrationsService';
 import Logger from './Logger';
 import Media from './media';
@@ -16,7 +15,6 @@ import { ProcessorsCache } from './media/streamEffects/ProcessorsCache';
 import VideoTrack from './media/tracks/DefaultVideoTrack';
 import { MyPeer } from './MyPeer';
 import Network from './network';
-import DataChannelsManager from './network/DataChannelsManager';
 import LoadBalancerApiClient from './network/LoadBalancerClient';
 import SocketIO from './network/Socket';
 import Peer from './Peer';
@@ -31,9 +29,8 @@ declare class Engine {
     private readonly myPeer;
     private readonly integrationsService;
     private readonly processorsCache;
-    private readonly mediaSoupEventsHandler;
+    private readonly mediaEventHandler;
     private readonly channelEventsHandler;
-    readonly channelStateSynchronizer: ChannelStateSynchronizer;
     private readonly peerTrackFactory;
     private readonly peers;
     readonly system: System;
@@ -45,13 +42,12 @@ declare class Engine {
     private readonly clientEventEmitter;
     private readonly internalEventEmitter;
     private readonly statsHandler;
-    private readonly dataChannelsManager;
     private readonly transportsStatsProvider;
     private readonly webRtcIssueDetector?;
     private rejoinRequested;
     private isReleasing;
     private readonly mark;
-    constructor(state: CallState, myPeer: MyPeer, loggerFactory: (namespace: string) => Logger, integrationsService: IntegrationsService, processorsCache: ProcessorsCache, mediaSoupEventsHandler: MediaSoupEventHandler, channelEventsHandler: ChannelEventHandler, channelStateSynchronizer: ChannelStateSynchronizer, peerTrackFactory: PeerTrackFactory, peers: IPeersService, system: System, media: Media, network: Network, loadBalancerClient: LoadBalancerApiClient, socket: SocketIO, eventsQueue: EventsQueue, clientEventEmitter: EnhancedEventEmitter<ClientObserverEvents>, internalEventEmitter: EnhancedEventEmitter<InternalObserverEvents>, statsHandler: StatsHandler, dataChannelsManager: DataChannelsManager, transportsStatsProvider: TransportsStatsProvider, webRtcIssueDetector?: WebRTCIssueDetector | undefined);
+    constructor(state: CallState, myPeer: MyPeer, loggerFactory: (namespace: string) => Logger, integrationsService: IntegrationsService, processorsCache: ProcessorsCache, mediaEventHandler: MediaEventHandler, channelEventsHandler: ChannelEventHandler, peerTrackFactory: PeerTrackFactory, peers: IPeersService, system: System, media: Media, network: Network, loadBalancerClient: LoadBalancerApiClient, socket: SocketIO, eventsQueue: EventsQueue, clientEventEmitter: EnhancedEventEmitter<ClientObserverEvents>, internalEventEmitter: EnhancedEventEmitter<InternalObserverEvents>, statsHandler: StatsHandler, transportsStatsProvider: TransportsStatsProvider, webRtcIssueDetector?: WebRTCIssueDetector | undefined);
     get isChannelJoined(): boolean;
     private initialize;
     release(keepTracks?: boolean): Promise<void>;
@@ -61,6 +57,7 @@ declare class Engine {
     confirmActivity(): Promise<void>;
     join(params: JoinChannelParams): Promise<void>;
     loadPeers(role?: Role): Promise<void>;
+    requestChannelStateSync(): void;
     setPeer(peerData: PeerResponse, emit?: boolean): Peer;
     removePeer(peerId: string): Promise<void>;
     updateAppData(appData: Record<string, unknown>): Promise<void>;

package/dist/engine/network/DataChannelsManager.d.ts

@@ -1,25 +1,24 @@
 import { DataConsumer } from 'mediasoup-client/lib/DataConsumer';
 import Logger from '../Logger';
-import Network from '.';
-import ChannelAudioObserverEventHandler from '../handlers/ChannelAudioObserverEventHandler';
-import ChannelStateSyncEventHandler from '../handlers/ChannelStateSyncEventHandler';
-import EventsQueue from '../EventsQueue';
 import { CallState } from '../CallState';
 import { MyPeer } from '../MyPeer';
+import SocketIO from './Socket';
+import { types } from 'mediasoup-client';
+import ChannelAudioObserverEventHandler from '../handlers/ChannelAudioObserverEventHandler';
 declare class DataChannelsManager {
     #private;
     private readonly state;
     private readonly myPeer;
-    readonly network: Network;
-    private readonly eventsQueue;
+    private readonly socket;
     private readonly channelAudioObserverEventHandler;
-    private readonly channelStateSyncEventHandler;
-    constructor(state: CallState, loggerFactory: (namespace: string) => Logger, myPeer: MyPeer, network: Network, eventsQueue: EventsQueue, channelAudioObserverEventHandler: ChannelAudioObserverEventHandler, channelStateSyncEventHandler: ChannelStateSyncEventHandler);
-    get generalDataConsumer(): DataConsumer | undefined;
-    createAllDataChannels(): Promise<void>;
-    closeAllDataChannels(): void;
-    private createAudioObserver;
-    private createGeneralDataConsumer;
-    private createChannelStateSyncDataConsumer;
+    constructor(state: CallState, loggerFactory: (namespace: string) => Logger, myPeer: MyPeer, socket: SocketIO, channelAudioObserverEventHandler: ChannelAudioObserverEventHandler);
+    get channelMessagesDataConsumer(): DataConsumer | undefined;
+    createAudioObserver(transport: types.Transport): Promise<void>;
+    createChannelMessagesDataConsumer(transport: types.Transport): Promise<void>;
+    closeAudioObserver(): void;
+    closeChannelMessagesDataConsumer(): void;
+    private createDataProducer;
+    private createDataConsumer;
+    private getAudioObserverProducer;
 }
 export default DataChannelsManager;

package/dist/engine/network/index.d.ts

@@ -1,7 +1,7 @@
 import { Device, type types } from 'mediasoup-client';
 import { IceParameters, Transport } from 'mediasoup-client/lib/Transport';
 import EnhancedEventEmitter from '../../EnhancedEventEmitter';
-import { CreateConsumerPayload, CreateConsumerResponse, CreateDataConsumerPayload, PeerResponse, Role, SocketResponse, TransportsStateInfo, UpdatePeerAppDataPayload } from '../../types/common';
+import { CreateConsumerPayload, CreateConsumerResponse, PeerResponse, Role, SocketResponse, TransportsStateInfo, UpdatePeerAppDataPayload } from '../../types/common';
 import { NetworkObserverEvents } from '../../types/network';
 import { CallState } from '../CallState';
 import Logger from '../Logger';
@@ -9,12 +9,14 @@ import { MyPeer } from '../MyPeer';
 import SocketIO from './Socket';
 import { LDTransport } from '../../types/mediasoup';
 import { ClientObserverEvents } from '../../types/engine';
+import DataChannelsManager from './DataChannelsManager';
 declare class Network {
     #private;
     private readonly state;
     private readonly myPeer;
     private readonly socket;
     private readonly clientEventEmitter;
+    private readonly dataChannelsManager;
     sendTransport?: Transport;
     receiveTransport?: Transport;
     signalingDataProducer?: types.DataProducer;
@@ -22,7 +24,7 @@ declare class Network {
     private signalingConsumerId?;
     private preferRelay?;
     peersLoaded: boolean;
-    constructor(state: CallState, myPeer: MyPeer, loggerFactory: (namespace: string) => Logger, socket: SocketIO, clientEventEmitter: EnhancedEventEmitter<ClientObserverEvents>);
+    constructor(state: CallState, myPeer: MyPeer, loggerFactory: (namespace: string) => Logger, socket: SocketIO, clientEventEmitter: EnhancedEventEmitter<ClientObserverEvents>, dataChannelsManager: DataChannelsManager);
     get isNetworkActive(): boolean;
     get observer(): EnhancedEventEmitter<NetworkObserverEvents>;
     get isSocketConnectionActive(): boolean;
@@ -40,24 +42,27 @@ declare class Network {
     getIceParameters(transport: Transport): Promise<IceParameters>;
     restartIce(transport: Transport): Promise<void>;
     createConsumer({ producerId, rtpCapabilities, appId, channelId, producerPeerId, }: CreateConsumerPayload): Promise<CreateConsumerResponse>;
-    createDataConsumer({ producerId, appId, channelId, ordered, }: CreateDataConsumerPayload): Promise<types.DataConsumer>;
     createSignalingConsumer(): Promise<void>;
+    get channelMessagesDataConsumer(): types.DataConsumer | undefined;
     private closePingConsumer;
     closeRemoteConsumer(consumerId: string): Promise<SocketResponse>;
     resumeRemoteConsumer(consumerId: string): Promise<SocketResponse>;
     pauseRemoteProducer(producerId: string): Promise<SocketResponse>;
     pauseRemoteConsumer(consumerId: string): Promise<SocketResponse>;
     updatePeerAppData({ peerId, appData }: UpdatePeerAppDataPayload): Promise<SocketResponse>;
-    getAudioObserverProducer(): Promise<SocketResponse>;
-    getGeneralDataProducer(): Promise<SocketResponse>;
-    getChannelStateSyncDataProducer(): Promise<SocketResponse>;
-    createDataProducer(label: string): Promise<SocketResponse>;
     getTransportsStateInfo(): Promise<TransportsStateInfo>;
     setPreferRelay(value: boolean): void;
     getPreferRelay(): boolean;
     getChannelPeers(role?: Role): Promise<{
         peers: PeerResponse[];
     }>;
+    createAllDataChannels(): Promise<void>;
+    closeAllDataChannels(): void;
+    waitForReceiveTransportConnected(): Promise<void>;
+    triggerChannelStateEvent(peersRole?: Role): Promise<number>;
+    waitForChannelMessagesDataConsumerConnected(): Promise<void>;
+    private waitForTransportConnected;
+    private waitForDataConsumerConnected;
     private getParsedTransportStats;
     private logTransportDetails;
     private stopRestartIceAttempts;

package/dist/helpers/channelMessageConverter.d.ts

@@ -0,0 +1,16 @@
+import type { MediaKind } from 'mediasoup-client/lib/RtpParameters';
+import type { PeerGroup, PeerResponse, ProducerData, Role } from '../types/common';
+import { TrackLabel } from '../types/common';
+import { ProducerLabel } from '../proto/generated/producer/producer_label';
+import type { Producer as ChannelMessageProducer } from '../proto/generated/producer/producer';
+import type { Peer as ChannelMessagePeer } from '../proto/generated/peer/peer';
+import { PeerGroup as ChannelMessagePeerGroup } from '../proto/generated/peer/peer_group';
+import { PeerRole as ChannelMessagePeerRole } from '../proto/generated/peer/peer_role';
+import { ProducerKind as ChannelMessageProducerKind } from '../proto/generated/producer/producer_kind';
+export declare const convertChannelMessageProducerKindToMediaKind: (producerKind: ChannelMessageProducerKind) => MediaKind;
+export declare const convertChannelMessagePeerGroupsToPeerGroups: (peerGroup: ChannelMessagePeerGroup) => PeerGroup;
+export declare const convertChannelMessageProducerLabelsToTrackLabels: (producerLabel: ProducerLabel) => TrackLabel;
+export declare const convertChannelMessagePeerRoleToRole: (peerRole: ChannelMessagePeerRole) => Role;
+export declare const convertChannelMessagePeerToPeerResponse: (peer: ChannelMessagePeer) => PeerResponse;
+export declare const convertChannelMessageProducerToProducerData: (producer: ChannelMessageProducer) => ProducerData;
+export declare const convertPeerGroupsToChannelMessagePeerGroups: (peerGroup: PeerGroup) => ChannelMessagePeerGroup;

package/dist/helpers/common.d.ts

@@ -7,7 +7,7 @@ declare global {
 type PlainObject = Record<string, unknown>;
 export declare function isObject(value: unknown): value is PlainObject;
 export declare function deepEqualObject(object1: PlainObject, object2: PlainObject): boolean;
-export declare function debounce<T extends (...args: unknown[]) => void>(callback: T, delay: number, immediate?: boolean): (this: unknown, ...args: Parameters<typeof callback>) => void;
+export declare function debounce<T extends (...args: never[]) => Promise<void>>(callback: T, delay: number, immediate?: boolean): (this: unknown, ...args: Parameters<typeof callback>) => Promise<void>;
 export declare function prepareLogLevel(level?: LogLevel): LogLevel;
 export declare function isAnalyticsActive(flag?: boolean): boolean;
 export declare function randomString(): string;

package/dist/index.d.ts

@@ -29,6 +29,7 @@ declare class Client {
     createCustomVideoTrack(options: CreateCustomVideoOptions): Track;
     deleteTrack(track: Track): Promise<void>;
     loadPeers(role?: Role): Promise<void>;
+    requestChannelStateSync(): void;
     updateAppData(appData: Record<string, unknown>): Promise<void>;
     getTransportsInfo(): Promise<TransportsStateInfo>;
     setPreferRelay(value: boolean): void;