ue-softphone-sdk 2.2.3 → 2.2.4

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

@@ -0,0 +1,134 @@
+import { Body, OutgoingByeRequest, OutgoingInfoRequest, OutgoingInviteRequest, OutgoingInviteRequestDelegate, OutgoingMessageRequest, OutgoingNotifyRequest, OutgoingPrackRequest, OutgoingReferRequest, OutgoingRequestDelegate, RequestOptions, URI } from "../messages";
+import { SessionDelegate } from "./session-delegate";
+/**
+ * Session.
+ * @remarks
+ * https://tools.ietf.org/html/rfc3261#section-13
+ * @public
+ */
+export interface Session {
+    /** Session delegate. */
+    delegate: SessionDelegate | undefined;
+    /** The session id. Equal to callId + localTag + remoteTag. */
+    readonly id: string;
+    /** Call Id. */
+    readonly callId: string;
+    /** Local Tag. */
+    readonly localTag: string;
+    /** Local URI. */
+    readonly localURI: URI;
+    /** Remote Tag. */
+    readonly remoteTag: string;
+    /** Remote Target. */
+    readonly remoteTarget: URI;
+    /** Remote URI. */
+    readonly remoteURI: URI;
+    /** Session state. */
+    readonly sessionState: SessionState;
+    /** Current state of the offer/answer exchange. */
+    readonly signalingState: SignalingState;
+    /** The current answer if signalingState is stable. Otherwise undefined. */
+    readonly answer: Body | undefined;
+    /** The current offer if signalingState is not initial or closed. Otherwise undefined. */
+    readonly offer: Body | undefined;
+    /**
+     * Destroy session.
+     */
+    dispose(): void;
+    /**
+     * Send a BYE request.
+     * Terminating a session.
+     * https://tools.ietf.org/html/rfc3261#section-15
+     * @param delegate - Request delegate.
+     * @param options - Options bucket.
+     */
+    bye(delegate?: OutgoingRequestDelegate, options?: RequestOptions): OutgoingByeRequest;
+    /**
+     * Send an INFO request.
+     * Exchange information during a session.
+     * https://tools.ietf.org/html/rfc6086#section-4.2.1
+     * @param delegate - Request delegate.
+     * @param options - Options bucket.
+     */
+    info(delegate?: OutgoingRequestDelegate, options?: RequestOptions): OutgoingInfoRequest;
+    /**
+     * Send re-INVITE request.
+     * Modifying a session.
+     * https://tools.ietf.org/html/rfc3261#section-14.1
+     * @param delegate - Request delegate.
+     * @param options - Options bucket.
+     */
+    invite(delegate?: OutgoingInviteRequestDelegate, options?: RequestOptions): OutgoingInviteRequest;
+    /**
+     * Send MESSAGE request.
+     * Deliver a message during a session.
+     * https://tools.ietf.org/html/rfc3428#section-4
+     * @param delegate - Request delegate.
+     * @param options - Options bucket.
+     */
+    message(delegate?: OutgoingRequestDelegate, options?: RequestOptions): OutgoingMessageRequest;
+    /**
+     * Send NOTIFY request.
+     * Inform referrer of transfer progress.
+     * The use of this is limited to the implicit creation of subscription by REFER (historical).
+     * Otherwise, notifiers MUST NOT create subscriptions except upon receipt of a SUBSCRIBE request.
+     * https://tools.ietf.org/html/rfc3515#section-3.7
+     * @param delegate - Request delegate.
+     * @param options - Options bucket.
+     */
+    notify(delegate?: OutgoingRequestDelegate, options?: RequestOptions): OutgoingNotifyRequest;
+    /**
+     * Send PRACK request.
+     * Acknowledge a reliable provisional response.
+     * https://tools.ietf.org/html/rfc3262#section-4
+     * @param delegate - Request delegate.
+     * @param options - Options bucket.
+     */
+    prack(delegate?: OutgoingRequestDelegate, options?: RequestOptions): OutgoingPrackRequest;
+    /**
+     * Send REFER request.
+     * Transfer a session.
+     * https://tools.ietf.org/html/rfc3515#section-2.4.1
+     * @param delegate - Request delegate.
+     * @param options - Options bucket.
+     */
+    refer(delegate?: OutgoingRequestDelegate, options?: RequestOptions): OutgoingReferRequest;
+}
+/**
+ * Session state.
+ * @remarks
+ * https://tools.ietf.org/html/rfc3261#section-13
+ * @public
+ */
+export declare enum SessionState {
+    Initial = "Initial",
+    Early = "Early",
+    AckWait = "AckWait",
+    Confirmed = "Confirmed",
+    Terminated = "Terminated"
+}
+/**
+ * Offer/Answer state.
+ * @remarks
+ * ```txt
+ *         Offer                Answer             RFC    Ini Est Early
+ *  -------------------------------------------------------------------
+ *  1. INVITE Req.          2xx INVITE Resp.     RFC 3261  Y   Y    N
+ *  2. 2xx INVITE Resp.     ACK Req.             RFC 3261  Y   Y    N
+ *  3. INVITE Req.          1xx-rel INVITE Resp. RFC 3262  Y   Y    N
+ *  4. 1xx-rel INVITE Resp. PRACK Req.           RFC 3262  Y   Y    N
+ *  5. PRACK Req.           200 PRACK Resp.      RFC 3262  N   Y    Y
+ *  6. UPDATE Req.          2xx UPDATE Resp.     RFC 3311  N   Y    Y
+ *
+ *       Table 1: Summary of SIP Usage of the Offer/Answer Model
+ * ```
+ * https://tools.ietf.org/html/rfc6337#section-2.2
+ * @public
+ */
+export declare enum SignalingState {
+    Initial = "Initial",
+    HaveLocalOffer = "HaveLocalOffer",
+    HaveRemoteOffer = "HaveRemoteOffer",
+    Stable = "Stable",
+    Closed = "Closed"
+}

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

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

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

@@ -0,0 +1,27 @@
+import { IncomingNotifyRequest, OutgoingSubscribeRequest } from "../messages";
+/**
+ * Subscription delegate.
+ * @public
+ */
+export interface SubscriptionDelegate {
+    /**
+     * Receive NOTIFY request. This includes in dialog NOTIFY requests only.
+     * Thus the first NOTIFY (the subscription creating NOTIFY) will not be provided.
+     * https://tools.ietf.org/html/rfc6665#section-4.1.3
+     * @param request - Incoming NOTIFY request.
+     */
+    onNotify?(request: IncomingNotifyRequest): void;
+    /**
+     * Sent a SUBSCRIBE request. This includes "auto refresh" in dialog SUBSCRIBE requests only.
+     * Thus SUBSCRIBE requests triggered by calls to `refresh()` or `subscribe()` will not be provided.
+     * Thus the first SUBSCRIBE (the subscription creating SUBSCRIBE) will not be provided.
+     * @param request - Outgoing SUBSCRIBE request.
+     */
+    onRefresh?(request: OutgoingSubscribeRequest): void;
+    /**
+     * Subscription termination. This includes non-NOTIFY termination causes only.
+     * Thus this will not be called if a NOTIFY is the cause of termination.
+     * https://tools.ietf.org/html/rfc6665#section-4.4.1
+     */
+    onTerminated?(): void;
+}

package/dist/core/subscription/subscription.d.ts

@@ -0,0 +1,55 @@
+import { OutgoingSubscribeRequest, OutgoingSubscribeRequestDelegate, RequestOptions } from "../messages";
+import { SubscriptionDelegate } from "./subscription-delegate";
+/**
+ * Subscription.
+ * @remarks
+ * https://tools.ietf.org/html/rfc6665
+ * @public
+ */
+export interface Subscription {
+    /** Subscription delegate. */
+    delegate: SubscriptionDelegate | undefined;
+    /** The subscription id. */
+    readonly id: string;
+    /** Subscription expires. Number of seconds until the subscription expires. */
+    readonly subscriptionExpires: number;
+    /** Subscription state. */
+    readonly subscriptionState: SubscriptionState;
+    /** If true, refresh subscription prior to expiration. Default is false. */
+    autoRefresh: boolean;
+    /**
+     * Destroy subscription.
+     */
+    dispose(): void;
+    /**
+     * Send re-SUBSCRIBE request.
+     * Refreshing a subscription and unsubscribing.
+     * https://tools.ietf.org/html/rfc6665#section-4.1.2.2
+     * @param delegate - Request delegate.
+     * @param options - Options bucket
+     */
+    subscribe(delegate?: OutgoingSubscribeRequestDelegate, options?: RequestOptions): OutgoingSubscribeRequest;
+    /**
+     * 4.1.2.2.  Refreshing of Subscriptions
+     * https://tools.ietf.org/html/rfc6665#section-4.1.2.2
+     */
+    refresh(): OutgoingSubscribeRequest;
+    /**
+     * 4.1.2.3.  Unsubscribing
+     * https://tools.ietf.org/html/rfc6665#section-4.1.2.3
+     */
+    unsubscribe(): OutgoingSubscribeRequest;
+}
+/**
+ * Subscription state.
+ * @remarks
+ * https://tools.ietf.org/html/rfc6665#section-4.1.2
+ * @public
+ */
+export declare enum SubscriptionState {
+    Initial = "Initial",
+    NotifyWait = "NotifyWait",
+    Pending = "Pending",
+    Active = "Active",
+    Terminated = "Terminated"
+}

package/dist/core/timers.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Timers.
+ * @public
+ */
+export declare const Timers: {
+    T1: number;
+    T2: number;
+    T4: number;
+    TIMER_B: number;
+    TIMER_D: number;
+    TIMER_F: number;
+    TIMER_H: number;
+    TIMER_I: number;
+    TIMER_J: number;
+    TIMER_K: number;
+    TIMER_L: number;
+    TIMER_M: number;
+    TIMER_N: number;
+    PROVISIONAL_RESPONSE_INTERVAL: number;
+};

package/dist/core/transactions/client-transaction.d.ts

@@ -0,0 +1,45 @@
+import { IncomingResponseMessage, OutgoingRequestMessage } from "../messages";
+import { Transport } from "../transport";
+import { Transaction } from "./transaction";
+import { TransactionState } from "./transaction-state";
+import { ClientTransactionUser } from "./transaction-user";
+/**
+ * Client Transaction.
+ * @remarks
+ * The client transaction provides its functionality through the
+ * maintenance of a state machine.
+ *
+ * The TU communicates with the client transaction through a simple
+ * interface.  When the TU wishes to initiate a new transaction, it
+ * creates a client transaction and passes it the SIP request to send
+ * and an IP address, port, and transport to which to send it.  The
+ * client transaction begins execution of its state machine.  Valid
+ * responses are passed up to the TU from the client transaction.
+ * https://tools.ietf.org/html/rfc3261#section-17.1
+ * @public
+ */
+export declare abstract class ClientTransaction extends Transaction {
+    private _request;
+    protected user: ClientTransactionUser;
+    protected constructor(_request: OutgoingRequestMessage, transport: Transport, user: ClientTransactionUser, state: TransactionState, loggerCategory: string);
+    private static makeId;
+    /** The outgoing request the transaction handling. */
+    get request(): OutgoingRequestMessage;
+    /**
+     * A 408 to non-INVITE will always arrive too late to be useful ([3]),
+     * The client already has full knowledge of the timeout. The only
+     * information this message would convey is whether or not the server
+     * believed the transaction timed out. However, with the current design
+     * of the NIT, a client cannot do anything with this knowledge. Thus,
+     * the 408 is simply wasting network resources and contributes to the
+     * response bombardment illustrated in [3].
+     * https://tools.ietf.org/html/rfc4320#section-4.1
+     */
+    protected onRequestTimeout(): void;
+    /**
+     * Receive incoming responses from the transport which match this transaction.
+     * Responses will be delivered to the transaction user as necessary.
+     * @param response - The incoming response.
+     */
+    abstract receiveResponse(response: IncomingResponseMessage): void;
+}

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

@@ -0,0 +1,10 @@
+export * from "./client-transaction";
+export * from "./invite-client-transaction";
+export * from "./invite-server-transaction";
+export * from "./non-invite-client-transaction";
+export * from "./non-invite-server-transaction";
+export * from "./invite-client-transaction";
+export * from "./server-transaction";
+export * from "./transaction-state";
+export * from "./transaction-user";
+export * from "./transaction";

package/dist/core/transactions/invite-client-transaction.d.ts

@@ -0,0 +1,116 @@
+import { TransportError } from "../exceptions";
+import { IncomingResponseMessage, OutgoingRequestMessage } from "../messages";
+import { Transport } from "../transport";
+import { ClientTransaction } from "./client-transaction";
+import { ClientTransactionUser } from "./transaction-user";
+/**
+ * INVITE Client Transaction.
+ * @remarks
+ * The INVITE transaction consists of a three-way handshake.  The client
+ * transaction sends an INVITE, the server transaction sends responses,
+ * and the client transaction sends an ACK.
+ * https://tools.ietf.org/html/rfc3261#section-17.1.1
+ * @public
+ */
+export declare class InviteClientTransaction extends ClientTransaction {
+    private B;
+    private D;
+    private M;
+    /**
+     * Map of 2xx to-tag to ACK.
+     * If value is not undefined, value is the ACK which was sent.
+     * If key exists but value is undefined, a 2xx was received but the ACK not yet sent.
+     * Otherwise, a 2xx was not (yet) received for this transaction.
+     */
+    private ackRetransmissionCache;
+    /**
+     * Constructor.
+     * Upon construction, the outgoing request's Via header is updated by calling `setViaHeader`.
+     * Then `toString` is called on the outgoing request and the message is sent via the transport.
+     * After construction the transaction will be in the "calling" state and the transaction id
+     * will equal the branch parameter set in the Via header of the outgoing request.
+     * https://tools.ietf.org/html/rfc3261#section-17.1.1
+     * @param request - The outgoing INVITE request.
+     * @param transport - The transport.
+     * @param user - The transaction user.
+     */
+    constructor(request: OutgoingRequestMessage, transport: Transport, user: ClientTransactionUser);
+    /**
+     * Destructor.
+     */
+    dispose(): void;
+    /** Transaction kind. Deprecated. */
+    get kind(): string;
+    /**
+     * ACK a 2xx final response.
+     *
+     * The transaction includes the ACK only if the final response was not a 2xx response (the
+     * transaction will generate and send the ACK to the transport automagically). If the
+     * final response was a 2xx, the ACK is not considered part of the transaction (the
+     * transaction user needs to generate and send the ACK).
+     *
+     * This library is not strictly RFC compliant with regard to ACK handling for 2xx final
+     * responses. Specifically, retransmissions of ACKs to a 2xx final responses is handled
+     * by the transaction layer (instead of the UAC core). The "standard" approach is for
+     * the UAC core to receive all 2xx responses and manage sending ACK retransmissions to
+     * the transport directly. Herein the transaction layer manages sending ACKs to 2xx responses
+     * and any retransmissions of those ACKs as needed.
+     *
+     * @param ack - The outgoing ACK request.
+     */
+    ackResponse(ack: OutgoingRequestMessage): void;
+    /**
+     * Handler for incoming responses from the transport which match this transaction.
+     * @param response - The incoming response.
+     */
+    receiveResponse(response: IncomingResponseMessage): void;
+    /**
+     * The client transaction SHOULD inform the TU that a transport failure
+     * has occurred, and the client transaction SHOULD transition directly
+     * to the "Terminated" state.  The TU will handle the failover
+     * mechanisms described in [4].
+     * https://tools.ietf.org/html/rfc3261#section-17.1.4
+     * @param error - The error.
+     */
+    protected onTransportError(error: TransportError): void;
+    /** For logging. */
+    protected typeToString(): string;
+    private ack;
+    /**
+     * Execute a state transition.
+     * @param newState - New state.
+     */
+    private stateTransition;
+    /**
+     * When timer A fires, the client transaction MUST retransmit the
+     * request by passing it to the transport layer, and MUST reset the
+     * timer with a value of 2*T1.
+     * When timer A fires 2*T1 seconds later, the request MUST be
+     * retransmitted again (assuming the client transaction is still in this
+     * state). This process MUST continue so that the request is
+     * retransmitted with intervals that double after each transmission.
+     * These retransmissions SHOULD only be done while the client
+     * transaction is in the "Calling" state.
+     * https://tools.ietf.org/html/rfc3261#section-17.1.1.2
+     */
+    private timerA;
+    /**
+     * If the client transaction is still in the "Calling" state when timer
+     * B fires, the client transaction SHOULD inform the TU that a timeout
+     * has occurred.  The client transaction MUST NOT generate an ACK.
+     * https://tools.ietf.org/html/rfc3261#section-17.1.1.2
+     */
+    private timerB;
+    /**
+     * If Timer D fires while the client transaction is in the "Completed" state,
+     * the client transaction MUST move to the "Terminated" state.
+     * https://tools.ietf.org/html/rfc6026#section-8.4
+     */
+    private timerD;
+    /**
+     * If Timer M fires while the client transaction is in the "Accepted"
+     * state, the client transaction MUST move to the "Terminated" state.
+     * https://tools.ietf.org/html/rfc6026#section-8.4
+     */
+    private timerM;
+}

package/dist/core/transactions/invite-server-transaction.d.ts

@@ -0,0 +1,127 @@
+import { IncomingRequestMessage } from "../messages";
+import { Transport } from "../transport";
+import { ServerTransaction } from "./server-transaction";
+import { ServerTransactionUser } from "./transaction-user";
+/**
+ * INVITE Server Transaction.
+ * @remarks
+ * https://tools.ietf.org/html/rfc3261#section-17.2.1
+ * @public
+ */
+export declare class InviteServerTransaction extends ServerTransaction {
+    private lastFinalResponse;
+    private lastProvisionalResponse;
+    private H;
+    private I;
+    private L;
+    /**
+     * FIXME: This should not be here. It should be in the UAS.
+     *
+     * 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.
+     *
+     *   An INVITE transaction can go on for extended durations when the
+     *   user is placed on hold, or when interworking with PSTN systems
+     *   which allow communications to take place without answering the
+     *   call.  The latter is common in Interactive Voice Response (IVR)
+     *   systems.
+     * https://tools.ietf.org/html/rfc3261#section-13.3.1.1
+     */
+    private progressExtensionTimer;
+    /**
+     * Constructor.
+     * Upon construction, a "100 Trying" reply will be immediately sent.
+     * After construction the transaction will be in the "proceeding" state and the transaction
+     * `id` will equal the branch parameter set in the Via header of the incoming request.
+     * https://tools.ietf.org/html/rfc3261#section-17.2.1
+     * @param request - Incoming INVITE request from the transport.
+     * @param transport - The transport.
+     * @param user - The transaction user.
+     */
+    constructor(request: IncomingRequestMessage, transport: Transport, user: ServerTransactionUser);
+    /**
+     * Destructor.
+     */
+    dispose(): void;
+    /** Transaction kind. Deprecated. */
+    get kind(): string;
+    /**
+     * Receive requests from transport matching this transaction.
+     * @param request - Request matching this transaction.
+     */
+    receiveRequest(request: IncomingRequestMessage): void;
+    /**
+     * Receive responses from TU for this transaction.
+     * @param statusCode - Status code of response.
+     * @param response - Response.
+     */
+    receiveResponse(statusCode: number, response: string): void;
+    /**
+     * Retransmit the last 2xx response. This is a noop if not in the "accepted" state.
+     */
+    retransmitAcceptedResponse(): void;
+    /**
+     * First, the procedures in [4] are followed, which attempt to deliver the response to a backup.
+     * If those should all fail, based on the definition of failure in [4], the server transaction SHOULD
+     * inform the TU that a failure has occurred, and MUST remain in the current state.
+     * https://tools.ietf.org/html/rfc6026#section-8.8
+     */
+    protected onTransportError(error: Error): void;
+    /** For logging. */
+    protected typeToString(): string;
+    /**
+     * Execute a state transition.
+     * @param newState - New state.
+     */
+    private stateTransition;
+    /**
+     * FIXME: UAS Provisional Retransmission Timer. See RFC 3261 Section 13.3.1.1
+     * This is in the wrong place. This is not a transaction level thing. It's a UAS level thing.
+     */
+    private startProgressExtensionTimer;
+    /**
+     * FIXME: UAS Provisional Retransmission Timer id. See RFC 3261 Section 13.3.1.1
+     * This is in the wrong place. This is not a transaction level thing. It's a UAS level thing.
+     */
+    private stopProgressExtensionTimer;
+    /**
+     * While in the "Proceeding" state, if the TU passes a response with status code
+     * from 300 to 699 to the server transaction, the response MUST be passed to the
+     * transport layer for transmission, and the state machine MUST enter the "Completed" state.
+     * For unreliable transports, timer G is set to fire in T1 seconds, and is not set to fire for
+     * reliable transports. If timer G fires, the response is passed to the transport layer once
+     * more for retransmission, and timer G is set to fire in MIN(2*T1, T2) seconds. From then on,
+     * when timer G fires, the response is passed to the transport again for transmission, and
+     * timer G is reset with a value that doubles, unless that value exceeds T2, in which case
+     * it is reset with the value of T2.
+     * https://tools.ietf.org/html/rfc3261#section-17.2.1
+     */
+    private timerG;
+    /**
+     * If timer H fires while in the "Completed" state, it implies that the ACK was never received.
+     * In this case, the server transaction MUST transition to the "Terminated" state, and MUST
+     * indicate to the TU that a transaction failure has occurred.
+     * https://tools.ietf.org/html/rfc3261#section-17.2.1
+     */
+    private timerH;
+    /**
+     * Once timer I fires, the server MUST transition to the "Terminated" state.
+     * https://tools.ietf.org/html/rfc3261#section-17.2.1
+     */
+    private timerI;
+    /**
+     * When Timer L fires and the state machine is in the "Accepted" state, the machine MUST
+     * transition to the "Terminated" state. Once the transaction is in the "Terminated" state,
+     * it MUST be destroyed immediately. Timer L reflects the amount of time the server
+     * transaction could receive 2xx responses for retransmission from the
+     * TU while it is waiting to receive an ACK.
+     * https://tools.ietf.org/html/rfc6026#section-7.1
+     * https://tools.ietf.org/html/rfc6026#section-8.7
+     */
+    private timerL;
+}

package/dist/core/transactions/non-invite-client-transaction.d.ts

@@ -0,0 +1,69 @@
+import { IncomingResponseMessage, OutgoingRequestMessage } from "../messages";
+import { Transport } from "../transport";
+import { ClientTransaction } from "./client-transaction";
+import { ClientTransactionUser } from "./transaction-user";
+/**
+ * Non-INVITE Client Transaction.
+ * @remarks
+ * Non-INVITE transactions do not make use of ACK.
+ * They are simple request-response interactions.
+ * https://tools.ietf.org/html/rfc3261#section-17.1.2
+ * @public
+ */
+export declare class NonInviteClientTransaction extends ClientTransaction {
+    private F;
+    private K;
+    /**
+     * Constructor
+     * Upon construction, the outgoing request's Via header is updated by calling `setViaHeader`.
+     * Then `toString` is called on the outgoing request and the message is sent via the transport.
+     * After construction the transaction will be in the "calling" state and the transaction id
+     * will equal the branch parameter set in the Via header of the outgoing request.
+     * https://tools.ietf.org/html/rfc3261#section-17.1.2
+     * @param request - The outgoing Non-INVITE request.
+     * @param transport - The transport.
+     * @param user - The transaction user.
+     */
+    constructor(request: OutgoingRequestMessage, transport: Transport, user: ClientTransactionUser);
+    /**
+     * Destructor.
+     */
+    dispose(): void;
+    /** Transaction kind. Deprecated. */
+    get kind(): string;
+    /**
+     * Handler for incoming responses from the transport which match this transaction.
+     * @param response - The incoming response.
+     */
+    receiveResponse(response: IncomingResponseMessage): void;
+    /**
+     * The client transaction SHOULD inform the TU that a transport failure has occurred,
+     * and the client transaction SHOULD transition directly to the "Terminated" state.
+     * The TU will handle the fail over mechanisms described in [4].
+     * https://tools.ietf.org/html/rfc3261#section-17.1.4
+     * @param error - Transport error
+     */
+    protected onTransportError(error: Error): void;
+    /** For logging. */
+    protected typeToString(): string;
+    /**
+     * Execute a state transition.
+     * @param newState - New state.
+     */
+    private stateTransition;
+    /**
+     * If Timer F fires while the client transaction is still in the
+     * "Trying" state, the client transaction SHOULD inform the TU about the
+     * timeout, and then it SHOULD enter the "Terminated" state.
+     * If timer F fires while in the "Proceeding" state, the TU MUST be informed of
+     * a timeout, and the client transaction MUST transition to the terminated state.
+     * https://tools.ietf.org/html/rfc3261#section-17.1.2.2
+     */
+    private timerF;
+    /**
+     * If Timer K fires while in this (COMPLETED) state, the client transaction
+     * MUST transition to the "Terminated" state.
+     * https://tools.ietf.org/html/rfc3261#section-17.1.2.2
+     */
+    private timerK;
+}

package/dist/core/transactions/non-invite-server-transaction.d.ts

@@ -0,0 +1,57 @@
+import { IncomingRequestMessage } from "../messages";
+import { Transport } from "../transport";
+import { ServerTransaction } from "./server-transaction";
+import { ServerTransactionUser } from "./transaction-user";
+/**
+ * Non-INVITE Server Transaction.
+ * @remarks
+ * https://tools.ietf.org/html/rfc3261#section-17.2.2
+ * @public
+ */
+export declare class NonInviteServerTransaction extends ServerTransaction {
+    private lastResponse;
+    private J;
+    /**
+     * Constructor.
+     * After construction the transaction will be in the "trying": state and the transaction
+     * `id` will equal the branch parameter set in the Via header of the incoming request.
+     * https://tools.ietf.org/html/rfc3261#section-17.2.2
+     * @param request - Incoming Non-INVITE request from the transport.
+     * @param transport - The transport.
+     * @param user - The transaction user.
+     */
+    constructor(request: IncomingRequestMessage, transport: Transport, user: ServerTransactionUser);
+    /**
+     * Destructor.
+     */
+    dispose(): void;
+    /** Transaction kind. Deprecated. */
+    get kind(): string;
+    /**
+     * Receive requests from transport matching this transaction.
+     * @param request - Request matching this transaction.
+     */
+    receiveRequest(request: IncomingRequestMessage): void;
+    /**
+     * Receive responses from TU for this transaction.
+     * @param statusCode - Status code of response. 101-199 not allowed per RFC 4320.
+     * @param response - Response to send.
+     */
+    receiveResponse(statusCode: number, response: string): void;
+    /**
+     * First, the procedures in [4] are followed, which attempt to deliver the response to a backup.
+     * If those should all fail, based on the definition of failure in [4], the server transaction SHOULD
+     * inform the TU that a failure has occurred, and SHOULD transition to the terminated state.
+     * https://tools.ietf.org/html/rfc3261#section-17.2.4
+     */
+    protected onTransportError(error: Error): void;
+    /** For logging. */
+    protected typeToString(): string;
+    private stateTransition;
+    /**
+     * The server transaction remains in this state until Timer J fires,
+     * at which point it MUST transition to the "Terminated" state.
+     * https://tools.ietf.org/html/rfc3261#section-17.2.2
+     */
+    private timerJ;
+}