@tencentcloud/tccc-sip-js 0.1.0

package/jssip.d.ts

@@ -0,0 +1,1099 @@
+import { Debug } from 'debug';
+import { EventEmitter, Listener } from 'events';
+import { Stream as Stream$1 } from 'trtc-js-sdk';
+
+declare const USER_AGENT: string
+declare const SIP = 'sip'
+declare const SIPS = 'sips'
+
+declare enum causes {
+  CONNECTION_ERROR = 'Connection Error',
+  REQUEST_TIMEOUT = 'Request Timeout',
+  SIP_FAILURE_CODE = 'SIP Failure Code',
+  INTERNAL_ERROR = 'Internal Error',
+  BUSY = 'Busy',
+  REJECTED = 'Rejected',
+  REDIRECTED = 'Redirected',
+  UNAVAILABLE = 'Unavailable',
+  NOT_FOUND = 'Not Found',
+  ADDRESS_INCOMPLETE = 'Address Incomplete',
+  INCOMPATIBLE_SDP = 'Incompatible SDP',
+  MISSING_SDP = 'Missing SDP',
+  AUTHENTICATION_ERROR = 'Authentication Error',
+  BYE = 'Terminated',
+  WEBRTC_ERROR = 'WebRTC Error',
+  CANCELED = 'Canceled',
+  NO_ANSWER = 'No Answer',
+  EXPIRES = 'Expires',
+  NO_ACK = 'No ACK',
+  DIALOG_ERROR = 'Dialog Error',
+  USER_DENIED_MEDIA_ACCESS = 'User Denied Media Access',
+  BAD_MEDIA_DESCRIPTION = 'Bad Media Description',
+  RTP_TIMEOUT = 'RTP Timeout',
+}
+
+declare const SIP_ERROR_CAUSES: {
+  REDIRECTED: [300, 301, 302, 305, 380],
+  BUSY: [486, 600],
+  REJECTED: [403, 603],
+  NOT_FOUND: [404, 604],
+  UNAVAILABLE: [480, 410, 408, 430],
+  ADDRESS_INCOMPLETE: [484, 424],
+  INCOMPATIBLE_SDP: [488, 606],
+  AUTHENTICATION_ERROR: [401, 407]
+}
+declare const ACK = 'ACK'
+declare const BYE = 'BYE'
+declare const CANCEL = 'CANCEL'
+declare const INFO = 'INFO'
+declare const INVITE = 'INVITE'
+declare const MESSAGE = 'MESSAGE'
+declare const NOTIFY = 'NOTIFY'
+declare const OPTIONS = 'OPTIONS'
+declare const REGISTER = 'REGISTER'
+declare const REFER = 'REFER'
+declare const UPDATE = 'UPDATE'
+declare const SUBSCRIBE = 'SUBSCRIBE'
+
+declare enum DTMF_TRANSPORT {
+  INFO = 'INFO',
+  RFC2833 = 'RFC2833',
+}
+
+declare const REASON_PHRASE: Record<number, string>
+declare const ALLOWED_METHODS = 'INVITE,ACK,CANCEL,BYE,UPDATE,MESSAGE,OPTIONS,REFER,INFO,NOTIFY'
+declare const ACCEPTED_BODY_TYPES = 'application/sdp, application/dtmf-relay'
+declare const MAX_FORWARDS = 69
+declare const SESSION_EXPIRES = 90
+declare const MIN_SESSION_EXPIRES = 60
+declare const CONNECTION_RECOVERY_MAX_INTERVAL = 30
+declare const CONNECTION_RECOVERY_MIN_INTERVAL = 2
+enum LOG_LEVEL {
+  TRACE = 0,
+  DEBUG = 1,
+  WARN = 2,
+  ERROR = 3,
+  NONE = 4
+}
+
+declare const Constants_d_USER_AGENT: typeof USER_AGENT;
+declare const Constants_d_SIP: typeof SIP;
+declare const Constants_d_SIPS: typeof SIPS;
+type Constants_d_causes = causes;
+declare const Constants_d_causes: typeof causes;
+declare const Constants_d_SIP_ERROR_CAUSES: typeof SIP_ERROR_CAUSES;
+declare const Constants_d_ACK: typeof ACK;
+declare const Constants_d_BYE: typeof BYE;
+declare const Constants_d_CANCEL: typeof CANCEL;
+declare const Constants_d_INFO: typeof INFO;
+declare const Constants_d_INVITE: typeof INVITE;
+declare const Constants_d_MESSAGE: typeof MESSAGE;
+declare const Constants_d_NOTIFY: typeof NOTIFY;
+declare const Constants_d_OPTIONS: typeof OPTIONS;
+declare const Constants_d_REGISTER: typeof REGISTER;
+declare const Constants_d_REFER: typeof REFER;
+declare const Constants_d_UPDATE: typeof UPDATE;
+declare const Constants_d_SUBSCRIBE: typeof SUBSCRIBE;
+type Constants_d_DTMF_TRANSPORT = DTMF_TRANSPORT;
+declare const Constants_d_DTMF_TRANSPORT: typeof DTMF_TRANSPORT;
+declare const Constants_d_REASON_PHRASE: typeof REASON_PHRASE;
+declare const Constants_d_ALLOWED_METHODS: typeof ALLOWED_METHODS;
+declare const Constants_d_ACCEPTED_BODY_TYPES: typeof ACCEPTED_BODY_TYPES;
+declare const Constants_d_MAX_FORWARDS: typeof MAX_FORWARDS;
+declare const Constants_d_SESSION_EXPIRES: typeof SESSION_EXPIRES;
+declare const Constants_d_MIN_SESSION_EXPIRES: typeof MIN_SESSION_EXPIRES;
+declare const Constants_d_CONNECTION_RECOVERY_MAX_INTERVAL: typeof CONNECTION_RECOVERY_MAX_INTERVAL;
+declare const Constants_d_CONNECTION_RECOVERY_MIN_INTERVAL: typeof CONNECTION_RECOVERY_MIN_INTERVAL;
+type Constants_d_LOG_LEVEL = LOG_LEVEL;
+declare const Constants_d_LOG_LEVEL: typeof LOG_LEVEL;
+declare namespace Constants_d {
+  export {
+    Constants_d_USER_AGENT as USER_AGENT,
+    Constants_d_SIP as SIP,
+    Constants_d_SIPS as SIPS,
+    Constants_d_causes as causes,
+    Constants_d_SIP_ERROR_CAUSES as SIP_ERROR_CAUSES,
+    Constants_d_ACK as ACK,
+    Constants_d_BYE as BYE,
+    Constants_d_CANCEL as CANCEL,
+    Constants_d_INFO as INFO,
+    Constants_d_INVITE as INVITE,
+    Constants_d_MESSAGE as MESSAGE,
+    Constants_d_NOTIFY as NOTIFY,
+    Constants_d_OPTIONS as OPTIONS,
+    Constants_d_REGISTER as REGISTER,
+    Constants_d_REFER as REFER,
+    Constants_d_UPDATE as UPDATE,
+    Constants_d_SUBSCRIBE as SUBSCRIBE,
+    Constants_d_DTMF_TRANSPORT as DTMF_TRANSPORT,
+    Constants_d_REASON_PHRASE as REASON_PHRASE,
+    Constants_d_ALLOWED_METHODS as ALLOWED_METHODS,
+    Constants_d_ACCEPTED_BODY_TYPES as ACCEPTED_BODY_TYPES,
+    Constants_d_MAX_FORWARDS as MAX_FORWARDS,
+    Constants_d_SESSION_EXPIRES as SESSION_EXPIRES,
+    Constants_d_MIN_SESSION_EXPIRES as MIN_SESSION_EXPIRES,
+    Constants_d_CONNECTION_RECOVERY_MAX_INTERVAL as CONNECTION_RECOVERY_MAX_INTERVAL,
+    Constants_d_CONNECTION_RECOVERY_MIN_INTERVAL as CONNECTION_RECOVERY_MIN_INTERVAL,
+    Constants_d_LOG_LEVEL as LOG_LEVEL,
+  };
+}
+
+declare class BaseError extends Error {
+  code: number
+}
+
+declare class ConfigurationError extends BaseError {
+  parameter: string
+  value: any
+
+  constructor(parameter: string, value?: any);
+}
+
+declare class InvalidStateError extends BaseError {
+  status: number
+
+  constructor(status: number);
+}
+
+declare class NotSupportedError extends BaseError {
+  constructor(message: string);
+}
+
+declare class NotReadyError extends BaseError {
+  constructor(message: string);
+}
+
+type Exceptions_d_ConfigurationError = ConfigurationError;
+declare const Exceptions_d_ConfigurationError: typeof ConfigurationError;
+type Exceptions_d_InvalidStateError = InvalidStateError;
+declare const Exceptions_d_InvalidStateError: typeof InvalidStateError;
+type Exceptions_d_NotSupportedError = NotSupportedError;
+declare const Exceptions_d_NotSupportedError: typeof NotSupportedError;
+type Exceptions_d_NotReadyError = NotReadyError;
+declare const Exceptions_d_NotReadyError: typeof NotReadyError;
+declare namespace Exceptions_d {
+  export {
+    Exceptions_d_ConfigurationError as ConfigurationError,
+    Exceptions_d_InvalidStateError as InvalidStateError,
+    Exceptions_d_NotSupportedError as NotSupportedError,
+    Exceptions_d_NotReadyError as NotReadyError,
+  };
+}
+
+type Grammar = any;
+
+declare function parse(input: string, startRule?: string): Grammar;
+
+declare function toSource(): any;
+
+type Grammar_d_Grammar = Grammar;
+declare const Grammar_d_parse: typeof parse;
+declare const Grammar_d_toSource: typeof toSource;
+declare namespace Grammar_d {
+  export {
+    Grammar_d_Grammar as Grammar,
+    Grammar_d_parse as parse,
+    Grammar_d_toSource as toSource,
+  };
+}
+
+type URIScheme = 'sip' | string;
+
+type Parameters = Record<string, string | null>;
+
+type Headers = Record<string, string | string[]>;
+
+declare class URI {
+  scheme: URIScheme
+  user: string
+  host: string
+  port: number
+
+  constructor(scheme: URIScheme, user: string, host: string, port?: number, parameters?: Parameters, headers?: Headers);
+
+  setParam(key: string, value?: string): void;
+
+  getParam<T = unknown>(key: string): T;
+
+  hasParam(key: string): boolean;
+
+  deleteParam(key: string): void;
+
+  clearParams(): void;
+
+  setHeader(key: string, value: string | string[]): void;
+
+  getHeader(key: string): string[];
+
+  hasHeader(key: string): boolean;
+
+  deleteHeader(key: string): void;
+
+  clearHeaders(): void;
+
+  clone(): this;
+
+  toString(): string;
+
+  toAor(): string;
+
+  static parse(uri: string): Grammar | undefined;
+}
+
+declare function str_utf8_length(str: string): number;
+
+declare function isFunction(func: unknown): boolean;
+
+declare function isString(str: unknown): str is string;
+
+declare function isDecimal(num: unknown): num is number;
+
+declare function isEmpty(value: unknown): boolean;
+
+declare function hasMethods(obj: any, ...methodNames: string[]): boolean;
+
+declare function newTag(): string;
+
+declare function newUUID(): string;
+
+declare function hostType(host: string): string;
+
+declare function escapeUser(user: string): string;
+
+declare function normalizeTarget(target: URI | string, domain?: string): URI | undefined;
+
+declare function headerize(str: string): string;
+
+declare function sipErrorCause(status_code: number): causes;
+
+declare function getRandomTestNetIP(): string;
+
+declare function calculateMD5(str: string): string;
+
+declare function closeMediaStream(stream?: MediaStream): void;
+
+declare function cloneArray<T = unknown>(arr: T[]): T[];
+
+declare function cloneObject<T>(obj: T, fallback?: T): T;
+
+declare function toPlainObject<T extends object>(obj: T): T
+
+declare function isMiniProgram(): boolean;
+
+declare const Utils_d_str_utf8_length: typeof str_utf8_length;
+declare const Utils_d_isFunction: typeof isFunction;
+declare const Utils_d_isString: typeof isString;
+declare const Utils_d_isDecimal: typeof isDecimal;
+declare const Utils_d_isEmpty: typeof isEmpty;
+declare const Utils_d_hasMethods: typeof hasMethods;
+declare const Utils_d_newTag: typeof newTag;
+declare const Utils_d_newUUID: typeof newUUID;
+declare const Utils_d_hostType: typeof hostType;
+declare const Utils_d_escapeUser: typeof escapeUser;
+declare const Utils_d_normalizeTarget: typeof normalizeTarget;
+declare const Utils_d_headerize: typeof headerize;
+declare const Utils_d_sipErrorCause: typeof sipErrorCause;
+declare const Utils_d_getRandomTestNetIP: typeof getRandomTestNetIP;
+declare const Utils_d_calculateMD5: typeof calculateMD5;
+declare const Utils_d_closeMediaStream: typeof closeMediaStream;
+declare const Utils_d_cloneArray: typeof cloneArray;
+declare const Utils_d_cloneObject: typeof cloneObject;
+declare const Utils_d_toPlainObject: typeof toPlainObject;
+declare const Utils_d_isMiniProgram: typeof isMiniProgram;
+declare namespace Utils_d {
+  export {
+    Utils_d_str_utf8_length as str_utf8_length,
+    Utils_d_isFunction as isFunction,
+    Utils_d_isString as isString,
+    Utils_d_isDecimal as isDecimal,
+    Utils_d_isEmpty as isEmpty,
+    Utils_d_hasMethods as hasMethods,
+    Utils_d_newTag as newTag,
+    Utils_d_newUUID as newUUID,
+    Utils_d_hostType as hostType,
+    Utils_d_escapeUser as escapeUser,
+    Utils_d_normalizeTarget as normalizeTarget,
+    Utils_d_headerize as headerize,
+    Utils_d_sipErrorCause as sipErrorCause,
+    Utils_d_getRandomTestNetIP as getRandomTestNetIP,
+    Utils_d_calculateMD5 as calculateMD5,
+    Utils_d_closeMediaStream as closeMediaStream,
+    Utils_d_cloneArray as cloneArray,
+    Utils_d_cloneObject as cloneObject,
+    Utils_d_toPlainObject as toPlainObject,
+    Utils_d_isMiniProgram as isMiniProgram,
+  };
+}
+
+declare function getMicrophones(): Promise<Array<MediaDeviceInfo>>
+declare function getSpeakers(): Promise<Array<MediaDeviceInfo>>
+declare function getDevices(): Promise<Array<MediaDeviceInfo>>
+
+declare const Devices_d_getMicrophones: typeof getMicrophones;
+declare const Devices_d_getSpeakers: typeof getSpeakers;
+declare const Devices_d_getDevices: typeof getDevices;
+declare namespace Devices_d {
+  export {
+    Devices_d_getMicrophones as getMicrophones,
+    Devices_d_getSpeakers as getSpeakers,
+    Devices_d_getDevices as getDevices,
+  };
+}
+
+declare class Logger {
+  constructor(prefix?: string);
+  static setLogLevel(level: LOG_LEVEL);
+  static setLogReport(bool: boolean);
+  static setConfig(config: object);
+  static setAttributes(attr: object);
+  debug(...args: any[])
+  warn(...args: any[])
+  error(...args: any[])
+}
+
+interface WeightedSocket  {
+  socket: Socket;
+  weight: number
+}
+
+declare class Socket {
+  get via_transport(): string;
+  set via_transport(value: string);
+
+  get url(): string;
+
+  get sip_uri(): string;
+
+  connect(): void;
+
+  disconnect(): void;
+
+  send(message: string | ArrayBufferLike | Blob | ArrayBufferView): boolean;
+
+  isConnected(): boolean;
+
+  isConnecting(): boolean;
+
+  onconnect(): void;
+
+  ondisconnect(error: boolean, code?: number, reason?: string): void;
+
+  ondata<T>(event: T): void;
+}
+
+declare class NameAddrHeader {
+  get display_name(): string;
+  set display_name(value: string);
+
+  get uri(): URI;
+
+  constructor(uri: URI, display_name?: string, parameters?: Parameters);
+
+  setParam(key: string, value?: string): void;
+
+  getParam<T = any>(key: string): T;
+
+  hasParam(key: string): boolean;
+
+  deleteParam(key: string): void;
+
+  clearParams(): void;
+
+  clone(): this;
+
+  toString(): string;
+
+  static parse(uri: string): Grammar | undefined;
+}
+
+declare class IncomingMessage {
+  method: string
+  from: NameAddrHeader
+  to: NameAddrHeader
+  body: string
+
+  constructor();
+
+  countHeader(name: string): number;
+
+  getHeader(name: string): string;
+
+  getHeaders(name: string): string[];
+
+  hasHeader(name: string): boolean;
+
+  parseHeader<T = unknown>(name: string, idx?: number): T;
+
+  toString(): string;
+}
+
+declare class IncomingRequest extends IncomingMessage {
+  ruri: URI
+}
+
+declare class IncomingResponse extends IncomingMessage {
+  status_code: number
+  reason_phrase: string
+}
+
+declare class OutgoingRequest {
+  method: string
+  ruri: URI
+  cseq: number
+  call_id: string
+  from: NameAddrHeader
+  to: NameAddrHeader
+  body: string
+
+  setHeader(name: string, value: string | string[]): void;
+
+  getHeader(name: string): string;
+
+  getHeaders(name: string): string[];
+
+  hasHeader(name: string): boolean;
+
+  toString(): string;
+}
+
+declare class Stream extends EventEmitter {
+  constructor(options: {
+    audio: boolean,
+    video: boolean
+  })
+
+  get mediaStream(): MediaStream
+
+  getMediaStream(): MediaStream
+}
+
+declare class RemoteStream extends Stream {
+  constructor(options: {
+    mediaStream: MediaStream
+  })
+
+  get type(): 'remote';
+}
+
+declare class LocalStream extends Stream {
+  get type(): 'local';
+
+  initialize(): Promise<LocalStream>;
+
+  close(): void;
+}
+
+interface RTCPeerConnectionDeprecated extends RTCPeerConnection {
+  /**
+   * @deprecated
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/getRemoteStreams
+   */
+  getRemoteStreams(): MediaStream[];
+}
+
+declare enum SessionDirection {
+  INCOMING = 'incoming',
+  OUTGOING = 'outgoing',
+}
+
+declare enum Originator {
+  LOCAL = 'local',
+  REMOTE = 'remote',
+  SYSTEM = 'system',
+}
+
+// options
+interface MediaConstraints {
+  audio?: boolean;
+  video?: boolean;
+}
+
+interface ExtraHeaders {
+  extraHeaders?: string[];
+}
+
+interface AnswerOptions extends ExtraHeaders {
+  mediaConstraints?: MediaConstraints;
+  mediaStream?: MediaStream;
+  pcConfig?: RTCConfiguration;
+  rtcConstraints?: object;
+  rtcAnswerConstraints?: RTCOfferOptions;
+  rtcOfferConstraints?: RTCOfferOptions;
+  sessionTimersExpires?: number;
+  // trtc localStream config
+  streamConfig?: {
+    audio?: boolean;
+    microphoneId?: string;
+    screenAudio?: boolean;
+    audioSource: MediaStreamTrack;
+  }
+}
+
+interface RejectOptions extends ExtraHeaders {
+  status_code?: number;
+  reason_phrase?: string;
+}
+
+interface TerminateOptions extends RejectOptions {
+  body?: string;
+  cause?: causes | string;
+}
+
+interface ReferOptions extends ExtraHeaders {
+  eventHandlers?: any;
+  replaces?: RTCSession;
+}
+
+interface OnHoldResult {
+  local: boolean;
+  remote: boolean;
+}
+
+interface DTFMOptions extends ExtraHeaders {
+  duration?: number;
+  interToneGap?: number;
+  transportType?: DTMF_TRANSPORT;
+}
+
+interface HoldOptions extends ExtraHeaders {
+  useUpdate?: boolean;
+}
+
+interface RenegotiateOptions extends HoldOptions {
+  rtcOfferConstraints?: RTCOfferOptions;
+}
+
+// events
+interface DTMF extends EventEmitter {
+  tone: string;
+  duration: number;
+}
+
+interface Info extends EventEmitter {
+  contentType: string;
+  body: string;
+}
+
+interface PeerConnectionEvent {
+  peerconnection: RTCPeerConnectionDeprecated;
+}
+
+interface ConnectingEvent$1 {
+  request: IncomingRequest | OutgoingRequest;
+}
+
+interface SendingEvent {
+  request: OutgoingRequest
+}
+
+interface IncomingEvent {
+  originator: Originator.LOCAL;
+}
+
+interface EndEvent {
+  originator: Originator;
+  message: IncomingRequest | IncomingResponse;
+  cause: string;
+}
+
+interface IncomingDTMFEvent {
+  originator: Originator.REMOTE;
+  dtmf: DTMF;
+  request: IncomingRequest;
+}
+
+interface OutgoingDTMFEvent {
+  originator: Originator.LOCAL;
+  dtmf: DTMF;
+  request: OutgoingRequest;
+}
+
+interface IncomingInfoEvent {
+  originator: Originator.REMOTE;
+  info: Info;
+  request: IncomingRequest;
+}
+
+interface OutgoingInfoEvent {
+  originator: Originator.LOCAL;
+  info: Info;
+  request: OutgoingRequest;
+}
+
+interface HoldEvent {
+  originator: Originator
+}
+
+interface ReInviteEvent {
+  request: IncomingRequest;
+  callback?: VoidFunction;
+  reject: (options?: RejectOptions) => void;
+}
+
+interface ReferEvent {
+  request: IncomingRequest;
+  accept: Function;
+  reject: VoidFunction;
+}
+
+interface SDPEvent {
+  originator: Originator;
+  type: string;
+  sdp: string;
+}
+
+interface IceCandidateEvent {
+  candidate: RTCIceCandidate;
+  ready: VoidFunction;
+}
+
+interface OutgoingEvent {
+  originator: Originator.REMOTE;
+  response: IncomingResponse;
+}
+
+interface OutgoingAckEvent {
+  originator: Originator.LOCAL;
+}
+
+interface IncomingAckEvent {
+  originator: Originator.REMOTE;
+  ack: IncomingRequest;
+}
+
+type NetworkQuality = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+
+interface NetworkQualityEvent {
+  uplinkNetworkQuality: NetworkQuality;
+  downlinkNetworkQuality: NetworkQuality;
+  uplinkRTT: number;
+  downlinkRTT: number;
+  uplinkLoss: number;
+  downlinkLoss: number;
+}
+
+type AudioVolume = {
+  originator: Originator
+  userId: string;
+  audioVolume: number;
+  stream: Stream$1[];
+}
+interface AudioVolumeEvent {
+  result: AudioVolume[]
+}
+interface StreamChangeEvent {
+  stream: RemoteStream
+}
+
+// listener
+type PeerConnectionListener = (event: PeerConnectionEvent) => void;
+type ConnectingListener$1 = (event: ConnectingEvent$1) => void;
+type SendingListener = (event: SendingEvent) => void;
+type IncomingListener = (event: IncomingEvent) => void;
+type OutgoingListener = (event: OutgoingEvent) => void;
+type IncomingConfirmedListener = (event: IncomingAckEvent) => void;
+type OutgoingConfirmedListener = (event: OutgoingAckEvent) => void;
+type CallListener = IncomingListener | OutgoingListener;
+type ConfirmedListener = IncomingConfirmedListener | OutgoingConfirmedListener;
+type EndListener = (event: EndEvent) => void;
+type IncomingDTMFListener = (event: IncomingDTMFEvent) => void;
+type OutgoingDTMFListener = (event: OutgoingDTMFEvent) => void;
+type DTMFListener = IncomingDTMFListener | OutgoingDTMFListener;
+type IncomingInfoListener = (event: IncomingInfoEvent) => void;
+type OutgoingInfoListener = (event: OutgoingInfoEvent) => void;
+type InfoListener = IncomingInfoListener | OutgoingInfoListener;
+type HoldListener = (event: HoldEvent) => void;
+type MuteListener = (event: MediaConstraints) => void;
+type ReInviteListener = (event: ReInviteEvent) => void;
+type UpdateListener = ReInviteListener;
+type ReferListener = (event: ReferEvent) => void;
+type SDPListener = (event: SDPEvent) => void;
+type IceCandidateListener = (event: IceCandidateEvent) => void;
+type NetworkQualityListener = (event: NetworkQualityEvent) => void;
+type AudioVolumeListener = (event: AudioVolumeEvent) => void;
+type StreamChangeListener = (event: StreamChangeEvent) => void;
+
+interface RTCSessionEventMap {
+  'peerconnection': PeerConnectionListener;
+  'connecting': ConnectingListener$1;
+  'sending': SendingListener;
+  'progress': CallListener;
+  'accepted': CallListener;
+  'confirmed': ConfirmedListener;
+  'ended': EndListener;
+  'failed': EndListener;
+  'newDTMF': DTMFListener;
+  'newInfo': InfoListener;
+  'hold': HoldListener;
+  'unhold': HoldListener;
+  'muted': MuteListener;
+  'unmuted': MuteListener;
+  'reinvite': ReInviteListener;
+  'update': UpdateListener;
+  'refer': ReferListener;
+  'replaces': ReferListener;
+  'sdp': SDPListener;
+  'icecandidate': IceCandidateListener;
+  'networkquality': NetworkQualityListener;
+  'audiovolume': AudioVolumeListener;
+  'addstream': StreamChangeListener;
+  'stream-subscribed': StreamChangeListener;
+  'remotestream': StreamChangeListener;
+  'stream-removed': StreamChangeListener;
+  'stream-updated': StreamChangeListener;
+  'getusermediafailed': Listener;
+  'peerconnection:createofferfailed': Listener;
+  'peerconnection:createanswerfailed': Listener;
+  'peerconnection:setlocaldescriptionfailed': Listener;
+  'peerconnection:setremotedescriptionfailed': Listener;
+}
+
+declare enum SessionStatus {
+  STATUS_NULL = 0,
+  STATUS_INVITE_SENT = 1,
+  STATUS_1XX_RECEIVED = 2,
+  STATUS_INVITE_RECEIVED = 3,
+  STATUS_WAITING_FOR_ANSWER = 4,
+  STATUS_ANSWERED = 5,
+  STATUS_WAITING_FOR_ACK = 6,
+  STATUS_CANCELED = 7,
+  STATUS_TERMINATED = 8,
+  STATUS_CONFIRMED = 9
+}
+
+declare class RTCSession extends EventEmitter {
+  static get C(): typeof SessionStatus;
+
+  get C(): typeof SessionStatus;
+
+  get causes(): typeof causes;
+
+  get id(): string;
+
+  set data(_data: any);
+  get data(): any;
+
+  get connection(): RTCPeerConnectionDeprecated;
+
+  get contact(): string;
+
+  get direction(): SessionDirection;
+
+  get local_identity(): NameAddrHeader;
+
+  get remote_identity(): NameAddrHeader;
+
+  get start_time(): Date;
+
+  get end_time(): Date;
+
+  get status(): SessionStatus;
+
+  get localStreams(): LocalStream[];
+
+  get remoteStreams(): RemoteStream[]
+
+  isInProgress(): boolean;
+
+  isEstablished(): boolean;
+
+  isEnded(): boolean;
+
+  isReadyToReOffer(): boolean;
+
+  answer(options?: AnswerOptions): void;
+
+  terminate(options?: TerminateOptions): void;
+
+  sendDTMF(tones: string | number, options?: DTFMOptions): void;
+
+  sendInfo(contentType: string, body?: string, options?: ExtraHeaders): void;
+
+  hold(options?: HoldOptions, done?: VoidFunction): boolean;
+
+  unhold(options?: HoldOptions, done?: VoidFunction): boolean;
+
+  renegotiate(options?: RenegotiateOptions, done?: VoidFunction): boolean;
+
+  isOnHold(): OnHoldResult;
+
+  mute(options?: MediaConstraints): void;
+
+  unmute(options?: MediaConstraints): void;
+
+  isMuted(): MediaConstraints;
+
+  refer(target: string | URI, options?: ReferOptions): void;
+
+  switchMicrophones(deviceId: string): Promise<void>;
+
+  switchSpeaker(deviceId: string): Promise<void>;
+
+  setAudioVolume(volume: number): void;
+
+  enableAudioVolumeEvaluation(interval?: number, enableInBackground?: boolean): void;
+
+  on<T extends keyof RTCSessionEventMap>(type: T, listener: RTCSessionEventMap[T]): this;
+}
+
+interface AcceptOptions extends ExtraHeaders {
+  body?: string;
+}
+
+interface MessageFailedEvent {
+  originator: Originator;
+  response: IncomingResponse;
+  cause?: causes;
+}
+
+type MessageFailedListener = (event: MessageFailedEvent) => void;
+
+interface MessageEventMap {
+  succeeded: OutgoingListener;
+  failed: MessageFailedListener;
+}
+
+interface SendMessageOptions extends ExtraHeaders {
+  contentType?: string;
+  eventHandlers?: Partial<MessageEventMap>;
+  fromUserName?: string;
+  fromDisplayName?: string;
+}
+
+declare class Message extends EventEmitter {
+  get direction(): SessionDirection;
+
+  get local_identity(): NameAddrHeader;
+
+  get remote_identity(): NameAddrHeader;
+
+  send(target: string, body: string, options?: SendMessageOptions): void;
+
+  accept(options: AcceptOptions): void;
+
+  reject(options: TerminateOptions): void;
+
+  on<T extends keyof MessageEventMap>(type: T, listener: MessageEventMap[T]): this;
+}
+
+interface RecoveryOptions {
+  min_interval: number;
+  max_interval: number;
+}
+
+declare class Transport extends Socket {
+  constructor(sockets: Socket | Socket[], recovery_options?: RecoveryOptions)
+}
+
+type ExtraContactParams = Record<string, string | number | boolean>;
+
+declare class Registrator {
+  constructor(ua: UA, transport: Transport);
+
+  setExtraHeaders(extraHeaders: string[]): void;
+
+  setExtraContactParams(extraContactParams: ExtraContactParams): void;
+}
+
+interface UnRegisterOptions {
+  all?: boolean;
+}
+
+interface CallOptions extends AnswerOptions {
+  eventHandlers?: Partial<RTCSessionEventMap>;
+  anonymous?: boolean;
+  fromUserName?: string;
+  fromDisplayName?: string;
+}
+
+interface UAConfiguration {
+  // mandatory parameters
+  sockets: Socket | Socket[] | WeightedSocket[] ;
+  uri: string;
+  // optional parameters
+  authorization_jwt?: string;
+  authorization_user?: string;
+  connection_recovery_max_interval?: number;
+  connection_recovery_min_interval?: number;
+  contact_uri?: string;
+  display_name?: string;
+  instance_id?: string;
+  no_answer_timeout?: number;
+  session_timers?: boolean;
+  session_timers_refresh_method?: string;
+  session_timers_force_refresher?: boolean;
+  password?: string;
+  realm?: string;
+  ha1?: string;
+  register?: boolean;
+  register_expires?: number;
+  registrar_server?: string;
+  use_preloaded_route?: boolean;
+  user_agent?: string;
+  extra_headers?: string[];
+  log_level?: LOG_LEVEL;
+  log_report?: boolean;
+  use_trtc?: boolean;
+}
+
+interface IncomingRTCSessionEvent {
+  originator: Originator.REMOTE;
+  session: RTCSession;
+  request: IncomingRequest;
+}
+
+interface OutgoingRTCSessionEvent {
+  originator: Originator.LOCAL;
+  session: RTCSession;
+  request: IncomingRequest;
+}
+
+interface ConnectingEvent {
+  socket: Socket;
+  attempts: number
+}
+
+interface ConnectedEvent {
+  socket: Socket;
+}
+
+interface DisconnectEvent {
+  socket: Socket;
+  error: boolean;
+  code?: number;
+  reason?: string;
+}
+
+interface RegisteredEvent {
+  response: IncomingResponse;
+}
+
+interface UnRegisteredEvent {
+  response: IncomingResponse;
+  cause?: causes;
+}
+
+interface IncomingMessageEvent {
+  originator: Originator.REMOTE;
+  message: Message;
+  request: IncomingRequest;
+}
+
+interface OutgoingMessageEvent {
+  originator: Originator.LOCAL;
+  message: Message;
+  request: OutgoingRequest;
+}
+
+interface IncomingOptionsEvent {
+  originator: Originator.REMOTE;
+  request: IncomingRequest;
+}
+
+interface OutgoingOptionsEvent {
+  originator: Originator.LOCAL;
+  request: OutgoingRequest;
+}
+
+type ConnectingListener = (event: ConnectingEvent) => void;
+type ConnectedListener = (event: ConnectedEvent) => void;
+type DisconnectedListener = (event: DisconnectEvent) => void;
+type RegisteredListener = (event: RegisteredEvent) => void;
+type UnRegisteredListener = (event: UnRegisteredEvent) => void;
+type RegistrationFailedListener = UnRegisteredListener;
+type IncomingRTCSessionListener = (event: IncomingRTCSessionEvent) => void;
+type OutgoingRTCSessionListener = (event: OutgoingRTCSessionEvent) => void;
+type RTCSessionListener = IncomingRTCSessionListener | OutgoingRTCSessionListener;
+type IncomingMessageListener = (event: IncomingMessageEvent) => void;
+type OutgoingMessageListener = (event: OutgoingMessageEvent) => void;
+type MessageListener = IncomingMessageListener | OutgoingMessageListener;
+type IncomingOptionsListener = (event: IncomingOptionsEvent) => void;
+type OutgoingOptionsListener = (event: OutgoingOptionsEvent) => void;
+type OptionsListener = IncomingOptionsListener | OutgoingOptionsListener;
+type SipEventListener = <T = any>(event: { event: T; request: IncomingRequest; }) => void
+
+interface UAEventMap {
+  connecting: ConnectingListener;
+  connected: ConnectedListener;
+  disconnected: DisconnectedListener;
+  registered: RegisteredListener;
+  unregistered: UnRegisteredListener;
+  registrationFailed: RegistrationFailedListener;
+  registrationExpiring: Listener;
+  newRTCSession: RTCSessionListener;
+  newMessage: MessageListener;
+  sipEvent: SipEventListener;
+  newOptions: OptionsListener;
+}
+
+interface UAContactOptions {
+  anonymous?: boolean;
+  outbound?: boolean;
+}
+
+interface UAContact {
+  pub_gruu?: string,
+  temp_gruu?: string,
+  uri?: string;
+
+  toString(options?: UAContactOptions): string
+}
+
+declare enum UAStatus {
+  // UA status codes.
+  STATUS_INIT = 0,
+  STATUS_READY = 1,
+  STATUS_USER_CLOSED = 2,
+  STATUS_NOT_READY = 3,
+  // UA error codes.
+  CONFIGURATION_ERROR = 1,
+  NETWORK_ERROR = 2
+}
+
+declare class UA extends EventEmitter {
+  static get C(): typeof UAStatus;
+
+  constructor(configuration: UAConfiguration);
+
+  get C(): typeof UAStatus;
+
+  get status(): UAStatus;
+
+  get contact(): UAContact;
+
+  start(): void;
+
+  stop(): void;
+
+  register(): void;
+
+  unregister(options?: UnRegisterOptions): void;
+
+  registrator(): Registrator;
+
+  call(target: string, options?: CallOptions): RTCSession;
+
+  sendMessage(target: string | URI, body: string, options?: SendMessageOptions): Message;
+
+  terminateSessions(options?: TerminateOptions): void;
+
+  isRegistered(): boolean;
+
+  isConnected(): boolean;
+
+  get<T extends keyof UAConfiguration>(parameter: T): UAConfiguration[T];
+
+  set<T extends keyof UAConfiguration>(parameter: T, value: UAConfiguration[T]): boolean;
+
+  on<T extends keyof UAEventMap>(type: T, listener: UAEventMap[T]): this;
+}
+
+declare class WebSocketInterface extends Socket {
+  constructor(url: string)
+}
+
+declare const debug: Debug
+declare const name: string
+declare const version: string
+
+export { Constants_d as C, Devices_d as Devices, Exceptions_d as Exceptions, Grammar_d as Grammar, Logger, NameAddrHeader, Socket, UA, UAConfiguration, URI, Utils_d as Utils, WebSocketInterface, WeightedSocket, debug, name, version };