ue-softphone-sdk-beta 4.0.11 → 4.0.13

package/dist/lib/types/lib/sip.js/platform/web/simple-user/simple-user-delegate.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Delegate for {@link SimpleUser}.
+ * @public
+ */
+export interface SimpleUserDelegate {
+    /**
+     * Called when a call is answered.
+     * @remarks
+     * Callback for handling establishment of a new Session.
+     */
+    onCallAnswered?(): void;
+    /**
+     * Called when a call is created.
+     * @remarks
+     * Callback for handling the creation of a new Session.
+     */
+    onCallCreated?(): void;
+    /**
+     * Called when a call is received.
+     * @remarks
+     * Callback for handling incoming INVITE requests.
+     * The callback must either accept or reject the incoming call by calling `answer()` or `decline()` respectively.
+     */
+    onCallReceived?(): void;
+    /**
+     * Called when a call is hung up.
+     * @remarks
+     * Callback for handling termination of a Session.
+     */
+    onCallHangup?(): void;
+    /**
+     * Called when a call is put on hold or taken off hold.
+     * @remarks
+     * Callback for handling re-INVITE responses.
+     */
+    onCallHold?(held: boolean): void;
+    /**
+     * Called when a call receives an incoming DTMF tone.
+     * @remarks
+     * Callback for handling an incoming INFO request with content type application/dtmf-relay.
+     */
+    onCallDTMFReceived?(tone: string, duration: number): void;
+    /**
+     * Called upon receiving a message.
+     * @remarks
+     * Callback for handling incoming MESSAGE requests.
+     * @param message - The message received.
+     */
+    onMessageReceived?(message: string): void;
+    /**
+     * Called when user is registered to received calls.
+     */
+    onRegistered?(): void;
+    /**
+     * Called when user is no longer registered to received calls.
+     */
+    onUnregistered?(): void;
+    /**
+     * Called when user is connected to server.
+     * @remarks
+     * Callback for handling user becomes connected.
+     */
+    onServerConnect?(): void;
+    /**
+     * Called when user is no longer connected.
+     * @remarks
+     * Callback for handling user becomes disconnected.
+     *
+     * @param error - An Error if server caused the disconnect. Otherwise undefined.
+     */
+    onServerDisconnect?(error?: Error): void;
+}

package/dist/lib/types/lib/sip.js/platform/web/simple-user/simple-user-options.d.ts

@@ -0,0 +1,90 @@
+import { UserAgentOptions } from "../../../api";
+import { SimpleUserDelegate } from "./simple-user-delegate";
+/**
+ * Media for {@link SimpleUserOptions}.
+ * @public
+ */
+export interface SimpleUserMedia {
+    /**
+     * Offer/Answer constraints determine if audio and/or video are utilized.
+     * If not specified, only audio is utilized (audio is true, video is false).
+     * @remarks
+     * Constraints are used when creating local media stream.
+     * If undefined, defaults to audio true and video false.
+     * If audio and video are false, media stream will have no tracks.
+     */
+    constraints?: SimpleUserMediaConstraints;
+    /** HTML elements for local media streams. */
+    local?: SimpleUserMediaLocal;
+    /** Local HTML media elements. */
+    remote?: SimpleUserMediaRemote;
+}
+/**
+ * Constraints for {@link SimpleUserMedia}.
+ * @public
+ */
+export interface SimpleUserMediaConstraints {
+    /** If true, offer and answer to send and receive audio. */
+    audio: boolean;
+    /** If true, offer and answer to send and receive video. */
+    video: boolean;
+}
+/**
+ * Local media elements for {@link SimpleUserMedia}.
+ * @public
+ */
+export interface SimpleUserMediaLocal {
+    /** The local video media stream is attached to this element. */
+    video?: HTMLVideoElement;
+}
+/**
+ * Remote media elements for {@link SimpleUserMedia}.
+ * @public
+ */
+export interface SimpleUserMediaRemote {
+    /** The remote audio media stream is attached to this element. */
+    audio?: HTMLAudioElement;
+    /** The remote video media stream is attached to this element. */
+    video?: HTMLVideoElement;
+}
+/**
+ * Options for {@link SimpleUser}.
+ * @public
+ */
+export interface SimpleUserOptions {
+    /**
+     * User's SIP Address of Record (AOR).
+     * @remarks
+     * The AOR is registered to receive incoming calls.
+     * If not specified, a random anonymous address is created for the user.
+     */
+    aor?: string;
+    /**
+     * Delegate for SimpleUser.
+     */
+    delegate?: SimpleUserDelegate;
+    /**
+     * Media options.
+     */
+    media?: SimpleUserMedia;
+    /**
+     * Maximum number of times to attempt to reconnection.
+     * @remarks
+     * When the transport connection is lost (WebSocket disconnects),
+     * reconnection will be attempted immediately. If that fails,
+     * reconnection will be attempted again when the browser indicates
+     * the application has come online. See:
+     * https://developer.mozilla.org/en-US/docs/Web/API/NavigatorOnLine
+     * @defaultValue 3
+     */
+    reconnectionAttempts?: number;
+    /**
+     * Seconds to wait between reconnection attempts.
+     * @defaultValue 4
+     */
+    reconnectionDelay?: number;
+    /**
+     * Options for UserAgent.
+     */
+    userAgentOptions?: UserAgentOptions;
+}

package/dist/lib/types/lib/sip.js/platform/web/simple-user/simple-user.d.ts

@@ -0,0 +1,226 @@
+import { InvitationAcceptOptions, InviterInviteOptions, InviterOptions, RegistererOptions, RegistererRegisterOptions, RegistererUnregisterOptions } from "../../../api";
+import { SimpleUserDelegate } from "./simple-user-delegate";
+import { SimpleUserOptions } from "./simple-user-options";
+/**
+ * A simple SIP user class.
+ * @remarks
+ * While this class is completely functional for simple use cases, it is not intended
+ * to provide an interface which is suitable for most (must less all) applications.
+ * While this class has many limitations (for example, it only handles a single concurrent session),
+ * it is, however, intended to serve as a simple example of using the SIP.js API.
+ * @public
+ */
+export declare class SimpleUser {
+    /** Delegate. */
+    delegate: SimpleUserDelegate | undefined;
+    private attemptingReconnection;
+    private connectRequested;
+    private logger;
+    private held;
+    private muted;
+    private options;
+    private registerer;
+    private registerRequested;
+    private session;
+    private userAgent;
+    /**
+     * Constructs a new instance of the `SimpleUser` class.
+     * @param server - SIP WebSocket Server URL.
+     * @param options - Options bucket. See {@link SimpleUserOptions} for details.
+     */
+    constructor(server: string, options?: SimpleUserOptions);
+    /**
+     * Instance identifier.
+     * @internal
+     */
+    get id(): string;
+    /** The local media stream. Undefined if call not answered. */
+    get localMediaStream(): MediaStream | undefined;
+    /** The remote media stream. Undefined if call not answered. */
+    get remoteMediaStream(): MediaStream | undefined;
+    /**
+     * The local audio track, if available.
+     * @deprecated Use localMediaStream and get track from the stream.
+     */
+    get localAudioTrack(): MediaStreamTrack | undefined;
+    /**
+     * The local video track, if available.
+     * @deprecated Use localMediaStream and get track from the stream.
+     */
+    get localVideoTrack(): MediaStreamTrack | undefined;
+    /**
+     * The remote audio track, if available.
+     * @deprecated Use remoteMediaStream and get track from the stream.
+     */
+    get remoteAudioTrack(): MediaStreamTrack | undefined;
+    /**
+     * The remote video track, if available.
+     * @deprecated Use remoteMediaStream and get track from the stream.
+     */
+    get remoteVideoTrack(): MediaStreamTrack | undefined;
+    /**
+     * Connect.
+     * @remarks
+     * Start the UserAgent's WebSocket Transport.
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect.
+     * @remarks
+     * Stop the UserAgent's WebSocket Transport.
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Return true if connected.
+     */
+    isConnected(): boolean;
+    /**
+     * Start receiving incoming calls.
+     * @remarks
+     * Send a REGISTER request for the UserAgent's AOR.
+     * Resolves when the REGISTER request is sent, otherwise rejects.
+     */
+    register(registererOptions?: RegistererOptions, registererRegisterOptions?: RegistererRegisterOptions): Promise<void>;
+    /**
+     * Stop receiving incoming calls.
+     * @remarks
+     * Send an un-REGISTER request for the UserAgent's AOR.
+     * Resolves when the un-REGISTER request is sent, otherwise rejects.
+     */
+    unregister(registererUnregisterOptions?: RegistererUnregisterOptions): Promise<void>;
+    /**
+     * Make an outgoing call.
+     * @remarks
+     * Send an INVITE request to create a new Session.
+     * Resolves when the INVITE request is sent, otherwise rejects.
+     * Use `onCallAnswered` delegate method to determine if Session is established.
+     * @param destination - The target destination to call. A SIP address to send the INVITE to.
+     * @param inviterOptions - Optional options for Inviter constructor.
+     * @param inviterInviteOptions - Optional options for Inviter.invite().
+     */
+    call(destination: string, inviterOptions?: InviterOptions, inviterInviteOptions?: InviterInviteOptions): Promise<void>;
+    /**
+     * Hangup a call.
+     * @remarks
+     * Send a BYE request, CANCEL request or reject response to end the current Session.
+     * Resolves when the request/response is sent, otherwise rejects.
+     * Use `onCallTerminated` delegate method to determine if and when call is ended.
+     */
+    hangup(): Promise<void>;
+    /**
+     * Answer an incoming call.
+     * @remarks
+     * Accept an incoming INVITE request creating a new Session.
+     * Resolves with the response is sent, otherwise rejects.
+     * Use `onCallAnswered` delegate method to determine if and when call is established.
+     * @param invitationAcceptOptions - Optional options for Inviter.accept().
+     */
+    answer(invitationAcceptOptions?: InvitationAcceptOptions): Promise<void>;
+    /**
+     * Decline an incoming call.
+     * @remarks
+     * Reject an incoming INVITE request.
+     * Resolves with the response is sent, otherwise rejects.
+     * Use `onCallTerminated` delegate method to determine if and when call is ended.
+     */
+    decline(): Promise<void>;
+    /**
+     * Hold call
+     * @remarks
+     * Send a re-INVITE with new offer indicating "hold".
+     * Resolves when the re-INVITE request is sent, otherwise rejects.
+     * Use `onCallHold` delegate method to determine if request is accepted or rejected.
+     * See: https://tools.ietf.org/html/rfc6337
+     */
+    hold(): Promise<void>;
+    /**
+     * Unhold call.
+     * @remarks
+     * Send a re-INVITE with new offer indicating "unhold".
+     * Resolves when the re-INVITE request is sent, otherwise rejects.
+     * Use `onCallHold` delegate method to determine if request is accepted or rejected.
+     * See: https://tools.ietf.org/html/rfc6337
+     */
+    unhold(): Promise<void>;
+    /**
+     * Hold state.
+     * @remarks
+     * True if session media is on hold.
+     */
+    isHeld(): boolean;
+    /**
+     * Mute call.
+     * @remarks
+     * Disable sender's media tracks.
+     */
+    mute(): void;
+    /**
+     * Unmute call.
+     * @remarks
+     * Enable sender's media tracks.
+     */
+    unmute(): void;
+    /**
+     * Mute state.
+     * @remarks
+     * True if sender's media track is disabled.
+     */
+    isMuted(): boolean;
+    /**
+     * Send DTMF.
+     * @remarks
+     * Send an INFO request with content type application/dtmf-relay.
+     * @param tone - Tone to send.
+     */
+    sendDTMF(tone: string): Promise<void>;
+    /**
+     * Send a message.
+     * @remarks
+     * Send a MESSAGE request.
+     * @param destination - The target destination for the message. A SIP address to send the MESSAGE to.
+     */
+    message(destination: string, message: string): Promise<void>;
+    /** Media constraints. */
+    private get constraints();
+    /**
+     * Attempt reconnection up to `maxReconnectionAttempts` times.
+     * @param reconnectionAttempt - Current attempt number.
+     */
+    private attemptReconnection;
+    /** Helper function to remove media from html elements. */
+    private cleanupMedia;
+    /** Helper function to enable/disable media tracks. */
+    private enableReceiverTracks;
+    /** Helper function to enable/disable media tracks. */
+    private enableSenderTracks;
+    /**
+     * Setup session delegate and state change handler.
+     * @param session - Session to setup
+     * @param referralInviterOptions - Options for any Inviter created as result of a REFER.
+     */
+    private initSession;
+    /** Helper function to init send then send invite. */
+    private sendInvite;
+    /**
+     * Puts Session on hold.
+     * @param hold - Hold on if true, off if false.
+     */
+    private setHold;
+    /**
+     * Puts Session on mute.
+     * @param mute - Mute on if true, off if false.
+     */
+    private setMute;
+    /** Helper function to attach local media to html elements. */
+    private setupLocalMedia;
+    /** Helper function to attach remote media to html elements. */
+    private setupRemoteMedia;
+    /**
+     * End a session.
+     * @remarks
+     * Send a BYE request, CANCEL request or reject response to end the current Session.
+     * Resolves when the request/response is sent, otherwise rejects.
+     * Use `onCallTerminated` delegate method to determine if and when Session is terminated.
+     */
+    private terminate;
+}

package/dist/lib/types/lib/sip.js/platform/web/transport/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A Transport implementation for web browsers.
+ * @packageDocumentation
+ */
+export * from "./transport";
+export * from "./transport-options";

package/dist/lib/types/lib/sip.js/platform/web/transport/transport-options.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Transport options.
+ * @public
+ */
+export interface TransportOptions {
+    /**
+     * URL of WebSocket server to connect with. For example, "wss://localhost:8080".
+     */
+    server: string;
+    /**
+     * Seconds to wait for WebSocket to connect before giving up.
+     * @defaultValue `5`
+     */
+    connectionTimeout?: number;
+    /**
+     * Keep alive - needs review.
+     * @internal
+     */
+    keepAliveInterval?: number;
+    /**
+     * Keep alive - needs review.
+     * @internal
+     */
+    keepAliveDebounce?: number;
+    /**
+     * If true, messages sent and received by the transport are logged.
+     * @defaultValue `true`
+     */
+    traceSip?: boolean;
+}

package/dist/lib/types/lib/sip.js/platform/web/transport/transport.d.ts

@@ -0,0 +1,125 @@
+import { Emitter } from '../../../api/emitter';
+import { Transport as TransportDefinition } from '../../../api/transport';
+import { TransportState } from '../../../api/transport-state';
+import { Logger } from '../../../core';
+import { TransportOptions } from './transport-options';
+/**
+ * Transport for SIP over secure WebSocket (WSS).
+ * @public
+ */
+export declare class Transport implements TransportDefinition {
+    private static defaultOptions;
+    onConnect: (() => void) | undefined;
+    onDisconnect: ((error?: Error) => void) | undefined;
+    onMessage: ((message: string) => void) | undefined;
+    private _protocol;
+    private _state;
+    private _stateEventEmitter;
+    private _ws;
+    private configuration;
+    private connectPromise;
+    private connectResolve;
+    private connectReject;
+    private connectTimeout;
+    private disconnectPromise;
+    private disconnectResolve;
+    private disconnectReject;
+    private keepAliveInterval;
+    private keepAliveDebounceTimeout;
+    private logger;
+    private transitioningState;
+    constructor(logger: Logger, options?: TransportOptions);
+    dispose(): Promise<void>;
+    /**
+     * The protocol.
+     *
+     * @remarks
+     * Formatted as defined for the Via header sent-protocol transport.
+     * https://tools.ietf.org/html/rfc3261#section-20.42
+     */
+    get protocol(): string;
+    /**
+     * The URL of the WebSocket Server.
+     */
+    get server(): string;
+    /**
+     * Transport state.
+     */
+    get state(): TransportState;
+    /**
+     * Transport state change emitter.
+     */
+    get stateChange(): Emitter<TransportState>;
+    /**
+     * The WebSocket.
+     */
+    get ws(): WebSocket | undefined;
+    /**
+     * Connect to network.
+     * Resolves once connected. Otherwise rejects with an Error.
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from network.
+     * Resolves once disconnected. Otherwise rejects with an Error.
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Returns true if the `state` equals "Connected".
+     * @remarks
+     * This is equivalent to `state === TransportState.Connected`.
+     */
+    isConnected(): boolean;
+    /**
+     * Sends a message.
+     * Resolves once message is sent. Otherwise rejects with an Error.
+     * @param message - Message to send.
+     */
+    send(message: string): Promise<void>;
+    private _connect;
+    private _disconnect;
+    private _send;
+    /**
+     * WebSocket "onclose" event handler.
+     * @param ev - Event.
+     */
+    private onWebSocketClose;
+    /**
+     * WebSocket "onerror" event handler.
+     * @param ev - Event.
+     */
+    private onWebSocketError;
+    /**
+     * WebSocket "onmessage" event handler.
+     * @param ev - Event.
+     */
+    private onWebSocketMessage;
+    /**
+     * WebSocket "onopen" event handler.
+     * @param ev - Event.
+     */
+    private onWebSocketOpen;
+    /**
+     * Helper function to generate an Error.
+     * @param state - State transitioning to.
+     */
+    private transitionLoopDetectedError;
+    /**
+     * Transition transport state.
+     * @internal
+     */
+    private transitionState;
+    private clearKeepAliveTimeout;
+    /**
+     * Send a keep-alive (a double-CRLF sequence).
+     */
+    private sendKeepAlive;
+    /**
+     * Start sending keep-alives.
+     */
+    private startSendingKeepAlives;
+    /**
+     * Stop sending keep-alives.
+     */
+    private stopSendingKeepAlives;
+}

package/dist/lib/types/lib/sip.js/version.d.ts

@@ -0,0 +1 @@
+export declare const LIBRARY_VERSION = "0.20.0";

package/dist/lib/types/webrtc/webrtc-method.d.ts

@@ -0,0 +1,2 @@
+export declare function getAudio(id: string): HTMLAudioElement;
+export declare function assignStream(stream: MediaStream, element: HTMLMediaElement): void;

package/dist/lib/types/webrtc/webrtc.d.ts

@@ -0,0 +1,38 @@
+import { RegistererUnregisterOptions } from '../lib/sip.js/index.ts';
+interface Options {
+    server: string;
+    sip: string;
+    secret: string;
+    onmessage?(event: string): void;
+    error?(error: string): void;
+}
+export default class UeWebrtc {
+    private registerer;
+    private userAgent;
+    private Ginvitation;
+    private registerRequested;
+    private attemptingReconnection;
+    private connectRequested;
+    private requestDelegate;
+    constructor(options: Options);
+    accept: () => Promise<void>;
+    /**
+     * Start receiving incoming calls.
+     * @remarks
+     * Send a REGISTER request for the UserAgent's AOR.
+     * Resolves when the REGISTER request is sent, otherwise rejects.
+     */
+    register(): Promise<void>;
+    unregister(registererUnregisterOptions?: RegistererUnregisterOptions): Promise<void>;
+    /**
+     * Attempt reconnection up to `maxReconnectionAttempts` times.
+     * @param reconnectionAttempt - Current attempt number.
+     */
+    private attemptReconnection;
+    ueUnregisterWebrtc: () => Promise<boolean | void>;
+    sendDTMF(tone: string): Promise<void>;
+    disconnect(): any;
+    connect(): any;
+    isConnected(): boolean;
+}
+export {};