workano-js-sdk/dist/lib/web-rtc-client.d.ts

Workano Communications SDK - A modern JavaScript SDK for WebRTC and VoIP integration.

import 'webrtc-adapter';
import type { InvitationRejectOptions } from 'sip.js/lib/api/invitation-reject-options';
import type { InviterCancelOptions } from 'sip.js/lib/api/inviter-cancel-options';
import type { SessionByeOptions } from 'sip.js/lib/api/session-bye-options';
import type { InvitationAcceptOptions } from 'sip.js/lib/api/invitation-accept-options';
import { UserAgentState } from 'sip.js/lib/api/user-agent-state';
import { URI } from 'sip.js/lib/grammar/uri';
import { UserAgent } from 'sip.js/lib/api/user-agent';
import { SessionDialog } from 'sip.js/lib/core/dialogs/session-dialog';
import { OutgoingByeRequest, OutgoingInviteRequest, OutgoingRequest } from 'sip.js/lib/core';
import { Inviter, Invitation, Registerer } from 'sip.js/lib/api';
import Emitter from './utils/Emitter';
import Heartbeat from './utils/Heartbeat';
import type { MediaConfig, UserAgentConfigOverrides, WebRtcConfig, UserAgentOptions, PeerConnection, WazoSession } from './domain/types';
export declare const replaceLocalIpModifier: (description: Record<string, any>) => Promise<any>;
export declare const events: string[];
export declare const transportEvents: string[];
export declare class CanceledCallError extends Error {
}
export default class WebRTCClient extends Emitter {
    clientId: number;
    config: WebRtcConfig;
    uaConfigOverrides?: UserAgentConfigOverrides;
    userAgent: UserAgent | null;
    registerer: Registerer | null;
    hasAudio: boolean;
    audio: MediaTrackConstraintSet | boolean | undefined;
    audioElements: Record<string, HTMLAudioElement>;
    video: MediaTrackConstraintSet | boolean | undefined;
    audioStreams: Record<string, any>;
    audioOutputDeviceId: string | null | undefined;
    audioOutputVolume: number;
    heldSessions: Record<string, any>;
    connectionPromise: Promise<void> | null | undefined;
    _boundOnHeartbeat: (...args: Array<any>) => any;
    heartbeat: Heartbeat;
    heartbeatTimeoutCb: ((...args: Array<any>) => any) | null | undefined;
    heartbeatCb: ((...args: Array<any>) => any) | null | undefined;
    statsIntervals: Record<string, any>;
    sipSessions: Record<string, WazoSession>;
    conferences: Record<string, boolean>;
    skipRegister: boolean;
    networkMonitoringInterval: Record<string, any>;
    sessionNetworkStats: Record<string, Record<string, any>>;
    forceClosed: boolean;
    ON_USER_AGENT: string;
    REGISTERED: string;
    UNREGISTERED: string;
    REGISTRATION_FAILED: string;
    INVITE: string;
    CONNECTED: string;
    DISCONNECTED: string;
    TRANSPORT_ERROR: string;
    MESSAGE: string;
    ACCEPTED: string;
    REJECTED: string;
    ON_TRACK: string;
    ON_REINVITE: string;
    ON_ERROR: string;
    ON_SCREEN_SHARING_REINVITE: string;
    ON_NETWORK_STATS: string;
    ON_EARLY_MEDIA: string;
    ON_PROGRESS: string;
    ON_DISCONNECTED: string;
    static isAPrivateIp(ip: string): boolean;
    static getIceServers(ip: string): Array<{
        urls: Array<string>;
    }>;
    constructor(config: WebRtcConfig, session?: WazoSession, uaConfigOverrides?: UserAgentConfigOverrides);
    configureMedia(media: MediaConfig): void;
    setMediaConstraints(media: MediaStreamConstraints): void;
    createUserAgent(uaConfigOverrides?: UserAgentConfigOverrides): UserAgent;
    isConnected(): boolean;
    isConnecting(): boolean;
    isRegistered(): boolean;
    onConnect(): Promise<void>;
    onDisconnect(error?: Error): Promise<void>;
    register(tries?: number): Promise<void>;
    _monkeyPatchRegisterer(registerer: Registerer | null | undefined): void;
    unregister(): Promise<void>;
    stop(): Promise<void>;
    call(number: string, enableVideo?: boolean, audioOnly?: boolean, conference?: boolean, options?: {}): WazoSession | null;
    answer(session: Invitation, enableVideo?: boolean): Promise<void>;
    hangup(session: WazoSession): Promise<OutgoingByeRequest | null>;
    getStats(session: WazoSession): Promise<RTCStatsReport | null>;
    startNetworkMonitoring(session: WazoSession, interval?: number): void;
    stopNetworkMonitoring(session: WazoSession): void;
    reject(session: WazoSession): Promise<void>;
    close(force?: boolean): Promise<void>;
    getNumber(session: Inviter): string | null | undefined;
    mute(session: WazoSession): void;
    unmute(session: WazoSession): void;
    isAudioMuted(session: WazoSession): boolean;
    toggleCameraOn(session: WazoSession): void;
    toggleCameraOff(session: WazoSession): void;
    hold(session: WazoSession, isConference?: boolean, hadVideo?: boolean): Promise<OutgoingInviteRequest | void>;
    unhold(session: WazoSession, isConference?: boolean): Promise<OutgoingInviteRequest | void>;
    upgradeToVideo(session: WazoSession, constraints: Record<string, any>, isConference: boolean): Promise<MediaStream | undefined>;
    downgradeToAudio(session: WazoSession): void;
    getStreamFromConstraints(constraints: Record<string, any>, conference?: boolean): Promise<MediaStream | null | undefined>;
    getHeldSession(sessionId: string): any;
    isCallHeld(session: WazoSession): boolean;
    isVideoRemotelyHeld(sessionId: string): boolean;
    sendDTMF(session: WazoSession, tone: string): boolean;
    message(destination: string, message: string): void;
    transfer(session: WazoSession, target: string): void;
    atxfer(session: WazoSession): Record<string, any>;
    sendMessage(sipSession: (WazoSession | null) | undefined, body: string, contentType?: string): void;
    pingServer(): OutgoingRequest | void;
    getState(): UserAgentState;
    getContactIdentifier(): string | null;
    isFirefox(): boolean;
    changeAudioOutputVolume(volume: number): void;
    changeAudioOutputDevice(id: string): Promise<void>;
    changeAudioInputDevice(id: string, session: WazoSession | null | undefined, force?: boolean): Promise<MediaStream | null>;
    changeVideoInputDevice(id: string, session?: WazoSession): Promise<MediaStream | void>;
    setVideoInputDevice(id: string): null | undefined;
    changeSessionVideoInputDevice(id: string | null | undefined, session: WazoSession): Promise<MediaStream | void>;
    getAudioDeviceId(): string | null | undefined;
    getVideoDeviceId(): string | null;
    reinvite(sipSession: WazoSession, newConstraints?: Record<string, any> | null | undefined, conference?: boolean, audioOnly?: boolean, iceRestart?: boolean): Promise<OutgoingInviteRequest | void>;
    getUserMedia(constraints: Record<string, any>): Promise<MediaStream>;
    getPeerConnection(sessionId: string): RTCPeerConnection | null | undefined;
    getLocalStream(sessionId: string): MediaStream | null;
    getLocalTracks(sessionId: string): MediaStreamTrack[];
    hasLocalVideo(sessionId: string): boolean;
    hasALocalVideoTrack(sessionId: string): boolean;
    getLocalVideoStream(sessionId: string): MediaStream | null | undefined;
    getRemoteStream(sessionId: string): MediaStream | null;
    getRemoteTracks(sessionId: string): MediaStreamTrack[];
    hasRemoteVideo(sessionId: string): boolean;
    hasARemoteVideoTrack(sessionId: string): boolean;
    getRemoteVideoStream(sessionId: string): MediaStream | null | undefined;
    getRemoteVideoStreamFromPc(sessionId: string): MediaStream | null | undefined;
    hasVideo(sessionId: string): boolean;
    hasAVideoTrack(sessionId: string): boolean;
    getSipSessionId(sipSession: WazoSession | null | undefined): string;
    waitForRegister(): Promise<void>;
    sessionWantsToDoVideo(session: WazoSession): boolean;
    hasHeartbeat(): boolean;
    startHeartbeat(): void;
    stopHeartbeat(): void;
    setOnHeartbeatTimeout(cb: (...args: Array<any>) => any): void;
    setOnHeartbeatCallback(cb: (...args: Array<any>) => any): void;
    onCallEnded(session: WazoSession): void;
    attemptReconnection(): void;
    storeSipSession(session: WazoSession): void;
    getSipSession(id: string): WazoSession | null | undefined;
    getSipSessionIds(): string[];
    setLocalMediaStream(sipSessionId: string, newStream: MediaStream): void;
    updateLocalStream(sipSessionId: string, newStream: MediaStream): Promise<void>;
    updateRemoteStream(sessionId: string, allTracks?: boolean): void;
    getMediaConfiguration(enableVideo: boolean, conference?: boolean, constraints?: Record<string, any> | null | undefined): Record<string, any>;
    isConference(sessionId: string): boolean;
    createAudioElementFor(sessionId: string): Promise<HTMLAudioElement>;
    _onTransportError(): void;
    enableLogger(logConnector: (level: any, className: string, label: any, content: string) => void): void;
    _onHeartbeat(message: string | Record<string, any>): void;
    _onHeartbeatTimeout(): Promise<void>;
    _isWeb(): boolean;
    _isVideoTrack(track: MediaStreamTrack): boolean;
    _hasAudio(): boolean;
    _getAudioConstraints(): MediaTrackConstraints | boolean;
    _getVideoConstraints(video?: boolean): MediaTrackConstraints | boolean;
    _connectIfNeeded(): Promise<any>;
    _buildConfig(config: WebRtcConfig, session: WazoSession | null | undefined): Promise<WebRtcConfig>;
    _createUaOptions(uaOptionsOverrides?: UserAgentConfigOverrides): UserAgentOptions;
    _getRtcOptions(): {
        mandatory: {
            OfferToReceiveAudio: boolean;
            OfferToReceiveVideo: boolean;
        };
    };
    _setupSession(session: WazoSession): void;
    _onProgress(session: WazoSession, early?: boolean): Promise<void>;
    _onAccepted(session: WazoSession, sessionDialog?: SessionDialog, withEvent?: boolean, initAllTracks?: boolean): Promise<void>;
    _isAudioOnly(session: WazoSession): boolean;
    _setupMedias(session: WazoSession, newStream?: MediaStream | null | undefined): Promise<void>;
    _cleanupMedia(session?: WazoSession): void;
    _cleanupStream(stream: MediaStream): void;
    _toggleAudio(session: WazoSession, muteAudio: boolean): void;
    _toggleVideo(session: WazoSession, muteCamera: boolean): void;
    /**
     * @param pc RTCPeerConnection
     */
    _getRemoteStream(pc: PeerConnection): MediaStream | null;
    _cleanupRegister(): void;
    _startSendingStats(session: WazoSession): void;
    _stopSendingStats(session: WazoSession): void;
    _makeURI(target: string): URI | undefined;
    _disconnectTransport(force?: boolean): Promise<void>;
    _fetchNetworkStats(sessionId: string): Promise<Record<string, any> | null | undefined>;
    _accept(session: Invitation, options?: InvitationAcceptOptions): Promise<void>;
    _reject(session: Invitation, options?: InvitationRejectOptions): Promise<void>;
    _cancel(session: Inviter, options?: InviterCancelOptions): Promise<void>;
    _bye(session: WazoSession, options?: SessionByeOptions): Promise<OutgoingByeRequest | null>;
}
//# sourceMappingURL=web-rtc-client.d.ts.map