@livedigital/client 3.16.0-new-peer-id.2 → 3.16.0

package/dist/EnhancedEventEmitter.d.ts

@@ -1,20 +1,7 @@
 /// <reference types="node" />
 import { EventEmitter } from 'events';
-declare type Events = Record<string, any[]>;
-export default class EnhancedEventEmitter<E extends Events = Events> extends EventEmitter {
+declare class EnhancedEventEmitter extends EventEmitter {
     constructor();
-    emit<K extends keyof E & string>(eventName: K, ...args: E[K]): boolean;
-    safeEmit<K extends keyof E & string>(eventName: K, ...args: E[K]): boolean;
-    on<K extends keyof E & string>(eventName: K, listener: (...args: E[K]) => void): this;
-    off<K extends keyof E & string>(eventName: K, listener: (...args: E[K]) => void): this;
-    addListener<K extends keyof E & string>(eventName: K, listener: (...args: E[K]) => void): this;
-    prependListener<K extends keyof E & string>(eventName: K, listener: (...args: E[K]) => void): this;
-    once<K extends keyof E & string>(eventName: K, listener: (...args: E[K]) => void): this;
-    prependOnceListener<K extends keyof E & string>(eventName: K, listener: (...args: E[K]) => void): this;
-    removeListener<K extends keyof E & string>(eventName: K, listener: (...args: E[K]) => void): this;
-    removeAllListeners<K extends keyof E & string>(eventName?: K): this;
-    listenerCount<K extends keyof E & string>(eventName: K): number;
-    listeners<K extends keyof E & string>(eventName: K): Function[];
-    rawListeners<K extends keyof E & string>(eventName: K): Function[];
+    safeEmit(event: string, ...args: unknown[]): boolean;
 }
-export {};
+export default EnhancedEventEmitter;

package/dist/constants/common.d.ts

@@ -1,5 +1,5 @@
 import { LogLevel } from '../types/common';
-export declare const SIGNALING_API_VERSION = 3;
+export declare const SIGNALING_API_VERSION = 2;
 export declare const LOG_LEVEL_ERROR: LogLevel;
 export declare const LOG_LEVEL_WARN: LogLevel;
 export declare const LOG_LEVEL_INFO: LogLevel;

package/dist/constants/common.ts

@@ -1,6 +1,6 @@
 import { LogLevel } from '../types/common';
 
-export const SIGNALING_API_VERSION = 3;
+export const SIGNALING_API_VERSION = 2;
 
 export const LOG_LEVEL_ERROR: LogLevel = 3;
 export const LOG_LEVEL_WARN: LogLevel = 4;

package/dist/constants/events.d.ts

@@ -1,87 +1,81 @@
 export declare const CHANNEL_EVENTS: {
-    readonly channelEvent: "channel.event";
-    readonly channelJoin: "channel.join";
-    readonly channelGetPeers: "channel.getPeers";
-    readonly channelLeave: "peer.disconnected";
-    readonly updatePeerAppData: "peer.updateAppData";
-    readonly activityConfirm: "channel.confirmActivity";
-    readonly activityConfirmationAcquired: "channel.activityConfirmationAcquired";
-    readonly activityConfirmationRequired: "channel.activityConfirmationRequired";
-    readonly activityConfirmationExpired: "channel.activityConfirmationExpired";
-    readonly getAudioObserverProducer: "channel.getAudioObserverProducer";
-    readonly getGeneralDataProducer: "channel.getGeneralDataProducer";
-    readonly getChannelStateSyncDataProducer: "channel.getChannelStateSyncDataProducer";
+    channelEvent: string;
+    channelJoin: string;
+    channelGetPeers: string;
+    channelLeave: string;
+    updatePeerAppData: string;
+    activityConfirm: string;
+    activityConfirmationAcquired: string;
+    activityConfirmationRequired: string;
+    activityConfirmationExpired: string;
+    getAudioObserverProducer: string;
+    getGeneralDataProducer: string;
+    getChannelStateSyncDataProducer: string;
 };
 export declare const CLIENT_EVENTS: {
-    readonly channelEvent: "channel-event";
-    readonly peerJoined: "peer-joined";
-    readonly peerLeft: "peer-left";
-    readonly activityConfirmationRequired: "channel-activity-confirmation-required";
-    readonly activityConfirmationAcquired: "channel-activity-confirmation-acquired";
-    readonly activityConfirmationExpired: "channel-activity-confirmation-expired";
-    readonly channelRejoinRequired: "channel-rejoin-required";
-    readonly devicesListUpdated: "devices-list-updated";
-    readonly transportConnectionTimeout: "transport-connection-timeout";
-    readonly trackForceClosed: "track-force-closed";
-    readonly activeSpeakerChanged: "active-speaker-changed";
-    readonly connectionLost: "connection-lost";
-    readonly connectionRestored: "connection-restored";
-    readonly forcedDisconnect: "forced-disconnect";
-    readonly rejectUnauthorized: "reject-unauthorized";
+    channelEvent: string;
+    peerJoined: string;
+    peerLeft: string;
+    activityConfirmationRequired: string;
+    activityConfirmationAcquired: string;
+    activityConfirmationExpired: string;
+    channelRejoinRequired: string;
+    devicesListUpdated: string;
+    transportConnectionTimeout: string;
+    trackPublishingFailed: string;
+    trackForceClosed: string;
+    activeSpeakerChanged: string;
+    channelStateInconsistent: string;
 };
 export declare const TRACK_EVENTS: {
-    readonly volumeChanged: "volume-changed";
+    volumeChanged: string;
 };
 export declare const INTERNAL_CLIENT_EVENTS: {
-    readonly trackProduced: "track-produced";
-    readonly trackUnproduced: "track-unproduced";
-    readonly trackPaused: "track-paused";
-    readonly trackResumed: "track-resumed";
-    readonly trackClosed: "track-closed";
-    readonly trackReopened: "track-reopened";
+    trackProduced: string;
+    trackUnproduced: string;
+    trackPaused: string;
+    trackResumed: string;
+    trackClosed: string;
+    trackReopened: string;
 };
 export declare const PEER_EVENTS: {
-    readonly mediaPublished: "media-published";
-    readonly mediaUnPublished: "media-unpublished";
-    readonly publisherPaused: "publisher-paused";
-    readonly publisherResumed: "publisher-resumed";
-    readonly connectionQualityChanged: "connection-quality-changed";
-    readonly trackStart: "track-start";
-    readonly trackEnd: "track-end";
-    readonly trackPaused: "track-paused";
-    readonly trackResumed: "track-resumed";
-    readonly trackFailed: "track-failed";
-    readonly appDataUpdated: "app-data-updated";
+    mediaPublished: string;
+    mediaUnPublished: string;
+    publisherPaused: string;
+    publisherResumed: string;
+    connectionQualityChanged: string;
+    trackStart: string;
+    trackEnd: string;
+    trackPaused: string;
+    trackResumed: string;
+    trackFailed: string;
+    appDataUpdated: string;
 };
 export declare const MEDIASOUP_EVENTS: {
-    readonly newProducer: "peer.newProducer";
-    readonly producerClose: "producer.close";
-    readonly producerPause: "producer.pause";
-    readonly producerResume: "producer.resume";
-    readonly producerPaused: "producer.paused";
-    readonly producerResumed: "producer.resumed";
-    readonly producerForceClosed: "producer.forceClosed";
-    readonly producerScoreChanged: "producer.scoreChanged";
-    readonly producerSetMaxSpatialLayer: "producer.setMaxSpatialLayer";
-    readonly producerRequestMaxSpatialLayer: "producer.requestMaxSpatialLayer";
-    readonly createConsumer: "consumer.create";
-    readonly createDataConsumer: "dataConsumer.create";
-    readonly closeConsumer: "consumer.close";
-    readonly pauseConsumer: "consumer.pause";
-    readonly resumeConsumer: "consumer.resume";
-    readonly consumerScoreChanged: "consumer.scoreChanged";
-    readonly consumerChangePreferredLayers: "consumer.changeConsumerPreferredLayers";
-    readonly consumerRequestKeyFrame: "consumer.requestKeyFrame";
-    readonly setConsumerPriority: "consumer.setConsumerPriority";
-    readonly transportCreate: "transport.create";
-    readonly transportClose: "transport.close";
-    readonly transportConnect: "transport.connect";
-    readonly transportProduce: "transport.produce";
-    readonly transportConnectionTimeout: "transport.connectionTimeout";
-    readonly transportStateChange: "connectionstatechange";
-    readonly transportGetIceParameters: "transport.getIceParameters";
-};
-export declare const NETWORK_OBSERVER_EVENTS: {
-    readonly socketState: "socket-state";
-    readonly transportState: "transport-state";
+    newProducer: string;
+    producerClose: string;
+    producerPause: string;
+    producerResume: string;
+    producerPaused: string;
+    producerResumed: string;
+    producerForceClosed: string;
+    producerScoreChanged: string;
+    producerSetMaxSpatialLayer: string;
+    producerRequestMaxSpatialLayer: string;
+    createConsumer: string;
+    createDataConsumer: string;
+    closeConsumer: string;
+    pauseConsumer: string;
+    resumeConsumer: string;
+    consumerScoreChanged: string;
+    consumerChangePreferredLayers: string;
+    consumerRequestKeyFrame: string;
+    setConsumerPriority: string;
+    transportCreate: string;
+    transportClose: string;
+    transportConnect: string;
+    transportProduce: string;
+    transportConnectionTimeout: string;
+    transportStateChange: string;
+    transportGetIceParameters: string;
 };

package/dist/constants/events.ts

@@ -11,7 +11,7 @@ export const CHANNEL_EVENTS = {
   getAudioObserverProducer: 'channel.getAudioObserverProducer',
   getGeneralDataProducer: 'channel.getGeneralDataProducer',
   getChannelStateSyncDataProducer: 'channel.getChannelStateSyncDataProducer',
-} as const;
+};
 
 export const CLIENT_EVENTS = {
   channelEvent: 'channel-event',
@@ -23,17 +23,15 @@ export const CLIENT_EVENTS = {
   channelRejoinRequired: 'channel-rejoin-required',
   devicesListUpdated: 'devices-list-updated',
   transportConnectionTimeout: 'transport-connection-timeout',
+  trackPublishingFailed: 'track-publishing-failed',
   trackForceClosed: 'track-force-closed',
   activeSpeakerChanged: 'active-speaker-changed',
-  connectionLost: 'connection-lost',
-  connectionRestored: 'connection-restored',
-  forcedDisconnect: 'forced-disconnect',
-  rejectUnauthorized: 'reject-unauthorized',
-} as const;
+  channelStateInconsistent: 'channel-state-inconsistent',
+};
 
 export const TRACK_EVENTS = {
   volumeChanged: 'volume-changed',
-} as const;
+};
 
 export const INTERNAL_CLIENT_EVENTS = {
   trackProduced: 'track-produced',
@@ -42,7 +40,7 @@ export const INTERNAL_CLIENT_EVENTS = {
   trackResumed: 'track-resumed',
   trackClosed: 'track-closed',
   trackReopened: 'track-reopened',
-} as const;
+};
 
 export const PEER_EVENTS = {
   mediaPublished: 'media-published',
@@ -56,7 +54,7 @@ export const PEER_EVENTS = {
   trackResumed: 'track-resumed',
   trackFailed: 'track-failed',
   appDataUpdated: 'app-data-updated',
-} as const;
+};
 
 export const MEDIASOUP_EVENTS = {
   newProducer: 'peer.newProducer',
@@ -85,9 +83,4 @@ export const MEDIASOUP_EVENTS = {
   transportConnectionTimeout: 'transport.connectionTimeout',
   transportStateChange: 'connectionstatechange',
   transportGetIceParameters: 'transport.getIceParameters',
-} as const;
-
-export const NETWORK_OBSERVER_EVENTS = {
-  socketState: 'socket-state',
-  transportState: 'transport-state',
-} as const;
+};

package/dist/engine/DefaultEngineDependenciesFactory.d.ts

@@ -7,7 +7,6 @@ import MediaSoupEventHandler from './handlers/MediaSoupEventHandler';
 import { CreateIssueDetectorParams, CreateMediaParams, CreateMediaSoupEventHandlerParams, CreateNetworkParams, CreateSystemParams, ChannelStateSyncEventHandlerParams, EngineDependenciesFactory } from '../types/engine';
 import ChannelAudioObserverEventHandler from './handlers/ChannelAudioObserverEventHandler';
 import ChannelStateSyncEventHandler from './handlers/ChannelStateSyncEventHandler';
-import ChannelStateSynchronizer, { ChannelStateSynchronizerParams } from './ChannelStateSynchronizer';
 declare class DefaultEngineDependenciesFactory implements EngineDependenciesFactory {
     createSystem(params: CreateSystemParams): System;
     createMedia(params: CreateMediaParams): Media;
@@ -16,7 +15,6 @@ declare class DefaultEngineDependenciesFactory implements EngineDependenciesFact
     createMediaSoupEventHandler(params: CreateMediaSoupEventHandlerParams): MediaSoupEventHandler;
     createAudioObserverEventHandler(params: CreateMediaSoupEventHandlerParams): ChannelAudioObserverEventHandler;
     createChannelStateSyncEventHandler(params: ChannelStateSyncEventHandlerParams): ChannelStateSyncEventHandler;
-    createChannelStateSynchronizer(params: ChannelStateSynchronizerParams): ChannelStateSynchronizer;
     createIssueDetector(params: CreateIssueDetectorParams): WebRTCIssueDetector;
 }
 export default DefaultEngineDependenciesFactory;

package/dist/engine/Peer.d.ts

@@ -1,7 +1,6 @@
-import { ConsumerScoreChangedPayload, ProducerData, ProducerScoreChangedPayload, ConnectionQuality, PayloadOfPublishedMedia, PayloadOfUnpublishedMedia, ChangePreferredLayersPayload, Role, ProducerSetMaxSpatialLayer, PeerInfo, SubscribeOptions, PeerShortData } from '../types/common';
+import { ProducerData, ConnectionQuality, PayloadOfPublishedMedia, Role, PeerInfo, SubscribeOptions } from '../types/common';
 import EnhancedEventEmitter from '../EnhancedEventEmitter';
 import Engine from './index';
-import { CHANNEL_EVENTS, MEDIASOUP_EVENTS, PEER_EVENTS } from '../constants/events';
 import PeerProducer from './PeerProducer';
 import PeerConsumer from './PeerConsumer';
 import PeerTrack from './media/tracks/PeerTrack';
@@ -24,31 +23,6 @@ export declare enum ScoreThreshold {
     MEDIUM = 6,
     GOOD = 10
 }
-export declare type PeerObserverEvents = {
-    [PEER_EVENTS.mediaPublished]: [PayloadOfPublishedMedia];
-    [PEER_EVENTS.appDataUpdated]: [Record<string, unknown>];
-    [PEER_EVENTS.connectionQualityChanged]: [{
-        connectionQuality: number;
-    }];
-    [PEER_EVENTS.publisherPaused]: [PayloadOfPublishedMedia];
-    [PEER_EVENTS.publisherResumed]: [PayloadOfPublishedMedia];
-    [PEER_EVENTS.mediaUnPublished]: [PayloadOfUnpublishedMedia];
-    [PEER_EVENTS.trackStart]: [PeerTrack];
-    [PEER_EVENTS.trackEnd]: [PeerTrack];
-    [PEER_EVENTS.trackResumed]: [PeerTrack];
-    [PEER_EVENTS.trackPaused]: [PeerTrack];
-    [PEER_EVENTS.trackFailed]: [PeerTrack];
-    [MEDIASOUP_EVENTS.producerClose]: [ProducerData];
-    [MEDIASOUP_EVENTS.newProducer]: [ProducerData];
-    [MEDIASOUP_EVENTS.closeConsumer]: [consumerId: string];
-    [MEDIASOUP_EVENTS.pauseConsumer]: [consumerId: string];
-    [MEDIASOUP_EVENTS.resumeConsumer]: [consumerId: string];
-    [MEDIASOUP_EVENTS.consumerScoreChanged]: [ConsumerScoreChangedPayload];
-    [MEDIASOUP_EVENTS.producerScoreChanged]: [ProducerScoreChangedPayload];
-    [MEDIASOUP_EVENTS.consumerChangePreferredLayers]: [ChangePreferredLayersPayload];
-    [MEDIASOUP_EVENTS.producerSetMaxSpatialLayer]: [ProducerSetMaxSpatialLayer];
-    [CHANNEL_EVENTS.updatePeerAppData]: [Record<string, unknown>];
-};
 declare class Peer {
     id: string;
     channelIds: string[];
@@ -67,10 +41,9 @@ declare class Peer {
     private overallConnectionQuality;
     constructor({ id, channelIds, appId, loginDate, producers, engine, appData, uid, role, }: PeerConstructor);
     get appData(): Record<string, unknown>;
-    get observer(): EnhancedEventEmitter<PeerObserverEvents>;
+    get observer(): EnhancedEventEmitter;
     get isMe(): boolean;
     get publishedMedia(): PayloadOfPublishedMedia[];
-    get shortData(): PeerShortData;
     subscribe({ producerId, muted }: SubscribeOptions): Promise<void>;
     unsubscribe(producerId: string): Promise<void>;
     getInfo(): Promise<PeerInfo>;

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

@@ -2,13 +2,11 @@ interface ChannelStateConsistencyCheckResultsParams {
     missingPeers: string[];
     missingProducers: string[];
     producersWithInconsistentState: string[];
-    peersWithInconsistentAppData: string[];
 }
 declare class ChannelStateConsistencyCheckResult {
     readonly missingPeers: string[];
     readonly missingProducers: string[];
     readonly producersWithInconsistentState: string[];
-    readonly peersWithInconsistentAppData: string[];
     constructor(params: ChannelStateConsistencyCheckResultsParams);
     hasInconsistencyCases(): boolean;
 }

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

@@ -12,13 +12,11 @@ declare class ChannelStateConsistencyChecker {
     private missingPeers;
     private missingProducers;
     private producersWithInconsistentState;
-    private peersWithInconsistentAppData;
     constructor(params: ChannelStateConsistencyCheckerParams);
     check(): ChannelStateConsistencyCheckResult;
     getMissingPeers(): string[];
     getMissingProducers(): string[];
     getProducersWithInconsistentState(): string[];
-    getPeersWithInconsistentAppData(): string[];
     private findLocalPeerById;
     private findLocalProducerById;
     private resetPreviousCheckResults;

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

@@ -0,0 +1,4 @@
+export declare const MAX_CHECK_RETRIES_BEFORE_CONFIRM = 4;
+export declare const SIGNALING_PING_TIMEOUT = 1000;
+export declare const BAD_NETWORK_SCORE = 2.6;
+export declare const EXCELLENT_NETWORK_SCORE = 4.3;

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

@@ -1,14 +1,13 @@
 /// <reference types="node" />
-import { LogMessageHandler } from '../../../types/common';
-import Engine from '../../index';
+import { ChannelStateSyncEventHandlerParams } from '../../../types/engine';
 declare class ChannelStateSyncEventHandler {
     #private;
     private readonly engine;
     private readonly logger;
-    constructor(params: {
-        engine: Engine;
-        onLogMessage?: LogMessageHandler;
-    });
+    private clientEventEmitter;
+    private webRTCIssueEmitter?;
+    private networkScores;
+    constructor(params: ChannelStateSyncEventHandlerParams);
     handle(payload: Buffer): Promise<void>;
     private handleChannelStateEvent;
     private getLastInconsistencyCheckResult;
@@ -21,10 +20,11 @@ declare class ChannelStateSyncEventHandler {
     private getConfirmedMissingPeers;
     private getConfirmedMissingProducers;
     private getConfirmedProducersWithInconsistencState;
-    private getConfirmedPeersWithInconsistentAppData;
     private parseChannelStateSyncEventPayload;
     private getAllConfirmedInconsistentEntityIds;
     private getLocalState;
     private getIsConnectionActive;
+    private listenNetworkScoresUpdatedEvents;
+    private isBadNetworkScore;
 }
 export default ChannelStateSyncEventHandler;

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

@@ -0,0 +1,5 @@
+export declare enum InconsistenceType {
+    MissingPeer = "missing-peer",
+    MissingProducer = "missing-producer",
+    IncorrectProducerState = "incorrect-producer-state"
+}

package/dist/engine/index.d.ts

@@ -1,16 +1,15 @@
-import { CreateCameraVideoTrackOptions, CreateMicrophoneAudioTrackOptions, CreateScreenMediaOptions, JoinChannelParams, LogLevel, LogMessageHandler, PeerResponse, Role } from '../types/common';
+import { CreateCameraVideoTrackOptions, CreateMicrophoneAudioTrackOptions, CreateScreenMediaOptions, JoinChannelParams, PeerResponse, Role, LogMessageHandler, LogLevel } from '../types/common';
 import EnhancedEventEmitter from '../EnhancedEventEmitter';
 import System from './system';
 import Peer from './Peer';
 import Network from './network';
 import Media from './media';
 import VideoTrack from './media/tracks/DefaultVideoTrack';
-import { ClientObserverEvents, EngineDependenciesFactory, InternalObserverEvents, IssuesHandler, NetworkScoresUpdatedHandler, NodeActiveStreamsStat } from '../types/engine';
+import { EngineDependenciesFactory, IssuesHandler, NetworkScoresUpdatedHandler, NodeActiveStreamsStat } from '../types/engine';
 import { LoadBalancerApiClientParams } from './network/LoadBalancerClient';
 import { MediaTracksFactory, AudioTrack, Track, BaseTrack, InitEffectsSDKParams } from '../types/media';
 declare type EngineParams = {
     clientEventEmitter: EnhancedEventEmitter;
-    internalEventEmitter: EnhancedEventEmitter;
     network: {
         loadbalancer: LoadBalancerApiClientParams;
     };
@@ -26,20 +25,18 @@ declare type EngineParams = {
     effectsSDKParams?: InitEffectsSDKParams;
 };
 declare class Engine {
-    #private;
     system: System;
     network: Network;
     media: Media;
-    clientEventEmitter: EnhancedEventEmitter<ClientObserverEvents>;
-    internalEventEmitter: EnhancedEventEmitter<InternalObserverEvents>;
+    clientEventEmitter: EnhancedEventEmitter;
     logLevel: LogLevel;
-    readonly peersRepository: Map<string, Peer>;
+    private readonly peersRepository;
     private channelEventsHandler;
     private mediaSoupEventsHandler;
     private channelAudioObserverEventHandler;
     private channelStateSyncEventHandler;
-    private channelStateSynchronizer;
     private initialized;
+    private isJoined;
     private app?;
     private channel?;
     private isChannelJoining;
@@ -55,7 +52,6 @@ declare class Engine {
     private readonly handleDataChannelEvent;
     private readonly handleChannelStateSyncEvent;
     constructor(params: EngineParams);
-    get isChannelJoined(): boolean;
     private initialize;
     release(): Promise<void>;
     private removeClientEventEmitterListeners;
@@ -64,10 +60,9 @@ declare class Engine {
     get peers(): Peer[];
     get hostPeers(): Peer[];
     get audiencePeers(): Peer[];
-    get myPeerId(): string | undefined;
-    get isSocketConnectionActive(): boolean;
+    get mySocketId(): string | undefined;
     getPeerById(id: string): Peer | undefined;
-    checkSocketConnectionActivity(): void;
+    checkConnectionActivity(): Promise<void>;
     confirmActivity(): Promise<void>;
     join(params: JoinChannelParams): Promise<void>;
     loadPeers(role?: Role): Promise<void>;
@@ -98,6 +93,5 @@ declare class Engine {
     private createGeneralDataConsumer;
     private createChannelStateSyncDataConsumer;
     private triggerRejoinEventIfAppropriate;
-    private watchNetworkState;
 }
 export default Engine;

package/dist/engine/media/tracks/DefaultBaseTrack.d.ts

@@ -4,7 +4,6 @@ import { BaseTrackInfo, EncoderConfig, TrackLabel, TrackOutboundStats, TrackProd
 import Logger from '../../Logger';
 import EnhancedEventEmitter from '../../../EnhancedEventEmitter';
 import { BaseTrack, BaseTrackParams, ProducerAppData } from '../../../types/media';
-import { InternalObserverEvents } from '../../../types/engine';
 declare class DefaultBaseTrack implements BaseTrack {
     #private;
     protected encoderConfig: EncoderConfig;
@@ -20,7 +19,7 @@ declare class DefaultBaseTrack implements BaseTrack {
     get producerId(): string | undefined;
     get isPublished(): boolean;
     get isPaused(): boolean;
-    get internalEventEmitter(): EnhancedEventEmitter<InternalObserverEvents>;
+    get clientEventEmitter(): EnhancedEventEmitter;
     getLabel(): TrackLabel;
     setLabel(label: TrackLabel): void;
     setEncoderConfig(encoderConfig: EncoderConfig): void;

package/dist/engine/media/tracks/PeerTrack.d.ts

@@ -1,6 +1,5 @@
 import { MediaKind } from 'mediasoup-client/lib/types';
 import { PreferredLayersParams, SpatialLayerParams, PeerTrackInfo, TrackLabel, LogMessageHandler } from '../../../types/common';
-import { PEER_EVENTS, TRACK_EVENTS } from '../../../constants/events';
 import PeerConsumer from '../../PeerConsumer';
 import Engine from '../../index';
 import EnhancedEventEmitter from '../../../EnhancedEventEmitter';
@@ -14,21 +13,11 @@ interface PeerTrackConstructor {
     peerEventEmitter: EnhancedEventEmitter;
     onLogMessage?: LogMessageHandler;
 }
-declare type PeerTrackObserverEvents = {
-    [PEER_EVENTS.trackStart]: [PeerTrack];
-    [PEER_EVENTS.trackEnd]: [PeerTrack];
-    [TRACK_EVENTS.volumeChanged]: [{
-        value: number;
-    }];
-    [PEER_EVENTS.trackFailed]: [PeerTrack];
-    [PEER_EVENTS.trackPaused]: [PeerTrack];
-    [PEER_EVENTS.trackResumed]: [PeerTrack];
-};
 declare class PeerTrack {
     #private;
     readonly label: TrackLabel;
     consumer?: PeerConsumer;
-    readonly observer: EnhancedEventEmitter<PeerTrackObserverEvents>;
+    readonly observer: EnhancedEventEmitter;
     constructor(payload: PeerTrackConstructor);
     get volume(): number;
     get isRemote(): boolean;

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

@@ -6,7 +6,6 @@ export declare type SocketIOConstructorParams = {
     onLogMessage?: LogMessageHandler;
 };
 declare class SocketIO {
-    #private;
     connection?: Socket;
     connectionError?: string;
     disconnectReason?: string;

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

@@ -2,10 +2,9 @@ import { IceParameters, Transport } from 'mediasoup-client/lib/Transport';
 import { Device } from 'mediasoup-client';
 import { DataConsumer } from 'mediasoup-client/lib/DataConsumer';
 import SocketIO from './Socket';
-import { CreateConsumerPayload, CreateConsumerResponse, LogLevel, LogMessageHandler, SocketResponse, TransportsStateInfo, UpdatePeerAppDataPayload, CreateDataConsumerPayload, TransportAppData, PeerResponse, Role } from '../../types/common';
+import { CreateConsumerPayload, CreateConsumerResponse, LogLevel, LogMessageHandler, SocketResponse, TransportsStateInfo, UpdatePeerAppDataPayload, CreateDataConsumerPayload, TransportAppData } from '../../types/common';
 import LoadBalancerApiClient from './LoadBalancerClient';
 import EnhancedEventEmitter from '../../EnhancedEventEmitter';
-import { NetworkObserverEvents } from '../../types/network';
 export declare type NetworkParams = {
     socketClient: SocketIO;
     logLevel: LogLevel;
@@ -14,17 +13,16 @@ export declare type NetworkParams = {
     onLogMessage?: LogMessageHandler;
 };
 declare class Network {
-    #private;
     readonly socket: SocketIO;
     readonly loadBalancerClient: LoadBalancerApiClient;
-    peerId?: string;
+    readonly eventEmitter: EnhancedEventEmitter;
     sendTransport?: Transport<TransportAppData>;
     receiveTransport?: Transport<TransportAppData>;
     private preferRelay;
+    private sendTransportRestartIceInterval?;
+    private recvTransportRestartIceInterval?;
     private readonly logger;
     constructor(params: NetworkParams);
-    get isNetworkActive(): boolean;
-    get observer(): EnhancedEventEmitter<NetworkObserverEvents>;
     private removeEventListeners;
     reset(): Promise<void>;
     closeRemoteProducer(producerId: string): Promise<void>;
@@ -47,12 +45,8 @@ declare class Network {
     getTransportsStateInfo(): Promise<TransportsStateInfo>;
     setPreferRelay(value: boolean): void;
     getPreferRelay(): boolean;
-    getChannelPeers(role?: Role): Promise<{
-        peers: PeerResponse[];
-    }>;
     private getParsedTransportStats;
     private logTransportDetails;
     private stopRestartIceAtempts;
-    private subscribeCommonTransportEvents;
 }
 export default Network;

package/dist/index.d.ts

@@ -2,11 +2,10 @@ import { AvailableMediaDevices, CreateCameraVideoTrackOptions, CreateMicrophoneA
 import EnhancedEventEmitter from './EnhancedEventEmitter';
 import Peer from './engine/Peer';
 import { LoadBalancerApiClientParams } from './engine/network/LoadBalancerClient';
-import { ClientObserverEvents, IssuesHandler, NetworkScoresUpdatedHandler, NodeActiveStreamsStat } from './types/engine';
+import { IssuesHandler, NetworkScoresUpdatedHandler, NodeActiveStreamsStat } from './types/engine';
 import { AudioTrack, InitEffectsSDKParams, Track, VideoTrack } from './types/media';
 declare type ClientParams = {
-    clientEventEmitter?: EnhancedEventEmitter;
-    internalEventEmitter?: EnhancedEventEmitter;
+    observer?: EnhancedEventEmitter;
     network?: {
         loadbalancer?: LoadBalancerApiClientParams;
     };
@@ -19,10 +18,9 @@ declare type ClientParams = {
 };
 declare class Client {
     private readonly engine;
-    private readonly _clientEventEmitter;
-    private readonly _internalEventEmitter;
+    private readonly _observer;
     constructor(params: ClientParams);
-    get observer(): EnhancedEventEmitter<ClientObserverEvents>;
+    get observer(): EnhancedEventEmitter;
     get id(): string | undefined;
     get peers(): Peer[];
     get availableVideoDevices(): MediaDeviceInfo[];