ue-softphone-sdk 2.2.2 → 2.2.4

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

@@ -0,0 +1,35 @@
+import { IncomingRequestMessage } from "../messages";
+import { Transport } from "../transport";
+import { Transaction } from "./transaction";
+import { TransactionState } from "./transaction-state";
+import { ServerTransactionUser } from "./transaction-user";
+/**
+ * Server Transaction.
+ * @remarks
+ * The server transaction is responsible for the delivery of requests to
+ * the TU and the reliable transmission of responses.  It accomplishes
+ * this through a state machine.  Server transactions are created by the
+ * core when a request is received, and transaction handling is desired
+ * for that request (this is not always the case).
+ * https://tools.ietf.org/html/rfc3261#section-17.2
+ * @public
+ */
+export declare abstract class ServerTransaction extends Transaction {
+    private _request;
+    protected user: ServerTransactionUser;
+    protected constructor(_request: IncomingRequestMessage, transport: Transport, user: ServerTransactionUser, state: TransactionState, loggerCategory: string);
+    /** The incoming request the transaction handling. */
+    get request(): IncomingRequestMessage;
+    /**
+     * Receive incoming requests from the transport which match this transaction.
+     * @param request - The incoming request.
+     */
+    abstract receiveRequest(request: IncomingRequestMessage): void;
+    /**
+     * Receive outgoing responses to this request from the transaction user.
+     * Responses will be delivered to the transport as necessary.
+     * @param statusCode - Response status code.
+     * @param response - Response.
+     */
+    abstract receiveResponse(statusCode: number, response: string): void;
+}

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

@@ -0,0 +1,13 @@
+/**
+ * Transaction state.
+ * @public
+ */
+export declare enum TransactionState {
+    Accepted = "Accepted",
+    Calling = "Calling",
+    Completed = "Completed",
+    Confirmed = "Confirmed",
+    Proceeding = "Proceeding",
+    Terminated = "Terminated",
+    Trying = "Trying"
+}

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

@@ -0,0 +1,72 @@
+import { TransportError } from "../exceptions";
+import { LoggerFactory } from "../log";
+import { IncomingResponseMessage } from "../messages";
+import { TransactionState } from "./transaction-state";
+/**
+ * Transaction User (TU).
+ * @remarks
+ * The layer of protocol processing that resides above the transaction layer.
+ * Transaction users include the UAC core, UAS core, and proxy core.
+ * https://tools.ietf.org/html/rfc3261#section-5
+ * https://tools.ietf.org/html/rfc3261#section-6
+ * @public
+ */
+export interface TransactionUser {
+    /**
+     * Logger factory.
+     */
+    loggerFactory: LoggerFactory;
+    /**
+     * Callback for notification of transaction state changes.
+     *
+     * Not called when transaction is constructed, so there is
+     * no notification of entering the initial transaction state.
+     * Otherwise, called once for each transaction state change.
+     * State changes adhere to the following RFCs.
+     * https://tools.ietf.org/html/rfc3261#section-17
+     * https://tools.ietf.org/html/rfc6026
+     */
+    onStateChange?: (newState: TransactionState) => void;
+    /**
+     * Callback for notification of a transport error.
+     *
+     * 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
+     * https://tools.ietf.org/html/rfc3261#section-17.1.4
+     * https://tools.ietf.org/html/rfc3261#section-17.2.4
+     * https://tools.ietf.org/html/rfc6026
+     */
+    onTransportError?: (error: TransportError) => void;
+}
+/**
+ * UAC Core Transaction User.
+ * @public
+ */
+export interface ClientTransactionUser extends TransactionUser {
+    /**
+     * Callback for request timeout 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.
+     * https://tools.ietf.org/html/rfc3261#section-8.1.3.1
+     * TU MUST be informed of a timeout.
+     * https://tools.ietf.org/html/rfc3261#section-17.1.2.2
+     */
+    onRequestTimeout?: () => void;
+    /**
+     * Callback for delegation of valid response handling.
+     *
+     * Valid responses are passed up to the TU from the client transaction.
+     * https://tools.ietf.org/html/rfc3261#section-17.1
+     */
+    receiveResponse?: (response: IncomingResponseMessage) => void;
+}
+/**
+ * UAS Core Transaction User.
+ * @public
+ */
+export interface ServerTransactionUser extends TransactionUser {
+}

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

@@ -0,0 +1,79 @@
+import { TransportError } from "../exceptions";
+import { Logger } from "../log";
+import { Transport } from "../transport";
+import { TransactionState } from "./transaction-state";
+import { TransactionUser } from "./transaction-user";
+/**
+ * Transaction.
+ * @remarks
+ * SIP is a transactional protocol: interactions between components take
+ * place in a series of independent message exchanges.  Specifically, a
+ * SIP transaction consists of a single request and any responses to
+ * that request, which include zero or more provisional responses and
+ * one or more final responses.  In the case of a transaction where the
+ * request was an INVITE (known as an INVITE transaction), the
+ * transaction also includes the ACK only if the final response was not
+ * a 2xx response.  If the response was a 2xx, the ACK is not considered
+ * part of the transaction.
+ * https://tools.ietf.org/html/rfc3261#section-17
+ * @public
+ */
+export declare abstract class Transaction {
+    private _transport;
+    private _user;
+    private _id;
+    private _state;
+    protected logger: Logger;
+    private listeners;
+    protected constructor(_transport: Transport, _user: TransactionUser, _id: string, _state: TransactionState, loggerCategory: string);
+    /**
+     * Destructor.
+     * Once the transaction is in the "terminated" state, it is destroyed
+     * immediately and there is no need to call `dispose`. However, if a
+     * transaction needs to be ended prematurely, the transaction user may
+     * do so by calling this method (for example, perhaps the UA is shutting down).
+     * No state transition will occur upon calling this method, all outstanding
+     * transmission timers will be cancelled, and use of the transaction after
+     * calling `dispose` is undefined.
+     */
+    dispose(): void;
+    /** Transaction id. */
+    get id(): string;
+    /** Transaction kind. Deprecated. */
+    get kind(): string;
+    /** Transaction state. */
+    get state(): TransactionState;
+    /** Transaction transport. */
+    get transport(): Transport;
+    /**
+     * Sets up a function that will be called whenever the transaction state changes.
+     * @param listener - Callback function.
+     * @param options - An options object that specifies characteristics about the listener.
+     *                  If once true, indicates that the listener should be invoked at most once after being added.
+     *                  If once true, the listener would be automatically removed when invoked.
+     */
+    addStateChangeListener(listener: () => void, options?: {
+        once?: boolean;
+    }): void;
+    /**
+     * This is currently public so tests may spy on it.
+     * @internal
+     */
+    notifyStateChangeListeners(): void;
+    /**
+     * Removes a listener previously registered with addStateListener.
+     * @param listener - Callback function.
+     */
+    removeStateChangeListener(listener: () => void): void;
+    protected logTransportError(error: TransportError, message: string): void;
+    /**
+     * Pass message to transport for transmission. If transport fails,
+     * the transaction user is notified by callback to onTransportError().
+     * @returns
+     * Rejects with `TransportError` if transport fails.
+     */
+    protected send(message: string): Promise<void>;
+    protected setState(state: TransactionState): void;
+    protected typeToString(): string;
+    protected abstract onTransportError(error: TransportError): void;
+}

package/dist/core/transport.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Transport layer interface expected by the user agent core.
+ *
+ * @remarks
+ * The transport layer is responsible for the actual transmission of
+ * requests and responses over network transports.  This includes
+ * determination of the connection to use for a request or response in
+ * the case of connection-oriented transports.
+ * https://tools.ietf.org/html/rfc3261#section-18
+ *
+ * @public
+ */
+export interface Transport {
+    /**
+     * The transport protocol.
+     *
+     * @remarks
+     * Formatted as defined for the Via header sent-protocol transport.
+     * https://tools.ietf.org/html/rfc3261#section-20.42
+     */
+    readonly protocol: string;
+    /**
+     * Send a message.
+     *
+     * @remarks
+     * Resolves once message is sent. Otherwise rejects with an Error.
+     *
+     * @param message - Message to send.
+     */
+    send(message: string): Promise<void>;
+}

package/dist/core/user-agent-core/allowed-methods.d.ts

@@ -0,0 +1,4 @@
+/**
+ * FIXME: TODO: Should be configurable/variable.
+ */
+export declare const AllowedMethods: string[];

package/dist/core/user-agent-core/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./user-agent-core";
+export * from "./user-agent-core-configuration";
+export * from "./user-agent-core-delegate";

package/dist/core/user-agent-core/user-agent-core-configuration.d.ts

@@ -0,0 +1,99 @@
+import { LoggerFactory } from "../log";
+import { DigestAuthentication, URI } from "../messages";
+import { Transport } from "../transport";
+/**
+ * Contact.
+ * @remarks
+ * https://tools.ietf.org/html/rfc3261#section-8.1.1.8
+ * This is ported from UA.contact.
+ * FIXME: TODO: This is not a great rep for Contact
+ * and is used in a kinda hacky way herein.
+ * @public
+ */
+export interface Contact {
+    pubGruu: URI | undefined;
+    tempGruu: URI | undefined;
+    uri: URI;
+    toString: (options?: {
+        anonymous?: boolean;
+        outbound?: boolean;
+    }) => string;
+}
+/**
+ * User Agent Core configuration.
+ * @public
+ */
+export interface UserAgentCoreConfiguration {
+    /**
+     * Address-of-Record (AOR).
+     * @remarks
+     * https://tools.ietf.org/html/rfc3261#section-6
+     */
+    aor: URI;
+    /**
+     * Contact.
+     * @remarks
+     * https://tools.ietf.org/html/rfc3261#section-8.1.1.8
+     */
+    contact: Contact;
+    /**
+     * From header display name.
+     */
+    displayName: string;
+    /**
+     * Logger factory.
+     */
+    loggerFactory: LoggerFactory;
+    /**
+     * Force Via header field transport to TCP.
+     */
+    hackViaTcp: boolean;
+    /**
+     * Preloaded route set.
+     */
+    routeSet: Array<string>;
+    /**
+     * Unique instance id.
+     */
+    sipjsId: string;
+    /**
+     * Option tags of supported SIP extensions.
+     */
+    supportedOptionTags: Array<string>;
+    /**
+     * Option tags of supported SIP extensions.
+     * Used in responses.
+     * @remarks
+     * FIXME: Make this go away.
+     */
+    supportedOptionTagsResponse: Array<string>;
+    /**
+     * User-Agent header field value.
+     * @remarks
+     * https://tools.ietf.org/html/rfc3261#section-20.41
+     */
+    userAgentHeaderFieldValue: string | undefined;
+    /**
+     * Force use of "rport" Via header field parameter.
+     * @remarks
+     * https://www.ietf.org/rfc/rfc3581.txt
+     */
+    viaForceRport: boolean;
+    /**
+     * Via header field host name or network address.
+     * @remarks
+     * The Via header field indicates the path taken by the request so far
+     * and indicates the path that should be followed in routing responses.
+     */
+    viaHost: string;
+    /**
+     * DEPRECATED
+     * Authentication factory function.
+     */
+    authenticationFactory(): DigestAuthentication | undefined;
+    /**
+     * DEPRECATED: This is a hack to get around `Transport`
+     * requiring the `UA` to start for construction.
+     */
+    transportAccessor(): Transport | undefined;
+}

package/dist/core/user-agent-core/user-agent-core-delegate.d.ts

@@ -0,0 +1,37 @@
+import { IncomingInviteRequest, IncomingMessageRequest, IncomingNotifyRequest, IncomingReferRequest, IncomingRegisterRequest, IncomingSubscribeRequest } from "../messages";
+/**
+ * User Agent Core delegate.
+ * @public
+ */
+export interface UserAgentCoreDelegate {
+    /**
+     * Receive INVITE request.
+     * @param request - Incoming INVITE request.
+     */
+    onInvite?(request: IncomingInviteRequest): void;
+    /**
+     * Receive MESSAGE request.
+     * @param request - Incoming MESSAGE request.
+     */
+    onMessage?(request: IncomingMessageRequest): void;
+    /**
+     * DEPRECATED. Receive NOTIFY request.
+     * @param message - Incoming NOTIFY request.
+     */
+    onNotify?(request: IncomingNotifyRequest): void;
+    /**
+     * Receive REFER request.
+     * @param request - Incoming REFER request.
+     */
+    onRefer?(request: IncomingReferRequest): void;
+    /**
+     * Receive REGISTER request.
+     * @param request - Incoming REGISTER request.
+     */
+    onRegister?(request: IncomingRegisterRequest): void;
+    /**
+     * Receive SUBSCRIBE request.
+     * @param request - Incoming SUBSCRIBE request.
+     */
+    onSubscribe?(request: IncomingSubscribeRequest): void;
+}

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

@@ -0,0 +1,179 @@
+import { Dialog } from "../dialogs";
+import { LoggerFactory } from "../log";
+import { Body, IncomingRequestMessage, IncomingResponseMessage, OutgoingInviteRequest, OutgoingInviteRequestDelegate, OutgoingMessageRequest, OutgoingPublishRequest, OutgoingRegisterRequest, OutgoingRequest, OutgoingRequestDelegate, OutgoingRequestMessage, OutgoingRequestMessageOptions, OutgoingResponse, OutgoingSubscribeRequest, OutgoingSubscribeRequestDelegate, ResponseOptions, URI } from "../messages";
+import { Transport } from "../transport";
+import { SubscribeUserAgentClient, UserAgentClient, UserAgentServer } from "../user-agents";
+import { UserAgentCoreConfiguration } from "./user-agent-core-configuration";
+import { UserAgentCoreDelegate } from "./user-agent-core-delegate";
+/**
+ * User Agent Core.
+ * @remarks
+ * Core designates the functions specific to a particular type
+ * of SIP entity, i.e., specific to either a stateful or stateless
+ * proxy, a user agent or registrar.  All cores, except those for
+ * the stateless proxy, are transaction users.
+ * https://tools.ietf.org/html/rfc3261#section-6
+ *
+ * UAC Core: The set of processing functions required of a UAC that
+ * reside above the transaction and transport layers.
+ * https://tools.ietf.org/html/rfc3261#section-6
+ *
+ * UAS Core: The set of processing functions required at a UAS that
+ * resides above the transaction and transport layers.
+ * https://tools.ietf.org/html/rfc3261#section-6
+ * @public
+ */
+export declare class UserAgentCore {
+    /** Configuration. */
+    configuration: UserAgentCoreConfiguration;
+    /** Delegate. */
+    delegate: UserAgentCoreDelegate;
+    /** Dialogs. */
+    dialogs: Map<string, Dialog>;
+    /** Subscribers. */
+    subscribers: Map<string, SubscribeUserAgentClient>;
+    /** UACs. */
+    userAgentClients: Map<string, UserAgentClient>;
+    /** UASs. */
+    userAgentServers: Map<string, UserAgentServer>;
+    private logger;
+    /**
+     * Constructor.
+     * @param configuration - Configuration.
+     * @param delegate - Delegate.
+     */
+    constructor(configuration: UserAgentCoreConfiguration, delegate?: UserAgentCoreDelegate);
+    /** Destructor. */
+    dispose(): void;
+    /** Reset. */
+    reset(): void;
+    /** Logger factory. */
+    get loggerFactory(): LoggerFactory;
+    /** Transport. */
+    get transport(): Transport;
+    /**
+     * Send INVITE.
+     * @param request - Outgoing request.
+     * @param delegate - Request delegate.
+     */
+    invite(request: OutgoingRequestMessage, delegate?: OutgoingInviteRequestDelegate): OutgoingInviteRequest;
+    /**
+     * Send MESSAGE.
+     * @param request - Outgoing request.
+     * @param delegate - Request delegate.
+     */
+    message(request: OutgoingRequestMessage, delegate?: OutgoingRequestDelegate): OutgoingMessageRequest;
+    /**
+     * Send PUBLISH.
+     * @param request - Outgoing request.
+     * @param delegate - Request delegate.
+     */
+    publish(request: OutgoingRequestMessage, delegate?: OutgoingRequestDelegate): OutgoingPublishRequest;
+    /**
+     * Send REGISTER.
+     * @param request - Outgoing request.
+     * @param delegate - Request delegate.
+     */
+    register(request: OutgoingRequestMessage, delegate?: OutgoingRequestDelegate): OutgoingRegisterRequest;
+    /**
+     * Send SUBSCRIBE.
+     * @param request - Outgoing request.
+     * @param delegate - Request delegate.
+     */
+    subscribe(request: OutgoingRequestMessage, delegate?: OutgoingSubscribeRequestDelegate): OutgoingSubscribeRequest;
+    /**
+     * Send a request.
+     * @param request - Outgoing request.
+     * @param delegate - Request delegate.
+     */
+    request(request: OutgoingRequestMessage, delegate?: OutgoingRequestDelegate): OutgoingRequest;
+    /**
+     * Outgoing request message factory function.
+     * @param method - Method.
+     * @param requestURI - Request-URI.
+     * @param fromURI - From URI.
+     * @param toURI - To URI.
+     * @param options - Request options.
+     * @param extraHeaders - Extra headers to add.
+     * @param body - Message body.
+     */
+    makeOutgoingRequestMessage(method: string, requestURI: URI, fromURI: URI, toURI: URI, options: OutgoingRequestMessageOptions, extraHeaders?: Array<string>, body?: Body): OutgoingRequestMessage;
+    /**
+     * Handle an incoming request message from the transport.
+     * @param message - Incoming request message from transport layer.
+     */
+    receiveIncomingRequestFromTransport(message: IncomingRequestMessage): void;
+    /**
+     * Handle an incoming response message from the transport.
+     * @param message - Incoming response message from transport layer.
+     */
+    receiveIncomingResponseFromTransport(message: IncomingResponseMessage): void;
+    /**
+     * A stateless UAS is a UAS that does not maintain transaction state.
+     * It replies to requests normally, but discards any state that would
+     * ordinarily be retained by a UAS after a response has been sent.  If a
+     * stateless UAS receives a retransmission of a request, it regenerates
+     * the response and re-sends it, just as if it were replying to the first
+     * instance of the request. A UAS cannot be stateless unless the request
+     * processing for that method would always result in the same response
+     * if the requests are identical. This rules out stateless registrars,
+     * for example.  Stateless UASs do not use a transaction layer; they
+     * receive requests directly from the transport layer and send responses
+     * directly to the transport layer.
+     * https://tools.ietf.org/html/rfc3261#section-8.2.7
+     * @param message - Incoming request message to reply to.
+     * @param statusCode - Status code to reply with.
+     */
+    replyStateless(message: IncomingRequestMessage, options: ResponseOptions): OutgoingResponse;
+    /**
+     * In Section 18.2.1, replace the last paragraph with:
+     *
+     * Next, the server transport attempts to match the request to a
+     * server transaction.  It does so using the matching rules described
+     * in Section 17.2.3.  If a matching server transaction is found, the
+     * request is passed to that transaction for processing.  If no match
+     * is found, the request is passed to the core, which may decide to
+     * construct a new server transaction for that request.
+     * https://tools.ietf.org/html/rfc6026#section-8.10
+     * @param message - Incoming request message from transport layer.
+     */
+    private receiveRequestFromTransport;
+    /**
+     * UAC and UAS procedures depend strongly on two factors.  First, based
+     * on whether the request or response is inside or outside of a dialog,
+     * and second, based on the method of a request.  Dialogs are discussed
+     * thoroughly in Section 12; they represent a peer-to-peer relationship
+     * between user agents and are established by specific SIP methods, such
+     * as INVITE.
+     * @param message - Incoming request message.
+     */
+    private receiveRequest;
+    /**
+     * Once a dialog has been established between two UAs, either of them
+     * MAY initiate new transactions as needed within the dialog.  The UA
+     * sending the request will take the UAC role for the transaction.  The
+     * UA receiving the request will take the UAS role.  Note that these may
+     * be different roles than the UAs held during the transaction that
+     * established the dialog.
+     * https://tools.ietf.org/html/rfc3261#section-12.2
+     * @param message - Incoming request message.
+     */
+    private receiveInsideDialogRequest;
+    /**
+     * Assuming all of the checks in the previous subsections are passed,
+     * the UAS processing becomes method-specific.
+     *  https://tools.ietf.org/html/rfc3261#section-8.2.5
+     * @param message - Incoming request message.
+     */
+    private receiveOutsideDialogRequest;
+    /**
+     * Responses are first processed by the transport layer and then passed
+     * up to the transaction layer.  The transaction layer performs its
+     * processing and then passes the response up to the TU.  The majority
+     * of response processing in the TU is method specific.  However, there
+     * are some general behaviors independent of the method.
+     * https://tools.ietf.org/html/rfc3261#section-8.1.3
+     * @param message - Incoming response message from transport layer.
+     */
+    private receiveResponseFromTransport;
+}

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

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

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

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

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

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

package/dist/core/user-agents/index.d.ts

@@ -0,0 +1,26 @@
+export * from "./bye-user-agent-client";
+export * from "./bye-user-agent-server";
+export * from "./cancel-user-agent-client";
+export * from "./info-user-agent-client";
+export * from "./info-user-agent-server";
+export * from "./invite-user-agent-client";
+export * from "./invite-user-agent-server";
+export * from "./message-user-agent-client";
+export * from "./message-user-agent-server";
+export * from "./notify-user-agent-client";
+export * from "./notify-user-agent-server";
+export * from "./publish-user-agent-client";
+export * from "./prack-user-agent-client";
+export * from "./prack-user-agent-server";
+export * from "./re-invite-user-agent-client";
+export * from "./re-invite-user-agent-server";
+export * from "./re-subscribe-user-agent-client";
+export * from "./re-subscribe-user-agent-server";
+export * from "./refer-user-agent-client";
+export * from "./refer-user-agent-server";
+export * from "./register-user-agent-client";
+export * from "./register-user-agent-server";
+export * from "./subscribe-user-agent-client";
+export * from "./subscribe-user-agent-server";
+export * from "./user-agent-client";
+export * from "./user-agent-server";

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

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

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

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