ue-softphone-sdk 2.2.2 → 2.2.4

package/dist/core/messages/methods/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./constants";
+export * from "./ack";
+export * from "./bye";
+export * from "./cancel";
+export * from "./info";
+export * from "./invite";
+export * from "./message";
+export * from "./notify";
+export * from "./prack";
+export * from "./publish";
+export * from "./register";
+export * from "./refer";
+export * from "./subscribe";

package/dist/core/messages/methods/info.d.ts

@@ -0,0 +1,21 @@
+import { IncomingRequest } from "../incoming-request";
+import { IncomingResponse } from "../incoming-response";
+import { OutgoingRequest } from "../outgoing-request";
+/**
+ * Incoming INFO request.
+ * @public
+ */
+export interface IncomingInfoRequest extends IncomingRequest {
+}
+/**
+ * Incoming INFO response.
+ * @public
+ */
+export interface IncomingInfoResponse extends IncomingResponse {
+}
+/**
+ * Outgoing INFO request.
+ * @public
+ */
+export interface OutgoingInfoRequest extends OutgoingRequest {
+}

package/dist/core/messages/methods/invite.d.ts

@@ -0,0 +1,86 @@
+import { Session } from "../../session";
+import { IncomingRequest } from "../incoming-request";
+import { IncomingResponse } from "../incoming-response";
+import { OutgoingRequest, OutgoingRequestDelegate, RequestOptions } from "../outgoing-request";
+import { OutgoingResponse, ResponseOptions } from "../outgoing-response";
+import { OutgoingAckRequest } from "./ack";
+import { OutgoingPrackRequest } from "./prack";
+/**
+ * Incoming INVITE request.
+ * @public
+ */
+export interface IncomingInviteRequest extends IncomingRequest {
+    /**
+     * Send a 2xx positive final response to this request. Defaults to 200.
+     * @param options - Response options bucket.
+     * @returns Outgoing response and a confirmed Session.
+     */
+    accept(options?: ResponseOptions): OutgoingResponseWithSession;
+    /**
+     * Send a 1xx provisional response to this request. Defaults to 180. Excludes 100.
+     * @param options - Response options bucket.
+     * @returns Outgoing response and an early Session.
+     */
+    progress(options?: ResponseOptions): OutgoingResponseWithSession;
+}
+/**
+ * Outgoing INVITE response with the associated {@link Session}.
+ * @public
+ */
+export interface OutgoingResponseWithSession extends OutgoingResponse {
+    /**
+     * Session associated with incoming request acceptance, or
+     * Session associated with incoming request progress (if an out of dialog request, an early dialog).
+     */
+    readonly session: Session;
+}
+/**
+ * Outgoing INVITE request.
+ * @public
+ */
+export interface OutgoingInviteRequest extends OutgoingRequest {
+    /** Delegate providing custom handling of this outgoing INVITE request. */
+    delegate?: OutgoingInviteRequestDelegate;
+}
+/**
+ * Delegate providing custom handling of outgoing INVITE requests.
+ * @public
+ */
+export interface OutgoingInviteRequestDelegate extends OutgoingRequestDelegate {
+    /**
+     * Received a 2xx positive final response to this request.
+     * @param response - Incoming response (including a confirmed Session).
+     */
+    onAccept?(response: AckableIncomingResponseWithSession): void;
+    /**
+     * Received a 1xx provisional response to this request. Excluding 100 responses.
+     * @param response - Incoming response (including an early Session).
+     */
+    onProgress?(response: PrackableIncomingResponseWithSession): void;
+}
+/**
+ * Incoming INVITE response received when request is accepted.
+ * @public
+ */
+export interface AckableIncomingResponseWithSession extends IncomingResponse {
+    /** Session associated with outgoing request acceptance. */
+    readonly session: Session;
+    /**
+     * Send an ACK to acknowledge this response.
+     * @param options - Request options bucket.
+     */
+    ack(options?: RequestOptions): OutgoingAckRequest;
+}
+/**
+ * Incoming INVITE response received when request is progressed.
+ * @public
+ */
+export interface PrackableIncomingResponseWithSession extends IncomingResponse {
+    /** Session associated with outgoing request progress. If out of dialog request, an early dialog. */
+    readonly session: Session;
+    /**
+     * Send an PRACK to acknowledge this response.
+     * @param options - Request options bucket.
+     */
+    prack(options?: RequestOptions): OutgoingPrackRequest;
+}

package/dist/core/messages/methods/message.d.ts

@@ -0,0 +1,21 @@
+import { IncomingRequest } from "../incoming-request";
+import { IncomingResponse } from "../incoming-response";
+import { OutgoingRequest } from "../outgoing-request";
+/**
+ * Incoming MESSAGE request.
+ * @public
+ */
+export interface IncomingMessageRequest extends IncomingRequest {
+}
+/**
+ * Incoming MESSAGE response.
+ * @public
+ */
+export interface IncomingMessageResponse extends IncomingResponse {
+}
+/**
+ * Outgoing MESSAGE request.
+ * @public
+ */
+export interface OutgoingMessageRequest extends OutgoingRequest {
+}

package/dist/core/messages/methods/notify.d.ts

@@ -0,0 +1,21 @@
+import { IncomingRequest } from "../incoming-request";
+import { IncomingResponse } from "../incoming-response";
+import { OutgoingRequest } from "../outgoing-request";
+/**
+ * Incoming NOTIFY request.
+ * @public
+ */
+export interface IncomingNotifyRequest extends IncomingRequest {
+}
+/**
+ * Incoming NOTIFY response.
+ * @public
+ */
+export interface IncomingNotifyResponse extends IncomingResponse {
+}
+/**
+ * Outgoing NOTIFY request.
+ * @public
+ */
+export interface OutgoingNotifyRequest extends OutgoingRequest {
+}

package/dist/core/messages/methods/prack.d.ts

@@ -0,0 +1,21 @@
+import { IncomingRequest } from "../incoming-request";
+import { IncomingResponse } from "../incoming-response";
+import { OutgoingRequest } from "../outgoing-request";
+/**
+ * Incoming PRACK request.
+ * @public
+ */
+export interface IncomingPrackRequest extends IncomingRequest {
+}
+/**
+ * Incoming PRACK response.
+ * @public
+ */
+export interface IncomingPrackResponse extends IncomingResponse {
+}
+/**
+ * Outgoing PRACK request.
+ * @public
+ */
+export interface OutgoingPrackRequest extends OutgoingRequest {
+}

package/dist/core/messages/methods/publish.d.ts

@@ -0,0 +1,21 @@
+import { IncomingRequest } from "../incoming-request";
+import { IncomingResponse } from "../incoming-response";
+import { OutgoingRequest } from "../outgoing-request";
+/**
+ * Incoming PUBLISH request.
+ * @public
+ */
+export interface IncomingPublishRequest extends IncomingRequest {
+}
+/**
+ * Incoming PUBLISH response.
+ * @public
+ */
+export interface IncomingPublishResponse extends IncomingResponse {
+}
+/**
+ * Outgoing PUBLISH request.
+ * @public
+ */
+export interface OutgoingPublishRequest extends OutgoingRequest {
+}

package/dist/core/messages/methods/refer.d.ts

@@ -0,0 +1,21 @@
+import { IncomingRequest } from "../incoming-request";
+import { IncomingResponse } from "../incoming-response";
+import { OutgoingRequest } from "../outgoing-request";
+/**
+ * Incoming REFER request.
+ * @public
+ */
+export interface IncomingReferRequest extends IncomingRequest {
+}
+/**
+ * Incoming REFER response.
+ * @public
+ */
+export interface IncomingReferResponse extends IncomingResponse {
+}
+/**
+ * Outgoing REFER request.
+ * @public
+ */
+export interface OutgoingReferRequest extends OutgoingRequest {
+}

package/dist/core/messages/methods/register.d.ts

@@ -0,0 +1,21 @@
+import { IncomingRequest } from "../incoming-request";
+import { IncomingResponse } from "../incoming-response";
+import { OutgoingRequest } from "../outgoing-request";
+/**
+ * Incoming REGISTER request.
+ * @public
+ */
+export interface IncomingRegisterRequest extends IncomingRequest {
+}
+/**
+ * Incoming REGISTER response.
+ * @public
+ */
+export interface IncomingRegisterResponse extends IncomingResponse {
+}
+/**
+ * Outgoing REGISTER request.
+ * @public
+ */
+export interface OutgoingRegisterRequest extends OutgoingRequest {
+}

package/dist/core/messages/methods/subscribe.d.ts

@@ -0,0 +1,54 @@
+import { Subscription } from "../../subscription";
+import { IncomingRequest } from "../incoming-request";
+import { IncomingResponse } from "../incoming-response";
+import { OutgoingRequest, OutgoingRequestDelegate } from "../outgoing-request";
+import { IncomingNotifyRequest } from "./notify";
+/**
+ * Incoming SUBSCRIBE request.
+ * @public
+ */
+export interface IncomingSubscribeRequest extends IncomingRequest {
+}
+/**
+ * Incoming SUBSCRIBE response.
+ * @public
+ */
+export interface IncomingSubscribeResponse extends IncomingResponse {
+}
+/**
+ * Outgoing SUBSCRIBE request.
+ * @public
+ */
+export interface OutgoingSubscribeRequest extends OutgoingRequest {
+    /** Delegate providing custom handling of this outgoing SUBSCRIBE request. */
+    delegate?: OutgoingSubscribeRequestDelegate;
+    /** Stop waiting for an inital subscription creating NOTIFY. */
+    waitNotifyStop(): void;
+}
+/**
+ * Delegate providing custom handling of outgoing SUBSCRIBE requests.
+ * @public
+ */
+export interface OutgoingSubscribeRequestDelegate extends OutgoingRequestDelegate {
+    /**
+     * Received the initial subscription creating NOTIFY in response to this request.
+     * Called for out of dialog SUBSCRIBE requests only (not called for re-SUBSCRIBE requests).
+     * @param request - Incoming NOTIFY request (including a Subscription).
+     */
+    onNotify?(request: IncomingRequestWithSubscription): void;
+    /**
+     * Timed out waiting to receive the initial subscription creating NOTIFY in response to this request.
+     * Called for out of dialog SUBSCRIBE requests only (not called for re-SUBSCRIBE requests).
+     */
+    onNotifyTimeout?(): void;
+}
+/**
+ * Incoming NOTIFY request with associated {@link Subscription}.
+ * @public
+ */
+export interface IncomingRequestWithSubscription {
+    /** The NOTIFY request which established the subscription. */
+    readonly request: IncomingNotifyRequest;
+    /** If subscription state is not "terminated", then the subscription. Otherwise undefined. */
+    readonly subscription?: Subscription;
+}

package/dist/core/messages/outgoing-request-message.d.ts

@@ -0,0 +1,94 @@
+import { NameAddrHeader, URI } from "../../grammar";
+import { Body } from "./body";
+/**
+ * Outgoing request message options.
+ * @public
+ */
+export interface OutgoingRequestMessageOptions {
+    callId?: string;
+    callIdPrefix?: string;
+    cseq?: number;
+    toDisplayName?: string;
+    toTag?: string;
+    fromDisplayName?: string;
+    fromTag?: string;
+    forceRport?: boolean;
+    hackViaTcp?: boolean;
+    optionTags?: Array<string>;
+    routeSet?: Array<string>;
+    userAgentString?: string;
+    viaHost?: string;
+}
+/**
+ * Outgoing SIP request message.
+ * @public
+ */
+export declare class OutgoingRequestMessage {
+    readonly headers: {
+        [name: string]: Array<string>;
+    };
+    readonly method: string;
+    readonly ruri: URI;
+    readonly from: NameAddrHeader;
+    readonly fromTag: string;
+    readonly fromURI: URI;
+    readonly to: NameAddrHeader;
+    readonly toTag: string | undefined;
+    readonly toURI: URI;
+    branch: string | undefined;
+    readonly callId: string;
+    cseq: number;
+    extraHeaders: Array<string>;
+    body: {
+        body: string;
+        contentType: string;
+    } | undefined;
+    private options;
+    constructor(method: string, ruri: URI, fromURI: URI, toURI: URI, options?: OutgoingRequestMessageOptions, extraHeaders?: Array<string>, body?: Body);
+    /** Get a copy of the default options. */
+    private static getDefaultOptions;
+    private static makeNameAddrHeader;
+    /**
+     * Get the value of the given header name at the given position.
+     * @param name - header name
+     * @returns Returns the specified header, undefined if header doesn't exist.
+     */
+    getHeader(name: string): string | undefined;
+    /**
+     * Get the header/s of the given name.
+     * @param name - header name
+     * @returns Array with all the headers of the specified name.
+     */
+    getHeaders(name: string): Array<string>;
+    /**
+     * Verify the existence of the given header.
+     * @param name - header name
+     * @returns true if header with given name exists, false otherwise
+     */
+    hasHeader(name: string): boolean;
+    /**
+     * Replace the the given header by the given value.
+     * @param name - header name
+     * @param value - header value
+     */
+    setHeader(name: string, value: string | Array<string>): void;
+    /**
+     * The Via header field indicates the transport used for the transaction
+     * and identifies the location where the response is to be sent.  A Via
+     * header field value is added only after the transport that will be
+     * used to reach the next hop has been selected (which may involve the
+     * usage of the procedures in [4]).
+     *
+     * When the UAC creates a request, it MUST insert a Via into that
+     * request.  The protocol name and protocol version in the header field
+     * MUST be SIP and 2.0, respectively.  The Via header field value MUST
+     * contain a branch parameter.  This parameter is used to identify the
+     * transaction created by that request.  This parameter is used by both
+     * the client and the server.
+     * https://tools.ietf.org/html/rfc3261#section-8.1.1.7
+     * @param branchParameter - The branch parameter.
+     * @param transport - The sent protocol transport.
+     */
+    setViaHeader(branch: string, transport: string): void;
+    toString(): string;
+}

package/dist/core/messages/outgoing-request.d.ts

@@ -0,0 +1,67 @@
+import { Body } from "./body";
+import { IncomingResponse } from "./incoming-response";
+import { OutgoingRequestMessage } from "./outgoing-request-message";
+/**
+ * A SIP message sent from a local client to a remote server.
+ * @remarks
+ * For the purpose of invoking a particular operation.
+ * https://tools.ietf.org/html/rfc3261#section-7.1
+ * @public
+ */
+export interface OutgoingRequest {
+    /** Delegate providing custom handling of this outgoing request. */
+    delegate?: OutgoingRequestDelegate;
+    /** The outgoing message. */
+    readonly message: OutgoingRequestMessage;
+    /**
+     * Destroy request.
+     */
+    dispose(): void;
+    /**
+     * Sends a CANCEL message targeting this request to the UAS.
+     * @param reason - Reason for canceling request.
+     * @param options - Request options bucket.
+     */
+    cancel(reason?: string, options?: RequestOptions): void;
+}
+/**
+ * Delegate providing custom handling of outgoing requests.
+ * @public
+ */
+export interface OutgoingRequestDelegate {
+    /**
+     * Received a 2xx positive final response to this request.
+     * @param response - Incoming response.
+     */
+    onAccept?(response: IncomingResponse): void;
+    /**
+     * Received a 1xx provisional response to this request. Excluding 100 responses.
+     * @param response - Incoming response.
+     */
+    onProgress?(response: IncomingResponse): void;
+    /**
+     * Received a 3xx negative final response to this request.
+     * @param response - Incoming response.
+     */
+    onRedirect?(response: IncomingResponse): void;
+    /**
+     * Received a 4xx, 5xx, or 6xx negative final response to this request.
+     * @param response - Incoming response.
+     */
+    onReject?(response: IncomingResponse): void;
+    /**
+     * Received a 100 provisional response.
+     * @param response - Incoming response.
+     */
+    onTrying?(response: IncomingResponse): void;
+}
+/**
+ * Request options bucket.
+ * @public
+ */
+export interface RequestOptions {
+    /** Extra headers to include in the message. */
+    extraHeaders?: Array<string>;
+    /** Body to include in the message. */
+    body?: Body;
+}

package/dist/core/messages/outgoing-response.d.ts

@@ -0,0 +1,42 @@
+import { Body } from "./body";
+import { IncomingRequestMessage } from "./incoming-request-message";
+/**
+ * A SIP message sent from a local server to a remote client.
+ * @remarks
+ * For indicating the status of a request sent from the client to the server.
+ * https://tools.ietf.org/html/rfc3261#section-7.2
+ * @public
+ */
+export interface OutgoingResponse {
+    /** The outgoing message. */
+    readonly message: string;
+}
+/**
+ * Response options bucket.
+ * @public
+ */
+export interface ResponseOptions {
+    /** Status code of the response. */
+    statusCode: number;
+    /** Reason phrase of the response. */
+    reasonPhrase?: string;
+    /** To tag of the response. If not provided, one is generated. */
+    toTag?: string;
+    /** User agent string for User-Agent header. */
+    userAgent?: string;
+    /** Support options tags for Supported header. */
+    supported?: Array<string>;
+    /** Extra headers to include in the message. */
+    extraHeaders?: Array<string>;
+    /** Body to include in the message. */
+    body?: Body;
+}
+/**
+ * When a UAS wishes to construct a response to a request, it follows
+ * the general procedures detailed in the following subsections.
+ * Additional behaviors specific to the response code in question, which
+ * are not detailed in this section, may also be required.
+ * https://tools.ietf.org/html/rfc3261#section-8.2.6
+ * @internal
+ */
+export declare function constructOutgoingResponse(message: IncomingRequestMessage, options: ResponseOptions): OutgoingResponse;

package/dist/core/messages/parser.d.ts

@@ -0,0 +1,14 @@
+import { Logger } from "../log/logger";
+import { IncomingRequestMessage } from "./incoming-request-message";
+import { IncomingResponseMessage } from "./incoming-response-message";
+/**
+ * Extract and parse every header of a SIP message.
+ * @internal
+ */
+export declare namespace Parser {
+    function getHeader(data: any, headerStart: number): number;
+    function parseHeader(message: IncomingRequestMessage | IncomingResponseMessage, data: any, headerStart: number, headerEnd: number): boolean | {
+        error: string;
+    };
+    function parseMessage(data: string, logger: Logger): IncomingRequestMessage | IncomingResponseMessage | undefined;
+}

package/dist/core/messages/utils.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @param size -
+ * @param base -
+ * @internal
+ */
+export declare function createRandomToken(size: number, base?: number): string;
+/**
+ * @internal
+ */
+export declare function getReasonPhrase(code: number): string;
+/**
+ * @internal
+ */
+export declare function newTag(): string;
+/**
+ * @param str -
+ * @internal
+ */
+export declare function headerize(str: string): string;
+/**
+ * @param str -
+ * @internal
+ */
+export declare function utf8Length(str: string): number;

package/dist/core/session/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./session";
+export * from "./session-delegate";

package/dist/core/session/session-delegate.d.ts

@@ -0,0 +1,70 @@
+import { IncomingAckRequest, IncomingByeRequest, IncomingInfoRequest, IncomingInviteRequest, IncomingMessageRequest, IncomingNotifyRequest, IncomingPrackRequest, IncomingReferRequest } from "../messages";
+/**
+ * Session delegate.
+ * @public
+ */
+export interface SessionDelegate {
+    /**
+     * Receive ACK request.
+     * @param request - Incoming ACK request.
+     * @returns
+     * The callback MUST return a promise if it asynchronously handles answers.
+     * For example, an ACK with an answer (offer in the 200 Ok) may require
+     * asynchronous processing in which case the callback MUST return a Promise
+     * which resolves when the answer handling is complete.
+     * @privateRemarks
+     * Unlike INVITE handling where we can rely on the generation of a response
+     * to indicate when offer/answer processing has been completed, ACK handling
+     * requires some indication from the handler that answer processing is complete
+     * so that we can avoid some race conditions (see comments in code for more details).
+     * Having the handler return a Promise provides said indication.
+     */
+    onAck?(request: IncomingAckRequest): Promise<void> | void;
+    /**
+     * Timeout waiting for ACK request.
+     * If no handler is provided the Session will terminated with a BYE.
+     * https://tools.ietf.org/html/rfc3261#section-13.3.1.4
+     */
+    onAckTimeout?(): void;
+    /**
+     * Receive BYE request.
+     * https://tools.ietf.org/html/rfc3261#section-15.1.2
+     * @param request - Incoming BYE request.
+     */
+    onBye?(request: IncomingByeRequest): void;
+    /**
+     * Receive INFO request.
+     * @param request - Incoming INFO request.
+     */
+    onInfo?(request: IncomingInfoRequest): void;
+    /**
+     * Receive re-INVITE request.
+     * https://tools.ietf.org/html/rfc3261#section-14.2
+     * @param request - Incoming INVITE request.
+     */
+    onInvite?(request: IncomingInviteRequest): void;
+    /**
+     * Receive MESSAGE request.
+     * https://tools.ietf.org/html/rfc3428#section-7
+     * @param request - Incoming MESSAGE request.
+     */
+    onMessage?(request: IncomingMessageRequest): void;
+    /**
+     * Receive NOTIFY request.
+     * https://tools.ietf.org/html/rfc6665#section-4.1.3
+     * @param request - Incoming NOTIFY request.
+     */
+    onNotify?(request: IncomingNotifyRequest): void;
+    /**
+     * Receive PRACK request.
+     * https://tools.ietf.org/html/rfc3262#section-3
+     * @param request - Incoming PRACK request.
+     */
+    onPrack?(request: IncomingPrackRequest): void;
+    /**
+     * Receive REFER request.
+     * https://tools.ietf.org/html/rfc3515#section-2.4.2
+     * @param request - Incoming REFER request.
+     */
+    onRefer?(request: IncomingReferRequest): void;
+}