ue-softphone-sdk 2.2.2 → 2.2.4

package/dist/core/user-agents/invite-user-agent-client.d.ts

@@ -0,0 +1,35 @@
+import { TransportError } from "../exceptions";
+import { IncomingResponseMessage, OutgoingInviteRequest, OutgoingInviteRequestDelegate, OutgoingRequestMessage } from "../messages";
+import { UserAgentCore } from "../user-agent-core";
+import { UserAgentClient } from "./user-agent-client";
+/**
+ * INVITE UAC.
+ * @remarks
+ * 13 Initiating a Session
+ * https://tools.ietf.org/html/rfc3261#section-13
+ * 13.1 Overview
+ * https://tools.ietf.org/html/rfc3261#section-13.1
+ * 13.2 UAC Processing
+ * https://tools.ietf.org/html/rfc3261#section-13.2
+ * @public
+ */
+export declare class InviteUserAgentClient extends UserAgentClient implements OutgoingInviteRequest {
+    delegate: OutgoingInviteRequestDelegate | undefined;
+    private confirmedDialogAcks;
+    private confirmedDialogs;
+    private earlyDialogs;
+    constructor(core: UserAgentCore, message: OutgoingRequestMessage, delegate?: OutgoingInviteRequestDelegate);
+    dispose(): void;
+    /**
+     * Special case for transport error while sending ACK.
+     * @param error - Transport error
+     */
+    protected onTransportError(error: TransportError): void;
+    /**
+     * Once the INVITE has been passed to the INVITE client transaction, the
+     * UAC waits for responses for the INVITE.
+     * https://tools.ietf.org/html/rfc3261#section-13.2.2
+     * @param incomingResponse - Incoming response to INVITE request.
+     */
+    protected receiveResponse(message: IncomingResponseMessage): void;
+}

package/dist/core/user-agents/invite-user-agent-server.d.ts

@@ -0,0 +1,77 @@
+import { IncomingInviteRequest, IncomingRequestDelegate, IncomingRequestMessage, OutgoingResponse, OutgoingResponseWithSession, ResponseOptions, URI } from "../messages";
+import { UserAgentCore } from "../user-agent-core";
+import { UserAgentServer } from "./user-agent-server";
+/**
+ * INVITE UAS.
+ * @remarks
+ * 13 Initiating a Session
+ * https://tools.ietf.org/html/rfc3261#section-13
+ * 13.1 Overview
+ * https://tools.ietf.org/html/rfc3261#section-13.1
+ * 13.3 UAS Processing
+ * https://tools.ietf.org/html/rfc3261#section-13.3
+ * @public
+ */
+export declare class InviteUserAgentServer extends UserAgentServer implements IncomingInviteRequest {
+    protected core: UserAgentCore;
+    /** The confirmed dialog, if any. */
+    private confirmedDialog;
+    /** The early dialog, if any. */
+    private earlyDialog;
+    constructor(core: UserAgentCore, message: IncomingRequestMessage, delegate?: IncomingRequestDelegate);
+    dispose(): void;
+    /**
+     * 13.3.1.4 The INVITE is Accepted
+     * The UAS core generates a 2xx response.  This response establishes a
+     * dialog, and therefore follows the procedures of Section 12.1.1 in
+     * addition to those of Section 8.2.6.
+     * https://tools.ietf.org/html/rfc3261#section-13.3.1.4
+     * @param options - Accept options bucket.
+     */
+    accept(options?: ResponseOptions): OutgoingResponseWithSession;
+    /**
+     * 13.3.1.1 Progress
+     * If the UAS is not able to answer the invitation immediately, it can
+     * choose to indicate some kind of progress to the UAC (for example, an
+     * indication that a phone is ringing).  This is accomplished with a
+     * provisional response between 101 and 199.  These provisional
+     * responses establish early dialogs and therefore follow the procedures
+     * of Section 12.1.1 in addition to those of Section 8.2.6.  A UAS MAY
+     * send as many provisional responses as it likes.  Each of these MUST
+     * indicate the same dialog ID.  However, these will not be delivered
+     * reliably.
+     *
+     * If the UAS desires an extended period of time to answer the INVITE,
+     * it will need to ask for an "extension" in order to prevent proxies
+     * from canceling the transaction.  A proxy has the option of canceling
+     * a transaction when there is a gap of 3 minutes between responses in a
+     * transaction.  To prevent cancellation, the UAS MUST send a non-100
+     * provisional response at every minute, to handle the possibility of
+     * lost provisional responses.
+     * https://tools.ietf.org/html/rfc3261#section-13.3.1.1
+     * @param options - Progress options bucket.
+     */
+    progress(options?: ResponseOptions): OutgoingResponseWithSession;
+    /**
+     * 13.3.1.2 The INVITE is Redirected
+     * If the UAS decides to redirect the call, a 3xx response is sent.  A
+     * 300 (Multiple Choices), 301 (Moved Permanently) or 302 (Moved
+     * Temporarily) response SHOULD contain a Contact header field
+     * containing one or more URIs of new addresses to be tried.  The
+     * response is passed to the INVITE server transaction, which will deal
+     * with its retransmissions.
+     * https://tools.ietf.org/html/rfc3261#section-13.3.1.2
+     * @param contacts - Contacts to redirect to.
+     * @param options - Redirect options bucket.
+     */
+    redirect(contacts: Array<URI>, options?: ResponseOptions): OutgoingResponse;
+    /**
+     * 13.3.1.3 The INVITE is Rejected
+     * A common scenario occurs when the callee is currently not willing or
+     * able to take additional calls at this end system.  A 486 (Busy Here)
+     * SHOULD be returned in such a scenario.
+     * https://tools.ietf.org/html/rfc3261#section-13.3.1.3
+     * @param options - Reject options bucket.
+     */
+    reject(options?: ResponseOptions): OutgoingResponse;
+}

package/dist/core/user-agents/message-user-agent-client.d.ts

@@ -0,0 +1,10 @@
+import { OutgoingMessageRequest, OutgoingRequestDelegate, OutgoingRequestMessage } from "../messages";
+import { UserAgentCore } from "../user-agent-core";
+import { UserAgentClient } from "./user-agent-client";
+/**
+ * MESSAGE UAC.
+ * @public
+ */
+export declare class MessageUserAgentClient extends UserAgentClient implements OutgoingMessageRequest {
+    constructor(core: UserAgentCore, message: OutgoingRequestMessage, delegate?: OutgoingRequestDelegate);
+}

package/dist/core/user-agents/message-user-agent-server.d.ts

@@ -0,0 +1,10 @@
+import { IncomingMessageRequest, IncomingRequestDelegate, IncomingRequestMessage } from "../messages";
+import { UserAgentCore } from "../user-agent-core";
+import { UserAgentServer } from "./user-agent-server";
+/**
+ * MESSAGE UAS.
+ * @public
+ */
+export declare class MessageUserAgentServer extends UserAgentServer implements IncomingMessageRequest {
+    constructor(core: UserAgentCore, message: IncomingRequestMessage, delegate?: IncomingRequestDelegate);
+}

package/dist/core/user-agents/notify-user-agent-client.d.ts

@@ -0,0 +1,10 @@
+import { SessionDialog } from "../dialogs";
+import { OutgoingNotifyRequest, OutgoingRequestDelegate, RequestOptions } from "../messages";
+import { UserAgentClient } from "./user-agent-client";
+/**
+ * NOTIFY UAS.
+ * @public
+ */
+export declare class NotifyUserAgentClient extends UserAgentClient implements OutgoingNotifyRequest {
+    constructor(dialog: SessionDialog, delegate?: OutgoingRequestDelegate, options?: RequestOptions);
+}

package/dist/core/user-agents/notify-user-agent-server.d.ts

@@ -0,0 +1,16 @@
+import { Dialog } from "../dialogs";
+import { IncomingNotifyRequest, IncomingRequestDelegate, IncomingRequestMessage } from "../messages";
+import { UserAgentCore } from "../user-agent-core";
+import { UserAgentServer } from "./user-agent-server";
+/**
+ * NOTIFY UAS.
+ * @public
+ */
+export declare class NotifyUserAgentServer extends UserAgentServer implements IncomingNotifyRequest {
+    /**
+     * NOTIFY UAS constructor.
+     * @param dialogOrCore - Dialog for in dialog NOTIFY, UserAgentCore for out of dialog NOTIFY (deprecated).
+     * @param message - Incoming NOTIFY request message.
+     */
+    constructor(dialogOrCore: Dialog | UserAgentCore, message: IncomingRequestMessage, delegate?: IncomingRequestDelegate);
+}

package/dist/core/user-agents/prack-user-agent-client.d.ts

@@ -0,0 +1,10 @@
+import { SessionDialog } from "../dialogs";
+import { OutgoingPrackRequest, OutgoingRequestDelegate, RequestOptions } from "../messages";
+import { UserAgentClient } from "./user-agent-client";
+/**
+ * PRACK UAC.
+ * @public
+ */
+export declare class PrackUserAgentClient extends UserAgentClient implements OutgoingPrackRequest {
+    constructor(dialog: SessionDialog, delegate?: OutgoingRequestDelegate, options?: RequestOptions);
+}

package/dist/core/user-agents/prack-user-agent-server.d.ts

@@ -0,0 +1,16 @@
+import { SessionDialog } from "../dialogs";
+import { IncomingPrackRequest, IncomingRequestDelegate, IncomingRequestMessage, OutgoingResponse, ResponseOptions } from "../messages";
+import { UserAgentServer } from "./user-agent-server";
+/**
+ * PRACK UAS.
+ * @public
+ */
+export declare class PrackUserAgentServer extends UserAgentServer implements IncomingPrackRequest {
+    private dialog;
+    constructor(dialog: SessionDialog, message: IncomingRequestMessage, delegate?: IncomingRequestDelegate);
+    /**
+     * Update the dialog signaling state on a 2xx response.
+     * @param options - Options bucket.
+     */
+    accept(options?: ResponseOptions): OutgoingResponse;
+}

package/dist/core/user-agents/publish-user-agent-client.d.ts

@@ -0,0 +1,10 @@
+import { OutgoingPublishRequest, OutgoingRequestDelegate, OutgoingRequestMessage } from "../messages";
+import { UserAgentCore } from "../user-agent-core";
+import { UserAgentClient } from "./user-agent-client";
+/**
+ * PUBLISH UAC.
+ * @public
+ */
+export declare class PublishUserAgentClient extends UserAgentClient implements OutgoingPublishRequest {
+    constructor(core: UserAgentCore, message: OutgoingRequestMessage, delegate?: OutgoingRequestDelegate);
+}

package/dist/core/user-agents/re-invite-user-agent-client.d.ts

@@ -0,0 +1,18 @@
+import { SessionDialog } from "../dialogs";
+import { IncomingResponseMessage, OutgoingInviteRequest, OutgoingInviteRequestDelegate, RequestOptions } from "../messages";
+import { UserAgentClient } from "./user-agent-client";
+/**
+ * Re-INVITE UAC.
+ * @remarks
+ * 14 Modifying an Existing Session
+ * https://tools.ietf.org/html/rfc3261#section-14
+ * 14.1 UAC Behavior
+ * https://tools.ietf.org/html/rfc3261#section-14.1
+ * @public
+ */
+export declare class ReInviteUserAgentClient extends UserAgentClient implements OutgoingInviteRequest {
+    delegate: OutgoingInviteRequestDelegate | undefined;
+    private dialog;
+    constructor(dialog: SessionDialog, delegate?: OutgoingInviteRequestDelegate, options?: RequestOptions);
+    protected receiveResponse(message: IncomingResponseMessage): void;
+}

package/dist/core/user-agents/re-invite-user-agent-server.d.ts

@@ -0,0 +1,41 @@
+import { SessionDialog } from "../dialogs";
+import { IncomingInviteRequest, IncomingRequestDelegate, IncomingRequestMessage, OutgoingResponse, OutgoingResponseWithSession, ResponseOptions, URI } from "../messages";
+import { UserAgentServer } from "./user-agent-server";
+/**
+ * Re-INVITE UAS.
+ * @remarks
+ * 14 Modifying an Existing Session
+ * https://tools.ietf.org/html/rfc3261#section-14
+ * 14.2 UAS Behavior
+ * https://tools.ietf.org/html/rfc3261#section-14.2
+ * @public
+ */
+export declare class ReInviteUserAgentServer extends UserAgentServer implements IncomingInviteRequest {
+    private dialog;
+    constructor(dialog: SessionDialog, message: IncomingRequestMessage, delegate?: IncomingRequestDelegate);
+    /**
+     * Update the dialog signaling state on a 2xx response.
+     * @param options - Options bucket.
+     */
+    accept(options?: ResponseOptions): OutgoingResponseWithSession;
+    /**
+     * Update the dialog signaling state on a 1xx response.
+     * @param options - Progress options bucket.
+     */
+    progress(options?: ResponseOptions): OutgoingResponseWithSession;
+    /**
+     * TODO: Not Yet Supported
+     * @param contacts - Contacts to redirect to.
+     * @param options - Redirect options bucket.
+     */
+    redirect(contacts: Array<URI>, options?: ResponseOptions): OutgoingResponse;
+    /**
+     * 3.1 Background on Re-INVITE Handling by UASs
+     * An error response to a re-INVITE has the following semantics.  As
+     * specified in Section 12.2.2 of RFC 3261 [RFC3261], if a re-INVITE is
+     * rejected, no state changes are performed.
+     * https://tools.ietf.org/html/rfc6141#section-3.1
+     * @param options - Reject options bucket.
+     */
+    reject(options?: ResponseOptions): OutgoingResponse;
+}

package/dist/core/user-agents/re-subscribe-user-agent-client.d.ts

@@ -0,0 +1,17 @@
+import { SubscriptionDialog } from "../dialogs";
+import { IncomingResponseMessage, OutgoingRequestDelegate, OutgoingSubscribeRequest, RequestOptions } from "../messages";
+import { UserAgentClient } from "./user-agent-client";
+/**
+ * Re-SUBSCRIBE UAC.
+ * @public
+ */
+export declare class ReSubscribeUserAgentClient extends UserAgentClient implements OutgoingSubscribeRequest {
+    private dialog;
+    constructor(dialog: SubscriptionDialog, delegate?: OutgoingRequestDelegate, options?: RequestOptions);
+    waitNotifyStop(): void;
+    /**
+     * Receive a response from the transaction layer.
+     * @param message - Incoming response message.
+     */
+    protected receiveResponse(message: IncomingResponseMessage): void;
+}

package/dist/core/user-agents/re-subscribe-user-agent-server.d.ts

@@ -0,0 +1,10 @@
+import { Dialog } from "../dialogs";
+import { IncomingRequestDelegate, IncomingRequestMessage, IncomingSubscribeRequest } from "../messages";
+import { UserAgentServer } from "./user-agent-server";
+/**
+ * Re-SUBSCRIBE UAS.
+ * @public
+ */
+export declare class ReSubscribeUserAgentServer extends UserAgentServer implements IncomingSubscribeRequest {
+    constructor(dialog: Dialog, message: IncomingRequestMessage, delegate?: IncomingRequestDelegate);
+}

package/dist/core/user-agents/refer-user-agent-client.d.ts

@@ -0,0 +1,10 @@
+import { SessionDialog } from "../dialogs";
+import { OutgoingReferRequest, OutgoingRequestDelegate, RequestOptions } from "../messages";
+import { UserAgentClient } from "./user-agent-client";
+/**
+ * REFER UAC.
+ * @public
+ */
+export declare class ReferUserAgentClient extends UserAgentClient implements OutgoingReferRequest {
+    constructor(dialog: SessionDialog, delegate?: OutgoingRequestDelegate, options?: RequestOptions);
+}

package/dist/core/user-agents/refer-user-agent-server.d.ts

@@ -0,0 +1,16 @@
+import { SessionDialog } from "../dialogs";
+import { IncomingReferRequest, IncomingRequestDelegate, IncomingRequestMessage } from "../messages";
+import { UserAgentCore } from "../user-agent-core";
+import { UserAgentServer } from "./user-agent-server";
+/**
+ * REFER UAS.
+ * @public
+ */
+export declare class ReferUserAgentServer extends UserAgentServer implements IncomingReferRequest {
+    /**
+     * REFER UAS constructor.
+     * @param dialogOrCore - Dialog for in dialog REFER, UserAgentCore for out of dialog REFER.
+     * @param message - Incoming REFER request message.
+     */
+    constructor(dialogOrCore: SessionDialog | UserAgentCore, message: IncomingRequestMessage, delegate?: IncomingRequestDelegate);
+}

package/dist/core/user-agents/register-user-agent-client.d.ts

@@ -0,0 +1,10 @@
+import { OutgoingRegisterRequest, OutgoingRequestDelegate, OutgoingRequestMessage } from "../messages";
+import { UserAgentCore } from "../user-agent-core";
+import { UserAgentClient } from "./user-agent-client";
+/**
+ * REGISTER UAC.
+ * @public
+ */
+export declare class RegisterUserAgentClient extends UserAgentClient implements OutgoingRegisterRequest {
+    constructor(core: UserAgentCore, message: OutgoingRequestMessage, delegate?: OutgoingRequestDelegate);
+}

package/dist/core/user-agents/register-user-agent-server.d.ts

@@ -0,0 +1,11 @@
+import { IncomingRegisterRequest, IncomingRequestDelegate, IncomingRequestMessage } from "../messages";
+import { UserAgentCore } from "../user-agent-core";
+import { UserAgentServer } from "./user-agent-server";
+/**
+ * REGISTER UAS.
+ * @public
+ */
+export declare class RegisterUserAgentServer extends UserAgentServer implements IncomingRegisterRequest {
+    protected core: UserAgentCore;
+    constructor(core: UserAgentCore, message: IncomingRequestMessage, delegate?: IncomingRequestDelegate);
+}

package/dist/core/user-agents/subscribe-user-agent-client.d.ts

@@ -0,0 +1,65 @@
+import { IncomingResponseMessage, OutgoingRequestMessage, OutgoingSubscribeRequest, OutgoingSubscribeRequestDelegate } from "../messages";
+import { UserAgentCore } from "../user-agent-core";
+import { NotifyUserAgentServer } from "./notify-user-agent-server";
+import { UserAgentClient } from "./user-agent-client";
+/**
+ * SUBSCRIBE UAC.
+ * @remarks
+ * 4.1.  Subscriber Behavior
+ * https://tools.ietf.org/html/rfc6665#section-4.1
+ *
+ * User agent client for installation of a single subscription per SUBSCRIBE request.
+ * TODO: Support for installation of multiple subscriptions on forked SUBSCRIBE requests.
+ * @public
+ */
+export declare class SubscribeUserAgentClient extends UserAgentClient implements OutgoingSubscribeRequest {
+    delegate: OutgoingSubscribeRequestDelegate | undefined;
+    /** Dialog created upon receiving the first NOTIFY. */
+    private dialog;
+    /** Identifier of this user agent client. */
+    private subscriberId;
+    /** When the subscription expires. Starts as requested expires and updated on 200 and NOTIFY. */
+    private subscriptionExpires;
+    /** The requested expires for the subscription. */
+    private subscriptionExpiresRequested;
+    /** Subscription event being targeted. */
+    private subscriptionEvent;
+    /** Subscription state. */
+    private subscriptionState;
+    /** Timer N Id. */
+    private N;
+    constructor(core: UserAgentCore, message: OutgoingRequestMessage, delegate?: OutgoingSubscribeRequestDelegate);
+    /**
+     * Destructor.
+     * Note that Timer N may live on waiting for an initial NOTIFY and
+     * the delegate may still receive that NOTIFY. If you don't want
+     * that behavior then either clear the delegate so the delegate
+     * doesn't get called (a 200 will be sent in response to the NOTIFY)
+     * or call `waitNotifyStop` which will clear Timer N and remove this
+     * UAC from the core (a 481 will be sent in response to the NOTIFY).
+     */
+    dispose(): void;
+    /**
+     * Handle out of dialog NOTIFY associated with SUBSCRIBE request.
+     * This is the first NOTIFY received after the SUBSCRIBE request.
+     * @param uas - User agent server handling the subscription creating NOTIFY.
+     */
+    onNotify(uas: NotifyUserAgentServer): void;
+    waitNotifyStart(): void;
+    waitNotifyStop(): void;
+    /**
+     * Receive a response from the transaction layer.
+     * @param message - Incoming response message.
+     */
+    protected receiveResponse(message: IncomingResponseMessage): void;
+    /**
+     * To ensure that subscribers do not wait indefinitely for a
+     * subscription to be established, a subscriber starts a Timer N, set to
+     * 64*T1, when it sends a SUBSCRIBE request.  If this Timer N expires
+     * prior to the receipt of a NOTIFY request, the subscriber considers
+     * the subscription failed, and cleans up any state associated with the
+     * subscription attempt.
+     * https://tools.ietf.org/html/rfc6665#section-4.1.2.4
+     */
+    private timerN;
+}

package/dist/core/user-agents/subscribe-user-agent-server.d.ts

@@ -0,0 +1,11 @@
+import { IncomingRequestDelegate, IncomingRequestMessage, IncomingSubscribeRequest } from "../messages";
+import { UserAgentCore } from "../user-agent-core";
+import { UserAgentServer } from "./user-agent-server";
+/**
+ * SUBSCRIBE UAS.
+ * @public
+ */
+export declare class SubscribeUserAgentServer extends UserAgentServer implements IncomingSubscribeRequest {
+    protected core: UserAgentCore;
+    constructor(core: UserAgentCore, message: IncomingRequestMessage, delegate?: IncomingRequestDelegate);
+}

package/dist/core/user-agents/user-agent-client.d.ts

@@ -0,0 +1,103 @@
+import { Dialog } from "../dialogs";
+import { TransportError } from "../exceptions";
+import { Logger, LoggerFactory } from "../log";
+import { IncomingResponseMessage, OutgoingRequest, OutgoingRequestDelegate, OutgoingRequestMessage, RequestOptions } from "../messages";
+import { ClientTransaction, ClientTransactionUser } from "../transactions";
+import { Transport } from "../transport";
+import { UserAgentCore } from "../user-agent-core";
+type ClientTransactionConstructor = new (message: OutgoingRequestMessage, transport: Transport, user: ClientTransactionUser) => ClientTransaction;
+/**
+ * User Agent Client (UAC).
+ * @remarks
+ * A user agent client is a logical entity
+ * that creates a new request, and then uses the client
+ * transaction state machinery to send it.  The role of UAC lasts
+ * only for the duration of that transaction.  In other words, if
+ * a piece of software initiates a request, it acts as a UAC for
+ * the duration of that transaction.  If it receives a request
+ * later, it assumes the role of a user agent server for the
+ * processing of that transaction.
+ * https://tools.ietf.org/html/rfc3261#section-6
+ * @public
+ */
+export declare class UserAgentClient implements OutgoingRequest {
+    private transactionConstructor;
+    protected core: UserAgentCore;
+    message: OutgoingRequestMessage;
+    delegate?: OutgoingRequestDelegate;
+    protected logger: Logger;
+    private _transaction;
+    private credentials;
+    private challenged;
+    private stale;
+    constructor(transactionConstructor: ClientTransactionConstructor, core: UserAgentCore, message: OutgoingRequestMessage, delegate?: OutgoingRequestDelegate);
+    dispose(): void;
+    get loggerFactory(): LoggerFactory;
+    /** The transaction associated with this request. */
+    get transaction(): ClientTransaction;
+    /**
+     * Since requests other than INVITE are responded to immediately, sending a
+     * CANCEL for a non-INVITE request would always create a race condition.
+     * A CANCEL request SHOULD NOT be sent to cancel a request other than INVITE.
+     * https://tools.ietf.org/html/rfc3261#section-9.1
+     * @param options - Cancel options bucket.
+     */
+    cancel(reason?: string, options?: RequestOptions): OutgoingRequestMessage;
+    /**
+     * If a 401 (Unauthorized) or 407 (Proxy Authentication Required)
+     * response is received, the UAC SHOULD follow the authorization
+     * procedures of Section 22.2 and Section 22.3 to retry the request with
+     * credentials.
+     * https://tools.ietf.org/html/rfc3261#section-8.1.3.5
+     * 22 Usage of HTTP Authentication
+     * https://tools.ietf.org/html/rfc3261#section-22
+     * 22.1 Framework
+     * https://tools.ietf.org/html/rfc3261#section-22.1
+     * 22.2 User-to-User Authentication
+     * https://tools.ietf.org/html/rfc3261#section-22.2
+     * 22.3 Proxy-to-User Authentication
+     * https://tools.ietf.org/html/rfc3261#section-22.3
+     *
+     * FIXME: This "guard for and retry the request with credentials"
+     * implementation is not complete and at best minimally passable.
+     * @param response - The incoming response to guard.
+     * @param dialog - If defined, the dialog within which the response was received.
+     * @returns True if the program execution is to continue in the branch in question.
+     *          Otherwise the request is retried with credentials and current request processing must stop.
+     */
+    protected authenticationGuard(message: IncomingResponseMessage, dialog?: Dialog): boolean;
+    /**
+     * 8.1.3.1 Transaction Layer Errors
+     * In some cases, the response returned by the transaction layer will
+     * not be a SIP message, but rather a transaction layer error.  When a
+     * timeout error is received from the transaction layer, it MUST be
+     * treated as if a 408 (Request Timeout) status code has been received.
+     * If a fatal transport error is reported by the transport layer
+     * (generally, due to fatal ICMP errors in UDP or connection failures in
+     * TCP), the condition MUST be treated as a 503 (Service Unavailable)
+     * status code.
+     * https://tools.ietf.org/html/rfc3261#section-8.1.3.1
+     */
+    protected onRequestTimeout(): void;
+    /**
+     * 8.1.3.1 Transaction Layer Errors
+     * In some cases, the response returned by the transaction layer will
+     * not be a SIP message, but rather a transaction layer error.  When a
+     * timeout error is received from the transaction layer, it MUST be
+     * treated as if a 408 (Request Timeout) status code has been received.
+     * If a fatal transport error is reported by the transport layer
+     * (generally, due to fatal ICMP errors in UDP or connection failures in
+     * TCP), the condition MUST be treated as a 503 (Service Unavailable)
+     * status code.
+     * https://tools.ietf.org/html/rfc3261#section-8.1.3.1
+     * @param error - Transport error
+     */
+    protected onTransportError(error: TransportError): void;
+    /**
+     * Receive a response from the transaction layer.
+     * @param message - Incoming response message.
+     */
+    protected receiveResponse(message: IncomingResponseMessage): void;
+    private init;
+}
+export {};

package/dist/core/user-agents/user-agent-server.d.ts

@@ -0,0 +1,79 @@
+import { Logger, LoggerFactory } from "../log";
+import { IncomingRequest, IncomingRequestDelegate, IncomingRequestMessage, OutgoingResponse, ResponseOptions, URI } from "../messages";
+import { ServerTransaction, ServerTransactionUser } from "../transactions";
+import { Transport } from "../transport";
+import { UserAgentCore } from "../user-agent-core";
+type ServerTransactionConstructor = new (message: IncomingRequestMessage, transport: Transport, user: ServerTransactionUser) => ServerTransaction;
+/**
+ * User Agent Server (UAS).
+ * @remarks
+ * A user agent server is a logical entity
+ * that generates a response to a SIP request.  The response
+ * accepts, rejects, or redirects the request.  This role lasts
+ * only for the duration of that transaction.  In other words, if
+ * a piece of software responds to a request, it acts as a UAS for
+ * the duration of that transaction.  If it generates a request
+ * later, it assumes the role of a user agent client for the
+ * processing of that transaction.
+ * https://tools.ietf.org/html/rfc3261#section-6
+ * @public
+ */
+export declare class UserAgentServer implements IncomingRequest {
+    private transactionConstructor;
+    protected core: UserAgentCore;
+    message: IncomingRequestMessage;
+    delegate?: IncomingRequestDelegate;
+    protected logger: Logger;
+    protected toTag: string;
+    private _transaction;
+    constructor(transactionConstructor: ServerTransactionConstructor, core: UserAgentCore, message: IncomingRequestMessage, delegate?: IncomingRequestDelegate);
+    dispose(): void;
+    get loggerFactory(): LoggerFactory;
+    /** The transaction associated with this request. */
+    get transaction(): ServerTransaction;
+    accept(options?: ResponseOptions): OutgoingResponse;
+    progress(options?: ResponseOptions): OutgoingResponse;
+    redirect(contacts: Array<URI>, options?: ResponseOptions): OutgoingResponse;
+    reject(options?: ResponseOptions): OutgoingResponse;
+    trying(options?: ResponseOptions): OutgoingResponse;
+    /**
+     * If the UAS did not find a matching transaction for the CANCEL
+     * according to the procedure above, it SHOULD respond to the CANCEL
+     * with a 481 (Call Leg/Transaction Does Not Exist).  If the transaction
+     * for the original request still exists, the behavior of the UAS on
+     * receiving a CANCEL request depends on whether it has already sent a
+     * final response for the original request.  If it has, the CANCEL
+     * request has no effect on the processing of the original request, no
+     * effect on any session state, and no effect on the responses generated
+     * for the original request.  If the UAS has not issued a final response
+     * for the original request, its behavior depends on the method of the
+     * original request.  If the original request was an INVITE, the UAS
+     * SHOULD immediately respond to the INVITE with a 487 (Request
+     * Terminated).  A CANCEL request has no impact on the processing of
+     * transactions with any other method defined in this specification.
+     * https://tools.ietf.org/html/rfc3261#section-9.2
+     * @param request - Incoming CANCEL request.
+     */
+    receiveCancel(message: IncomingRequestMessage): void;
+    protected get acceptable(): boolean;
+    protected get progressable(): boolean;
+    protected get redirectable(): boolean;
+    protected get rejectable(): boolean;
+    protected get tryingable(): boolean;
+    /**
+     * 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.
+     *
+     * Once all procedures associated with the creation of a response have
+     * been completed, the UAS hands the response back to the server
+     * transaction from which it received the request.
+     * https://tools.ietf.org/html/rfc3261#section-8.2.6
+     * @param statusCode - Status code to reply with.
+     * @param options - Reply options bucket.
+     */
+    private reply;
+    private init;
+}
+export {};

package/dist/grammar/grammar.d.ts

@@ -0,0 +1,26 @@
+import { NameAddrHeader } from "./name-addr-header";
+import { URI } from "./uri";
+/**
+ * Grammar.
+ * @internal
+ */
+export declare namespace Grammar {
+    /**
+     * Parse.
+     * @param input -
+     * @param startRule -
+     */
+    function parse(input: string, startRule: string): any;
+    /**
+     * Parse the given string and returns a SIP.NameAddrHeader instance or undefined if
+     * it is an invalid NameAddrHeader.
+     * @param name_addr_header -
+     */
+    function nameAddrHeaderParse(nameAddrHeader: string): NameAddrHeader | undefined;
+    /**
+     * Parse the given string and returns a SIP.URI instance or undefined if
+     * it is an invalid URI.
+     * @param uri -
+     */
+    function URIParse(uri: string): URI | undefined;
+}

package/dist/grammar/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./grammar";
+export * from "./name-addr-header";
+export * from "./parameters";
+export * from "./uri";