sip-connector 20.2.0 → 20.3.0

package/dist/ApiManager/@ApiManager.d.ts

@@ -1,6 +1,6 @@
 import { CallManager } from '../CallManager';
 import { ConnectionManager } from '../ConnectionManager';
-import { TEventMap, TEvents } from './eventNames';
+import { TEventMap, TEvents } from './events';
 import { TChannels, TMediaState, TOptionsInfoMediaState } from './types';
 declare class ApiManager {
     readonly events: TEvents;

package/dist/ApiManager/{eventNames.d.ts → events.d.ts}

@@ -91,3 +91,4 @@ export type TEventMap = {
     };
 };
 export type TEvents = TypedEvents<TEventMap>;
+export declare const createEvents: () => TypedEvents<TEventMap, readonly (keyof TEventMap)[]>;

package/dist/ApiManager/index.d.ts

@@ -1,3 +1,4 @@
 export { default as ApiManager } from './@ApiManager';
 export { EContentTypeReceived, EContentTypeSent, EEventsMainCAM, EEventsMic, EEventsSyncMediaState, EHeader, EShareState, EUseLicense, } from './constants';
-export type { TEvent as TApiEvent } from './eventNames';
+export { createEvents } from './events';
+export type { TEventMap, TEvent as TApiEvent, TEvents as TApiEvents } from './events';

package/dist/AutoConnectorManager/@AutoConnectorManager.d.ts

@@ -1,7 +1,7 @@
 import { CallManager } from '../CallManager';
 import { ConnectionManager } from '../ConnectionManager';
 import { ConnectionQueueManager } from '../ConnectionQueueManager';
-import { TEventMap, TEvents } from './eventNames';
+import { TEventMap, TEvents } from './events';
 import { IAutoConnectorOptions, TParametersAutoConnect } from './types';
 declare class AutoConnectorManager {
     readonly events: TEvents;

package/dist/AutoConnectorManager/{eventNames.d.ts → events.d.ts}

@@ -20,3 +20,4 @@ export type TEventMap = {
     'limit-reached-attempts': Error;
 };
 export type TEvents = TypedEvents<TEventMap>;
+export declare const createEvents: () => TypedEvents<TEventMap, readonly (keyof TEventMap)[]>;

package/dist/AutoConnectorManager/index.d.ts

@@ -1,2 +1,3 @@
 export { default as AutoConnectorManager } from './@AutoConnectorManager';
+export { createEvents } from './events';
 export type { IAutoConnectorOptions } from './types';

package/dist/CallManager/CallStateMachine.d.ts

@@ -0,0 +1,83 @@
+import { BaseStateMachine } from '../tools/BaseStateMachine';
+import { ActorRefFrom, SnapshotFrom } from 'xstate';
+import { TEvents } from './events';
+export declare enum EState {
+    IDLE = "call:idle",
+    CONNECTING = "call:connecting",
+    RINGING = "call:ringing",
+    ACCEPTED = "call:accepted",
+    IN_CALL = "call:inCall",
+    ENDED = "call:ended",
+    FAILED = "call:failed"
+}
+type TCallEvent = {
+    type: 'CALL.CONNECTING';
+} | {
+    type: 'CALL.RINGING';
+} | {
+    type: 'CALL.ACCEPTED';
+} | {
+    type: 'CALL.CONFIRMED';
+} | {
+    type: 'CALL.ENDED';
+} | {
+    type: 'CALL.FAILED';
+    error?: unknown;
+} | {
+    type: 'CALL.RESET';
+};
+interface ICallContext {
+    lastError?: Error;
+}
+declare const callMachine: import('xstate').StateMachine<ICallContext, {
+    type: "CALL.CONNECTING";
+} | {
+    type: "CALL.RINGING";
+} | {
+    type: "CALL.ACCEPTED";
+} | {
+    type: "CALL.CONFIRMED";
+} | {
+    type: "CALL.ENDED";
+} | {
+    type: "CALL.FAILED";
+    error?: unknown;
+} | {
+    type: "CALL.RESET";
+}, {}, never, {
+    type: "rememberError";
+    params: import('xstate').NonReducibleUnknown;
+} | {
+    type: "resetError";
+    params: import('xstate').NonReducibleUnknown;
+}, never, never, EState, string, import('xstate').NonReducibleUnknown, import('xstate').NonReducibleUnknown, import('xstate').EventObject, import('xstate').MetaObject, {
+    id: "call";
+    states: {
+        readonly "call:idle": {};
+        readonly "call:connecting": {};
+        readonly "call:ringing": {};
+        readonly "call:accepted": {};
+        readonly "call:inCall": {};
+        readonly "call:ended": {};
+        readonly "call:failed": {};
+    };
+}>;
+export type TCallSnapshot = SnapshotFrom<typeof callMachine>;
+export type TCallActor = ActorRefFrom<typeof callMachine>;
+export declare class CallStateMachine extends BaseStateMachine<typeof callMachine, EState> {
+    constructor(events: TEvents);
+    get isIdle(): boolean;
+    get isConnecting(): boolean;
+    get isRinging(): boolean;
+    get isAccepted(): boolean;
+    get isInCall(): boolean;
+    get isEnded(): boolean;
+    get isFailed(): boolean;
+    get isActive(): boolean;
+    get isPending(): boolean;
+    get lastError(): Error | undefined;
+    reset(): void;
+    send(event: TCallEvent): void;
+    private subscribeToEvents;
+}
+export {};

package/dist/CallManager/MCUSession.d.ts

@@ -1,5 +1,5 @@
 import { RTCSession } from '@krivega/jssip';
-import { TEvents } from './eventNames';
+import { TEvents } from './events';
 import { IMCUSession } from './types';
 export declare class MCUSession implements IMCUSession {
     protected readonly events: TEvents;
@@ -12,6 +12,7 @@ export declare class MCUSession implements IMCUSession {
     get connection(): RTCPeerConnection | undefined;
     get isCallActive(): boolean;
     getEstablishedRTCSession: () => RTCSession | undefined;
+    renegotiate(): Promise<boolean>;
     startCall: IMCUSession['startCall'];
     endCall(): Promise<void>;
     answerToIncomingCall: IMCUSession['answerToIncomingCall'];

package/dist/CallManager/RemoteStreamsManager.d.ts

@@ -2,6 +2,7 @@ export declare class RemoteStreamsManager {
     private readonly participantGroups;
     private readonly trackToGroup;
     private readonly trackDisposers;
+    get mainStream(): MediaStream | undefined;
     reset(): void;
     addTrack(track: MediaStreamTrack, { onRemoved, streamHint, }?: {
         streamHint?: string;

package/dist/CallManager/{eventNames.d.ts → events.d.ts}

@@ -1,5 +1,5 @@
-import { IncomingInfoEvent, OutgoingInfoEvent, EndEvent } from '@krivega/jssip';
 import { TypedEvents } from 'events-constructor';
+import { IncomingInfoEvent, OutgoingInfoEvent, EndEvent } from '@krivega/jssip';
 export declare enum EEvent {
     PEER_CONNECTION = "peerconnection",
     CONNECTING = "connecting",
@@ -94,3 +94,4 @@ export type TEventMap = {
     };
 };
 export type TEvents = TypedEvents<TEventMap>;
+export declare const createEvents: () => TypedEvents<TEventMap, readonly (keyof TEventMap)[]>;

package/dist/CallManager/index.d.ts

@@ -1,7 +1,6 @@
 export { default as CallManager } from './@CallManager';
 export { ECallCause } from './causes';
-export type { TEventMap } from './eventNames';
-export { EEvent as ECallEvent } from './eventNames';
-export type { TEvent as TCallEvent, TEvents as TCallEvents } from './eventNames';
+export { EEvent as ECallEvent, createEvents } from './events';
 export { default as hasCanceledCallError } from './hasCanceledCallError';
 export type { TCustomError, TGetUri } from './types';
+export type { TEventMap, TEvent as TCallEvent, TEvents as TCallEvents } from './events';

package/dist/CallManager/types.d.ts

@@ -1,6 +1,6 @@
 import { RTCSession, UA } from '@krivega/jssip';
 import { TContentHint } from '../PresentationManager';
-import { Originator } from './eventNames';
+import { Originator } from './events';
 import { TTools } from './RecvSession';
 export type TOnAddedTransceiver = (transceiver: RTCRtpTransceiver, track: MediaStreamTrack, streams: MediaStream[]) => Promise<void>;
 export type TGetUri = (id: string) => string;
@@ -67,6 +67,7 @@ export interface IMCUSession {
     getEstablishedRTCSession: () => RTCSession | undefined;
     startCall: TStartCall;
     endCall: () => Promise<void>;
+    renegotiate: () => Promise<boolean>;
     answerToIncomingCall: (incomingRTCSession: RTCSession, params: TParamsAnswerToIncomingCall) => Promise<RTCPeerConnection>;
     replaceMediaStream: TReplaceMediaStream;
     restartIce: (options?: {

package/dist/ConnectionManager/ConnectionFlow.d.ts

@@ -2,7 +2,7 @@ import { UA, WebSocketInterface } from '@krivega/jssip';
 import { TGetUri } from '../CallManager';
 import { TJsSIP } from '../types';
 import { default as ConnectionStateMachine } from './ConnectionStateMachine';
-import { TEvents } from './eventNames';
+import { TEvents } from './events';
 import { default as RegistrationManager } from './RegistrationManager';
 import { default as UAFactory } from './UAFactory';
 export type TOptionsExtraHeaders = {

package/dist/ConnectionManager/ConnectionStateMachine.d.ts

@@ -1,4 +1,6 @@
-import { TEvents } from './eventNames';
+import { BaseStateMachine } from '../tools/BaseStateMachine';
+import { ActorRefFrom, SnapshotFrom } from 'xstate';
+import { TEvents } from './events';
 export declare enum EEvents {
     START_CONNECT = "START_CONNECT",
     START_INIT_UA = "START_INIT_UA",
@@ -10,23 +12,67 @@ export declare enum EEvents {
     RESET = "RESET"
 }
 type TConnectionMachineEvent = `${EEvents}`;
+type TConnectionFailedEvent = {
+    type: typeof EEvents.CONNECTION_FAILED;
+    error?: Error;
+};
+interface IConnectionMachineContext {
+    error?: Error;
+}
 export declare enum EState {
-    IDLE = "idle",
-    CONNECTING = "connecting",
-    INITIALIZING = "initializing",
-    CONNECTED = "connected",
-    REGISTERED = "registered",
-    DISCONNECTED = "disconnected",
-    FAILED = "failed"
+    IDLE = "connection:idle",
+    CONNECTING = "connection:connecting",
+    INITIALIZING = "connection:initializing",
+    CONNECTED = "connection:connected",
+    REGISTERED = "connection:registered",
+    DISCONNECTED = "connection:disconnected",
+    FAILED = "connection:failed"
+}
+declare enum EAction {
+    LOG_TRANSITION = "logTransition",
+    LOG_STATE_CHANGE = "logStateChange",
+    SET_ERROR = "setError",
+    CLEAR_ERROR = "clearError"
 }
-export default class ConnectionStateMachine {
-    private readonly actor;
+declare const connectionMachine: import('xstate').StateMachine<IConnectionMachineContext, TConnectionFailedEvent | {
+    type: TConnectionMachineEvent;
+}, {}, never, {
+    type: EAction.LOG_TRANSITION;
+    params: {
+        from: string;
+        to: string;
+        event: string;
+    };
+} | {
+    type: EAction.LOG_STATE_CHANGE;
+    params: {
+        state: string;
+    };
+} | {
+    type: EAction.SET_ERROR;
+    params: import('xstate').NonReducibleUnknown;
+} | {
+    type: EAction.CLEAR_ERROR;
+    params: import('xstate').NonReducibleUnknown;
+}, never, never, EState, string, import('xstate').NonReducibleUnknown, import('xstate').NonReducibleUnknown, import('xstate').EventObject, import('xstate').MetaObject, {
+    id: "connection";
+    states: {
+        readonly "connection:idle": {};
+        readonly "connection:connecting": {};
+        readonly "connection:initializing": {};
+        readonly "connection:connected": {};
+        readonly "connection:registered": {};
+        readonly "connection:disconnected": {};
+        readonly "connection:failed": {};
+    };
+}>;
+export type TConnectionSnapshot = SnapshotFrom<typeof connectionMachine>;
+export type TConnectionActor = ActorRefFrom<typeof connectionMachine>;
+export default class ConnectionStateMachine extends BaseStateMachine<typeof connectionMachine, EState> {
     private readonly stateChangeListeners;
     private readonly events;
     private unsubscribeFromEvents?;
-    private readonly actorSubscription?;
     constructor(events: TEvents);
-    get state(): EState;
     get isIdle(): boolean;
     get isConnecting(): boolean;
     get isInitializing(): boolean;
@@ -34,6 +80,7 @@ export default class ConnectionStateMachine {
     get isRegistered(): boolean;
     get isDisconnected(): boolean;
     get isFailed(): boolean;
+    get error(): Error | undefined;
     get isPending(): boolean;
     get isPendingConnect(): boolean;
     get isPendingInitUa(): boolean;
@@ -56,5 +103,7 @@ export default class ConnectionStateMachine {
     private readonly toFailed;
     private readonly toIdle;
     private subscribeToEvents;
+    private readonly handleRegistrationFailed;
+    private readonly handleConnectFailed;
 }
 export {};

package/dist/ConnectionManager/RegistrationManager.d.ts

@@ -1,5 +1,5 @@
 import { RegisteredEvent, UA, UnRegisteredEvent, DisconnectEvent } from '@krivega/jssip';
-import { TEvents } from './eventNames';
+import { TEvents } from './events';
 interface IDependencies {
     events: TEvents;
     getUaProtected: () => UA;

package/dist/ConnectionManager/{eventNames.d.ts → events.d.ts}

@@ -1,5 +1,5 @@
-import { ConnectedEvent, ConnectingEventUA, DisconnectEvent, IncomingMessageEvent, IncomingRequest, OutgoingMessageEvent, RegisteredEvent, RTCSessionEvent, UnRegisteredEvent } from '@krivega/jssip';
 import { TypedEvents } from 'events-constructor';
+import { ConnectedEvent, ConnectingEventUA, DisconnectEvent, IncomingMessageEvent, IncomingRequest, OutgoingMessageEvent, RegisteredEvent, RTCSessionEvent, UnRegisteredEvent } from '@krivega/jssip';
 import { TConnectionConfigurationWithUa, TParametersConnection } from './ConnectionFlow';
 export declare enum EEvent {
     CONNECTING = "connecting",
@@ -44,3 +44,4 @@ export type TEventMap = {
     'connect-parameters-resolve-failed': unknown;
 };
 export type TEvents = TypedEvents<TEventMap>;
+export declare const createEvents: () => TypedEvents<TEventMap, readonly (keyof TEventMap)[]>;

package/dist/ConnectionManager/index.d.ts

@@ -1,5 +1,5 @@
 export { default as ConnectionManager } from './@ConnectionManager';
-export type { TParametersConnection, TConnectionConfigurationWithUa } from './ConnectionFlow';
-export { EVENT_NAMES as CONNECTION_MANAGER_EVENT_NAMES, EEvent as EConnectionManagerEvent, } from './eventNames';
-export type { TEvent as TConnectionManagerEvent, TEvents as TConnectionManagerEvents, } from './eventNames';
 export { hasNotReadyForConnectionError, createNotReadyForConnectionError } from './utils';
+export { EVENT_NAMES as CONNECTION_MANAGER_EVENT_NAMES, EEvent as EConnectionManagerEvent, createEvents, } from './events';
+export type { TParametersConnection, TConnectionConfigurationWithUa } from './ConnectionFlow';
+export type { TEvent as TConnectionManagerEvent, TEvents as TConnectionManagerEvents, } from './events';

package/dist/IncomingCallManager/IncomingCallStateMachine.d.ts

@@ -0,0 +1,114 @@
+import { BaseStateMachine } from '../tools/BaseStateMachine';
+import { ActorRefFrom, SnapshotFrom } from 'xstate';
+import { TEvents as TConnectionEvents } from '../ConnectionManager/events';
+import { TEvents as TIncomingEvents, TRemoteCallerData } from './events';
+export declare enum EState {
+    IDLE = "incoming:idle",
+    RINGING = "incoming:ringing",
+    CONSUMED = "incoming:consumed",
+    DECLINED = "incoming:declined",
+    TERMINATED = "incoming:terminated",
+    FAILED = "incoming:failed"
+}
+declare enum EAction {
+    LOG_TRANSITION = "logTransition",
+    LOG_STATE_CHANGE = "logStateChange",
+    REMEMBER_INCOMING = "rememberIncoming",
+    REMEMBER_REASON = "rememberReason",
+    CLEAR_INCOMING = "clearIncoming"
+}
+type TIncomingEvent = {
+    type: 'INCOMING.RINGING';
+    data: TRemoteCallerData;
+} | {
+    type: 'INCOMING.CONSUMED';
+} | {
+    type: 'INCOMING.DECLINED';
+    data: TRemoteCallerData;
+} | {
+    type: 'INCOMING.TERMINATED';
+    data: TRemoteCallerData;
+} | {
+    type: 'INCOMING.FAILED';
+    data: TRemoteCallerData;
+} | {
+    type: 'INCOMING.CLEAR';
+};
+interface IIncomingContext {
+    remoteCallerData?: TRemoteCallerData;
+    lastReason?: EState.CONSUMED | EState.DECLINED | EState.TERMINATED | EState.FAILED;
+}
+declare const incomingMachine: import('xstate').StateMachine<IIncomingContext, {
+    type: "INCOMING.RINGING";
+    data: TRemoteCallerData;
+} | {
+    type: "INCOMING.CONSUMED";
+} | {
+    type: "INCOMING.DECLINED";
+    data: TRemoteCallerData;
+} | {
+    type: "INCOMING.TERMINATED";
+    data: TRemoteCallerData;
+} | {
+    type: "INCOMING.FAILED";
+    data: TRemoteCallerData;
+} | {
+    type: "INCOMING.CLEAR";
+}, {}, never, {
+    type: EAction.LOG_TRANSITION;
+    params: {
+        from: string;
+        to: string;
+        event: string;
+    };
+} | {
+    type: EAction.LOG_STATE_CHANGE;
+    params: {
+        state: string;
+    };
+} | {
+    type: EAction.REMEMBER_INCOMING;
+    params: import('xstate').NonReducibleUnknown;
+} | {
+    type: EAction.REMEMBER_REASON;
+    params: import('xstate').NonReducibleUnknown;
+} | {
+    type: EAction.CLEAR_INCOMING;
+    params: import('xstate').NonReducibleUnknown;
+}, never, never, EState, string, import('xstate').NonReducibleUnknown, import('xstate').NonReducibleUnknown, import('xstate').EventObject, import('xstate').MetaObject, {
+    id: "incoming";
+    states: {
+        readonly "incoming:idle": {};
+        readonly "incoming:ringing": {};
+        readonly "incoming:consumed": {};
+        readonly "incoming:declined": {};
+        readonly "incoming:terminated": {};
+        readonly "incoming:failed": {};
+    };
+}>;
+export type TIncomingSnapshot = SnapshotFrom<typeof incomingMachine>;
+export type TIncomingActor = ActorRefFrom<typeof incomingMachine>;
+type TDeps = {
+    incomingEvents: TIncomingEvents;
+    connectionEvents: TConnectionEvents;
+};
+export declare class IncomingCallStateMachine extends BaseStateMachine<typeof incomingMachine, EState> {
+    constructor({ incomingEvents, connectionEvents }: TDeps);
+    get isIdle(): boolean;
+    get isRinging(): boolean;
+    get isConsumed(): boolean;
+    get isDeclined(): boolean;
+    get isTerminated(): boolean;
+    get isFailed(): boolean;
+    get isActive(): boolean;
+    get isFinished(): boolean;
+    get remoteCallerData(): TRemoteCallerData | undefined;
+    get lastReason(): EState.CONSUMED | EState.DECLINED | EState.TERMINATED | EState.FAILED | undefined;
+    reset(): void;
+    send(event: TIncomingEvent): void;
+    toConsumed(): void;
+    private subscribeIncomingEvents;
+    private subscribeConnectionEvents;
+    private toClearIncoming;
+}
+export {};

package/dist/IncomingCallManager/{eventNames.d.ts → events.d.ts}

@@ -1,5 +1,5 @@
-import { RTCSession } from '@krivega/jssip';
 import { TypedEvents } from 'events-constructor';
+import { RTCSession } from '@krivega/jssip';
 export declare enum EEvent {
     INCOMING_CALL = "incomingCall",
     DECLINED_INCOMING_CALL = "declinedIncomingCall",
@@ -26,3 +26,4 @@ export type TEventMap = {
     failedIncomingCall: TRemoteCallerData;
 };
 export type TEvents = TypedEvents<TEventMap>;
+export declare const createEvents: () => TypedEvents<TEventMap, readonly (keyof TEventMap)[]>;

package/dist/IncomingCallManager/index.d.ts

@@ -1,2 +1,3 @@
 export { default as IncomingCallManager } from './@IncomingCallManager';
-export type { TEvent as TIncomingCallEvent } from './eventNames';
+export { createEvents } from './events';
+export type { TEvent as TIncomingCallEvent, TRemoteCallerData } from './events';

package/dist/MainStreamHealthMonitor/@MainStreamHealthMonitor.d.ts

@@ -0,0 +1,16 @@
+import { CallManager } from '../CallManager';
+import { StatsManager } from '../StatsManager';
+import { TEventMap, TEvents } from './events';
+declare class MainStreamHealthMonitor {
+    readonly events: TEvents;
+    private readonly statsManager;
+    private readonly callManager;
+    constructor(statsManager: StatsManager, callManager: CallManager);
+    private get mainVideoTrack();
+    private get isMutedMainVideoTrack();
+    on<T extends keyof TEventMap>(eventName: T, handler: (data: TEventMap[T]) => void): () => void;
+    private readonly handleStatsCollected;
+    private readonly hasNoIncomingFrames;
+    private subscribe;
+}
+export default MainStreamHealthMonitor;

package/dist/MainStreamHealthMonitor/events.d.ts

@@ -0,0 +1,8 @@
+import { TypedEvents } from 'events-constructor';
+export declare const NO_INBOUND_FRAMES_EVENT_NAME: "no-inbound-frames";
+export declare const EVENT_NAMES: readonly ["no-inbound-frames"];
+export type TEventMap = {
+    [NO_INBOUND_FRAMES_EVENT_NAME]: Record<string, never>;
+};
+export type TEvents = TypedEvents<TEventMap>;
+export declare const createEvents: () => TypedEvents<TEventMap, readonly "no-inbound-frames"[]>;

package/dist/MainStreamHealthMonitor/index.d.ts

@@ -0,0 +1 @@
+export { default as MainStreamHealthMonitor } from './@MainStreamHealthMonitor';

package/dist/MainStreamRecovery/@MainStreamRecovery.d.ts

@@ -0,0 +1,12 @@
+import { CallManager } from '../CallManager';
+declare class MainStreamRecovery {
+    private readonly renegotiateRequester;
+    private readonly renegotiateThrottled;
+    private readonly callManager;
+    constructor(callManager: CallManager, throttleRecoveryTimeout?: number);
+    recover(): void;
+    private readonly requestRenegotiate;
+    private subscribe;
+    private cancel;
+}
+export default MainStreamRecovery;

package/dist/MainStreamRecovery/index.d.ts

@@ -0,0 +1 @@
+export { default as MainStreamRecovery } from './@MainStreamRecovery';

package/dist/PresentationManager/PresentationStateMachine.d.ts

@@ -0,0 +1,101 @@
+import { BaseStateMachine } from '../tools/BaseStateMachine';
+import { ActorRefFrom, SnapshotFrom } from 'xstate';
+import { TCallEvents } from '../CallManager';
+export declare enum EState {
+    IDLE = "presentation:idle",
+    STARTING = "presentation:starting",
+    ACTIVE = "presentation:active",
+    STOPPING = "presentation:stopping",
+    FAILED = "presentation:failed"
+}
+declare enum EAction {
+    LOG_TRANSITION = "logTransition",
+    LOG_STATE_CHANGE = "logStateChange",
+    SET_ERROR = "setError",
+    CLEAR_ERROR = "clearError"
+}
+type TPresentationEvent = {
+    type: 'SCREEN.STARTING';
+} | {
+    type: 'SCREEN.STARTED';
+} | {
+    type: 'SCREEN.ENDING';
+} | {
+    type: 'SCREEN.ENDED';
+} | {
+    type: 'SCREEN.FAILED';
+    error?: unknown;
+} | {
+    type: 'CALL.ENDED';
+} | {
+    type: 'CALL.FAILED';
+    error?: unknown;
+} | {
+    type: 'PRESENTATION.RESET';
+};
+interface IPresentationContext {
+    lastError?: Error;
+}
+declare const presentationMachine: import('xstate').StateMachine<IPresentationContext, {
+    type: "SCREEN.STARTING";
+} | {
+    type: "SCREEN.STARTED";
+} | {
+    type: "SCREEN.ENDING";
+} | {
+    type: "SCREEN.ENDED";
+} | {
+    type: "SCREEN.FAILED";
+    error?: unknown;
+} | {
+    type: "CALL.ENDED";
+} | {
+    type: "CALL.FAILED";
+    error?: unknown;
+} | {
+    type: "PRESENTATION.RESET";
+}, {}, never, {
+    type: EAction.LOG_TRANSITION;
+    params: {
+        from: string;
+        to: string;
+        event: string;
+    };
+} | {
+    type: EAction.LOG_STATE_CHANGE;
+    params: {
+        state: string;
+    };
+} | {
+    type: EAction.SET_ERROR;
+    params: import('xstate').NonReducibleUnknown;
+} | {
+    type: EAction.CLEAR_ERROR;
+    params: import('xstate').NonReducibleUnknown;
+}, never, never, EState, string, import('xstate').NonReducibleUnknown, import('xstate').NonReducibleUnknown, import('xstate').EventObject, import('xstate').MetaObject, {
+    id: "presentation";
+    states: {
+        readonly "presentation:idle": {};
+        readonly "presentation:starting": {};
+        readonly "presentation:active": {};
+        readonly "presentation:stopping": {};
+        readonly "presentation:failed": {};
+    };
+}>;
+export type TPresentationSnapshot = SnapshotFrom<typeof presentationMachine>;
+export type TPresentationActor = ActorRefFrom<typeof presentationMachine>;
+export declare class PresentationStateMachine extends BaseStateMachine<typeof presentationMachine, EState> {
+    constructor(callEvents: TCallEvents);
+    get isIdle(): boolean;
+    get isStarting(): boolean;
+    get isActive(): boolean;
+    get isStopping(): boolean;
+    get isFailed(): boolean;
+    get isPending(): boolean;
+    get isActiveOrPending(): boolean;
+    get lastError(): Error | undefined;
+    reset(): void;
+    send(event: TPresentationEvent): void;
+    private subscribeCallEvents;
+}
+export {};

package/dist/PresentationManager/{eventNames.d.ts → events.d.ts}

@@ -16,3 +16,4 @@ export type TEventMap = {
     'presentation:failed': Error;
 };
 export type TEvents = TypedEvents<TEventMap>;
+export declare const createEvents: () => TypedEvents<TEventMap, readonly (keyof TEventMap)[]>;

package/dist/PresentationManager/index.d.ts

@@ -1,2 +1,3 @@
 export { hasCanceledStartPresentationError, default as PresentationManager, } from './@PresentationManager';
+export { createEvents } from './events';
 export type { TContentHint, TOnAddedTransceiver } from './types';