sip-connector 14.1.0-alpha.9 → 14.1.1

package/dist/ConnectionManager/ConnectionFlow.d.ts

@@ -1,84 +0,0 @@
-import { UA, WebSocketInterface } from '@krivega/jssip';
-import { default as Events } from 'events-constructor';
-import { TGetServerUrl } from '../CallManager';
-import { TJsSIP } from '../types';
-import { default as ConnectionStateMachine } from './ConnectionStateMachine';
-import { EVENT_NAMES } from './eventNames';
-import { default as RegistrationManager } from './RegistrationManager';
-import { default as UAFactory } from './UAFactory';
-export type TOptionsExtraHeaders = {
-    extraHeaders?: string[];
-};
-export 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;
-};
-export type TConnect = (parameters: TParametersConnection, options?: {
-    callLimit?: number;
-}) => Promise<UA>;
-export type TSet = (parameters: {
-    displayName?: string;
-}) => Promise<boolean>;
-interface IDependencies {
-    JsSIP: TJsSIP;
-    events: Events<typeof EVENT_NAMES>;
-    uaFactory: UAFactory;
-    stateMachine: ConnectionStateMachine;
-    registrationManager: RegistrationManager;
-    getUa: () => UA | undefined;
-    setUa: (ua: UA | undefined) => void;
-    getConnectionConfiguration: () => {
-        sipServerUrl?: string;
-        displayName?: string;
-        register?: boolean;
-        user?: string;
-        password?: string;
-    };
-    setConnectionConfiguration: (config: {
-        sipServerUrl?: string;
-        displayName?: string;
-        register?: boolean;
-        user?: string;
-        password?: string;
-    }) => void;
-    updateConnectionConfiguration: (key: 'displayName', value: string) => void;
-    setSipServerUrl: (getSipServerUrl: TGetServerUrl) => void;
-    setSocket: (socket: WebSocketInterface) => void;
-}
-export default class ConnectionFlow {
-    private cancelableConnectWithRepeatedCalls;
-    private readonly JsSIP;
-    private readonly events;
-    private readonly uaFactory;
-    private readonly stateMachine;
-    private readonly registrationManager;
-    private readonly getUa;
-    private readonly setUa;
-    private readonly getConnectionConfiguration;
-    private readonly setConnectionConfiguration;
-    private readonly updateConnectionConfiguration;
-    private readonly setSipServerUrl;
-    private readonly setSocket;
-    constructor(dependencies: IDependencies);
-    connect: TConnect;
-    set: TSet;
-    disconnect: () => Promise<void>;
-    cancelRequests(): void;
-    private readonly connectWithDuplicatedCalls;
-    private hasEqualConnectionConfiguration;
-    private readonly connectInner;
-    private readonly initUa;
-    private readonly start;
-    private cancelConnectWithRepeatedCalls;
-}
-export {};

package/dist/ConnectionManager/ConnectionStateMachine.d.ts

@@ -1,61 +0,0 @@
-import { default as Events } from 'events-constructor';
-import { EVENT_NAMES } from './eventNames';
-export declare enum EEvents {
-    START_CONNECT = "START_CONNECT",
-    START_INIT_UA = "START_INIT_UA",
-    UA_CONNECTED = "UA_CONNECTED",
-    UA_REGISTERED = "UA_REGISTERED",
-    UA_UNREGISTERED = "UA_UNREGISTERED",
-    UA_DISCONNECTED = "UA_DISCONNECTED",
-    CONNECTION_FAILED = "CONNECTION_FAILED",
-    RESET = "RESET"
-}
-type TConnectionMachineEvent = `${EEvents}`;
-export declare enum EState {
-    IDLE = "idle",
-    CONNECTING = "connecting",
-    INITIALIZING = "initializing",
-    CONNECTED = "connected",
-    REGISTERED = "registered",
-    DISCONNECTED = "disconnected",
-    FAILED = "failed"
-}
-export default class ConnectionStateMachine {
-    private readonly actor;
-    private readonly stateChangeListeners;
-    private readonly events;
-    private unsubscribeFromEvents?;
-    private readonly actorSubscription?;
-    constructor(events: Events<typeof EVENT_NAMES>);
-    get state(): EState;
-    get isIdle(): boolean;
-    get isConnecting(): boolean;
-    get isInitializing(): boolean;
-    get isConnected(): boolean;
-    get isRegistered(): boolean;
-    get isDisconnected(): boolean;
-    get isFailed(): boolean;
-    get isPending(): boolean;
-    get isPendingConnect(): boolean;
-    get isPendingInitUa(): boolean;
-    get isActiveConnection(): boolean;
-    startConnect(): void;
-    startInitUa(): void;
-    reset(): void;
-    destroy(): void;
-    onStateChange(listener: (state: EState) => void): () => void;
-    canTransition(event: TConnectionMachineEvent): boolean;
-    getValidEvents(): TConnectionMachineEvent[];
-    private hasState;
-    private sendEvent;
-    private readonly toStartConnect;
-    private readonly toStartInitUa;
-    private readonly toConnected;
-    private readonly toRegistered;
-    private readonly toUnregistered;
-    private readonly toDisconnected;
-    private readonly toFailed;
-    private readonly toIdle;
-    private subscribeToEvents;
-}
-export {};

package/dist/ConnectionManager/RegistrationManager.d.ts

@@ -1,17 +0,0 @@
-import { RegisteredEvent, UA, UnRegisteredEvent } from '@krivega/jssip';
-import { default as Events } from 'events-constructor';
-import { EVENT_NAMES } from './eventNames';
-interface IDependencies {
-    events: Events<typeof EVENT_NAMES>;
-    getUaProtected: () => UA;
-}
-export default class RegistrationManager {
-    private readonly events;
-    private readonly getUaProtected;
-    constructor(dependencies: IDependencies);
-    register(): Promise<RegisteredEvent>;
-    unregister(): Promise<UnRegisteredEvent>;
-    tryRegister(): Promise<RegisteredEvent>;
-    subscribeToStartEvents(onSuccess: () => void, onError: (error: Error) => void): () => void;
-}
-export {};

package/dist/ConnectionManager/SipOperations.d.ts

@@ -1,32 +0,0 @@
-import { UA, URI } from '@krivega/jssip';
-import { default as UAFactory } from './UAFactory';
-export type TParametersCheckTelephony = {
-    displayName: string;
-    sipServerUrl: string;
-    sipWebSocketServerURL: string;
-    userAgent?: string;
-    remoteAddress?: string;
-    extraHeaders?: string[];
-};
-interface IDependencies {
-    uaFactory: UAFactory;
-    getUaProtected: () => UA;
-}
-export default class SipOperations {
-    private readonly uaFactory;
-    private readonly getUaProtected;
-    constructor(dependencies: IDependencies);
-    /**
-     * Отправляет SIP OPTIONS запрос к указанному адресу
-     */
-    sendOptions(target: URI | string, body?: string, extraHeaders?: string[]): Promise<void>;
-    /**
-     * Отправляет SIP OPTIONS запрос к собственному URI (ping)
-     */
-    ping(body?: string, extraHeaders?: string[]): Promise<void>;
-    /**
-     * Проверяет доступность телефонии, создавая временное соединение
-     */
-    checkTelephony({ userAgent, displayName, sipServerUrl, sipWebSocketServerURL, remoteAddress, extraHeaders, }: TParametersCheckTelephony): Promise<void>;
-}
-export {};

package/dist/ConnectionManager/UAFactory.d.ts

@@ -1,50 +0,0 @@
-import { UA, UAConfigurationParams, WebSocketInterface } from '@krivega/jssip';
-import { TJsSIP } from '../types';
-export type TUAConfiguration = {
-    configuration: UAConfigurationParams;
-    helpers: {
-        socket: WebSocketInterface;
-        getSipServerUrl: (id: string) => string;
-    };
-};
-export type TCreateUAParameters = UAConfigurationParams & {
-    remoteAddress?: string;
-    extraHeaders?: string[];
-};
-type TParametersCreateUaConfiguration = {
-    sipWebSocketServerURL: string;
-    displayName?: string;
-    sipServerUrl: string;
-    user?: string;
-    register?: boolean;
-    password?: string;
-    sessionTimers?: boolean;
-    registerExpires?: number;
-    connectionRecoveryMinInterval?: number;
-    connectionRecoveryMaxInterval?: number;
-    userAgent?: string;
-};
-export default class UAFactory {
-    private readonly JsSIP;
-    constructor(JsSIP: TJsSIP);
-    static isRegisteredUA(ua?: UA): boolean;
-    private static validateConfiguration;
-    private static resolveAuthorizationUser;
-    private static buildExtraHeaders;
-    createConfiguration({ user, password, sipWebSocketServerURL, displayName, sipServerUrl, register, sessionTimers, registerExpires, // 5 minutes in sec
-    connectionRecoveryMinInterval, connectionRecoveryMaxInterval, userAgent, }: TParametersCreateUaConfiguration): TUAConfiguration;
-    createUA({ remoteAddress, extraHeaders, ...parameters }: TCreateUAParameters): UA;
-    /**
-     * Создает UA с полным жизненным циклом - конфигурация + создание + настройка событий
-     */
-    createUAWithConfiguration(parameters: TParametersCreateUaConfiguration & {
-        remoteAddress?: string;
-        extraHeaders?: string[];
-    }, events: {
-        eachTriggers: (callback: (trigger: (...args: unknown[]) => void, eventName: string) => void) => void;
-    }): {
-        ua: UA;
-        helpers: TUAConfiguration['helpers'];
-    };
-}
-export {};

package/dist/ConnectionManager/eventNames.d.ts

@@ -1,16 +0,0 @@
-import { default as Events } from 'events-constructor';
-export declare enum EEvent {
-    CONNECTING = "connecting",
-    CONNECTED = "connected",
-    DISCONNECTED = "disconnected",
-    NEW_RTC_SESSION = "newRTCSession",
-    REGISTERED = "registered",
-    UNREGISTERED = "unregistered",
-    REGISTRATION_FAILED = "registrationFailed",
-    NEW_MESSAGE = "newMessage",
-    SIP_EVENT = "sipEvent"
-}
-export declare const UA_EVENT_NAMES: readonly ["connecting", "connected", "disconnected", "newRTCSession", "registered", "unregistered", "registrationFailed", "newMessage", "sipEvent"];
-export declare const EVENT_NAMES: ("connecting" | "connected" | "disconnected" | "newRTCSession" | "registered" | "unregistered" | "registrationFailed" | "newMessage" | "sipEvent")[];
-export type TEvent = (typeof EVENT_NAMES)[number];
-export type TEvents = Events<typeof EVENT_NAMES>;

package/dist/ConnectionManager/index.d.ts

@@ -1,3 +0,0 @@
-export { default as ConnectionManager } from './@ConnectionManager';
-export { EVENT_NAMES as CONNECTION_MANAGER_EVENT_NAMES, EEvent as EConnectionManagerEvent, } from './eventNames';
-export type { TEvent as TConnectionManagerEvent, TEvents as TConnectionManagerEvents, } from './eventNames';

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

@@ -1,37 +0,0 @@
-import { RTCSession } from '@krivega/jssip';
-import { default as Events } from 'events-constructor';
-import { ConnectionManager } from '../ConnectionManager';
-import { TEvent, EVENT_NAMES } from './eventNames';
-type TRemoteCallerData = {
-    displayName?: string;
-    host?: string;
-    incomingNumber?: string;
-    rtcSession?: RTCSession;
-};
-export default class IncomingCallManager {
-    readonly events: Events<typeof EVENT_NAMES>;
-    private incomingRTCSession?;
-    private readonly connectionManager;
-    constructor(connectionManager: ConnectionManager);
-    get remoteCallerData(): TRemoteCallerData;
-    get isAvailableIncomingCall(): boolean;
-    start(): void;
-    stop(): void;
-    getIncomingRTCSession: () => RTCSession;
-    extractIncomingRTCSession: () => RTCSession;
-    declineToIncomingCall({ statusCode, }?: {
-        statusCode?: number;
-    }): Promise<void>;
-    busyIncomingCall(): Promise<void>;
-    on<T>(eventName: TEvent, handler: (data: T) => void): () => void;
-    once<T>(eventName: TEvent, handler: (data: T) => void): () => void;
-    onceRace<T>(eventNames: TEvent[], handler: (data: T, eventName: string) => void): () => void;
-    wait<T>(eventName: TEvent): Promise<T>;
-    off<T>(eventName: TEvent, handler: (data: T) => void): void;
-    private subscribe;
-    private unsubscribe;
-    private readonly handleNewRTCSession;
-    private setIncomingSession;
-    private removeIncomingSession;
-}
-export {};

package/dist/IncomingCallManager/eventNames.d.ts

@@ -1,13 +0,0 @@
-export declare enum EEvent {
-    INCOMING_CALL = "incomingCall",
-    DECLINED_INCOMING_CALL = "declinedIncomingCall",
-    TERMINATED_INCOMING_CALL = "terminatedIncomingCall",
-    FAILED_INCOMING_CALL = "failedIncomingCall"
-}
-export declare enum Originator {
-    LOCAL = "local",
-    REMOTE = "remote",
-    SYSTEM = "system"
-}
-export declare const EVENT_NAMES: readonly ["incomingCall", "declinedIncomingCall", "terminatedIncomingCall", "failedIncomingCall"];
-export type TEvent = (typeof EVENT_NAMES)[number];

package/dist/IncomingCallManager/index.d.ts

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

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

@@ -1,47 +0,0 @@
-import { CallManager } from '../CallManager';
-import { TEvent, TEvents } from './eventNames';
-import { TContentHint, TOnAddedTransceiver } from './types';
-export declare const hasCanceledStartPresentationError: (error: unknown) => error is import('repeated-calls').TCanceledError<unknown>;
-declare class PresentationManager {
-    readonly events: TEvents;
-    promisePendingStartPresentation?: Promise<MediaStream>;
-    promisePendingStopPresentation?: Promise<MediaStream | undefined>;
-    streamPresentationCurrent?: MediaStream;
-    private cancelableSendPresentationWithRepeatedCalls;
-    private readonly callManager;
-    constructor({ callManager }: {
-        callManager: CallManager;
-    });
-    get isPendingPresentation(): boolean;
-    startPresentation(beforeStartPresentation: () => Promise<void>, stream: MediaStream, { isNeedReinvite, maxBitrate, contentHint, sendEncodings, onAddedTransceiver, }?: {
-        isNeedReinvite?: boolean;
-        maxBitrate?: number;
-        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>(eventName: TEvent, handler: (data: T) => void): () => void;
-    once<T>(eventName: TEvent, handler: (data: T) => void): () => void;
-    onceRace<T>(eventNames: TEvent[], handler: (data: T, eventName: string) => void): () => void;
-    wait<T>(eventName: TEvent): Promise<T>;
-    off<T>(eventName: TEvent, handler: (data: T) => void): void;
-    private subscribe;
-    private sendPresentationWithDuplicatedCalls;
-    private sendPresentation;
-    private readonly getRtcSessionProtected;
-    private readonly handleEnded;
-    private reset;
-    private resetPresentation;
-    private removeStreamPresentationCurrent;
-}
-export default PresentationManager;

package/dist/PresentationManager/constants.d.ts

@@ -1 +0,0 @@
-export declare const ONE_MEGABIT_IN_BITS = 1000000;

package/dist/PresentationManager/eventNames.d.ts

@@ -1,11 +0,0 @@
-import { default as Events } from 'events-constructor';
-export declare enum EEvent {
-    START_PRESENTATION = "presentation:start",
-    STARTED_PRESENTATION = "presentation:started",
-    END_PRESENTATION = "presentation:end",
-    ENDED_PRESENTATION = "presentation:ended",
-    FAILED_PRESENTATION = "presentation:failed"
-}
-export declare const EVENT_NAMES: readonly ["presentation:start", "presentation:started", "presentation:end", "presentation:ended", "presentation:failed"];
-export type TEvent = (typeof EVENT_NAMES)[number];
-export type TEvents = Events<typeof EVENT_NAMES>;

package/dist/PresentationManager/index.d.ts

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

package/dist/PresentationManager/types.d.ts

@@ -1,2 +0,0 @@
-export type TOnAddedTransceiver = (transceiver: RTCRtpTransceiver, track: MediaStreamTrack, stream: MediaStream) => Promise<void>;
-export type TContentHint = 'motion' | 'detail' | 'text' | 'none';

package/dist/SipConnector/@SipConnector.d.ts

@@ -1,96 +0,0 @@
-import { default as Events } from 'events-constructor';
-import { ApiManager } from '../ApiManager';
-import { TGetServerUrl, CallManager } from '../CallManager';
-import { ConnectionManager } from '../ConnectionManager';
-import { IncomingCallManager } from '../IncomingCallManager';
-import { PresentationManager } from '../PresentationManager';
-import { TContentHint, TOnAddedTransceiver } from '../PresentationManager/types';
-import { TJsSIP } from '../types';
-import { TEvent, EVENT_NAMES } from './eventNames';
-declare class SipConnector {
-    readonly events: Events<typeof EVENT_NAMES>;
-    readonly connectionManager: ConnectionManager;
-    readonly callManager: CallManager;
-    readonly apiManager: ApiManager;
-    readonly incomingCallManager: IncomingCallManager;
-    readonly presentationManager: PresentationManager;
-    constructor({ JsSIP }: {
-        JsSIP: TJsSIP;
-    });
-    get requestedConnection(): boolean;
-    get isPendingConnect(): boolean;
-    get isPendingInitUa(): boolean;
-    get connectionState(): import('../ConnectionManager/ConnectionStateMachine').EState;
-    get isRegistered(): boolean;
-    get isRegisterConfig(): boolean;
-    get socket(): import('@krivega/jssip').WebSocketInterface | undefined;
-    get requestedCall(): boolean;
-    get connection(): RTCPeerConnection | undefined;
-    get establishedRTCSession(): import('@krivega/jssip').RTCSession | undefined;
-    get isCallActive(): boolean;
-    get remoteCallerData(): IncomingCallManager['remoteCallerData'];
-    get isAvailableIncomingCall(): IncomingCallManager['isAvailableIncomingCall'];
-    on<T>(eventName: TEvent, handler: (data: T) => void): () => void;
-    once<T>(eventName: TEvent, handler: (data: T) => void): () => void;
-    onceRace<T>(eventNames: TEvent[], handler: (data: T, eventName: string) => void): () => void;
-    wait<T>(eventName: TEvent): Promise<T>;
-    off<T>(eventName: TEvent, handler: (data: T) => void): void;
-    connect: ConnectionManager['connect'];
-    set: ConnectionManager['set'];
-    disconnect: () => Promise<void>;
-    register: () => Promise<import('@krivega/jssip').RegisteredEvent>;
-    unregister: () => Promise<import('@krivega/jssip').UnRegisteredEvent>;
-    tryRegister: () => Promise<import('@krivega/jssip').RegisteredEvent>;
-    sendOptions: (target: Parameters<ConnectionManager["sendOptions"]>[0], body?: Parameters<ConnectionManager["sendOptions"]>[1], extraHeaders?: Parameters<ConnectionManager["sendOptions"]>[2]) => Promise<void>;
-    ping: (body?: Parameters<ConnectionManager["ping"]>[0], extraHeaders?: Parameters<ConnectionManager["ping"]>[1]) => Promise<void>;
-    checkTelephony: ConnectionManager['checkTelephony'];
-    isConfigured: () => boolean;
-    getConnectionConfiguration: () => import('../ConnectionManager/ConfigurationManager').IConnectionConfiguration;
-    getSipServerUrl: TGetServerUrl;
-    call: (params: Parameters<CallManager["startCall"]>[2]) => Promise<RTCPeerConnection>;
-    hangUp: CallManager['endCall'];
-    answerToIncomingCall: (params: Parameters<CallManager["answerToIncomingCall"]>[1]) => Promise<RTCPeerConnection>;
-    declineToIncomingCall: IncomingCallManager['declineToIncomingCall'];
-    getEstablishedRTCSession: CallManager['getEstablishedRTCSession'];
-    getCallConfiguration: CallManager['getCallConfiguration'];
-    getRemoteStreams: CallManager['getRemoteStreams'];
-    replaceMediaStream: CallManager['replaceMediaStream'];
-    startPresentation(stream: MediaStream, options?: {
-        isP2P?: boolean;
-        isNeedReinvite?: boolean;
-        maxBitrate?: number;
-        contentHint?: TContentHint;
-        sendEncodings?: RTCRtpEncodingParameters[];
-        onAddedTransceiver?: TOnAddedTransceiver;
-        callLimit?: number;
-    }): Promise<MediaStream>;
-    stopPresentation(options?: {
-        isP2P?: boolean;
-    }): Promise<MediaStream | undefined>;
-    updatePresentation(stream: MediaStream, options?: {
-        isP2P?: boolean;
-        isNeedReinvite?: boolean;
-        maxBitrate?: number;
-        contentHint?: TContentHint;
-        sendEncodings?: RTCRtpEncodingParameters[];
-        onAddedTransceiver?: TOnAddedTransceiver;
-    }): Promise<MediaStream | undefined>;
-    waitChannels(...args: Parameters<ApiManager['waitChannels']>): Promise<import('../ApiManager/types').TChannels>;
-    waitSyncMediaState(...args: Parameters<ApiManager['waitSyncMediaState']>): Promise<{
-        isSyncForced: boolean;
-    }>;
-    sendDTMF(...args: Parameters<ApiManager['sendDTMF']>): Promise<void>;
-    sendChannels(...args: Parameters<ApiManager['sendChannels']>): Promise<void>;
-    sendMediaState(...args: Parameters<ApiManager['sendMediaState']>): Promise<void>;
-    sendRefusalToTurnOn(...args: Parameters<ApiManager['sendRefusalToTurnOn']>): Promise<void>;
-    sendRefusalToTurnOnMic(...args: Parameters<ApiManager['sendRefusalToTurnOnMic']>): Promise<void>;
-    sendRefusalToTurnOnCam(...args: Parameters<ApiManager['sendRefusalToTurnOnCam']>): Promise<void>;
-    sendMustStopPresentationP2P(...args: Parameters<ApiManager['sendMustStopPresentationP2P']>): Promise<void>;
-    sendStoppedPresentationP2P(...args: Parameters<ApiManager['sendStoppedPresentationP2P']>): Promise<void>;
-    sendStoppedPresentation(...args: Parameters<ApiManager['sendStoppedPresentation']>): Promise<void>;
-    askPermissionToStartPresentationP2P(...args: Parameters<ApiManager['askPermissionToStartPresentationP2P']>): Promise<void>;
-    askPermissionToStartPresentation(...args: Parameters<ApiManager['askPermissionToStartPresentation']>): Promise<void>;
-    askPermissionToEnableCam(...args: Parameters<ApiManager['askPermissionToEnableCam']>): Promise<void>;
-    private subscribe;
-}
-export default SipConnector;

package/dist/SipConnector/eventNames.d.ts

@@ -1,4 +0,0 @@
-import { default as Events } from 'events-constructor';
-export declare const EVENT_NAMES: readonly ("connection:connecting" | "connection:connected" | "connection:disconnected" | "connection:newRTCSession" | "connection:registered" | "connection:unregistered" | "connection:registrationFailed" | "connection:newMessage" | "connection:sipEvent" | "call:peerconnection" | "call:connecting" | "call:sending" | "call:progress" | "call:accepted" | "call:confirmed" | "call:ended" | "call:failed" | "call:newDTMF" | "call:newInfo" | "call:reinvite" | "call:update" | "call:refer" | "call:replaces" | "call:sdp" | "call:icecandidate" | "call:getusermediafailed" | "call:peerconnection:createofferfailed" | "call:peerconnection:createanswerfailed" | "call:peerconnection:setlocaldescriptionfailed" | "call:peerconnection:setremotedescriptionfailed" | "call:presentation:start" | "call:presentation:started" | "call:presentation:end" | "call:presentation:ended" | "call:presentation:failed" | "call:peerconnection:confirmed" | "call:peerconnection:ontrack" | "call:ended:fromserver" | "api:newDTMF" | "api:channels:notify" | "api:participant:added-to-list-moderators" | "api:participant:removed-from-list-moderators" | "api:participant:move-request-to-stream" | "api:participant:move-request-to-spectators" | "api:participant:move-request-to-participants" | "api:participation:accepting-word-request" | "api:participation:cancelling-word-request" | "api:webcast:started" | "api:webcast:stopped" | "api:account:changed" | "api:account:deleted" | "api:conference:participant-token-issued" | "api:channels" | "api:enterRoom" | "api:shareState" | "api:main-cam-control" | "api:useLicense" | "api:admin-start-main-cam" | "api:admin-stop-main-cam" | "api:admin-start-mic" | "api:admin-stop-mic" | "api:admin-force-sync-media-state" | "api:availableSecondRemoteStream" | "api:notAvailableSecondRemoteStream" | "api:mustStopPresentation" | "incoming-call:incomingCall" | "incoming-call:declinedIncomingCall" | "incoming-call:terminatedIncomingCall" | "incoming-call:failedIncomingCall" | "presentation:presentation:start" | "presentation:presentation:started" | "presentation:presentation:end" | "presentation:presentation:ended" | "presentation:presentation:failed")[];
-export type TEvent = (typeof EVENT_NAMES)[number];
-export type TEvents = Events<typeof EVENT_NAMES>;

package/dist/SipConnector/index.d.ts

@@ -1,2 +0,0 @@
-export { default as SipConnector } from './@SipConnector';
-export type { TEvent, TEvents } from './eventNames';

package/dist/index.d.ts

@@ -1,14 +0,0 @@
-export { EUseLicense } from './ApiManager';
-export { ECallCause, hasCanceledCallError } from './CallManager';
-export type { TCustomError } from './CallManager';
-export { debug, disableDebug, enableDebug } from './logger';
-export { hasCanceledStartPresentationError } from './PresentationManager';
-export type { TContentHint } from './PresentationManager';
-export { default as setParametersToSender } from './setParametersToSender';
-export { SipConnector } from './SipConnector';
-export { SipConnectorFacade } from './SipConnectorFacade';
-export * as tools from './tools';
-export { EMimeTypesVideoCodecs } from './types';
-export type { TJsSIP } from './types';
-export { default as getCodecFromSender } from './utils/getCodecFromSender';
-export { default as resolveVideoSendingBalancer } from './videoSendingBalancer';

package/dist/types.d.ts

@@ -1,23 +0,0 @@
-import { UA, WebSocketInterface } from '@krivega/jssip';
-export type TJsSIP = {
-    UA: typeof UA;
-    WebSocketInterface: typeof WebSocketInterface;
-};
-export type TRtpSendParameters = Partial<Omit<RTCRtpSendParameters, 'transactionId'>>;
-export type TSize = {
-    width: number;
-    height: number;
-};
-export type TSimulcastEncoding = TSize & {
-    rid?: string;
-    scalabilityMode?: string;
-};
-export declare enum EMimeTypesVideoCodecs {
-    VP8 = "video/VP8",
-    VP9 = "video/VP9",
-    H264 = "video/H264",
-    AV1 = "video/AV1",
-    rtx = "video/rtx",
-    red = "video/red",
-    flexfec03 = "video/flexfec-03"
-}

package/dist/videoSendingBalancer/scaleBitrate.d.ts

@@ -1,2 +0,0 @@
-declare const scaleMaxBitrateBySender: (senders: RTCRtpSender[], mediaStream: MediaStream, maxBitrate: number) => Promise<import('./setEncodingsToSender').TResult | undefined>;
-export default scaleMaxBitrateBySender;