From 36f28a752bc22657589c12681bfe09c40ec4492a Mon Sep 17 00:00:00 2001 From: Vitaliy Yakovenko Date: Mon, 2 Sep 2019 23:25:31 +0500 Subject: [PATCH] Typescript typings --- lib/Constants.d.ts | 66 ++++++++ lib/Exceptions.d.ts | 24 +++ lib/Grammar.d.ts | 5 + lib/JsSIP.d.ts | 14 ++ lib/Message.d.ts | 45 ++++++ lib/NameAddrHeader.d.ts | 27 ++++ lib/RTCSession.d.ts | 298 ++++++++++++++++++++++++++++++++++++ lib/Registrator.d.ts | 12 ++ lib/SIPMessage.d.ts | 52 +++++++ lib/Transport.d.ts | 10 ++ lib/UA.d.ts | 176 +++++++++++++++++++++ lib/URI.d.ts | 44 ++++++ lib/Utils.d.ts | 36 +++++ lib/WebSocketInterface.d.ts | 35 +++++ package.json | 3 + 15 files changed, 847 insertions(+) create mode 100644 lib/Constants.d.ts create mode 100644 lib/Exceptions.d.ts create mode 100644 lib/Grammar.d.ts create mode 100644 lib/JsSIP.d.ts create mode 100644 lib/Message.d.ts create mode 100644 lib/NameAddrHeader.d.ts create mode 100644 lib/RTCSession.d.ts create mode 100644 lib/Registrator.d.ts create mode 100644 lib/SIPMessage.d.ts create mode 100644 lib/Transport.d.ts create mode 100644 lib/UA.d.ts create mode 100644 lib/URI.d.ts create mode 100644 lib/Utils.d.ts create mode 100644 lib/WebSocketInterface.d.ts diff --git a/lib/Constants.d.ts b/lib/Constants.d.ts new file mode 100644 index 000000000..465552f49 --- /dev/null +++ b/lib/Constants.d.ts @@ -0,0 +1,66 @@ +export const USER_AGENT: string +export const SIP = 'sip' +export const SIPS = 'sips' + +export 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', +} + +export 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] +} +export const ACK = 'ACK' +export const BYE = 'BYE' +export const CANCEL = 'CANCEL' +export const INFO = 'INFO' +export const INVITE = 'INVITE' +export const MESSAGE = 'MESSAGE' +export const NOTIFY = 'NOTIFY' +export const OPTIONS = 'OPTIONS' +export const REGISTER = 'REGISTER' +export const REFER = 'REFER' +export const UPDATE = 'UPDATE' +export const SUBSCRIBE = 'SUBSCRIBE' + +export enum DTMF_TRANSPORT { + INFO = 'INFO', + RFC2833 = 'RFC2833', +} + +export const REASON_PHRASE: Record +export const ALLOWED_METHODS = 'INVITE,ACK,CANCEL,BYE,UPDATE,MESSAGE,OPTIONS,REFER,INFO,NOTIFY' +export const ACCEPTED_BODY_TYPES = 'application/sdp, application/dtmf-relay' +export const MAX_FORWARDS = 69 +export const SESSION_EXPIRES = 90 +export const MIN_SESSION_EXPIRES = 60 +export const CONNECTION_RECOVERY_MAX_INTERVAL = 30 +export const CONNECTION_RECOVERY_MIN_INTERVAL = 2 diff --git a/lib/Exceptions.d.ts b/lib/Exceptions.d.ts new file mode 100644 index 000000000..03c9fd85e --- /dev/null +++ b/lib/Exceptions.d.ts @@ -0,0 +1,24 @@ +declare class BaseError extends Error { + code: number +} + +export class ConfigurationError extends BaseError { + parameter: string + value: any + + constructor(parameter: string, value?: any); +} + +export class InvalidStateError extends BaseError { + status: number + + constructor(status: number); +} + +export class NotSupportedError extends BaseError { + constructor(message: string); +} + +export class NotReadyError extends BaseError { + constructor(message: string); +} diff --git a/lib/Grammar.d.ts b/lib/Grammar.d.ts new file mode 100644 index 000000000..6ac750188 --- /dev/null +++ b/lib/Grammar.d.ts @@ -0,0 +1,5 @@ +export type Grammar = any; + +export function parse(input: string, startRule?: string): Grammar; + +export function toSource(): any; diff --git a/lib/JsSIP.d.ts b/lib/JsSIP.d.ts new file mode 100644 index 000000000..f69b863b4 --- /dev/null +++ b/lib/JsSIP.d.ts @@ -0,0 +1,14 @@ +import {Debug} from 'debug' + +export * as C from './Constants' +export * as Exceptions from './Exceptions' +export * as Utils from './Utils' +export {UA} from './UA' +export {URI} from './URI' +export {NameAddrHeader} from './NameAddrHeader' +export {WebSocketInterface} from './WebSocketInterface' +export * as Grammar from './Grammar' + +export const debug: Debug +export const name: string +export const version: string diff --git a/lib/Message.d.ts b/lib/Message.d.ts new file mode 100644 index 000000000..05e4a9b54 --- /dev/null +++ b/lib/Message.d.ts @@ -0,0 +1,45 @@ +/// +import {EventEmitter} from 'events' + +import {ExtraHeaders, Originator, OutgoingListener, SessionDirection, TerminateOptions} from './RTCSession' +import {IncomingResponse} from './SIPMessage' +import {NameAddrHeader} from './NameAddrHeader' +import {causes} from './Constants'; + +export interface AcceptOptions extends ExtraHeaders { + body?: string; +} + +export interface MessageFailedEvent { + originator: Originator; + response: IncomingResponse; + cause?: causes; +} + +export type MessageFailedListener = (event: MessageFailedEvent) => void; + +export interface MessageEventMap { + succeeded: OutgoingListener; + failed: MessageFailedListener; +} + +export interface SendMessageOptions extends ExtraHeaders { + contentType?: string; + eventHandlers?: Partial; +} + +export 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(type: T, listener: MessageEventMap[T]): this; +} diff --git a/lib/NameAddrHeader.d.ts b/lib/NameAddrHeader.d.ts new file mode 100644 index 000000000..6529c100f --- /dev/null +++ b/lib/NameAddrHeader.d.ts @@ -0,0 +1,27 @@ +import {Parameters, URI} from './URI' +import {Grammar} from './Grammar' + +export 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(key: string): T; + + hasParam(key: string): boolean; + + deleteParam(key: string): void; + + clearParams(): void; + + clone(): this; + + toString(): string; + + static parse(uri: string): Grammar | undefined; +} diff --git a/lib/RTCSession.d.ts b/lib/RTCSession.d.ts new file mode 100644 index 000000000..b4398202f --- /dev/null +++ b/lib/RTCSession.d.ts @@ -0,0 +1,298 @@ +/// +import {EventEmitter} from 'events' + +import {IncomingRequest, IncomingResponse, OutgoingRequest} from './SIPMessage' +import {NameAddrHeader} from './NameAddrHeader' +import {URI} from './URI' +import {causes, DTMF_TRANSPORT} from './Constants' + +interface RTCPeerConnectionDeprecated extends RTCPeerConnection { + /** + * @deprecated + * @see https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/getRemoteStreams + */ + getRemoteStreams(): MediaStream[]; +} + +export enum SessionDirection { + INCOMING = 'incoming', + OUTGOING = 'outgoing', +} + +export enum Originator { + LOCAL = 'local', + REMOTE = 'remote', + SYSTEM = 'system', +} + +// options +export interface MediaConstraints { + audio?: boolean; + video?: boolean; +} + +export interface ExtraHeaders { + extraHeaders?: string[]; +} + +export interface AnswerOptions extends ExtraHeaders { + mediaConstraints?: MediaConstraints; + mediaStream?: MediaStream; + pcConfig?: RTCConfiguration; + rtcConstraints?: object; + rtcAnswerConstraints?: RTCOfferOptions; + rtcOfferConstraints?: RTCOfferOptions; + sessionTimersExpires?: number; +} + +export interface RejectOptions extends ExtraHeaders { + status_code?: number; + reason_phrase?: string; +} + +export interface TerminateOptions extends RejectOptions { + body?: string; + cause?: causes | string; +} + +export interface ReferOptions extends ExtraHeaders { + eventHandlers?: any; + replaces?: RTCSession; +} + +export interface OnHoldResult { + local: boolean; + remote: boolean; +} + +export interface DTFMOptions extends ExtraHeaders { + duration?: number; + interToneGap?: number; + transportType?: DTMF_TRANSPORT; +} + +export interface HoldOptions extends ExtraHeaders { + useUpdate?: boolean; +} + +export interface RenegotiateOptions extends HoldOptions { + rtcOfferConstraints?: RTCOfferOptions; +} + +// events +export interface DTMF extends EventEmitter { + tone: string; + duration: number; +} + +export interface Info extends EventEmitter { + contentType: string; + body: string; +} + +export interface PeerConnectionEvent { + peerconnection: RTCPeerConnectionDeprecated; +} + +export interface ConnectingEvent { + request: IncomingRequest | OutgoingRequest; +} + +export interface SendingEvent { + request: OutgoingRequest +} + +export interface IncomingEvent { + originator: Originator.LOCAL; +} + +export interface EndEvent { + originator: Originator; + message: IncomingRequest | IncomingResponse; + cause: string; +} + +export interface IncomingDTMFEvent { + originator: Originator.REMOTE; + dtmf: DTMF; + request: IncomingRequest; +} + +export interface OutgoingDTMFEvent { + originator: Originator.LOCAL; + dtmf: DTMF; + request: OutgoingRequest; +} + +export interface IncomingInfoEvent { + originator: Originator.REMOTE; + info: Info; + request: IncomingRequest; +} + +export interface OutgoingInfoEvent { + originator: Originator.LOCAL; + info: Info; + request: OutgoingRequest; +} + +export interface HoldEvent { + originator: Originator +} + +export interface ReInviteEvent { + request: IncomingRequest; + callback?: VoidFunction; + reject: (options?: RejectOptions) => void; +} + +export interface ReferEvent { + request: IncomingRequest; + accept: Function; + reject: VoidFunction; +} + +export interface SDPEvent { + originator: Originator; + type: string; + sdp: string; +} + +export interface IceCandidateEvent { + candidate: RTCIceCandidate; + ready: VoidFunction; +} + +export interface OutgoingEvent { + originator: Originator.REMOTE; + response: IncomingResponse +} + +// listener +export type AnyListener = (...args: any[]) => void; +export type PeerConnectionListener = (event: PeerConnectionEvent) => void; +export type ConnectingListener = (event: ConnectingEvent) => void; +export type SendingListener = (event: SendingEvent) => void; +export type IncomingListener = (event: IncomingEvent) => void; +export type OutgoingListener = (event: OutgoingEvent) => void; +export type CallListener = IncomingListener | OutgoingListener; +export type EndListener = (event: EndEvent) => void; +export type IncomingDTMFListener = (event: IncomingDTMFEvent) => void; +export type OutgoingDTMFListener = (event: OutgoingDTMFEvent) => void; +export type DTMFListener = IncomingDTMFListener | OutgoingDTMFListener; +export type IncomingInfoListener = (event: IncomingInfoEvent) => void; +export type OutgoingInfoListener = (event: OutgoingInfoEvent) => void; +export type InfoListener = IncomingInfoListener | OutgoingInfoListener; +export type HoldListener = (event: HoldEvent) => void; +export type MuteListener = (event: MediaConstraints) => void; +export type ReInviteListener = (event: ReInviteEvent) => void; +export type UpdateListener = ReInviteListener; +export type ReferListener = (event: ReferEvent) => void; +export type SDPListener = (event: SDPEvent) => void; +export type IceCandidateListener = (event: IceCandidateEvent) => void; + +export interface RTCSessionEventMap { + 'peerconnection': PeerConnectionListener; + 'connecting': ConnectingListener; + 'sending': SendingListener; + 'progress': CallListener; + 'accepted': CallListener; + 'confirmed': CallListener; + '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; + 'getusermediafailed': AnyListener; + 'peerconnection:createofferfailed': AnyListener; + 'peerconnection:createanswerfailed': AnyListener; + 'peerconnection:setlocaldescriptionfailed': AnyListener; + 'peerconnection:setremotedescriptionfailed': AnyListener; +} + +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 +} + +export 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; + + 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; + + resetLocalMedia(): void; + + on(type: T, listener: RTCSessionEventMap[T]): this; +} diff --git a/lib/Registrator.d.ts b/lib/Registrator.d.ts new file mode 100644 index 000000000..7d5d6a152 --- /dev/null +++ b/lib/Registrator.d.ts @@ -0,0 +1,12 @@ +import {UA} from './UA' +import {Transport} from './Transport' + +export type ExtraContactParams = Record; + +export class Registrator { + constructor(ua: UA, transport: Transport); + + setExtraHeaders(extraHeaders: string[]): void; + + setExtraContactParams(extraContactParams: ExtraContactParams): void; +} diff --git a/lib/SIPMessage.d.ts b/lib/SIPMessage.d.ts new file mode 100644 index 000000000..9b737332f --- /dev/null +++ b/lib/SIPMessage.d.ts @@ -0,0 +1,52 @@ +import {NameAddrHeader} from './NameAddrHeader' +import {URI} from './URI' + +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(name: string, idx?: number): T; + + toString(): string; +} + +export class IncomingRequest extends IncomingMessage { + ruri: URI +} + +export class IncomingResponse extends IncomingMessage { + status_code: number + reason_phrase: string +} + +export 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; +} diff --git a/lib/Transport.d.ts b/lib/Transport.d.ts new file mode 100644 index 000000000..68d2322e8 --- /dev/null +++ b/lib/Transport.d.ts @@ -0,0 +1,10 @@ +import {Socket} from './WebSocketInterface' + +export interface RecoveryOptions { + min_interval: number; + max_interval: number; +} + +export class Transport extends Socket { + constructor(sockets: Socket | Socket[], recovery_options?: RecoveryOptions) +} diff --git a/lib/UA.d.ts b/lib/UA.d.ts new file mode 100644 index 000000000..566e85dc8 --- /dev/null +++ b/lib/UA.d.ts @@ -0,0 +1,176 @@ +/// +import {EventEmitter} from 'events' + +import {DisconnectEvent, Socket} from './WebSocketInterface' +import {AnswerOptions, AnyListener, Originator, RTCSession, RTCSessionEventMap, TerminateOptions} from './RTCSession' +import {IncomingRequest, IncomingResponse, OutgoingRequest} from './SIPMessage' +import {Message, SendMessageOptions} from './Message' +import {Registrator} from './Registrator' +import {URI} from './URI' +import {causes} from './Constants' + +export interface UnRegisterOptions { + all?: boolean; +} + +export interface CallOptions extends AnswerOptions { + eventHandlers?: Partial; + anonymous?: boolean; +} + +export interface UAConfiguration { + // mandatory parameters + sockets: Socket | Socket[]; + uri: string; + // optional parameters + 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; + password?: string; + realm?: string; + ha1?: string; + register?: boolean; + register_expires?: number; + registrar_server?: string; + use_preloaded_route?: boolean; + user_agent?: string; +} + +export interface IncomingRTCSessionEvent { + originator: Originator.REMOTE; + session: RTCSession; + request: IncomingRequest; +} + +export interface OutgoingRTCSessionEvent { + originator: Originator.LOCAL; + session: RTCSession; + request: IncomingRequest; +} + +export type RTCSessionEvent = IncomingRTCSessionEvent | OutgoingRTCSessionEvent; + +export interface UAConnectingEvent { + socket: Socket; + attempts: number +} + +export interface ConnectedEvent { + socket: Socket; +} + +export interface RegisteredEvent { + response: IncomingResponse; +} + +export interface UnRegisteredEvent { + response: IncomingResponse; + cause?: causes; +} + +export interface IncomingMessageEvent { + originator: Originator.REMOTE; + message: Message; + request: IncomingRequest; +} + +export interface OutgoingMessageEvent { + originator: Originator.LOCAL; + message: Message; + request: OutgoingRequest; +} + +export type UAConnectingListener = (event: UAConnectingEvent) => void; +export type ConnectedListener = (event: ConnectedEvent) => void; +export type DisconnectedListener = (event: DisconnectEvent) => void; +export type RegisteredListener = (event: RegisteredEvent) => void; +export type UnRegisteredListener = (event: UnRegisteredEvent) => void; +export type RegistrationFailedListener = UnRegisteredListener; +export type IncomingRTCSessionListener = (event: IncomingRTCSessionEvent) => void; +export type OutgoingRTCSessionListener = (event: OutgoingRTCSessionEvent) => void; +export type RTCSessionListener = IncomingRTCSessionListener | OutgoingRTCSessionListener; +export type IncomingMessageListener = (event: IncomingMessageEvent) => void; +export type OutgoingMessageListener = (event: OutgoingMessageEvent) => void; +export type MessageListener = IncomingMessageListener | OutgoingMessageListener; +export type SipEventListener = (event: { event: T; request: IncomingRequest; }) => void + +export interface UAEventMap { + connecting: UAConnectingListener; + connected: ConnectedListener; + disconnected: DisconnectedListener; + registered: RegisteredListener; + unregistered: UnRegisteredListener; + registrationFailed: RegistrationFailedListener; + registrationExpiring: AnyListener; + newRTCSession: RTCSessionListener; + newMessage: MessageListener; + sipEvent: SipEventListener; +} + +export interface UAContactOptions { + anonymous?: boolean; + outbound?: boolean; +} + +export 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 +} + +export 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(parameter: T): UAConfiguration[T]; + + set(parameter: T, value: UAConfiguration[T]): boolean; + + on(type: T, listener: UAEventMap[T]): this; +} diff --git a/lib/URI.d.ts b/lib/URI.d.ts new file mode 100644 index 000000000..66d3a0963 --- /dev/null +++ b/lib/URI.d.ts @@ -0,0 +1,44 @@ +import {Grammar} from './Grammar' + +export type URIScheme = 'sip' | string; + +export type Parameters = Record; + +export type Headers = Record; + +export 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(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; +} diff --git a/lib/Utils.d.ts b/lib/Utils.d.ts new file mode 100644 index 000000000..3e73f8843 --- /dev/null +++ b/lib/Utils.d.ts @@ -0,0 +1,36 @@ +import {URI} from './URI' +import {causes} from './Constants' + +export function str_utf8_length(str: string): number; + +export function isString(str: unknown): str is string; + +export function isDecimal(num: unknown): num is number; + +export function isEmpty(value: unknown): boolean; + +export function hasMethods(obj: any, ...methodNames: string[]): boolean; + +export function newTag(): string; + +export function newUUID(): string; + +export function hostType(host: string): string; + +export function escapeUser(user: string): string; + +export function normalizeTarget(target: URI | string, domain?: string): URI | undefined; + +export function headerize(str: string): string; + +export function sipErrorCause(status_code: number): causes; + +export function getRandomTestNetIP(): string; + +export function calculateMD5(str: string): string; + +export function closeMediaStream(stream?: MediaStream): void; + +export function cloneArray(arr: T[]): T[]; + +export function cloneObject(obj: T, fallback?: T): T; diff --git a/lib/WebSocketInterface.d.ts b/lib/WebSocketInterface.d.ts new file mode 100644 index 000000000..a274709a7 --- /dev/null +++ b/lib/WebSocketInterface.d.ts @@ -0,0 +1,35 @@ +export interface DisconnectEvent { + socket: Socket; + error: boolean; + code?: number; + reason?: string; +} + +export 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(event: DisconnectEvent): void; + + ondata(event: T): void; +} + +export class WebSocketInterface extends Socket { + constructor(url: string) +} diff --git a/package.json b/package.json index 94193b001..36edb1a0c 100644 --- a/package.json +++ b/package.json @@ -8,6 +8,7 @@ "contributors": [ "IƱaki Baz Castillo (https://github.com/ibc)" ], + "types": "lib/JsSIP.d.ts", "main": "lib-es5/JsSIP.js", "keywords": [ "sip", @@ -26,6 +27,8 @@ "url": "https://github.com/versatica/JsSIP/issues" }, "dependencies": { + "@types/debug": "^4.1.5", + "@types/node": "^14.0.6", "debug": "^4.1.1", "events": "^3.1.0", "sdp-transform": "^2.14.0"