@ale-rainbow/web-sdk 5.1.0

package/lib/models/call.model.d.ts

@@ -0,0 +1,1271 @@
+/**
+ * @module Calls
+ */
+import type { Subscription } from "rxjs";
+import { RBEvent } from "./event.model";
+import type { Conversation } from "./conversation.model";
+import { ContextMap } from "./common";
+import type { User } from "./user.model";
+import type { Contact } from "./contact.model";
+/**
+ * Call events send to other services
+ * Can listen to it via `Call.subscribe()` API.
+ */
+export declare enum CallEvents {
+    /**
+     * @eventProperty
+     * This `RBEvent` is sent when the call capabilities have been updated.<br>
+     * The new call capabilities can be retrieved via the 'capabilities' property.
+     */
+    ON_CALL_CAPABILITIES_UPDATED = "ON_CALL_CAPABILITIES_UPDATED",
+    /**
+     * @eventProperty
+     * This `RBEvent` is sent when the status of the call (from a telephone point of view) has changed.<br>
+     * The new call status can be retrieved via the 'callStatus' property.
+     */
+    ON_CALL_STATUS_CHANGE = "ON_CALL_STATUS_CHANGE",
+    /**
+     * @eventProperty
+     * This `RBEvent` is sent when the status of the mute of the call (On or Off) has changed.<br>
+     * The new mute status can be retrieved via the 'isMuted' property.
+     */
+    ON_CALL_MUTE_CHANGE = "ON_CALL_MUTE_CHANGE",
+    /**
+     * @eventProperty
+     * This `RBEvent` is sent when during a call, the network quality has changed.
+     *
+     * **Event Data**
+     * - **data**: The current network quality for the call
+     */
+    ON_CALL_NETWORK_QUALITY_CHANGE = "ON_CALL_NETWORK_QUALITY_CHANGE",
+    /**
+     * @internal
+     * @eventProperty
+     * This `RBEvent` is sent when a bad network quality has been detected.<br>
+     * The detection is currently done by Web Client component, based on internal WebClient criteria for UI purpose.
+     *
+     * **Event Data**
+     * - **data**: The current network quality for the call
+     */
+    ON_CALL_NETWORK_BAD_QUALITY = "ON_CALL_NETWORK_BAD_QUALITY",
+    /**
+     * @eventProperty
+     * This `RBEvent` is sent when there have been changes in the media used by the local or the remote user.<br>
+     * By change we mean the addition or removal of a media (Video/Sharing) for the current call.
+     */
+    ON_CALL_MEDIA_UPDATED = "ON_CALL_MEDIA_UPDATED",
+    /**
+     * @eventProperty
+     * This `RBEvent` is sent when when the call has evolved and as a result some of its properties, such as its status, have been updated.
+     */
+    ON_CALL_UPDATED_EVENT = "ON_CALL_UPDATED_EVENT",
+    /**
+    * @eventProperty
+    * This `RBEvent` is sent when the distant party has started / stopped the recording of the call; Only available for direct P2P calls with Rainbow user
+    */
+    ON_CALL_REMOTE_RECORDING_UPDATE = "ON_CALL_REMOTE_RECORDING_UPDATE",
+    /**
+     * @eventProperty
+     * This `RBEvent` is sent when the call recorder state change
+     * **Event Data**
+     * - **callRecorderState**: The new CallRecorderState of the call
+     */
+    ON_CALL_RECORDING_UPDATE = "ON_CALL_RECORDING_UPDATE"
+}
+/**
+ * Media type available in a P2P call.<br>
+ * Media can be combined within the same call, e.g. for a video call, both audio and video media will be used.
+ */
+export declare enum MediaType {
+    /**
+     * Audio
+     */
+    AUDIO = "audio",
+    /**
+     * Video
+     */
+    VIDEO = "video",
+    /**
+     * Screen Sharing
+     */
+    SHARING = "sharing"
+}
+/**
+ * Type of call managed for a P2P communication.
+ */
+export declare enum CallType {
+    /**
+     * Webrtc call
+     */
+    WEBRTC = 1,
+    /**
+     * Phone call
+     */
+    PHONE = 2
+}
+/**
+ * The possible status of the call (e.g. dialing, active, releasing...)
+ */
+export declare enum CallStatus {
+    /**
+     * Active call
+     */
+    ACTIVE = "ACTIVE",
+    /**
+     * Call Cleared
+     */
+    ENDED = "ENDED",
+    /**
+     * In dialing
+     */
+    DIALING = "DIALING",
+    /**
+     * In queue (user side)
+     */
+    QUEUED_INCOMMING = "QUEUED_INCOMMING",
+    /**
+     * In queue (recipient side)
+     */
+    QUEUED_OUTGOING = "QUEUED_OUTGOING",
+    /**
+     * Call in ringing (user side)
+     */
+    RINGING_INCOMMING = "RINGING_INCOMMING",
+    /**
+     * Call in ringing (recipient side)
+     */
+    RINGING_OUTGOING = "RINGING_OUTGOING",
+    /**
+     * Call on hold by local party
+     */
+    HOLD = "HOLD",
+    /**
+     * Call put on hold by the distant party
+     */
+    PUT_ON_HOLD = "PUT_ON_HOLD",
+    /**
+     * Call is clearing
+     */
+    RELEASING = "RELEASING",
+    /**
+     * Call is being answered
+     */
+    ANSWERING = "ANSWERING",
+    /**
+     * Trying to connect / reconnect the call
+     */
+    CONNECTING = "CONNECTING",
+    /**
+     * Call error
+     */
+    ERROR = "ERROR"
+}
+/**
+ * Call direction
+ */
+export declare enum CallDirection {
+    /**
+     * Default initial value.
+     */
+    UNDEFINED = "",
+    /**
+     * Incoming call.<br>
+     * Call in which the connected user is the call recipient.
+     */
+    INCOMING = "incoming",
+    /**
+     * Outgoing call.<br>
+     * Call in which the connected user initiates the call.
+     */
+    OUTGOING = "outgoing"
+}
+/**
+ * Call Redirection cause
+ */
+export declare enum CallRedirectionCause {
+    /**
+     * Default initial value.
+     */
+    UNDEFINED = "",
+    /**
+     * The call has been forwarded.
+     */
+    FORWARDED = "forwarded",
+    /**
+     * The call is a group call : it is redirected by the group number to the group member.
+     */
+    HUNTGROUP = "hg"
+}
+/**
+ * @internal
+ * Media used by the local or the remote party of a WebRTC or PBX call
+ */
+export declare const CallMedia: {
+    /**
+     * No media
+     */
+    readonly NONE: 0;
+    /**
+     * WebRTC audio call
+     */
+    readonly AUDIO: 1;
+    /**
+     * WebRTC audio and video call
+     */
+    readonly VIDEO: 2;
+    /**
+     * Telephony call (PBX) call
+     */
+    readonly PHONE: 4;
+    /**
+     * Screen Sharing
+     */
+    readonly SHARING: 8;
+};
+/**
+ * For a call, indicates for each managed media whether it is in use or not.
+ */
+export interface CallMedias {
+    /**
+     * Indicates if the audio stream is used in the call.
+     */
+    audio?: boolean;
+    /**
+     * Indicates if the video stream is used in the call.<br>
+     * This stream is active for example when using a camera.
+     */
+    video?: boolean;
+    /**
+     * Indicates if the sharing stream is used in the call.<br>
+     * This stream is used for example when sharing a browser tab, a window or the entire screen.
+     */
+    sharing?: boolean;
+}
+/**
+ * Data associated with the destination of a call.
+ */
+export interface CallDestination {
+    /**
+     * Peer object related to the Call destination.<br>
+     * If the call destination is a Rainbow user, the object is an instance of User.
+     */
+    user?: User;
+    /**
+     * Phone number to be used for the call destination.<br>
+     * This can be a telephone number associated with the Rainbow user profile.<br>
+     * Or in the case of an external destination, a public PSTN number.
+     */
+    phoneNumber?: string;
+    /**
+     * Phone number country.<br>
+     * This information is only relevant if the destination is external.<br>
+     * If not indicated, the caller's country is taken into account.
+     */
+    country?: string;
+}
+/**
+ * Data associated with the initial called party
+ */
+export interface CalledParty {
+    /**
+     * Pbx call's initial called number
+     * @readonly
+     */
+    phoneNumber: string;
+    /**
+     * Pbx call's initial called display name
+     * @readonly
+     */
+    displayName: string;
+    /**
+     * Pbx call's initial called lastname
+     * @readonly
+     */
+    lastName: string;
+    /**
+     * Pbx call's initial called firstname
+     * @readonly
+     */
+    firstName: string;
+    /**
+     * Pbx call's initial called Jabber identifier
+     * @readonly
+     */
+    jid: string;
+    /**
+     * Pbx call's initial called role : "called" for forwarded calls / "called_group" for group calls
+     * @readonly
+     */
+    role: string;
+}
+/**
+ * Call capabilities representing all the actions that could be done for the call given the state
+ */
+export interface CallCapabilities {
+    /**
+     * Indicates if the incoming call can be answered.
+     * @readonly
+     */
+    answer: boolean;
+    /**
+     * Indicates if the call can be released / ended / declined.
+     * @readonly
+     */
+    release: boolean;
+    /**
+     * Indicates if we can deflect the incoming call to the VoiceMail.<br>
+     * Only available for HYBRID systems (for Cloud telephony, the release action will follow the system/user configuration)
+     * @readonly
+     */
+    deflectToVoicemail: boolean;
+    /**
+     * Indicates if we can deflect the incoming call to a phone number.<br>
+     * The possible destinations numbers for call deflection are available in the 'deflectPhoneNumberDestinations' data.
+     * @readonly
+     */
+    deflectToPhoneNumber: boolean;
+    /**
+     * The list of phone numbers where we can deflect the call
+     * @readonly
+     */
+    deflectPhoneNumberDestinations: [{
+        id: string;
+        number: string;
+    }?];
+    /**
+     * Indicates if we can mute the call
+     * @readonly
+     */
+    mute: boolean;
+    /**
+     * Indicates if we can unmute the call
+     * @readonly
+     */
+    unmute: boolean;
+    /**
+     * Indicates if we can add the audio media to the call.<br>
+     * This could happen if there's no audio, for example in case of sharing only call.
+     * @readonly
+     */
+    addAudio: boolean;
+    /**
+     * Indicates if we can add the video media to the call.
+     * @readonly
+     */
+    addVideo: boolean;
+    /**
+     * Indicates if we can remove the video media from the call.
+     * @readonly
+     */
+    removeVideo: boolean;
+    /**
+     * Indicates if we can add the sharing media to the call.
+     * @readonly
+     */
+    addSharing: boolean;
+    /**
+     * Indicates if we can remove the sharing media from the call.
+     * @readonly
+     */
+    removeSharing: boolean;
+    /**
+     * Indicates if we can make a blind transfer of this call (transfer it to some other contact without having a call with them beforehand).<br>
+     * This will remove the current call, and the other party will be transferred to the other contact / number.
+     * @readonly
+     */
+    blindTransfer: boolean;
+    /**
+     * Indicates if we can make a conference call from the current call and one other call in progress for the current user (can be used to merge the 2 calls).<br>
+     * This will remove the 2 calls and create one single call (for hybride systems) or web conference.
+     * @readonly
+     */
+    mergeCalls: boolean;
+    /**
+     * Indicates if we can make a conference call from the current call by adding any other contact or number (that we dont have currently call with).<br>
+     * This will remove the current call and create a web conference call instead.
+     * @readonly
+     */
+    addParticipantsToCall: boolean;
+    /**
+     * Indicates if we can put the call on hold.
+     * @readonly
+     */
+    hold: boolean;
+    /**
+     * Indicates if we can retrieve the call (if it is on hold).
+     * @readonly
+     */
+    retrieve: boolean;
+    /**
+     * Indicates if we can send dtmf for the call.
+     * @readonly
+     */
+    dtmf: boolean;
+    /**
+     * Indicates if we can transfer the current call to the other call.<br>
+     * If the call is on HOLD, then the tranfer is always made towards the ACTIVE call.<br>
+     * Otherwise, we can transfer this call to any other call from the transferCallDestinations list.
+     * @readonly
+     */
+    transferToOtherCall: boolean;
+    /**
+     * The list of calls where we can transfer this call;
+     * @readonly
+     */
+    transferCallDestinations: Call[];
+    /**
+    * Indicates whether recording can be started for this call
+    */
+    startRecording: boolean;
+    /**
+    * Indicates whether recording can be stopped for this call
+    */
+    stopRecording: boolean;
+    /**
+    * Indicates whether recording can be paused for this call
+    */
+    pauseRecording: boolean;
+    /**
+    * Indicates whether recording can be resumed for this call
+    */
+    resumeRecording: boolean;
+    /**
+     * Indicates whether recording can be cancelled for this call
+    */
+    cancelRecording: boolean;
+}
+export interface Call {
+    /**
+     * Capabilities of the call
+     * @readonly
+     */
+    capabilities: CallCapabilities;
+    /**
+     * Call telephone status
+     * @readonly
+     */
+    callStatus: CallStatus;
+    /**
+     * The type of the call (WebRTC or Telephony)
+     * @readonly
+     */
+    callType: CallType;
+    /**
+     * On an incoming call, contains the subject of the call if this has been specified by the caller
+     * @readonly
+     */
+    subject: string;
+    /**
+     * The user reference representing the other party (as caller or callee) engaged in this call
+     * @readonly
+     */
+    contact: User;
+    /**
+     * Call duration in seconds
+     * @readonly
+     */
+    duration: number;
+    /**
+     * Call direction
+     * This information is relevant only for telephone (PBX) call. For WebRTC call it is undefined.
+     */
+    direction: CallDirection;
+    /**
+     * The media stream used by the local user.
+     * Typed as number BUT MUST follow the values defined by 'CallMedia' type or a combination thereof.
+     * @readonly
+     */
+    localMedias: CallMedias;
+    /**
+     * The media stream used by the remote user/party.
+     * Typed as number BUT MUST follow the values defined by 'CallMedia' type or a combination thereof.
+     * @readonly
+     */
+    remoteMedias: CallMedias;
+    /**
+     * The current mute status of the call
+     * @readonly
+     */
+    isMuted: boolean;
+    /**
+     * The current network quality (0 - bad, 1 - medium, 2 - good) for the call
+     * @readonly
+     */
+    networkQuality: number;
+    /**
+     * The original unprocessed video stream from the camera.
+     * This stream contains the raw video before any processing is applied, such as virtual background effects or filters.
+     * It is used as a reference when video effects need to be applied or removed during the call.
+     * @internal
+     */
+    originalStream: MediaStream | null;
+    /**
+     * Strongly-typed heterogeneous map for attaching UI or app-layer state to the call
+     * without polluting the SDK model with presentation concerns.
+     * Keys must be created via `makeContext<T>()` in the consumer layer.
+     * @internal
+     */
+    context: ContextMap;
+    /**
+     * Subscribe to updates on the current call (all events are of RBEvent<CallEvents>
+     * @param callback - The callback function that will be called when events are received
+     * @param eventNames - (optional) array of event to listen
+     * @returns Returns RxJS Subscription
+     */
+    subscribe: (callback: (event: RBEvent<CallEvents>) => any, eventNames?: CallEvents | CallEvents[]) => Subscription;
+    /**
+     * Answer the current incoming call.<br>
+     * This feature can be used only if the "answer" call capability is 'True'.<br>
+     * By default, the answer is done with AUDIO only.<br>
+     * If the 'withVideo' option is set to 'True' and the incoming call contains video, the answer will directly be done with audio and video.
+     * @param withVideo - Option to answer the call directly with audio and video. Default value is 'False'
+     */
+    answer: (withVideo?: boolean) => Promise<void>;
+    /**
+     * Release the current call.<br>
+     * This method allows to decline an incoming call or stop an outgoing call.<br>
+     * This feature can be used only if the "release" call capability is 'True'.
+     */
+    release: () => Promise<void>;
+    /**
+     * Put on hold the current call.<br>
+     * This feature can be used only if the "hold" call capability is 'True'.
+     */
+    hold: () => Promise<void>;
+    /**
+     * Retrieve from hold the current call.<br>
+     * This feature can be used only if the "retrieve" call capability is 'True'.
+     */
+    retrieve: () => Promise<void>;
+    /**
+     * Mute the current call.<br>
+     * This feature can be used only if the "mute" call capability is 'True'.
+     */
+    mute: () => void;
+    /**
+     * Unmute the current call.<br>
+     * This feature can be used only if the "unmute" call capability is 'True'.
+     */
+    unmute: () => void;
+    /**
+     * Send DTMF signal to the current call.<br>
+     * This feature can be used only if the "dtmf" call capability is 'True'.
+     * @param dialKey - The DTMF character sequences to be send
+     * Only the following characters are authorised: the ten single digits (0..9), the letters (a,b,c,d), the asterisk (*) and the pound sign (#).
+     */
+    sendDTMF: (dialKey: string) => void;
+    /**
+     * Add the AUDIO media to the current call.<br>
+     * This feature can be used only if the "addAudio" call capability is 'True' and available only for WebRTC Calls.
+     */
+    addAudio: () => Promise<void>;
+    /**
+     * Add the VIDEO media to the current call.<br>
+     * This feature can be used only if the "addVideo" call capability is 'True' and available only for WebRTC Calls.
+     */
+    addVideo: () => Promise<void>;
+    /**
+     * Add the SHARING media to the current call.<br>
+     * This feature can be used only if the "addSharing" call capability is 'True' and available only for WebRTC Calls.
+     */
+    addSharing: () => Promise<void>;
+    /**
+     * Remove the VIDEO media from the current call.<br>
+     * This feature can be used only if the "removeVideo" call capability is 'True' and available only for WebRTC Calls.
+     */
+    removeVideo: () => Promise<void>;
+    /**
+     * Remove the SHARING media from the current call.<br>
+     * This feature can be used only if the "removeSharing" call capability is 'True' and available only for WebRTC Calls.
+     */
+    removeSharing: () => Promise<void>;
+    /**
+     * Add participants to the current call.<br>
+     * This feature can be used only if the "addParticipantsToCall" call capability is 'True'.<br>
+     * The participants could be other Rainbow users or phone numbers (if the PBX system supports it).<br>
+     * This will result in a new conversation being created with web conference inside. The active call will be "transferred" to the bubble conference;
+     * @param participants - The list of participants to be added to the call
+     * @returns The new bubble conversation where the web conference is active
+     */
+    addParticipantsToCall: (participants: CallDestination[]) => Promise<Conversation>;
+    /**
+     * Create a conference from 2 calls, including the current call.
+     * This will lead to the creation of either a web conference (managed via a Rainbow bubble) or a pure telephone conference (managed by a PBX system).
+     * In the first case, a new conversation is created with the web conference inside. The two calls will be "transferred" to the bubble conference.
+     * In the second case, a new 'conference' type conversation is created. This applies only with a Rainbow Hybrid (OXO or OXE) telephone system.
+     * This feature can be used only if the "mergeCalls" call capability is 'True'.
+     * @returns The new conversation or null depending on the type of conference created
+     */
+    activateConference: () => Promise<Conversation | undefined>;
+    /**
+     * Blind transfer the current call another destination which could be any rainbow user or phone number.<br>
+     * A blind transfer is when you transfer a call directly to another party without consulting with the person receiving the call.<br>
+     * In other words, there is no need to call the other party to make the transfer.<br>
+     * This feature is available only if the connected user is behind a Rainbow Hub telephone system.
+     * @param destination - The destination of the blind transfer
+     */
+    blindTransfer: (destination: CallDestination) => Promise<void>;
+    /**
+     * Deflect the current incoming call to the voice mail.<br>
+     * This feature can be used only if the "deflectToVoicemail" call capability is 'True'.<br>
+     * The 'deflect to voice mail' is only available on HYBRID telephony systems.<br>
+     * For Cloud telephony systems, the release call will follow the user configuration (which could be deflect or other).
+     */
+    deflectToVoicemail: () => Promise<void>;
+    /**
+     * Deflect (redirect) the current incoming call to the specified phone number.<br>
+     * This feature can be used only if the "deflectToPhoneNumber" call capability  is 'True'.<br>
+     * The list of phone numbers where we can deflect the incoming call is available in the 'deflectPhoneNumberDestinations' call capability.
+     * @param number - The phone number the call will be deflected to.
+     */
+    deflectToPhoneNumber: (number: string) => Promise<void>;
+    /**
+     * Transfer the current call to another call.<br>
+     * If the destination call is not specified, then the transfer will be done towards the current active call.<br>
+     * The list of destination calls to which we can deflect the call current is available in the 'transferCallDestinations' call capability.
+     * @param destinationCall - The destination call to which we want to transfer the current call.
+     */
+    transferToOtherCall: (destinationCall?: Call) => Promise<void>;
+    /**
+     * Attach the local video stream to a given HTML VIDEO tag element;
+     * @param HtmlElementId - The ID of the HTML VIDEO tag element visible on the page
+     */
+    attachLocalVideoStream: (HtmlElementId: string) => void;
+    /**
+     * Attach the local sharing stream to a given HTML VIDEO tag element;
+     * @param HtmlElementId - The ID of the HTML VIDEO tag element visible on the page
+     */
+    attachLocalSharingStream: (HtmlElementId: string) => void;
+    /**
+     * Attach the remote video stream to a given HTML VIDEO tag element;
+     * @param HtmlElementId - The ID of the HTML VIDEO tag element visible on the page
+     */
+    attachRemoteVideoStream: (HtmlElementId: string) => void;
+    /**
+     * Attach the remote sharing stream to a given HTML VIDEO tag element;
+     * @param HtmlElementId - The ID of the HTML VIDEO tag element visible on the page
+     */
+    attachRemoteSharingStream: (HtmlElementId: string) => void;
+    /**
+    * @internal
+    */
+    toJSON: () => any;
+    /**
+     * This API allows the user to start the recording of the current call.
+     */
+    startRecording: () => Promise<void>;
+    /**
+     * This API allows the user to stop the recording of the current call.
+     */
+    stopRecording: () => Promise<void>;
+    /**
+     * This API allows the user to pause the recording of the current call.
+     */
+    pauseRecording: () => void;
+    /**
+     * This API allows the user to resume the recording of the current call.
+     */
+    resumeRecording: () => void;
+    /**
+     * This API allows the user to get the duration of the current call recording.
+     */
+    getRecordingDuration: () => number;
+    /**
+     * This API allows the user to cancel the recording of the current call, without downloading the recording file.
+     */
+    cancelRecording: () => void;
+}
+/**
+ * This CallRecordingState enum lists all the states a record can be in.
+*/
+export declare enum CallRecordingState {
+    /**
+     * This 'RECORDING_IN_PROGRESS' state means that the recording is in progress.
+    */
+    RECORDING_IN_PROGRESS = "RECORDING_IN_PROGRESS",
+    /**
+     * This 'RECORDING_PAUSED' state means that the recording is on pause.
+    */
+    RECORDING_PAUSED = "RECORDING_PAUSED",
+    /**
+     * This 'RECORDING_STOPPED' state means that the recording is stopped.
+    */
+    RECORDING_STOPPED = "RECORDING_STOPPED"
+}
+/**
+ * @internal
+ * This class represents a call. <br>
+ * A call is a "short" interaction between the user and one or several contacts (Rainbow users or not) that uses either a WebRTC media (audio, video or screen sharing) or a Telephony media (PBX phone). <br>
+ * No Rainbow users such as external users can only be engaged into a Telephony call. <br>
+ * A call is always attached to a conversation.
+ */
+export declare class CallRB implements Call {
+    /**
+     * @deprecated OBSOLETE, TO BE REMOVED WHEN DESKTOP REMOVES CODE
+     */
+    static Status: {
+        UNKNOWN: {
+            key: number;
+            value: string;
+        };
+        DIALING: {
+            key: number;
+            value: string;
+        };
+        QUEUED_INCOMMING: {
+            key: number;
+            value: string;
+        };
+        QUEUED_OUTGOING: {
+            key: number;
+            value: string;
+        };
+        RINGING_INCOMMING: {
+            key: number;
+            value: string;
+        };
+        RINGING_OUTGOING: {
+            key: number;
+            value: string;
+        };
+        ACTIVE: {
+            key: number;
+            value: string;
+        };
+        HOLD: {
+            key: number;
+            value: string;
+        };
+        PUT_ON_HOLD: {
+            key: number;
+            value: string;
+        };
+        RELEASING: {
+            key: number;
+            value: string;
+        };
+        ANSWERING: {
+            key: number;
+            value: string;
+        };
+        CONNECTING: {
+            key: number;
+            value: string;
+        };
+        ERROR: {
+            key: number;
+            value: string;
+        };
+        ENDED: {
+            key: number;
+            value: string;
+        };
+    };
+    /**
+     * NOT TO BE USED ANYMORE !!!! Use callStatus instead !
+     * @deprecated -- Use {@link callStatus} instead !
+     */
+    status: any;
+    /**
+     * @deprecated OBSOLETE, TO BE REMOVED WHEN DESKTOP REMOVES CODE
+     */
+    static Type: {
+        /** WebRTC call */
+        WEBRTC: {
+            key: number;
+            value: string;
+        };
+        /** Telephony call (from PBX) */
+        PHONE: {
+            key: number;
+            value: string;
+        };
+    };
+    /**
+     * @deprecated OBSOLETE, TO BE REMOVED WHEN DESKTOP REMOVES CODE
+     */
+    static Media: {
+        /** WebRTC audio call */
+        AUDIO: number;
+        /** WebRTC audio and video call */
+        VIDEO: number;
+        /** Telephony call (from pbx) */
+        PHONE: number;
+        /** WebRTC Screen sharing call */
+        SHARING: number;
+    };
+    /**
+     * @deprecated OBSOLETE, TO BE REMOVED WHEN DESKTOP REMOVES CODE
+     */
+    get type(): {
+        key: number;
+        value: string;
+    };
+    private conversationService;
+    private callService;
+    private callRecorderService?;
+    private rxSubject;
+    private durationTimer;
+    readonly context: ContextMap;
+    id: string;
+    conversationId: string;
+    connectionId: string;
+    onHold: boolean;
+    putOnHold: boolean;
+    networkQualityIteration: number;
+    isInExternalWindow: boolean;
+    externalWindowRef: any;
+    customCommandsRequested: any;
+    thirdPartyInfos: string;
+    private _contact?;
+    private _status;
+    private _muted;
+    private _capabilities;
+    /**
+     * The type of the call (WebRTC or Telephony)
+     */
+    callType: CallType;
+    /**
+     * Call duration in seconds
+     */
+    duration: number;
+    /**
+     * Call direction
+     * This information is relevant only for telephone (PBX) call. For WebRTC call it is undefined.
+     */
+    direction: CallDirection;
+    /**
+     * Media stream associated to the local party.
+     * Typed as number BUT MUST follow the values defined by CallMedia type or a combination thereof.
+     */
+    localMedia: number;
+    /**
+     * Media stream associated to the remote party.
+     * Typed as number BUT MUST follow the values defined by CallMedia type or a combination thereof.
+     */
+    remoteMedia: number;
+    /**
+     * NetworkQuality Value (0 - bad, 1 - medium, 2 - good) representing the current network quality for the call
+     * @readonly
+     */
+    networkQuality: number;
+    /**
+     * On an incoming call, contains the subject of the call if this has been specified by the caller (inside purpose)
+     * @readonly
+     */
+    subject: string;
+    get localMedias(): CallMedias;
+    get remoteMedias(): CallMedias;
+    recorder: {
+        state: CallRecordingState;
+        getDuration: () => number;
+    };
+    isEscalated: boolean;
+    isError: boolean;
+    unifiedPlanActivated: boolean;
+    startDate: Date;
+    isInitiator: boolean;
+    correlatorData: string;
+    correlatorDataHex: string;
+    isHidden: boolean;
+    makecallCtiExtern: boolean;
+    isVm: boolean;
+    participants: any;
+    isConference: boolean;
+    avatars: any[];
+    fullJid: string;
+    mediaPillarCall: any;
+    isSecondary: boolean;
+    /**
+     * Indicates that this call comes from an OXE attendant (OPE).
+     * While set, the call server forbids any second call, hold, retrieve or transfer attempt,
+     * so the related capabilities must be disabled (see CRRAINB-53349).
+     */
+    isAttendantCall: boolean;
+    isSecondSharingCall: boolean;
+    relevant: boolean;
+    relevantEquipmentId: string;
+    deviceId: any;
+    isOwner: any;
+    isMPAudioOwner: any;
+    pbxConnectionDown: any;
+    statusInfo: any;
+    globalCallId: string;
+    activeControl: boolean;
+    hasRemoteControlling: boolean;
+    sipWiseData: any;
+    sipWiseEndPointDeviceList: any;
+    noIncomingPopup: boolean;
+    errorMessage: string;
+    autoOffHookResource: string;
+    autoOffHookInProgress: boolean;
+    mixtWebTelSingleStepTrans: boolean;
+    localStreams: MediaStream[];
+    statsInterval: any;
+    originalStream: MediaStream;
+    autoClear: any;
+    autoAnswer: boolean;
+    distantType: string;
+    addVideoAfterUnhold: boolean;
+    _redirectionCause: CallRedirectionCause;
+    get redirectionCause(): CallRedirectionCause;
+    set redirectionCause(redirectionCause: CallRedirectionCause);
+    private _isRecorded;
+    get isRecorded(): boolean;
+    set isRecorded(value: boolean);
+    private _isRemoteRecordingPaused;
+    get isRemoteRecordingPaused(): boolean;
+    set isRemoteRecordingPaused(value: boolean);
+    callerNumber: string;
+    calledParty: CalledParty;
+    get calledNumber(): string;
+    get alertingNumber(): string;
+    get remoteNumber(): string;
+    remoteParty: {
+        rawPhoneNumber: string;
+        phoneNumber: string;
+        contact: any;
+        jid: string;
+    };
+    remoteParties: {
+        rawPhoneNumber: string;
+        phoneNumber: string;
+        contact: any;
+        jid: string;
+        direction?: CallDirection;
+    }[];
+    isWebrtcMpIncomingCallPopup: boolean;
+    webConferenceRoom: any;
+    remoteControled: boolean;
+    remoteControledHybride: boolean;
+    transferInitiatorUserId: string;
+    role: string;
+    ccdGlobalWaitingTime: string;
+    private _lastCause;
+    get lastCause(): string;
+    set lastCause(cause: string);
+    private _PBXDisplay;
+    get PBXDisplay(): string;
+    set PBXDisplay(display: string);
+    get isDoorphoneCall(): boolean;
+    hasRemoteSharingWithAudio: boolean;
+    constructor(status: CallStatus, id: string, type: CallType, contact: Contact);
+    static create(status: any, id: string, type: CallType, contact?: any): CallRB;
+    get contact(): Contact;
+    set contact(contact: Contact);
+    get capabilities(): CallCapabilities;
+    /**
+     * Update globally the capabilities of the call.
+     * Tests are performed to check whether capabilities have been modified and whether the data needs to be updated.
+     * This avoids sending an 'ON_CALL_CAPABILITIES_UPDATED' event if no changement has been detected.
+     * @param capabilities - The new values of the capabilities
+     */
+    set capabilities(capabilities: CallCapabilities);
+    get isMuted(): boolean;
+    set isMuted(muted: boolean);
+    get callStatus(): CallStatus;
+    set callStatus(status: CallStatus);
+    setCallId(id: string): void;
+    getGlobalCallId(): string;
+    setGlobalCallId(id: string): void;
+    setConversationId(conversationId: string): void;
+    setStatus(status: CallStatus): void;
+    setCorrelatorData(correlatorData: string): void;
+    setCorrelatorDataHex(correlatorDataHex: string): void;
+    setIsVm(isVM: boolean): void;
+    getIsVm(): boolean;
+    setContact(contact: any): void;
+    setSubject(subject: string): void;
+    getRemoteParty(): {
+        rawPhoneNumber: string;
+        phoneNumber: string;
+        contact: any;
+        jid: string;
+    };
+    setRemoteParty(rawPhoneNumber: string, jid: string, contact: any, phoneNumber?: string): void;
+    getRemoteParties(): {
+        rawPhoneNumber: string;
+        phoneNumber: string;
+        contact: any;
+        jid: string;
+        direction?: CallDirection;
+    }[];
+    setRemoteParties(remoteParties: any[]): void;
+    getRemotePartyPhoneNumber(): string;
+    getRemotePartyRawPhoneNumber(): string;
+    setRemotePartyPhoneNumberAndJid(rawPhoneNumber: string, jid: string, phoneNumber?: string): void;
+    setRemotePartyContact(contact: any, jid: string): void;
+    setRelevantEquipmentId(relevantEquipmentId: string): void;
+    setParticipants(participants: any[]): void;
+    setConnectionId(connectionId: string): void;
+    getccdGlobalWaitingTime(): string;
+    setccdGlobalWaitingTime(waitingTime: string): void;
+    /**
+     * @public
+     * @param name - the name of the event
+     * @param data - the data to be send (an object)
+     * CallEvents events send to other services via sendEvent()
+     * Can listen to it via Call.subscribe() API
+     */
+    sendEvent(name: string, data?: any): void;
+    isInConversationWithMobile(): boolean;
+    isInConversationWithDesktopApp(): boolean;
+    toString(): string;
+    toJSON(): any;
+    private manageDurationTimer;
+    private manageIncomingPopupData;
+    startDuration(): void;
+    stopDuration(): void;
+    static getIdFromConnectionId(connectionId: string): string;
+    static getCallIdFromConnectionId(connectionId: string): string;
+    static getDeviceIdFromConnectionId(connectionId: string): string;
+    getDeviceIdFromConnectionIdFromCall(): any;
+    isWebRtcMediaPillar(): boolean;
+    /**
+     * Check if the call is linked to a media pillar context
+     * Note: if it is a new call not already managed through webrtcGatewayService then not conclusive
+     * (because could be linked after)
+     */
+    isMediaPillarCall(): boolean;
+    isInCallWithMediaPillar(): boolean;
+    getMediaPillarCall(): any;
+    setMediaPillarCall(mediaPillarCallContext: any): void;
+    setDeviceIdSipWise(deviceId: string): void;
+    getDeviceIdSipWise(): any;
+    setConnectionIdSipWise(connectionId: string): void;
+    getConnectionIdSipWise(): string;
+    resetSipWiseData(): void;
+    setInitCauseSipWiseData(cause: string): void;
+    getLastCause(): string;
+    setLastCause(cause: string): void;
+    getInitCauseSipWiseData(): any;
+    setTypeSipWiseData(type: string): void;
+    getTypeSipWiseData(): any;
+    /**
+     * For a sipwise (cloud tel) incoming call to an user who is belong to a hunting group
+     * We have to known if the call is for the group or privatly for the user
+     * This methode gives this info.
+     * @returns Return true if the call is for the hunting group false otherwise
+     */
+    isHuntingGroupCallSipWise(): boolean;
+    isHuntingGroupCallQueueSipWise(): boolean;
+    isSipWiseSfuIncomingCall(): boolean;
+    isSfuPbxCall(): boolean;
+    setAssocPhoneCallId(assocPhoneCallId: any): void;
+    getAssocPhoneCallId(): any;
+    setEndPointDeviceListSipWise(deviceList: any): void;
+    getEndPointDeviceListSipWise(): any;
+    setAutoOffHookResource(resource: string): void;
+    getAutoOffHookResource(): string;
+    setAutoOffHookInProgress(inProgress: boolean): void;
+    getAutoOffHookInProgress(): boolean;
+    setMixtWebTelSingleStepTrans(flag: boolean): void;
+    getMixtWebTelSingleStepTrans(): boolean;
+    setDirection(direction: CallDirection): void;
+    getDirection(): CallDirection;
+    getRecordingDuration(): number;
+    static StatusDisplay: {
+        UNKNOWN: string;
+        ENDED: string;
+        DIALING: string;
+        QUEUED_INCOMMING: string;
+        QUEUED_OUTGOING: string;
+        RINGING_INCOMMING: string;
+        RINGING_OUTGOING: string;
+        ACTIVE: string;
+        HOLD: string;
+        PUT_ON_HOLD: string;
+        RELEASING: string;
+        ANSWERING: string;
+        CONNECTING: string;
+        ERROR: string;
+    };
+    getStatusForDisplay(): string;
+    /**
+     * Attach the local video stream to a given HTML VIDEO tag element;
+     * @param HtmlElement - TheHTML VIDEO tag element visible on the page
+     */
+    attachLocalVideoStreamToElement(HtmlElement: HTMLElement): void;
+    /**
+     * Attach the local sharing stream to a given HTML VIDEO tag element;
+     * @param HtmlElementId - The HTML VIDEO tag element visible on the page
+     */
+    attachLocalSharingStreamToElement(HtmlElement: HTMLElement): void;
+    /**
+     * Attach the remote video stream to a given HTML VIDEO tag element;
+     * @param HtmlElementId - The HTML VIDEO tag element visible on the page
+     */
+    attachRemoteVideoStreamToElement(HtmlElement: HTMLElement): void;
+    /**
+     * Attach the remote sharing stream to a given HTML VIDEO tag element;
+     * @param HtmlElementId - The HTML VIDEO tag element visible on the page
+     */
+    attachRemoteSharingStreamToElement(HtmlElement: HTMLElement): void;
+    /**
+     * Subscribe to updates on the current call (all events are of RBEvent<CallEvents>
+     * @param callback - The callback function that will be called when events are received
+     * @param eventNames - (optional) array of event to listen
+     * @returns Returns RxJS Subscription
+     */
+    subscribe(callback: (event: RBEvent<CallEvents>) => any, eventNames?: CallEvents | CallEvents[]): Subscription;
+    /**
+     * Answer the current incoming call.
+     * This feature can be used only if the "answer" call capability is 'True'.
+     * By default, the answer is done with AUDIO only.
+     * If the 'withVideo' option is set to 'True' and the incoming call contains video, the answer will directly be done with audio and video.
+     * @param withVideo - Option to answer the call directly with audio and video. Default value is 'False'
+     */
+    answer(withVideo?: boolean): Promise<void>;
+    /**
+     * Release the current call.
+     * This method allows to decline an incoming call or stop an outgoing call.
+     * This feature can be used only if the "release" call capability is 'True'.
+     */
+    release(): Promise<void>;
+    /**
+     * Put on hold the current call.
+     * This feature can be used only if the "hold" call capability is 'True'.
+     */
+    hold(): Promise<void>;
+    /**
+     * Retrieve from hold the current call.
+     * This feature can be used only if the "retrieve" call capability is 'True'.
+     */
+    retrieve(): Promise<void>;
+    /**
+     * Mute the call
+     * This feature can be used only if the "mute" call capability is 'True'.
+     */
+    mute(): void;
+    /**
+     * Unmute the call
+     * This feature can be used only if the "unmute" call capability is 'True'.
+     */
+    unmute(): void;
+    /**
+     * Send DTMF signal to the current call.
+     * This feature can be used only if the "dtmf" call capability is 'True'.
+     * @param dialKey - the DTMF character sequences to be send
+     * Only the following characters are authorised: the ten single digits (0..9), the letters (a,b,c,d), the asterisk (*) and the pound sign (#).
+     */
+    sendDTMF(dialKey: string): void;
+    /**
+     * Add the AUDIO media to the current call.
+     * This feature can be used only if the "addAudio" call capability is 'True' and available only for WebRTC Calls.
+     */
+    addAudio(): Promise<void>;
+    /**
+     * Add the VIDEO media to the current call.
+     * This feature can be used only if the "addVideo" call capability is 'True' and available only for WebRTC Calls.
+     */
+    addVideo(): Promise<void>;
+    /**
+     * Add the SHARING media to the current call.
+     * This feature can be used only if the "addSharing" call capability is 'True' and available only for WebRTC Calls.
+     */
+    addSharing(): Promise<void>;
+    /**
+     * Remove the VIDEO media from the current call.
+     * This feature can be used only if the "removeVideo" call capability is 'True' and available only for WebRTC Calls.
+     */
+    removeVideo(): Promise<void>;
+    /**
+     * Remove the SHARING media from the current call.
+     * This feature can be used only if the "removeSharing" call capability is 'True' and available only for WebRTC Calls.
+     */
+    removeSharing(): Promise<void>;
+    /**
+     * Add participants to the current call.
+     * The participants could be other Rainbow users or phone numbers (if the PBX system supports it).
+     * This will result in a new conversation being created with web conference inside. The active call will be "transferred" to the bubble conference.
+     * @param participants - The list of participants to be added to the call
+     * @returns The new bubble conversation where the web conference is active
+     */
+    addParticipantsToCall(participants: CallDestination[]): Promise<Conversation>;
+    /**
+     * Create a conference from 2 calls, including the current call.
+     * This will lead to the creation of either a web conference (managed via a Rainbow bubble) or a pure telephone conference (managed by a PBX system).
+     * In the first case, a new conversation is created with the web conference inside. The two calls will be "transferred" to the bubble conference.
+     * In the second case, a new 'conference' type conversation is created. This applies only with a Rainbow Hybrid (OXO or OXE) telephone system.
+     * This feature can be used only if the "mergeCalls" call capability is 'True'.
+     * @returns The new conversation or undefined depending on the type of conference created.
+     */
+    activateConference(): Promise<Conversation | undefined>;
+    /**
+     * Blind transfer the current call another destination which could be any rainbow user or phone number.
+     * A blind transfer is when you transfer a call directly to another party without consulting with the person receiving the call.
+     * In other words, there is no need to call the other party to make the transfer.
+     * This feature is available only if the connected user is behind a Rainbow Hub telephone system.
+     * @param destination - The destination of the blind transfer
+     */
+    blindTransfer(destination: CallDestination): Promise<void>;
+    /**
+     * Deflect the incoming call to the voice mail.
+     * This feature can be used only if the "deflectToVoicemail" call capability is 'True'.
+     * The 'deflect to voice mail' is only available on HYBRID telephony systems.
+     * For Cloud telephony systems, the release call will follow the user configuration (which could be deflect or other).
+     */
+    deflectToVoicemail(): Promise<void>;
+    /**
+     * @public
+     * Deflect (redirect) the current incoming call to the specified phone number.
+     * This feature can be used only if the "deflectToPhoneNumber" call capability is 'True'.
+     * The list of number where we can deflect the incoming call is available in the 'deflectPhoneNumberDestinations' call capability.
+     * @param number - The phone number the call will be deflected to.
+     */
+    deflectToPhoneNumber(number: string): Promise<void>;
+    /**
+     * Transfer the current call to another call.
+     * If the destination call is not specified, then the transfer will be done towards the current active call.
+     * The list of destination calls to which we can deflect the call current is available in the 'transferCallDestinations' call capability.
+     * @param destinationCall - The destination call to which we want to transfer the current call.
+     */
+    transferToOtherCall(destinationCall?: Call): Promise<void>;
+    /**
+     * Attach the local video stream to a given HTML VIDEO tag element;
+     * @param HtmlElementId - The ID of the HTML VIDEO tag element visible on the page
+     */
+    attachLocalVideoStream(HtmlElementId: string, HtmlElement?: HTMLElement): void;
+    /**
+     * Attach the local sharing stream to a given HTML VIDEO tag element;
+     * @param HtmlElementId - The ID of the HTML VIDEO tag element visible on the page
+     */
+    attachLocalSharingStream(HtmlElementId: string): void;
+    /**
+     * Attach the remote video stream to a given HTML VIDEO tag element;
+     * @param HtmlElementId - The ID of the HTML VIDEO tag element visible on the page
+     */
+    attachRemoteVideoStream(HtmlElementId: string): void;
+    /**
+     * Attach the remote sharing stream to a given HTML VIDEO tag element;
+     * @param HtmlElementId - The ID of the HTML VIDEO tag element visible on the page
+     */
+    attachRemoteSharingStream(HtmlElementId: string): void;
+    /**
+    * Start the recording of a call
+    * @param recordingName - optional name for the recording (stored as the uploaded file's fileName)
+    * @returns the call updated or an error
+    */
+    startRecording(recordingName?: string): Promise<void>;
+    /**
+    * Pause the recording
+    * @returns the call updated or an error
+    */
+    pauseRecording(): Promise<void>;
+    /**
+    * Resume the recording
+    * @returns the call updated or an error
+    */
+    resumeRecording(): Promise<void>;
+    /**
+    * Stop the recording
+    * @returns the call updated or an error
+    */
+    stopRecording(): Promise<void>;
+    /**
+     * Cancel the recording
+     * @returns the call updated or an error
+     */
+    cancelRecording(): Promise<void>;
+}
+//# sourceMappingURL=call.model.d.ts.map