ue-softphone-sdk 2.2.2 → 2.2.4

package/dist/api/user-agent.d.ts

@@ -0,0 +1,200 @@
+import { Contact, Logger, LoggerFactory, URI, UserAgentCore } from "../core";
+import { Emitter } from "./emitter";
+import { Inviter } from "./inviter";
+import { InviterOptions } from "./inviter-options";
+import { Publisher } from "./publisher";
+import { Registerer } from "./registerer";
+import { Session } from "./session";
+import { Subscription } from "./subscription";
+import { Transport } from "./transport";
+import { UserAgentDelegate } from "./user-agent-delegate";
+import { UserAgentOptions } from "./user-agent-options";
+import { UserAgentState } from "./user-agent-state";
+/**
+ * A user agent sends and receives requests using a `Transport`.
+ *
+ * @remarks
+ * A user agent (UA) is associated with a user via the user's SIP address of record (AOR)
+ * and acts on behalf of that user to send and receive SIP requests. The user agent can
+ * register to receive incoming requests, as well as create and send outbound messages.
+ * The user agent also maintains the Transport over which its signaling travels.
+ *
+ * @public
+ */
+export declare class UserAgent {
+    /**
+     * Property reserved for use by instance owner.
+     * @defaultValue `undefined`
+     */
+    data: unknown;
+    /**
+     * Delegate.
+     */
+    delegate: UserAgentDelegate | undefined;
+    /** @internal */
+    _publishers: {
+        [id: string]: Publisher;
+    };
+    /** @internal */
+    _registerers: {
+        [id: string]: Registerer;
+    };
+    /** @internal */
+    _sessions: {
+        [id: string]: Session;
+    };
+    /** @internal */
+    _subscriptions: {
+        [id: string]: Subscription;
+    };
+    private _contact;
+    private _state;
+    private _stateEventEmitter;
+    private _transport;
+    private _userAgentCore;
+    /** Logger. */
+    private logger;
+    /** LoggerFactory. */
+    private loggerFactory;
+    /** Options. */
+    private options;
+    /**
+     * Constructs a new instance of the `UserAgent` class.
+     * @param options - Options bucket. See {@link UserAgentOptions} for details.
+     */
+    constructor(options?: Partial<UserAgentOptions>);
+    /**
+     * Create a URI instance from a string.
+     * @param uri - The string to parse.
+     *
+     * @example
+     * ```ts
+     * const uri = UserAgent.makeURI("sip:edgar@example.com");
+     * ```
+     */
+    static makeURI(uri: string): URI | undefined;
+    /** Default user agent options. */
+    private static defaultOptions;
+    /**
+     * Strip properties with undefined values from options.
+     * This is a work around while waiting for missing vs undefined to be addressed (or not)...
+     * https://github.com/Microsoft/TypeScript/issues/13195
+     * @param options - Options to reduce
+     */
+    private static stripUndefinedProperties;
+    /**
+     * User agent configuration.
+     */
+    get configuration(): Required<UserAgentOptions>;
+    /**
+     * User agent contact.
+     */
+    get contact(): Contact;
+    /**
+     * User agent state.
+     */
+    get state(): UserAgentState;
+    /**
+     * User agent state change emitter.
+     */
+    get stateChange(): Emitter<UserAgentState>;
+    /**
+     * User agent transport.
+     */
+    get transport(): Transport;
+    /**
+     * User agent core.
+     */
+    get userAgentCore(): UserAgentCore;
+    /**
+     * The logger.
+     */
+    getLogger(category: string, label?: string): Logger;
+    /**
+     * The logger factory.
+     */
+    getLoggerFactory(): LoggerFactory;
+    /**
+     * True if transport is connected.
+     */
+    isConnected(): boolean;
+    /**
+     * Reconnect the transport.
+     */
+    reconnect(): Promise<void>;
+    /**
+     * Start the user agent.
+     *
+     * @remarks
+     * Resolves if transport connects, otherwise rejects.
+     *
+     * @example
+     * ```ts
+     * userAgent.start()
+     *   .then(() => {
+     *     // userAgent.isConnected() === true
+     *   })
+     *   .catch((error: Error) => {
+     *     // userAgent.isConnected() === false
+     *   });
+     * ```
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the user agent.
+     *
+     * @remarks
+     * Resolves when the user agent has completed a graceful shutdown.
+     * ```txt
+     * 1) Sessions terminate.
+     * 2) Registerers unregister.
+     * 3) Subscribers unsubscribe.
+     * 4) Publishers unpublish.
+     * 5) Transport disconnects.
+     * 6) User Agent Core resets.
+     * ```
+     * NOTE: While this is a "graceful shutdown", it can also be very slow one if you
+     * are waiting for the returned Promise to resolve. The disposal of the clients and
+     * dialogs is done serially - waiting on one to finish before moving on to the next.
+     * This can be slow if there are lot of subscriptions to unsubscribe for example.
+     *
+     * THE SLOW PACE IS INTENTIONAL!
+     * While one could spin them all down in parallel, this could slam the remote server.
+     * It is bad practice to denial of service attack (DoS attack) servers!!!
+     * Moreover, production servers will automatically blacklist clients which send too
+     * many requests in too short a period of time - dropping any additional requests.
+     *
+     * If a different approach to disposing is needed, one can implement whatever is
+     * needed and execute that prior to calling `stop()`. Alternatively one may simply
+     * not wait for the Promise returned by `stop()` to complete.
+     */
+    stop(): Promise<void>;
+    /**
+     * Used to avoid circular references.
+     * @internal
+     */
+    _makeInviter(targetURI: URI, options?: InviterOptions): Inviter;
+    /**
+     * Attempt reconnection up to `maxReconnectionAttempts` times.
+     * @param reconnectionAttempt - Current attempt number.
+     */
+    private attemptReconnection;
+    /**
+     * Initialize contact.
+     */
+    private initContact;
+    /**
+     * Initialize user agent core.
+     */
+    private initCore;
+    private initTransportCallbacks;
+    private onTransportConnect;
+    private onTransportDisconnect;
+    private onTransportMessage;
+    /**
+     * Transition state.
+     */
+    private transitionState;
+    /** Unload listener. */
+    private unloadListener;
+}

package/dist/core/dialogs/dialog-state.d.ts

@@ -0,0 +1,34 @@
+import { URI } from "../../grammar";
+/**
+ * Dialog state.
+ * @remarks
+ * A dialog contains certain pieces of state needed for further message
+ * transmissions within the dialog.  This state consists of the dialog
+ * ID, a local sequence number (used to order requests from the UA to
+ * its peer), a remote sequence number (used to order requests from its
+ * peer to the UA), a local URI, a remote URI, remote target, a boolean
+ * flag called "secure", and a route set, which is an ordered list of
+ * URIs.  The route set is the list of servers that need to be traversed
+ * to send a request to the peer.  A dialog can also be in the "early"
+ * state, which occurs when it is created with a provisional response,
+ * and then transition to the "confirmed" state when a 2xx final
+ * response arrives.  For other responses, or if no response arrives at
+ * all on that dialog, the early dialog terminates.
+ *
+ * https://tools.ietf.org/html/rfc3261#section-12
+ * @public
+ */
+export interface DialogState {
+    id: string;
+    early: boolean;
+    callId: string;
+    localTag: string;
+    remoteTag: string;
+    localSequenceNumber: number | undefined;
+    remoteSequenceNumber: number | undefined;
+    localURI: URI;
+    remoteURI: URI;
+    remoteTarget: URI;
+    routeSet: Array<string>;
+    secure: boolean;
+}

package/dist/core/dialogs/dialog.d.ts

@@ -0,0 +1,161 @@
+import { Body, IncomingRequestMessage, IncomingResponseMessage, OutgoingRequestMessage, URI } from "../messages";
+import { UserAgentCore } from "../user-agent-core";
+import { DialogState } from "./dialog-state";
+/**
+ * Dialog.
+ * @remarks
+ * A key concept for a user agent is that of a dialog.  A dialog
+ * represents a peer-to-peer SIP relationship between two user agents
+ * that persists for some time.  The dialog facilitates sequencing of
+ * messages between the user agents and proper routing of requests
+ * between both of them.  The dialog represents a context in which to
+ * interpret SIP messages.
+ * https://tools.ietf.org/html/rfc3261#section-12
+ * @public
+ */
+export declare class Dialog {
+    protected core: UserAgentCore;
+    protected dialogState: DialogState;
+    /**
+     * Dialog constructor.
+     * @param core - User agent core.
+     * @param dialogState - Initial dialog state.
+     */
+    protected constructor(core: UserAgentCore, dialogState: DialogState);
+    /**
+     * When a UAC receives a response that establishes a dialog, it
+     * constructs the state of the dialog.  This state MUST be maintained
+     * for the duration of the dialog.
+     * https://tools.ietf.org/html/rfc3261#section-12.1.2
+     * @param outgoingRequestMessage - Outgoing request message for dialog.
+     * @param incomingResponseMessage - Incoming response message creating dialog.
+     */
+    static initialDialogStateForUserAgentClient(outgoingRequestMessage: OutgoingRequestMessage, incomingResponseMessage: IncomingResponseMessage): DialogState;
+    /**
+     * The UAS then constructs the state of the dialog.  This state MUST be
+     * maintained for the duration of the dialog.
+     * https://tools.ietf.org/html/rfc3261#section-12.1.1
+     * @param incomingRequestMessage - Incoming request message creating dialog.
+     * @param toTag - Tag in the To field in the response to the incoming request.
+     */
+    static initialDialogStateForUserAgentServer(incomingRequestMessage: IncomingRequestMessage, toTag: string, early?: boolean): DialogState;
+    /** Destructor. */
+    dispose(): void;
+    /**
+     * A dialog is identified at each UA with a dialog ID, which consists of
+     * a Call-ID value, a local tag and a remote tag.  The dialog ID at each
+     * UA involved in the dialog is not the same.  Specifically, the local
+     * tag at one UA is identical to the remote tag at the peer UA.  The
+     * tags are opaque tokens that facilitate the generation of unique
+     * dialog IDs.
+     * https://tools.ietf.org/html/rfc3261#section-12
+     */
+    get id(): string;
+    /**
+     * A dialog can also be in the "early" state, which occurs when it is
+     * created with a provisional response, and then it transition to the
+     * "confirmed" state when a 2xx final response received or is sent.
+     *
+     * Note: RFC 3261 is concise on when a dialog is "confirmed", but it
+     * can be a point of confusion if an INVITE dialog is "confirmed" after
+     * a 2xx is sent or after receiving the ACK for the 2xx response.
+     * With careful reading it can be inferred a dialog is always is
+     * "confirmed" when the 2xx is sent (regardless of type of dialog).
+     * However a INVITE dialog does have additional considerations
+     * when it is confirmed but an ACK has not yet been received (in
+     * particular with regard to a callee sending BYE requests).
+     */
+    get early(): boolean;
+    /** Call identifier component of the dialog id. */
+    get callId(): string;
+    /** Local tag component of the dialog id. */
+    get localTag(): string;
+    /** Remote tag component of the dialog id. */
+    get remoteTag(): string;
+    /** Local sequence number (used to order requests from the UA to its peer). */
+    get localSequenceNumber(): number | undefined;
+    /** Remote sequence number (used to order requests from its peer to the UA). */
+    get remoteSequenceNumber(): number | undefined;
+    /** Local URI. */
+    get localURI(): URI;
+    /** Remote URI. */
+    get remoteURI(): URI;
+    /** Remote target. */
+    get remoteTarget(): URI;
+    /**
+     * Route set, which is an ordered list of URIs. The route set is the
+     * list of servers that need to be traversed to send a request to the peer.
+     */
+    get routeSet(): Array<string>;
+    /**
+     * If the request was sent over TLS, and the Request-URI contained
+     * a SIPS URI, the "secure" flag is set to true. *NOT IMPLEMENTED*
+     */
+    get secure(): boolean;
+    /** The user agent core servicing this dialog. */
+    get userAgentCore(): UserAgentCore;
+    /** Confirm the dialog. Only matters if dialog is currently early. */
+    confirm(): void;
+    /**
+     * Requests sent within a dialog, as any other requests, are atomic.  If
+     * a particular request is accepted by the UAS, all the state changes
+     * associated with it are performed.  If the request is rejected, none
+     * of the state changes are performed.
+     *
+     *    Note that some requests, such as INVITEs, affect several pieces of
+     *    state.
+     *
+     * https://tools.ietf.org/html/rfc3261#section-12.2.2
+     * @param message - Incoming request message within this dialog.
+     */
+    receiveRequest(message: IncomingRequestMessage): void;
+    /**
+     * If the dialog identifier in the 2xx response matches the dialog
+     * identifier of an existing dialog, the dialog MUST be transitioned to
+     * the "confirmed" state, and the route set for the dialog MUST be
+     * recomputed based on the 2xx response using the procedures of Section
+     * 12.2.1.2.  Otherwise, a new dialog in the "confirmed" state MUST be
+     * constructed using the procedures of Section 12.1.2.
+     *
+     * Note that the only piece of state that is recomputed is the route
+     * set.  Other pieces of state such as the highest sequence numbers
+     * (remote and local) sent within the dialog are not recomputed.  The
+     * route set only is recomputed for backwards compatibility.  RFC
+     * 2543 did not mandate mirroring of the Record-Route header field in
+     * a 1xx, only 2xx.  However, we cannot update the entire state of
+     * the dialog, since mid-dialog requests may have been sent within
+     * the early dialog, modifying the sequence numbers, for example.
+     *
+     *  https://tools.ietf.org/html/rfc3261#section-13.2.2.4
+     */
+    recomputeRouteSet(message: IncomingResponseMessage): void;
+    /**
+     * A request within a dialog is constructed by using many of the
+     * components of the state stored as part of the dialog.
+     * https://tools.ietf.org/html/rfc3261#section-12.2.1.1
+     * @param method - Outgoing request method.
+     */
+    createOutgoingRequestMessage(method: string, options?: {
+        cseq?: number;
+        extraHeaders?: Array<string>;
+        body?: Body;
+    }): OutgoingRequestMessage;
+    /**
+     * Increment the local sequence number by one.
+     * It feels like this should be protected, but the current authentication handling currently
+     * needs this to keep the dialog in sync when "auto re-sends" request messages.
+     * @internal
+     */
+    incrementLocalSequenceNumber(): void;
+    /**
+     * If the remote sequence number was not empty, but the sequence number
+     * of the request is lower than the remote sequence number, the request
+     * is out of order and MUST be rejected with a 500 (Server Internal
+     * Error) response.
+     * https://tools.ietf.org/html/rfc3261#section-12.2.2
+     * @param request - Incoming request to guard.
+     * @returns True if the program execution is to continue in the branch in question.
+     *          Otherwise a 500 Server Internal Error was stateless sent and request processing must stop.
+     */
+    protected sequenceGuard(message: IncomingRequestMessage): boolean;
+}

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

@@ -0,0 +1,4 @@
+export * from "./dialog";
+export * from "./dialog-state";
+export * from "./session-dialog";
+export * from "./subscription-dialog";

package/dist/core/dialogs/session-dialog.d.ts

@@ -0,0 +1,196 @@
+import { Body, IncomingRequestMessage, IncomingResponseMessage, OutgoingAckRequest, OutgoingByeRequest, OutgoingInfoRequest, OutgoingInviteRequest, OutgoingInviteRequestDelegate, OutgoingMessageRequest, OutgoingNotifyRequest, OutgoingPrackRequest, OutgoingReferRequest, OutgoingRequestDelegate, OutgoingRequestMessage, RequestOptions } from "../messages";
+import { Session, SessionDelegate, SessionState, SignalingState } from "../session";
+import { InviteClientTransaction, InviteServerTransaction } from "../transactions";
+import { UserAgentCore } from "../user-agent-core";
+import { ReInviteUserAgentClient } from "../user-agents/re-invite-user-agent-client";
+import { ReInviteUserAgentServer } from "../user-agents/re-invite-user-agent-server";
+import { Dialog } from "./dialog";
+import { DialogState } from "./dialog-state";
+/**
+ * Session Dialog.
+ * @public
+ */
+export declare class SessionDialog extends Dialog implements Session {
+    private initialTransaction;
+    delegate: SessionDelegate | undefined;
+    reinviteUserAgentClient: ReInviteUserAgentClient | undefined;
+    reinviteUserAgentServer: ReInviteUserAgentServer | undefined;
+    /** The state of the offer/answer exchange. */
+    private _signalingState;
+    /** The current offer. Undefined unless signaling state HaveLocalOffer, HaveRemoteOffer, or Stable. */
+    private _offer;
+    /** The current answer. Undefined unless signaling state Stable. */
+    private _answer;
+    /** The rollback offer. Undefined unless signaling state HaveLocalOffer or HaveRemoteOffer. */
+    private _rollbackOffer;
+    /** The rollback answer. Undefined unless signaling state HaveLocalOffer or HaveRemoteOffer. */
+    private _rollbackAnswer;
+    /** True if waiting for an ACK to the initial transaction 2xx (UAS only). */
+    private ackWait;
+    /** True if processing an ACK to the initial transaction 2xx (UAS only). */
+    private ackProcessing;
+    /** Retransmission timer for 2xx response which confirmed the dialog. */
+    private invite2xxTimer;
+    /** The rseq of the last reliable response. */
+    private rseq;
+    private logger;
+    constructor(initialTransaction: InviteClientTransaction | InviteServerTransaction, core: UserAgentCore, state: DialogState, delegate?: SessionDelegate);
+    dispose(): void;
+    get sessionState(): SessionState;
+    /** The state of the offer/answer exchange. */
+    get signalingState(): SignalingState;
+    /** The current offer. Undefined unless signaling state HaveLocalOffer, HaveRemoteOffer, of Stable. */
+    get offer(): Body | undefined;
+    /** The current answer. Undefined unless signaling state Stable. */
+    get answer(): Body | undefined;
+    /** Confirm the dialog. Only matters if dialog is currently early. */
+    confirm(): void;
+    /** Re-confirm the dialog. Only matters if handling re-INVITE request. */
+    reConfirm(): void;
+    /**
+     * The UAC core MUST generate an ACK request for each 2xx received from
+     * the transaction layer.  The header fields of the ACK are constructed
+     * in the same way as for any request sent within a dialog (see Section
+     * 12) with the exception of the CSeq and the header fields related to
+     * authentication.  The sequence number of the CSeq header field MUST be
+     * the same as the INVITE being acknowledged, but the CSeq method MUST
+     * be ACK.  The ACK MUST contain the same credentials as the INVITE.  If
+     * the 2xx contains an offer (based on the rules above), the ACK MUST
+     * carry an answer in its body.  If the offer in the 2xx response is not
+     * acceptable, the UAC core MUST generate a valid answer in the ACK and
+     * then send a BYE immediately.
+     * https://tools.ietf.org/html/rfc3261#section-13.2.2.4
+     * @param options - ACK options bucket.
+     */
+    ack(options?: RequestOptions): OutgoingAckRequest;
+    /**
+     * Terminating a Session
+     *
+     * This section describes the procedures for terminating a session
+     * established by SIP.  The state of the session and the state of the
+     * dialog are very closely related.  When a session is initiated with an
+     * INVITE, each 1xx or 2xx response from a distinct UAS creates a
+     * dialog, and if that response completes the offer/answer exchange, it
+     * also creates a session.  As a result, each session is "associated"
+     * with a single dialog - the one which resulted in its creation.  If an
+     * initial INVITE generates a non-2xx final response, that terminates
+     * all sessions (if any) and all dialogs (if any) that were created
+     * through responses to the request.  By virtue of completing the
+     * transaction, a non-2xx final response also prevents further sessions
+     * from being created as a result of the INVITE.  The BYE request is
+     * used to terminate a specific session or attempted session.  In this
+     * case, the specific session is the one with the peer UA on the other
+     * side of the dialog.  When a BYE is received on a dialog, any session
+     * associated with that dialog SHOULD terminate.  A UA MUST NOT send a
+     * BYE outside of a dialog.  The caller's UA MAY send a BYE for either
+     * confirmed or early dialogs, and the callee's UA MAY send a BYE on
+     * confirmed dialogs, but MUST NOT send a BYE on early dialogs.
+     *
+     * However, the callee's UA MUST NOT send a BYE on a confirmed dialog
+     * until it has received an ACK for its 2xx response or until the server
+     * transaction times out.  If no SIP extensions have defined other
+     * application layer states associated with the dialog, the BYE also
+     * terminates the dialog.
+     *
+     * https://tools.ietf.org/html/rfc3261#section-15
+     * FIXME: Make these proper Exceptions...
+     * @param options - BYE options bucket.
+     * @returns
+     * Throws `Error` if callee's UA attempts a BYE on an early dialog.
+     * Throws `Error` if callee's UA attempts a BYE on a confirmed dialog
+     *                while it's waiting on the ACK for its 2xx response.
+     */
+    bye(delegate?: OutgoingRequestDelegate, options?: RequestOptions): OutgoingByeRequest;
+    /**
+     * An INFO request can be associated with an Info Package (see
+     * Section 5), or associated with a legacy INFO usage (see Section 2).
+     *
+     * The construction of the INFO request is the same as any other
+     * non-target refresh request within an existing invite dialog usage as
+     * described in Section 12.2 of RFC 3261.
+     * https://tools.ietf.org/html/rfc6086#section-4.2.1
+     * @param options - Options bucket.
+     */
+    info(delegate?: OutgoingRequestDelegate, options?: RequestOptions): OutgoingInfoRequest;
+    /**
+     * Modifying an Existing Session
+     *
+     * A successful INVITE request (see Section 13) establishes both a
+     * dialog between two user agents and a session using the offer-answer
+     * model.  Section 12 explains how to modify an existing dialog using a
+     * target refresh request (for example, changing the remote target URI
+     * of the dialog).  This section describes how to modify the actual
+     * session.  This modification can involve changing addresses or ports,
+     * adding a media stream, deleting a media stream, and so on.  This is
+     * accomplished by sending a new INVITE request within the same dialog
+     * that established the session.  An INVITE request sent within an
+     * existing dialog is known as a re-INVITE.
+     *
+     *    Note that a single re-INVITE can modify the dialog and the
+     *    parameters of the session at the same time.
+     *
+     * Either the caller or callee can modify an existing session.
+     * https://tools.ietf.org/html/rfc3261#section-14
+     * @param options - Options bucket
+     */
+    invite(delegate?: OutgoingInviteRequestDelegate, options?: RequestOptions): OutgoingInviteRequest;
+    /**
+     * A UAC MAY associate a MESSAGE request with an existing dialog.  If a
+     * MESSAGE request is sent within a dialog, it is "associated" with any
+     * media session or sessions associated with that dialog.
+     * https://tools.ietf.org/html/rfc3428#section-4
+     * @param options - Options bucket.
+     */
+    message(delegate: OutgoingRequestDelegate, options?: RequestOptions): OutgoingMessageRequest;
+    /**
+     * The NOTIFY mechanism defined in [2] MUST be used to inform the agent
+     * sending the REFER of the status of the reference.
+     * https://tools.ietf.org/html/rfc3515#section-2.4.4
+     * @param options - Options bucket.
+     */
+    notify(delegate?: OutgoingRequestDelegate, options?: RequestOptions): OutgoingNotifyRequest;
+    /**
+     * Assuming the response is to be transmitted reliably, the UAC MUST
+     * create a new request with method PRACK.  This request is sent within
+     * the dialog associated with the provisional response (indeed, the
+     * provisional response may have created the dialog).  PRACK requests
+     * MAY contain bodies, which are interpreted according to their type and
+     * disposition.
+     * https://tools.ietf.org/html/rfc3262#section-4
+     * @param options - Options bucket.
+     */
+    prack(delegate?: OutgoingRequestDelegate, options?: RequestOptions): OutgoingPrackRequest;
+    /**
+     * REFER is a SIP request and is constructed as defined in [1].  A REFER
+     * request MUST contain exactly one Refer-To header field value.
+     * https://tools.ietf.org/html/rfc3515#section-2.4.1
+     * @param options - Options bucket.
+     */
+    refer(delegate?: OutgoingRequestDelegate, options?: RequestOptions): OutgoingReferRequest;
+    /**
+     * Requests sent within a dialog, as any other requests, are atomic.  If
+     * a particular request is accepted by the UAS, all the state changes
+     * associated with it are performed.  If the request is rejected, none
+     * of the state changes are performed.
+     * https://tools.ietf.org/html/rfc3261#section-12.2.2
+     * @param message - Incoming request message within this dialog.
+     */
+    receiveRequest(message: IncomingRequestMessage): void;
+    /**
+     * Guard against out of order reliable provisional responses and retransmissions.
+     * Returns false if the response should be discarded, otherwise true.
+     * @param message - Incoming response message within this dialog.
+     */
+    reliableSequenceGuard(message: IncomingResponseMessage): boolean;
+    /**
+     * If not in a stable signaling state, rollback to prior stable signaling state.
+     */
+    signalingStateRollback(): void;
+    /**
+     * Update the signaling state of the dialog.
+     * @param message - The message to base the update off of.
+     */
+    signalingStateTransition(message: IncomingRequestMessage | IncomingResponseMessage | OutgoingRequestMessage | Body): void;
+    private start2xxRetransmissionTimer;
+    private startReInvite2xxRetransmissionTimer;
+}