sip-connector 14.1.0-alpha.9 → 14.1.1

package/dist/src/SipConnector.d.ts

@@ -0,0 +1,235 @@
+import { RTCSession, RegisteredEvent, UA, URI, UnRegisteredEvent, WebSocketInterface } from '@krivega/jssip';
+import { TEventSession, TEventUA } from './eventNames';
+import { TContentHint, TJsSIP, TOnAddedTransceiver } from './types';
+export declare const hasCanceledCallError: (error: unknown) => boolean;
+export declare const hasCanceledStartPresentationError: (error: unknown) => error is import('node_modules/repeated-calls/dist/utils').TCanceledError<unknown>;
+type TChannels = {
+    inputChannels: string;
+    outputChannels: string;
+};
+type TMediaState = {
+    cam: boolean;
+    mic: boolean;
+};
+type TOptionsInfoMediaState = {
+    noTerminateWhenError?: boolean;
+};
+type TOptionsExtraHeaders = {
+    extraHeaders?: string[];
+};
+type TOntrack = (track: RTCTrackEvent) => void;
+type TParametersConnection = TOptionsExtraHeaders & {
+    displayName?: string;
+    user?: string;
+    password?: string;
+    register?: boolean;
+    sipServerUrl: string;
+    sipWebSocketServerURL: string;
+    remoteAddress?: string;
+    sessionTimers?: boolean;
+    registerExpires?: number;
+    connectionRecoveryMinInterval?: number;
+    connectionRecoveryMaxInterval?: number;
+    userAgent?: string;
+};
+type TParametersCheckTelephony = {
+    displayName: string;
+    sipServerUrl: string;
+    sipWebSocketServerURL: string;
+    userAgent?: string;
+    remoteAddress?: string;
+    extraHeaders?: string[];
+};
+type TConnect = (parameters: TParametersConnection, options?: {
+    callLimit?: number;
+}) => Promise<UA>;
+type TSet = ({ displayName, password, }: {
+    displayName?: string;
+    password?: string;
+}) => Promise<boolean>;
+type TParametersAnswerToIncomingCall = {
+    mediaStream: MediaStream;
+    extraHeaders?: TOptionsExtraHeaders['extraHeaders'];
+    ontrack?: TOntrack;
+    iceServers?: RTCIceServer[];
+    directionVideo?: RTCRtpTransceiverDirection;
+    directionAudio?: RTCRtpTransceiverDirection;
+    contentHint?: TContentHint;
+    sendEncodings?: RTCRtpEncodingParameters[];
+    offerToReceiveAudio?: boolean;
+    offerToReceiveVideo?: boolean;
+    onAddedTransceiver?: TOnAddedTransceiver;
+};
+type TParametersCall = TParametersAnswerToIncomingCall & {
+    number: string;
+};
+type TCall = (parameters: TParametersCall) => Promise<RTCPeerConnection>;
+type TAnswerToIncomingCall = (parameters: TParametersAnswerToIncomingCall) => Promise<RTCPeerConnection>;
+type TSendDTMF = (tone: number | string) => Promise<void>;
+type THangUp = () => Promise<void>;
+export default class SipConnector {
+    promisePendingStartPresentation?: Promise<MediaStream>;
+    promisePendingStopPresentation?: Promise<MediaStream | undefined>;
+    ua?: UA;
+    rtcSession?: RTCSession;
+    incomingRTCSession?: RTCSession;
+    streamPresentationCurrent?: MediaStream;
+    socket?: WebSocketInterface;
+    private isRegisterConfigInner;
+    private connectionConfiguration;
+    private remoteStreams;
+    private readonly JsSIP;
+    private readonly sessionEvents;
+    private readonly uaEvents;
+    private cancelableConnectWithRepeatedCalls;
+    private cancelableSendPresentationWithRepeatedCalls;
+    private isPendingConnect;
+    private isPendingInitUa;
+    private isPendingCall;
+    private isPendingAnswer;
+    constructor({ JsSIP }: {
+        JsSIP: TJsSIP;
+    });
+    get connection(): RTCPeerConnection | undefined;
+    get remoteCallerData(): {
+        displayName: string | undefined;
+        host: string | undefined;
+        incomingNumber: string | undefined;
+        rtcSession: RTCSession | undefined;
+    };
+    get requested(): boolean;
+    get establishedRTCSession(): RTCSession | undefined;
+    get isRegistered(): boolean;
+    get isRegisterConfig(): boolean;
+    get isCallActive(): boolean;
+    get isAvailableIncomingCall(): boolean;
+    get isPendingPresentation(): boolean;
+    connect: TConnect;
+    hangUp: THangUp;
+    register(): Promise<RegisteredEvent>;
+    unregister(): Promise<UnRegisteredEvent>;
+    readonly tryRegister: () => Promise<RegisteredEvent>;
+    sendOptions(target: URI | string, body?: string, extraHeaders?: string[]): Promise<void>;
+    ping(body?: string, extraHeaders?: string[]): Promise<void>;
+    checkTelephony({ userAgent, displayName, sipServerUrl, sipWebSocketServerURL, remoteAddress, extraHeaders, }: TParametersCheckTelephony): Promise<void>;
+    replaceMediaStream(mediaStream: MediaStream, options?: {
+        deleteExisting?: boolean;
+        addMissing?: boolean;
+        forceRenegotiation?: boolean;
+        contentHint?: TContentHint;
+        sendEncodings?: RTCRtpEncodingParameters[];
+        onAddedTransceiver?: TOnAddedTransceiver;
+    }): Promise<void>;
+    declineToIncomingCall: ({ statusCode, }?: {
+        statusCode?: number;
+    }) => Promise<void>;
+    busyIncomingCall: () => Promise<void>;
+    askPermissionToEnableCam(options?: TOptionsInfoMediaState): Promise<void>;
+    startPresentation(stream: MediaStream, { isNeedReinvite, isP2P, maxBitrate, contentHint, sendEncodings, onAddedTransceiver, }?: {
+        isNeedReinvite?: boolean;
+        isP2P?: boolean;
+        maxBitrate?: number;
+        contentHint?: TContentHint;
+        sendEncodings?: RTCRtpEncodingParameters[];
+        onAddedTransceiver?: TOnAddedTransceiver;
+    }, options?: {
+        callLimit: number;
+    }): Promise<MediaStream>;
+    stopPresentation({ isP2P, }?: {
+        isP2P?: boolean;
+    }): Promise<MediaStream | undefined>;
+    updatePresentation(stream: MediaStream, { isP2P, maxBitrate, contentHint, sendEncodings, onAddedTransceiver, }?: {
+        isP2P?: boolean;
+        maxBitrate?: number;
+        contentHint?: TContentHint;
+        sendEncodings?: RTCRtpEncodingParameters[];
+        onAddedTransceiver?: TOnAddedTransceiver;
+    }): Promise<MediaStream | undefined>;
+    on<T>(eventName: TEventUA, handler: (data: T) => void): () => void;
+    once<T>(eventName: TEventUA, handler: (data: T) => void): () => void;
+    onceRace<T>(eventNames: TEventUA[], handler: (data: T, eventName: string) => void): () => void;
+    wait<T>(eventName: TEventUA): Promise<T>;
+    off<T>(eventName: TEventUA, handler: (data: T) => void): void;
+    onSession<T>(eventName: TEventSession, handler: (data: T) => void): () => void;
+    onceSession<T>(eventName: TEventSession, handler: (data: T) => void): () => void;
+    onceRaceSession<T>(eventNames: TEventSession[], handler: (data: T, eventName: string) => void): () => void;
+    waitSession<T>(eventName: TEventSession): Promise<T>;
+    offSession<T>(eventName: TEventSession, handler: (data: T) => void): void;
+    isConfigured(): boolean;
+    getConnectionConfiguration(): {
+        sipServerUrl?: string;
+        displayName?: string;
+        register?: boolean;
+        user?: string;
+        password?: string;
+        number?: string;
+        answer?: boolean;
+    };
+    getRemoteStreams(): MediaStream[] | undefined;
+    getIncomingRTCSession(): RTCSession;
+    set: TSet;
+    disconnect: () => Promise<void>;
+    call: TCall;
+    answerToIncomingCall: TAnswerToIncomingCall;
+    sendDTMF: TSendDTMF;
+    cancelSendPresentationWithRepeatedCalls(): void;
+    waitChannels(): Promise<TChannels>;
+    waitSyncMediaState(): Promise<{
+        isSyncForced: boolean;
+    }>;
+    sendChannels({ inputChannels, outputChannels }: TChannels): Promise<void>;
+    sendMediaState({ cam, mic }: TMediaState, options?: TOptionsInfoMediaState): Promise<void>;
+    sendRefusalToTurnOn(type: 'cam' | 'mic', options?: TOptionsInfoMediaState): Promise<void>;
+    sendRefusalToTurnOnMic(options?: TOptionsInfoMediaState): Promise<void>;
+    sendRefusalToTurnOnCam(options?: TOptionsInfoMediaState): Promise<void>;
+    private readonly removeIncomingSession;
+    private getSipServerUrl;
+    private sendMustStopPresentation;
+    private readonly connectWithDuplicatedCalls;
+    private sendPresentationWithDuplicatedCalls;
+    private hasEqualConnectionConfiguration;
+    private createUaConfiguration;
+    private sendPresentation;
+    private removeStreamPresentationCurrent;
+    private resetPresentation;
+    private cancelRequestsAndResetPresentation;
+    private readonly handleNewRTCSession;
+    private readonly connectInner;
+    private readonly initUa;
+    private readonly createUa;
+    private readonly start;
+    private readonly handleCall;
+    private readonly restoreSession;
+    private generateStream;
+    private generateAudioStream;
+    private generateStreams;
+    private generateAudioStreams;
+    private readonly hangUpWithoutCancelRequests;
+    private cancelRequests;
+    private cancelConnectWithRepeatedCalls;
+    private readonly handleShareState;
+    private readonly maybeTriggerChannels;
+    private readonly handleNotify;
+    private readonly triggerRemovedFromListModeratorsNotify;
+    private readonly triggerAddedToListModeratorsNotify;
+    private readonly triggerWebcastStartedNotify;
+    private readonly triggerWebcastStoppedNotify;
+    private readonly triggerAccountChangedNotify;
+    private readonly triggerAccountDeletedNotify;
+    private readonly triggerConferenceParticipantTokenIssued;
+    private readonly triggerChannelsNotify;
+    private readonly triggerParticipationAcceptingWordRequest;
+    private readonly triggerParticipationCancellingWordRequest;
+    private readonly triggerParticipantMoveRequestToStream;
+    private readonly triggerEnterRoom;
+    private readonly triggerShareState;
+    private readonly maybeTriggerParticipantMoveRequest;
+    private readonly triggerMainCamControl;
+    private readonly triggerMicControl;
+    private readonly triggerUseLicense;
+    private readonly handleNewInfo;
+    private readonly handleSipEvent;
+    private readonly maybeHandleNotify;
+    private readonly handleEnded;
+}
+export {};

package/dist/{SipConnectorFacade → src/SipConnectorFacade}/SipConnectorFacade.d.ts

@@ -1,14 +1,17 @@
 import { UA } from '@krivega/jssip';
-import { EUseLicense } from '../ApiManager';
-import { TContentHint } from '../PresentationManager';
-import { SipConnector } from '../SipConnector';
-import { TSimulcastEncoding } from '../types';
+import { default as SipConnector } from '../SipConnector';
+import { EUseLicense, TContentHint, TSimulcastEncoding } from '../types';
 interface IProxyMethods {
     on: SipConnector['on'];
     once: SipConnector['once'];
     onceRace: SipConnector['onceRace'];
     wait: SipConnector['wait'];
     off: SipConnector['off'];
+    onSession: SipConnector['onSession'];
+    onceSession: SipConnector['onceSession'];
+    onceRaceSession: SipConnector['onceRaceSession'];
+    waitSession: SipConnector['waitSession'];
+    offSession: SipConnector['offSession'];
     sendDTMF: SipConnector['sendDTMF'];
     hangUp: SipConnector['hangUp'];
     declineToIncomingCall: SipConnector['declineToIncomingCall'];
@@ -26,6 +29,11 @@ declare class SipConnectorFacade implements IProxyMethods {
     onceRace: IProxyMethods['onceRace'];
     wait: IProxyMethods['wait'];
     off: IProxyMethods['off'];
+    onSession: IProxyMethods['onSession'];
+    onceSession: IProxyMethods['onceSession'];
+    onceRaceSession: IProxyMethods['onceRaceSession'];
+    waitSession: IProxyMethods['waitSession'];
+    offSession: IProxyMethods['offSession'];
     sendDTMF: IProxyMethods['sendDTMF'];
     hangUp: IProxyMethods['hangUp'];
     declineToIncomingCall: IProxyMethods['declineToIncomingCall'];
@@ -86,7 +94,7 @@ declare class SipConnectorFacade implements IProxyMethods {
     disconnectFromServer: () => Promise<{
         isSuccessful: boolean;
     }>;
-    answerToIncomingCall: (parameters: {
+    answerIncomingCall: (parameters: {
         mediaStream: MediaStream;
         extraHeaders?: string[] | undefined;
         iceServers?: RTCIceServer[];
@@ -122,7 +130,7 @@ declare class SipConnectorFacade implements IProxyMethods {
         preferredMimeTypesVideoCodecs?: string[];
         excludeMimeTypesVideoCodecs?: string[];
     }) => Promise<MediaStream | undefined>;
-    startPresentation: ({ mediaStream, isP2P, maxBitrate, contentHint, simulcastEncodings, degradationPreference, sendEncodings, preferredMimeTypesVideoCodecs, excludeMimeTypesVideoCodecs, callLimit, }: {
+    startPresentation: ({ mediaStream, isP2P, maxBitrate, contentHint, simulcastEncodings, degradationPreference, sendEncodings, preferredMimeTypesVideoCodecs, excludeMimeTypesVideoCodecs, }: {
         mediaStream: MediaStream;
         isP2P: boolean;
         maxBitrate?: number;
@@ -132,7 +140,8 @@ declare class SipConnectorFacade implements IProxyMethods {
         sendEncodings?: RTCRtpEncodingParameters[];
         preferredMimeTypesVideoCodecs?: string[];
         excludeMimeTypesVideoCodecs?: string[];
-        callLimit?: number;
+    }, options?: {
+        callLimit: number;
     }) => Promise<MediaStream | undefined>;
     stopShareSipConnector: ({ isP2P }?: {
         isP2P?: boolean;

package/dist/{__fixtures__ → src/__fixtures__}/BaseSession.mock.d.ts

@@ -1,6 +1,6 @@
 import { AnswerOptions, ExtraHeaders, HoldOptions, MediaStreamTypes, NameAddrHeader, OnHoldResult, RTCPeerConnectionDeprecated, RTCSession, ReferOptions, RenegotiateOptions, SessionDirection, SessionStatus, TerminateOptions, URI, C as constants } from '@krivega/jssip';
 import { default as Events } from 'events-constructor';
-import { TEventSession, SESSION_EVENT_NAMES } from './eventNames';
+import { TEventSession, SESSION_EVENT_NAMES } from '../eventNames';
 export type TEventHandlers = Record<string, (data: unknown) => void>;
 declare class BaseSession implements RTCSession {
     originator: string;
@@ -11,10 +11,9 @@ declare class BaseSession implements RTCSession {
         audio: boolean;
         video: boolean;
     };
-    constructor({ originator, eventHandlers, remoteIdentity, }: {
+    constructor({ originator, eventHandlers, }: {
         originator?: string;
         eventHandlers: TEventHandlers;
-        remoteIdentity: NameAddrHeader;
     });
     get contact(): string;
     get direction(): SessionDirection;
@@ -49,7 +48,7 @@ declare class BaseSession implements RTCSession {
     addListener(_event: string | symbol, _listener: (...arguments_: unknown[]) => void): this;
     once(_event: string | symbol, _listener: (...arguments_: unknown[]) => void): this;
     removeListener(_event: string | symbol, _listener: (...arguments_: unknown[]) => void): this;
-    off(eventName: string | symbol, _listener: (...arguments_: unknown[]) => void): this;
+    off(_event: string | symbol, _listener: (...arguments_: unknown[]) => void): this;
     removeAllListeners(_event?: string | symbol): this;
     setMaxListeners(_n: number): this;
     getMaxListeners(): number;
@@ -60,7 +59,7 @@ declare class BaseSession implements RTCSession {
     prependListener(_event: string | symbol, _listener: (...arguments_: unknown[]) => void): this;
     prependOnceListener(_event: string | symbol, _listener: (...arguments_: unknown[]) => void): this;
     eventNames(): (string | symbol)[];
-    initEvents(eventHandlers?: TEventHandlers): void;
+    initEvents(eventHandlers: TEventHandlers): void;
     on<T>(eventName: string, handler: (data: T) => void): this;
     trigger(eventName: TEventSession, data?: unknown): void;
     /**
@@ -72,6 +71,7 @@ declare class BaseSession implements RTCSession {
      */
     sendDTMF(): void;
     startPresentation(stream: MediaStream): Promise<MediaStream>;
+    updatePresentation(stream: MediaStream): Promise<MediaStream>;
     stopPresentation(stream: MediaStream): Promise<MediaStream>;
     isEstablished(): boolean;
 }

package/dist/{__fixtures__ → src/__fixtures__}/RTCSessionMock.d.ts

@@ -1,9 +1,8 @@
-import { IncomingInfoEvent, NameAddrHeader } from '@krivega/jssip';
+import { IncomingInfoEvent } from '@krivega/jssip';
 import { TEventHandlers, default as BaseSession } from './BaseSession.mock';
 export declare const FAILED_CONFERENCE_NUMBER = "777";
 export declare const createDeclineStartPresentationError: () => Error;
 declare class RTCSessionMock extends BaseSession {
-    private static presentationError?;
     private static startPresentationError?;
     private static countStartPresentationError;
     private static countStartsPresentation;
@@ -21,23 +20,18 @@ declare class RTCSessionMock extends BaseSession {
     answer: jest.Mock<void, [{
         mediaStream: MediaStream;
     }], any>;
-    replaceMediaStream: jest.Mock<Promise<void>, [_mediaStream: MediaStream], any>;
     private isEndedInner;
-    constructor({ url, mediaStream, eventHandlers, originator, remoteIdentity, }: {
+    constructor({ url, mediaStream, eventHandlers, originator, }: {
         url?: string;
         mediaStream?: MediaStream;
         eventHandlers: TEventHandlers;
         originator: string;
-        remoteIdentity?: NameAddrHeader;
     });
-    static setPresentationError(presentationError: Error): void;
-    static resetPresentationError(): void;
     static setStartPresentationError(startPresentationError: Error, { count }?: {
         count?: number;
     }): void;
     static resetStartPresentationError(): void;
-    startPresentation: (stream: MediaStream) => Promise<MediaStream>;
-    stopPresentation: (stream: MediaStream) => Promise<MediaStream>;
+    startPresentation(stream: MediaStream): Promise<MediaStream>;
     initPeerconnection(mediaStream: MediaStream | undefined): boolean;
     createPeerconnection(sendedStream: MediaStream): void;
     connect(target: string): void;
@@ -68,6 +62,7 @@ declare class RTCSessionMock extends BaseSession {
         audio: boolean;
         video: boolean;
     };
+    replaceMediaStream(_mediaStream: MediaStream): Promise<void>;
     onmute({ audio, video }: {
         audio: boolean;
         video: boolean;

package/dist/{__fixtures__ → src/__fixtures__}/UA.mock.d.ts

@@ -18,17 +18,6 @@ declare class UA implements IUA {
         mediaStream: MediaStream;
         eventHandlers: TEventHandlers;
     }], any>;
-    sendOptions: jest.Mock<void, [target: string, body?: string | undefined, options?: Record<string, unknown> | undefined], any>;
-    /**
-     * start – имитирует запуск UA.
-     */
-    start: jest.Mock<void, [], any>;
-    /**
-     * stop – имитирует остановку UA.
-     */
-    stop: jest.Mock<void, [], any>;
-    removeAllListeners: jest.Mock<this, [], any>;
-    once: jest.Mock<this, [eventName: string, handler: () => void], any>;
     private startedTimeout?;
     private stopedTimeout?;
     private session?;
@@ -42,9 +31,22 @@ declare class UA implements IUA {
     static resetStartError(): void;
     static setAvailableTelephony(): void;
     static setNotAvailableTelephony(): void;
-    static reset(): void;
+    /**
+     * start
+     *
+     * @returns {undefined}
+     */
+    start(): void;
+    /**
+     * stop
+     *
+     * @returns {undefined}
+     */
+    stop(): void;
     on<T extends keyof UAEventMap>(eventName: T, handler: UAEventMap[T]): this;
+    once<T extends keyof UAEventMap>(eventName: T, handler: UAEventMap[T]): this;
     off<T extends keyof UAEventMap>(eventName: T, handler: UAEventMap[T]): this;
+    removeAllListeners(): this;
     trigger<T extends keyof UAEventMap>(eventName: T, data: Parameters<UAEventMap[T]>[0]): void;
     /**
      * terminateSessions

package/dist/{__fixtures__ → src/__fixtures__}/index.d.ts

@@ -40,7 +40,7 @@ export declare const uaConfigurationWithAuthorization: {
     session_timers: boolean;
     sockets: import('./WebSocketInterface.mock').default[];
     user_agent: string;
-    sdpSemantics: string;
+    sdp_semantics: string;
     register_expires: number;
     connection_recovery_max_interval: number;
     connection_recovery_min_interval: number;
@@ -53,7 +53,7 @@ export declare const uaConfigurationWithAuthorizationWithDisplayName: {
     session_timers: boolean;
     sockets: import('./WebSocketInterface.mock').default[];
     user_agent: string;
-    sdpSemantics: string;
+    sdp_semantics: string;
     register_expires: number;
     connection_recovery_max_interval: number;
     connection_recovery_min_interval: number;
@@ -64,7 +64,7 @@ export declare const uaConfigurationWithoutAuthorization: {
     session_timers: boolean;
     sockets: import('./WebSocketInterface.mock').default[];
     user_agent: string;
-    sdpSemantics: string;
+    sdp_semantics: string;
     register_expires: number;
     connection_recovery_max_interval: number;
     connection_recovery_min_interval: number;
@@ -75,7 +75,7 @@ export declare const uaConfigurationWithoutAuthorizationWithoutDisplayName: {
     session_timers: boolean;
     sockets: import('./WebSocketInterface.mock').default[];
     user_agent: string;
-    sdpSemantics: string;
+    sdp_semantics: string;
     register_expires: number;
     connection_recovery_max_interval: number;
     connection_recovery_min_interval: number;

package/dist/{__fixtures__ → src/__fixtures__}/jssip.mock.d.ts

@@ -1,10 +1,10 @@
 import { RTCSession, UA } from '@krivega/jssip';
-import { default as UAMock } from './UA.mock';
+import { default as UAmock } from './UA.mock';
 import { default as WebSocketInterfaceMock } from './WebSocketInterface.mock';
 declare const jssip: {
     triggerNewInfo: (rtcSession: RTCSession, extraHeaders: [string, string][]) => void;
     triggerNewSipEvent: (ua: UA, extraHeaders: [string, string][]) => void;
-    triggerIncomingSession: (ua: UAMock, { incomingNumber, displayName, host, }: {
+    triggerIncomingSession: (ua: UAmock, { incomingNumber, displayName, host, }: {
         incomingNumber?: string;
         displayName: string;
         host: string;
@@ -13,7 +13,7 @@ declare const jssip: {
         originator: "local" | "remote";
     }) => void;
     WebSocketInterface: typeof WebSocketInterfaceMock;
-    UA: typeof UAMock;
+    UA: typeof UAmock;
     C: {
         INVITE: string;
     };

package/dist/src/causes.d.ts

@@ -0,0 +1,23 @@
+export declare const CONNECTION_ERROR = "Connection Error";
+export declare const REQUEST_TIMEOUT = "Request Timeout";
+export declare const SIP_FAILURE_CODE = "SIP Failure Code";
+export declare const INTERNAL_ERROR = "Internal Error";
+export declare const BUSY = "Busy";
+export declare const REJECTED = "Rejected";
+export declare const REDIRECTED = "Redirected";
+export declare const UNAVAILABLE = "Unavailable";
+export declare const NOT_FOUND = "Not Found";
+export declare const ADDRESS_INCOMPLETE = "Address Incomplete";
+export declare const INCOMPATIBLE_SDP = "Incompatible SDP";
+export declare const MISSING_SDP = "Missing SDP";
+export declare const AUTHENTICATION_ERROR = "Authentication Error";
+export declare const BYE = "Terminated";
+export declare const WEBRTC_ERROR = "WebRTC Error";
+export declare const CANCELED = "Canceled";
+export declare const NO_ANSWER = "No Answer";
+export declare const EXPIRES = "Expires";
+export declare const NO_ACK = "No ACK";
+export declare const DIALOG_ERROR = "Dialog Error";
+export declare const USER_DENIED_MEDIA_ACCESS = "User Denied Media Access";
+export declare const BAD_MEDIA_DESCRIPTION = "Bad Media Description";
+export declare const RTP_TIMEOUT = "RTP Timeout";

package/dist/{doMock.d.ts → src/doMock.d.ts}

@@ -1,6 +1,5 @@
-import { SipConnector } from './SipConnector';
+import { default as SipConnector } from './SipConnector';
 export { FAILED_CONFERENCE_NUMBER } from './__fixtures__/RTCSessionMock';
 export { NAME_INCORRECT, PASSWORD_CORRECT, PASSWORD_CORRECT_2 } from './__fixtures__/UA.mock';
 export * from './__fixtures__/index';
 export declare const doMockSipConnector: () => SipConnector;
-export { default as JsSIP } from './__fixtures__/jssip.mock';

package/dist/{__fixtures__ → src}/eventNames.d.ts

@@ -2,7 +2,7 @@ export declare const UA_SYNTHETICS_EVENT_NAMES: readonly ["incomingCall", "decli
 export declare const UA_JSSIP_EVENT_NAMES: readonly ["connecting", "connected", "disconnected", "newRTCSession", "registered", "unregistered", "registrationFailed", "newMessage", "sipEvent"];
 export declare const SESSION_SYNTHETICS_EVENT_NAMES: readonly ["availableSecondRemoteStream", "notAvailableSecondRemoteStream", "mustStopPresentation", "shareState", "enterRoom", "useLicense", "peerconnection:confirmed", "peerconnection:ontrack", "channels", "ended:fromserver", "main-cam-control", "admin-start-main-cam", "admin-stop-main-cam", "admin-stop-mic", "admin-start-mic", "admin-force-sync-media-state", "participant:move-request-to-spectators", "participant:move-request-to-participants"];
 export declare const SESSION_JSSIP_EVENT_NAMES: readonly ["ended", "connecting", "sending", "reinvite", "replaces", "refer", "progress", "accepted", "confirmed", "peerconnection", "failed", "muted", "unmuted", "newDTMF", "newInfo", "hold", "unhold", "update", "sdp", "icecandidate", "getusermediafailed", "peerconnection:createofferfailed", "peerconnection:createanswerfailed", "peerconnection:setlocaldescriptionfailed", "peerconnection:setremotedescriptionfailed", "presentation:start", "presentation:started", "presentation:end", "presentation:ended", "presentation:failed"];
-export declare const UA_EVENT_NAMES: ("connecting" | "connected" | "disconnected" | "newRTCSession" | "registered" | "unregistered" | "registrationFailed" | "newMessage" | "sipEvent" | "channels:notify" | "participant:added-to-list-moderators" | "participant:removed-from-list-moderators" | "participant:move-request-to-stream" | "participation:accepting-word-request" | "participation:cancelling-word-request" | "webcast:started" | "webcast:stopped" | "account:changed" | "account:deleted" | "conference:participant-token-issued" | "incomingCall" | "declinedIncomingCall" | "terminatedIncomingCall" | "failedIncomingCall")[];
+export declare const UA_EVENT_NAMES: ("incomingCall" | "declinedIncomingCall" | "failedIncomingCall" | "terminatedIncomingCall" | "connecting" | "connected" | "disconnected" | "newRTCSession" | "registered" | "unregistered" | "registrationFailed" | "newMessage" | "sipEvent" | "channels:notify" | "participant:added-to-list-moderators" | "participant:removed-from-list-moderators" | "participant:move-request-to-stream" | "participation:accepting-word-request" | "participation:cancelling-word-request" | "webcast:started" | "webcast:stopped" | "account:changed" | "account:deleted" | "conference:participant-token-issued")[];
 export declare const SESSION_EVENT_NAMES: readonly ["ended", "connecting", "sending", "reinvite", "replaces", "refer", "progress", "accepted", "confirmed", "peerconnection", "failed", "muted", "unmuted", "newDTMF", "newInfo", "hold", "unhold", "update", "sdp", "icecandidate", "getusermediafailed", "peerconnection:createofferfailed", "peerconnection:createanswerfailed", "peerconnection:setlocaldescriptionfailed", "peerconnection:setremotedescriptionfailed", "presentation:start", "presentation:started", "presentation:end", "presentation:ended", "presentation:failed", "availableSecondRemoteStream", "notAvailableSecondRemoteStream", "mustStopPresentation", "shareState", "enterRoom", "useLicense", "peerconnection:confirmed", "peerconnection:ontrack", "channels", "ended:fromserver", "main-cam-control", "admin-start-main-cam", "admin-stop-main-cam", "admin-stop-mic", "admin-start-mic", "admin-force-sync-media-state", "participant:move-request-to-spectators", "participant:move-request-to-participants"];
 export type TEventUA = (typeof UA_EVENT_NAMES)[number];
 export type TEventSession = (typeof SESSION_EVENT_NAMES)[number];

package/dist/src/headers.d.ts

@@ -0,0 +1,37 @@
+export declare const HEADER_CONTENT_TYPE_NAME = "content-type";
+export declare const HEADER_CONTENT_ENTER_ROOM = "x-webrtc-enter-room";
+export declare const CONTENT_TYPE_SHARE_STATE = "application/vinteo.webrtc.sharedesktop";
+export declare const CONTENT_TYPE_ENTER_ROOM = "application/vinteo.webrtc.roomname";
+export declare const CONTENT_TYPE_CHANNELS = "application/vinteo.webrtc.channels";
+export declare const CONTENT_TYPE_MEDIA_STATE = "application/vinteo.webrtc.mediastate";
+export declare const CONTENT_TYPE_REFUSAL = "application/vinteo.webrtc.refusal";
+export declare const CONTENT_TYPE_MAIN_CAM = "application/vinteo.webrtc.maincam";
+export declare const CONTENT_TYPE_MIC = "application/vinteo.webrtc.mic";
+export declare const CONTENT_TYPE_USE_LICENSE = "application/vinteo.webrtc.uselic";
+export declare const HEADER_CONTENT_USE_LICENSE = "X-WEBRTC-USE-LICENSE";
+export declare const HEADER_PARTICIPANT_NAME = "X-WEBRTC-PARTICIPANT-NAME";
+export declare const HEADER_INPUT_CHANNELS = "X-WEBRTC-INPUT-CHANNELS";
+export declare const HEADER_OUTPUT_CHANNELS = "X-WEBRTC-OUTPUT-CHANNELS";
+export declare const HEADER_MAIN_CAM = "X-WEBRTC-MAINCAM";
+export declare const HEADER_MIC = "X-WEBRTC-MIC";
+export declare const HEADER_MEDIA_SYNC = "X-WEBRTC-SYNC";
+export declare const HEADER_MAIN_CAM_RESOLUTION = "X-WEBRTC-MAINCAM-RESOLUTION";
+export declare const HEADER_MEDIA_STATE = "X-WEBRTC-MEDIA-STATE";
+export declare const HEADER_MEDIA_TYPE = "X-Vinteo-Media-Type";
+export declare const HEADER_MAIN_CAM_STATE = "X-Vinteo-MainCam-State";
+export declare const HEADER_MIC_STATE = "X-Vinteo-Mic-State";
+export declare const CONTENT_TYPE_PARTICIPANT_STATE = "application/vinteo.webrtc.partstate";
+export declare const HEADER_CONTENT_PARTICIPANT_STATE = "X-WEBRTC-PARTSTATE";
+export declare const CONTENT_TYPE_NOTIFY = "application/vinteo.webrtc.notify";
+export declare const HEADER_NOTIFY = "X-VINTEO-NOTIFY";
+export declare const HEADER_CONTENT_SHARE_STATE = "x-webrtc-share-state";
+export declare const HEADER_START_PRESENTATION = "x-webrtc-share-state: LETMESTARTPRESENTATION";
+export declare const HEADER_STOP_PRESENTATION = "x-webrtc-share-state: STOPPRESENTATION";
+export declare const AVAILABLE_SECOND_REMOTE_STREAM = "YOUCANRECEIVECONTENT";
+export declare const NOT_AVAILABLE_SECOND_REMOTE_STREAM = "CONTENTEND";
+export declare const MUST_STOP_PRESENTATION = "YOUMUSTSTOPSENDCONTENT";
+export declare const HEADER_MUST_STOP_PRESENTATION_P2P = "x-webrtc-share-state: YOUMUSTSTOPSENDCONTENT";
+export declare const HEADER_START_PRESENTATION_P2P = "x-webrtc-share-state: YOUCANRECEIVECONTENT";
+export declare const HEADER_STOP_PRESENTATION_P2P = "x-webrtc-share-state: CONTENTEND";
+export declare const HEADER_CONTENT_ENABLE_MEDIA_DEVICE = "X-WEBRTC-REQUEST-ENABLE-MEDIA-DEVICE";
+export declare const HEADER_ENABLE_MAIN_CAM = "X-WEBRTC-REQUEST-ENABLE-MEDIA-DEVICE: LETMESTARTMAINCAM";

package/dist/src/index.d.ts

@@ -0,0 +1,11 @@
+export * as causes from './causes';
+export * as constants from './constants';
+export * as eventNames from './eventNames';
+export { debug, disableDebug, enableDebug } from './logger';
+export { default as setParametersToSender } from './setParametersToSender';
+export * as tools from './tools';
+export * from './types';
+export { default as getCodecFromSender } from './utils/getCodecFromSender';
+export { default as resolveVideoSendingBalancer } from './videoSendingBalancer';
+export { hasCanceledCallError, hasCanceledStartPresentationError, default as SipConnector, } from './SipConnector';
+export { SipConnectorFacade } from './SipConnectorFacade';

package/dist/{tools → src/tools}/__fixtures__/connectToServer.d.ts

@@ -95,7 +95,7 @@ export declare const uaConfigurationWithAuthorization: {
     session_timers: boolean;
     sockets: import('../../__fixtures__/WebSocketInterface.mock').default[];
     user_agent: string;
-    sdpSemantics: string;
+    sdp_semantics: string;
     register_expires: number;
     connection_recovery_max_interval: number;
     connection_recovery_min_interval: number;
@@ -108,7 +108,7 @@ export declare const uaConfigurationWithAuthorizationPasswordChanged: {
     session_timers: boolean;
     sockets: import('../../__fixtures__/WebSocketInterface.mock').default[];
     user_agent: string;
-    sdpSemantics: string;
+    sdp_semantics: string;
     register_expires: number;
     connection_recovery_max_interval: number;
     connection_recovery_min_interval: number;

package/dist/{tools → src/tools}/__fixtures__/processRequest.d.ts

@@ -1,4 +1,4 @@
-import { SipConnector } from '../../SipConnector';
+import { default as SipConnector } from '../../SipConnector';
 declare const resolveInitUaPromised: (sipConnector: SipConnector) => (state: {
     remoteAddress: string | undefined;
     sipServerUrl: string;

package/dist/{tools → src/tools}/error/getLinkError.d.ts

@@ -1,3 +1,3 @@
-import { TCustomError } from '../../CallManager';
+import { TCustomError } from '../../types';
 declare const getLinkError: (error: TCustomError) => string | undefined;
 export default getLinkError;

package/dist/{tools → src/tools}/error/getTypeFromError.d.ts

@@ -1,4 +1,4 @@
-import { TCustomError } from '../../CallManager';
+import { TCustomError } from '../../types';
 export declare enum EErrorTypes {
     CONNECT_SERVER_FAILED = "CONNECT_SERVER_FAILED",
     WRONG_USER_OR_PASSWORD = "WRONG_USER_OR_PASSWORD",

package/dist/{tools → src/tools}/error/getValuesFromError.d.ts

@@ -1,4 +1,4 @@
-import { TCustomError } from '../../CallManager';
+import { TCustomError } from '../../types';
 export type TValues = {
     code: string;
     cause: string;

package/dist/{tools → src/tools}/index.d.ts

@@ -2,5 +2,5 @@ export * as error from './error';
 export { default as getExtraHeaders } from './getExtraHeaders';
 export { default as getUserAgent } from './getUserAgent';
 export { default as hasPurgatory, PURGATORY_CONFERENCE_NUMBER } from './hasPurgatory';
-export { default as sendDtmfAccumulated } from './sendDtmfFAccumulated';
+export { default as sendDtmfAccumulated } from './sendDTMFAccumulated';
 export { default as createSyncMediaState } from './syncMediaState';

package/dist/{tools → src/tools}/prepareMediaStream.d.ts

@@ -1,4 +1,4 @@
-import { TContentHint } from '../PresentationManager';
+import { TContentHint } from '../types';
 declare const prepareMediaStream: (mediaStream?: MediaStream, { directionVideo, directionAudio, contentHint, }?: {
     directionVideo?: RTCRtpTransceiverDirection;
     directionAudio?: RTCRtpTransceiverDirection;