react-jssip-kit 0.5.1 → 0.5.2

package/dist/index.d.ts

@@ -1,87 +1,389 @@
-import * as jssip_lib_UA from 'jssip/lib/UA';
-import { UAEventMap, IncomingRTCSessionEvent, UAConfiguration, CallOptions, RTCSessionEvent } from 'jssip/lib/UA';
-export { CallOptions, RTCSessionEvent, UAEventMap } from 'jssip/lib/UA';
-import * as jssip_lib_RTCSession from 'jssip/lib/RTCSession';
-import { RTCSessionEventMap, DTFMOptions as DTFMOptions$1, AnswerOptions, TerminateOptions, RTCSession, ReferOptions } from 'jssip/lib/RTCSession';
-export { AnswerOptions, RTCSession, RTCSessionEventMap, ReferOptions, TerminateOptions } from 'jssip/lib/RTCSession';
 import { UA } from 'jssip';
 export { WebSocketInterface } from 'jssip';
 import * as react from 'react';
 import react__default from 'react';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 
+type Originator = "local" | "remote" | "system";
+type SessionDirection = "incoming" | "outgoing";
+
+interface SIPURI {
+  user: string;
+}
+
+interface NameAddrHeader {
+  uri: SIPURI;
+}
+
+interface IncomingRequest {
+  body?: string | { toString(): string };
+  from: NameAddrHeader;
+  to: NameAddrHeader;
+}
+
+interface OutgoingRequest {
+  body?: string | { toString(): string };
+  from: NameAddrHeader;
+  to: NameAddrHeader;
+}
+
+interface IncomingResponse {
+  status_code?: number;
+  reason_phrase?: string;
+}
+
+interface ExtraHeaders {
+  extraHeaders?: string[];
+}
+
+interface AnswerOptions extends ExtraHeaders {
+  mediaConstraints?: MediaStreamConstraints;
+  mediaStream?: MediaStream;
+  pcConfig?: RTCConfiguration;
+  rtcConstraints?: object;
+  rtcAnswerConstraints?: RTCOfferOptions;
+  rtcOfferConstraints?: RTCOfferOptions;
+  sessionTimersExpires?: number;
+}
+
+interface RejectOptions extends ExtraHeaders {
+  status_code?: number;
+  reason_phrase?: string;
+}
+
+interface TerminateOptions extends RejectOptions {
+  body?: string;
+  cause?: string;
+}
+
+interface ReferOptions extends ExtraHeaders {
+  eventHandlers?: Record<string, unknown>;
+  replaces?: RTCSession;
+}
+
+interface DTFMOptions extends ExtraHeaders {
+  duration?: number;
+  interToneGap?: number;
+  transportType?: string;
+}
+
+interface HoldOptions extends ExtraHeaders {
+  useUpdate?: boolean;
+}
+
+interface MediaStreamTypes {
+  audio?: boolean;
+  video?: boolean;
+}
+
+interface DTMF {
+  tone: string;
+  duration: number;
+}
+
+interface Info {
+  contentType: string;
+  body: string;
+}
+
+interface PeerConnectionEvent {
+  peerconnection: RTCPeerConnection;
+}
+
+interface ConnectingEvent {
+  request: IncomingRequest | OutgoingRequest;
+}
+
+interface SendingEvent {
+  request: OutgoingRequest;
+}
+
+interface IncomingEvent {
+  originator: Originator;
+}
+
+interface OutgoingEvent {
+  originator: Originator;
+  response?: IncomingResponse;
+}
+
+interface IncomingAckEvent {
+  originator: Originator;
+  ack: IncomingRequest;
+}
+
+interface OutgoingAckEvent {
+  originator: Originator;
+}
+
+interface EndEvent {
+  originator: Originator;
+  message?: IncomingRequest | IncomingResponse;
+  cause?: string;
+}
+
+interface IncomingDTMFEvent {
+  originator: Originator;
+  dtmf: DTMF;
+  request?: IncomingRequest;
+}
+
+interface OutgoingDTMFEvent {
+  originator: Originator;
+  dtmf: DTMF;
+  request?: OutgoingRequest;
+}
+
+interface IncomingInfoEvent {
+  originator: Originator;
+  info: Info;
+  request?: IncomingRequest;
+}
+
+interface OutgoingInfoEvent {
+  originator: Originator;
+  info: Info;
+  request?: OutgoingRequest;
+}
+
+interface HoldEvent {
+  originator: Originator;
+}
+
+interface ReInviteEvent {
+  request?: IncomingRequest;
+  callback?: VoidFunction;
+  reject?: (options?: RejectOptions) => void;
+}
+
+interface ReferEvent {
+  request?: IncomingRequest;
+  accept?: () => void;
+  reject?: VoidFunction;
+}
+
+interface SDPEvent {
+  originator: Originator;
+  type: string;
+  sdp: string;
+}
+
+interface IceCandidateEvent {
+  candidate: RTCIceCandidate;
+  ready: VoidFunction;
+}
+
+interface IncomingRTCSessionEvent {
+  originator: "remote";
+  session: RTCSession;
+  request: IncomingRequest;
+}
+
+interface OutgoingRTCSessionEvent {
+  originator: "local";
+  session: RTCSession;
+  request: OutgoingRequest;
+}
+
+type RTCSessionEvent = IncomingRTCSessionEvent | OutgoingRTCSessionEvent;
+
+type RTCSessionEventMap = {
+  peerconnection: (event: PeerConnectionEvent) => void;
+  connecting: (event: ConnectingEvent) => void;
+  sending: (event: SendingEvent) => void;
+  progress: (event: IncomingEvent | OutgoingEvent) => void;
+  accepted: (event: IncomingEvent | OutgoingEvent) => void;
+  confirmed: (event: IncomingAckEvent | OutgoingAckEvent) => void;
+  ended: (event: EndEvent) => void;
+  failed: (event: EndEvent) => void;
+  newDTMF: (event: IncomingDTMFEvent | OutgoingDTMFEvent) => void;
+  newInfo: (event: IncomingInfoEvent | OutgoingInfoEvent) => void;
+  hold: (event: HoldEvent) => void;
+  unhold: (event: HoldEvent) => void;
+  muted: (event: MediaStreamTypes) => void;
+  unmuted: (event: MediaStreamTypes) => void;
+  reinvite: (event: ReInviteEvent) => void;
+  update: (event: ReInviteEvent) => void;
+  refer: (event: ReferEvent) => void;
+  replaces: (event: ReferEvent) => void;
+  sdp: (event: SDPEvent) => void;
+  icecandidate: (event: IceCandidateEvent) => void;
+  getusermediafailed: (error: unknown) => void;
+  "peerconnection:createofferfailed": (error: unknown) => void;
+  "peerconnection:createanswerfailed": (error: unknown) => void;
+  "peerconnection:setlocaldescriptionfailed": (error: unknown) => void;
+  "peerconnection:setremotedescriptionfailed": (error: unknown) => void;
+};
+
+interface RTCSession {
+  id: string;
+  direction: SessionDirection;
+  connection?: RTCPeerConnection;
+  answer(options?: AnswerOptions): void;
+  terminate(options?: TerminateOptions): void;
+  mute(options?: MediaStreamTypes): void;
+  unmute(options?: MediaStreamTypes): void;
+  hold(options?: HoldOptions, done?: VoidFunction): boolean;
+  unhold(options?: HoldOptions, done?: VoidFunction): boolean;
+  sendDTMF(tones: string | number, options?: DTFMOptions): void;
+  refer(target: string | RTCSession, options?: ReferOptions): void;
+  on<K extends keyof RTCSessionEventMap>(
+    type: K,
+    listener: RTCSessionEventMap[K]
+  ): this;
+  off<K extends keyof RTCSessionEventMap>(
+    type: K,
+    listener: RTCSessionEventMap[K]
+  ): this;
+}
+
+interface UAConfiguration {
+  sockets: unknown | unknown[];
+  uri: string;
+  password?: string;
+  [key: string]: unknown;
+}
+
+interface CallOptions extends AnswerOptions {
+  eventHandlers?: Partial<RTCSessionEventMap>;
+  anonymous?: boolean;
+  fromUserName?: string;
+  fromDisplayName?: string;
+}
+
+interface ConnectingUAEvent {
+  socket: unknown;
+  attempts: number;
+}
+
+interface ConnectedEvent {
+  socket: unknown;
+}
+
+interface DisconnectEvent {
+  socket: unknown;
+  error: boolean;
+  code?: number;
+  reason?: string;
+}
+
+interface RegisteredEvent {
+  response: IncomingResponse;
+}
+
+interface UnRegisteredEvent {
+  response: IncomingResponse;
+  cause?: string;
+}
+
+interface IncomingMessageEvent {
+  originator: Originator;
+  message: unknown;
+  request: IncomingRequest;
+}
+
+interface OutgoingMessageEvent {
+  originator: Originator;
+  message: unknown;
+  request: OutgoingRequest;
+}
+
+interface IncomingOptionsEvent {
+  originator: Originator;
+  request: IncomingRequest;
+}
+
+interface OutgoingOptionsEvent {
+  originator: Originator;
+  request: OutgoingRequest;
+}
+
+type UAEventMap = {
+  connecting: (event: ConnectingUAEvent) => void;
+  connected: (event: ConnectedEvent) => void;
+  disconnected: (event: DisconnectEvent) => void;
+  registered: (event: RegisteredEvent) => void;
+  unregistered: (event: UnRegisteredEvent) => void;
+  registrationFailed: (event: UnRegisteredEvent) => void;
+  registrationExpiring: () => void;
+  newRTCSession: (event: RTCSessionEvent) => void;
+  newMessage: (event: IncomingMessageEvent | OutgoingMessageEvent) => void;
+  sipEvent: (event: { event: unknown; request: IncomingRequest }) => void;
+  newOptions: (event: IncomingOptionsEvent | OutgoingOptionsEvent) => void;
+};
+
 type UAExtraEvents = {
-  error: {
-    cause: string;
-    code?: string;
-    raw?: any;
-    message?: string;
-  };
+  error: { cause: string; code?: string; raw?: any; message?: string };
   missed: IncomingRTCSessionEvent;
 };
 
 type UAEventName = keyof UAEventMap | keyof UAExtraEvents;
 type SessionEventName = keyof RTCSessionEventMap;
-declare const JsSIPEventName: {
-  readonly connecting: "connecting";
-  readonly connected: "connected";
-  readonly disconnected: "disconnected";
-  readonly registered: "registered";
-  readonly unregistered: "unregistered";
-  readonly registrationFailed: "registrationFailed";
-  readonly registrationExpiring: "registrationExpiring";
-  readonly newRTCSession: "newRTCSession";
-  readonly newMessage: "newMessage";
-  readonly sipEvent: "sipEvent";
-  readonly newOptions: "newOptions";
-  readonly peerconnection: "peerconnection";
-  readonly sending: "sending";
-  readonly progress: "progress";
-  readonly accepted: "accepted";
-  readonly confirmed: "confirmed";
-  readonly ended: "ended";
-  readonly failed: "failed";
-  readonly newDTMF: "newDTMF";
-  readonly newInfo: "newInfo";
-  readonly hold: "hold";
-  readonly unhold: "unhold";
-  readonly muted: "muted";
-  readonly unmuted: "unmuted";
-  readonly reinvite: "reinvite";
-  readonly update: "update";
-  readonly refer: "refer";
-  readonly replaces: "replaces";
-  readonly sdp: "sdp";
-  readonly error: "error";
-  readonly icecandidate: "icecandidate";
-  readonly getusermediafailed: "getusermediafailed";
-  readonly "peerconnection:createofferfailed": "peerconnection:createofferfailed";
-  readonly "peerconnection:createanswerfailed": "peerconnection:createanswerfailed";
+
+declare const JsSIPEventName: {
+  readonly connecting: "connecting";
+  readonly connected: "connected";
+  readonly disconnected: "disconnected";
+  readonly registered: "registered";
+  readonly unregistered: "unregistered";
+  readonly registrationFailed: "registrationFailed";
+  readonly registrationExpiring: "registrationExpiring";
+  readonly newRTCSession: "newRTCSession";
+  readonly newMessage: "newMessage";
+  readonly sipEvent: "sipEvent";
+  readonly newOptions: "newOptions";
+  readonly peerconnection: "peerconnection";
+  readonly sending: "sending";
+  readonly progress: "progress";
+  readonly accepted: "accepted";
+  readonly confirmed: "confirmed";
+  readonly ended: "ended";
+  readonly failed: "failed";
+  readonly newDTMF: "newDTMF";
+  readonly newInfo: "newInfo";
+  readonly hold: "hold";
+  readonly unhold: "unhold";
+  readonly muted: "muted";
+  readonly unmuted: "unmuted";
+  readonly reinvite: "reinvite";
+  readonly update: "update";
+  readonly refer: "refer";
+  readonly replaces: "replaces";
+  readonly sdp: "sdp";
+  readonly error: "error";
+  readonly icecandidate: "icecandidate";
+  readonly getusermediafailed: "getusermediafailed";
+  readonly "peerconnection:createofferfailed": "peerconnection:createofferfailed";
+  readonly "peerconnection:createanswerfailed": "peerconnection:createanswerfailed";
   readonly "peerconnection:setlocaldescriptionfailed": "peerconnection:setlocaldescriptionfailed";
   readonly "peerconnection:setremotedescriptionfailed": "peerconnection:setremotedescriptionfailed";
   readonly missed: "missed";
 };
 type JsSIPEventName = UAEventName | SessionEventName;
-type UAEventPayload<K extends UAEventName> =
-  K extends keyof UAEventMap
-    ? Parameters<UAEventMap[K]>[0]
-    : K extends keyof UAExtraEvents
-    ? UAExtraEvents[K]
-    : never;
+
+type UAEventPayload<K extends UAEventName> = K extends keyof UAEventMap
+  ? Parameters<UAEventMap[K]>[0]
+  : K extends keyof UAExtraEvents
+  ? UAExtraEvents[K]
+  : never;
+
 type SessionEventPayload<K extends SessionEventName> =
   K extends keyof RTCSessionEventMap ? Parameters<RTCSessionEventMap[K]>[0] : never;
-type JsSIPEventPayload<K extends JsSIPEventName> =
-  K extends UAEventName
-    ? UAEventPayload<K>
-    : K extends SessionEventName
-    ? SessionEventPayload<K>
-    : never;
+
+type JsSIPEventPayload<K extends JsSIPEventName> = K extends UAEventName
+  ? UAEventPayload<K>
+  : K extends SessionEventName
+  ? SessionEventPayload<K>
+  : never;
+
 type JsSIPEventHandler<K extends JsSIPEventName> = (
   payload?: JsSIPEventPayload<K>
 ) => void;
-type SipEventHandlers = {
-  [K in JsSIPEventName]?: JsSIPEventHandler<K>;
-};
+
+type SipEventHandlers = {
+  [K in JsSIPEventName]?: JsSIPEventHandler<K>;
+};
+
 interface SipEventManager {
   onUA: <K extends UAEventName>(
     event: K,
@@ -93,25 +395,24 @@ interface SipEventManager {
     handler: (payload?: SessionEventPayload<K>) => void
   ) => () => void;
 }
-type JsSIPEventMap = {
-  [K in JsSIPEventName]: JsSIPEventPayload<K>;
-};
-
-type DTFMOptions = DTFMOptions$1;
-
-type SipConfiguration = Omit<UAConfiguration, "password" | "uri"> & {
-  /**
-   * Enable JsSIP debug logging. If string, treated as debug pattern.
-   */
-  debug?: boolean | string;
-  /**
-   * Maximum allowed concurrent sessions. Additional sessions are rejected.
-   */
-  maxSessionCount?: number;
-  /**
-   * Milliseconds to keep enqueued outgoing media before dropping. Defaults to 30000.
-   */
-  pendingMediaTtlMs?: number;
+
+type JsSIPEventMap = {
+  [K in JsSIPEventName]: JsSIPEventPayload<K>;
+};
+
+type SipConfiguration = Omit<UAConfiguration, "password" | "uri"> & {
+  /**
+   * Enable JsSIP debug logging. If string, treated as debug pattern.
+   */
+  debug?: boolean | string;
+  /**
+   * Maximum allowed concurrent sessions. Additional sessions are rejected.
+   */
+  maxSessionCount?: number;
+  /**
+   * Milliseconds to keep enqueued outgoing media before dropping. Defaults to 30000.
+   */
+  pendingMediaTtlMs?: number;
 };
 
 type StartOpts = {
@@ -292,19 +593,19 @@ declare const SipContext: react.Context<SipContextType | null>;
 declare function useSipState(): SipState;
 
 declare function useSipActions(): {
-    call: (target: string, callOptions?: jssip_lib_UA.CallOptions | undefined) => void;
-    answer: (sessionId: string, options?: jssip_lib_RTCSession.AnswerOptions | undefined) => boolean;
-    hangup: (sessionId: string, options?: jssip_lib_RTCSession.TerminateOptions | undefined) => boolean;
+    call: (target: string, callOptions?: CallOptions | undefined) => void;
+    answer: (sessionId: string, options?: AnswerOptions | undefined) => boolean;
+    hangup: (sessionId: string, options?: TerminateOptions | undefined) => boolean;
     toggleMute: (sessionId?: string | undefined) => boolean;
     toggleHold: (sessionId?: string | undefined) => boolean;
-    sendDTMF: (sessionId: string, tones: string | number, options?: jssip_lib_RTCSession.DTFMOptions | undefined) => boolean;
-    transfer: (sessionId: string, target: string | jssip_lib_RTCSession.RTCSession, options?: jssip_lib_RTCSession.ReferOptions | undefined) => boolean;
-    attendedTransfer: (sessionId: string, otherSession: jssip_lib_RTCSession.RTCSession) => boolean;
-    getSession: (sessionId: string) => jssip_lib_RTCSession.RTCSession | null;
+    sendDTMF: (sessionId: string, tones: string | number, options?: DTFMOptions | undefined) => boolean;
+    transfer: (sessionId: string, target: string | RTCSession, options?: ReferOptions | undefined) => boolean;
+    attendedTransfer: (sessionId: string, otherSession: RTCSession) => boolean;
+    getSession: (sessionId: string) => RTCSession | null;
     getSessionIds: () => string[];
     getSessions: () => {
         id: string;
-        session: jssip_lib_RTCSession.RTCSession;
+        session: RTCSession;
     }[];
     setSessionMedia: (sessionId: string, stream: MediaStream) => void;
     switchCamera: (sessionId: string, track: MediaStreamTrack) => false | Promise<boolean>;
@@ -329,4 +630,4 @@ declare function SipProvider({ client, children, sipEventManager, }: {
     children: react__default.ReactNode;
 }): react_jsx_runtime.JSX.Element;
 
-export { CallDirection, CallDirection as CallDirectionType, CallPlayer, CallStatus, CallStatus as CallStatusType, type DTFMOptions, type JsSIPEventMap, JsSIPEventName, type SessionEventName, type SessionEventPayload, type SipConfiguration, SipContext, type SipContextType, type SipEventHandlers, type SipEventManager, SipProvider, type SipSessionState, type SipState, SipStatus, SipStatus as SipStatusType, type UAEventName, type UAEventPayload, createSipClientInstance, createSipEventManager, useSip, useSipActions, useSipEvent, useSipSessionEvent, useSipSessions, useSipState };
+export { type AnswerOptions, CallDirection, CallDirection as CallDirectionType, type CallOptions, CallPlayer, CallStatus, CallStatus as CallStatusType, type DTFMOptions, type JsSIPEventMap, JsSIPEventName, type RTCSession, type RTCSessionEvent, type RTCSessionEventMap, type ReferOptions, type SessionEventName, type SessionEventPayload, type SipConfiguration, SipContext, type SipContextType, type SipEventHandlers, type SipEventManager, SipProvider, type SipSessionState, type SipState, SipStatus, SipStatus as SipStatusType, type TerminateOptions, type UAEventMap, type UAEventName, type UAEventPayload, createSipClientInstance, createSipEventManager, useSip, useSipActions, useSipEvent, useSipSessionEvent, useSipSessions, useSipState };