## API Report File for "sip.js"

> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).

```ts

import { EventEmitter } from 'events';

// @public
export interface AckableIncomingResponseWithSession extends IncomingResponse {
    ack(options?: RequestOptions): OutgoingAckRequest;
    readonly session: Session;
}

// @public
export interface Body {
    content: string;
    contentDisposition: string;
    contentType: string;
}

// @public
export class ByeUserAgentClient extends UserAgentClient implements OutgoingByeRequest {
    constructor(dialog: SessionDialog, delegate?: OutgoingRequestDelegate, options?: RequestOptions);
}

// @public
export class ByeUserAgentServer extends UserAgentServer implements IncomingByeRequest {
    constructor(dialog: SessionDialog, message: IncomingRequestMessage, delegate?: IncomingRequestDelegate);
}

// Warning: (ae-internal-missing-underscore) The name "C" should be prefixed with an underscore because the declaration is marked as @internal
//
// @internal
export namespace C {
    const // (undocumented)
    ACK = "ACK";
    const // (undocumented)
    BYE = "BYE";
    const // (undocumented)
    CANCEL = "CANCEL";
    const // (undocumented)
    INFO = "INFO";
    const // (undocumented)
    INVITE = "INVITE";
    const // (undocumented)
    MESSAGE = "MESSAGE";
    const // (undocumented)
    NOTIFY = "NOTIFY";
    const // (undocumented)
    OPTIONS = "OPTIONS";
    const // (undocumented)
    REGISTER = "REGISTER";
    const // (undocumented)
    UPDATE = "UPDATE";
    const // (undocumented)
    SUBSCRIBE = "SUBSCRIBE";
    const // (undocumented)
    PUBLISH = "PUBLISH";
    const // (undocumented)
    REFER = "REFER";
    const // (undocumented)
    PRACK = "PRACK";
}

// @public
export class CancelUserAgentClient extends UserAgentClient implements OutgoingCancelRequest {
    constructor(core: UserAgentCore, message: OutgoingRequestMessage, delegate?: OutgoingRequestDelegate);
}

// @public
export abstract class ClientTransaction extends Transaction {
    protected constructor(_request: OutgoingRequestMessage, transport: Transport, user: ClientTransactionUser, state: TransactionState, loggerCategory: string);
    protected onRequestTimeout(): void;
    abstract receiveResponse(response: IncomingResponseMessage): void;
    readonly request: OutgoingRequestMessage;
    // (undocumented)
    protected user: ClientTransactionUser;
}

// @public
export interface ClientTransactionUser extends TransactionUser {
    onRequestTimeout?: () => void;
    receiveResponse?: (response: IncomingResponseMessage) => void;
}

// Warning: (ae-internal-missing-underscore) The name "constructOutgoingResponse" should be prefixed with an underscore because the declaration is marked as @internal
//
// @internal
export function constructOutgoingResponse(message: IncomingRequestMessage, options: ResponseOptions): OutgoingResponse;

// @public
export interface Contact {
    // (undocumented)
    pubGruu: URI | undefined;
    // (undocumented)
    tempGruu: URI | undefined;
    // (undocumented)
    toString: (options?: {
        anonymous?: boolean;
        outbound?: boolean;
    }) => string;
    // (undocumented)
    uri: URI;
}

// @public
export class Dialog {
    protected constructor(core: UserAgentCore, dialogState: DialogState);
    readonly callId: string;
    confirm(): void;
    // (undocumented)
    protected core: UserAgentCore;
    createOutgoingRequestMessage(method: string, options?: {
        cseq?: number;
        extraHeaders?: Array<string>;
        body?: Body;
    }): OutgoingRequestMessage;
    // (undocumented)
    protected dialogState: DialogState;
    dispose(): void;
    readonly early: boolean;
    readonly id: string;
    static initialDialogStateForUserAgentClient(outgoingRequestMessage: OutgoingRequestMessage, incomingResponseMessage: IncomingResponseMessage): DialogState;
    static initialDialogStateForUserAgentServer(incomingRequestMessage: IncomingRequestMessage, toTag: string, early?: boolean): DialogState;
    readonly localSequenceNumber: number | undefined;
    readonly localTag: string;
    readonly localURI: URI;
    receiveRequest(message: IncomingRequestMessage): void;
    recomputeRouteSet(message: IncomingResponseMessage): void;
    readonly remoteSequenceNumber: number | undefined;
    readonly remoteTag: string;
    readonly remoteTarget: URI;
    readonly remoteURI: URI;
    readonly routeSet: Array<string>;
    readonly secure: boolean;
    protected sequenceGuard(message: IncomingRequestMessage): boolean;
    readonly userAgentCore: UserAgentCore;
}

// @public
export interface DialogState {
    // (undocumented)
    callId: string;
    // (undocumented)
    early: boolean;
    // (undocumented)
    id: string;
    // (undocumented)
    localSequenceNumber: number | undefined;
    // (undocumented)
    localTag: string;
    // (undocumented)
    localURI: URI;
    // (undocumented)
    remoteSequenceNumber: number | undefined;
    // (undocumented)
    remoteTag: string;
    // (undocumented)
    remoteTarget: URI;
    // (undocumented)
    remoteURI: URI;
    // (undocumented)
    routeSet: Array<string>;
    // (undocumented)
    secure: boolean;
}

// Warning: (ae-internal-missing-underscore) The name "DigestAuthentication" should be prefixed with an underscore because the declaration is marked as @internal
//
// @internal
export class DigestAuthentication {
    constructor(loggerFactory: LoggerFactory, username: string | undefined, password: string | undefined);
    authenticate(request: OutgoingRequestMessage, challenge: any, body?: string): boolean;
    // (undocumented)
    stale: boolean | undefined;
    toString(): string;
    }

// @public
export abstract class Exception extends Error {
    protected constructor(message?: string);
}

// Warning: (ae-internal-missing-underscore) The name "fromBodyLegacy" should be prefixed with an underscore because the declaration is marked as @internal
//
// @internal
export function fromBodyLegacy(bodyLegacy: string | {
    body: string;
    contentType: string;
}): Body;

// Warning: (ae-internal-missing-underscore) The name "getBody" should be prefixed with an underscore because the declaration is marked as @internal
//
// @internal
export function getBody(message: IncomingRequestMessage | IncomingResponseMessage | OutgoingRequestMessage | Body): Body | undefined;

// Warning: (ae-internal-missing-underscore) The name "Grammar" should be prefixed with an underscore because the declaration is marked as @internal
//
// @internal
export namespace Grammar {
    export function nameAddrHeaderParse(nameAddrHeader: string): NameAddrHeader | undefined;
    export function parse(input: string, startRule: string): any;
    export function URIParse(uri: string): URI | undefined;
}

// @public
export interface IncomingAckRequest {
    readonly message: IncomingRequestMessage;
}

// @public
export interface IncomingByeRequest extends IncomingRequest {
}

// @public
export interface IncomingByeResponse extends IncomingResponse {
}

// @public
export interface IncomingCancelRequest extends IncomingRequest {
}

// @public
export interface IncomingCancelResponse extends IncomingResponse {
}

// @public
export interface IncomingInfoRequest extends IncomingRequest {
}

// @public
export interface IncomingInfoResponse extends IncomingResponse {
}

// @public
export interface IncomingInviteRequest extends IncomingRequest {
    accept(options?: ResponseOptions): OutgoingResponseWithSession;
    progress(options?: ResponseOptions): OutgoingResponseWithSession;
}

// @public
export class IncomingMessage {
    addHeader(name: string, value: string): void;
    // (undocumented)
    body: string;
    // (undocumented)
    callId: string;
    // (undocumented)
    cseq: number;
    // (undocumented)
    data: string;
    // (undocumented)
    from: NameAddrHeader;
    // (undocumented)
    fromTag: string;
    getHeader(name: string): string | undefined;
    getHeaders(name: string): Array<string>;
    hasHeader(name: string): boolean;
    // (undocumented)
    headers: {
        [name: string]: Array<{
            parsed?: any;
            raw: string;
        }>;
    };
    // (undocumented)
    method: string;
    parseHeader(name: string, idx?: number): any | undefined;
    // (undocumented)
    referTo: string | undefined;
    s(name: string, idx?: number): any | undefined;
    setHeader(name: string, value: string): void;
    // (undocumented)
    to: NameAddrHeader;
    // (undocumented)
    toString(): string;
    // (undocumented)
    toTag: string;
    // (undocumented)
    via: {
        host: string;
        port: number;
    };
    // (undocumented)
    viaBranch: string;
}

// @public
export interface IncomingMessageRequest extends IncomingRequest {
}

// @public
export interface IncomingMessageResponse extends IncomingResponse {
}

// @public
export interface IncomingNotifyRequest extends IncomingRequest {
}

// @public
export interface IncomingNotifyResponse extends IncomingResponse {
}

// @public
export interface IncomingPrackRequest extends IncomingRequest {
}

// @public
export interface IncomingPrackResponse extends IncomingResponse {
}

// @public
export interface IncomingPublishRequest extends IncomingRequest {
}

// @public
export interface IncomingPublishResponse extends IncomingResponse {
}

// @public
export interface IncomingReferRequest extends IncomingRequest {
}

// @public
export interface IncomingReferResponse extends IncomingResponse {
}

// @public
export interface IncomingRegisterRequest extends IncomingRequest {
}

// @public
export interface IncomingRegisterResponse extends IncomingResponse {
}

// @public
export interface IncomingRequest {
    accept(options?: ResponseOptions): OutgoingResponse;
    delegate?: IncomingRequestDelegate;
    readonly message: IncomingRequestMessage;
    progress(options?: ResponseOptions): OutgoingResponse;
    redirect(contacts: Array<URI>, options?: ResponseOptions): OutgoingResponse;
    reject(options?: ResponseOptions): OutgoingResponse;
    trying(options?: ResponseOptions): OutgoingResponse;
}

// @public
export interface IncomingRequestDelegate {
    onCancel?(message: IncomingRequestMessage): void;
    onTransportError?(error: TransportError): void;
}

// @public
export class IncomingRequestMessage extends IncomingMessage {
    constructor();
    // (undocumented)
    ruri: URI | undefined;
}

// @public
export interface IncomingRequestWithSubscription {
    readonly request: IncomingNotifyRequest;
    readonly subscription?: Subscription;
}

// @public
export interface IncomingResponse {
    readonly message: IncomingResponseMessage;
}

// @public
export class IncomingResponseMessage extends IncomingMessage {
    constructor();
    // (undocumented)
    reasonPhrase: string | undefined;
    // (undocumented)
    statusCode: number | undefined;
}

// @public
export interface IncomingSubscribeRequest extends IncomingRequest {
}

// @public
export interface IncomingSubscribeResponse extends IncomingResponse {
}

// @public
export class InfoUserAgentClient extends UserAgentClient implements OutgoingInfoRequest {
    constructor(dialog: SessionDialog, delegate?: OutgoingRequestDelegate, options?: RequestOptions);
}

// @public
export class InfoUserAgentServer extends UserAgentServer implements IncomingInfoRequest {
    constructor(dialog: SessionDialog, message: IncomingRequestMessage, delegate?: IncomingRequestDelegate);
}

// @public
export class InviteClientTransaction extends ClientTransaction {
    constructor(request: OutgoingRequestMessage, transport: Transport, user: ClientTransactionUser);
    ackResponse(ack: OutgoingRequestMessage): void;
    dispose(): void;
    readonly kind: string;
    protected onTransportError(error: TransportError): void;
    receiveResponse(response: IncomingResponseMessage): void;
    protected typeToString(): string;
}

// @public
export class InviteServerTransaction extends ServerTransaction {
    constructor(request: IncomingRequestMessage, transport: Transport, user: ServerTransactionUser);
    dispose(): void;
    readonly kind: string;
    protected onTransportError(error: Error): void;
    receiveRequest(request: IncomingRequestMessage): void;
    receiveResponse(statusCode: number, response: string): void;
    retransmitAcceptedResponse(): void;
    protected typeToString(): string;
}

// @public
export class InviteUserAgentClient extends UserAgentClient implements OutgoingInviteRequest {
    constructor(core: UserAgentCore, message: OutgoingRequestMessage, delegate?: OutgoingInviteRequestDelegate);
    // (undocumented)
    delegate: OutgoingInviteRequestDelegate | undefined;
    // (undocumented)
    dispose(): void;
    protected onTransportError(error: TransportError): void;
    protected receiveResponse(message: IncomingResponseMessage): void;
}

// @public
export class InviteUserAgentServer extends UserAgentServer implements IncomingInviteRequest {
    constructor(core: UserAgentCore, message: IncomingRequestMessage, delegate?: IncomingRequestDelegate);
    accept(options?: ResponseOptions): OutgoingResponseWithSession;
    // (undocumented)
    protected core: UserAgentCore;
    // (undocumented)
    dispose(): void;
    progress(options?: ResponseOptions): OutgoingResponseWithSession;
    redirect(contacts: Array<URI>, options?: ResponseOptions): OutgoingResponse;
    reject(options?: ResponseOptions): OutgoingResponse;
}

// Warning: (ae-internal-missing-underscore) The name "isBody" should be prefixed with an underscore because the declaration is marked as @internal
//
// @internal
export function isBody(body: any): body is Body;

// @public
export enum Levels {
    // (undocumented)
    debug = 3,
    // (undocumented)
    error = 0,
    // (undocumented)
    log = 2,
    // (undocumented)
    warn = 1
}

// @public
export class Logger {
    constructor(logger: LoggerFactory, category: string, label?: string);
    // (undocumented)
    debug(content: string): void;
    // (undocumented)
    error(content: string): void;
    // (undocumented)
    log(content: string): void;
    // (undocumented)
    warn(content: string): void;
}

// @public
export class LoggerFactory {
    constructor();
    // (undocumented)
    builtinEnabled: boolean;
    // (undocumented)
    connector: ((level: string, category: string, label: string | undefined, content: any) => void) | undefined;
    // (undocumented)
    genericLog(levelToLog: Levels, category: string, label: string | undefined, content: any): void;
    // (undocumented)
    getLogger(category: string, label?: string): Logger;
    // (undocumented)
    level: Levels;
    }

// @public
export class MessageUserAgentClient extends UserAgentClient implements OutgoingMessageRequest {
    constructor(core: UserAgentCore, message: OutgoingRequestMessage, delegate?: OutgoingRequestDelegate);
}

// @public
export class MessageUserAgentServer extends UserAgentServer implements IncomingMessageRequest {
    constructor(core: UserAgentCore, message: IncomingRequestMessage, delegate?: IncomingRequestDelegate);
    // (undocumented)
    protected core: UserAgentCore;
}

// Warning: (ae-incompatible-release-tags) The symbol "NameAddrHeader" is marked as @public, but its signature references "Parameters" which is marked as @internal
//
// @public
export class NameAddrHeader extends Parameters {
    constructor(uri: URI, displayName: string, parameters: {
        [name: string]: string;
    });
    // (undocumented)
    clone(): NameAddrHeader;
    // (undocumented)
    displayName: string;
    // (undocumented)
    readonly friendlyName: string;
    // (undocumented)
    toString(): string;
    // (undocumented)
    uri: URI;
}

// @public
export class NonInviteClientTransaction extends ClientTransaction {
    constructor(request: OutgoingRequestMessage, transport: Transport, user: ClientTransactionUser);
    dispose(): void;
    readonly kind: string;
    protected onTransportError(error: Error): void;
    receiveResponse(response: IncomingResponseMessage): void;
    protected typeToString(): string;
}

// @public
export class NonInviteServerTransaction extends ServerTransaction {
    constructor(request: IncomingRequestMessage, transport: Transport, user: ServerTransactionUser);
    dispose(): void;
    readonly kind: string;
    protected onTransportError(error: Error): void;
    receiveRequest(request: IncomingRequestMessage): void;
    receiveResponse(statusCode: number, response: string): void;
    protected typeToString(): string;
}

// @public
export class NotifyUserAgentClient extends UserAgentClient implements OutgoingNotifyRequest {
    constructor(dialog: SessionDialog, delegate?: OutgoingRequestDelegate, options?: RequestOptions);
}

// @public
export class NotifyUserAgentServer extends UserAgentServer implements IncomingNotifyRequest {
    constructor(dialogOrCore: Dialog | UserAgentCore, message: IncomingRequestMessage, delegate?: IncomingRequestDelegate);
}

// @public
export interface OutgoingAckRequest {
    readonly message: OutgoingRequestMessage;
}

// @public
export interface OutgoingByeRequest extends OutgoingRequest {
}

// @public
export interface OutgoingCancelRequest extends OutgoingRequest {
}

// @public
export interface OutgoingInfoRequest extends OutgoingRequest {
}

// @public
export interface OutgoingInviteRequest extends OutgoingRequest {
    delegate?: OutgoingInviteRequestDelegate;
}

// @public
export interface OutgoingInviteRequestDelegate extends OutgoingRequestDelegate {
    onAccept?(response: AckableIncomingResponseWithSession): void;
    onProgress?(response: PrackableIncomingResponseWithSession): void;
}

// @public
export interface OutgoingMessageRequest extends OutgoingRequest {
}

// @public
export interface OutgoingNotifyRequest extends OutgoingRequest {
}

// @public
export interface OutgoingPrackRequest extends OutgoingRequest {
}

// @public
export interface OutgoingPublishRequest extends OutgoingRequest {
}

// @public
export interface OutgoingReferRequest extends OutgoingRequest {
}

// @public
export interface OutgoingRegisterRequest extends OutgoingRequest {
}

// @public
export interface OutgoingRequest {
    cancel(reason?: string, options?: RequestOptions): void;
    delegate?: OutgoingRequestDelegate;
    dispose(): void;
    readonly message: OutgoingRequestMessage;
}

// @public
export interface OutgoingRequestDelegate {
    onAccept?(response: IncomingResponse): void;
    onProgress?(response: IncomingResponse): void;
    onRedirect?(response: IncomingResponse): void;
    onReject?(response: IncomingResponse): void;
    onTrying?(response: IncomingResponse): void;
}

// @public
export class OutgoingRequestMessage {
    constructor(method: string, ruri: URI, fromURI: URI, toURI: URI, options?: OutgoingRequestMessageOptions, extraHeaders?: Array<string>, body?: Body);
    // (undocumented)
    body: {
        body: string;
        contentType: string;
    } | undefined;
    // (undocumented)
    branch: string | undefined;
    // (undocumented)
    readonly callId: string;
    // (undocumented)
    cseq: number;
    // (undocumented)
    extraHeaders: Array<string>;
    // (undocumented)
    readonly from: NameAddrHeader;
    // (undocumented)
    readonly fromTag: string;
    // (undocumented)
    readonly fromURI: URI;
    getHeader(name: string): string | undefined;
    getHeaders(name: string): Array<string>;
    hasHeader(name: string): boolean;
    // (undocumented)
    readonly headers: {
        [name: string]: Array<string>;
    };
    // (undocumented)
    readonly method: string;
    // (undocumented)
    readonly ruri: URI;
    setHeader(name: string, value: string | Array<string>): void;
    setViaHeader(branch: string, transport: string): void;
    // (undocumented)
    readonly to: NameAddrHeader;
    // (undocumented)
    toString(): string;
    // (undocumented)
    readonly toTag: string | undefined;
    // (undocumented)
    readonly toURI: URI;
}

// @public
export interface OutgoingRequestMessageOptions {
    // (undocumented)
    callId?: string;
    // (undocumented)
    callIdPrefix?: string;
    // (undocumented)
    cseq?: number;
    // (undocumented)
    forceRport?: boolean;
    // (undocumented)
    fromDisplayName?: string;
    // (undocumented)
    fromTag?: string;
    // (undocumented)
    hackViaTcp?: boolean;
    // (undocumented)
    optionTags?: Array<string>;
    // (undocumented)
    routeSet?: Array<string>;
    // (undocumented)
    toDisplayName?: string;
    // (undocumented)
    toTag?: string;
    // (undocumented)
    userAgentString?: string;
    // (undocumented)
    viaHost?: string;
}

// @public
export interface OutgoingResponse {
    readonly message: string;
}

// @public
export interface OutgoingResponseWithSession extends OutgoingResponse {
    readonly session: Session;
}

// @public
export interface OutgoingSubscribeRequest extends OutgoingRequest {
    delegate?: OutgoingSubscribeRequestDelegate;
    waitNotifyStop(): void;
}

// @public
export interface OutgoingSubscribeRequestDelegate extends OutgoingRequestDelegate {
    onNotify?(request: IncomingRequestWithSubscription): void;
    onNotifyTimeout?(): void;
}

// Warning: (ae-internal-missing-underscore) The name "Parameters" should be prefixed with an underscore because the declaration is marked as @internal
//
// @internal (undocumented)
export class Parameters {
    constructor(parameters: {
        [name: string]: string;
    });
    // (undocumented)
    clearParams(): void;
    // (undocumented)
    deleteParam(parameter: string): any;
    // (undocumented)
    getParam(key: string): string | undefined;
    // (undocumented)
    hasParam(key: string): boolean;
    // (undocumented)
    parameters: {
        [name: string]: string;
    };
    // (undocumented)
    setParam(key: string, value: any): void;
}

// Warning: (ae-internal-missing-underscore) The name "Parser" should be prefixed with an underscore because the declaration is marked as @internal
//
// @internal
export namespace Parser {
    // (undocumented)
    export function getHeader(data: any, headerStart: number): number;
    // (undocumented)
    export function parseHeader(message: IncomingRequestMessage | IncomingResponseMessage, data: any, headerStart: number, headerEnd: number): boolean | {
        error: string;
    };
    // (undocumented)
    export function parseMessage(data: string, logger: Logger): IncomingRequestMessage | IncomingResponseMessage | undefined;
}

// @public
export interface PrackableIncomingResponseWithSession extends IncomingResponse {
    prack(options?: RequestOptions): OutgoingPrackRequest;
    readonly session: Session;
}

// @public
export class PrackUserAgentClient extends UserAgentClient implements OutgoingPrackRequest {
    constructor(dialog: SessionDialog, delegate?: OutgoingRequestDelegate, options?: RequestOptions);
}

// @public
export class PrackUserAgentServer extends UserAgentServer implements IncomingPrackRequest {
    constructor(dialog: SessionDialog, message: IncomingRequestMessage, delegate?: IncomingRequestDelegate);
    accept(options?: ResponseOptions): OutgoingResponse;
    }

// @public
export class PublishUserAgentClient extends UserAgentClient implements OutgoingPublishRequest {
    constructor(core: UserAgentCore, message: OutgoingRequestMessage, delegate?: OutgoingRequestDelegate);
}

// @public
export class ReferUserAgentClient extends UserAgentClient implements OutgoingReferRequest {
    constructor(dialog: SessionDialog, delegate?: OutgoingRequestDelegate, options?: RequestOptions);
}

// @public
export class ReferUserAgentServer extends UserAgentServer implements IncomingReferRequest {
    constructor(dialogOrCore: SessionDialog | UserAgentCore, message: IncomingRequestMessage, delegate?: IncomingRequestDelegate);
}

// @public
export class RegisterUserAgentClient extends UserAgentClient implements OutgoingRegisterRequest {
    constructor(core: UserAgentCore, message: OutgoingRequestMessage, delegate?: OutgoingRequestDelegate);
}

// @public
export class RegisterUserAgentServer extends UserAgentServer implements IncomingRegisterRequest {
    constructor(core: UserAgentCore, message: IncomingRequestMessage, delegate?: IncomingRequestDelegate);
    // (undocumented)
    protected core: UserAgentCore;
}

// @public
export class ReInviteUserAgentClient extends UserAgentClient implements OutgoingInviteRequest {
    constructor(dialog: SessionDialog, delegate?: OutgoingInviteRequestDelegate, options?: RequestOptions);
    // (undocumented)
    delegate: OutgoingInviteRequestDelegate | undefined;
    // (undocumented)
    protected receiveResponse(message: IncomingResponseMessage): void;
}

// @public
export class ReInviteUserAgentServer extends UserAgentServer implements IncomingInviteRequest {
    constructor(dialog: SessionDialog, message: IncomingRequestMessage, delegate?: IncomingRequestDelegate);
    accept(options?: ResponseOptions): OutgoingResponseWithSession;
    progress(options?: ResponseOptions): OutgoingResponseWithSession;
    redirect(contacts: Array<URI>, options?: ResponseOptions): OutgoingResponse;
    reject(options?: ResponseOptions): OutgoingResponse;
}

// @public
export interface RequestOptions {
    body?: Body;
    extraHeaders?: Array<string>;
}

// @public
export interface ResponseOptions {
    body?: Body;
    extraHeaders?: Array<string>;
    reasonPhrase?: string;
    statusCode: number;
    supported?: Array<string>;
    toTag?: string;
    userAgent?: string;
}

// @public
export class ReSubscribeUserAgentClient extends UserAgentClient implements OutgoingSubscribeRequest {
    constructor(dialog: SubscriptionDialog, delegate?: OutgoingRequestDelegate, options?: RequestOptions);
    protected receiveResponse(message: IncomingResponseMessage): void;
    // (undocumented)
    waitNotifyStop(): void;
}

// @public
export class ReSubscribeUserAgentServer extends UserAgentServer implements IncomingSubscribeRequest {
    constructor(dialog: Dialog, message: IncomingRequestMessage, delegate?: IncomingRequestDelegate);
}

// @public
export abstract class ServerTransaction extends Transaction {
    protected constructor(_request: IncomingRequestMessage, transport: Transport, user: ServerTransactionUser, state: TransactionState, loggerCategory: string);
    abstract receiveRequest(request: IncomingRequestMessage): void;
    abstract receiveResponse(statusCode: number, response: string): void;
    readonly request: IncomingRequestMessage;
    // (undocumented)
    protected user: ServerTransactionUser;
}

// @public
export interface ServerTransactionUser extends TransactionUser {
}

// @public
export interface Session {
    readonly answer: Body | undefined;
    bye(delegate?: OutgoingRequestDelegate, options?: RequestOptions): OutgoingByeRequest;
    readonly callId: string;
    delegate: SessionDelegate | undefined;
    dispose(): void;
    readonly id: string;
    info(delegate?: OutgoingRequestDelegate, options?: RequestOptions): OutgoingInfoRequest;
    invite(delegate?: OutgoingInviteRequestDelegate, options?: RequestOptions): OutgoingInviteRequest;
    readonly localTag: string;
    readonly localURI: URI;
    notify(delegate?: OutgoingRequestDelegate, options?: RequestOptions): OutgoingNotifyRequest;
    readonly offer: Body | undefined;
    prack(delegate?: OutgoingRequestDelegate, options?: RequestOptions): OutgoingPrackRequest;
    refer(delegate?: OutgoingRequestDelegate, options?: RequestOptions): OutgoingReferRequest;
    readonly remoteTag: string;
    readonly remoteTarget: URI;
    readonly remoteURI: URI;
    readonly sessionState: SessionState;
    readonly signalingState: SignalingState;
}

// @public
export interface SessionDelegate {
    onAck?(request: IncomingAckRequest): void;
    onAckTimeout?(): void;
    onBye?(request: IncomingByeRequest): void;
    onInfo?(request: IncomingInfoRequest): void;
    onInvite?(request: IncomingInviteRequest): void;
    onNotify?(request: IncomingNotifyRequest): void;
    onPrack?(request: IncomingPrackRequest): void;
    onRefer?(request: IncomingReferRequest): void;
}

// @public
export class SessionDialog extends Dialog implements Session {
    constructor(initialTransaction: InviteClientTransaction | InviteServerTransaction, core: UserAgentCore, state: DialogState, delegate?: SessionDelegate);
    ack(options?: RequestOptions): OutgoingAckRequest;
    readonly answer: Body | undefined;
    bye(delegate?: OutgoingRequestDelegate, options?: RequestOptions): OutgoingByeRequest;
    confirm(): void;
    // (undocumented)
    delegate: SessionDelegate | undefined;
    // (undocumented)
    dispose(): void;
    info(delegate?: OutgoingRequestDelegate, options?: RequestOptions): OutgoingInfoRequest;
    invite(delegate?: OutgoingInviteRequestDelegate, options?: RequestOptions): OutgoingInviteRequest;
    notify(delegate?: OutgoingRequestDelegate, options?: RequestOptions): OutgoingNotifyRequest;
    readonly offer: Body | undefined;
    prack(delegate?: OutgoingRequestDelegate, options?: RequestOptions): OutgoingPrackRequest;
    receiveRequest(message: IncomingRequestMessage): void;
    reConfirm(): void;
    refer(delegate?: OutgoingRequestDelegate, options?: RequestOptions): OutgoingReferRequest;
    // (undocumented)
    reinviteUserAgentClient: ReInviteUserAgentClient | undefined;
    // (undocumented)
    reinviteUserAgentServer: ReInviteUserAgentServer | undefined;
    // (undocumented)
    reliableSequenceGuard(message: IncomingResponseMessage): boolean;
    // (undocumented)
    readonly sessionState: SessionState;
    readonly signalingState: SignalingState;
    signalingStateRollback(): void;
    signalingStateTransition(message: IncomingRequestMessage | IncomingResponseMessage | OutgoingRequestMessage | Body): void;
    }

// @public
export enum SessionState {
    // (undocumented)
    AckWait = "AckWait",
    // (undocumented)
    Confirmed = "Confirmed",
    // (undocumented)
    Early = "Early",
    // (undocumented)
    Initial = "Initial",
    // (undocumented)
    Terminated = "Terminated"
}

// @public
export enum SignalingState {
    // (undocumented)
    Closed = "Closed",
    // (undocumented)
    HaveLocalOffer = "HaveLocalOffer",
    // (undocumented)
    HaveRemoteOffer = "HaveRemoteOffer",
    // (undocumented)
    Initial = "Initial",
    // (undocumented)
    Stable = "Stable"
}

// @public
export class SubscribeUserAgentClient extends UserAgentClient implements OutgoingSubscribeRequest {
    constructor(core: UserAgentCore, message: OutgoingRequestMessage, delegate?: OutgoingSubscribeRequestDelegate);
    // (undocumented)
    delegate: OutgoingSubscribeRequestDelegate | undefined;
    dispose(): void;
    onNotify(uas: NotifyUserAgentServer): void;
    protected receiveResponse(message: IncomingResponseMessage): void;
    // (undocumented)
    waitNotifyStart(): void;
    // (undocumented)
    waitNotifyStop(): void;
}

// @public
export class SubscribeUserAgentServer extends UserAgentServer implements IncomingSubscribeRequest {
    constructor(core: UserAgentCore, message: IncomingRequestMessage, delegate?: IncomingRequestDelegate);
    // (undocumented)
    protected core: UserAgentCore;
}

// @public
export interface Subscription {
    autoRefresh: boolean;
    delegate: SubscriptionDelegate | undefined;
    dispose(): void;
    readonly id: string;
    refresh(): OutgoingSubscribeRequest;
    subscribe(delegate?: OutgoingSubscribeRequestDelegate, options?: RequestOptions): OutgoingSubscribeRequest;
    readonly subscriptionExpires: number;
    readonly subscriptionState: SubscriptionState;
    unsubscribe(): OutgoingSubscribeRequest;
}

// @public
export interface SubscriptionDelegate {
    onNotify?(request: IncomingNotifyRequest): void;
    onRefresh?(request: OutgoingSubscribeRequest): void;
    onTerminated?(): void;
}

// @public
export class SubscriptionDialog extends Dialog implements Subscription {
    constructor(subscriptionEvent: string, subscriptionExpires: number, subscriptionState: SubscriptionState, core: UserAgentCore, state: DialogState, delegate?: SubscriptionDelegate);
    // (undocumented)
    autoRefresh: boolean;
    // (undocumented)
    delegate: SubscriptionDelegate | undefined;
    // (undocumented)
    dispose(): void;
    static initialDialogStateForSubscription(outgoingSubscribeRequestMessage: OutgoingRequestMessage, incomingNotifyRequestMessage: IncomingRequestMessage): DialogState;
    receiveRequest(message: IncomingRequestMessage): void;
    refresh(): OutgoingSubscribeRequest;
    subscribe(delegate?: OutgoingSubscribeRequestDelegate, options?: RequestOptions): OutgoingSubscribeRequest;
    // (undocumented)
    readonly subscriptionEvent: string;
    subscriptionExpires: number;
    // (undocumented)
    readonly subscriptionExpiresInitial: number;
    readonly subscriptionRefresh: number | undefined;
    // (undocumented)
    readonly subscriptionState: SubscriptionState;
    terminate(): void;
    unsubscribe(): OutgoingSubscribeRequest;
}

// @public
export enum SubscriptionState {
    // (undocumented)
    Active = "Active",
    // (undocumented)
    Initial = "Initial",
    // (undocumented)
    NotifyWait = "NotifyWait",
    // (undocumented)
    Pending = "Pending",
    // (undocumented)
    Terminated = "Terminated"
}

// @public
export 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;
};

// @public
export abstract class Transaction extends EventEmitter {
    protected constructor(_transport: Transport, _user: TransactionUser, _id: string, _state: TransactionState, loggerCategory: string);
    dispose(): void;
    readonly id: string;
    readonly kind: string;
    // (undocumented)
    protected logger: Logger;
    // (undocumented)
    protected logTransportError(error: TransportError, message: string): void;
    on(name: "stateChanged", callback: () => void): this;
    // (undocumented)
    protected abstract onTransportError(error: TransportError): void;
    protected send(message: string): Promise<void>;
    // (undocumented)
    protected setState(state: TransactionState): void;
    readonly state: TransactionState;
    readonly transport: Transport;
    // (undocumented)
    protected typeToString(): string;
    }

// @public
export enum TransactionState {
    // (undocumented)
    Accepted = "Accepted",
    // (undocumented)
    Calling = "Calling",
    // (undocumented)
    Completed = "Completed",
    // (undocumented)
    Confirmed = "Confirmed",
    // (undocumented)
    Proceeding = "Proceeding",
    // (undocumented)
    Terminated = "Terminated",
    // (undocumented)
    Trying = "Trying"
}

// @public
export class TransactionStateError extends Exception {
    constructor(message?: string);
}

// @public
export interface TransactionUser {
    loggerFactory: LoggerFactory;
    onStateChange?: (newState: TransactionState) => void;
    onTransportError?: (error: TransportError) => void;
}

// @public
export interface Transport {
    readonly protocol: string;
    send(message: string): Promise<void>;
}

// @public
export class TransportError extends Exception {
    constructor(message?: string);
}

// Warning: (ae-incompatible-release-tags) The symbol "URI" is marked as @public, but its signature references "Parameters" which is marked as @internal
//
// @public
export class URI extends Parameters {
    constructor(scheme: string, user: string, host: string, port?: number, parameters?: any, headers?: any);
    // (undocumented)
    readonly aor: string;
    // (undocumented)
    clearHeaders(): void;
    // (undocumented)
    clone(): URI;
    // (undocumented)
    deleteHeader(header: string): any;
    // (undocumented)
    getHeader(name: string): string | undefined;
    // (undocumented)
    hasHeader(name: string): boolean;
    // (undocumented)
    host: string;
    // (undocumented)
    port: number | undefined;
    // (undocumented)
    scheme: string;
    // (undocumented)
    setHeader(name: string, value: any): void;
    // (undocumented)
    toRaw(): string;
    // (undocumented)
    toString(): string;
    // (undocumented)
    user: string | undefined;
}

// @public
export class UserAgentClient implements OutgoingRequest {
    // Warning: (ae-forgotten-export) The symbol "ClientTransactionConstructor" needs to be exported by the entry point index.d.ts
    constructor(transactionConstructor: ClientTransactionConstructor, core: UserAgentCore, message: OutgoingRequestMessage, delegate?: OutgoingRequestDelegate | undefined);
    protected authenticationGuard(message: IncomingResponseMessage): boolean;
    cancel(reason?: string, options?: RequestOptions): OutgoingRequestMessage;
    // (undocumented)
    protected core: UserAgentCore;
    // (undocumented)
    delegate?: OutgoingRequestDelegate | undefined;
    // (undocumented)
    dispose(): void;
    // (undocumented)
    protected logger: Logger;
    // (undocumented)
    readonly loggerFactory: LoggerFactory;
    // (undocumented)
    message: OutgoingRequestMessage;
    protected onRequestTimeout(): void;
    protected onTransportError(error: TransportError): void;
    protected receiveResponse(message: IncomingResponseMessage): void;
    readonly transaction: ClientTransaction;
    }

// @public
export class UserAgentCore {
    constructor(configuration: UserAgentCoreConfiguration, delegate?: UserAgentCoreDelegate);
    configuration: UserAgentCoreConfiguration;
    delegate: UserAgentCoreDelegate;
    dialogs: Map<string, Dialog>;
    dispose(): void;
    invite(request: OutgoingRequestMessage, delegate?: OutgoingInviteRequestDelegate): OutgoingInviteRequest;
    readonly loggerFactory: LoggerFactory;
    makeOutgoingRequestMessage(method: string, requestURI: URI, fromURI: URI, toURI: URI, options: OutgoingRequestMessageOptions, extraHeaders?: Array<string>, body?: Body): OutgoingRequestMessage;
    message(request: OutgoingRequestMessage, delegate?: OutgoingRequestDelegate): OutgoingMessageRequest;
    publish(request: OutgoingRequestMessage, delegate?: OutgoingRequestDelegate): OutgoingPublishRequest;
    receiveIncomingRequestFromTransport(message: IncomingRequestMessage): void;
    receiveIncomingResponseFromTransport(message: IncomingResponseMessage): void;
    register(request: OutgoingRequestMessage, delegate?: OutgoingRequestDelegate): OutgoingRegisterRequest;
    replyStateless(message: IncomingRequestMessage, options: ResponseOptions): OutgoingResponse;
    request(request: OutgoingRequestMessage, delegate?: OutgoingRequestDelegate): OutgoingRequest;
    reset(): void;
    subscribe(request: OutgoingRequestMessage, delegate?: OutgoingSubscribeRequestDelegate): OutgoingSubscribeRequest;
    subscribers: Map<string, SubscribeUserAgentClient>;
    readonly transport: Transport;
    userAgentClients: Map<string, UserAgentClient>;
    userAgentServers: Map<string, UserAgentServer>;
}

// @public
export interface UserAgentCoreConfiguration {
    aor: URI;
    // Warning: (ae-incompatible-release-tags) The symbol "authenticationFactory" is marked as @public, but its signature references "DigestAuthentication" which is marked as @internal
    authenticationFactory(): DigestAuthentication | undefined;
    contact: Contact;
    displayName: string;
    hackViaTcp: boolean;
    loggerFactory: LoggerFactory;
    routeSet: Array<string>;
    sipjsId: string;
    supportedOptionTags: Array<string>;
    supportedOptionTagsResponse: Array<string>;
    transportAccessor(): Transport | undefined;
    userAgentHeaderFieldValue: string | undefined;
    viaForceRport: boolean;
    viaHost: string;
}

// @public
export interface UserAgentCoreDelegate {
    onInvite?(request: IncomingInviteRequest): void;
    onMessage?(request: IncomingMessageRequest): void;
    onNotify?(request: IncomingNotifyRequest): void;
    onRefer?(request: IncomingReferRequest): void;
    onRegister?(request: IncomingRegisterRequest): void;
    onSubscribe?(request: IncomingSubscribeRequest): void;
}

// @public
export class UserAgentServer implements IncomingRequest {
    // Warning: (ae-forgotten-export) The symbol "ServerTransactionConstructor" needs to be exported by the entry point index.d.ts
    constructor(transactionConstructor: ServerTransactionConstructor, core: UserAgentCore, message: IncomingRequestMessage, delegate?: IncomingRequestDelegate | undefined);
    // (undocumented)
    accept(options?: ResponseOptions): OutgoingResponse;
    // (undocumented)
    protected readonly acceptable: boolean;
    // (undocumented)
    protected core: UserAgentCore;
    // (undocumented)
    delegate?: IncomingRequestDelegate | undefined;
    // (undocumented)
    dispose(): void;
    // (undocumented)
    protected logger: Logger;
    // (undocumented)
    readonly loggerFactory: LoggerFactory;
    // (undocumented)
    message: IncomingRequestMessage;
    // (undocumented)
    progress(options?: ResponseOptions): OutgoingResponse;
    // (undocumented)
    protected readonly progressable: boolean;
    receiveCancel(message: IncomingRequestMessage): void;
    // (undocumented)
    redirect(contacts: Array<URI>, options?: ResponseOptions): OutgoingResponse;
    // (undocumented)
    protected readonly redirectable: boolean;
    // (undocumented)
    reject(options?: ResponseOptions): OutgoingResponse;
    // (undocumented)
    protected readonly rejectable: boolean;
    // (undocumented)
    protected toTag: string;
    readonly transaction: ServerTransaction;
    // (undocumented)
    trying(options?: ResponseOptions): OutgoingResponse;
    // (undocumented)
    protected readonly tryingable: boolean;
}


```