sip-connector 20.4.0 → 20.4.1

package/dist/CallManager/@CallManager.d.ts

@@ -0,0 +1,60 @@
+import { CallStateMachine, TCallActor } from './CallStateMachine';
+import { RTCSession } from '@krivega/jssip';
+import { ConferenceStateManager } from '../ConferenceStateManager';
+import { TEventMap, TEvents } from './events';
+import { TAnswerToIncomingCall, TCallRoleSpectator, TReplaceMediaStream, TStartCall } from './types';
+declare class CallManager {
+    readonly events: TEvents;
+    readonly callStateMachine: CallStateMachine;
+    protected isPendingCall: boolean;
+    protected isPendingAnswer: boolean;
+    protected rtcSession?: RTCSession;
+    private readonly conferenceStateManager;
+    private readonly mainRemoteStreamsManager;
+    private readonly recvRemoteStreamsManager;
+    private readonly roleManager;
+    private readonly mcuSession;
+    private recvSession?;
+    private disposeRecvSessionTrackListener?;
+    constructor(conferenceStateManager: ConferenceStateManager);
+    get callActor(): TCallActor;
+    get requested(): boolean;
+    get connection(): RTCPeerConnection | undefined;
+    get isCallActive(): boolean;
+    getEstablishedRTCSession: () => RTCSession | undefined;
+    on<T extends keyof TEventMap>(eventName: T, handler: (data: TEventMap[T]) => void): () => void;
+    onRace<T extends keyof TEventMap>(eventNames: T[], handler: (data: TEventMap[T], eventName: string) => void): () => void;
+    once<T extends keyof TEventMap>(eventName: T, handler: (data: TEventMap[T]) => void): () => void;
+    onceRace<T extends keyof TEventMap>(eventNames: T[], handler: (data: TEventMap[T], eventName: string) => void): () => void;
+    wait<T extends keyof TEventMap>(eventName: T): Promise<TEventMap[T]>;
+    off<T extends keyof TEventMap>(eventName: T, handler: (data: TEventMap[T]) => void): void;
+    startCall: TStartCall;
+    endCall(): Promise<void>;
+    renegotiate(): Promise<boolean>;
+    answerToIncomingCall: TAnswerToIncomingCall;
+    getMainStream(): MediaStream | undefined;
+    getRemoteStreams(): MediaStream[];
+    setCallRoleParticipant(): void;
+    setCallRoleSpectatorSynthetic(): void;
+    setCallRoleSpectator(recvParams: TCallRoleSpectator['recvParams']): void;
+    replaceMediaStream(mediaStream: Parameters<TReplaceMediaStream>[0], options?: Parameters<TReplaceMediaStream>[1]): Promise<void>;
+    restartIce(options?: {
+        useUpdate?: boolean;
+        extraHeaders?: string[];
+        rtcOfferConstraints?: RTCOfferOptions;
+        sendEncodings?: RTCRtpEncodingParameters[];
+        degradationPreference?: RTCDegradationPreference;
+    }): Promise<boolean>;
+    private readonly reset;
+    private subscribeCallStatusChange;
+    private maybeTriggerCallStatus;
+    private subscribeMcuRemoteTrackEvents;
+    private addRemoteTrack;
+    private emitRemoteStreamsChanged;
+    private getActiveStreamsManager;
+    private attachRecvSessionTracks;
+    private startRecvSession;
+    private stopRecvSession;
+    private readonly onRoleChanged;
+}
+export default CallManager;

package/dist/ConnectionManager/@ConnectionManager.d.ts

@@ -0,0 +1,59 @@
+import { default as SipOperations, TParametersCheckTelephony } from './SipOperations';
+import { RegisteredEvent, UA, UnRegisteredEvent, WebSocketInterface } from '@krivega/jssip';
+import { TGetUri } from '../CallManager';
+import { TJsSIP } from '../types';
+import { TConnect, TConnectionConfigurationWithUa, TParametersConnection, TSet } from './ConnectionFlow';
+import { TConnectionActor } from './ConnectionStateMachine';
+import { TEventMap, TEvents } from './events';
+type TConnectParameters = (() => Promise<TParametersConnection>) | TParametersConnection;
+type TConnectOptions = Parameters<TConnect>[1] & {
+    hasReadyForConnection?: () => boolean;
+};
+export default class ConnectionManager {
+    readonly events: TEvents;
+    ua?: UA;
+    socket?: WebSocketInterface;
+    private readonly uaFactory;
+    private readonly registrationManager;
+    private readonly stateMachine;
+    private readonly connectionFlow;
+    private readonly sipOperations;
+    private readonly configurationManager;
+    private readonly JsSIP;
+    constructor({ JsSIP }: {
+        JsSIP: TJsSIP;
+    });
+    get requested(): boolean;
+    get isPendingConnect(): boolean;
+    get isPendingInitUa(): boolean;
+    get isIdle(): boolean;
+    get isDisconnected(): boolean;
+    get isFailed(): boolean;
+    get connectionActor(): TConnectionActor;
+    get connectionState(): import('./ConnectionStateMachine').EState;
+    get isRegistered(): boolean;
+    get isRegisterConfig(): boolean;
+    connect: (parameters: TConnectParameters, options?: TConnectOptions) => Promise<TConnectionConfigurationWithUa>;
+    set: TSet;
+    disconnect: () => Promise<void>;
+    register(): Promise<RegisteredEvent>;
+    unregister(): Promise<UnRegisteredEvent>;
+    readonly tryRegister: () => Promise<RegisteredEvent>;
+    sendOptions: (target: Parameters<SipOperations["sendOptions"]>[0], body?: Parameters<SipOperations["sendOptions"]>[1], extraHeaders?: Parameters<SipOperations["sendOptions"]>[2]) => Promise<void>;
+    ping: (body?: Parameters<SipOperations["ping"]>[0], extraHeaders?: Parameters<SipOperations["ping"]>[1]) => Promise<void>;
+    checkTelephony: (parameters: TParametersCheckTelephony) => Promise<void>;
+    on<T extends keyof TEventMap>(eventName: T, handler: (data: TEventMap[T]) => void): () => void;
+    once<T extends keyof TEventMap>(eventName: T, handler: (data: TEventMap[T]) => void): () => void;
+    onceRace<T extends keyof TEventMap>(eventNames: T[], handler: (data: TEventMap[T], eventName: string) => void): () => void;
+    wait<T extends keyof TEventMap>(eventName: T): Promise<TEventMap[T]>;
+    off<T extends keyof TEventMap>(eventName: T, handler: (data: TEventMap[T]) => void): void;
+    isConfigured(): boolean;
+    getConnectionConfiguration: () => import('./ConfigurationManager').IConnectionConfiguration | undefined;
+    destroy(): void;
+    getUri: TGetUri;
+    readonly getUaProtected: () => UA;
+    private readonly getUa;
+    private readonly connectWithProcessError;
+    private readonly processConnect;
+}
+export {};

package/dist/IncomingCallManager/@IncomingCallManager.d.ts

@@ -0,0 +1,32 @@
+import { IncomingCallStateMachine, TIncomingActor } from './IncomingCallStateMachine';
+import { RTCSession } from '@krivega/jssip';
+import { ConnectionManager } from '../ConnectionManager';
+import { TEventMap, TEvents } from './events';
+export default class IncomingCallManager {
+    readonly events: TEvents;
+    readonly incomingStateMachine: IncomingCallStateMachine;
+    private incomingRTCSession?;
+    private readonly connectionManager;
+    constructor(connectionManager: ConnectionManager);
+    get incomingActor(): TIncomingActor;
+    get remoteCallerData(): TEventMap['incomingCall'];
+    get isAvailableIncomingCall(): boolean;
+    start(): void;
+    stop(): void;
+    getIncomingRTCSession: () => RTCSession;
+    extractIncomingRTCSession: () => RTCSession;
+    declineToIncomingCall({ statusCode, }?: {
+        statusCode?: number;
+    }): Promise<void>;
+    busyIncomingCall(): Promise<void>;
+    on<T extends keyof TEventMap>(eventName: T, handler: (data: TEventMap[T]) => void): () => void;
+    once<T extends keyof TEventMap>(eventName: T, handler: (data: TEventMap[T]) => void): () => void;
+    onceRace<T extends keyof TEventMap>(eventNames: T[], handler: (data: TEventMap[T], eventName: string) => void): () => void;
+    wait<T extends keyof TEventMap>(eventName: T): Promise<TEventMap[T]>;
+    off<T extends keyof TEventMap>(eventName: T, handler: (data: TEventMap[T]) => void): void;
+    private subscribe;
+    private unsubscribe;
+    private readonly handleNewRTCSession;
+    private setIncomingSession;
+    private removeIncomingSession;
+}

package/dist/PresentationManager/@PresentationManager.d.ts

@@ -0,0 +1,53 @@
+import { PresentationStateMachine, TPresentationActor } from './PresentationStateMachine';
+import { CallManager } from '../CallManager';
+import { TEventMap, TEvents } from './events';
+import { TContentHint, TOnAddedTransceiver } from './types';
+export declare const hasCanceledStartPresentationError: (error: unknown) => error is import('repeated-calls').TCanceledError<unknown>;
+declare class PresentationManager {
+    readonly events: TEvents;
+    readonly presentationStateMachine: PresentationStateMachine;
+    promisePendingStartPresentation?: Promise<MediaStream>;
+    promisePendingStopPresentation?: Promise<MediaStream | undefined>;
+    streamPresentationCurrent?: MediaStream;
+    private readonly maxBitrate?;
+    private cancelableSendPresentationWithRepeatedCalls;
+    private readonly callManager;
+    constructor({ callManager, maxBitrate, }: {
+        callManager: CallManager;
+        maxBitrate?: number;
+    });
+    get presentationActor(): TPresentationActor;
+    get isPendingPresentation(): boolean;
+    get isPresentationInProcess(): boolean;
+    startPresentation(beforeStartPresentation: () => Promise<void>, stream: MediaStream, { isNeedReinvite, contentHint, sendEncodings, onAddedTransceiver, }?: {
+        isNeedReinvite?: boolean;
+        contentHint?: TContentHint;
+        sendEncodings?: RTCRtpEncodingParameters[];
+        onAddedTransceiver?: TOnAddedTransceiver;
+    }, options?: {
+        callLimit: number;
+    }): Promise<MediaStream>;
+    stopPresentation(beforeStopPresentation: () => Promise<void>): Promise<MediaStream | undefined>;
+    updatePresentation(beforeStartPresentation: () => Promise<void>, stream: MediaStream, { contentHint, sendEncodings, onAddedTransceiver, }?: {
+        isP2P?: boolean;
+        contentHint?: TContentHint;
+        sendEncodings?: RTCRtpEncodingParameters[];
+        onAddedTransceiver?: TOnAddedTransceiver;
+    }): Promise<MediaStream | undefined>;
+    cancelSendPresentationWithRepeatedCalls(): void;
+    on<T extends keyof TEventMap>(eventName: T, handler: (data: TEventMap[T]) => void): () => void;
+    once<T extends keyof TEventMap>(eventName: T, handler: (data: TEventMap[T]) => void): () => void;
+    onceRace<T extends keyof TEventMap>(eventNames: T[], handler: (data: TEventMap[T], eventName: string) => void): () => void;
+    wait<T extends keyof TEventMap>(eventName: T): Promise<TEventMap[T]>;
+    off<T extends keyof TEventMap>(eventName: T, handler: (data: TEventMap[T]) => void): void;
+    private subscribe;
+    private sendPresentationWithDuplicatedCalls;
+    private sendPresentation;
+    private readonly setMaxBitrate;
+    private readonly getRtcSessionProtected;
+    private readonly handleEnded;
+    private reset;
+    private resetPresentation;
+    private removeStreamPresentationCurrent;
+}
+export default PresentationManager;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sip-connector",
-  "version": "20.4.0",
+  "version": "20.4.1",
   "description": "Module for connect to Vinteo server",
   "keywords": [
     "webrtc",