sip-connector 6.21.4 → 6.21.6

package/dist/__fixtures__/BaseSession.mock.d.ts

@@ -0,0 +1,91 @@
+import type { AnswerOptions, ExtraHeaders, HoldOptions, MediaConstraints, NameAddrHeader, OnHoldResult, RTCPeerConnectionDeprecated, RTCSession, ReferOptions, RenegotiateOptions, SessionDirection, SessionStatus, TerminateOptions, URI, C as constants } from '@krivega/jssip';
+import Events from 'events-constructor';
+import type { TEventSession } from '../eventNames';
+import { SESSION_EVENT_NAMES } from '../eventNames';
+/**
+ * BaseSession
+ * @class
+ */
+declare class BaseSession implements RTCSession {
+    originator: string;
+    _connection: RTCPeerConnectionDeprecated;
+    _events: Events<typeof SESSION_EVENT_NAMES>;
+    _remote_identity: NameAddrHeader;
+    _mutedOptions: {
+        audio: boolean;
+        video: boolean;
+    };
+    constructor({ originator, eventHandlers }: {
+        originator?: string | undefined;
+        eventHandlers: any;
+    });
+    get C(): SessionStatus;
+    get causes(): constants.causes;
+    get id(): string;
+    set data(_data: any);
+    get data(): any;
+    get connection(): RTCPeerConnectionDeprecated;
+    get contact(): string;
+    get direction(): SessionDirection;
+    get local_identity(): NameAddrHeader;
+    get remote_identity(): NameAddrHeader;
+    get start_time(): Date;
+    get end_time(): Date;
+    get status(): SessionStatus;
+    isInProgress(): boolean;
+    isEnded(): boolean;
+    isReadyToReOffer(): boolean;
+    answer(_options?: AnswerOptions): void;
+    terminate(_options?: TerminateOptions): void;
+    sendInfo(_contentType: string, _body?: string, _options?: ExtraHeaders): Promise<void>;
+    hold(_options?: HoldOptions, _done?: VoidFunction): boolean;
+    unhold(_options?: HoldOptions, _done?: VoidFunction): boolean;
+    renegotiate(_options?: RenegotiateOptions, _done?: VoidFunction): Promise<boolean>;
+    isOnHold(): OnHoldResult;
+    mute(_options?: MediaConstraints): void;
+    unmute(_options?: MediaConstraints): void;
+    isMuted(): MediaConstraints;
+    refer(_target: URI | string, _options?: ReferOptions): void;
+    resetLocalMedia(): void;
+    replaceMediaStream(_stream: MediaStream, _options?: {
+        deleteExisting: boolean;
+        addMissing: boolean;
+    }): Promise<void>;
+    addListener(_event: string | symbol, _listener: (...arguments_: any[]) => void): this;
+    once(_event: string | symbol, _listener: (...arguments_: any[]) => void): this;
+    removeListener(_event: string | symbol, _listener: (...arguments_: any[]) => void): this;
+    off(_event: string | symbol, _listener: (...arguments_: any[]) => void): this;
+    removeAllListeners(_event?: string | symbol): this;
+    setMaxListeners(_n: number): this;
+    getMaxListeners(): number;
+    listeners(_event: string | symbol): (() => void)[];
+    rawListeners(_event: string | symbol): (() => void)[];
+    emit(_event: string | symbol, ..._arguments_: any[]): boolean;
+    listenerCount(_event: string | symbol): number;
+    prependListener(_event: string | symbol, _listener: (...arguments_: any[]) => void): this;
+    prependOnceListener(_event: string | symbol, _listener: (...arguments_: any[]) => void): this;
+    eventNames(): (string | symbol)[];
+    /**
+     * initEvents
+     *
+     * @param {Array} [eventHandlers=[] - ]  The event handlers
+     *
+     * @returns {undefined}
+     */
+    initEvents(eventHandlers?: never[]): void;
+    on<T>(eventName: string, handler: (data: T) => void): this;
+    trigger(eventName: TEventSession, data?: any): void;
+    /**
+     * sendDTMF
+     *
+     * @param {object} options - options
+     *
+     * @returns {undefined}
+     */
+    sendDTMF(): void;
+    startPresentation(stream: MediaStream): Promise<MediaStream>;
+    updatePresentation(stream: MediaStream): Promise<MediaStream>;
+    stopPresentation(stream: MediaStream): Promise<MediaStream>;
+    isEstablished(): boolean;
+}
+export default BaseSession;

package/dist/__fixtures__/RTCPeerConnectionMock.d.ts

@@ -0,0 +1,58 @@
+import type { RTCPeerConnectionDeprecated } from '@krivega/jssip';
+import type { MediaStreamTrackMock } from 'webrtc-mock';
+declare class RTCPeerConnectionMock implements RTCPeerConnectionDeprecated {
+    _senders: RTCRtpSender[];
+    _receivers: any[];
+    constructor(_configuration?: RTCConfiguration, tracks: MediaStreamTrackMock[]);
+    canTrickleIceCandidates: boolean | null;
+    connectionState: RTCPeerConnectionState;
+    currentLocalDescription: RTCSessionDescription | null;
+    currentRemoteDescription: RTCSessionDescription | null;
+    iceConnectionState: RTCIceConnectionState;
+    iceGatheringState: RTCIceGatheringState;
+    idpErrorInfo: string | null;
+    idpLoginUrl: string | null;
+    localDescription: RTCSessionDescription | null;
+    onconnectionstatechange: ((this: RTCPeerConnection, event_: Event) => any) | null;
+    ondatachannel: ((this: RTCPeerConnection, event_: RTCDataChannelEvent) => any) | null;
+    onicecandidate: ((this: RTCPeerConnection, event_: RTCPeerConnectionIceEvent) => any) | null;
+    onicecandidateerror: ((this: RTCPeerConnection, event_: Event) => any) | null;
+    oniceconnectionstatechange: ((this: RTCPeerConnection, event_: Event) => any) | null;
+    onicegatheringstatechange: ((this: RTCPeerConnection, event_: Event) => any) | null;
+    onnegotiationneeded: ((this: RTCPeerConnection, event_: Event) => any) | null;
+    onsignalingstatechange: ((this: RTCPeerConnection, event_: Event) => any) | null;
+    ontrack: ((this: RTCPeerConnection, event_: RTCTrackEvent) => any) | null;
+    peerIdentity: undefined;
+    pendingLocalDescription: RTCSessionDescription | null;
+    pendingRemoteDescription: RTCSessionDescription | null;
+    remoteDescription: RTCSessionDescription | null;
+    sctp: null;
+    signalingState: RTCSignalingState;
+    getRemoteStreams(): MediaStream[];
+    addIceCandidate(_candidate: RTCIceCandidate | RTCIceCandidateInit): Promise<void>;
+    addTransceiver(_trackOrKind: MediaStreamTrack | string, _init?: RTCRtpTransceiverInit): RTCRtpTransceiver;
+    close(): void;
+    restartIce(): void;
+    createAnswer(options?: RTCAnswerOptions): Promise<RTCSessionDescriptionInit>;
+    createAnswer(successCallback: RTCSessionDescriptionCallback, failureCallback: RTCPeerConnectionErrorCallback): Promise<void>;
+    createDataChannel(_label: string, _dataChannelDict?: RTCDataChannelInit): RTCDataChannel;
+    createOffer(options?: RTCOfferOptions): Promise<RTCSessionDescriptionInit>;
+    createOffer(successCallback: RTCSessionDescriptionCallback, failureCallback: RTCPeerConnectionErrorCallback, options?: RTCOfferOptions): Promise<void>;
+    getConfiguration(): RTCConfiguration;
+    getIdentityAssertion(): Promise<string>;
+    getStats(_selector?: MediaStreamTrack | null): Promise<RTCStatsReport>;
+    getTransceivers(): RTCRtpTransceiver[];
+    removeTrack(_sender: RTCRtpSender): void;
+    setConfiguration(_configuration: RTCConfiguration): void;
+    setLocalDescription(_description: RTCSessionDescriptionInit): Promise<void>;
+    setRemoteDescription(_description: RTCSessionDescriptionInit): Promise<void>;
+    addEventListener<K extends keyof RTCPeerConnectionEventMap>(type: K, listener: (this: RTCPeerConnection, event_: RTCPeerConnectionEventMap[K]) => any, options?: AddEventListenerOptions | boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: AddEventListenerOptions | boolean): void;
+    removeEventListener<K extends keyof RTCPeerConnectionEventMap>(type: K, listener: (this: RTCPeerConnection, event_: RTCPeerConnectionEventMap[K]) => any, options?: EventListenerOptions | boolean): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: EventListenerOptions | boolean): void;
+    dispatchEvent(_event: Event): boolean;
+    getReceivers: () => any[];
+    getSenders: () => RTCRtpSender[];
+    addTrack: (track: MediaStreamTrack) => RTCRtpSender;
+}
+export default RTCPeerConnectionMock;

package/dist/__fixtures__/RTCRtpSenderMock.d.ts

@@ -0,0 +1,12 @@
+declare class RTCRtpSenderMock implements RTCRtpSender {
+    dtmf: RTCDTMFSender | null;
+    track: MediaStreamTrack | null;
+    transport: RTCDtlsTransport | null;
+    private _parameters;
+    getStats(): Promise<RTCStatsReport>;
+    replaceTrack(): Promise<void>;
+    setParameters(parameters: RTCRtpSendParameters): Promise<void>;
+    getParameters(): RTCRtpSendParameters;
+    setStreams(): void;
+}
+export default RTCRtpSenderMock;

package/dist/__fixtures__/Registrator.mock.d.ts

@@ -0,0 +1,7 @@
+import type { Registrator } from '@krivega/jssip';
+declare class RegistratorMock implements Registrator {
+    extraHeaders?: string[];
+    setExtraHeaders(extraHeaders: string[]): void;
+    setExtraContactParams(): void;
+}
+export default RegistratorMock;

package/dist/__fixtures__/Request.mock.d.ts

@@ -0,0 +1,8 @@
+import { IncomingRequest } from '@krivega/jssip/lib/SIPMessage';
+type TExtraHeaders = [string, string][];
+declare class Request extends IncomingRequest {
+    private readonly headers;
+    constructor(extraHeaders: TExtraHeaders);
+    getHeader(headerName: string): string;
+}
+export default Request;

package/dist/__fixtures__/Session.mock.d.ts

@@ -0,0 +1,67 @@
+/// <reference types="jest" />
+import type { IncomingInfoEvent } from '@krivega/jssip';
+import BaseSession from './BaseSession.mock';
+export declare const FAILED_CONFERENCE_NUMBER = "777";
+declare class Session extends BaseSession {
+    url: string;
+    status_code?: number;
+    private _isEnded;
+    constructor({ url, mediaStream, eventHandlers, originator, }: {
+        url?: string;
+        mediaStream?: any;
+        eventHandlers?: any;
+        originator: string;
+    });
+    initPeerconnection(mediaStream: any): boolean;
+    createPeerconnection(sendedStream: any): void;
+    connect(target: string): void;
+    /**
+       * answer
+       *
+       * @param {Object} arg1               - The argument 1
+       * @param {Object} arg1.mediaStream   - The media stream
+       * @param {Array}  arg1.eventHandlers - The event handlers
+  
+   * @returns {undefined}
+       */
+    answer: jest.Mock<void, [any], any>;
+    terminate({ status_code }?: {
+        status_code?: number;
+    }): this;
+    terminateRemote({ status_code }?: {
+        status_code?: number;
+    }): this;
+    _addStream(stream: Record<string, () => any[]>, action?: string): void;
+    _forEachSenders(callback: {
+        ({ track }: {
+            track: any;
+        }): void;
+        ({ track }: {
+            track: any;
+        }): void;
+        (argument0: any): void;
+    }): RTCRtpSender[];
+    _toggleMuteAudio(mute: boolean): void;
+    _toggleMuteVideo(mute: boolean): void;
+    mute(options: {
+        audio: any;
+        video: any;
+    }): void;
+    unmute(options: {
+        audio: any;
+        video: any;
+    }): void;
+    isMuted(): {
+        audio: boolean;
+        video: boolean;
+    };
+    replaceMediaStream(mediaStream: any): Promise<any>;
+    _onmute({ audio, video }: {
+        audio: boolean;
+        video: boolean;
+    }): void;
+    sendInfo(): Promise<void>;
+    isEnded(): boolean;
+    newInfo(data: IncomingInfoEvent): void;
+}
+export default Session;

package/dist/__fixtures__/UA.mock.d.ts

@@ -0,0 +1,80 @@
+/// <reference types="jest" />
+import type { UA as IUA, IncomingRequest, UAConfiguration } from '@krivega/jssip';
+import Events from 'events-constructor';
+import type { TEventUA } from '../eventNames';
+import { UA_EVENT_NAMES } from '../eventNames';
+import Registrator from './Registrator.mock';
+import Session from './Session.mock';
+export declare const PASSWORD_CORRECT = "PASSWORD_CORRECT";
+export declare const PASSWORD_CORRECT_2 = "PASSWORD_CORRECT_2";
+export declare const NAME_INCORRECT = "NAME_INCORRECT";
+declare class UA implements IUA {
+    _events: Events<typeof UA_EVENT_NAMES>;
+    _startedTimeout?: ReturnType<typeof setTimeout>;
+    _stopedTimeout?: ReturnType<typeof setTimeout>;
+    session?: Session;
+    _isRegistered?: boolean;
+    _isConnected?: boolean;
+    configuration: UAConfiguration;
+    _registrator: Registrator;
+    constructor(configuration: UAConfiguration);
+    /**
+     * start
+     *
+     * @returns {undefined}
+     */
+    start(): void;
+    /**
+     * stop
+     *
+     * @returns {undefined}
+     */
+    stop(): void;
+    call: jest.Mock<Session, [url: string, parameters: any], any>;
+    on(eventName: TEventUA, handler: any): this;
+    trigger(eventName: TEventUA, data?: any): void;
+    /**
+     * terminateSessions
+     *
+     * @returns {undefined}
+     */
+    terminateSessions(): void;
+    /**
+     * set
+     *
+     * @param {string} key   - key
+     * @param {string} value - value
+     *
+     * @returns {boolean} true
+     */
+    set(key: string, value: any): boolean;
+    /**
+     * register
+     *
+     * @returns {undefined}
+     */
+    register(): void;
+    /**
+     * unregister
+     *
+     * @returns {undefined}
+     */
+    unregister(): void;
+    /**
+     * isRegistered
+     *
+     * @returns {boolean} isRegistered
+     */
+    isRegistered(): boolean;
+    /**
+     * isStarted
+     *
+     * @returns {boolean} isStarted
+     */
+    isStarted(): boolean;
+    registrator(): Registrator;
+    newSipEvent(data: {
+        request: IncomingRequest;
+    }): void;
+}
+export default UA;

package/dist/__fixtures__/WebSocketInterface.mock.d.ts

@@ -0,0 +1,5 @@
+declare class WebSocketInterface {
+    url: string;
+    constructor(url: string);
+}
+export default WebSocketInterface;

package/dist/__fixtures__/accountNotify.d.ts

@@ -0,0 +1,2 @@
+export declare const accountChangedHeaders: [string, string][];
+export declare const accountDeletedHeaders: [string, string][];

package/dist/__fixtures__/channels.d.ts

@@ -0,0 +1,8 @@
+export declare const channelsHeaders: [string, string][];
+export declare const channelsData: {
+    inputChannels: string;
+    outputChannels: string;
+};
+export declare const sendedExtraHeaders: {
+    extraHeaders: string[];
+};

package/dist/__fixtures__/channelsNotify.d.ts

@@ -0,0 +1,5 @@
+export declare const channelsHeaders: [string, string][];
+export declare const channelsData: {
+    inputChannels: any;
+    outputChannels: any;
+};

package/dist/__fixtures__/conferenceParticipantTokenIssuedNotify.d.ts

@@ -0,0 +1,6 @@
+export declare const conferenceParticipantTokenIssuedHeaders: [string, string][];
+export declare const conferenceParticipantTokenIssuedData: {
+    conference: string;
+    participant: string;
+    jwt: string;
+};

package/dist/__fixtures__/delayPromise.d.ts

@@ -0,0 +1,2 @@
+declare const delayPromise: (timeout: number) => Promise<void>;
+export default delayPromise;

package/dist/__fixtures__/index.d.ts

@@ -0,0 +1,83 @@
+export declare const user = "user";
+export declare const displayName = "displayName";
+export declare const SIP_SERVER_URL = "SIP_SERVER_URL";
+export declare const SIP_WEB_SOCKET_SERVER_URL = "SIP_WEB_SOCKET_SERVER_URL";
+export declare const dataForConnectionWithoutAuthorizationWithoutDisplayName: {
+    userAgent: string;
+    sipServerUrl: string;
+    sipWebSocketServerURL: string;
+};
+export declare const dataForConnectionWithAuthorization: {
+    user: string;
+    password: string;
+    register: boolean;
+    userAgent: string;
+    sipServerUrl: string;
+    sipWebSocketServerURL: string;
+};
+export declare const dataForConnectionWithAuthorizationWithDisplayName: {
+    displayName: string;
+    user: string;
+    password: string;
+    register: boolean;
+    userAgent: string;
+    sipServerUrl: string;
+    sipWebSocketServerURL: string;
+};
+export declare const dataForConnectionWithoutAuthorization: {
+    displayName: string;
+    register: boolean;
+    userAgent: string;
+    sipServerUrl: string;
+    sipWebSocketServerURL: string;
+};
+export declare const uaConfigurationWithAuthorization: {
+    password: string;
+    uri: string;
+    display_name: string;
+    register: boolean;
+    session_timers: boolean;
+    sockets: import("./WebSocketInterface.mock").default[];
+    user_agent: string;
+    sdp_semantics: string;
+    register_expires: number;
+    connection_recovery_max_interval: number;
+    connection_recovery_min_interval: number;
+};
+export declare const uaConfigurationWithAuthorizationWithDisplayName: {
+    password: string;
+    uri: string;
+    display_name: string;
+    register: boolean;
+    session_timers: boolean;
+    sockets: import("./WebSocketInterface.mock").default[];
+    user_agent: string;
+    sdp_semantics: string;
+    register_expires: number;
+    connection_recovery_max_interval: number;
+    connection_recovery_min_interval: number;
+};
+export declare const uaConfigurationWithoutAuthorization: {
+    display_name: string;
+    register: boolean;
+    session_timers: boolean;
+    sockets: import("./WebSocketInterface.mock").default[];
+    user_agent: string;
+    sdp_semantics: string;
+    register_expires: number;
+    connection_recovery_max_interval: number;
+    connection_recovery_min_interval: number;
+};
+export declare const uaConfigurationWithoutAuthorizationWithoutDisplayName: {
+    display_name: string;
+    register: boolean;
+    session_timers: boolean;
+    sockets: import("./WebSocketInterface.mock").default[];
+    user_agent: string;
+    sdp_semantics: string;
+    register_expires: number;
+    connection_recovery_max_interval: number;
+    connection_recovery_min_interval: number;
+};
+export declare const remoteAddress = "10.10.10.10";
+export declare const extraHeadersRemoteAddress: string[];

package/dist/__fixtures__/jssip.mock.d.ts

@@ -0,0 +1,29 @@
+import type { RTCSession, UA } from '@krivega/jssip';
+import UAmock from './UA.mock';
+import WebSocketInterfaceMock from './WebSocketInterface.mock';
+declare const jssip: {
+    triggerNewInfo: (session: RTCSession, extraHeaders: [
+        string,
+        string
+    ][]) => void;
+    triggerNewSipEvent: (ua: UA, extraHeaders: [
+        string,
+        string
+    ][]) => void;
+    triggerIncomingSession: (ua: UAmock, { incomingNumber, displayName, host, }: {
+        incomingNumber?: string | undefined;
+        displayName: string;
+        host: string;
+    }) => void;
+    triggerFailIncomingSession: (incomingSession: unknown, options?: {
+        originator: 'local' | 'remote';
+    }) => void;
+    WebSocketInterface: typeof WebSocketInterfaceMock;
+    UA: typeof UAmock;
+    C: {
+        INVITE: string;
+    };
+};
+export default jssip;
+export { NAME_INCORRECT, PASSWORD_CORRECT, PASSWORD_CORRECT_2 } from './UA.mock';
+export { FAILED_CONFERENCE_NUMBER } from './Session.mock';

package/dist/__fixtures__/mediaState.d.ts

@@ -0,0 +1,7 @@
+export declare const mediaStateData: {
+    cam: boolean;
+    mic: boolean;
+};
+export declare const extraHeaders: {
+    extraHeaders: string[];
+};

package/dist/__fixtures__/participantMoveRequests.d.ts

@@ -0,0 +1,12 @@
+export declare const moveRequestToConferenceHeaders: [string, string][];
+export declare const moveRequestToConferenceData: {
+    conference: string;
+};
+export declare const cancelingWordRequestHeaders: [string, string][];
+export declare const cancelingWordRequestData: {
+    conference: string;
+};
+export declare const moveRequestToStreamHeaders: [string, string][];
+export declare const moveRequestToStreamData: {
+    conference: string;
+};

package/dist/__fixtures__/participantNotify.d.ts

@@ -0,0 +1,8 @@
+export declare const removedFromListModeratorsHeaders: [string, string][];
+export declare const removedFromListModeratorsData: {
+    conference: any;
+};
+export declare const addedToListModeratorsHeaders: [string, string][];
+export declare const addedToListModeratorsData: {
+    conference: any;
+};

package/dist/__fixtures__/remoteCallerData.d.ts

@@ -0,0 +1,7 @@
+declare const remoteCallerData: {
+    displayName: string;
+    host: string;
+    user: string;
+    incomingNumber: string;
+};
+export default remoteCallerData;

package/dist/__fixtures__/utils.d.ts

@@ -0,0 +1 @@
+export declare function getRoomFromSipUrl(sipUrl: string): string;

package/dist/__fixtures__/webcastNotify.d.ts

@@ -0,0 +1,10 @@
+export declare const webcastStartedHeaders: [string, string][];
+export declare const webcastStartedData: {
+    conference: string;
+    type: string;
+};
+export declare const webcastStoppedHeaders: [string, string][];
+export declare const webcastStoppedData: {
+    conference: string;
+    type: string;
+};

package/dist/tools/__fixtures__/call.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="jest" />
+import RTCPeerConnectionMock from '../../__fixtures__/RTCPeerConnectionMock';
+declare const data: {
+    mediaStream: import("webrtc-mock/dist/MediaStreamMock").default;
+    conference: string;
+    setOutgoingCall: jest.Mock<any, any, any>;
+    setRemoteStreams: jest.Mock<any, any, any>;
+};
+export default data;
+export declare const peerConnectionFromData: RTCPeerConnectionMock;

package/dist/tools/__fixtures__/connectToServer.d.ts

@@ -0,0 +1,129 @@
+export declare const LOCKED_SIP_WEB_SOCKET_SERVER_URL = "LOCKED_SIP_WEB_SOCKET_SERVER_URL";
+export declare const dataForConnectionWithAuthorization: {
+    password: string;
+    name: string;
+    isRegisteredUser: boolean;
+    remoteAddress: string;
+    sipServerUrl: string;
+    sipWebSocketServerURL: string;
+    sdpSemantics: "plan-b";
+    userAgent: string;
+};
+export declare const dataForConnectionWithAuthorizationWithDisplayName: {
+    displayName: string;
+    remoteAddress: string;
+    sipServerUrl: string;
+    sipWebSocketServerURL: string;
+    sdpSemantics: "plan-b";
+    userAgent: string;
+};
+export declare const dataForConnectionWithoutAuthorization: {
+    displayName: string;
+    isRegisteredUser: boolean;
+    remoteAddress: string;
+    sipServerUrl: string;
+    sipWebSocketServerURL: string;
+    sdpSemantics: "plan-b";
+    userAgent: string;
+};
+export declare const dataForConnectionWithoutAuthorizationWithoutDisplayName: {
+    displayName: string;
+    isRegisteredUser: boolean;
+    remoteAddress: string;
+    sipServerUrl: string;
+    sipWebSocketServerURL: string;
+    sdpSemantics: "plan-b";
+    userAgent: string;
+};
+export declare const dataForConnectionWithoutAuthorizationWithSipServerUrlChanged: {
+    sipServerUrl: string;
+    displayName: string;
+    isRegisteredUser: boolean;
+    remoteAddress: string;
+    sipWebSocketServerURL: string;
+    sdpSemantics: "plan-b";
+    userAgent: string;
+};
+export declare const dataForConnectionWithoutAuthorizationWithSipWebSocketServerUrlChanged: {
+    sipWebSocketServerURL: string;
+    sipWebSocketServerURLChanged: boolean;
+    displayName: string;
+    isRegisteredUser: boolean;
+    remoteAddress: string;
+    sipServerUrl: string;
+    sdpSemantics: "plan-b";
+    userAgent: string;
+};
+export declare const dataForConnectionWithAuthorizationIncorrectUser: {
+    name: string;
+    password: string;
+    isRegisteredUser: boolean;
+    remoteAddress: string;
+    sipServerUrl: string;
+    sipWebSocketServerURL: string;
+    sdpSemantics: "plan-b";
+    userAgent: string;
+};
+export declare const dataForConnectionWithAuthorizationIncorrectPassword: {
+    password: string;
+    name: string;
+    isRegisteredUser: boolean;
+    remoteAddress: string;
+    sipServerUrl: string;
+    sipWebSocketServerURL: string;
+    sdpSemantics: "plan-b";
+    userAgent: string;
+};
+export declare const withNameChanged: {
+    nameChanged: boolean;
+    password: string;
+    name: string;
+    isRegisteredUser: boolean;
+    remoteAddress: string;
+    sipServerUrl: string;
+    sipWebSocketServerURL: string;
+    sdpSemantics: "plan-b";
+    userAgent: string;
+};
+export declare const dataForConnectionWithAuthorizationPasswordChanged: {
+    password: string;
+    passwordChanged: boolean;
+    name: string;
+    isRegisteredUser: boolean;
+    remoteAddress: string;
+    sipServerUrl: string;
+    sipWebSocketServerURL: string;
+    sdpSemantics: "plan-b";
+    userAgent: string;
+};
+export declare const uaConfigurationWithAuthorization: {
+    password: string;
+    uri: string;
+    display_name: string;
+    register: boolean;
+    session_timers: boolean;
+    sockets: import("../../__fixtures__/WebSocketInterface.mock").default[];
+    user_agent: string;
+    sdp_semantics: string;
+    register_expires: number;
+    connection_recovery_max_interval: number;
+    connection_recovery_min_interval: number;
+};
+export declare const uaConfigurationWithAuthorizationPasswordChanged: {
+    password: string;
+    uri: string;
+    display_name: string;
+    register: boolean;
+    session_timers: boolean;
+    sockets: import("../../__fixtures__/WebSocketInterface.mock").default[];
+    user_agent: string;
+    sdp_semantics: string;
+    register_expires: number;
+    connection_recovery_max_interval: number;
+    connection_recovery_min_interval: number;
+};
+export declare const oneWord = "a";
+export declare const twoWord = "ab";
+export declare const thirdWord = "abc";
+export declare const uriWithName: (name: string) => string;
+export { uaConfigurationWithoutAuthorization, uaConfigurationWithoutAuthorizationWithoutDisplayName, } from '../../__fixtures__';

package/dist/tools/__fixtures__/hasValidUri.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Determines if it has valid uri.
+ *
+ * @param      {string}   uri     The uri for check
+ * @param      {string}   url     The  base url
+ * @returns     {boolean}  True if has valid uri, False otherwise.
+ */
+declare const hasValidUri: (uri: string, url?: string) => boolean;
+export default hasValidUri;

package/dist/tools/__fixtures__/permissions.d.ts

@@ -0,0 +1,8 @@
+export declare const canConnectToServer: ({ remoteAddress, sipServerUrl, sipWebSocketServerURL, name, password, isRegisteredUser, }: {
+    remoteAddress: string | undefined;
+    sipServerUrl: string | undefined;
+    sipWebSocketServerURL: string | undefined;
+    name: string;
+    password: string;
+    isRegisteredUser: boolean;
+}) => boolean;

package/dist/tools/__fixtures__/processRequest.d.ts

@@ -0,0 +1,11 @@
+import type SipConnector from '../../SipConnector';
+declare const resolveInitUaPromised: (sipConnector: SipConnector) => (state: {
+    remoteAddress: string | undefined;
+    sipServerUrl: string;
+    displayName: string | undefined;
+    sipWebSocketServerURL: string;
+    name: string;
+    password: string;
+    isRegisteredUser: boolean;
+}) => Promise<unknown>;
+export default resolveInitUaPromised;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sip-connector",
-  "version": "6.21.4",
+  "version": "6.21.6",
   "description": "Module for connect to Vinteo server",
   "keywords": [
     "webrtc",
@@ -53,9 +53,9 @@
     "prepare": "husky install",
     "prepublishOnly": "yarn build",
     "preview": "vite preview",
-    "release": "standard-version && npm release:publish",
-    "release:major": "standard-version --release-as major && npm release:publish",
-    "release:pre": "standard-version --prerelease && npm release:publish",
+    "release": "standard-version && npm run release:publish",
+    "release:major": "standard-version --release-as major && npm run release:publish",
+    "release:pre": "standard-version --prerelease && npm run release:publish",
     "release:publish": "git push --follow-tags origin master && npm publish --access=public",
     "test": "jest --watch",
     "test:ci": "cross-env CI=true jest --passWithNoTests",
@@ -69,7 +69,7 @@
     "sequent-promises": "^1.0.0",
     "stack-promises": "^1.0.1",
     "ts-debounce": "^4.0.0",
-    "webrtc-mock": "^1.0.0"
+    "webrtc-mock": "^1.0.1"
   },
   "devDependencies": {
     "@babel/preset-typescript": "^7.23.2",