@telnyx/webrtc/lib/src/Modules/Verto/webrtc/BaseCall.d.ts

Telnyx WebRTC Client

import BrowserSession from '../BrowserSession';
import { type ICallReportFlushReason } from './CallReportCollector';
import Call from './Call';
import Peer from './Peer';
import { Direction, State } from './constants';
import { AnswerParams, IHangupParams, IVertoCallOptions, IWebRTCCall } from './interfaces';
export default abstract class BaseCall implements IWebRTCCall {
    protected session: BrowserSession;
    private _webRTCStats;
    private _callReportCollector;
    private _callRecorder;
    private _mediaDeviceCollector;
    id: string;
    recoveredCallId: string;
    state: string;
    prevState: string;
    direction: Direction;
    peer: Peer;
    options: IVertoCallOptions;
    cause: string;
    causeCode: number;
    sipReason: string;
    sipCode: number;
    sipCallId: string;
    channels: string[];
    role: string;
    extension: string;
    get creatingPeer(): boolean;
    get signalingStateClosed(): boolean;
    private _state;
    private _prevState;
    private gotAnswer;
    private gotEarly;
    private _lastSerno;
    private _targetNodeId;
    private _iceTimeout;
    private _ringtone;
    private _ringback;
    private _statsBindings;
    private _statsIntervalId;
    private _pendingIceCandidates;
    private _isRemoteDescriptionSet;
    private _signalingStateClosed;
    private _creatingPeer;
    private _desiredAudioMuted;
    private _firstCandidateSent;
    private _firstNonHostCandidateSent;
    private _isRecovering;
    private _captureHangupCallerStack;
    constructor(session: BrowserSession, opts?: IVertoCallOptions);
    get nodeId(): string;
    set nodeId(what: string);
    get isVideoCall(): boolean;
    get telnyxIDs(): {
        telnyxCallControlId: string;
        telnyxSessionId: string;
        telnyxLegId: string;
    };
    get localStream(): MediaStream;
    get remoteStream(): MediaStream;
    get memberChannel(): string;
    get isAudioMuted(): boolean;
    private _getLocalAudioTrackId;
    private _hasActiveUnmutedLocalAudioTrack;
    shouldForceRelayCandidateForRecovery(): boolean;
    invite(): Promise<void>;
    answer(params?: AnswerParams): Promise<void>;
    playRingtone(): void;
    stopRingtone(): void;
    playRingback(): void;
    stopRingback(): void;
    hangup(): Promise<void>;
    hangup(hangupParams: IHangupParams, hangupExecute: boolean): Promise<void>;
    hold(): Promise<any>;
    unhold(): Promise<any>;
    toggleHold(): Promise<any>;
    dtmf(dtmf: string): void;
    message(to: string, body: string): void;
    muteAudio(): void;
    unmuteAudio(): void;
    _applyDesiredAudioMuteState(): void;
    toggleAudioMute(): void;
    setAudioInDevice(deviceId: string, muted?: boolean): Promise<void>;
    muteVideo(): void;
    unmuteVideo(): void;
    toggleVideoMute(): void;
    setVideoDevice(deviceId: string): Promise<void>;
    deaf(): void;
    undeaf(): void;
    toggleDeaf(): void;
    setBandwidthEncodingsMaxBps(max: number, _kind: string): Promise<void>;
    setAudioBandwidthEncodingsMaxBps(max: number): void;
    setVideoBandwidthEncodingsMaxBps(max: number): void;
    private _isTerminatingOrTerminated;
    getStats(callback: Function, constraints: any): void;
    setState(state: State): void;
    handleMessage(msg: any): void;
    handleConferenceUpdate(packet: any, initialPvtData: any): Promise<string>;
    _addChannel(channel: string): void;
    private _subscribeConferenceChat;
    private _subscribeConferenceInfo;
    private _confControl;
    private _handleChangeHoldStateSuccess;
    private _handleChangeHoldStateError;
    private _sendIceRestartModify;
    private _onIceRestartFailed;
    private _onRemoteSdp;
    private _requestAnotherLocalDescription;
    private _onIceSdp;
    private _onTrickleIceSdp;
    private _onIce;
    private _onTrickleIce;
    private _sendIceCandidate;
    private _addIceCandidate;
    private _addIceCandidateToPeer;
    private _sendEndOfCandidates;
    private _trackCandidateMarks;
    private _resetTrickleIceCandidateState;
    private _flushPendingTrickleIceCandidates;
    private _registerPeerEvents;
    private _checkConferenceSerno;
    private _onMediaError;
    private _onPeerConnectionFailureError;
    private _onPeerConnectionSignalingStateClosed;
    private _dispatchConferenceUpdate;
    private _dispatchNotification;
    private _execute;
    private _registerInboundAnswerAttempt;
    private _init;
    protected _finalize(): void;
    private _getCallReportVoiceSdkId;
    private _getClientSummary;
    private _getAuthenticationType;
    private _sanitizeIceServers;
    private _sanitizeClientOption;
    private _isSensitiveClientOptionKey;
    flushIntermediateCallReport(flushReason?: ICallReportFlushReason): void;
    private _flushIntermediateReport;
    private _postCallReport;
    private _startStats;
    private _stopStats;
    private _doStats;
    static setStateTelnyx: (call: Call) => Call;
}