feat(ts) add auto-generated type declarations

This should allow us to monitor the progress when comparing them to hand-crafted
ones.

.eslintignore

@@ -1,6 +1,7 @@
 # The build artifacts of the lib-jiti-meet project.
 lib-jitsi-meet.*
 dist/
+types/
 
 # Third-party source code which we (1) do not want to modify or (2) try to
 # modify as little as possible.

tsconfig.json

@@ -2,7 +2,8 @@
   "compilerOptions": {
     "target": "es6",
     "module": "es6",
-    "declaration": false,
+    "declaration": true,
+    "declarationDir": "types/auto/",
     "sourceMap": true,
     "allowJs": true,
     "skipLibCheck": true,

types/auto/JitsiConferenceErrors.d.ts

@@ -0,0 +1,88 @@
+/**
+ * The errors for the conference.
+ */
+/**
+ * Indicates that client must be authenticated to create the conference.
+ */
+export const AUTHENTICATION_REQUIRED: "conference.authenticationRequired";
+/**
+ * Indicates that chat error occurred.
+ */
+export const CHAT_ERROR: "conference.chatError";
+/**
+ * Indicates that a settings error occurred.
+ */
+export const SETTINGS_ERROR: "conference.settingsError";
+/**
+ * Indicates that conference has been destroyed.
+ */
+export const CONFERENCE_DESTROYED: "conference.destroyed";
+/**
+ * Indicates that max users limit has been reached.
+ */
+export const CONFERENCE_MAX_USERS: "conference.max_users";
+/**
+ * Indicates that a connection error occurred when trying to join a conference.
+ */
+export const CONNECTION_ERROR: "conference.connectionError";
+/**
+ * Indicates that the client has been forced to restart by jicofo when the
+ * conference was migrated from one bridge to another.
+ */
+export const CONFERENCE_RESTARTED: "conference.restarted";
+/**
+ * Indicates that a connection error is due to not allowed,
+ * occurred when trying to join a conference.
+ */
+export const NOT_ALLOWED_ERROR: "conference.connectionError.notAllowed";
+/**
+ * Indicates that a connection error is due to not allowed,
+ * occurred when trying to join a conference, only approved members are allowed to join.
+ */
+export const MEMBERS_ONLY_ERROR: "conference.connectionError.membersOnly";
+/**
+ * Indicates that a connection error is due to denied access to the room,
+ * occurred after joining a lobby room and access is denied by the room moderators.
+ */
+export const CONFERENCE_ACCESS_DENIED: "conference.connectionError.accessDenied";
+/**
+ * Indicates that focus error happened.
+ */
+export const FOCUS_DISCONNECTED: "conference.focusDisconnected";
+/**
+ * Indicates that focus left the conference.
+ */
+export const FOCUS_LEFT: "conference.focusLeft";
+/**
+ * Indicates that graceful shutdown happened.
+ */
+export const GRACEFUL_SHUTDOWN: "conference.gracefulShutdown";
+/**
+ * Indicates that the media connection has failed.
+ */
+export const ICE_FAILED: "conference.iceFailed";
+/**
+ * Indicates that the versions of the server side components are incompatible
+ * with the client side.
+ */
+export const INCOMPATIBLE_SERVER_VERSIONS: "conference.incompatible_server_versions";
+/**
+ * Indicates that offer/answer had failed.
+ */
+export const OFFER_ANSWER_FAILED: "conference.offerAnswerFailed";
+/**
+ * Indicates that password cannot be set for this conference.
+ */
+export const PASSWORD_NOT_SUPPORTED: "conference.passwordNotSupported";
+/**
+ * Indicates that a password is required in order to join the conference.
+ */
+export const PASSWORD_REQUIRED: "conference.passwordRequired";
+/**
+ * Indicates that reservation system returned error.
+ */
+export const RESERVATION_ERROR: "conference.reservationError";
+/**
+ * Indicates that there is no available videobridge.
+ */
+export const VIDEOBRIDGE_NOT_AVAILABLE: "conference.videobridgeNotAvailable";

types/auto/JitsiConferenceEventManager.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Setups all event listeners related to conference
+ * @param conference {JitsiConference} the conference
+ */
+export default function JitsiConferenceEventManager(conference: any): void;
+export default class JitsiConferenceEventManager {
+    /**
+     * Setups all event listeners related to conference
+     * @param conference {JitsiConference} the conference
+     */
+    constructor(conference: any);
+    conference: any;
+    xmppListeners: {};
+    /**
+     * Setups event listeners related to conference.chatRoom
+     */
+    setupChatRoomListeners(): void;
+    chatRoomForwarder: EventEmitterForwarder;
+    /**
+     * Setups event listeners related to conference.rtc
+     */
+    setupRTCListeners(): void;
+    /**
+     * Removes event listeners related to conference.xmpp
+     */
+    removeXMPPListeners(): void;
+    /**
+     * Setups event listeners related to conference.xmpp
+     */
+    setupXMPPListeners(): void;
+    /**
+     * Add XMPP listener and save its reference for remove on leave conference.
+     */
+    _addConferenceXMPPListener(eventName: any, listener: any): void;
+    /**
+     * Setups event listeners related to conference.statistics
+     */
+    setupStatisticsListeners(): void;
+}
+import EventEmitterForwarder from "./modules/util/EventEmitterForwarder";

types/auto/JitsiConferenceEvents.d.ts

@@ -0,0 +1,383 @@
+/**
+ * The events for the conference.
+ */
+/**
+ * Event indicates that the current conference audio input switched between audio
+ * input states,i.e. with or without audio input.
+ */
+export const AUDIO_INPUT_STATE_CHANGE: "conference.audio_input_state_changed";
+/**
+ * Event indicates that the permission for unmuting audio has changed based on the number of audio senders in the call
+ * and the audio sender limit configured in Jicofo.
+ */
+export const AUDIO_UNMUTE_PERMISSIONS_CHANGED: "conference.audio_unmute_permissions_changed";
+/**
+ * Indicates that authentication status changed.
+ */
+export const AUTH_STATUS_CHANGED: "conference.auth_status_changed";
+/**
+ * Fired just before the statistics module is disposed and it's the last chance
+ * to submit some logs to the statistics service (ex. CallStats if enabled),
+ * before it's disconnected.
+ */
+export const BEFORE_STATISTICS_DISPOSED: "conference.beforeStatisticsDisposed";
+/**
+ * Indicates that an error occured.
+ */
+export const CONFERENCE_ERROR: "conference.error";
+/**
+ * Indicates that conference failed.
+ */
+export const CONFERENCE_FAILED: "conference.failed";
+/**
+ * Indicates that conference is in progress of joining.
+ */
+export const CONFERENCE_JOIN_IN_PROGRESS: "conference.join_in_progress";
+/**
+ * Indicates that conference has been joined. The event does NOT provide any
+ * parameters to its listeners.
+ */
+export const CONFERENCE_JOINED: "conference.joined";
+/**
+ * Indicates that conference has been left.
+ */
+export const CONFERENCE_LEFT: "conference.left";
+/**
+ * Indicates that the conference unique identifier has been set.
+ */
+export const CONFERENCE_UNIQUE_ID_SET: "conference.unique_id_set";
+/**
+ * Indicates that the connection to the conference has been established
+ * XXX This is currently fired whenVthe *ICE* connection enters 'connected'
+ * state for the first time.
+ */
+export const CONNECTION_ESTABLISHED: "conference.connectionEstablished";
+/**
+ * Indicates that the connection to the conference has been interrupted for some
+ * reason.
+ * XXX This is currently fired when the *ICE* connection is interrupted.
+ */
+export const CONNECTION_INTERRUPTED: "conference.connectionInterrupted";
+/**
+ * Indicates that the connection to the conference has been restored.
+ * XXX This is currently fired when the *ICE* connection is restored.
+ */
+export const CONNECTION_RESTORED: "conference.connectionRestored";
+/**
+ * A connection to the video bridge's data channel has been established.
+ */
+export const DATA_CHANNEL_OPENED: "conference.dataChannelOpened";
+/**
+ * A user has changed it display name
+ */
+export const DISPLAY_NAME_CHANGED: "conference.displayNameChanged";
+/**
+ * The dominant speaker was changed.
+ */
+export const DOMINANT_SPEAKER_CHANGED: "conference.dominantSpeaker";
+/**
+ * UTC conference timestamp when first participant joined.
+ */
+export const CONFERENCE_CREATED_TIMESTAMP: "conference.createdTimestamp";
+/**
+ * Indicates that DTMF support changed.
+ */
+export const DTMF_SUPPORT_CHANGED: "conference.dtmfSupportChanged";
+/**
+ * Indicates that a message from another participant is received on data
+ * channel.
+ */
+export const ENDPOINT_MESSAGE_RECEIVED: "conference.endpoint_message_received";
+/**
+ * Indicates that a message for the remote endpoint statistics has been received on the bridge channel.
+ */
+export const ENDPOINT_STATS_RECEIVED: "conference.endpoint_stats_received";
+/**
+ * NOTE This is lib-jitsi-meet internal event and can be removed at any time !
+ *
+ * Event emitted when conference transits, between one to one and multiparty JVB
+ * conference. If the conference switches to P2P it's neither one to one nor
+ * a multiparty JVB conference, but P2P (the status argument of this event will
+ * be <tt>false</tt>).
+ *
+ * The first argument is a boolean which carries the previous value and
+ * the seconds argument is a boolean with the new status. The event is emitted
+ * only if the previous and the new values are different.
+ *
+ * @type {string}
+ */
+export const JVB121_STATUS: string;
+/**
+ * You are kicked from the conference.
+ * @param {JitsiParticipant} the participant that initiated the kick.
+ */
+export const KICKED: "conference.kicked";
+/**
+ * Participant was kicked from the conference.
+ * @param {JitsiParticipant} the participant that initiated the kick.
+ * @param {JitsiParticipant} the participant that was kicked.
+ */
+export const PARTICIPANT_KICKED: "conference.participant_kicked";
+/**
+ * The Last N set is changed.
+ *
+ * @param {Array<string>|null} leavingEndpointIds the ids of all the endpoints
+ * which are leaving Last N
+ * @param {Array<string>|null} enteringEndpointIds the ids of all the endpoints
+ * which are entering Last N
+ */
+export const LAST_N_ENDPOINTS_CHANGED: "conference.lastNEndpointsChanged";
+/**
+ * Indicates that the room has been locked or unlocked.
+ */
+export const LOCK_STATE_CHANGED: "conference.lock_state_changed";
+/**
+ * Indicates that the region of the media server (jitsi-videobridge) that we
+ * are connected to changed (or was initially set).
+ * @type {string} the region.
+ */
+export const SERVER_REGION_CHANGED: string;
+/**
+ * An event(library-private) fired when a new media session is added to the conference.
+ * @type {string}
+ * @private
+ */
+export const _MEDIA_SESSION_STARTED: string;
+/**
+ * An event(library-private) fired when the conference switches the currently active media session.
+ * @type {string}
+ * @private
+ */
+export const _MEDIA_SESSION_ACTIVE_CHANGED: string;
+/**
+ * Indicates that the conference had changed to members only enabled/disabled.
+ * The first argument of this event is a <tt>boolean</tt> which when set to
+ * <tt>true</tt> means that the conference is running in members only mode.
+ * You may need to use Lobby if supported to ask for permissions to enter the conference.
+ */
+export const MEMBERS_ONLY_CHANGED: "conference.membersOnlyChanged";
+/**
+ * New text message was received.
+ */
+export const MESSAGE_RECEIVED: "conference.messageReceived";
+/**
+ * Event indicates that the current selected input device has no signal
+ */
+export const NO_AUDIO_INPUT: "conference.no_audio_input";
+/**
+ * Event indicates that the current microphone used by the conference is noisy.
+ */
+export const NOISY_MIC: "conference.noisy_mic";
+/**
+ * Indicates that a message from the local user or from the Prosody backend
+ * was received on the data channel.
+ */
+export const NON_PARTICIPANT_MESSAGE_RECEIVED: "conference.non_participant_message_received";
+/**
+ * New private text message was received.
+ */
+export const PRIVATE_MESSAGE_RECEIVED: "conference.privateMessageReceived";
+/**
+ * Event fired when JVB sends notification about interrupted/restored user's
+ * ICE connection status or we detect local problem with the video track.
+ * First argument is the ID of the participant and
+ * the seconds is a string indicating if the connection is currently
+ * - active - the connection is active
+ * - inactive - the connection is inactive, was intentionally interrupted by
+ * the bridge
+ * - interrupted - a network problem occurred
+ * - restoring - the connection was inactive and is restoring now
+ *
+ * The current status value can be obtained by calling
+ * JitsiParticipant.getConnectionStatus().
+ */
+export const PARTICIPANT_CONN_STATUS_CHANGED: "conference.participant_conn_status_changed";
+/**
+ * Indicates that the features of the participant has been changed.
+ */
+export const PARTCIPANT_FEATURES_CHANGED: "conference.partcipant_features_changed";
+/**
+ * Indicates that a the value of a specific property of a specific participant
+ * has changed.
+ */
+export const PARTICIPANT_PROPERTY_CHANGED: "conference.participant_property_changed";
+/**
+ * Indicates that the conference has switched between JVB and P2P connections.
+ * The first argument of this event is a <tt>boolean</tt> which when set to
+ * <tt>true</tt> means that the conference is running on the P2P connection.
+ */
+export const P2P_STATUS: "conference.p2pStatus";
+/**
+ * Indicates that phone number changed.
+ */
+export const PHONE_NUMBER_CHANGED: "conference.phoneNumberChanged";
+/**
+ * The conference properties changed.
+ * @type {string}
+ */
+export const PROPERTIES_CHANGED: string;
+/**
+ * Indicates that recording state changed.
+ */
+export const RECORDER_STATE_CHANGED: "conference.recorderStateChanged";
+/**
+ * Indicates that video SIP GW state changed.
+ * @param {VideoSIPGWConstants} status.
+ */
+export const VIDEO_SIP_GW_AVAILABILITY_CHANGED: "conference.videoSIPGWAvailabilityChanged";
+/**
+ * Indicates that video SIP GW Session state changed.
+ * @param {options} event - {
+ *     {string} address,
+ *     {VideoSIPGWConstants} oldState,
+ *     {VideoSIPGWConstants} newState,
+ *     {string} displayName}
+ * }.
+ */
+export const VIDEO_SIP_GW_SESSION_STATE_CHANGED: "conference.videoSIPGWSessionStateChanged";
+/**
+ * Indicates that start muted settings changed.
+ */
+export const START_MUTED_POLICY_CHANGED: "conference.start_muted_policy_changed";
+/**
+ * Indicates that the local user has started muted.
+ */
+export const STARTED_MUTED: "conference.started_muted";
+/**
+ * Indicates that subject of the conference has changed.
+ */
+export const SUBJECT_CHANGED: "conference.subjectChanged";
+/**
+ * Indicates that DTMF support changed.
+ */
+export const SUSPEND_DETECTED: "conference.suspendDetected";
+/**
+ * Event indicates that local user is talking while he muted himself
+ */
+export const TALK_WHILE_MUTED: "conference.talk_while_muted";
+/**
+ * A new media track was added to the conference. The event provides the
+ * following parameters to its listeners:
+ *
+ * @param {JitsiTrack} track the added JitsiTrack
+ */
+export const TRACK_ADDED: "conference.trackAdded";
+/**
+ * Audio levels of a media track ( attached to the conference) was changed.
+ */
+export const TRACK_AUDIO_LEVEL_CHANGED: "conference.audioLevelsChanged";
+/**
+ * A media track ( attached to the conference) mute status was changed.
+ * @param {JitsiParticipant|null} the participant that initiated the mute
+ * if it is a remote mute.
+ */
+export const TRACK_MUTE_CHANGED: "conference.trackMuteChanged";
+/**
+ * The media track was removed from the conference. The event provides the
+ * following parameters to its listeners:
+ *
+ * @param {JitsiTrack} track the removed JitsiTrack
+ */
+export const TRACK_REMOVED: "conference.trackRemoved";
+/**
+ * The source-add for unmuting of a media track was rejected by Jicofo.
+ *
+ */
+export const TRACK_UNMUTE_REJECTED: "conference.trackUnmuteRejected";
+/**
+ * Notifies for transcription status changes. The event provides the
+ * following parameters to its listeners:
+ *
+ * @param {String} status - The new status.
+ */
+export const TRANSCRIPTION_STATUS_CHANGED: "conference.transcriptionStatusChanged";
+/**
+ * A new user joined the conference.
+ */
+export const USER_JOINED: "conference.userJoined";
+/**
+ * A user has left the conference.
+ */
+export const USER_LEFT: "conference.userLeft";
+/**
+ * User role changed.
+ */
+export const USER_ROLE_CHANGED: "conference.roleChanged";
+/**
+ * User status changed.
+ */
+export const USER_STATUS_CHANGED: "conference.statusChanged";
+/**
+ * Event indicates that the permission for unmuting video has changed based on the number of video senders in the call
+ * and the video sender limit configured in Jicofo.
+ */
+export const VIDEO_UNMUTE_PERMISSIONS_CHANGED: "conference.video_unmute_permissions_changed";
+/**
+ * Event indicates that the bot participant type changed.
+ */
+export const BOT_TYPE_CHANGED: "conference.bot_type_changed";
+/**
+ * A new user joined the lobby room.
+ */
+export const LOBBY_USER_JOINED: "conference.lobby.userJoined";
+/**
+ * A user from the lobby room has been update.
+ */
+export const LOBBY_USER_UPDATED: "conference.lobby.userUpdated";
+/**
+ * A user left the lobby room.
+ */
+export const LOBBY_USER_LEFT: "conference.lobby.userLeft";
+/**
+ * The local participant was approved to be able to unmute.
+ * @param {options} event - {
+ *     {MediaType} mediaType
+ * }.
+ */
+export const AV_MODERATION_APPROVED: "conference.av_moderation.approved";
+/**
+ * The local participant was blocked to be able to unmute.
+ * @param {options} event - {
+ *     {MediaType} mediaType
+ * }.
+ */
+export const AV_MODERATION_REJECTED: "conference.av_moderation.rejected";
+/**
+ * AV Moderation was enabled/disabled. The actor is the participant that is currently in the meeting,
+ * or undefined if that participant has left the meeting.
+ *
+ * @param {options} event - {
+ *     {boolean} enabled,
+ *     {MediaType} mediaType,
+ *     {JitsiParticipant} actor
+ * }.
+ */
+export const AV_MODERATION_CHANGED: "conference.av_moderation.changed";
+/**
+ * AV Moderation, report for user being approved to unmute.
+ * @param {options} event - {
+ *     {JitsiParticipant} participant,
+ *     {MediaType} mediaType
+ * }.
+ */
+export const AV_MODERATION_PARTICIPANT_APPROVED: "conference.av_moderation.participant.approved";
+/**
+ * AV Moderation, report for user being blocked to unmute.
+ * @param {options} event - {
+ *     {JitsiParticipant} participant,
+ *     {MediaType} mediaType
+ * }.
+ */
+export const AV_MODERATION_PARTICIPANT_REJECTED: "conference.av_moderation.participant.rejected";
+/**
+ * A new facial expression is added with its duration for a participant
+ */
+export const FACIAL_EXPRESSION_ADDED: "conference.facial_expression.added";
+/**
+ * Event fired when a participant is requested to join a given (breakout) room.
+ */
+export const BREAKOUT_ROOMS_MOVE_TO_ROOM: "conference.breakout-rooms.move-to-room";
+/**
+ * Event fired when the breakout rooms data was updated.
+ */
+export const BREAKOUT_ROOMS_UPDATED: "conference.breakout-rooms.updated";

types/auto/JitsiConnection.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Creates a new connection object for the Jitsi Meet server side video
+ * conferencing service. Provides access to the JitsiConference interface.
+ * @param appID identification for the provider of Jitsi Meet video conferencing
+ * services.
+ * @param token the JWT token used to authenticate with the server(optional)
+ * @param options Object with properties / settings related to connection with
+ * the server.
+ * @constructor
+ */
+export default function JitsiConnection(appID: any, token: any, options: any): void;
+export default class JitsiConnection {
+    /**
+     * Creates a new connection object for the Jitsi Meet server side video
+     * conferencing service. Provides access to the JitsiConference interface.
+     * @param appID identification for the provider of Jitsi Meet video conferencing
+     * services.
+     * @param token the JWT token used to authenticate with the server(optional)
+     * @param options Object with properties / settings related to connection with
+     * the server.
+     * @constructor
+     */
+    constructor(appID: any, token: any, options: any);
+    appID: any;
+    token: any;
+    options: any;
+    xmpp: XMPP;
+    /**
+     * Connect the client with the server.
+     * @param options {object} connecting options
+     * (for example authentications parameters).
+     */
+    connect(options?: object): void;
+    /**
+     * Attach to existing connection. Can be used for optimizations. For example:
+     * if the connection is created on the server we can attach to it and start
+     * using it.
+     *
+     * @param options {object} connecting options - rid, sid and jid.
+     */
+    attach(options: object): void;
+    /**
+     * Disconnect the client from the server.
+     * @returns {Promise} - Resolves when the disconnect process is finished or rejects with an error.
+     */
+    disconnect(...args: any[]): Promise<any>;
+    /**
+     * Returns the jid of the participant associated with the XMPP connection.
+     *
+     * @returns {string} The jid of the participant.
+     */
+    getJid(): string;
+    /**
+     * This method allows renewal of the tokens if they are expiring.
+     * @param token the new token.
+     */
+    setToken(token: any): void;
+    /**
+     * Creates and joins new conference.
+     * @param name the name of the conference; if null - a generated name will be
+     * provided from the api
+     * @param options Object with properties / settings related to the conference
+     * that will be created.
+     * @returns {JitsiConference} returns the new conference object.
+     */
+    initJitsiConference(name: any, options: any): JitsiConference;
+    /**
+     * Subscribes the passed listener to the event.
+     * @param event {JitsiConnectionEvents} the connection event.
+     * @param listener {Function} the function that will receive the event
+     */
+    addEventListener(event: typeof JitsiConnectionEvents, listener: Function): void;
+    /**
+     * Unsubscribes the passed handler.
+     * @param event {JitsiConnectionEvents} the connection event.
+     * @param listener {Function} the function that will receive the event
+     */
+    removeEventListener(event: typeof JitsiConnectionEvents, listener: Function): void;
+    /**
+     * Returns measured connectionTimes.
+     */
+    getConnectionTimes(): {};
+    /**
+     * Adds new feature to the list of supported features for the local
+     * participant.
+     * @param {String} feature the name of the feature.
+     * @param {boolean} submit if true - the new list of features will be
+     * immediately submitted to the others.
+     */
+    addFeature(feature: string, submit?: boolean): void;
+    /**
+     * Removes a feature from the list of supported features for the local
+     * participant
+     * @param {String} feature the name of the feature.
+     * @param {boolean} submit if true - the new list of features will be
+     * immediately submitted to the others.
+     */
+    removeFeature(feature: string, submit?: boolean): void;
+    /**
+     * Get object with internal logs.
+     */
+    getLogs(): any;
+}
+import XMPP from "./modules/xmpp/xmpp";
+import JitsiConference from "./JitsiConference";
+import * as JitsiConnectionEvents from "./JitsiConnectionEvents";

types/auto/JitsiConnectionErrors.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The errors for the connection.
+ */
+/**
+ * Indicates that the connection was dropped with an error which was most likely
+ * caused by some networking issues. The dropped term in this context means that
+ * the connection was closed unexpectedly (not on user's request).
+ *
+ * One example is 'item-not-found' error thrown by Prosody when the BOSH session
+ * times out after 60 seconds of inactivity. On the other hand 'item-not-found'
+ * could also happen when BOSH request is sent to the server with the session-id
+ * that is not know to the server. But this should not happen in lib-jitsi-meet
+ * case as long as the service is configured correctly (there is no bug).
+ */
+export const CONNECTION_DROPPED_ERROR: "connection.droppedError";
+/**
+ * Not specified errors.
+ */
+export const OTHER_ERROR: "connection.otherError";
+/**
+ * Indicates that a password is required in order to join the conference.
+ */
+export const PASSWORD_REQUIRED: "connection.passwordRequired";
+/**
+ * Indicates that the connection was dropped, because of too many 5xx HTTP
+ * errors on BOSH requests.
+ */
+export const SERVER_ERROR: "connection.serverError";

types/auto/JitsiConnectionEvents.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The events for the connection.
+ */
+/**
+ * Indicates that the connection has been disconnected. The event provides
+ * the following parameters to its listeners:
+ *
+ * @param msg {string} a message associated with the disconnect such as the
+ * last (known) error message
+ */
+export const CONNECTION_DISCONNECTED: "connection.connectionDisconnected";
+/**
+ * Indicates that the connection has been established. The event provides
+ * the following parameters to its listeners:
+ *
+ * @param id {string} the ID of the local endpoint/participant/peer (within
+ * the context of the established connection)
+ */
+export const CONNECTION_ESTABLISHED: "connection.connectionEstablished";
+/**
+ * Indicates that the connection has been failed for some reason. The event
+ * provides the following parameters to its listeners:
+ *
+ * @param errType {JitsiConnectionErrors} the type of error associated with
+ * the failure
+ * @param errReason {string} the error (message) associated with the failure
+ * @param credentials {object} the credentials used to connect (if any)
+ * @param errReasonDetails {object} an optional object with details about
+ * the error, like shard moving, suspending. Used for analytics purposes.
+ */
+export const CONNECTION_FAILED: "connection.connectionFailed";
+/**
+ * Indicates that the performed action cannot be executed because the
+ * connection is not in the correct state(connected, disconnected, etc.)
+ */
+export const WRONG_STATE: "connection.wrongState";
+/**
+ * Indicates that the display name is required over this connection and need to be supplied when
+ * joining the room.
+ * There are cases like lobby room where display name is required.
+ */
+export const DISPLAY_NAME_REQUIRED: "connection.display_name_required";

types/auto/JitsiMediaDevices.d.ts

@@ -0,0 +1,100 @@
+/// <reference types="node" />
+declare var _default: JitsiMediaDevices;
+export default _default;
+/**
+ * Media devices utilities for Jitsi.
+ */
+declare class JitsiMediaDevices {
+    _eventEmitter: EventEmitter;
+    _permissions: {};
+    _permissionsApiSupported: Promise<any>;
+    /**
+     * Parses a PermissionState object and returns true for granted and false otherwise.
+     *
+     * @param {PermissionState} permissionStatus - The PermissionState object retrieved from the Permissions API.
+     * @returns {boolean} - True for granted and false for denied.
+     * @throws {TypeError}
+     */
+    _parsePermissionState(permissionStatus?: PermissionState): boolean;
+    /**
+     * Updates the local granted/denied permissions cache. A permissions might be
+     * granted, denied, or undefined. This is represented by having its media
+     * type key set to {@code true} or {@code false} respectively.
+     *
+     * @param {Object} permissions - Object with the permissions.
+     */
+    _handlePermissionsChange(permissions: any): void;
+    /**
+     * Gathers data and sends it to statistics.
+     * @param deviceID the device id to log
+     * @param devices list of devices
+     */
+    _logOutputDevice(deviceID: any, devices: any): void;
+    /**
+     * Executes callback with list of media devices connected.
+     * @param {function} callback
+     */
+    enumerateDevices(callback: Function): void;
+    /**
+     * Checks if its possible to enumerate available cameras/micropones.
+     * @returns {Promise<boolean>} a Promise which will be resolved only once
+     * the WebRTC stack is ready, either with true if the device listing is
+     * available available or with false otherwise.
+     */
+    isDeviceListAvailable(): Promise<boolean>;
+    /**
+     * Returns true if changing the input (camera / microphone) or output
+     * (audio) device is supported and false if not.
+     * @param {string} [deviceType] - type of device to change. Default is
+     *      undefined or 'input', 'output' - for audio output device change.
+     * @returns {boolean} true if available, false otherwise.
+     */
+    isDeviceChangeAvailable(deviceType?: string): boolean;
+    /**
+     * Checks if the permission for the given device was granted.
+     *
+     * @param {'audio'|'video'} [type] - type of devices to check,
+     *      undefined stands for both 'audio' and 'video' together
+     * @returns {Promise<boolean>}
+     */
+    isDevicePermissionGranted(type?: 'audio' | 'video'): Promise<boolean>;
+    /**
+     * Returns true if it is possible to be simultaneously capturing audio from more than one device.
+     *
+     * @returns {boolean}
+     */
+    isMultipleAudioInputSupported(): boolean;
+    /**
+     * Returns currently used audio output device id, 'default' stands
+     * for default device
+     * @returns {string}
+     */
+    getAudioOutputDevice(): string;
+    /**
+     * Sets current audio output device.
+     * @param {string} deviceId - id of 'audiooutput' device from
+     *      navigator.mediaDevices.enumerateDevices(), 'default' is for
+     *      default device
+     * @returns {Promise} - resolves when audio output is changed, is rejected
+     *      otherwise
+     */
+    setAudioOutputDevice(deviceId: string): Promise<any>;
+    /**
+     * Adds an event handler.
+     * @param {string} event - event name
+     * @param {function} handler - event handler
+     */
+    addEventListener(event: string, handler: Function): void;
+    /**
+     * Removes event handler.
+     * @param {string} event - event name
+     * @param {function} handler - event handler
+     */
+    removeEventListener(event: string, handler: Function): void;
+    /**
+     * Emits an event.
+     * @param {string} event - event name
+     */
+    emitEvent(event: string, ...args: any[]): void;
+}
+import EventEmitter from "events";

types/auto/JitsiMediaDevicesEvents.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The events for the media devices.
+ */
+/**
+ * Indicates that the list of available media devices has been changed. The
+ * event provides the following parameters to its listeners:
+ *
+ * @param {MediaDeviceInfo[]} devices - array of MediaDeviceInfo or
+ *  MediaDeviceInfo-like objects that are currently connected.
+ *  @see https://developer.mozilla.org/en-US/docs/Web/API/MediaDeviceInfo
+ */
+export const DEVICE_LIST_CHANGED: "mediaDevices.devicechange";
+/**
+ * Event emitted when the user granted/blocked a permission for the camera / mic.
+ * Used to keep track of the granted permissions on browsers which don't
+ * support the Permissions API.
+ */
+export const PERMISSIONS_CHANGED: "rtc.permissions_changed";
+/**
+ * Indicates that the environment is currently showing permission prompt to
+ * access camera and/or microphone. The event provides the following
+ * parameters to its listeners:
+ *
+ * @param {'chrome'|'opera'|'firefox'|'safari'|'nwjs'
+ *  |'react-native'|'android'} environmentType - type of browser or
+ *  other execution environment.
+ */
+export const PERMISSION_PROMPT_IS_SHOWN: "mediaDevices.permissionPromptIsShown";
+export const SLOW_GET_USER_MEDIA: "mediaDevices.slowGetUserMedia";

types/auto/JitsiMeetJS.d.ts

@@ -0,0 +1,2 @@
+declare var _default: any;
+export default _default;

types/auto/JitsiParticipant.d.ts

@@ -0,0 +1,201 @@
+/**
+ * Represents a participant in (i.e. a member of) a conference.
+ */
+export default class JitsiParticipant {
+    /**
+     * Initializes a new JitsiParticipant instance.
+     *
+     * @constructor
+     * @param jid the conference XMPP jid
+     * @param conference
+     * @param displayName
+     * @param {Boolean} hidden - True if the new JitsiParticipant instance is to
+     * represent a hidden participant; otherwise, false.
+     * @param {string} statsID - optional participant statsID
+     * @param {string} status - the initial status if any.
+     * @param {object} identity - the xmpp identity
+     * @param {boolean?} isReplacing - whether this is a participant replacing another into the meeting.
+     * @param {boolean?} isReplaced - whether this is a participant to be kicked and replaced into the meeting.
+     */
+    constructor(jid: any, conference: any, displayName: any, hidden: boolean, statsID: string, status: string, identity: object, isReplacing: boolean | null, isReplaced: boolean | null);
+    _jid: any;
+    _id: any;
+    _conference: any;
+    _displayName: any;
+    _supportsDTMF: boolean;
+    _tracks: any[];
+    _role: string;
+    _status: string;
+    _hidden: boolean;
+    _statsID: string;
+    _connectionStatus: string;
+    _properties: {};
+    _identity: any;
+    _isReplacing: boolean;
+    _isReplaced: boolean;
+    _features: Set<any>;
+    /**
+     * @returns {JitsiConference} The conference that this participant belongs
+     * to.
+     */
+    getConference(): any;
+    /**
+     * Gets the value of a property of this participant.
+     */
+    getProperty(name: any): any;
+    /**
+     * Checks whether this <tt>JitsiParticipant</tt> has any video tracks which
+     * are muted according to their underlying WebRTC <tt>MediaStreamTrack</tt>
+     * muted status.
+     * @return {boolean} <tt>true</tt> if this <tt>participant</tt> contains any
+     * video <tt>JitsiTrack</tt>s which are muted as defined in
+     * {@link JitsiTrack.isWebRTCTrackMuted}.
+     */
+    hasAnyVideoTrackWebRTCMuted(): boolean;
+    /**
+     * Updates participant's connection status.
+     * @param {string} state the current participant connection state.
+     * {@link ParticipantConnectionStatus}.
+     * @private
+     */
+    private _setConnectionStatus;
+    /**
+     * Return participant's connectivity status.
+     *
+     * @returns {string} the connection status
+     * <tt>ParticipantConnectionStatus</tt> of the user.
+     * {@link ParticipantConnectionStatus}.
+     */
+    getConnectionStatus(): string;
+    /**
+     * Sets the value of a property of this participant, and fires an event if
+     * the value has changed.
+     * @name the name of the property.
+     * @value the value to set.
+     */
+    setProperty(name: any, value: any): void;
+    /**
+     * @returns {Array.<JitsiTrack>} The list of media tracks for this
+     * participant.
+     */
+    getTracks(): Array<any>;
+    /**
+     * @param {MediaType} mediaType
+     * @returns {Array.<JitsiTrack>} an array of media tracks for this
+     * participant, for given media type.
+     */
+    getTracksByMediaType(mediaType: typeof MediaType): Array<any>;
+    /**
+     * @returns {String} The ID of this participant.
+     */
+    getId(): string;
+    /**
+     * @returns {String} The JID of this participant.
+     */
+    getJid(): string;
+    /**
+     * @returns {String} The human-readable display name of this participant.
+     */
+    getDisplayName(): string;
+    /**
+     * @returns {String} The stats ID of this participant.
+     */
+    getStatsID(): string;
+    /**
+     * @returns {String} The status of the participant.
+     */
+    getStatus(): string;
+    /**
+     * @returns {Boolean} Whether this participant is a moderator or not.
+     */
+    isModerator(): boolean;
+    /**
+     * @returns {Boolean} Whether this participant is a hidden participant. Some
+     * special system participants may want to join hidden (like for example the
+     * recorder).
+     */
+    isHidden(): boolean;
+    /**
+     * @returns {Boolean} Wheter this participants replaces another participant
+     * from the meeting.
+     */
+    isReplacing(): boolean;
+    /**
+     * @returns {Boolean} Wheter this participants will be replaced by another
+     * participant in the meeting.
+     */
+    isReplaced(): boolean;
+    /**
+     * @returns {Boolean} Whether this participant has muted their audio.
+     */
+    isAudioMuted(): boolean;
+    /**
+     * Determines whether all JitsiTracks which are of a specific MediaType and
+     * which belong to this JitsiParticipant are muted.
+     *
+     * @param {MediaType} mediaType - The MediaType of the JitsiTracks to be
+     * checked.
+     * @private
+     * @returns {Boolean} True if all JitsiTracks which are of the specified
+     * mediaType and which belong to this JitsiParticipant are muted; otherwise,
+     * false.
+     */
+    private _isMediaTypeMuted;
+    /**
+     * @returns {Boolean} Whether this participant has muted their video.
+     */
+    isVideoMuted(): boolean;
+    /**
+     * @returns {String} The role of this participant.
+     */
+    getRole(): string;
+    /**
+     * Sets a new participant role.
+     * @param {String} newRole - the new role.
+     */
+    setRole(newRole: string): void;
+    /**
+     * Sets whether participant is replacing another based on jwt.
+     * @param {String} newIsReplacing - whether is replacing.
+     */
+    setIsReplacing(newIsReplacing: string): void;
+    /**
+     * Sets whether participant is being replaced by another based on jwt.
+     * @param {boolean} newIsReplaced - whether is being replaced.
+     */
+    setIsReplaced(newIsReplaced: boolean): void;
+    /**
+     *
+     */
+    supportsDTMF(): boolean;
+    /**
+     * Returns a set with the features for the participant.
+     * @returns {Promise<Set<String>, Error>}
+     */
+    getFeatures(): Promise<Set<string>, Error>;
+    /**
+     * Checks current set features.
+     * @param {String} feature - the feature to check.
+     * @return {boolean} <tt>true</tt> if this <tt>participant</tt> contains the
+     * <tt>feature</tt>.
+     */
+    hasFeature(feature: string): boolean;
+    /**
+     * Set new features.
+     * @param {Set<String>|undefined} newFeatures - Sets new features.
+     */
+    setFeatures(newFeatures: Set<string> | undefined): void;
+    /**
+     * Returns the bot type for the participant.
+     *
+     * @returns {string|undefined} - The bot type of the participant.
+     */
+    getBotType(): string | undefined;
+    /**
+     * Sets the bot type for the participant.
+     * @param {String} newBotType - The new bot type to set.
+     */
+    setBotType(newBotType: string): void;
+    _botType: string;
+}
+import * as MediaType from "./service/RTC/MediaType";

types/auto/JitsiTrackError.d.ts

@@ -0,0 +1,53 @@
+export default JitsiTrackError;
+/**
+ *
+ * Represents an error that occurred to a JitsiTrack. Can represent various
+ * types of errors. For error descriptions (@see JitsiTrackErrors).
+ *
+ * @extends Error
+ *
+ *
+ * @constructor
+ * @param {Object|string} error - error object or error name
+ * @param {Object|string} (options) - getUserMedia constraints object or
+ * error message
+ * @param {('audio'|'video'|'desktop'|'screen'|'audiooutput')[]} (devices) -
+ * list of getUserMedia requested devices
+ */
+declare function JitsiTrackError(error: any | string, options: any, devices: any): void;
+declare class JitsiTrackError {
+    /**
+     *
+     * Represents an error that occurred to a JitsiTrack. Can represent various
+     * types of errors. For error descriptions (@see JitsiTrackErrors).
+     *
+     * @extends Error
+     *
+     *
+     * @constructor
+     * @param {Object|string} error - error object or error name
+     * @param {Object|string} (options) - getUserMedia constraints object or
+     * error message
+     * @param {('audio'|'video'|'desktop'|'screen'|'audiooutput')[]} (devices) -
+     * list of getUserMedia requested devices
+     */
+    constructor(error: any | string, options: any, devices: any);
+    /**
+     * Additional information about original getUserMedia error
+     * and constraints.
+     * @type {{
+     *     error: Object,
+     *     constraints: Object,
+     *     devices: Array.<'audio'|'video'|'desktop'|'screen'>
+     * }}
+     */
+    gum: {
+        error: any;
+        constraints: any;
+        devices: Array<'audio' | 'video' | 'desktop' | 'screen'>;
+    };
+    name: string;
+    message: any;
+    stack: any;
+    constructor: typeof JitsiTrackError;
+}

types/auto/JitsiTrackErrors.d.ts

@@ -0,0 +1,58 @@
+/**
+ * The errors for the JitsiTrack objects.
+ */
+/**
+ * An error which indicates that some of requested constraints in
+ * getUserMedia call were not satisfied.
+ */
+export const CONSTRAINT_FAILED: "gum.constraint_failed";
+/**
+ * A generic error which indicates an error occurred while selecting
+ * a DesktopCapturerSource from the electron app.
+ */
+export const ELECTRON_DESKTOP_PICKER_ERROR: "gum.electron_desktop_picker_error";
+/**
+ * An error which indicates a custom desktop picker could not be detected
+ * for the electron app.
+ */
+export const ELECTRON_DESKTOP_PICKER_NOT_FOUND: "gum.electron_desktop_picker_not_found";
+/**
+ * Generic getUserMedia error.
+ */
+export const GENERAL: "gum.general";
+/**
+ * An error which indicates that requested device was not found.
+ */
+export const NOT_FOUND: "gum.not_found";
+/**
+ * An error which indicates that user denied permission to share requested
+ * device.
+ */
+export const PERMISSION_DENIED: "gum.permission_denied";
+/**
+ * Generic error for screensharing failure.
+ */
+export const SCREENSHARING_GENERIC_ERROR: "gum.screensharing_generic_error";
+/**
+ * An error which indicates that user canceled screen sharing window
+ * selection dialog.
+ */
+export const SCREENSHARING_USER_CANCELED: "gum.screensharing_user_canceled";
+/**
+ * Indicates that the timeout passed to the obtainAudioAndVideoPermissions has expired without GUM resolving.
+ */
+export const TIMEOUT: "gum.timeout";
+/**
+ * An error which indicates that track has been already disposed and cannot
+ * be longer used.
+ */
+export const TRACK_IS_DISPOSED: "track.track_is_disposed";
+/**
+ * An error which indicates that track has no MediaStream associated.
+ */
+export const TRACK_NO_STREAM_FOUND: "track.no_stream_found";
+/**
+ * An error which indicates that requested video resolution is not supported
+ * by a webcam.
+ */
+export const UNSUPPORTED_RESOLUTION: "gum.unsupported_resolution";

types/auto/JitsiTrackEvents.d.ts

@@ -0,0 +1,39 @@
+/**
+ * The media track was removed to the conference.
+ */
+export const LOCAL_TRACK_STOPPED: "track.stopped";
+/**
+ * Audio levels of a this track was changed.
+ * The first argument is a number with audio level value in range [0, 1].
+ * The second argument is a <tt>TraceablePeerConnection</tt> which is the peer
+ * connection which measured the audio level (one audio track can be added
+ * to multiple peer connection at the same time). This argument is optional for
+ * local tracks for which we can measure audio level without the peer
+ * connection (the value will be <tt>undefined</tt>).
+ *
+ * NOTE The second argument should be treated as library internal and can be
+ * removed at any time.
+ */
+export const TRACK_AUDIO_LEVEL_CHANGED: "track.audioLevelsChanged";
+/**
+ * The audio output of the track was changed.
+ */
+export const TRACK_AUDIO_OUTPUT_CHANGED: "track.audioOutputChanged";
+/**
+ * A media track mute status was changed.
+ */
+export const TRACK_MUTE_CHANGED: "track.trackMuteChanged";
+/**
+ * The video type("camera" or "desktop") of the track was changed.
+ */
+export const TRACK_VIDEOTYPE_CHANGED: "track.videoTypeChanged";
+/**
+ * Indicates that the track is not receiving any data even though we expect it
+ * to receive data (i.e. the stream is not stopped).
+ */
+export const NO_DATA_FROM_SOURCE: "track.no_data_from_source";
+/**
+ * Indicates that the local audio track is not receiving any audio input from
+ * the microphone that is currently selected.
+ */
+export const NO_AUDIO_INPUT: "track.no_audio_input";

types/auto/JitsiTranscriptionStatus.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The transciption is on.
+ *
+ * @type {String}
+ */
+export const ON: string;
+/**
+ * The transciption is off.
+ *
+ * @type {String}
+ */
+export const OFF: string;

types/auto/authenticateAndUpgradeRole.d.ts

@@ -0,0 +1,81 @@
+/**
+ * @typedef {Object} UpgradeRoleError
+ *
+ * @property {JitsiConnectionErrors} [connectionError] - One of
+ * {@link JitsiConnectionErrors} which occurred when trying to connect to the
+ * XMPP server.
+ * @property {String} [authenticationError] - One of XMPP error conditions
+ * returned by Jicofo on authentication attempt. See
+ * {@link https://xmpp.org/rfcs/rfc3920.html#streams-error}.
+ * @property {String} [message] - More details about the error.
+ * @property {Object} [credentials] - The credentials that failed the
+ * authentication.
+ * @property {String} [credentials.jid] - The XMPP ID part of the credentials
+ * that failed the authentication.
+ * @property {string} [credentials.password] - The password part of the
+ * credentials that failed the authentication.
+ *
+ * NOTE If neither one of the errors is present, then the operation has been
+ * canceled.
+ */
+/**
+ * Connects to the XMPP server using the specified credentials and contacts
+ * Jicofo in order to obtain a session ID (which is then stored in the local
+ * storage). The user's role of the parent conference will be upgraded to
+ * moderator (by Jicofo). It's also used to join the conference when starting
+ * from anonymous domain and only authenticated users are allowed to create new
+ * rooms.
+ *
+ * @param {Object} options
+ * @param {string} options.id - XMPP user's ID to log in. For example,
+ * user@xmpp-server.com.
+ * @param {string} options.password - XMPP user's password to log in with.
+ * @param {string} [options.roomPassword] - The password to join the MUC with.
+ * @param {Function} [options.onLoginSuccessful] - Callback called when logging
+ * into the XMPP server was successful. The next step will be to obtain a new
+ * session ID from Jicofo and join the MUC using it which will effectively
+ * upgrade the user's role to moderator.
+ * @returns {Object} A <tt>thenable</tt> which (1) settles when the process of
+ * authenticating and upgrading the role of the specified XMPP user finishes and
+ * (2) has a <tt>cancel</tt> method that allows the caller to interrupt the
+ * process. If the process finishes successfully, the session ID has been stored
+ * in the settings and the <tt>thenable</tt> is resolved. If the process
+ * finishes with failure, the <tt>thenable</tt> is rejected with reason of type
+ * {@link UpgradeRoleError} which will have either <tt>connectionError</tt> or
+ * <tt>authenticationError</tt> property set depending on which of the steps has
+ * failed. If <tt>cancel</tt> is called before the process finishes, then the
+ * thenable will be rejected with an empty object (i.e. no error property will
+ * be set on the rejection reason).
+ */
+export default function authenticateAndUpgradeRole({ id, password, onCreateResource, onLoginSuccessful, roomPassword }: {
+    id: string;
+    password: string;
+    roomPassword?: string;
+    onLoginSuccessful?: Function;
+}): any;
+export type UpgradeRoleError = {
+    /**
+     * - One of
+     * {@link JitsiConnectionErrors } which occurred when trying to connect to the
+     * XMPP server.
+     */
+    connectionError?: any;
+    /**
+     * - One of XMPP error conditions
+     * returned by Jicofo on authentication attempt. See
+     * {@link https ://xmpp.org/rfcs/rfc3920.html#streams-error}.
+     */
+    authenticationError?: string;
+    /**
+     * - More details about the error.
+     */
+    message?: string;
+    /**
+     * - The credentials that failed the
+     * authentication.
+     */
+    credentials?: {
+        jid?: string;
+        password?: string;
+    };
+};

types/auto/connection_optimization/external_connect.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Requests the given webservice that will create the connection and will return
+ * the necessary details(rid, sid and jid) to attach to this connection and
+ * start using it. This script can be used for optimizing the connection startup
+ * time. The function will send AJAX request to a webservice that should
+ * create the bosh session much faster than the client because the webservice
+ * can be started on the same machine as the XMPP serever.
+ *
+ * NOTE: It's vert important to execute this function as early as you can for
+ * optimal results.
+ *
+ * @param webserviceUrl the url for the web service that is going to create the
+ * connection.
+ * @param successCallback callback function called with the result of the AJAX
+ * request if the request was successfull. The callback will receive one
+ * parameter which will be JS Object with properties - rid, sid and jid. This
+ * result should be passed to JitsiConnection.attach method in order to use that
+ * connection.
+ * @param error_callback callback function called the AJAX request fail. This
+ * callback is going to receive one parameter which is going to be JS error
+ * object with a reason for failure in it.
+ */
+declare function createConnectionExternally(webserviceUrl: any, successCallback: any, error_callback: any): void;

types/auto/index.d.ts

@@ -0,0 +1,2 @@
+declare const _exports: any;
+export = _exports;

types/auto/modules/RTC/BridgeChannel.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Handles a WebRTC RTCPeerConnection or a WebSocket instance to communicate
+ * with the videobridge.
+ */
+export default class BridgeChannel {
+    /**
+     * Binds "ondatachannel" event listener on the given RTCPeerConnection
+     * instance, or creates a WebSocket connection with the videobridge.
+     * At least one of both, peerconnection or wsUrl parameters, must be
+     * given.
+     * @param {RTCPeerConnection} [peerconnection] WebRTC peer connection
+     * instance.
+     * @param {string} [wsUrl] WebSocket URL.
+     * @param {EventEmitter} emitter the EventEmitter instance to use for event emission.
+     */
+    constructor(peerconnection?: RTCPeerConnection, wsUrl?: string, emitter: any);
+    _channel: any;
+    _eventEmitter: any;
+    _mode: string;
+    _areRetriesEnabled: boolean;
+    _closedFromClient: boolean;
+    _wsUrl: string;
+    /**
+     * Initializes the web socket channel.
+     *
+     * @returns {void}
+     */
+    _initWebSocket(): void;
+    /**
+     * Starts the websocket connection retries.
+     *
+     * @returns {void}
+     */
+    _startConnectionRetries(): void;
+    _retryTimeout: NodeJS.Timeout;
+    /**
+     * Stops the websocket connection retries.
+     *
+     * @returns {void}
+     */
+    _stopConnectionRetries(): void;
+    /**
+     * Retries to establish the websocket connection after the connection was closed by the server.
+     *
+     * @param {CloseEvent} closeEvent - The close event that triggered the retries.
+     * @returns {void}
+     */
+    _retryWebSocketConnection(closeEvent: CloseEvent): void;
+    /**
+     * The channel mode.
+     * @return {string} "datachannel" or "websocket" (or null if not yet set).
+     */
+    get mode(): string;
+    /**
+     * Closes the currently opened channel.
+     */
+    close(): void;
+    /**
+     * Whether there is an underlying RTCDataChannel or WebSocket and it's
+     * open.
+     * @return {boolean}
+     */
+    isOpen(): boolean;
+    /**
+     * Sends local stats via the bridge channel.
+     * @param {Object} payload The payload of the message.
+     * @throws NetworkError/InvalidStateError/Error if the operation fails or if there is no data channel created.
+     */
+    sendEndpointStatsMessage(payload: any): void;
+    /**
+     * Sends message via the channel.
+     * @param {string} to The id of the endpoint that should receive the
+     * message. If "" the message will be sent to all participants.
+     * @param  {object} payload The payload of the message.
+     * @throws NetworkError or InvalidStateError from RTCDataChannel#send (@see
+     * {@link https://developer.mozilla.org/docs/Web/API/RTCDataChannel/send})
+     * or from WebSocket#send or Error with "No opened channel" message.
+     */
+    sendMessage(to: string, payload: object): void;
+    /**
+     * Sends a "lastN value changed" message via the channel.
+     * @param {number} value The new value for lastN. -1 means unlimited.
+     */
+    sendSetLastNMessage(value: number): void;
+    /**
+     * Sends a "selected endpoints changed" message via the channel.
+     *
+     * @param {Array<string>} endpointIds - The ids of the selected endpoints.
+     * @throws NetworkError or InvalidStateError from RTCDataChannel#send (@see
+     * {@link https://developer.mozilla.org/docs/Web/API/RTCDataChannel/send})
+     * or from WebSocket#send or Error with "No opened channel" message.
+     */
+    sendSelectedEndpointsMessage(endpointIds: Array<string>): void;
+    /**
+     * Sends a "receiver video constraint" message via the channel.
+     * @param {Number} maxFrameHeightPixels the maximum frame height,
+     * in pixels, this receiver is willing to receive
+     */
+    sendReceiverVideoConstraintMessage(maxFrameHeightPixels: number): void;
+    /**
+     * Sends a 'ReceiverVideoConstraints' message via the bridge channel.
+     *
+     * @param {ReceiverVideoConstraints} constraints video constraints.
+     */
+    sendNewReceiverVideoConstraintsMessage(constraints: any): void;
+    /**
+     * Sends a 'VideoTypeMessage' message via the bridge channel.
+     *
+     * @param {string} videoType 'camera', 'desktop' or 'none'.
+     * @deprecated to be replaced with sendSourceVideoTypeMessage
+     */
+    sendVideoTypeMessage(videoType: string): void;
+    /**
+     * Sends a 'VideoTypeMessage' message via the bridge channel.
+     *
+     * @param {BridgeVideoType} videoType - the video type.
+     * @param {SourceName} sourceName - the source name of the video track.
+     * @returns {void}
+     */
+    sendSourceVideoTypeMessage(sourceName: any, videoType: any): void;
+    /**
+     * Set events on the given RTCDataChannel or WebSocket instance.
+     */
+    _handleChannel(channel: any): void;
+    /**
+     * Sends passed object via the channel.
+     * @param {object} jsonObject The object that will be sent.
+     * @throws NetworkError or InvalidStateError from RTCDataChannel#send (@see
+     * {@link https://developer.mozilla.org/docs/Web/API/RTCDataChannel/send})
+     * or from WebSocket#send or Error with "No opened channel" message.
+     */
+    _send(jsonObject: object): void;
+}

types/auto/modules/RTC/CodecSelection.d.ts

@@ -0,0 +1,106 @@
+/**
+ * This class handles the codec selection mechanism for the conference based on the config.js settings.
+ * The preferred codec is selected based on the settings and the list of codecs supported by the browser.
+ * The preferred codec is published in presence which is then used by the other endpoints in the
+ * conference to pick a supported codec at join time and when the call transitions between p2p and jvb
+ * connections.
+ */
+export class CodecSelection {
+    /**
+     * Creates a new instance for a given conference.
+     *
+     * @param {JitsiConference} conference the conference instance
+     * @param {*} options
+     * @param {string} options.disabledCodec the codec that needs to be disabled.
+     * @param {boolean} options.enforcePreferredCodec whether codec preference has to be
+     * enforced even when an endpoints that doesn't support the preferred codec joins the call.
+     * Falling back to the standard codec will be skipped when this option is true, endpoints
+     * that do not support the preferred codec may not be able to encode/decode video when this happens.
+     * @param {string} options.jvbCodec the codec that is preferred on jvb connection.
+     * @param {string} options.p2pCodec the codec that is preferred on p2p connection.
+     */
+    constructor(conference: any, options: any);
+    conference: any;
+    options: any;
+    disabledCodec: {
+        H264: string;
+        OPUS: string;
+        ULPFEC: string;
+        VP8: string;
+        VP9: string;
+    };
+    jvbPreferredCodec: string | {
+        H264: string;
+        OPUS: string;
+        ULPFEC: string;
+        VP8: string;
+        VP9: string;
+    };
+    p2pPreferredCodec: string | {
+        H264: string;
+        OPUS: string;
+        ULPFEC: string;
+        VP8: string;
+        VP9: string;
+    };
+    /**
+     * Checks if a given string is a valid video codec mime type.
+     *
+     * @param {string} codec the codec string that needs to be validated.
+     * @returns {CodecMimeType|null} mime type if valid, null otherwise.
+     * @private
+     */
+    private _getCodecMimeType;
+    /**
+     * Checks if the given codec is supported by the browser.
+     *
+     * @param {CodecMimeType} preferredCodec codec to be checked.
+     * @returns {boolean} true if the given codec is supported, false otherwise.
+     * @private
+     */
+    private _isCodecSupported;
+    /**
+     * Handles the {@link JitsiConferenceEvents._MEDIA_SESSION_STARTED} event. Codecs need to be
+     * configured on the media session that is newly created.
+     *
+     * @param {JingleSessionPC} mediaSession media session that started.
+     * @returns {void}
+     * @private
+     */
+    private _onMediaSessionStarted;
+    /**
+     * Sets the codec on the media session based on the preferred codec setting and the supported codecs
+     * published by the remote participants in their presence.
+     *
+     * @param {JingleSessionPC} mediaSession session for which the codec selection has to be made.
+     * @param {CodecMimeType} preferredCodec preferred codec.
+     * @param {CodecMimeType} disabledCodec codec that needs to be disabled.
+     */
+    _selectPreferredCodec(mediaSession?: any, preferredCodec?: {
+        H264: string;
+        OPUS: string;
+        ULPFEC: string;
+        VP8: string;
+        VP9: string;
+    }, disabledCodec?: {
+        H264: string;
+        OPUS: string;
+        ULPFEC: string;
+        VP8: string;
+        VP9: string;
+    }): void;
+    /**
+     * Returns the preferred codec for the conference. The preferred codec for the JVB media session
+     * is the one that gets published in presence and a comparision is made whenever a participant joins
+     * or leaves the call.
+     *
+     * @returns {CodecMimeType} preferred codec.
+     */
+    getPreferredCodec(): {
+        H264: string;
+        OPUS: string;
+        ULPFEC: string;
+        VP8: string;
+        VP9: string;
+    };
+}

types/auto/modules/RTC/JitsiLocalTrack.d.ts

@@ -0,0 +1,295 @@
+/**
+ * Represents a single media track(either audio or video).
+ * One <tt>JitsiLocalTrack</tt> corresponds to one WebRTC MediaStreamTrack.
+ */
+export default class JitsiLocalTrack extends JitsiTrack {
+    /**
+     * Constructs a new JitsiLocalTrack instance.
+     *
+     * @constructor
+     * @param {Object} trackInfo
+     * @param {number} trackInfo.rtcId - The ID assigned by the RTC module.
+     * @param {Object} trackInfo.stream - The WebRTC MediaStream, parent of the track.
+     * @param {Object} trackInfo.track - The underlying WebRTC MediaStreamTrack for new JitsiLocalTrack.
+     * @param {string} trackInfo.mediaType - The MediaType of the JitsiLocalTrack.
+     * @param {string} trackInfo.videoType - The VideoType of the JitsiLocalTrack.
+     * @param {Array<Object>} trackInfo.effects - The effects to be applied to the JitsiLocalTrack.
+     * @param {number} trackInfo.resolution - The the video resolution if it's a video track
+     * @param {string} trackInfo.deviceId - The ID of the local device for this track.
+     * @param {string} trackInfo.facingMode - Thehe camera facing mode used in getUserMedia call (for mobile only).
+     * @param {sourceId} trackInfo.sourceId - The id of the desktop sharing source. NOTE: defined for desktop sharing
+     * tracks only.
+     */
+    constructor({ deviceId, facingMode, mediaType, resolution, rtcId, sourceId, sourceType, stream, track, videoType, effects }: {
+        rtcId: number;
+        stream: any;
+        track: any;
+        mediaType: string;
+        videoType: string;
+        effects: Array<any>;
+        resolution: number;
+        deviceId: string;
+        facingMode: string;
+        sourceId: any;
+    });
+    _setEffectInProgress: boolean;
+    /**
+     * Track metadata.
+     */
+    metadata: {
+        displaySurface?: any;
+        timestamp: number;
+    };
+    /**
+     * The ID assigned by the RTC module on instance creation.
+     *
+     * @type {number}
+     */
+    rtcId: number;
+    sourceId: any;
+    sourceType: any;
+    resolution: any;
+    maxEnabledResolution: number;
+    _constraints: any;
+    deviceId: string;
+    /**
+     * The <tt>Promise</tt> which represents the progress of a previously
+     * queued/scheduled {@link _setMuted} (from the point of view of
+     * {@link _queueSetMuted}).
+     *
+     * @private
+     * @type {Promise}
+     */
+    private _prevSetMuted;
+    /**
+     * The facing mode of the camera from which this JitsiLocalTrack
+     * instance was obtained.
+     *
+     * @private
+     * @type {CameraFacingMode|undefined}
+     */
+    private _facingMode;
+    _trackEnded: boolean;
+    /**
+     * Indicates whether data has been sent or not.
+     */
+    _hasSentData: boolean;
+    /**
+     * Used only for detection of audio problems. We want to check only once
+     * whether the track is sending data ot not. This flag is set to false
+     * after the check.
+     */
+    _testDataSent: boolean;
+    _realDeviceId: string;
+    _trackMutedTS: number;
+    _onDeviceListWillChange: (devices: any) => void;
+    _onAudioOutputDeviceChanged: any;
+    /**
+     * Adds stream to conference and marks it as "unmute" operation.
+     *
+     * @private
+     * @returns {Promise}
+     */
+    private _addStreamToConferenceAsUnmute;
+    /**
+     * Fires NO_DATA_FROM_SOURCE event and logs it to analytics and callstats.
+     *
+     * @private
+     * @returns {void}
+     */
+    private _fireNoDataFromSourceEvent;
+    /**
+     * Sets handlers to the MediaStreamTrack object that will detect camera issues.
+     *
+     * @private
+     * @returns {void}
+     */
+    private _initNoDataFromSourceHandlers;
+    /**
+     * Returns true if no data from source events are enabled for this JitsiLocalTrack and false otherwise.
+     *
+     * @private
+     * @returns {boolean} - True if no data from source events are enabled for this JitsiLocalTrack and false otherwise.
+     */
+    private _isNoDataFromSourceEventsEnabled;
+    /**
+     * Initializes a new Promise to execute {@link #_setMuted}. May be called multiple times in a row and the
+     * invocations of {@link #_setMuted} and, consequently, {@link #mute} and/or {@link #unmute} will be resolved in a
+     * serialized fashion.
+     *
+     * @param {boolean} muted - The value to invoke <tt>_setMuted</tt> with.
+     * @private
+     * @returns {Promise}
+     */
+    private _queueSetMuted;
+    /**
+     * Removes stream from conference and marks it as "mute" operation.
+     *
+     * @param {Function} successCallback - Callback that will be called when the operation is successful.
+     * @param {Function} errorCallback - Callback that will be called when the operation fails.
+     * @private
+     * @returns {Promise}
+     */
+    private _removeStreamFromConferenceAsMute;
+    /**
+     * Sends mute status for a track to conference if any.
+     *
+     * @param {boolean} mute - If track is muted.
+     * @private
+     * @returns {void}
+     */
+    private _sendMuteStatus;
+    /**
+     * Mutes / unmutes this track.
+     *
+     * @param {boolean} muted - If <tt>true</tt>, this track will be muted; otherwise, this track will be unmuted.
+     * @private
+     * @returns {Promise}
+     */
+    private _setMuted;
+    /**
+     * Sets real device ID by comparing track information with device information. This is temporary solution until
+     * getConstraints() method will be implemented in browsers.
+     *
+     * @param {MediaDeviceInfo[]} devices - The list of devices obtained from enumerateDevices() call.
+     * @private
+     * @returns {void}
+     */
+    private _setRealDeviceIdFromDeviceList;
+    storedMSID: string;
+    /**
+     * Starts the effect process and returns the modified stream.
+     *
+     * @param {Object} effect - Represents effect instance
+     * @private
+     * @returns {void}
+     */
+    private _startStreamEffect;
+    _streamEffect: any;
+    _originalStream: any;
+    /**
+     * Stops the effect process and returns the original stream.
+     *
+     * @private
+     * @returns {void}
+     */
+    private _stopStreamEffect;
+    /**
+     * Switches the camera facing mode if the WebRTC implementation supports the custom MediaStreamTrack._switchCamera
+     * method. Currently, the method in question is implemented in react-native-webrtc only. When such a WebRTC
+     * implementation is executing, the method is the preferred way to switch between the front/user-facing and the
+     * back/environment-facing cameras because it will likely be (as is the case of react-native-webrtc) noticeably
+     * faster that creating a new MediaStreamTrack via a new getUserMedia call with the switched facingMode constraint
+     * value. Moreover, the approach with a new getUserMedia call may not even work: WebRTC on Android and iOS is
+     * either very slow to open the camera a second time or plainly freezes attempting to do that.
+     *
+     * @returns {void}
+     */
+    _switchCamera(): void;
+    /**
+     * Stops the currently used effect (if there is one) and starts the passed effect (if there is one).
+     *
+     * @param {Object|undefined} effect - The new effect to be set.
+     * @private
+     * @returns {void}
+     */
+    private _switchStreamEffect;
+    /**
+     * Returns facing mode for video track from camera. For other cases (e.g. audio track or 'desktop' video track)
+     * returns undefined.
+     *
+     * @returns {CameraFacingMode|undefined}
+     */
+    getCameraFacingMode(): CameraFacingMode | undefined;
+    /**
+     * Returns device id associated with track.
+     *
+     * @returns {string}
+     */
+    getDeviceId(): string;
+    /**
+     * Get the duration of the track.
+     *
+     * @returns {Number} the duration of the track in seconds
+     */
+    getDuration(): number;
+    /**
+     * Returns the participant id which owns the track.
+     *
+     * @returns {string} the id of the participants. It corresponds to the
+     * Colibri endpoint id/MUC nickname in case of Jitsi-meet.
+     */
+    getParticipantId(): string;
+    /**
+     * Returns if associated MediaStreamTrack is in the 'ended' state
+     *
+     * @returns {boolean}
+     */
+    isEnded(): boolean;
+    /**
+     * Returns <tt>true</tt> - if the stream is muted and <tt>false</tt> otherwise.
+     *
+     * @returns {boolean} <tt>true</tt> - if the stream is muted and <tt>false</tt> otherwise.
+     */
+    isMuted(): boolean;
+    /**
+     * Checks whether the attached MediaStream is receiving data from source or not. If the stream property is null
+     * (because of mute or another reason) this method will return false.
+     * NOTE: This method doesn't indicate problem with the streams directly. For example in case of video mute the
+     * method will return false or if the user has disposed the track.
+     *
+     * @returns {boolean} true if the stream is receiving data and false this otherwise.
+     */
+    isReceivingData(): boolean;
+    /**
+     * Asynchronously mutes this track.
+     *
+     * @returns {Promise}
+     */
+    mute(): Promise<any>;
+    /**
+     * Handles bytes sent statistics. NOTE: used only for audio tracks to detect audio issues.
+     *
+     * @param {TraceablePeerConnection} tpc - The peerconnection that is reporting the bytes sent stat.
+     * @param {number} bytesSent - The new value.
+     * @returns {void}
+     */
+    onByteSentStatsReceived(tpc: any, bytesSent: number): void;
+    /**
+     * Sets the JitsiConference object associated with the track. This is temp solution.
+     *
+     * @param conference - JitsiConference object.
+     * @returns {void}
+     */
+    setConference(conference: any): void;
+    /**
+     * Sets the effect and switches between the modified stream and original one.
+     *
+     * @param {Object} effect - Represents the effect instance to be used.
+     * @returns {Promise}
+     */
+    setEffect(effect: any): Promise<any>;
+    /**
+     * Stops the associated MediaStream.
+     *
+     * @returns {void}
+     */
+    stopStream(): void;
+    /**
+     * Indicates that we are executing {@link #stopStream} i.e.
+     * {@link RTCUtils#stopMediaStream} for the <tt>MediaStream</tt>
+     * associated with this <tt>JitsiTrack</tt> instance.
+     *
+     * @private
+     * @type {boolean}
+     */
+    private _stopStreamInProgress;
+    /**
+     * Asynchronously unmutes this track.
+     *
+     * @returns {Promise}
+     */
+    unmute(): Promise<any>;
+}
+import JitsiTrack from "./JitsiTrack";
+import CameraFacingMode from "../../service/RTC/CameraFacingMode";

types/auto/modules/RTC/JitsiRemoteTrack.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Represents a single media track (either audio or video).
+ */
+export default class JitsiRemoteTrack extends JitsiTrack {
+    /**
+     * Creates new JitsiRemoteTrack instance.
+     * @param {RTC} rtc the RTC service instance.
+     * @param {JitsiConference} conference the conference to which this track
+     *        belongs to
+     * @param {string} ownerEndpointId the endpoint ID of the track owner
+     * @param {MediaStream} stream WebRTC MediaStream, parent of the track
+     * @param {MediaStreamTrack} track underlying WebRTC MediaStreamTrack for
+     *        the new JitsiRemoteTrack
+     * @param {MediaType} mediaType the type of the media
+     * @param {VideoType} videoType the type of the video if applicable
+     * @param {number} ssrc the SSRC number of the Media Stream
+     * @param {boolean} muted the initial muted state
+     * @param {boolean} isP2P indicates whether or not this track belongs to a
+     * P2P session
+     * @param {String} sourceName the source name signaled for the track
+     * @throws {TypeError} if <tt>ssrc</tt> is not a number.
+     * @constructor
+     */
+    constructor(rtc: any, conference: any, ownerEndpointId: string, stream: MediaStream, track: MediaStreamTrack, mediaType: any, videoType: any, ssrc: number, muted: boolean, isP2P: boolean, sourceName: string);
+    rtc: any;
+    ssrc: number;
+    ownerEndpointId: string;
+    muted: boolean;
+    isP2P: boolean;
+    _sourceName: string;
+    hasBeenMuted: boolean;
+    _containerHandlers: {};
+    /**
+     * Attaches the track handlers.
+     *
+     * @returns {void}
+     */
+    _bindTrackHandlers(): void;
+    /**
+     * Callback invoked when the track is muted. Emits an event notifying
+     * listeners of the mute event.
+     *
+     * @private
+     * @returns {void}
+     */
+    private _onTrackMute;
+    /**
+     * Callback invoked when the track is unmuted. Emits an event notifying
+     * listeners of the mute event.
+     *
+     * @private
+     * @returns {void}
+     */
+    private _onTrackUnmute;
+    /**
+     * Sets current muted status and fires an events for the change.
+     * @param value the muted status.
+     */
+    setMute(value: any): void;
+    /**
+     * Returns the current muted status of the track.
+     * @returns {boolean|*|JitsiRemoteTrack.muted} <tt>true</tt> if the track is
+     * muted and <tt>false</tt> otherwise.
+     */
+    isMuted(): boolean | any | any;
+    /**
+     * Returns the participant id which owns the track.
+     *
+     * @returns {string} the id of the participants. It corresponds to the
+     * Colibri endpoint id/MUC nickname in case of Jitsi-meet.
+     */
+    getParticipantId(): string;
+    /**
+     * Returns the synchronization source identifier (SSRC) of this remote
+     * track.
+     *
+     * @returns {number} the SSRC of this remote track.
+     */
+    getSSRC(): number;
+    /**
+     * Returns the tracks source name
+     *
+     * @returns {string} the track's source name
+     */
+    getSourceName(): string;
+    /**
+     * Changes the video type of the track.
+     *
+     * @param {string} type - The new video type("camera", "desktop").
+     */
+    _setVideoType(type: string): void;
+    /**
+     * Handles track play events.
+     */
+    _playCallback(): void;
+    /**
+     * An event handler for events triggered by the attached container.
+     *
+     * @param {string} type - The type of the event.
+     */
+    _containerEventHandler(type: string): void;
+    /**
+     * Returns a string with a description of the current status of the track.
+     *
+     * @returns {string}
+     */
+    _getStatus(): string;
+}
+import JitsiTrack from "./JitsiTrack";

types/auto/modules/RTC/JitsiTrack.d.ts

@@ -0,0 +1,240 @@
+/// <reference types="node" />
+/**
+ * Represents a single media track (either audio or video).
+ */
+export default class JitsiTrack extends EventEmitter {
+    /**
+     * Represents a single media track (either audio or video).
+     * @constructor
+     * @param conference the rtc instance
+     * @param stream the WebRTC MediaStream instance
+     * @param track the WebRTC MediaStreamTrack instance, must be part of
+     * the given <tt>stream</tt>.
+     * @param streamInactiveHandler the function that will handle
+     *        onended/oninactive events of the stream.
+     * @param trackMediaType the media type of the JitsiTrack
+     * @param videoType the VideoType for this track if any
+     */
+    constructor(conference: any, stream: any, track: any, streamInactiveHandler: any, trackMediaType: any, videoType: any);
+    addEventListener: (eventName: string | symbol, listener: (...args: any[]) => void) => JitsiTrack;
+    removeEventListener: (eventName: string | symbol, listener: (...args: any[]) => void) => JitsiTrack;
+    /**
+     * Array with the HTML elements that are displaying the streams.
+     * @type {Array}
+     */
+    containers: any[];
+    conference: any;
+    audioLevel: number;
+    type: any;
+    track: any;
+    videoType: any;
+    handlers: Map<any, any>;
+    /**
+     * Indicates whether this JitsiTrack has been disposed. If true, this
+     * JitsiTrack is to be considered unusable and operations involving it
+     * are to fail (e.g. {@link JitsiConference#addTrack(JitsiTrack)},
+     * {@link JitsiConference#removeTrack(JitsiTrack)}).
+     * @type {boolean}
+     */
+    disposed: boolean;
+    /**
+     * The inactive handler which will be triggered when the underlying
+     * <tt>MediaStream</tt> ends.
+     *
+     * @private
+     * @type {Function}
+     */
+    private _streamInactiveHandler;
+    /**
+     * Adds onended/oninactive handler to a MediaStream or a MediaStreamTrack.
+     * Firefox doesn't fire a inactive event on the MediaStream, instead it fires
+     * a onended event on the MediaStreamTrack.
+     * @param {Function} handler the handler
+     */
+    _addMediaStreamInactiveHandler(handler: Function): void;
+    /**
+     * Sets handler to the WebRTC MediaStream or MediaStreamTrack object
+     * depending on the passed type.
+     * @param {string} type the type of the handler that is going to be set
+     * @param {Function} handler the handler.
+     */
+    _setHandler(type: string, handler: Function): void;
+    /**
+     * Unregisters all event handlers bound to the underlying media stream/track
+     * @private
+     */
+    private _unregisterHandlers;
+    /**
+     * Sets the stream property of JitsiTrack object and sets all stored
+     * handlers to it.
+     *
+     * @param {MediaStream} stream the new stream.
+     * @protected
+     */
+    protected _setStream(stream: MediaStream): void;
+    stream: any;
+    /**
+     * Returns the video type (camera or desktop) of this track.
+     */
+    getVideoType(): any;
+    /**
+     * Returns the type (audio or video) of this track.
+     */
+    getType(): any;
+    /**
+     * Check if this is an audio track.
+     */
+    isAudioTrack(): boolean;
+    /**
+     * Checks whether the underlying WebRTC <tt>MediaStreamTrack</tt> is muted
+     * according to it's 'muted' field status.
+     * @return {boolean} <tt>true</tt> if the underlying
+     * <tt>MediaStreamTrack</tt> is muted or <tt>false</tt> otherwise.
+     */
+    isWebRTCTrackMuted(): boolean;
+    /**
+     * Check if this is a video track.
+     */
+    isVideoTrack(): boolean;
+    /**
+     * Checks whether this is a local track.
+     * @abstract
+     * @return {boolean} 'true' if it's a local track or 'false' otherwise.
+     */
+    isLocal(): boolean;
+    /**
+     * Check whether this is a local audio track.
+     *
+     * @return {boolean} -  true if track represents a local audio track, false otherwise.
+     */
+    isLocalAudioTrack(): boolean;
+    /**
+     * Returns the WebRTC MediaStream instance.
+     */
+    getOriginalStream(): any;
+    /**
+     * Returns the ID of the underlying WebRTC Media Stream(if any)
+     * @returns {String|null}
+     */
+    getStreamId(): string | null;
+    /**
+     * Return the underlying WebRTC MediaStreamTrack
+     * @returns {MediaStreamTrack}
+     */
+    getTrack(): MediaStreamTrack;
+    /**
+     * Return the underlying WebRTC MediaStreamTrack label
+     * @returns {string}
+     */
+    getTrackLabel(): string;
+    /**
+     * Returns the ID of the underlying WebRTC MediaStreamTrack(if any)
+     * @returns {String|null}
+     */
+    getTrackId(): string | null;
+    /**
+     * Return meaningful usage label for this track depending on it's media and
+     * eventual video type.
+     * @returns {string}
+     */
+    getUsageLabel(): string;
+    /**
+     * Eventually will trigger RTCEvents.TRACK_ATTACHED event.
+     * @param container the video/audio container to which this stream is
+     *        attached and for which event will be fired.
+     * @private
+     */
+    private _maybeFireTrackAttached;
+    /**
+     * Attaches the MediaStream of this track to an HTML container.
+     * Adds the container to the list of containers that are displaying the
+     * track.
+     *
+     * @param container the HTML container which can be 'video' or 'audio'
+     * element.
+     *
+     * @returns {void}
+     */
+    attach(container: any): void;
+    /**
+     * Removes this JitsiTrack from the passed HTML container.
+     *
+     * @param container the HTML container to detach from this JitsiTrack. If
+     * <tt>null</tt> or <tt>undefined</tt>, all containers are removed. A
+     * container can be a 'video', 'audio' or 'object' HTML element instance to
+     * which this JitsiTrack is currently attached.
+     */
+    detach(container: any): void;
+    /**
+     * Called when the track has been attached to a new container.
+     *
+     * @param {HTMLElement} container the HTML container which can be 'video' or
+     * 'audio' element.
+     * @private
+     */
+    private _onTrackAttach;
+    /**
+     * Called when the track has been detached from a container.
+     *
+     * @param {HTMLElement} container the HTML container which can be 'video' or
+     * 'audio' element.
+     * @private
+     */
+    private _onTrackDetach;
+    /**
+     * Attach time to first media tracker only if there is conference and only
+     * for the first element.
+     *
+     * @param {HTMLElement} container the HTML container which can be 'video' or
+     * 'audio' element.
+     * @private
+     */
+    private _attachTTFMTracker;
+    /**
+     * Removes attached event listeners.
+     *
+     * @returns {Promise}
+     */
+    dispose(): Promise<any>;
+    /**
+     * Returns true if this is a video track and the source of the video is a
+     * screen capture as opposed to a camera.
+     */
+    isScreenSharing(): void;
+    /**
+     * Returns id of the track.
+     * @returns {string|null} id of the track or null if this is fake track.
+     */
+    getId(): string | null;
+    /**
+     * Checks whether the MediaStream is active/not ended.
+     * When there is no check for active we don't have information and so
+     * will return that stream is active (in case of FF).
+     * @returns {boolean} whether MediaStream is active.
+     */
+    isActive(): boolean;
+    /**
+     * Sets the audio level for the stream
+     * @param {number} audioLevel value between 0 and 1
+     * @param {TraceablePeerConnection} [tpc] the peerconnection instance which
+     * is source for the audio level. It can be <tt>undefined</tt> for
+     * a local track if the audio level was measured outside of the
+     * peerconnection (see /modules/statistics/LocalStatsCollector.js).
+     */
+    setAudioLevel(audioLevel: number, tpc?: any): void;
+    /**
+     * Returns the msid of the stream attached to the JitsiTrack object or null
+     * if no stream is attached.
+     */
+    getMSID(): string;
+    /**
+     * Sets new audio output device for track's DOM elements. Video tracks are
+     * ignored.
+     * @param {string} audioOutputDeviceId - id of 'audiooutput' device from
+     *      navigator.mediaDevices.enumerateDevices(), '' for default device
+     * @emits JitsiTrackEvents.TRACK_AUDIO_OUTPUT_CHANGED
+     * @returns {Promise}
+     */
+    setAudioOutput(audioOutputDeviceId: string): Promise<any>;
+}
+import EventEmitter from "events";

types/auto/modules/RTC/MockClasses.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Mock {@link TraceablePeerConnection} - add things as needed, but only things useful for all tests.
+ */
+export class MockPeerConnection {
+    /**
+     * Constructor.
+     *
+     * @param {string} id RTC id
+     * @param {boolean} usesUnifiedPlan
+     */
+    constructor(id: string, usesUnifiedPlan: boolean);
+    id: string;
+    _usesUnifiedPlan: boolean;
+    /**
+     * {@link TraceablePeerConnection.localDescription}.
+     *
+     * @returns {Object}
+     */
+    get localDescription(): any;
+    /**
+     * {@link TraceablePeerConnection.remoteDescription}.
+     *
+     * @returns {Object}
+     */
+    get remoteDescription(): any;
+    /**
+     * {@link TraceablePeerConnection.createAnswer}.
+     *
+     * @returns {Promise<Object>}
+     */
+    createAnswer(): Promise<any>;
+    /**
+     * {@link TraceablePeerConnection.setLocalDescription}.
+     *
+     * @returns {Promise<void>}
+     */
+    setLocalDescription(): Promise<void>;
+    /**
+     * {@link TraceablePeerConnection.setRemoteDescription}.
+     *
+     * @returns {Promise<void>}
+     */
+    setRemoteDescription(): Promise<void>;
+    /**
+     * {@link TraceablePeerConnection.setSenderVideoConstraints}.
+     */
+    setSenderVideoConstraints(): void;
+    /**
+     * {@link TraceablePeerConnection.setVideoTransferActive}.
+     */
+    setVideoTransferActive(): boolean;
+    /**
+     * {@link TraceablePeerConnection.usesUnifiedPlan}.
+     */
+    usesUnifiedPlan(): boolean;
+}
+/**
+ * Mock {@link RTC} - add things as needed, but only things useful for all tests.
+ */
+export class MockRTC {
+    /**
+     * {@link RTC.createPeerConnection}.
+     *
+     * @returns {MockPeerConnection}
+     */
+    createPeerConnection(): MockPeerConnection;
+    pc: MockPeerConnection;
+}

types/auto/modules/RTC/RTC.d.ts

@@ -0,0 +1,435 @@
+/**
+ *
+ */
+export default class RTC extends Listenable {
+    /**
+     * Exposes the private helper for converting a WebRTC MediaStream to a
+     * JitsiLocalTrack.
+     *
+     * @param {Array<Object>} tracksInfo
+     * @returns {Array<JitsiLocalTrack>}
+     */
+    static createLocalTracks(tracksInfo: Array<any>): Array<JitsiLocalTrack>;
+    /**
+     * Creates the local MediaStreams.
+     * @param {object} [options] Optional parameters.
+     * @param {array} options.devices The devices that will be requested.
+     * @param {string} options.resolution Resolution constraints.
+     * @param {string} options.cameraDeviceId
+     * @param {string} options.micDeviceId
+     * @returns {*} Promise object that will receive the new JitsiTracks
+     */
+    static obtainAudioAndVideoPermissions(options?: {
+        devices: any[];
+        resolution: string;
+        cameraDeviceId: string;
+        micDeviceId: string;
+    }): any;
+    /**
+     *
+     * @param eventType
+     * @param listener
+     */
+    static addListener(eventType: any, listener: any): void;
+    /**
+     *
+     * @param eventType
+     * @param listener
+     */
+    static removeListener(eventType: any, listener: any): void;
+    /**
+     *
+     * @param options
+     */
+    static init(options?: {}): void;
+    /**
+     *
+     * @param elSelector
+     * @param stream
+     */
+    static attachMediaStream(elSelector: any, stream: any): any;
+    /**
+     * Returns the id of the given stream.
+     * @param {MediaStream} stream
+     */
+    static getStreamID(stream: MediaStream): any;
+    /**
+     * Returns the id of the given track.
+     * @param {MediaStreamTrack} track
+     */
+    static getTrackID(track: MediaStreamTrack): any;
+    /**
+     * Returns true if retrieving the list of input devices is supported
+     * and false if not.
+     */
+    static isDeviceListAvailable(): boolean;
+    /**
+     * Returns true if changing the input (camera / microphone) or output
+     * (audio) device is supported and false if not.
+     * @param {string} [deviceType] Type of device to change. Default is
+     *      undefined or 'input', 'output' - for audio output device change.
+     * @returns {boolean} true if available, false otherwise.
+     */
+    static isDeviceChangeAvailable(deviceType?: string): boolean;
+    /**
+     * Returns whether the current execution environment supports WebRTC (for
+     * use within this library).
+     *
+     * @returns {boolean} {@code true} if WebRTC is supported in the current
+     * execution environment (for use within this library); {@code false},
+     * otherwise.
+     */
+    static isWebRtcSupported(): boolean;
+    /**
+     * Returns currently used audio output device id, '' stands for default
+     * device
+     * @returns {string}
+     */
+    static getAudioOutputDevice(): string;
+    /**
+     * Returns list of available media devices if its obtained, otherwise an
+     * empty array is returned/
+     * @returns {array} list of available media devices.
+     */
+    static getCurrentlyAvailableMediaDevices(): any[];
+    /**
+     * Returns whether available devices have permissions granted
+     * @returns {Boolean}
+     */
+    static arePermissionsGrantedForAvailableDevices(): boolean;
+    /**
+     * Returns event data for device to be reported to stats.
+     * @returns {MediaDeviceInfo} device.
+     */
+    static getEventDataForActiveDevice(device: any): MediaDeviceInfo;
+    /**
+     * Sets current audio output device.
+     * @param {string} deviceId Id of 'audiooutput' device from
+     *      navigator.mediaDevices.enumerateDevices().
+     * @returns {Promise} resolves when audio output is changed, is rejected
+     *      otherwise
+     */
+    static setAudioOutputDevice(deviceId: string): Promise<any>;
+    /**
+     * Returns <tt>true<tt/> if given WebRTC MediaStream is considered a valid
+     * "user" stream which means that it's not a "receive only" stream nor a
+     * "mixed" JVB stream.
+     *
+     * Clients that implement Unified Plan, such as Firefox use recvonly
+     * "streams/channels/tracks" for receiving remote stream/tracks, as opposed
+     * to Plan B where there are only 3 channels: audio, video and data.
+     *
+     * @param {MediaStream} stream The WebRTC MediaStream instance.
+     * @returns {boolean}
+     */
+    static isUserStream(stream: MediaStream): boolean;
+    /**
+     * Returns <tt>true<tt/> if a WebRTC MediaStream identified by given stream
+     * ID is considered a valid "user" stream which means that it's not a
+     * "receive only" stream nor a "mixed" JVB stream.
+     *
+     * Clients that implement Unified Plan, such as Firefox use recvonly
+     * "streams/channels/tracks" for receiving remote stream/tracks, as opposed
+     * to Plan B where there are only 3 channels: audio, video and data.
+     *
+     * @param {string} streamId The id of WebRTC MediaStream.
+     * @returns {boolean}
+     */
+    static isUserStreamById(streamId: string): boolean;
+    /**
+     * Allows to receive list of available cameras/microphones.
+     * @param {function} callback Would receive array of devices as an
+     *      argument.
+     */
+    static enumerateDevices(callback: Function): void;
+    /**
+     * A method to handle stopping of the stream.
+     * One point to handle the differences in various implementations.
+     * @param {MediaStream} mediaStream MediaStream object to stop.
+     */
+    static stopMediaStream(mediaStream: MediaStream): void;
+    /**
+     * Returns whether the desktop sharing is enabled or not.
+     * @returns {boolean}
+     */
+    static isDesktopSharingEnabled(): boolean;
+    /**
+     *
+     * @param conference
+     * @param options
+     */
+    constructor(conference: any, options?: {});
+    conference: any;
+    /**
+     * A map of active <tt>TraceablePeerConnection</tt>.
+     * @type {Map.<number, TraceablePeerConnection>}
+     */
+    peerConnections: Map<number, TraceablePeerConnection>;
+    localTracks: any[];
+    options: {};
+    _channel: BridgeChannel;
+    /**
+     * The value specified to the last invocation of setLastN before the
+     * channel completed opening. If non-null, the value will be sent
+     * through a channel (once) as soon as it opens and will then be
+     * discarded.
+     * @private
+     * @type {number}
+     */
+    private _lastN;
+    /**
+     * Defines the last N endpoints list. It can be null or an array once
+     * initialised with a channel last N event.
+     * @type {Array<string>|null}
+     * @private
+     */
+    private _lastNEndpoints;
+    /**
+     * The number representing the maximum video height the local client
+     * should receive from the bridge.
+     *
+     * @type {number|undefined}
+     * @private
+     */
+    private _maxFrameHeight;
+    /**
+     * The endpoint IDs of currently selected participants.
+     *
+     * @type {Array}
+     * @private
+     */
+    private _selectedEndpoints;
+    _lastNChangeListener: any;
+    /**
+     * Callback invoked when the list of known audio and video devices has
+     * been updated. Attempts to update the known available audio output
+     * devices.
+     *
+     * @private
+     * @returns {void}
+     */
+    private _onDeviceListChanged;
+    /**
+     * Updates the target audio output device for all remote audio tracks.
+     *
+     * @param {string} deviceId - The device id of the audio ouput device to
+     * use for all remote tracks.
+     * @private
+     * @returns {void}
+     */
+    private _updateAudioOutputForAudioTracks;
+    /**
+     * The default video type assumed by the bridge.
+     * @deprecated this will go away with multiple streams support
+     * @type {BridgeVideoType}
+     * @private
+     */
+    private _videoType;
+    /**
+     * Removes any listeners and stored state from this {@code RTC} instance.
+     *
+     * @returns {void}
+     */
+    destroy(): void;
+    /**
+     * Initializes the bridge channel of this instance.
+     * At least one of both, peerconnection or wsUrl parameters, must be
+     * given.
+     * @param {RTCPeerConnection} [peerconnection] WebRTC peer connection
+     * instance.
+     * @param {string} [wsUrl] WebSocket URL.
+     */
+    initializeBridgeChannel(peerconnection?: RTCPeerConnection, wsUrl?: string): void;
+    _channelOpenListener: any;
+    /**
+     * Receives events when Last N had changed.
+     * @param {array} lastNEndpoints The new Last N endpoints.
+     * @private
+     */
+    private _onLastNChanged;
+    /**
+     * Should be called when current media session ends and after the
+     * PeerConnection has been closed using PeerConnection.close() method.
+     */
+    onCallEnded(): void;
+    /**
+     * Sets the capture frame rate to be used for desktop tracks.
+     *
+     * @param {number} maxFps framerate to be used for desktop track capture.
+     */
+    setDesktopSharingFrameRate(maxFps: number): void;
+    /**
+     * Sets the receiver video constraints that determine how bitrate is allocated to each of the video streams
+     * requested from the bridge. The constraints are cached and sent through the bridge channel once the channel
+     * is established.
+     * @param {*} constraints
+     */
+    setNewReceiverVideoConstraints(constraints: any): void;
+    _receiverVideoConstraints: any;
+    /**
+     * Sets the maximum video size the local participant should receive from
+     * remote participants. Will cache the value and send it through the channel
+     * once it is created.
+     *
+     * @param {number} maxFrameHeightPixels the maximum frame height, in pixels,
+     * this receiver is willing to receive.
+     * @returns {void}
+     */
+    setReceiverVideoConstraint(maxFrameHeight: any): void;
+    /**
+     * Sets the video type and availability for the local video source.
+     *
+     * @param {string} videoType 'camera' for camera, 'desktop' for screenshare and
+     * 'none' for when local video source is muted or removed from the peerconnection.
+     * @returns {void}
+     */
+    setVideoType(videoType: string): void;
+    /**
+     * Sends the track's  video type to the JVB.
+     * @param {SourceName} sourceName - the track's source name.
+     * @param {BridgeVideoType} videoType - the track's video type.
+     */
+    sendSourceVideoType(sourceName: any, videoType: {
+        CAMERA: string;
+        DESKTOP: string;
+        DESKTOP_HIGH_FPS: string;
+        NONE: string;
+    }): void;
+    /**
+     * Elects the participants with the given ids to be the selected
+     * participants in order to always receive video for this participant (even
+     * when last n is enabled). If there is no channel we store it and send it
+     * through the channel once it is created.
+     *
+     * @param {Array<string>} ids - The user ids.
+     * @throws NetworkError or InvalidStateError or Error if the operation
+     * fails.
+     * @returns {void}
+     */
+    selectEndpoints(ids: Array<string>): void;
+    /**
+     * Creates new <tt>TraceablePeerConnection</tt>
+     * @param {SignalingLayer} signaling The signaling layer that will provide information about the media or
+     * participants which is not carried over SDP.
+     * @param {object} pcConfig The {@code RTCConfiguration} to use for the WebRTC peer connection.
+     * @param {boolean} isP2P Indicates whether or not the new TPC will be used in a peer to peer type of session.
+     * @param {object} options The config options.
+     * @param {boolean} options.enableInsertableStreams - Set to true when the insertable streams constraints is to be
+     * enabled on the PeerConnection.
+     * @param {boolean} options.disableSimulcast If set to 'true' will disable the simulcast.
+     * @param {boolean} options.disableRtx If set to 'true' will disable the RTX.
+     * @param {boolean} options.startSilent If set to 'true' no audio will be sent or received.
+     * @return {TraceablePeerConnection}
+     */
+    createPeerConnection(signaling: any, pcConfig: object, isP2P: boolean, options: {
+        enableInsertableStreams: boolean;
+        disableSimulcast: boolean;
+        disableRtx: boolean;
+        startSilent: boolean;
+    }): TraceablePeerConnection;
+    /**
+     * Removed given peer connection from this RTC module instance.
+     * @param {TraceablePeerConnection} traceablePeerConnection
+     * @return {boolean} <tt>true</tt> if the given peer connection was removed
+     * successfully or <tt>false</tt> if there was no peer connection mapped in
+     * this RTC instance.
+     */
+    _removePeerConnection(traceablePeerConnection: TraceablePeerConnection): boolean;
+    /**
+     *
+     * @param track
+     */
+    addLocalTrack(track: any): void;
+    /**
+     * Get local video track.
+     * @returns {JitsiLocalTrack|undefined}
+     */
+    getLocalVideoTrack(): JitsiLocalTrack | undefined;
+    /**
+     * Get local audio track.
+     * @returns {JitsiLocalTrack|undefined}
+     */
+    getLocalAudioTrack(): JitsiLocalTrack | undefined;
+    /**
+     * Returns the endpoint id for the local user.
+     * @returns {string}
+     */
+    getLocalEndpointId(): string;
+    /**
+     * Returns the local tracks of the given media type, or all local tracks if
+     * no specific type is given.
+     * @param {MediaType} [mediaType] Optional media type filter.
+     * (audio or video).
+     */
+    getLocalTracks(mediaType?: typeof MediaType): any[];
+    /**
+     * Obtains all remote tracks currently known to this RTC module instance.
+     * @param {MediaType} [mediaType] The remote tracks will be filtered
+     *      by their media type if this argument is specified.
+     * @return {Array<JitsiRemoteTrack>}
+     */
+    getRemoteTracks(mediaType?: typeof MediaType): Array<any>;
+    /**
+     * Set mute for all local audio streams attached to the conference.
+     * @param value The mute value.
+     * @returns {Promise}
+     */
+    setAudioMute(value: any): Promise<any>;
+    /**
+    * Set mute for all local video streams attached to the conference.
+    * @param value The mute value.
+    * @returns {Promise}
+    */
+    setVideoMute(value: any): Promise<any>;
+    /**
+     *
+     * @param track
+     */
+    removeLocalTrack(track: any): void;
+    /**
+     * Closes the currently opened bridge channel.
+     */
+    closeBridgeChannel(): void;
+    /**
+     *
+     * @param {TraceablePeerConnection} tpc
+     * @param {number} ssrc
+     * @param {number} audioLevel
+     * @param {boolean} isLocal
+     */
+    setAudioLevel(tpc: TraceablePeerConnection, ssrc: number, audioLevel: number, isLocal: boolean): void;
+    /**
+     * Sends message via the bridge channel.
+     * @param {string} to The id of the endpoint that should receive the
+     *      message. If "" the message will be sent to all participants.
+     * @param {object} payload The payload of the message.
+     * @throws NetworkError or InvalidStateError or Error if the operation
+     * fails or there is no data channel created.
+     */
+    sendChannelMessage(to: string, payload: object): void;
+    /**
+     * Sends the local stats via the bridge channel.
+     * @param {Object} payload The payload of the message.
+     * @throws NetworkError/InvalidStateError/Error if the operation fails or if there is no data channel created.
+     */
+    sendEndpointStatsMessage(payload: any): void;
+    /**
+     * Selects a new value for "lastN". The requested amount of videos are going
+     * to be delivered after the value is in effect. Set to -1 for unlimited or
+     * all available videos.
+     * @param {number} value the new value for lastN.
+     */
+    setLastN(value: number): void;
+    /**
+     * Indicates if the endpoint id is currently included in the last N.
+     * @param {string} id The endpoint id that we check for last N.
+     * @returns {boolean} true if the endpoint id is in the last N or if we
+     * don't have bridge channel support, otherwise we return false.
+     */
+    isInLastN(id: string): boolean;
+}
+import Listenable from "../util/Listenable";
+import TraceablePeerConnection from "./TraceablePeerConnection";
+import BridgeChannel from "./BridgeChannel";
+import JitsiLocalTrack from "./JitsiLocalTrack";
+import * as MediaType from "../../service/RTC/MediaType";

types/auto/modules/RTC/RTCUtils.d.ts

@@ -0,0 +1,181 @@
+export default rtcUtils;
+declare const rtcUtils: RTCUtils;
+/**
+ *
+ */
+declare class RTCUtils extends Listenable {
+    /**
+     *
+     */
+    constructor();
+    /**
+     * Depending on the browser, sets difference instance methods for
+     * interacting with user media and adds methods to native WebRTC-related
+     * objects. Also creates an instance variable for peer connection
+     * constraints.
+     *
+     * @param {Object} options
+     * @returns {void}
+     */
+    init(options?: any): void;
+    RTCPeerConnectionType: {
+        new (configuration?: RTCConfiguration): RTCPeerConnection;
+        prototype: RTCPeerConnection;
+        generateCertificate(keygenAlgorithm: AlgorithmIdentifier): Promise<RTCCertificate>;
+    };
+    attachMediaStream: Function;
+    getStreamID: ({ id }: {
+        id: any;
+    }) => any;
+    getTrackID: ({ id }: {
+        id: any;
+    }) => any;
+    pcConstraints: {
+        optional: ({
+            googScreencastMinBitrate: number;
+            googCpuOveruseDetection?: undefined;
+        } | {
+            googCpuOveruseDetection: boolean;
+            googScreencastMinBitrate?: undefined;
+        })[];
+    } | {
+        optional?: undefined;
+    };
+    /**
+     *
+     * @param {Function} callback
+     */
+    enumerateDevices(callback: Function): void;
+    /**
+     * Acquires a media stream via getUserMedia that
+     * matches the given constraints
+     *
+     * @param {array} umDevices which devices to acquire (e.g. audio, video)
+     * @param {Object} constraints - Stream specifications to use.
+     * @param {number} timeout - The timeout in ms for GUM.
+     * @returns {Promise}
+     */
+    _getUserMedia(umDevices: any[], constraints?: any, timeout?: number): Promise<any>;
+    /**
+     * Acquire a display stream via the screenObtainer. This requires extra
+     * logic compared to use screenObtainer versus normal device capture logic
+     * in RTCUtils#_getUserMedia.
+     *
+     * @returns {Promise} A promise which will be resolved with an object which
+     * contains the acquired display stream. If desktop sharing is not supported
+     * then a rejected promise will be returned.
+     */
+    _getDesktopMedia(): Promise<any>;
+    /**
+     * Private utility for determining if the passed in MediaStream contains
+     * tracks of the type(s) specified in the requested devices.
+     *
+     * @param {string[]} requestedDevices - The track types that are expected to
+     * be includes in the stream.
+     * @param {MediaStream} stream - The MediaStream to check if it has the
+     * expected track types.
+     * @returns {string[]} An array of string with the missing track types. The
+     * array will be empty if all requestedDevices are found in the stream.
+     */
+    _getMissingTracks(requestedDevices: string[], stream: MediaStream): string[];
+    /**
+     * Gets streams from specified device types. This function intentionally
+     * ignores errors for upstream to catch and handle instead.
+     *
+     * @param {Object} options - A hash describing what devices to get and
+     * relevant constraints.
+     * @param {string[]} options.devices - The types of media to capture. Valid
+     * values are "desktop", "audio", and "video".
+     * @param {Object} options.desktopSharingFrameRate
+     * @param {Object} options.desktopSharingFrameRate.min - Minimum fps
+     * @param {Object} options.desktopSharingFrameRate.max - Maximum fps
+     * @param {String} options.desktopSharingSourceDevice - The device id or
+     * label for a video input source that should be used for screensharing.
+     * @returns {Promise} The promise, when successful, will return an array of
+     * meta data for the requested device type, which includes the stream and
+     * track. If an error occurs, it will be deferred to the caller for
+     * handling.
+     */
+    obtainAudioAndVideoPermissions(options: {
+        devices: string[];
+        desktopSharingFrameRate: {
+            min: any;
+            max: any;
+        };
+        desktopSharingSourceDevice: string;
+    }): Promise<any>;
+    /**
+     * Checks whether it is possible to enumerate available cameras/microphones.
+     *
+     * @returns {boolean} {@code true} if the device listing is available;
+     * {@code false}, otherwise.
+     */
+    isDeviceListAvailable(): boolean;
+    /**
+     * Returns true if changing the input (camera / microphone) or output
+     * (audio) device is supported and false if not.
+     * @params {string} [deviceType] - type of device to change. Default is
+     *      undefined or 'input', 'output' - for audio output device change.
+     * @returns {boolean} true if available, false otherwise.
+     */
+    isDeviceChangeAvailable(deviceType: any): boolean;
+    /**
+     * A method to handle stopping of the stream.
+     * One point to handle the differences in various implementations.
+     * @param mediaStream MediaStream object to stop.
+     */
+    stopMediaStream(mediaStream: any): void;
+    /**
+     * Returns whether the desktop sharing is enabled or not.
+     * @returns {boolean}
+     */
+    isDesktopSharingEnabled(): boolean;
+    /**
+     * Sets current audio output device.
+     * @param {string} deviceId - id of 'audiooutput' device from
+     *      navigator.mediaDevices.enumerateDevices(), 'default' for default
+     *      device
+     * @returns {Promise} - resolves when audio output is changed, is rejected
+     *      otherwise
+     */
+    setAudioOutputDevice(deviceId: string): Promise<any>;
+    /**
+     * Sets the capture frame rate for desktop tracks.
+     *
+     * @param {number} maxFps - max fps to be used as the capture frame rate.
+     * @returns {void}
+     */
+    setDesktopSharingFrameRate(maxFps: number): void;
+    /**
+     * Returns currently used audio output device id, '' stands for default
+     * device
+     * @returns {string}
+     */
+    getAudioOutputDevice(): string;
+    /**
+     * Returns list of available media devices if its obtained, otherwise an
+     * empty array is returned/
+     * @returns {Array} list of available media devices.
+     */
+    getCurrentlyAvailableMediaDevices(): any[];
+    /**
+     * Returns whether available devices have permissions granted
+     * @returns {Boolean}
+     */
+    arePermissionsGrantedForAvailableDevices(): boolean;
+    /**
+     * Returns event data for device to be reported to stats.
+     * @returns {MediaDeviceInfo} device.
+     */
+    getEventDataForActiveDevice(device: any): MediaDeviceInfo;
+    /**
+     * Configures the given PeerConnection constraints to either enable or
+     * disable (according to the value of the 'enable' parameter) the
+     * 'googSuspendBelowMinBitrate' option.
+     * @param constraints the constraints on which to operate.
+     * @param enable {boolean} whether to enable or disable the suspend video
+     * option.
+     */
+    setSuspendVideo(constraints: any, enable: boolean): void;
+}
+import Listenable from "../util/Listenable";

types/auto/modules/RTC/ScreenObtainer.d.ts

@@ -0,0 +1,118 @@
+/**
+ * The default frame rate for Screen Sharing.
+ */
+export const SS_DEFAULT_FRAME_RATE: 5;
+export default ScreenObtainer;
+declare namespace ScreenObtainer {
+    const obtainStream: any;
+    /**
+     * Initializes the function used to obtain a screen capture
+     * (this.obtainStream).
+     *
+     * @param {object} options
+     */
+    function init(options?: any): void;
+    /**
+     * Initializes the function used to obtain a screen capture
+     * (this.obtainStream).
+     *
+     * @param {object} options
+     */
+    function init(options?: any): void;
+    /**
+     * Returns a method which will be used to obtain the screen sharing stream
+     * (based on the browser type).
+     *
+     * @returns {Function}
+     * @private
+     */
+    function _createObtainStreamMethod(): Function;
+    /**
+     * Returns a method which will be used to obtain the screen sharing stream
+     * (based on the browser type).
+     *
+     * @returns {Function}
+     * @private
+     */
+    function _createObtainStreamMethod(): Function;
+    /**
+     * Gets the appropriate constraints for audio sharing.
+     *
+     * @returns {Object|boolean}
+     */
+    function _getAudioConstraints(): any;
+    /**
+     * Gets the appropriate constraints for audio sharing.
+     *
+     * @returns {Object|boolean}
+     */
+    function _getAudioConstraints(): any;
+    /**
+     * Checks whether obtaining a screen capture is supported in the current
+     * environment.
+     * @returns {boolean}
+     */
+    function isSupported(): boolean;
+    /**
+     * Checks whether obtaining a screen capture is supported in the current
+     * environment.
+     * @returns {boolean}
+     */
+    function isSupported(): boolean;
+    /**
+     * Obtains a screen capture stream on Electron.
+     *
+     * @param onSuccess - Success callback.
+     * @param onFailure - Failure callback.
+     */
+    function obtainScreenOnElectron(onSuccess: any, onFailure: any): void;
+    /**
+     * Obtains a screen capture stream on Electron.
+     *
+     * @param onSuccess - Success callback.
+     * @param onFailure - Failure callback.
+     */
+    function obtainScreenOnElectron(onSuccess: any, onFailure: any): void;
+    /**
+     * Obtains a screen capture stream using getDisplayMedia.
+     *
+     * @param callback - The success callback.
+     * @param errorCallback - The error callback.
+     */
+    function obtainScreenFromGetDisplayMedia(callback: any, errorCallback: any): void;
+    /**
+     * Obtains a screen capture stream using getDisplayMedia.
+     *
+     * @param callback - The success callback.
+     * @param errorCallback - The error callback.
+     */
+    function obtainScreenFromGetDisplayMedia(callback: any, errorCallback: any): void;
+    /**
+     * Obtains a screen capture stream using getDisplayMedia.
+     *
+     * @param callback - The success callback.
+     * @param errorCallback - The error callback.
+     */
+    function obtainScreenFromGetDisplayMediaRN(callback: any, errorCallback: any): void;
+    /**
+     * Obtains a screen capture stream using getDisplayMedia.
+     *
+     * @param callback - The success callback.
+     * @param errorCallback - The error callback.
+     */
+    function obtainScreenFromGetDisplayMediaRN(callback: any, errorCallback: any): void;
+    /**
+     * Sets the max frame rate to be used for a desktop track capture.
+     *
+     * @param {number} maxFps capture frame rate to be used for desktop tracks.
+     * @returns {void}
+     */
+    function setDesktopSharingFrameRate(maxFps: number): void;
+    /**
+     * Sets the max frame rate to be used for a desktop track capture.
+     *
+     * @param {number} maxFps capture frame rate to be used for desktop tracks.
+     * @returns {void}
+     */
+    function setDesktopSharingFrameRate(maxFps: number): void;
+}

types/auto/modules/RTC/TPCUtils.d.ts

@@ -0,0 +1,161 @@
+export const HD_BITRATE: 2500000;
+export const HD_SCALE_FACTOR: 1;
+export const LD_SCALE_FACTOR: 4;
+export const SD_SCALE_FACTOR: 2;
+export const SIM_LAYER_RIDS: string[];
+/**
+ * Handles track related operations on TraceablePeerConnection when browser is
+ * running in unified plan mode.
+ */
+export class TPCUtils {
+    /**
+     * Creates a new instance for a given TraceablePeerConnection
+     *
+     * @param peerconnection - the tpc instance for which we have utility functions.
+     */
+    constructor(peerconnection: any);
+    pc: any;
+    videoBitrates: any;
+    /**
+     * The startup configuration for the stream encodings that are applicable to
+     * the video stream when a new sender is created on the peerconnection. The initial
+     * config takes into account the differences in browser's simulcast implementation.
+     *
+     * Encoding parameters:
+     * active - determine the on/off state of a particular encoding.
+     * maxBitrate - max. bitrate value to be applied to that particular encoding
+     *  based on the encoding's resolution and config.js videoQuality settings if applicable.
+     * rid - Rtp Stream ID that is configured for a particular simulcast stream.
+     * scaleResolutionDownBy - the factor by which the encoding is scaled down from the
+     *  original resolution of the captured video.
+     */
+    localStreamEncodingsConfig: {
+        active: boolean;
+        maxBitrate: any;
+        rid: string;
+        scaleResolutionDownBy: number;
+    }[];
+    /**
+     * Obtains stream encodings that need to be configured on the given track based
+     * on the track media type and the simulcast setting.
+     * @param {JitsiLocalTrack} localTrack
+     */
+    _getStreamEncodings(localTrack: any): {
+        active: boolean;
+        maxBitrate: any;
+        rid: string;
+        scaleResolutionDownBy: number;
+    }[] | {
+        active: boolean;
+        maxBitrate: any;
+    }[] | {
+        active: boolean;
+    }[];
+    /**
+     * Ensures that the ssrcs associated with a FID ssrc-group appear in the correct order, i.e.,
+     * the primary ssrc first and the secondary rtx ssrc later. This is important for unified
+     * plan since we have only one FID group per media description.
+     * @param {Object} description the webRTC session description instance for the remote
+     * description.
+     * @private
+     */
+    private ensureCorrectOrderOfSsrcs;
+    /**
+     * Returns the transceiver associated with a given RTCRtpSender/RTCRtpReceiver.
+     *
+     * @param {string} mediaType - type of track associated with the transceiver 'audio' or 'video'.
+     * @param {JitsiLocalTrack} localTrack - local track to be used for lookup.
+     * @returns {RTCRtpTransceiver}
+     */
+    findTransceiver(mediaType: string, localTrack?: any): RTCRtpTransceiver;
+    /**
+     * Takes in a *unified plan* offer and inserts the appropriate
+     * parameters for adding simulcast receive support.
+     * @param {Object} desc - A session description object
+     * @param {String} desc.type - the type (offer/answer)
+     * @param {String} desc.sdp - the sdp content
+     *
+     * @return {Object} A session description (same format as above) object
+     * with its sdp field modified to advertise simulcast receive support
+     */
+    insertUnifiedPlanSimulcastReceive(desc: {
+        type: string;
+        sdp: string;
+    }): any;
+    /**
+    * Adds {@link JitsiLocalTrack} to the WebRTC peerconnection for the first time.
+    * @param {JitsiLocalTrack} track - track to be added to the peerconnection.
+    * @param {boolean} isInitiator - boolean that indicates if the endpoint is offerer in a p2p connection.
+    * @returns {void}
+    */
+    addTrack(localTrack: any, isInitiator: boolean): void;
+    /**
+     * Returns the calculated active state of the simulcast encodings based on the frame height requested for the send
+     * stream. All the encodings that have a resolution lower than the frame height requested will be enabled.
+     *
+     * @param {JitsiLocalTrack} localVideoTrack The local video track.
+     * @param {number} newHeight The resolution requested for the video track.
+     * @returns {Array<boolean>}
+     */
+    calculateEncodingsActiveState(localVideoTrack: any, newHeight: number): Array<boolean>;
+    /**
+     * Returns the calculates max bitrates that need to be configured on the simulcast encodings based on the video
+     * type and other considerations associated with screenshare.
+     *
+     * @param {JitsiLocalTrack} localVideoTrack The local video track.
+     * @returns {Array<number>}
+     */
+    calculateEncodingsBitrates(localVideoTrack: any): Array<number>;
+    /**
+     * Replaces the existing track on a RTCRtpSender with the given track.
+     * @param {JitsiLocalTrack} oldTrack - existing track on the sender that needs to be removed.
+     * @param {JitsiLocalTrack} newTrack - new track that needs to be added to the sender.
+     * @returns {Promise<void>} - resolved when done.
+     */
+    replaceTrack(oldTrack: any, newTrack: any): Promise<void>;
+    /**
+    * Enables/disables audio transmission on the peer connection. When
+    * disabled the audio transceiver direction will be set to 'inactive'
+    * which means that no data will be sent nor accepted, but
+    * the connection should be kept alive.
+    * @param {boolean} active - true to enable audio media transmission or
+    * false to disable.
+    * @returns {void}
+    */
+    setAudioTransferActive(active: boolean): void;
+    /**
+     * Set the simulcast stream encoding properties on the RTCRtpSender.
+     * @param {JitsiLocalTrack} track - the current track in use for which
+     * the encodings are to be set.
+     * @returns {Promise<void>} - resolved when done.
+     */
+    setEncodings(track: any): Promise<void>;
+    /**
+     * Enables/disables media transmission on the peerconnection by changing the direction
+     * on the transceiver for the specified media type.
+     * @param {String} mediaType - 'audio' or 'video'
+     * @param {boolean} active - true to enable media transmission or false
+     * to disable.
+     * @returns {void}
+     */
+    setMediaTransferActive(mediaType: string, active: boolean): void;
+    /**
+    * Enables/disables video media transmission on the peer connection. When
+    * disabled the SDP video media direction in the local SDP will be adjusted to
+    * 'inactive' which means that no data will be sent nor accepted, but
+    * the connection should be kept alive.
+    * @param {boolean} active - true to enable video media transmission or
+    * false to disable.
+    * @returns {void}
+    */
+    setVideoTransferActive(active: boolean): void;
+    /**
+     * Ensures that the resolution of the stream encodings are consistent with the values
+     * that were configured on the RTCRtpSender when the source was added to the peerconnection.
+     * This should prevent us from overriding the default values if the browser returns
+     * erroneous values when RTCRtpSender.getParameters is used for getting the encodings info.
+     * @param {Object} parameters - the RTCRtpEncodingParameters obtained from the browser.
+     * @returns {void}
+     */
+    updateEncodingsResolution(parameters: any): void;
+}

types/auto/modules/RTC/TraceablePeerConnection.d.ts

@@ -0,0 +1,785 @@
+/**
+ * Creates new instance of 'TraceablePeerConnection'.
+ *
+ * @param {RTC} rtc the instance of <tt>RTC</tt> service
+ * @param {number} id the peer connection id assigned by the parent RTC module.
+ * @param {SignalingLayer} signalingLayer the signaling layer instance
+ * @param {object} pcConfig The {@code RTCConfiguration} to use for the WebRTC peer connection.
+ * @param {object} constraints WebRTC 'PeerConnection' constraints
+ * @param {boolean} isP2P indicates whether or not the new instance will be used in a peer to peer connection.
+ * @param {object} options <tt>TracablePeerConnection</tt> config options.
+ * @param {boolean} options.disableSimulcast if set to 'true' will disable the simulcast.
+ * @param {boolean} options.disableRtx if set to 'true' will disable the RTX.
+ * @param {string} options.disabledCodec the mime type of the code that should not be negotiated on the peerconnection.
+ * @param {string} options.preferredCodec the mime type of the codec that needs to be made the preferred codec for the
+ * peerconnection.
+ * @param {boolean} options.startSilent If set to 'true' no audio will be sent or received.
+ * @param {boolean} options.usesUnifiedPlan Indicates if the  browser is running in unified plan mode.
+ *
+ * FIXME: initially the purpose of TraceablePeerConnection was to be able to
+ * debug the peer connection. Since many other responsibilities have been added
+ * it would make sense to extract a separate class from it and come up with
+ * a more suitable name.
+ *
+ * @constructor
+ */
+export default function TraceablePeerConnection(rtc: RTC, id: number, signalingLayer: any, pcConfig: object, constraints: object, isP2P: boolean, options: {
+    disableSimulcast: boolean;
+    disableRtx: boolean;
+    disabledCodec: string;
+    preferredCodec: string;
+    startSilent: boolean;
+    usesUnifiedPlan: boolean;
+}): void;
+export default class TraceablePeerConnection {
+    /**
+     * Creates new instance of 'TraceablePeerConnection'.
+     *
+     * @param {RTC} rtc the instance of <tt>RTC</tt> service
+     * @param {number} id the peer connection id assigned by the parent RTC module.
+     * @param {SignalingLayer} signalingLayer the signaling layer instance
+     * @param {object} pcConfig The {@code RTCConfiguration} to use for the WebRTC peer connection.
+     * @param {object} constraints WebRTC 'PeerConnection' constraints
+     * @param {boolean} isP2P indicates whether or not the new instance will be used in a peer to peer connection.
+     * @param {object} options <tt>TracablePeerConnection</tt> config options.
+     * @param {boolean} options.disableSimulcast if set to 'true' will disable the simulcast.
+     * @param {boolean} options.disableRtx if set to 'true' will disable the RTX.
+     * @param {string} options.disabledCodec the mime type of the code that should not be negotiated on the peerconnection.
+     * @param {string} options.preferredCodec the mime type of the codec that needs to be made the preferred codec for the
+     * peerconnection.
+     * @param {boolean} options.startSilent If set to 'true' no audio will be sent or received.
+     * @param {boolean} options.usesUnifiedPlan Indicates if the  browser is running in unified plan mode.
+     *
+     * FIXME: initially the purpose of TraceablePeerConnection was to be able to
+     * debug the peer connection. Since many other responsibilities have been added
+     * it would make sense to extract a separate class from it and come up with
+     * a more suitable name.
+     *
+     * @constructor
+     */
+    constructor(rtc: RTC, id: number, signalingLayer: any, pcConfig: object, constraints: object, isP2P: boolean, options: {
+        disableSimulcast: boolean;
+        disableRtx: boolean;
+        disabledCodec: string;
+        preferredCodec: string;
+        startSilent: boolean;
+        usesUnifiedPlan: boolean;
+    });
+    /**
+     * Indicates whether or not this peer connection instance is actively
+     * sending/receiving audio media. When set to <tt>false</tt> the SDP audio
+     * media direction will be adjusted to 'inactive' in order to suspend
+     * the transmission.
+     * @type {boolean}
+     * @private
+     */
+    private audioTransferActive;
+    /**
+     * The DTMF sender instance used to send DTMF tones.
+     *
+     * @type {RTCDTMFSender|undefined}
+     * @private
+     */
+    private _dtmfSender;
+    /**
+     * @typedef {Object} TouchToneRequest
+     * @property {string} tones - The DTMF tones string as defined by
+     * {@code RTCDTMFSender.insertDTMF}, 'tones' argument.
+     * @property {number} duration - The amount of time in milliseconds that
+     * each DTMF should last.
+     * @property {string} interToneGap - The length of time in miliseconds to
+     * wait between tones.
+     */
+    /**
+     * TouchToneRequests which are waiting to be played. This queue is filled
+     * if there are touch tones currently being played.
+     *
+     * @type {Array<TouchToneRequest>}
+     * @private
+     */
+    private _dtmfTonesQueue;
+    /**
+     * Indicates whether or not this peer connection instance is actively
+     * sending/receiving video media. When set to <tt>false</tt> the SDP video
+     * media direction will be adjusted to 'inactive' in order to suspend
+     * the transmission.
+     * @type {boolean}
+     * @private
+     */
+    private videoTransferActive;
+    /**
+     * The parent instance of RTC service which created this
+     * <tt>TracablePeerConnection</tt>.
+     * @type {RTC}
+     */
+    rtc: RTC;
+    /**
+     * The peer connection identifier assigned by the RTC module.
+     * @type {number}
+     */
+    id: number;
+    /**
+     * Indicates whether or not this instance is used in a peer to peer
+     * connection.
+     * @type {boolean}
+     */
+    isP2P: boolean;
+    /**
+     * The map holds remote tracks associated with this peer connection.
+     * It maps user's JID to media type and remote track
+     * (one track per media type per user's JID).
+     * @type {Map<string, Map<MediaType, JitsiRemoteTrack>>}
+     */
+    remoteTracks: Map<string, Map<typeof MediaType, JitsiRemoteTrack>>;
+    /**
+     * A map which stores local tracks mapped by {@link JitsiLocalTrack.rtcId}
+     * @type {Map<number, JitsiLocalTrack>}
+     */
+    localTracks: Map<number, any>;
+    /**
+     * Keeps tracks of the WebRTC <tt>MediaStream</tt>s that have been added to
+     * the underlying WebRTC PeerConnection.
+     * @type {Array}
+     * @private
+     */
+    private _addedStreams;
+    /**
+     * @typedef {Object} TPCGroupInfo
+     * @property {string} semantics the SSRC groups semantics
+     * @property {Array<number>} ssrcs group's SSRCs in order where the first
+     * one is group's primary SSRC, the second one is secondary (RTX) and so
+     * on...
+     */
+    /**
+     * @typedef {Object} TPCSSRCInfo
+     * @property {Array<number>} ssrcs an array which holds all track's SSRCs
+     * @property {Array<TPCGroupInfo>} groups an array stores all track's SSRC
+     * groups
+     */
+    /**
+     * Holds the info about local track's SSRCs mapped per their
+     * {@link JitsiLocalTrack.rtcId}
+     * @type {Map<number, TPCSSRCInfo>}
+     */
+    localSSRCs: Map<number, {
+        /**
+         * an array which holds all track's SSRCs
+         */
+        ssrcs: Array<number>;
+        /**
+         * an array stores all track's SSRC
+         * groups
+         */
+        groups: {
+            /**
+             * the SSRC groups semantics
+             */
+            semantics: string;
+            /**
+             * group's SSRCs in order where the first
+             * one is group's primary SSRC, the second one is secondary (RTX) and so
+             * on...
+             */
+            ssrcs: Array<number>;
+        }[];
+    }>;
+    /**
+     * The local ICE username fragment for this session.
+     */
+    localUfrag: any;
+    /**
+     * The remote ICE username fragment for this session.
+     */
+    remoteUfrag: any;
+    /**
+     * The DTLS transport object for the PeerConnection.
+     * Note: this assume only one shared transport exists because we bundled
+     *       all streams on the same underlying transport.
+     */
+    _dtlsTransport: RTCDtlsTransport;
+    /**
+     * The signaling layer which operates this peer connection.
+     * @type {SignalingLayer}
+     */
+    signalingLayer: any;
+    _peerVideoTypeChanged: any;
+    _peerMutedChanged: any;
+    options: {
+        disableSimulcast: boolean;
+        disableRtx: boolean;
+        disabledCodec: string;
+        preferredCodec: string;
+        startSilent: boolean;
+        usesUnifiedPlan: boolean;
+    };
+    peerconnection: RTCPeerConnection;
+    tpcUtils: TPCUtils;
+    updateLog: any[];
+    stats: {};
+    statsinterval: number;
+    /**
+     * Flag used to indicate if simulcast is turned off and a cap of 500 Kbps is applied on screensharing.
+     */
+    _capScreenshareBitrate: any;
+    /**
+    * Flag used to indicate if the browser is running in unified  plan mode.
+    */
+    _usesUnifiedPlan: boolean;
+    /**
+     * Flag used to indicate if RTCRtpTransceiver#setCodecPreferences is to be used instead of SDP
+     * munging for codec selection.
+     */
+    _usesTransceiverCodecPreferences: boolean;
+    /**
+     * @type {number} The max number of stats to keep in this.stats. Limit to
+     * 300 values, i.e. 5 minutes; set to 0 to disable
+     */
+    maxstats: number;
+    interop: any;
+    simulcast: any;
+    sdpConsistency: SdpConsistency;
+    /**
+     * Munges local SDP provided to the Jingle Session in order to prevent from
+     * sending SSRC updates on attach/detach and mute/unmute (for video).
+     * @type {LocalSdpMunger}
+     */
+    localSdpMunger: LocalSdpMunger;
+    /**
+     * TracablePeerConnection uses RTC's eventEmitter
+     * @type {EventEmitter}
+     */
+    eventEmitter: any;
+    rtxModifier: RtxModifier;
+    /**
+     * The height constraint applied on the video sender. The default value is 2160 (4K) when layer suspension is
+     * explicitly disabled.
+     */
+    _senderVideoMaxHeight: number;
+    trace: (what: any, info: any) => void;
+    onicecandidate: any;
+    onTrack: (evt: any) => void;
+    onsignalingstatechange: any;
+    oniceconnectionstatechange: any;
+    onnegotiationneeded: any;
+    onconnectionstatechange: any;
+    ondatachannel: any;
+    private _processStat;
+    /**
+     * Forwards the {@link peerconnection.iceConnectionState} state except that it
+     * will convert "completed" into "connected" where both mean that the ICE has
+     * succeeded and is up and running. We never see "completed" state for
+     * the JVB connection, but it started appearing for the P2P one. This method
+     * allows to adapt old logic to this new situation.
+     * @return {string}
+     */
+    getConnectionState(): string;
+    private getDesiredMediaDirection;
+    /**
+     * Returns the list of RTCRtpReceivers created for the source of the given media type associated with
+     * the set of remote endpoints specified.
+     * @param {Array<string>} endpoints list of the endpoints
+     * @param {string} mediaType 'audio' or 'video'
+     * @returns {Array<RTCRtpReceiver>} list of receivers created by the peerconnection.
+     */
+    _getReceiversByEndpointIds(endpoints: Array<string>, mediaType: string): Array<RTCRtpReceiver>;
+    /**
+     * Tells whether or not this TPC instance is using Simulcast.
+     * @return {boolean} <tt>true</tt> if simulcast is enabled and active or
+     * <tt>false</tt> if it's turned off.
+     */
+    isSimulcastOn(): boolean;
+    /**
+     * Obtains audio levels of the remote audio tracks by getting the source information on the RTCRtpReceivers.
+     * The information relevant to the ssrc is updated each time a RTP packet constaining the ssrc is received.
+     * @param {Array<string>} speakerList list of endpoint ids for which audio levels are to be gathered.
+     * @returns {Object} containing ssrc and audio level information as a key-value pair.
+     */
+    getAudioLevels(speakerList?: Array<string>): any;
+    /**
+     * Obtains local tracks for given {@link MediaType}. If the <tt>mediaType</tt>
+     * argument is omitted the list of all local tracks will be returned.
+     * @param {MediaType} [mediaType]
+     * @return {Array<JitsiLocalTrack>}
+     */
+    getLocalTracks(mediaType?: typeof MediaType): Array<any>;
+    /**
+     * Retrieves the local video track.
+     *
+     * @returns {JitsiLocalTrack|undefined} - local video track.
+     */
+    getLocalVideoTrack(): any | undefined;
+    /**
+     * Checks whether or not this {@link TraceablePeerConnection} instance contains
+     * any local tracks for given <tt>mediaType</tt>.
+     * @param {MediaType} mediaType
+     * @return {boolean}
+     */
+    hasAnyTracksOfType(mediaType: typeof MediaType): boolean;
+    /**
+     * Obtains all remote tracks currently known to this PeerConnection instance.
+     * @param {string} [endpointId] the track owner's identifier (MUC nickname)
+     * @param {MediaType} [mediaType] the remote tracks will be filtered
+     * by their media type if this argument is specified.
+     * @return {Array<JitsiRemoteTrack>}
+     */
+    getRemoteTracks(endpointId?: string, mediaType?: typeof MediaType): Array<JitsiRemoteTrack>;
+    /**
+     * Parses the remote description and returns the sdp lines of the sources associated with a remote participant.
+     *
+     * @param {string} id Endpoint id of the remote participant.
+     * @returns {Array<string>} The sdp lines that have the ssrc information.
+     */
+    getRemoteSourceInfoByParticipant(id: string): Array<string>;
+    /**
+     * Returns the target bitrates configured for the local video source.
+     *
+     * @returns {Object}
+     */
+    getTargetVideoBitrates(): any;
+    /**
+     * Tries to find {@link JitsiTrack} for given SSRC number. It will search both
+     * local and remote tracks bound to this instance.
+     * @param {number} ssrc
+     * @return {JitsiTrack|null}
+     */
+    getTrackBySSRC(ssrc: number): any | null;
+    /**
+     * Tries to find SSRC number for given {@link JitsiTrack} id. It will search
+     * both local and remote tracks bound to this instance.
+     * @param {string} id
+     * @return {number|null}
+     */
+    getSsrcByTrackId(id: string): number | null;
+    /**
+     * Called when new remote MediaStream is added to the PeerConnection.
+     * @param {MediaStream} stream the WebRTC MediaStream for remote participant
+     */
+    _remoteStreamAdded(stream: MediaStream): void;
+    /**
+     * Called on "track added" and "stream added" PeerConnection events (because we
+     * handle streams on per track basis). Finds the owner and the SSRC for
+     * the track and passes that to ChatRoom for further processing.
+     * @param {MediaStream} stream the WebRTC MediaStream instance which is
+     * the parent of the track
+     * @param {MediaStreamTrack} track the WebRTC MediaStreamTrack added for remote
+     * participant.
+     * @param {RTCRtpTransceiver} transceiver the WebRTC transceiver that is created
+     * for the remote participant in unified plan.
+     */
+    _remoteTrackAdded(stream: MediaStream, track: MediaStreamTrack, transceiver?: RTCRtpTransceiver): void;
+    /**
+     * Initializes a new JitsiRemoteTrack instance with the data provided by
+     * the signaling layer and SDP.
+     *
+     * @param {string} ownerEndpointId the owner's endpoint ID (MUC nickname)
+     * @param {MediaStream} stream the WebRTC stream instance
+     * @param {MediaStreamTrack} track the WebRTC track instance
+     * @param {MediaType} mediaType the track's type of the media
+     * @param {VideoType} [videoType] the track's type of the video (if applicable)
+     * @param {number} ssrc the track's main SSRC number
+     * @param {boolean} muted the initial muted status
+     * @param {String} sourceName the track's source name
+     */
+    _createRemoteTrack(ownerEndpointId: string, stream: MediaStream, track: MediaStreamTrack, mediaType: typeof MediaType, videoType?: {
+        CAMERA: string;
+        DESKTOP: string;
+    }, ssrc: number, muted: boolean, sourceName: string): void;
+    /**
+     * Handles remote stream removal.
+     * @param stream the WebRTC MediaStream object which is being removed from the
+     * PeerConnection
+     */
+    _remoteStreamRemoved(stream: any): void;
+    /**
+     * Handles remote media track removal.
+     * @param {MediaStream} stream WebRTC MediaStream instance which is the parent
+     * of the track.
+     * @param {MediaStreamTrack} track the WebRTC MediaStreamTrack which has been
+     * removed from the PeerConnection.
+     */
+    _remoteTrackRemoved(stream: MediaStream, track: MediaStreamTrack): void;
+    private _getRemoteTrackById;
+    /**
+     * Removes all JitsiRemoteTracks associated with given MUC nickname
+     * (resource part of the JID). Returns array of removed tracks.
+     *
+     * @param {string} owner - The resource part of the MUC JID.
+     * @returns {JitsiRemoteTrack[]}
+     */
+    removeRemoteTracks(owner: string): JitsiRemoteTrack[];
+    /**
+     * Removes and disposes given <tt>JitsiRemoteTrack</tt> instance. Emits
+     * {@link RTCEvents.REMOTE_TRACK_REMOVED}.
+     * @param {JitsiRemoteTrack} toBeRemoved
+     */
+    _removeRemoteTrack(toBeRemoved: JitsiRemoteTrack): void;
+    /**
+     * Removes and disposes <tt>JitsiRemoteTrack</tt> identified by given stream and
+     * track ids.
+     *
+     * @param {string} streamId the media stream id as defined by the WebRTC
+     * @param {string} trackId the media track id as defined by the WebRTC
+     * @returns {JitsiRemoteTrack|undefined} the track which has been removed or
+     * <tt>undefined</tt> if no track matching given stream and track ids was
+     * found.
+     */
+    _removeRemoteTrackById(streamId: string, trackId: string): JitsiRemoteTrack | undefined;
+    /**
+     * Returns a map with keys msid/mediaType and <tt>TrackSSRCInfo</tt> values.
+     * @param {RTCSessionDescription} desc the local description.
+     * @return {Map<string,TrackSSRCInfo>}
+     */
+    _extractSSRCMap(desc: RTCSessionDescription): Map<string, any>;
+    /**
+     *
+     * @param {JitsiLocalTrack} localTrack
+     */
+    getLocalSSRC(localTrack: any): number;
+    /**
+     * When doing unified plan simulcast, we'll have a set of ssrcs with the
+     * same msid but no ssrc-group, since unified plan signals the simulcast
+     * group via the a=simulcast line.  Unfortunately, Jicofo will complain
+     * if it sees ssrcs with matching msids but no ssrc-group, so we'll inject
+     * an ssrc-group line to make Jicofo happy.
+     * @param desc A session description object (with 'type' and 'sdp' fields)
+     * @return A session description object with its sdp field modified to
+     * contain an inject ssrc-group for simulcast
+     */
+    _injectSsrcGroupForUnifiedSimulcast(desc: any): any;
+    _getSSRC(rtcId: any): {
+        /**
+         * an array which holds all track's SSRCs
+         */
+        ssrcs: Array<number>;
+        /**
+         * an array stores all track's SSRC
+         * groups
+         */
+        groups: {
+            /**
+             * the SSRC groups semantics
+             */
+            semantics: string;
+            /**
+             * group's SSRCs in order where the first
+             * one is group's primary SSRC, the second one is secondary (RTX) and so
+             * on...
+             */
+            ssrcs: Array<number>;
+        }[];
+    };
+    private isSharingLowFpsScreen;
+    /**
+     * Checks if screensharing is in progress.
+     *
+     * @returns {boolean}  Returns true if a desktop track has been added to the
+     * peerconnection, false otherwise.
+     */
+    _isSharingScreen(): boolean;
+    /**
+     * Munges the order of the codecs in the SDP passed based on the preference
+     * set through config.js settings. All instances of the specified codec are
+     * moved up to the top of the list when it is preferred. The specified codec
+     * is deleted from the list if the configuration specifies that the codec be
+     * disabled.
+     * @param {RTCSessionDescription} description that needs to be munged.
+     * @returns {RTCSessionDescription} the munged description.
+     */
+    _mungeCodecOrder(description: RTCSessionDescription): RTCSessionDescription;
+    /**
+     * Add {@link JitsiLocalTrack} to this TPC.
+     * @param {JitsiLocalTrack} track
+     * @param {boolean} isInitiator indicates if the endpoint is the offerer.
+     * @returns {Promise<void>} - resolved when done.
+     */
+    addTrack(track: any, isInitiator?: boolean): Promise<void>;
+    /**
+     * Adds local track as part of the unmute operation.
+     * @param {JitsiLocalTrack} track the track to be added as part of the unmute operation.
+     *
+     * @return {Promise<boolean>} Promise that resolves to true if the underlying PeerConnection's
+     * state has changed and renegotiation is required, false if no renegotiation is needed or
+     * Promise is rejected when something goes wrong.
+     */
+    addTrackUnmute(track: any): Promise<boolean>;
+    private _addStream;
+    /**
+     * Removes WebRTC media stream from the underlying PeerConection
+     * @param {MediaStream} mediaStream
+     */
+    _removeStream(mediaStream: MediaStream): void;
+    private _assertTrackBelongs;
+    /**
+     * Returns the codec that is configured on the client as the preferred video codec.
+     * This takes into account the current order of codecs in the local description sdp.
+     *
+     * @returns {CodecMimeType} The codec that is set as the preferred codec to receive
+     * video in the local SDP.
+     */
+    getConfiguredVideoCodec(): {
+        H264: string;
+        OPUS: string;
+        ULPFEC: string;
+        VP8: string;
+        VP9: string;
+    };
+    /**
+     * Enables or disables simulcast for screenshare based on the frame rate requested for desktop track capture.
+     *
+     * @param {number} maxFps framerate to be used for desktop track capture.
+     */
+    setDesktopSharingFrameRate(maxFps: number): void;
+    /**
+     * Sets the codec preference on the peerconnection. The codec preference goes into effect when
+     * the next renegotiation happens.
+     *
+     * @param {CodecMimeType} preferredCodec the preferred codec.
+     * @param {CodecMimeType} disabledCodec the codec that needs to be disabled.
+     * @returns {void}
+     */
+    setVideoCodecs(preferredCodec?: {
+        H264: string;
+        OPUS: string;
+        ULPFEC: string;
+        VP8: string;
+        VP9: string;
+    }, disabledCodec?: {
+        H264: string;
+        OPUS: string;
+        ULPFEC: string;
+        VP8: string;
+        VP9: string;
+    }): void;
+    codecPreference: {
+        enable: boolean;
+        mediaType: string;
+        mimeType: {
+            H264: string;
+            OPUS: string;
+            ULPFEC: string;
+            VP8: string;
+            VP9: string;
+        };
+    };
+    /**
+     * Tells if the given WebRTC <tt>MediaStream</tt> has been added to
+     * the underlying WebRTC PeerConnection.
+     * @param {MediaStream} mediaStream
+     * @returns {boolean}
+     */
+    isMediaStreamInPc(mediaStream: MediaStream): boolean;
+    /**
+     * Remove local track from this TPC.
+     * @param {JitsiLocalTrack} localTrack the track to be removed from this TPC.
+     *
+     * FIXME It should probably remove a boolean just like {@link removeTrackMute}
+     *       The same applies to addTrack.
+     */
+    removeTrack(localTrack: any): void;
+    /**
+     * Returns the sender corresponding to the given media type.
+     * @param {MEDIA_TYPE} mediaType - The media type 'audio' or 'video' to be used for the search.
+     * @returns {RTPSender|undefined} - The found sender or undefined if no sender
+     * was found.
+     */
+    findSenderByKind(mediaType: any): any | undefined;
+    /**
+     * Returns the receiver corresponding to the given MediaStreamTrack.
+     *
+     * @param {MediaSreamTrack} track - The media stream track used for the search.
+     * @returns {RTCRtpReceiver|undefined} - The found receiver or undefined if no receiver
+     * was found.
+     */
+    findReceiverForTrack(track: any): RTCRtpReceiver | undefined;
+    /**
+     * Returns the sender corresponding to the given MediaStreamTrack.
+     *
+     * @param {MediaSreamTrack} track - The media stream track used for the search.
+     * @returns {RTCRtpSender|undefined} - The found sender or undefined if no sender
+     * was found.
+     */
+    findSenderForTrack(track: any): RTCRtpSender | undefined;
+    /**
+     * Replaces <tt>oldTrack</tt> with <tt>newTrack</tt> from the peer connection.
+     * Either <tt>oldTrack</tt> or <tt>newTrack</tt> can be null; replacing a valid
+     * <tt>oldTrack</tt> with a null <tt>newTrack</tt> effectively just removes
+     * <tt>oldTrack</tt>
+     *
+     * @param {JitsiLocalTrack|null} oldTrack - The current track in use to be replaced on the pc.
+     * @param {JitsiLocalTrack|null} newTrack - The new track to be used.
+     *
+     * @returns {Promise<boolean>} - If the promise resolves with true, renegotiation will be needed.
+     * Otherwise no renegotiation is needed.
+     */
+    replaceTrack(oldTrack: any | null, newTrack: any | null): Promise<boolean>;
+    /**
+     * Removes local track as part of the mute operation.
+     * @param {JitsiLocalTrack} localTrack the local track to be remove as part of
+     * the mute operation.
+     * @return {Promise<boolean>} Promise that resolves to true if the underlying PeerConnection's
+     * state has changed and renegotiation is required, false if no renegotiation is needed or
+     * Promise is rejected when something goes wrong.
+     */
+    removeTrackMute(localTrack: any): Promise<boolean>;
+    createDataChannel(label: any, opts: any): RTCDataChannel;
+    private _ensureSimulcastGroupIsLast;
+    private _adjustLocalMediaDirection;
+    private _adjustRemoteMediaDirection;
+    /**
+     * Munges the stereo flag as well as the opusMaxAverageBitrate in the SDP, based
+     * on values set through config.js, if present.
+     *
+     * @param {RTCSessionDescription} description that needs to be munged.
+     * @returns {RTCSessionDescription} the munged description.
+     */
+    _mungeOpus(description: RTCSessionDescription): RTCSessionDescription;
+    /**
+     * Sets up the _dtlsTransport object and initializes callbacks for it.
+     */
+    _initializeDtlsTransport(): void;
+    /**
+     * Configures the stream encodings depending on the video type and the bitrates configured.
+     *
+     * @returns {Promise} promise that will be resolved when the operation is successful and rejected otherwise.
+     */
+    configureSenderVideoEncodings(): Promise<any>;
+    setLocalDescription(description: any): Promise<any>;
+    /**
+     * Enables/disables audio media transmission on this peer connection. When
+     * disabled the SDP audio media direction in the local SDP will be adjusted to
+     * 'inactive' which means that no data will be sent nor accepted, but
+     * the connection should be kept alive.
+     * @param {boolean} active <tt>true</tt> to enable audio media transmission or
+     * <tt>false</tt> to disable. If the value is not a boolean the call will have
+     * no effect.
+     * @return {boolean} <tt>true</tt> if the value has changed and sRD/sLD cycle
+     * needs to be executed in order for the changes to take effect or
+     * <tt>false</tt> if the given value was the same as the previous one.
+     * @public
+     */
+    public setAudioTransferActive(active: boolean): boolean;
+    setRemoteDescription(description: any): Promise<any>;
+    /**
+     * Changes the resolution of the video stream that is sent to the peer based on the resolution requested by the peer
+     * and user preference, sets the degradation preference on the sender based on the video type, configures the maximum
+     * bitrates on the send stream.
+     *
+     * @param {number} frameHeight - The max frame height to be imposed on the outgoing video stream.
+     * @returns {Promise} promise that will be resolved when the operation is successful and rejected otherwise.
+     */
+    setSenderVideoConstraints(frameHeight: number): Promise<any>;
+    encodingsEnabledState: boolean[];
+    /**
+     * Enables/disables video media transmission on this peer connection. When
+     * disabled the SDP video media direction in the local SDP will be adjusted to
+     * 'inactive' which means that no data will be sent nor accepted, but
+     * the connection should be kept alive.
+     * @param {boolean} active <tt>true</tt> to enable video media transmission or
+     * <tt>false</tt> to disable. If the value is not a boolean the call will have
+     * no effect.
+     * @return {boolean} <tt>true</tt> if the value has changed and sRD/sLD cycle
+     * needs to be executed in order for the changes to take effect or
+     * <tt>false</tt> if the given value was the same as the previous one.
+     * @public
+     */
+    public setVideoTransferActive(active: boolean): boolean;
+    /**
+     * Sends DTMF tones if possible.
+     *
+     * @param {string} tones - The DTMF tones string as defined by {@code RTCDTMFSender.insertDTMF}, 'tones' argument.
+     * @param {number} duration - The amount of time in milliseconds that each DTMF should last. It's 200ms by default.
+     * @param {number} interToneGap - The length of time in miliseconds to wait between tones. It's 200ms by default.
+     *
+     * @returns {void}
+     */
+    sendTones(tones: string, duration?: number, interToneGap?: number): void;
+    private _onToneChange;
+    /**
+     * Makes the underlying TraceablePeerConnection generate new SSRC for
+     * the recvonly video stream.
+     */
+    generateRecvonlySsrc(): void;
+    /**
+     * Makes the underlying TraceablePeerConnection forget the current primary video
+     * SSRC.
+     */
+    clearRecvonlySsrc(): void;
+    /**
+     * Closes underlying WebRTC PeerConnection instance and removes all remote
+     * tracks by emitting {@link RTCEvents.REMOTE_TRACK_REMOVED} for each one of
+     * them.
+     */
+    close(): void;
+    createAnswer(constraints: any): Promise<any>;
+    createOffer(constraints: any): Promise<any>;
+    _createOfferOrAnswer(isOffer: any, constraints: any): Promise<any>;
+    /**
+     * Extract primary SSRC from given {@link TrackSSRCInfo} object.
+     * @param {TrackSSRCInfo} ssrcObj
+     * @return {number|null} the primary SSRC or <tt>null</tt>
+     */
+    _extractPrimarySSRC(ssrcObj: any): number | null;
+    private _processLocalSSRCsMap;
+    addIceCandidate(candidate: any): Promise<void>;
+    /**
+     * Returns the number of simulcast streams that are currently enabled on the peerconnection.
+     *
+     * @returns {number} The number of simulcast streams currently enabled or 1 when simulcast is disabled.
+     */
+    getActiveSimulcastStreams(): number;
+    /**
+     * Obtains call-related stats from the peer connection.
+     *
+     * @returns {Promise<Object>} Promise which resolves with data providing statistics about
+     * the peerconnection.
+     */
+    getStats(): Promise<any>;
+    /**
+     * Generates and stores new SSRC info object for given local track.
+     * The method should be called only for a video track being added to this TPC
+     * in the muted state (given that the current browser uses this strategy).
+     * @param {JitsiLocalTrack} track
+     * @return {TPCSSRCInfo}
+     */
+    generateNewStreamSSRCInfo(track: any): {
+        /**
+         * an array which holds all track's SSRCs
+         */
+        ssrcs: Array<number>;
+        /**
+         * an array stores all track's SSRC
+         * groups
+         */
+        groups: {
+            /**
+             * the SSRC groups semantics
+             */
+            semantics: string;
+            /**
+             * group's SSRCs in order where the first
+             * one is group's primary SSRC, the second one is secondary (RTX) and so
+             * on...
+             */
+            ssrcs: Array<number>;
+        }[];
+    };
+    /**
+     * Returns if the peer connection uses Unified plan implementation.
+     *
+     * @returns {boolean} True if the pc uses Unified plan, false otherwise.
+     */
+    usesUnifiedPlan(): boolean;
+    /**
+     * Creates a text representation of this <tt>TraceablePeerConnection</tt>
+     * instance.
+     * @return {string}
+     */
+    toString(): string;
+}
+import RTC from "./RTC";
+import * as MediaType from "../../service/RTC/MediaType";
+import JitsiRemoteTrack from "./JitsiRemoteTrack";
+import { TPCUtils } from "./TPCUtils";
+import SdpConsistency from "../sdp/SdpConsistency";
+import LocalSdpMunger from "../sdp/LocalSdpMunger";
+import RtxModifier from "../sdp/RtxModifier";

types/auto/modules/browser/BrowserCapabilities.d.ts

@@ -0,0 +1,197 @@
+/**
+ * Implements browser capabilities for lib-jitsi-meet.
+ */
+export default class BrowserCapabilities {
+    /**
+     * Tells whether or not the <tt>MediaStream/tt> is removed from the <tt>PeerConnection</tt> and disposed on video
+     * mute (in order to turn off the camera device). This is needed on Firefox because of the following bug
+     * https://bugzilla.mozilla.org/show_bug.cgi?id=1735951
+     *
+     * @return {boolean} <tt>true</tt> if the current browser supports this strategy or <tt>false</tt> otherwise.
+     */
+    doesVideoMuteByStreamRemove(): boolean;
+    /**
+     * Checks if the current browser is Chromium based, i.e., it's either Chrome / Chromium or uses it as its engine,
+     * but doesn't identify as Chrome.
+     *
+     * This includes the following browsers:
+     * - Chrome and Chromium.
+     * - Other browsers which use the Chrome engine, but are detected as Chrome, such as Brave and Vivaldi.
+     * - Browsers which are NOT Chrome but use it as their engine, and have custom detection code: Opera, Electron
+     *   and NW.JS.
+     * This excludes
+     * - Chrome on iOS since it uses WKWebView.
+     */
+    isChromiumBased(): boolean;
+    /**
+     * Checks if the current platform is iOS.
+     *
+     * @returns {boolean}
+     */
+    isIosBrowser(): boolean;
+    /**
+     * Checks if the current browser is WebKit based. It's either
+     * Safari or uses WebKit as its engine.
+     *
+     * This includes Chrome and Firefox on iOS
+     *
+     * @returns {boolean}
+     */
+    isWebKitBased(): boolean;
+    /**
+     * Checks whether current running context is a Trusted Web Application.
+     *
+     * @returns {boolean} Whether the current context is a TWA.
+     */
+    isTwa(): boolean;
+    /**
+     * Checks if the current browser is supported.
+     *
+     * @returns {boolean} true if the browser is supported, false otherwise.
+     */
+    isSupported(): boolean;
+    /**
+     * Returns whether the browser is supported for Android
+     * @returns {boolean} true if the browser is supported for Android devices
+     */
+    isSupportedAndroidBrowser(): boolean;
+    /**
+     * Returns whether the browser is supported for iOS
+     * @returns {boolean} true if the browser is supported for iOS devices
+     */
+    isSupportedIOSBrowser(): boolean;
+    /**
+     * Returns whether or not the current environment needs a user interaction
+     * with the page before any unmute can occur.
+     *
+     * @returns {boolean}
+     */
+    isUserInteractionRequiredForUnmute(): boolean;
+    /**
+     * Checks if the current browser triggers 'onmute'/'onunmute' events when
+     * user's connection is interrupted and the video stops playback.
+     * @returns {*|boolean} 'true' if the event is supported or 'false'
+     * otherwise.
+     */
+    supportsVideoMuteOnConnInterrupted(): any | boolean;
+    /**
+     * Checks if the current browser reports upload and download bandwidth
+     * statistics.
+     * @return {boolean}
+     */
+    supportsBandwidthStatistics(): boolean;
+    /**
+     * Checks if the current browser supports setting codec preferences on the transceiver.
+     * @returns {boolean}
+     */
+    supportsCodecPreferences(): boolean;
+    /**
+     * Checks if the current browser support the device change event.
+     * @return {boolean}
+     */
+    supportsDeviceChangeEvent(): boolean;
+    /**
+     * Checks if the current browser supports RTT statistics for srflx local
+     * candidates through the legacy getStats() API.
+     */
+    supportsLocalCandidateRttStatistics(): any;
+    /**
+     * Checks if the current browser supports the Long Tasks API that lets us observe
+     * performance measurement events and be notified of tasks that take longer than
+     * 50ms to execute on the main thread.
+     */
+    supportsPerformanceObserver(): boolean;
+    /**
+     * Checks if the current browser supports audio level stats on the receivers.
+     */
+    supportsReceiverStats(): boolean;
+    /**
+     * Checks if the current browser reports round trip time statistics for
+     * the ICE candidate pair.
+     * @return {boolean}
+     */
+    supportsRTTStatistics(): boolean;
+    /**
+     * Returns true if VP9 is supported by the client on the browser. VP9 is currently disabled on Firefox and Safari
+     * because of issues with rendering. Please check https://bugzilla.mozilla.org/show_bug.cgi?id=1492500,
+     * https://bugs.webkit.org/show_bug.cgi?id=231071 and https://bugs.webkit.org/show_bug.cgi?id=231074 for details.
+     */
+    supportsVP9(): any;
+    /**
+     * Checks if the browser uses SDP munging for turning on simulcast.
+     *
+     * @returns {boolean}
+     */
+    usesSdpMungingForSimulcast(): boolean;
+    /**
+     * Checks if the browser uses webrtc-adapter. All browsers except React Native do.
+     *
+     * @returns {boolean}
+     */
+    usesAdapter(): boolean;
+    /**
+     * Checks if the browser uses RIDs/MIDs for siganling the simulcast streams
+     * to the bridge instead of the ssrcs.
+     */
+    usesRidsForSimulcast(): boolean;
+    /**
+     * Checks if the browser supports getDisplayMedia.
+     * @returns {boolean} {@code true} if the browser supports getDisplayMedia.
+     */
+    supportsGetDisplayMedia(): boolean;
+    /**
+     * Checks if the browser supports WebRTC Encoded Transform, an alternative
+     * to insertable streams.
+     *
+     * NOTE: At the time of this writing the only browser supporting this is
+     * Safari / WebKit, behind a flag.
+     *
+     * @returns {boolean} {@code true} if the browser supports it.
+     */
+    supportsEncodedTransform(): boolean;
+    /**
+     * Checks if the browser supports insertable streams, needed for E2EE.
+     * @returns {boolean} {@code true} if the browser supports insertable streams.
+     */
+    supportsInsertableStreams(): boolean;
+    /**
+     * Whether the browser supports the RED format for audio.
+     */
+    supportsAudioRed(): boolean;
+    /**
+     * Checks if the browser supports unified plan.
+     *
+     * @returns {boolean}
+     */
+    supportsUnifiedPlan(): boolean;
+    /**
+     * Checks if the browser supports voice activity detection via the @type {VADAudioAnalyser} service.
+     *
+     * @returns {boolean}
+     */
+    supportsVADDetection(): boolean;
+    /**
+     * Check if the browser supports the RTP RTX feature (and it is usable).
+     *
+     * @returns {boolean}
+     */
+    supportsRTX(): boolean;
+    /**
+     * Returns the version of a Chromium based browser.
+     *
+     * @returns {Number}
+     */
+    _getChromiumBasedVersion(): number;
+    /**
+     * Returns the version of a Safari browser.
+     *
+     * @returns {Number}
+     */
+    _getSafariVersion(): number;
+    /**
+     * Returns the version of an ios browser.
+     *
+     * @returns {Number}
+     */
+    _getIOSVersion(): number;
+}

types/auto/modules/browser/index.d.ts

@@ -0,0 +1,3 @@
+declare var _default: BrowserCapabilities;
+export default _default;
+import BrowserCapabilities from "./BrowserCapabilities";

types/auto/modules/connectivity/ConnectionQuality.d.ts

@@ -0,0 +1,97 @@
+/**
+ * A class which monitors the local statistics coming from the RTC modules, and
+ * calculates a "connection quality" value, in percent, for the media
+ * connection. A value of 100% indicates a very good network connection, and a
+ * value of 0% indicates a poor connection.
+ */
+export default class ConnectionQuality {
+    /**
+     *
+     * @param conference
+     * @param eventEmitter
+     * @param options
+     */
+    constructor(conference: any, eventEmitter: any, options: any);
+    eventEmitter: any;
+    /**
+     * The owning JitsiConference.
+     */
+    _conference: any;
+    /**
+     * Holds statistics about the local connection quality.
+     */
+    _localStats: {
+        connectionQuality: number;
+        jvbRTT: any;
+    };
+    /**
+     * The time this._localStats.connectionQuality was last updated.
+     */
+    _lastConnectionQualityUpdate: number;
+    /**
+     * Conference options.
+     */
+    _options: any;
+    /**
+     * Maps a participant ID to an object holding connection quality
+     * statistics received from this participant.
+     */
+    _remoteStats: {};
+    /**
+     * The time that the ICE state last changed to CONNECTED. We use this
+     * to calculate how much time we as a sender have had to ramp-up.
+     */
+    _timeIceConnected: number;
+    /**
+     * The time that local video was unmuted. We use this to calculate how
+     * much time we as a sender have had to ramp-up.
+     */
+    _timeVideoUnmuted: number;
+    /**
+     * Sets _timeVideoUnmuted if it was previously unset. If it was already set,
+     * doesn't change it.
+     */
+    _maybeUpdateUnmuteTime(): void;
+    /**
+     * Calculates a new "connection quality" value.
+     * @param videoType {VideoType} the type of the video source (camera or a screen capture).
+     * @param isMuted {boolean} whether the local video is muted.
+     * @param resolutionName {Resolution} the input resolution used by the camera.
+     * @returns {*} the newly calculated connection quality.
+     */
+    _calculateConnectionQuality(videoType: {
+        CAMERA: string;
+        DESKTOP: string;
+    }, isMuted: boolean, resolutionName: any): any;
+    /**
+     * Updates the localConnectionQuality value
+     * @param values {number} the new value. Should be in [0, 100].
+     */
+    _updateLocalConnectionQuality(value: any): void;
+    /**
+     * Broadcasts the local statistics to all other participants in the
+     * conference.
+     */
+    _broadcastLocalStats(): void;
+    /**
+     * Updates the local statistics
+     * @param {TraceablePeerConnection} tpc the peerconnection which emitted
+     * the stats
+     * @param data new statistics
+     */
+    _updateLocalStats(tpc: any, data: any): void;
+    /**
+     * Updates remote statistics
+     * @param id the id of the remote participant
+     * @param data the statistics received
+     */
+    _updateRemoteStats(id: any, data: any): void;
+    /**
+     * Returns the local statistics.
+     * Exported only for use in jitsi-meet-torture.
+     */
+    getStats(): {
+        connectionQuality: number;
+        jvbRTT: any;
+    };
+}

types/auto/modules/connectivity/IceFailedHandling.d.ts

@@ -0,0 +1,36 @@
+/**
+ * This class deals with shenanigans around JVB media session's ICE failed status handling.
+ *
+ * If ICE restarts are NOT explicitly enabled by the {@code enableIceRestart} config option, then the conference will
+ * delay emitting the {@JitsiConferenceErrors.ICE_FAILED} event by 15 seconds. If the network info module reports
+ * the internet offline status then the time will start counting after the internet comes back online.
+ *
+ * If ICE restart are enabled, then a delayed ICE failed notification to Jicofo will be sent, only if the ICE connection
+ * does not recover soon after or before the XMPP connection is restored (if it was ever broken). If ICE fails while
+ * the XMPP connection is not broken then the notifications will be sent after 2 seconds delay.
+ */
+export default class IceFailedHandling {
+    /**
+     * Creates new {@code DelayedIceFailed} task.
+     * @param {JitsiConference} conference
+     */
+    constructor(conference: any);
+    _conference: any;
+    /**
+     * After making sure there's no way for the ICE connection to recover this method either sends ICE failed
+     * notification to Jicofo or emits the ice failed conference event.
+     * @private
+     * @returns {void}
+     */
+    private _actOnIceFailed;
+    /**
+     * Starts the task.
+     */
+    start(): void;
+    _iceFailedTimeout: any;
+    /**
+     * Cancels the task.
+     */
+    cancel(): void;
+    _canceled: boolean;
+}

types/auto/modules/connectivity/NetworkInfo.d.ts

@@ -0,0 +1,33 @@
+export const NETWORK_INFO_EVENT: "NETWORK_INFO_CHANGED";
+/**
+ * Module provides information about the current status of the internet
+ * connection. Lib-jitsi-meet doesn't have any logic for detecting internet
+ * online/offline, but rather it relies on the information supplied by the app
+ * that uses it. By default the online state is assumed and the lib acts as if
+ * it was connected. See {@link JitsiMeetJS.setNetworkInfo}.
+ */
+export class NetworkInfo extends Listenable {
+    /**
+     * Creates new {@link NetworkInfo} instance.
+     */
+    constructor();
+    _current: {
+        isOnline: boolean;
+    };
+    /**
+     * Updates the network info state.
+     * @param {boolean} isOnline - {@code true} if internet is online or {@code false} otherwise.
+     */
+    updateNetworkInfo({ isOnline }: boolean): void;
+    /**
+     * Returns the online/offline internet status. By default the value is {@code true} and changes only if
+     * the lib's user wires the state through {@link JitsiMeetJS.setNetworkInfo} like the jitsi-meet does. Because of
+     * that any logic should still assume that the internet may be offline and should handle the failure gracefully.
+     * It's only a good hint in the other way around: to pause internet operations until it comes back online.
+     * @returns {boolean}
+     */
+    isOnline(): boolean;
+}
+export default networkInfo;
+import Listenable from "../util/Listenable";
+declare const networkInfo: NetworkInfo;

types/auto/modules/connectivity/ParticipantConnectionStatus.d.ts

@@ -0,0 +1,350 @@
+/**
+ * Participant connection statuses.
+ *
+ * @type {{
+ *      ACTIVE: string,
+ *      INACTIVE: string,
+ *      INTERRUPTED: string,
+ *      RESTORING: string
+ * }}
+ */
+export const ParticipantConnectionStatus: {
+    ACTIVE: string;
+    INACTIVE: string;
+    INTERRUPTED: string;
+    RESTORING: string;
+};
+/**
+ * Class is responsible for emitting
+ * JitsiConferenceEvents.PARTICIPANT_CONN_STATUS_CHANGED events.
+ */
+export default class ParticipantConnectionStatusHandler {
+    /**
+     * Calculates the new {@link ParticipantConnectionStatus} based on
+     * the values given for some specific remote user. It is assumed that
+     * the conference is currently in the JVB mode (in contrary to the P2P mode)
+     * @param {boolean} isConnectionActiveByJvb true if the JVB did not get any
+     * data from the user for the last 15 seconds.
+     * @param {boolean} isInLastN indicates whether the user is in the last N
+     * set. When set to false it means that JVB is not sending any video for
+     * the user.
+     * @param {boolean} isRestoringTimedout if true it means that the user has
+     * been outside of last N too long to be considered
+     * {@link ParticipantConnectionStatus.RESTORING}.
+     * @param {boolean} isVideoMuted true if the user is video muted and we
+     * should not expect to receive any video.
+     * @param {boolean} isVideoTrackFrozen if the current browser support video
+     * frozen detection then it will be set to true when the video track is
+     * frozen. If the current browser does not support frozen detection the it's
+     * always false.
+     * @return {ParticipantConnectionStatus} the new connection status for
+     * the user for whom the values above were provided.
+     * @private
+     */
+    private static _getNewStateForJvbMode;
+    /**
+     * In P2P mode we don't care about any values coming from the JVB and
+     * the connection status can be only active or interrupted.
+     * @param {boolean} isVideoMuted the user if video muted
+     * @param {boolean} isVideoTrackFrozen true if the video track for
+     * the remote user is currently frozen. If the current browser does not
+     * support video frozen detection then it's always false.
+     * @return {ParticipantConnectionStatus}
+     * @private
+     */
+    private static _getNewStateForP2PMode;
+    /**
+     * Creates new instance of <tt>ParticipantConnectionStatus</tt>.
+     *
+     * @constructor
+     * @param {RTC} rtc the RTC service instance
+     * @param {JitsiConference} conference parent conference instance
+     * @param {Object} options
+     * @param {number} [options.p2pRtcMuteTimeout=2500] custom value for
+     * {@link ParticipantConnectionStatus.p2pRtcMuteTimeout}.
+     * @param {number} [options.rtcMuteTimeout=2000] custom value for
+     * {@link ParticipantConnectionStatus.rtcMuteTimeout}.
+     * @param {number} [options.outOfLastNTimeout=500] custom value for
+     * {@link ParticipantConnectionStatus.outOfLastNTimeout}.
+     */
+    constructor(rtc: any, conference: any, options: {
+        p2pRtcMuteTimeout?: number;
+        rtcMuteTimeout?: number;
+        outOfLastNTimeout?: number;
+    });
+    rtc: any;
+    conference: any;
+    /**
+     * A map of the "endpoint ID"(which corresponds to the resource part
+     * of MUC JID(nickname)) to the timeout callback IDs scheduled using
+     * window.setTimeout.
+     * @type {Object.<string, number>}
+     */
+    trackTimers: {
+        [x: string]: number;
+    };
+    /**
+     * This map holds the endpoint connection status received from the JVB
+     * (as it might be different than the one stored in JitsiParticipant).
+     * Required for getting back in sync when remote video track is removed.
+     * @type {Object.<string, boolean>}
+     */
+    connStatusFromJvb: {
+        [x: string]: boolean;
+    };
+    /**
+     * If video track frozen detection through RTC mute event is supported,
+     * we wait some time until video track is considered frozen. But because
+     * when the user falls out of last N it is expected for the video to
+     * freeze this timeout must be significantly reduced in "out of last N"
+     * case.
+     *
+     * Basically this value is used instead of {@link rtcMuteTimeout} when
+     * user is not in last N.
+     * @type {number}
+     */
+    outOfLastNTimeout: number;
+    /**
+     * How long we are going to wait for the corresponding signaling mute event after the RTC video track muted
+     * event is fired on the Media stream, before the connection interrupted is fired. The default value is
+     * {@link DEFAULT_P2P_RTC_MUTE_TIMEOUT}.
+     *
+     * @type {number} amount of time in milliseconds.
+     */
+    p2pRtcMuteTimeout: number;
+    /**
+     * How long we're going to wait after the RTC video track muted event
+     * for the corresponding signalling mute event, before the connection
+     * interrupted is fired. The default value is
+     * {@link DEFAULT_RTC_MUTE_TIMEOUT}.
+     *
+     * @type {number} amount of time in milliseconds
+     */
+    rtcMuteTimeout: number;
+    /**
+     * This map holds a timestamp indicating  when participant's video track
+     * was RTC muted (it is assumed that each participant can have only 1
+     * video track at a time). The purpose of storing the timestamp is to
+     * avoid the transition to disconnected status in case of legitimate
+     * video mute operation where the signalling video muted event can
+     * arrive shortly after RTC muted event.
+     *
+     * The key is participant's ID which is the same as endpoint id in
+     * the Colibri conference allocated on the JVB.
+     *
+     * The value is a timestamp measured in milliseconds obtained with
+     * <tt>Date.now()</tt>.
+     *
+     * FIXME merge this logic with NO_DATA_FROM_SOURCE event
+     *       implemented in JitsiLocalTrack by extending the event to
+     *       the remote track and allowing to set different timeout for
+     *       local and remote tracks.
+     *
+     * @type {Object.<string, number>}
+     */
+    rtcMutedTimestamp: {
+        [x: string]: number;
+    };
+    /**
+     * This map holds the timestamps indicating when participant's video
+     * entered lastN set. Participants entering lastN will have connection
+     * status restoring and when we start receiving video will become
+     * active, but if video is not received for certain time
+     * {@link DEFAULT_RESTORING_TIMEOUT} that participant connection status
+     * will become interrupted.
+     *
+     * @type {Map<string, number>}
+     */
+    enteredLastNTimestamp: Map<string, number>;
+    /**
+     * A map of the "endpoint ID"(which corresponds to the resource part
+     * of MUC JID(nickname)) to the restoring timeout callback IDs
+     * scheduled using window.setTimeout.
+     *
+     * @type {Map<string, number>}
+     */
+    restoringTimers: Map<string, number>;
+    /**
+     * A map that holds the current connection status (along with all the internal events that happen
+     * while in that state).
+     *
+     * The goal is to send this information to the analytics backend for post-mortem analysis.
+     */
+    connectionStatusMap: Map<any, any>;
+    /**
+     * Gets the video frozen timeout for given user.
+     * @param {string} id endpoint/participant ID
+     * @return {number} how long are we going to wait since RTC video muted
+     * even, before a video track is considered frozen.
+     * @private
+     */
+    private _getVideoFrozenTimeout;
+    /**
+     * Initializes <tt>ParticipantConnectionStatus</tt> and bind required event
+     * listeners.
+     */
+    init(): void;
+    _onEndpointConnStatusChanged: any;
+    _onP2PStatus: any;
+    _onUserLeft: any;
+    _onTrackRtcMuted: any;
+    _onTrackRtcUnmuted: any;
+    _onRemoteTrackAdded: any;
+    _onRemoteTrackRemoved: any;
+    _onSignallingMuteChanged: any;
+    _onTrackVideoTypeChanged: any;
+    /**
+     * On change in Last N set check all leaving and entering participants to
+     * change their corresponding statuses.
+     *
+     * @param {Array<string>} leavingLastN - The array of ids leaving lastN.
+     * @param {Array<string>} enteringLastN - The array of ids entering lastN.
+     * @private
+     */
+    private _onLastNChanged;
+    _onLastNValueChanged: any;
+    /**
+     * Removes all event listeners and disposes of all resources held by this
+     * instance.
+     */
+    dispose(): void;
+    /**
+     * Handles RTCEvents.ENDPOINT_CONN_STATUS_CHANGED triggered when we receive
+     * notification over the data channel from the bridge about endpoint's
+     * connection status update.
+     * @param {string} endpointId - The endpoint ID(MUC nickname/resource JID).
+     * @param {boolean} isActive - true if the connection is OK or false otherwise.
+     */
+    onEndpointConnStatusChanged(endpointId: string, isActive: boolean): void;
+    /**
+     * Changes connection status.
+     * @param {JitsiParticipant} participant
+     * @param newStatus
+     */
+    _changeConnectionStatus(participant: any, newStatus: any): void;
+    /**
+     * Reset the postponed "connection interrupted" event which was previously
+     * scheduled as a timeout on RTC 'onmute' event.
+     *
+     * @param {string} participantId - The participant for which the "connection
+     * interrupted" timeout was scheduled.
+     */
+    clearTimeout(participantId: string): void;
+    /**
+     * Clears the timestamp of the RTC muted event for participant's video track
+     * @param {string} participantId the id of the conference participant which
+     * is the same as the Colibri endpoint ID of the video channel allocated for
+     * the user on the videobridge.
+     */
+    clearRtcMutedTimestamp(participantId: string): void;
+    /**
+     * Bind signalling mute event listeners for video {JitsiRemoteTrack} when
+     * a new one is added to the conference.
+     *
+     * @param {JitsiTrack} remoteTrack - The {JitsiTrack} which is being added to
+     * the conference.
+     */
+    onRemoteTrackAdded(remoteTrack: any): void;
+    /**
+     * Removes all event listeners bound to the remote video track and clears
+     * any related timeouts.
+     *
+     * @param {JitsiRemoteTrack} remoteTrack - The remote track which is being
+     * removed from the conference.
+     */
+    onRemoteTrackRemoved(remoteTrack: any): void;
+    /**
+     * Checks if given participant's video is considered frozen.
+     * @param {JitsiParticipant} participant - The participant.
+     * @return {boolean} <tt>true</tt> if the video has frozen for given
+     * participant or <tt>false</tt> when it's either not considered frozen
+     * (yet) or if freeze detection is not supported by the current browser.
+     *
+     * FIXME merge this logic with NO_DATA_FROM_SOURCE event
+     *       implemented in JitsiLocalTrack by extending the event to
+     *       the remote track and allowing to set different timeout for
+     *       local and remote tracks.
+     *
+     */
+    isVideoTrackFrozen(participant: any): boolean;
+    /**
+     * Goes over every participant and updates connectivity status.
+     * Should be called when a parameter which affects all of the participants
+     * is changed (P2P for example).
+     */
+    refreshConnectionStatusForAll(): void;
+    /**
+     * Figures out (and updates) the current connectivity status for
+     * the participant identified by the given id.
+     *
+     * @param {string} id - The participant's id (MUC nickname or Colibri endpoint ID).
+     */
+    figureOutConnectionStatus(id: string): void;
+    /**
+     * Computes the duration of the current connection status for the participant with the specified id (i.e. 15 seconds
+     * in the INTERRUPTED state) and sends a participant connection status event.
+     * @param {string} id - The jid of the participant.
+     * @param {Number} nowMs - The current time (in millis).
+     * @returns {void}
+     */
+    maybeSendParticipantConnectionStatusEvent(id: string, nowMs: number): void;
+    /**
+     * Clears the restoring timer for participant's video track and the
+     * timestamp for entering lastN.
+     *
+     * @param {string} participantId - The id of the conference participant which
+     * is the same as the Colibri endpoint ID of the video channel allocated for
+     * the user on the videobridge.
+     */
+    _clearRestoringTimer(participantId: string): void;
+    /**
+     * Checks whether a track had stayed enough in restoring state, compares
+     * current time and the time the track entered in lastN. If it hasn't
+     * timedout and there is no timer added, add new timer in order to give it
+     * more time to become active or mark it as interrupted on next check.
+     *
+     * @param {string} participantId - The id of the conference participant which
+     * is the same as the Colibri endpoint ID of the video channel allocated for
+     * the user on the videobridge.
+     * @returns {boolean} <tt>true</tt> if the track was in restoring state
+     * more than the timeout ({@link DEFAULT_RESTORING_TIMEOUT}.) in order to
+     * set its status to interrupted.
+     * @private
+     */
+    private _isRestoringTimedout;
+    /**
+     * Sends a last/final participant connection status event for the participant that left the conference.
+     * @param {string} id - The id of the participant that left the conference.
+     * @returns {void}
+     */
+    onUserLeft(id: string): void;
+    /**
+     * Handles RTC 'onmute' event for the video track.
+     *
+     * @param {JitsiRemoteTrack} track - The video track for which 'onmute' event
+     * will be processed.
+     */
+    onTrackRtcMuted(track: any): void;
+    /**
+     * Handles RTC 'onunmute' event for the video track.
+     *
+     * @param {JitsiRemoteTrack} track - The video track for which 'onunmute'
+     * event will be processed.
+     */
+    onTrackRtcUnmuted(track: any): void;
+    /**
+     * Here the signalling "mute"/"unmute" events are processed.
+     *
+     * @param {JitsiRemoteTrack} track - The remote video track for which
+     * the signalling mute/unmute event will be processed.
+     */
+    onSignallingMuteChanged(track: any): void;
+    /**
+     * Sends a participant connection status event as a result of the video type
+     * changing.
+     * @param {JitsiRemoteTrack} track - The track.
+     * @param {VideoType} type - The video type.
+     * @returns {void}
+     */
+    onTrackVideoTypeChanged(track: any, type: any): void;
+}

types/auto/modules/detection/ActiveDeviceDetector.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Go through all audio devices on the system and return one that is active, i.e. has audio signal.
+ *
+ * @returns Promise<Object> - Object containing information about the found device.
+ */
+export default function getActiveAudioDevice(): Promise<any>;

types/auto/modules/detection/DetectionEvents.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Event triggered by a audio detector indicating that its active state has changed from active to inactive or vice
+ * versa.
+ * @event
+ * @type {boolean} - true when service has changed to active false otherwise.
+ */
+export const DETECTOR_STATE_CHANGE: boolean;
+/** Event triggered by {@link NoAudioSignalDetector} when the local audio device associated with a JitsiConference
+ * starts receiving audio levels with the value of 0 meaning no audio is being captured on that device, or when
+ * it starts receiving audio levels !== 0 after being in a state of no audio.
+ * @event
+ * @type {boolean} - true when the current conference audio track has audio input false otherwise.
+ */
+export const AUDIO_INPUT_STATE_CHANGE: boolean;
+/** Event triggered by NoAudioSignalDetector when the local audio device associated with a JitsiConference goes silent
+ * for a period of time, meaning that the device is either broken or hardware/software muted.
+ * @event
+ * @type {void}
+ */
+export const NO_AUDIO_INPUT: void;
+/**
+ *  Event generated by {@link VADNoiseDetection} when the tracked device is considered noisy.
+ *  @event
+ *  @type {Object}
+ */
+export const VAD_NOISY_DEVICE: any;
+/**
+ * Event generated by VADReportingService when if finishes creating a VAD report for the monitored devices.
+ * The generated objects are of type Array<Object>, one score for each monitored device.
+ * @event VAD_REPORT_PUBLISHED
+ * @type Array<Object> with the following structure:
+ * @property {Date} timestamp - Timestamp at which the compute took place.
+ * @property {number} avgVAD - Average VAD score over monitored period of time.
+ * @property {string} deviceId - Associate local audio device ID.
+ */
+export const VAD_REPORT_PUBLISHED: Array<any>;
+/**
+ * Event generated by {@link TrackVADEmitter} when PCM sample VAD score is available.
+ *
+ * @event
+ * @type {Object}
+ * @property {Date}   timestamp - Exact time at which processed PCM sample was generated.
+ * @property {number} score - VAD score on a scale from 0 to 1 (i.e. 0.7)
+ * @property {Float32Array} pcmData - Raw PCM data with which the VAD score was calculated.
+ * @property {string} deviceId - Device id of the associated track.
+ */
+export const VAD_SCORE_PUBLISHED: any;
+/**
+ *  Event generated by {@link VADTalkMutedDetection} when a user is talking while the mic is muted.
+ *
+ *  @event
+ *  @type {Object}
+ */
+export const VAD_TALK_WHILE_MUTED: any;

types/auto/modules/detection/NoAudioSignalDetection.d.ts

@@ -0,0 +1,57 @@
+/// <reference types="node" />
+/**
+ * Detect if there is no audio input on the current TraceAblePeerConnection selected track. The no audio
+ * state must be constant for a configured amount of time in order for the event to be triggered.
+ * @fires DetectionEvents.AUDIO_INPUT_STATE_CHANGE
+ * @fires DetectionEvents.NO_AUDIO_INPUT
+ */
+export default class NoAudioSignalDetection extends EventEmitter {
+    /**
+     * Creates new NoAudioSignalDetection.
+     *
+     * @param conference the JitsiConference instance that created us.
+     * @constructor
+     */
+    constructor(conference: any);
+    _conference: any;
+    _timeoutTrigger: NodeJS.Timeout;
+    _hasAudioInput: boolean;
+    /**
+     * Clear the timeout state.
+     */
+    _clearTriggerTimeout(): void;
+    /**
+     * Generated event triggered by a change in the current conference audio input state.
+     *
+     * @param {*} audioLevel - The audio level of the ssrc.
+     * @fires DetectionEvents.AUDIO_INPUT_STATE_CHANGE
+     */
+    _handleAudioInputStateChange(audioLevel: any): void;
+    /**
+     * Generate event triggered by a prolonged period of no audio input.
+     *
+     * @param {number} audioLevel - The audio level of the ssrc.
+     * @fires DetectionEvents.NO_AUDIO_INPUT
+     */
+    _handleNoAudioInputDetection(audioLevel: number): void;
+    _eventFired: boolean;
+    /**
+     * Receives audio level events for all send and receive streams on the current TraceablePeerConnection.
+     *
+     * @param {TraceablePeerConnection} tpc - TraceablePeerConnection of the owning conference.
+     * @param {number} ssrc - The synchronization source identifier (SSRC) of the endpoint/participant/stream
+     * being reported.
+     * @param {number} audioLevel - The audio level of the ssrc.
+     * @param {boolean} isLocal - true for local/send streams or false for remote/receive streams.
+     */
+    _audioLevel(tpc: any, ssrc: number, audioLevel: number, isLocal: boolean): void;
+    /**
+     * Notifies NoAudioSignalDetection that a JitsiTrack was added to the associated JitsiConference.
+     * Only take into account local audio tracks.
+     *
+     * @param {JitsiTrack} track - The added JitsiTrack.
+     */
+    _trackAdded(track: any): void;
+    _audioTrack: any;
+}
+import EventEmitter from "events";

types/auto/modules/detection/P2PDominantSpeakerDetection.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The <tt>P2PDominantSpeakerDetection</tt> is activated only when p2p is
+ * currently used.
+ * Listens for changes in the audio level changes of the local p2p audio track
+ * or remote p2p one and fires dominant speaker events to be able to use
+ * features depending on those events (speaker stats), to make them work without
+ * the video bridge.
+ */
+export default class P2PDominantSpeakerDetection {
+    /**
+     * Creates P2PDominantSpeakerDetection
+     * @param conference the JitsiConference instance that created us.
+     * @constructor
+     */
+    constructor(conference: any);
+    conference: any;
+    myUserID: any;
+    /**
+     * Receives audio level events for all streams in the conference.
+     *
+     * @param {String} id - The participant id
+     * @param {number} audioLevel - The audio level.
+     */
+    _audioLevel(id: string, audioLevel: number): void;
+}

types/auto/modules/detection/TrackVADEmitter.d.ts

@@ -0,0 +1,129 @@
+/// <reference types="node" />
+/**
+ * Connects an audio JitsiLocalTrack to a vadProcessor using WebAudio ScriptProcessorNode.
+ * Once an object is created audio from the local track flows through the ScriptProcessorNode as raw PCM.
+ * The PCM is processed by the injected vad module and a voice activity detection score is obtained, the
+ * score is published to consumers via an EventEmitter.
+ * After work is done with this service the destroy method needs to be called for a proper cleanup.
+ *
+ * @fires VAD_SCORE_PUBLISHED
+ */
+export default class TrackVADEmitter extends EventEmitter {
+    /**
+     * Factory method that sets up all the necessary components for the creation of the TrackVADEmitter.
+     *
+     * @param {string} micDeviceId - Target microphone device id.
+     * @param {number} procNodeSampleRate - Sample rate of the proc node.
+     * @param {Object} vadProcessor -Module that calculates the voice activity score for a certain audio PCM sample.
+     * The processor needs to implement the following functions:
+     * - <tt>getSampleLength()</tt> - Returns the sample size accepted by getSampleLength.
+     * - <tt>getRequiredPCMFrequency()</tt> - Returns the PCM frequency at which the processor operates.
+     * - <tt>calculateAudioFrameVAD(pcmSample)</tt> - Process a 32 float pcm sample of getSampleLength size.
+     * @returns {Promise<TrackVADEmitter>} - Promise resolving in a new instance of TrackVADEmitter.
+     */
+    static create(micDeviceId: string, procNodeSampleRate: number, vadProcessor: any): Promise<TrackVADEmitter>;
+    /**
+     * Constructor.
+     *
+     * @param {number} procNodeSampleRate - Sample rate of the ScriptProcessorNode. Possible values  256, 512, 1024,
+     *  2048, 4096, 8192, 16384. Passing other values will default to closes neighbor.
+     * @param {Object} vadProcessor - VAD processor that allows us to calculate VAD score for PCM samples.
+     * @param {JitsiLocalTrack} jitsiLocalTrack - JitsiLocalTrack corresponding to micDeviceId.
+     */
+    constructor(procNodeSampleRate: number, vadProcessor: any, jitsiLocalTrack: any);
+    /**
+     * Sample rate of the ScriptProcessorNode.
+     */
+    _procNodeSampleRate: number;
+    /**
+     * VAD Processor that allows us to calculate VAD score for PCM samples
+     */
+    _vadProcessor: any;
+    /**
+     * The JitsiLocalTrack instance.
+     */
+    _localTrack: any;
+    /**
+     * Buffer to hold residue PCM resulting after a ScriptProcessorNode callback
+     */
+    _bufferResidue: Float32Array;
+    /**
+     * The AudioContext instance with the preferred sample frequency.
+     */
+    _audioContext: AudioContext;
+    /**
+     * PCM Sample size expected by the VAD Processor instance. We cache it here as this value is used extensively,
+     * saves a couple of function calls.
+     */
+    _vadSampleSize: any;
+    /**
+     * ScriptProcessorNode callback, the input parameters contains the PCM audio that is then sent to rnnoise.
+     * Rnnoise only accepts PCM samples of 480 bytes whereas the webaudio processor node can't sample at a multiple
+     * of 480 thus after each _onAudioProcess callback there will remain and PCM buffer residue equal
+     * to _procNodeSampleRate / 480 which will be added to the next sample buffer and so on.\
+     *
+     *
+     * @param {AudioProcessingEvent} audioEvent - Audio event.
+     * @returns {void}
+     * @fires VAD_SCORE_PUBLISHED
+     */
+    _onAudioProcess(audioEvent: AudioProcessingEvent): void;
+    /**
+     * Sets up the audio graph in the AudioContext.
+     *
+     * @returns {void}
+     */
+    _initializeAudioContext(): void;
+    _audioSource: MediaStreamAudioSourceNode;
+    _audioProcessingNode: ScriptProcessorNode;
+    /**
+     * Connects the nodes in the AudioContext to start the flow of audio data.
+     *
+     * @returns {void}
+     */
+    _connectAudioGraph(): void;
+    /**
+     * Disconnects the nodes in the AudioContext.
+     *
+     * @returns {void}
+     */
+    _disconnectAudioGraph(): void;
+    /**
+     * Cleanup potentially acquired resources.
+     *
+     * @returns {void}
+     */
+    _cleanupResources(): void;
+    /**
+     * Get the associated track device ID.
+     *
+     * @returns {string}
+     */
+    getDeviceId(): string;
+    /**
+     * Get the associated track label.
+     *
+     * @returns {string}
+     */
+    getTrackLabel(): string;
+    /**
+     * Start the emitter by connecting the audio graph.
+     *
+     * @returns {void}
+     */
+    start(): void;
+    /**
+     * Stops the emitter by disconnecting the audio graph.
+     *
+     * @returns {void}
+     */
+    stop(): void;
+    /**
+     * Destroy TrackVADEmitter instance (release resources and stop callbacks).
+     *
+     * @returns {void}
+     */
+    destroy(): void;
+    _destroyed: boolean;
+}
+import EventEmitter from "events";

types/auto/modules/detection/VADAudioAnalyser.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Connects a TrackVADEmitter to the target conference local audio track and manages various services that use
+ * the data to produce audio analytics (VADTalkMutedDetection and VADNoiseDetection).
+ */
+export default class VADAudioAnalyser extends EventEmitter {
+    /**
+     * Creates <tt>VADAudioAnalyser</tt>
+     * @param {JitsiConference} conference - JitsiConference instance that created us.
+     * @param {Object} createVADProcessor - Function that creates a Voice activity detection processor. The processor
+     * needs to implement the following functions:
+     * - <tt>getSampleLength()</tt> - Returns the sample size accepted by getSampleLength.
+     * - <tt>getRequiredPCMFrequency()</tt> - Returns the PCM frequency at which the processor operates.
+     * - <tt>calculateAudioFrameVAD(pcmSample)</tt> - Process a 32 float pcm sample of getSampleLength size.
+     * @constructor
+     */
+    constructor(conference: any, createVADProcessor: any);
+    /**
+     * Member function that instantiates a VAD processor.
+     */
+    _createVADProcessor: any;
+    /**
+     * Current {@link TrackVADEmitter}. VAD Emitter uses a {@link JitsiLocalTrack} and VAD processor to generate
+     * period voice probability scores.
+     */
+    _vadEmitter: TrackVADEmitter;
+    /**
+     * Current state of the _vadEmitter
+     */
+    _isVADEmitterRunning: boolean;
+    /**
+     * Array of currently attached VAD processing services.
+     */
+    _detectionServices: any[];
+    /**
+     * Promise used to chain create and destroy operations associated with TRACK_ADDED and TRACK_REMOVED events
+     * coming from the conference.
+     * Because we have an async created component (VAD Processor) we need to make sure that it's initialized before
+     * we destroy it ( when changing the device for instance), or when we use it from an external point of entry
+     * i.e. (TRACK_MUTE_CHANGED event callback).
+     */
+    _vadInitTracker: Promise<void>;
+    /**
+     * Listens for {@link TrackVADEmitter} events and directs them to attached services as needed.
+     *
+     * @param {Object} vadScore -VAD score emitted by {@link TrackVADEmitter}
+     * @param {Date}   vadScore.timestamp - Exact time at which processed PCM sample was generated.
+     * @param {number} vadScore.score - VAD score on a scale from 0 to 1 (i.e. 0.7)
+     * @param {Float32Array} pcmData - Raw PCM data with which the VAD score was calculated.
+     * @param {string} vadScore.deviceId - Device id of the associated track.
+     * @listens VAD_SCORE_PUBLISHED
+     */
+    _processVADScore(vadScore: {
+        timestamp: Date;
+        score: number;
+    }): void;
+    /**
+     * Attach a VAD detector service to the analyser and handle it's state changes.
+     *
+     * @param {Object} vadTMDetector
+     */
+    addVADDetectionService(vadService: any): void;
+    /**
+     * Start the {@link TrackVADEmitter} and attach the event listener.
+     * @returns {void}
+     */
+    _startVADEmitter(): void;
+    /**
+     * Stop the {@link TrackVADEmitter} and detach the event listener.
+     * @returns {void}
+     */
+    _stopVADEmitter(): void;
+    /**
+     * Change the isMuted state of all attached detection services.
+     *
+     * @param {boolean} isMuted
+     */
+    _changeDetectorsMuteState(isMuted: boolean): void;
+    /**
+     * Notifies the detector that a track was added to the associated {@link JitsiConference}.
+     * Only take into account local audio tracks.
+     * @param {JitsiTrack} track - The added track.
+     * @returns {void}
+     * @listens TRACK_ADDED
+     */
+    _trackAdded(track: any): void;
+    /**
+     * Notifies the detector that the mute state of a {@link JitsiConference} track has changed. Only takes into account
+     * local audio tracks.
+     * @param {JitsiTrack} track - The track whose mute state has changed.
+     * @returns {void}
+     * @listens TRACK_MUTE_CHANGED
+     */
+    _trackMuteChanged(track: any): void;
+    /**
+     * Notifies the detector that a track associated with the {@link JitsiConference} was removed. Only takes into
+     * account local audio tracks. Cleans up resources associated with the track and resets the processing context.
+     *
+     * @param {JitsiTrack} track - The removed track.
+     * @returns {void}
+     * @listens TRACK_REMOVED
+     */
+    _trackRemoved(track: any): void;
+}
+import { EventEmitter } from "events";
+import TrackVADEmitter from "./TrackVADEmitter";

types/auto/modules/detection/VADNoiseDetection.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Detect if provided VAD score and PCM data is considered noise.
+ */
+export default class VADNoiseDetection extends EventEmitter {
+    /**
+     * Creates <tt>VADNoiseDetection</tt>
+     *
+     * @constructor
+     */
+    constructor();
+    /**
+     * Flag which denotes the current state of the detection service i.e.if there is already a processing operation
+     * ongoing.
+     */
+    _processing: boolean;
+    /**
+     * Buffer that keeps the VAD scores for a period of time.
+     */
+    _scoreArray: any[];
+    /**
+     * Buffer that keeps audio level samples for a period of time.
+     */
+    _audioLvlArray: any[];
+    /**
+     * Current state of the service, if it's not active no processing will occur.
+     */
+    _active: boolean;
+    /**
+     * Compute cumulative VAD score and PCM audio levels once the PROCESS_TIME_FRAME_SPAN_MS timeout has elapsed.
+     * If the score is above the set threshold fire the event.
+     * @returns {void}
+     * @fires VAD_NOISY_DEVICE
+     */
+    _calculateNoisyScore(): void;
+    /**
+     * Record the vad score and average volume in the appropriate buffers.
+     *
+     * @param {number} vadScore
+     * @param {number} avgAudioLvl - average audio level of the PCM sample associated with the VAD score.s
+     */
+    _recordValues(vadScore: number, avgAudioLvl: number): void;
+    /**
+     * Set the active state of the detection service and notify any listeners.
+     *
+     * @param {boolean} active
+     * @fires DETECTOR_STATE_CHANGE
+     */
+    _setActiveState(active: boolean): void;
+    /**
+     * Change the state according to the muted status of the tracked device.
+     *
+     * @param {boolean} isMuted - Is the device muted or not.
+     */
+    changeMuteState(isMuted: boolean): void;
+    /**
+     * Check whether or not the service is active or not.
+     *
+     * @returns {boolean}
+     */
+    isActive(): boolean;
+    /**
+     * Reset the processing context, clear buffers, cancel the timeout trigger.
+     *
+     * @returns {void}
+     */
+    reset(): void;
+    /**
+     * Listens for {@link TrackVADEmitter} events and processes them.
+     *
+     * @param {Object} vadScore -VAD score emitted by {@link TrackVADEmitter}
+     * @param {Date}   vadScore.timestamp - Exact time at which processed PCM sample was generated.
+     * @param {number} vadScore.score - VAD score on a scale from 0 to 1 (i.e. 0.7)
+     * @param {Float32Array} vadScore.pcmData - Raw PCM Data associated with the VAD score.
+     * @param {string} vadScore.deviceId - Device id of the associated track.
+     * @listens VAD_SCORE_PUBLISHED
+     */
+    processVADScore(vadScore: {
+        timestamp: Date;
+        score: number;
+        pcmData: Float32Array;
+        deviceId: string;
+    }): void;
+    _processTimeout: NodeJS.Timeout;
+}
+import { EventEmitter } from "events";

types/auto/modules/detection/VADReportingService.d.ts

@@ -0,0 +1,96 @@
+/// <reference types="node" />
+/**
+ * Voice activity detection reporting service. The service create TrackVADEmitters for the provided devices and
+ * publishes an average of their VAD score over the specified interval via EventEmitter.
+ * The service is not reusable if destroyed a new one needs to be created, i.e. when a new device is added to the system
+ * a new service needs to be created and the old discarded.
+ */
+export default class VADReportingService extends EventEmitter {
+    /**
+     * Factory methods that creates the TrackVADEmitters for the associated array of devices and instantiates
+     * a VADReportingService.
+     *
+     * @param {Array<MediaDeviceInfo>} micDeviceList - Device list that is monitored inside the service.
+     * @param {number} intervalDelay - Delay at which to publish VAD score for monitored devices.
+     * @param {Object} createVADProcessor - Function that creates a Voice activity detection processor. The processor
+     * needs to implement the following functions:
+     * - <tt>getSampleLength()</tt> - Returns the sample size accepted by getSampleLength.
+     * - <tt>getRequiredPCMFrequency()</tt> - Returns the PCM frequency at which the processor operates.
+     * - <tt>calculateAudioFrameVAD(pcmSample)</tt> - Process a 32 float pcm sample of getSampleLength size.
+     *
+     * @returns {Promise<VADReportingService>}
+     */
+    static create(micDeviceList: Array<MediaDeviceInfo>, intervalDelay: number, createVADProcessor: any): Promise<VADReportingService>;
+    /**
+     *
+     * @param {number} intervalDelay - Delay at which to publish VAD score for monitored devices.
+     *
+     * @constructor
+     */
+    constructor(intervalDelay: number);
+    /**
+     * Map containing context for devices currently being monitored by the reporting service.
+     */
+    _contextMap: Map<any, any>;
+    /**
+     * State flag, check if the instance was destroyed.
+     */
+    _destroyed: boolean;
+    /**
+     * Delay at which to publish VAD score for monitored devices.
+     */
+    _intervalDelay: number;
+    /**
+     * Identifier for the interval publishing stats on the set interval.
+     */
+    _intervalId: NodeJS.Timer;
+    /**
+     * Destroy TrackVADEmitters and clear the context map.
+     *
+     * @returns {void}
+     */
+    _clearContextMap(): void;
+    /**
+     * Set the watched device contexts.
+     *
+     * @param {Array<VADDeviceContext>} vadContextArray - List of mics.
+     * @returns {void}
+     */
+    _setVADContextArray(vadContextArray: Array<any>): void;
+    /**
+     * Start the setInterval reporting process.
+     *
+     * @returns {void}.
+     */
+    _startPublish(): void;
+    /**
+     * Function called at set interval with selected compute. The result will be published on the set callback.
+     *
+     * @returns {void}
+     * @fires VAD_REPORT_PUBLISHED
+     */
+    _reportVadScore(): void;
+    /**
+     * Callback method passed to vad emitters in order to publish their score.
+     *
+     * @param {Object} vadScore -VAD score emitted by.
+     * @param {Date}   vadScore.timestamp - Exact time at which processed PCM sample was generated.
+     * @param {number} vadScore.score - VAD score on a scale from 0 to 1 (i.e. 0.7).
+     * @param {string} vadScore.deviceId - Device id of the associated track.
+     * @returns {void}
+     * @listens VAD_SCORE_PUBLISHED
+     */
+    _devicePublishVADScore(vadScore: {
+        timestamp: Date;
+        score: number;
+        deviceId: string;
+    }): void;
+    /**
+     * Destroy the VADReportingService, stops the setInterval reporting, destroys the emitters and clears the map.
+     * After this call the instance is no longer usable.
+     *
+     * @returns {void}.
+     */
+    destroy(): void;
+}
+import EventEmitter from "events";

types/auto/modules/detection/VADTalkMutedDetection.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Detect if provided VAD score which is generated on a muted device is voice and fires an event.
+ */
+export default class VADTalkMutedDetection extends EventEmitter {
+    /**
+     * Creates <tt>VADTalkMutedDetection</tt>
+     * @constructor
+     */
+    constructor();
+    /**
+     * Flag which denotes the current state of the detection service i.e.if there is already a processing operation
+     * ongoing.
+     */
+    _processing: boolean;
+    /**
+     * Buffer that keeps the VAD scores for a period of time.
+     */
+    _scoreArray: any[];
+    /**
+     * Current mute state of the audio track being monitored.
+     */
+    _active: boolean;
+    /**
+     * Compute cumulative VAD score function called once the PROCESS_TIME_FRAME_SPAN_MS timeout has elapsed.
+     * @returns {void}
+     * @fires VAD_TALK_WHILE_MUTED
+     */
+    _calculateVADScore(): void;
+    /**
+     * Set the active state of the detection service and notify any listeners.
+     *
+     * @param {boolean} active
+     * @fires DETECTOR_STATE_CHANGE
+     */
+    _setActiveState(active: boolean): void;
+    /**
+     * Change the state according to the muted status of the tracked device.
+     *
+     * @param {boolean} isMuted - Is the device muted or not.
+     */
+    changeMuteState(isMuted: boolean): void;
+    /**
+     * Check whether or not the service is active or not.
+     *
+     * @returns {boolean}
+     */
+    isActive(): boolean;
+    /**
+     * Listens for {@link TrackVADEmitter} events and processes them.
+     *
+     * @param {Object} vadScore -VAD score emitted by {@link TrackVADEmitter}
+     * @param {Date}   vadScore.timestamp - Exact time at which processed PCM sample was generated.
+     * @param {number} vadScore.score - VAD score on a scale from 0 to 1 (i.e. 0.7)
+     * @param {string} vadScore.deviceId - Device id of the associated track.
+     * @listens VAD_SCORE_PUBLISHED
+     */
+    processVADScore(vadScore: {
+        timestamp: Date;
+        score: number;
+        deviceId: string;
+    }): void;
+    _processTimeout: NodeJS.Timeout;
+    /**
+     * Reset the processing context, clear buffer, cancel the timeout trigger.
+     *
+     * @returns {void}
+     */
+    reset(): void;
+}
+import { EventEmitter } from "events";

types/auto/modules/e2ee/Context.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Per-participant context holding the cryptographic keys and
+ * encode/decode functions
+ */
+export class Context {
+    /**
+     * @param {Object} options
+     */
+    constructor({ sharedKey }?: any);
+    _cryptoKeyRing: any[];
+    _currentKeyIndex: number;
+    _sendCounts: Map<any, any>;
+    _sharedKey: any;
+    /**
+     * Derives the different subkeys and starts using them for encryption or
+     * decryption.
+     * @param {Uint8Array|false} key bytes. Pass false to disable.
+     * @param {Number} keyIndex
+     */
+    setKey(key: Uint8Array | false, keyIndex?: number): Promise<void>;
+    /**
+     * Sets a set of keys and resets the sendCount.
+     * decryption.
+     * @param {Object} keys set of keys.
+     * @param {Number} keyIndex optional
+     * @private
+     */
+    private _setKeys;
+    _sendCount: bigint;
+    /**
+     * Function that will be injected in a stream and will encrypt the given encoded frames.
+     *
+     * @param {RTCEncodedVideoFrame|RTCEncodedAudioFrame} encodedFrame - Encoded video frame.
+     * @param {TransformStreamDefaultController} controller - TransportStreamController.
+     *
+     * The VP8 payload descriptor described in
+     * https://tools.ietf.org/html/rfc7741#section-4.2
+     * is part of the RTP packet and not part of the frame and is not controllable by us.
+     * This is fine as the SFU keeps having access to it for routing.
+     *
+     * The encrypted frame is formed as follows:
+     * 1) Leave the first (10, 3, 1) bytes unencrypted, depending on the frame type and kind.
+     * 2) Form the GCM IV for the frame as described above.
+     * 3) Encrypt the rest of the frame using AES-GCM.
+     * 4) Allocate space for the encrypted frame.
+     * 5) Copy the unencrypted bytes to the start of the encrypted frame.
+     * 6) Append the ciphertext to the encrypted frame.
+     * 7) Append the IV.
+     * 8) Append a single byte for the key identifier.
+     * 9) Enqueue the encrypted frame for sending.
+     */
+    encodeFunction(encodedFrame: any | any, controller: TransformStreamDefaultController): Promise<void>;
+    /**
+     * Function that will be injected in a stream and will decrypt the given encoded frames.
+     *
+     * @param {RTCEncodedVideoFrame|RTCEncodedAudioFrame} encodedFrame - Encoded video frame.
+     * @param {TransformStreamDefaultController} controller - TransportStreamController.
+     */
+    decodeFunction(encodedFrame: any | any, controller: TransformStreamDefaultController): Promise<void>;
+    /**
+     * Function that will decrypt the given encoded frame. If the decryption fails, it will
+     * ratchet the key for up to RATCHET_WINDOW_SIZE times.
+     *
+     * @param {RTCEncodedVideoFrame|RTCEncodedAudioFrame} encodedFrame - Encoded video frame.
+     * @param {number} keyIndex - the index of the decryption data in _cryptoKeyRing array.
+     * @param {number} ratchetCount - the number of retries after ratcheting the key.
+     * @returns {RTCEncodedVideoFrame|RTCEncodedAudioFrame} - The decrypted frame.
+     * @private
+     */
+    private _decryptFrame;
+    /**
+     * Construct the IV used for AES-GCM and sent (in plain) with the packet similar to
+     * https://tools.ietf.org/html/rfc7714#section-8.1
+     * It concatenates
+     * - the 32 bit synchronization source (SSRC) given on the encoded frame,
+     * - the 32 bit rtp timestamp given on the encoded frame,
+     * - a send counter that is specific to the SSRC. Starts at a random number.
+     * The send counter is essentially the pictureId but we currently have to implement this ourselves.
+     * There is no XOR with a salt. Note that this IV leaks the SSRC to the receiver but since this is
+     * randomly generated and SFUs may not rewrite this is considered acceptable.
+     * The SSRC is used to allow demultiplexing multiple streams with the same key, as described in
+     *   https://tools.ietf.org/html/rfc3711#section-4.1.1
+     * The RTP timestamp is 32 bits and advances by the codec clock rate (90khz for video, 48khz for
+     * opus audio) every second. For video it rolls over roughly every 13 hours.
+     * The send counter will advance at the frame rate (30fps for video, 50fps for 20ms opus audio)
+     * every second. It will take a long time to roll over.
+     *
+     * See also https://developer.mozilla.org/en-US/docs/Web/API/AesGcmParams
+     */
+    _makeIV(synchronizationSource: any, timestamp: any): ArrayBuffer;
+}

types/auto/modules/e2ee/E2EEContext.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Context encapsulating the cryptography bits required for E2EE.
+ * This uses the WebRTC Insertable Streams API which is explained in
+ *   https://github.com/alvestrand/webrtc-media-streams/blob/master/explainer.md
+ * that provides access to the encoded frames and allows them to be transformed.
+ *
+ * The encoded frame format is explained below in the _encodeFunction method.
+ * High level design goals were:
+ * - do not require changes to existing SFUs and retain (VP8) metadata.
+ * - allow the SFU to rewrite SSRCs, timestamp, pictureId.
+ * - allow for the key to be rotated frequently.
+ */
+export default class E2EEcontext {
+    /**
+     * Build a new E2EE context instance, which will be used in a given conference.
+     * @param {boolean} [options.sharedKey] - whether there is a uniques key shared amoung all participants.
+     */
+    constructor({ sharedKey }?: boolean);
+    _worker: Worker;
+    /**
+     * Cleans up all state associated with the given participant. This is needed when a
+     * participant leaves the current conference.
+     *
+     * @param {string} participantId - The participant that just left.
+     */
+    cleanup(participantId: string): void;
+    /**
+     * Cleans up all state associated with all participants in the conference. This is needed when disabling e2ee.
+     *
+     */
+    cleanupAll(): void;
+    /**
+     * Handles the given {@code RTCRtpReceiver} by creating a {@code TransformStream} which will inject
+     * a frame decoder.
+     *
+     * @param {RTCRtpReceiver} receiver - The receiver which will get the decoding function injected.
+     * @param {string} kind - The kind of track this receiver belongs to.
+     * @param {string} participantId - The participant id that this receiver belongs to.
+     */
+    handleReceiver(receiver: RTCRtpReceiver, kind: string, participantId: string): void;
+    /**
+     * Handles the given {@code RTCRtpSender} by creating a {@code TransformStream} which will inject
+     * a frame encoder.
+     *
+     * @param {RTCRtpSender} sender - The sender which will get the encoding function injected.
+     * @param {string} kind - The kind of track this sender belongs to.
+     * @param {string} participantId - The participant id that this sender belongs to.
+     */
+    handleSender(sender: RTCRtpSender, kind: string, participantId: string): void;
+    /**
+     * Set the E2EE key for the specified participant.
+     *
+     * @param {string} participantId - the ID of the participant who's key we are setting.
+     * @param {Uint8Array | boolean} key - they key for the given participant.
+     * @param {Number} keyIndex - the key index.
+     */
+    setKey(participantId: string, key: Uint8Array | boolean, keyIndex: number): void;
+}

types/auto/modules/e2ee/E2EEncryption.d.ts

@@ -0,0 +1,42 @@
+/**
+ * This module integrates {@link KeyHandler} with {@link JitsiConference} in order to enable E2E encryption.
+ */
+export class E2EEncryption {
+    /**
+     * Indicates if E2EE is supported in the current platform.
+     *
+     * @param {object} config - Global configuration.
+     * @returns {boolean}
+     */
+    static isSupported(config: object): boolean;
+    /**
+     * A constructor.
+     * @param {JitsiConference} conference - The conference instance for which E2E encryption is to be enabled.
+     */
+    constructor(conference: any);
+    _externallyManaged: any;
+    _keyHandler: ExternallyManagedKeyHandler | ManagedKeyHandler;
+    /**
+     * Indicates whether E2EE is currently enabled or not.
+     *
+     * @returns {boolean}
+     */
+    isEnabled(): boolean;
+    /**
+     * Enables / disables End-To-End encryption.
+     *
+     * @param {boolean} enabled - whether E2EE should be enabled or not.
+     * @returns {void}
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * Sets the key and index for End-to-End encryption.
+     *
+     * @param {CryptoKey} [keyInfo.encryptionKey] - encryption key.
+     * @param {Number} [keyInfo.index] - the index of the encryption key.
+     * @returns {void}
+     */
+    setEncryptionKey(keyInfo: any): void;
+}
+import { ExternallyManagedKeyHandler } from "./ExternallyManagedKeyHandler";
+import { ManagedKeyHandler } from "./ManagedKeyHandler";

types/auto/modules/e2ee/ExternallyManagedKeyHandler.d.ts

@@ -0,0 +1,19 @@
+/**
+ * This module integrates {@link E2EEContext} with {external} in order to set the keys for encryption.
+ */
+export class ExternallyManagedKeyHandler extends KeyHandler {
+    /**
+     * Build a new ExternallyManagedKeyHandler instance, which will be used in a given conference.
+     * @param conference - the current conference.
+     */
+    constructor(conference: any);
+    /**
+     * Sets the key and index for End-to-End encryption.
+     *
+     * @param {CryptoKey} [keyInfo.encryptionKey] - encryption key.
+     * @param {Number} [keyInfo.index] - the index of the encryption key.
+     * @returns {void}
+     */
+    setKey(keyInfo: any): void;
+}
+import { KeyHandler } from "./KeyHandler";

types/auto/modules/e2ee/KeyHandler.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Abstract class that integrates {@link E2EEContext} with a key management system.
+ */
+export class KeyHandler extends Listenable {
+    /**
+     * Build a new KeyHandler instance, which will be used in a given conference.
+     * @param {JitsiConference} conference - the current conference.
+     * @param {object} options - the options passed to {E2EEContext}, see implemention.
+     */
+    constructor(conference: any, options?: object);
+    conference: any;
+    e2eeCtx: E2EEContext;
+    enabled: boolean;
+    _enabling: Deferred;
+    /**
+     * Indicates whether E2EE is currently enabled or not.
+     *
+     * @returns {boolean}
+     */
+    isEnabled(): boolean;
+    /**
+     * Enables / disables End-To-End encryption.
+     *
+     * @param {boolean} enabled - whether E2EE should be enabled or not.
+     * @returns {void}
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * Sets the key for End-to-End encryption.
+     *
+     * @returns {void}
+     */
+    setEncryptionKey(): void;
+    /**
+     * Setup E2EE on the new track that has been added to the conference, apply it on all the open peerconnections.
+     * @param {JitsiLocalTrack} track - the new track that's being added to the conference.
+     * @private
+     */
+    private _onLocalTrackAdded;
+    /**
+     * Setups E2E encryption for the new session.
+     * @param {JingleSessionPC} session - the new media session.
+     * @private
+     */
+    private _onMediaSessionStarted;
+    /**
+     * Setup E2EE for the receiving side.
+     *
+     * @private
+     */
+    private _setupReceiverE2EEForTrack;
+    /**
+     * Setup E2EE for the sending side.
+     *
+     * @param {JingleSessionPC} session - the session which sends the media produced by the track.
+     * @param {JitsiLocalTrack} track - the local track for which e2e encoder will be configured.
+     * @private
+     */
+    private _setupSenderE2EEForTrack;
+    /**
+     * Setup E2EE on the sender that is created for the unmuted local video track.
+     * @param {JitsiLocalTrack} track - the track for which muted status has changed.
+     * @private
+     */
+    private _trackMuteChanged;
+}
+import Listenable from "../util/Listenable";
+import E2EEContext from "./E2EEContext";
+import Deferred from "../util/Deferred";

types/auto/modules/e2ee/ManagedKeyHandler.d.ts

@@ -0,0 +1,73 @@
+/**
+ * This module integrates {@link E2EEContext} with {@link OlmAdapter} in order to distribute the keys for encryption.
+ */
+export class ManagedKeyHandler extends KeyHandler {
+    /**
+     * Build a new AutomaticKeyHandler instance, which will be used in a given conference.
+     */
+    constructor(conference: any);
+    _key: any;
+    _conferenceJoined: boolean;
+    _olmAdapter: OlmAdapter;
+    _rotateKey: any;
+    _ratchetKey: any;
+    /**
+     * When E2EE is enabled it initializes sessions and sets the key.
+     * Cleans up the sessions when disabled.
+     *
+     * @param {boolean} enabled - whether E2EE should be enabled or not.
+     * @returns {void}
+     */
+    _setEnabled(enabled: boolean): void;
+    /**
+     * Handles an update in a participant's presence property.
+     *
+     * @param {JitsiParticipant} participant - The participant.
+     * @param {string} name - The name of the property that changed.
+     * @param {*} oldValue - The property's previous value.
+     * @param {*} newValue - The property's new value.
+     * @private
+     */
+    private _onParticipantPropertyChanged;
+    /**
+     * Advances (using ratcheting) the current key when a new participant joins the conference.
+     * @private
+     */
+    private _onParticipantJoined;
+    /**
+     * Rotates the current key when a participant leaves the conference.
+     * @private
+     */
+    private _onParticipantLeft;
+    /**
+     * Rotates the local key. Rotating the key implies creating a new one, then distributing it
+     * to all participants and once they all received it, start using it.
+     *
+     * @private
+     */
+    private _rotateKeyImpl;
+    /**
+     * Advances the current key by using ratcheting.
+     *
+     * @private
+     */
+    private _ratchetKeyImpl;
+    /**
+     * Handles an update in a participant's key.
+     *
+     * @param {string} id - The participant ID.
+     * @param {Uint8Array | boolean} key - The new key for the participant.
+     * @param {Number} index - The new key's index.
+     * @private
+     */
+    private _onParticipantKeyUpdated;
+    /**
+     * Generates a new 256 bit random key.
+     *
+     * @returns {Uint8Array}
+     * @private
+     */
+    private _generateKey;
+}
+import { KeyHandler } from "./KeyHandler";
+import { OlmAdapter } from "./OlmAdapter";

types/auto/modules/e2ee/OlmAdapter.d.ts

@@ -0,0 +1,166 @@
+/**
+ * This class implements an End-to-End Encrypted communication channel between every two peers
+ * in the conference. This channel uses libolm to achieve E2EE.
+ *
+ * The created channel is then used to exchange the secret key that each participant will use
+ * to encrypt the actual media (see {@link E2EEContext}).
+ *
+ * A simple JSON message based protocol is implemented, which follows a request - response model:
+ * - session-init: Initiates an olm session establishment procedure. This message will be sent
+ *                 by the participant who just joined, to everyone else.
+ * - session-ack: Completes the olm session etablishment. This messsage may contain ancilliary
+ *                encrypted data, more specifically the sender's current key.
+ * - key-info: Includes the sender's most up to date key information.
+ * - key-info-ack: Acknowledges the reception of a key-info request. In addition, it may contain
+ *                 the sender's key information, if available.
+ * - error: Indicates a request processing error has occurred.
+ *
+ * These requessts and responses are transport independent. Currently they are sent using XMPP
+ * MUC private messages.
+ */
+export class OlmAdapter extends Listenable {
+    /**
+     * Indicates if olm is supported on the current platform.
+     *
+     * @returns {boolean}
+     */
+    static isSupported(): boolean;
+    /**
+     * Creates an adapter instance for the given conference.
+     */
+    constructor(conference: any);
+    _conf: any;
+    _init: Deferred;
+    _key: boolean | Uint8Array;
+    _keyIndex: number;
+    _reqs: Map<any, any>;
+    _sessionInitialization: Deferred;
+    /**
+     * Starts new olm sessions with every other participant that has the participantId "smaller" the localParticipantId.
+     */
+    initSessions(): Promise<void>;
+    /**
+     * Updates the current participant key and distributes it to all participants in the conference
+     * by sending a key-info message.
+     *
+     * @param {Uint8Array|boolean} key - The new key.
+     * @retrns {Promise<Number>}
+     */
+    updateKey(key: Uint8Array | boolean): Promise<number>;
+    /**
+     * Updates the current participant key.
+     * @param {Uint8Array|boolean} key - The new key.
+     * @returns {number}
+    */
+    updateCurrentKey(key: Uint8Array | boolean): number;
+    /**
+     * Frees the olmData session for the given participant.
+     *
+     */
+    clearParticipantSession(participant: any): void;
+    /**
+     * Frees the olmData sessions for all participants.
+     *
+     */
+    clearAllParticipantsSessions(): void;
+    /**
+     * Internal helper to bootstrap the olm library.
+     *
+     * @returns {Promise<void>}
+     * @private
+     */
+    private _bootstrapOlm;
+    _olmAccount: any;
+    _idKey: any;
+    /**
+     * Publishes our own Olmn id key in presence.
+     * @private
+     */
+    private _onIdKeyReady;
+    /**
+     * Event posted when the E2EE signalling channel has been established with the given participant.
+     * @private
+     */
+    private _onParticipantE2EEChannelReady;
+    /**
+     * Internal helper for encrypting the current key information for a given participant.
+     *
+     * @param {Olm.Session} session - Participant's session.
+     * @returns {string} - The encrypted text with the key information.
+     * @private
+     */
+    private _encryptKeyInfo;
+    /**
+     * Internal helper for getting the olm related data associated with a participant.
+     *
+     * @param {JitsiParticipant} participant - Participant whose data wants to be extracted.
+     * @returns {Object}
+     * @private
+     */
+    private _getParticipantOlmData;
+    /**
+     * Handles leaving the conference, cleaning up olm sessions.
+     *
+     * @private
+     */
+    private _onConferenceLeft;
+    /**
+     * Main message handler. Handles 1-to-1 messages received from other participants
+     * and send the appropriate replies.
+     *
+     * @private
+     */
+    private _onEndpointMessageReceived;
+    /**
+     * Handles a participant leaving. When a participant leaves their olm session is destroyed.
+     *
+     * @private
+     */
+    private _onParticipantLeft;
+    /**
+    * Handles an update in a participant's presence property.
+    *
+    * @param {JitsiParticipant} participant - The participant.
+    * @param {string} name - The name of the property that changed.
+    * @param {*} oldValue - The property's previous value.
+    * @param {*} newValue - The property's new value.
+    * @private
+    */
+    private _onParticipantPropertyChanged;
+    /**
+     * Builds and sends an error message to the target participant.
+     *
+     * @param {JitsiParticipant} participant - The target participant.
+     * @param {string} error - The error message.
+     * @returns {void}
+     */
+    _sendError(participant: any, error: string): void;
+    /**
+     * Internal helper to send the given object to the given participant ID.
+     * This function merely exists so the transport can be easily swapped.
+     * Currently messages are transmitted via XMPP MUC private messages.
+     *
+     * @param {object} data - The data that will be sent to the target participant.
+     * @param {string} participantId - ID of the target participant.
+     */
+    _sendMessage(data: object, participantId: string): void;
+    /**
+     * Builds and sends the session-init request to the target participant.
+     *
+     * @param {JitsiParticipant} participant - Participant to whom we'll send the request.
+     * @returns {Promise} - The promise will be resolved when the session-ack is received.
+     * @private
+     */
+    private _sendSessionInit;
+}
+export namespace OlmAdapter {
+    export { OlmAdapterEvents as events };
+}
+import Listenable from "../util/Listenable";
+import Deferred from "../util/Deferred";
+declare namespace OlmAdapterEvents {
+    const OLM_ID_KEY_READY: string;
+    const PARTICIPANT_E2EE_CHANNEL_READY: string;
+    const PARTICIPANT_KEY_UPDATED: string;
+}
+export {};

types/auto/modules/e2ee/Worker.d.ts

@@ -0,0 +1 @@
+export {};

types/auto/modules/e2ee/crypto-utils.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Derives a set of keys from the master key.
+ * @param {CryptoKey} material - master key to derive from
+ *
+ * See https://tools.ietf.org/html/draft-omara-sframe-00#section-4.3.1
+ */
+export function deriveKeys(material: CryptoKey): Promise<{
+    material: CryptoKey;
+    encryptionKey: CryptoKey;
+}>;
+/**
+ * Ratchets a key. See
+ * https://tools.ietf.org/html/draft-omara-sframe-00#section-4.3.5.1
+ * @param {CryptoKey} material - base key material
+ * @returns {ArrayBuffer} - ratcheted key material
+ */
+export function ratchet(material: CryptoKey): ArrayBuffer;
+/**
+ * Converts a raw key into a WebCrypto key object with default options
+ * suitable for our usage.
+ * @param {ArrayBuffer} keyBytes - raw key
+ * @param {Array} keyUsages - key usages, see importKey documentation
+ * @returns {CryptoKey} - the WebCrypto key.
+ */
+export function importKey(keyBytes: ArrayBuffer): CryptoKey;

types/auto/modules/e2ee/utils.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Compares two byteArrays for equality.
+ */
+export function isArrayEqual(a1: any, a2: any): boolean;

types/auto/modules/e2eping/e2eping.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Implements end-to-end ping (from one conference participant to another) via
+ * the jitsi-videobridge channel (either WebRTC data channel or web socket).
+ *
+ * TODO: use a broadcast message instead of individual pings to each remote
+ * participant.
+ *
+ * This class:
+ * 1. Sends periodic ping requests to all other participants in the
+ * conference.
+ * 2. Responds to ping requests from other participants.
+ * 3. Fires events with the end-to-end RTT to each participant whenever a
+ * response is received.
+ * 4. Fires analytics events with the end-to-end RTT periodically.
+ */
+export default class E2ePing {
+    /**
+     * @param {JitsiConference} conference - The conference.
+     * @param {Function} sendMessage - The function to use to send a message.
+     * @param {Object} options
+     */
+    constructor(conference: any, options: any, sendMessage: Function);
+    conference: any;
+    eventEmitter: any;
+    sendMessage: Function;
+    pingIntervalMs: any;
+    analyticsIntervalMs: any;
+    participants: {};
+    isDataChannelOpen: boolean;
+    /**
+     * Handles a participant joining the conference. Starts to send ping
+     * requests to the participant.
+     *
+     * @param {String} id - The ID of the participant.
+     * @param {JitsiParticipant} participant - The participant that joined.
+     */
+    participantJoined(id: string, participant: any): void;
+    /**
+     * Handles a participant leaving the conference. Stops sending requests.
+     *
+     * @param {String} id - The ID of the participant.
+     */
+    participantLeft(id: string): void;
+    /**
+     * Handles a message that was received.
+     *
+     * @param participant - The message sender.
+     * @param payload - The payload of the message.
+     */
+    messageReceived(participant: any, payload: any): void;
+    /**
+     * Notifies this instance that the communications channel has been opened
+     * and it can now send messages via sendMessage.
+     */
+    dataChannelOpened(): void;
+    /**
+     * Handles a ping request coming from another participant.
+     *
+     * @param {string} participantId - The ID of the participant who sent the
+     * request.
+     * @param {Object} request - The request.
+     */
+    handleRequest(participantId: string, request: any): void;
+    /**
+     * Handles a ping response coming from another participant
+     * @param {string} participantId - The ID of the participant who sent the
+     * response.
+     * @param {Object} response - The response.
+     */
+    handleResponse(participantId: string, response: any): void;
+    /**
+     * Stops this E2ePing (i.e. stop sending requests).
+     */
+    stop(): void;
+}

types/auto/modules/event/Jvb121EventGenerator.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Emits {@link JitsiConferenceEvents.JVB121_STATUS} events based on the current
+ * P2P status and the conference participants count. See the event description
+ * for more info.
+ */
+export default class Jvb121EventGenerator {
+    /**
+     * Creates new <tt>Jvb121EventGenerator</tt> for the given conference.
+     * @param {JitsiConference} conference
+     */
+    constructor(conference: any);
+    _conference: any;
+    /**
+     * Indicates whether it's a one to one JVB conference (<tt>true</tt>)
+     * or a multiparty (<tt>false</tt>). Will be also <tt>false</tt> if
+     * the conference is currently in the P2P mode.
+     * @type {boolean}
+     * @private
+     */
+    private _jvb121;
+    /**
+     * Checks whether the JVB121 value should be updated and a new event
+     * emitted.
+     */
+    evaluateStatus(): void;
+}

types/auto/modules/flags/FeatureFlags.d.ts

@@ -0,0 +1,20 @@
+declare var _default: FeatureFlags;
+export default _default;
+/**
+ * A global module for accessing information about different feature flags state.
+ */
+declare class FeatureFlags {
+    /**
+     * Configures the module.
+     *
+     * @param {boolean} flags.sourceNameSignaling - Enables source names in the signaling.
+     */
+    init(flags: any): void;
+    _sourceNameSignaling: boolean;
+    /**
+     * Checks if the source name signaling is enabled.
+     *
+     * @returns {boolean}
+     */
+    isSourceNameSignalingEnabled(): boolean;
+}

types/auto/modules/proxyconnection/ProxyConnectionPC.d.ts

@@ -0,0 +1,167 @@
+/**
+ * An adapter around {@code JingleSessionPC} so its logic can be re-used without
+ * an XMPP connection. It is being re-used for consistency with the rest of the
+ * codebase and to leverage existing peer connection event handling. Also
+ * this class provides a facade to hide most of the API for
+ * {@code JingleSessionPC}.
+ */
+export default class ProxyConnectionPC {
+    /**
+     * Initializes a new {@code ProxyConnectionPC} instance.
+     *
+     * @param {Object} options - Values to initialize the instance with.
+     * @param {Object} [options.pcConfig] - The {@code RTCConfiguration} to use for the WebRTC peer connection.
+     * @param {boolean} [options.isInitiator] - If true, the local client should send offers. If false, the local
+     * client should send answers. Defaults to false.
+     * @param {Function} options.onRemoteStream - Callback to invoke when a remote media stream has been received
+     * through the peer connection.
+     * @param {string} options.peerJid - The jid of the remote client with which the peer connection is being establish
+     * and which should receive direct messages regarding peer connection updates.
+     * @param {boolean} [options.receiveVideo] - Whether or not the peer connection should accept incoming video
+     * streams. Defaults to false.
+     * @param {Function} options.onSendMessage - Callback to invoke when a message has to be sent (signaled) out.
+     */
+    constructor(options?: {
+        pcConfig?: any;
+        isInitiator?: boolean;
+        onRemoteStream: Function;
+        peerJid: string;
+        receiveVideo?: boolean;
+        onSendMessage: Function;
+    });
+    _options: {
+        pcConfig: any;
+        isInitiator: boolean;
+        onRemoteStream: Function;
+        peerJid: string;
+        receiveVideo: boolean;
+        onSendMessage: Function;
+        receiveAudio: boolean;
+    };
+    /**
+     * Instances of {@code JitsiTrack} associated with this instance of
+     * {@code ProxyConnectionPC}.
+     *
+     * @type {Array<JitsiTrack>}
+     */
+    _tracks: Array<any>;
+    /**
+     * The active instance of {@code JingleSessionPC}.
+     *
+     * @type {JingleSessionPC|null}
+     */
+    _peerConnection: JingleSessionPC | null;
+    /**
+     * Invoked when a connection related issue has been encountered.
+     *
+     * @param {string} errorType - The constant indicating the type of the error
+     * that occured.
+     * @param {string} details - Optional additional data about the error.
+     * @private
+     * @returns {void}
+     */
+    private _onError;
+    /**
+     * Callback invoked when the peer connection has received a remote media
+     * stream.
+     *
+     * @param {JitsiRemoteTrack} jitsiRemoteTrack - The remote media stream
+     * wrapped in {@code JitsiRemoteTrack}.
+     * @private
+     * @returns {void}
+     */
+    private _onRemoteStream;
+    /**
+     * Callback invoked when {@code JingleSessionPC} needs to signal a message
+     * out to the remote peer.
+     *
+     * @param {XML} iq - The message to signal out.
+     * @private
+     * @returns {void}
+     */
+    private _onSendMessage;
+    /**
+     * Returns the jid of the remote peer with which this peer connection should
+     * be established with.
+     *
+     * @returns {string}
+     */
+    getPeerJid(): string;
+    /**
+     * Updates the peer connection based on the passed in jingle.
+     *
+     * @param {Object} $jingle - An XML jingle element, wrapped in query,
+     * describing how the peer connection should be updated.
+     * @returns {void}
+     */
+    processMessage($jingle: any): void;
+    /**
+     * Instantiates a peer connection and starts the offer/answer cycle to
+     * establish a connection with a remote peer.
+     *
+     * @param {Array<JitsiLocalTrack>} localTracks - Initial local tracks to add
+     * to add to the peer connection.
+     * @returns {void}
+     */
+    start(localTracks?: Array<any>): void;
+    /**
+     * Begins the process of disconnecting from a remote peer and cleaning up
+     * the peer connection.
+     *
+     * @returns {void}
+     */
+    stop(): void;
+    /**
+     * Instantiates a new {@code JingleSessionPC} by stubbing out the various
+     * dependencies of {@code JingleSessionPC}.
+     *
+     * @private
+     * @returns {JingleSessionPC}
+     */
+    private _createPeerConnection;
+    /**
+     * Create an instance of {@code RTC} as it is required for peer
+     * connection creation by {@code JingleSessionPC}. An existing instance
+     * of {@code RTC} from elsewhere should not be re-used because it is
+     * a stateful grouping of utilities.
+     */
+    _rtc: RTC;
+    /**
+     * Callback invoked in response to an agreement to start a proxy connection.
+     * The passed in jingle element should contain an SDP answer to a previously
+     * sent SDP offer.
+     *
+     * @param {Object} $jingle - The jingle element wrapped in jQuery.
+     * @private
+     * @returns {void}
+     */
+    private _onSessionAccept;
+    /**
+     * Callback invoked in response to a request to start a proxy connection.
+     * The passed in jingle element should contain an SDP offer.
+     *
+     * @param {Object} $jingle - The jingle element wrapped in jQuery.
+     * @private
+     * @returns {void}
+     */
+    private _onSessionInitiate;
+    /**
+     * Callback invoked in response to a request to disconnect an active proxy
+     * connection. Cleans up tracks and the peer connection.
+     *
+     * @private
+     * @returns {void}
+     */
+    private _onSessionTerminate;
+    /**
+     * Callback invoked in response to ICE candidates from the remote peer.
+     * The passed in jingle element should contain an ICE candidate.
+     *
+     * @param {Object} $jingle - The jingle element wrapped in jQuery.
+     * @private
+     * @returns {void}
+     */
+    private _onTransportInfo;
+}
+import JingleSessionPC from "../xmpp/JingleSessionPC";
+import RTC from "../RTC/RTC";

types/auto/modules/proxyconnection/ProxyConnectionService.d.ts

@@ -0,0 +1,141 @@
+/**
+ * Instantiates a new ProxyConnectionPC and ensures only one exists at a given
+ * time. Currently it assumes ProxyConnectionPC is used only for screensharing
+ * and assumes IQs to be used for communication.
+ */
+export default class ProxyConnectionService {
+    /**
+     * Initializes a new {@code ProxyConnectionService} instance.
+     *
+     * @param {Object} options - Values to initialize the instance with.
+     * @param {boolean} [options.convertVideoToDesktop] - Whether or not proxied video should be returned as a desktop
+     * stream. Defaults to false.
+     * @param {Object} [options.pcConfig] - The {@code RTCConfiguration} to use for the WebRTC peer connection.
+     * @param {JitsiConnection} [options.jitsiConnection] - The {@code JitsiConnection} which will be used to fetch
+     * TURN credentials for the P2P connection.
+     * @param {Function} options.onRemoteStream - Callback to invoke when a remote video stream has been received and
+     * converted to a {@code JitsiLocakTrack}. The {@code JitsiLocakTrack} will be passed in.
+     * @param {Function} options.onSendMessage - Callback to invoke when a message has to be sent (signaled) out. The
+     * arguments passed in are the jid to send the message to and the message.
+     */
+    constructor(options?: {
+        convertVideoToDesktop?: boolean;
+        pcConfig?: any;
+        jitsiConnection?: any;
+        onRemoteStream: Function;
+        onSendMessage: Function;
+    });
+    /**
+     * Holds a reference to the collection of all callbacks.
+     *
+     * @type {Object}
+     */
+    _options: any;
+    /**
+     * The active instance of {@code ProxyConnectionService}.
+     *
+     * @type {ProxyConnectionPC|null}
+     */
+    _peerConnection: ProxyConnectionPC | null;
+    /**
+     * Callback invoked when an error occurs that should cause
+     * {@code ProxyConnectionPC} to be closed if the peer is currently
+     * connected. Sends an error message/reply back to the peer.
+     *
+     * @param {string} peerJid - The peer jid with which the connection was
+     * attempted or started, and to which an iq with error details should be
+     * sent.
+     * @param {string} errorType - The constant indicating the type of the error
+     * that occured.
+     * @param {string} details - Optional additional data about the error.
+     * @private
+     * @returns {void}
+     */
+    private _onFatalError;
+    /**
+     * Formats and forwards a message an iq to be sent to a peer jid.
+     *
+     * @param {string} peerJid - The jid the iq should be sent to.
+     * @param {Object} iq - The iq which would be sent to the peer jid.
+     * @private
+     * @returns {void}
+     */
+    private _onSendMessage;
+    /**
+     * Callback invoked when the remote peer of the {@code ProxyConnectionPC}
+     * has offered a media stream. The stream is converted into a
+     * {@code JitsiLocalTrack} for local usage if the {@code onRemoteStream}
+     * callback is defined.
+     *
+     * @param {JitsiRemoteTrack} jitsiRemoteTrack - The {@code JitsiRemoteTrack}
+     * for the peer's media stream.
+     * @private
+     * @returns {void}
+     */
+    private _onRemoteStream;
+    /**
+     * Parses a message object regarding a proxy connection to create a new
+     * proxy connection or update and existing connection.
+     *
+     * @param {Object} message - A message object regarding establishing or
+     * updating a proxy connection.
+     * @param {Object} message.data - An object containing additional message
+     * details.
+     * @param {string} message.data.iq - The stringified iq which explains how
+     * and what to update regarding the proxy connection.
+     * @param {string} message.from - The message sender's full jid. Used for
+     * sending replies.
+     * @returns {void}
+     */
+    processMessage(message: {
+        data: {
+            iq: string;
+        };
+        from: string;
+    }): void;
+    /**
+     * Instantiates and initiates a proxy peer connection.
+     *
+     * @param {string} peerJid - The jid of the remote client that should
+     * receive messages.
+     * @param {Array<JitsiLocalTrack>} localTracks - Initial media tracks to
+     * send through to the peer.
+     * @returns {void}
+     */
+    start(peerJid: string, localTracks?: Array<any>): void;
+    /**
+     * Terminates any active proxy peer connection.
+     *
+     * @returns {void}
+     */
+    stop(): void;
+    /**
+     * Transforms a stringified xML into a XML wrapped in jQuery.
+     *
+     * @param {string} xml - The XML in string form.
+     * @private
+     * @returns {Object|null} A jQuery version of the xml. Null will be returned
+     * if an error is encountered during transformation.
+     */
+    private _convertStringToXML;
+    /**
+     * Helper for creating an instance of {@code ProxyConnectionPC}.
+     *
+     * @param {string} peerJid - The jid of the remote peer with which the
+     * {@code ProxyConnectionPC} will be established with.
+     * @param {Object} options - Additional defaults to instantiate the
+     * {@code ProxyConnectionPC} with. See the constructor of ProxyConnectionPC
+     * for more details.
+     * @private
+     * @returns {ProxyConnectionPC}
+     */
+    private _createPeerConnection;
+    /**
+     * Invoked when preemptively closing the {@code ProxyConnectionPC}.
+     *
+     * @private
+     * @returns {void}
+     */
+    private _selfCloseConnection;
+}
+import ProxyConnectionPC from "./ProxyConnectionPC";

types/auto/modules/proxyconnection/constants.d.ts

@@ -0,0 +1,8 @@
+export namespace ACTIONS {
+    const ACCEPT: string;
+    const CONNECTION_ERROR: string;
+    const INITIATE: string;
+    const TERMINATE: string;
+    const TRANSPORT_INFO: string;
+    const UNAVAILABLE: string;
+}

types/auto/modules/qualitycontrol/ReceiveVideoController.d.ts

@@ -0,0 +1,123 @@
+/**
+ * This class translates the legacy signaling format between the client and the bridge (that affects bandwidth
+ * allocation) to the new format described here https://github.com/jitsi/jitsi-videobridge/blob/master/doc/allocation.md
+ */
+export class ReceiverVideoConstraints {
+    _defaultConstraints: {
+        maxHeight: number;
+    };
+    _lastN: number;
+    _maxFrameHeight: number;
+    _selectedEndpoints: any[];
+    _receiverVideoConstraints: {
+        constraints: {};
+        defaultConstraints: any;
+        lastN: number;
+        onStageEndpoints: any[];
+        selectedEndpoints: any[];
+    };
+    /**
+     * Returns the receiver video constraints that need to be sent on the bridge channel.
+     */
+    get constraints(): {
+        constraints: {};
+        defaultConstraints: any;
+        lastN: number;
+        onStageEndpoints: any[];
+        selectedEndpoints: any[];
+    };
+    /**
+     * Updates the lastN field of the ReceiverVideoConstraints sent to the bridge.
+     *
+     * @param {number} value
+     * @returns {boolean} Returns true if the the value has been updated, false otherwise.
+     */
+    updateLastN(value: number): boolean;
+    /**
+     * Updates the resolution (height requested) in the contraints field of the ReceiverVideoConstraints
+     * sent to the bridge.
+     *
+     * @param {number} maxFrameHeight
+     * @requires {boolean} Returns true if the the value has been updated, false otherwise.
+     */
+    updateReceiveResolution(maxFrameHeight: number): boolean;
+    /**
+     * Updates the receiver constraints sent to the bridge.
+     *
+     * @param {Object} videoConstraints
+     * @returns {boolean} Returns true if the the value has been updated, false otherwise.
+     */
+    updateReceiverVideoConstraints(videoConstraints: any): boolean;
+    /**
+     * Updates the list of selected endpoints.
+     *
+     * @param {Array<string>} ids
+     * @returns {void}
+     */
+    updateSelectedEndpoints(ids: Array<string>): void;
+}
+/**
+ * This class manages the receive video contraints for a given {@link JitsiConference}. These constraints are
+ * determined by the application based on how the remote video streams need to be displayed. This class is responsible
+ * for communicating these constraints to the bridge over the bridge channel.
+ */
+export class ReceiveVideoController {
+    /**
+     * Creates a new instance for a given conference.
+     *
+     * @param {JitsiConference} conference the conference instance for which the new instance will be managing
+     * the receive video quality constraints.
+     * @param {RTC} rtc the rtc instance which is responsible for initializing the bridge channel.
+     */
+    constructor(conference: any, rtc: any);
+    _conference: any;
+    _rtc: any;
+    _lastN: any;
+    _maxFrameHeight: number;
+    _receiverVideoConstraints: ReceiverVideoConstraints;
+    _selectedEndpoints: any[];
+    /**
+     * Handles the {@link JitsiConferenceEvents.MEDIA_SESSION_STARTED}, that is when the conference creates new media
+     * session. The preferred receive frameHeight is applied on the media session.
+     *
+     * @param {JingleSessionPC} mediaSession - the started media session.
+     * @returns {void}
+     * @private
+     */
+    private _onMediaSessionStarted;
+    /**
+     * Returns the lastN value for the conference.
+     *
+     * @returns {number}
+     */
+    getLastN(): number;
+    /**
+     * Elects the participants with the given ids to be the selected participants in order to always receive video
+     * for this participant (even when last n is enabled).
+     *
+     * @param {Array<string>} ids - The user ids.
+     * @returns {void}
+     */
+    selectEndpoints(ids: Array<string>): void;
+    /**
+     * Selects a new value for "lastN". The requested amount of videos are going to be delivered after the value is
+     * in effect. Set to -1 for unlimited or all available videos.
+     *
+     * @param {number} value the new value for lastN.
+     * @returns {void}
+     */
+    setLastN(value: number): void;
+    /**
+     * Sets the maximum video resolution the local participant should receive from remote participants.
+     *
+     * @param {number|undefined} maxFrameHeight - the new value.
+     * @returns {void}
+     */
+    setPreferredReceiveMaxFrameHeight(maxFrameHeight: number | undefined): void;
+    /**
+     * Sets the receiver constraints for the conference.
+     *
+     * @param {Object} constraints The video constraints.
+     */
+    setReceiverConstraints(constraints: any): void;
+}

types/auto/modules/qualitycontrol/SendVideoController.d.ts

@@ -0,0 +1,53 @@
+/**
+ * The class manages send video constraints across media sessions({@link JingleSessionPC}) which belong to
+ * {@link JitsiConference}. It finds the lowest common value, between the local user's send preference and
+ * the remote party's receive preference. Also this module will consider only the active session's receive value,
+ * because local tracks are shared and while JVB may have no preference, the remote p2p may have and they may be totally
+ * different.
+ */
+export class SendVideoController {
+    /**
+     * Creates new instance for a given conference.
+     *
+     * @param {JitsiConference} conference - the conference instance for which the new instance will be managing
+     * the send video quality constraints.
+     * @param {RTC} rtc - the rtc instance that is responsible for sending the messages on the bridge channel.
+     */
+    constructor(conference: any, rtc: any);
+    conference: any;
+    layerSuspensionEnabled: any;
+    rtc: any;
+    _senderVideoConstraints: any;
+    /**
+     * Handles the {@link JitsiConferenceEvents.MEDIA_SESSION_STARTED}, that is when the conference creates new media
+     * session. It doesn't mean it's already active though. For example the JVB connection may be created after
+     * the conference has entered the p2p mode already.
+     *
+     * @param {JingleSessionPC} mediaSession - the started media session.
+     * @private
+     */
+    private _onMediaSessionStarted;
+    /**
+     * Figures out the send video constraint as specified by {@link selectSendMaxFrameHeight} and sets it on all media
+     * sessions for the reasons mentioned in this class description.
+     *
+     * @returns {Promise<void[]>}
+     * @private
+     */
+    private _propagateSendMaxFrameHeight;
+    /**
+     * Selects the lowest common value for the local video send constraint by looking at local user's preference and
+     * the active media session's receive preference set by the remote party.
+     *
+     * @returns {number|undefined}
+     */
+    selectSendMaxFrameHeight(): number | undefined;
+    /**
+     * Sets local preference for max send video frame height.
+     *
+     * @param {number} maxFrameHeight - the new value to set.
+     * @returns {Promise<void[]>} - resolved when the operation is complete.
+     */
+    setPreferredSendMaxFrameHeight(maxFrameHeight: number): Promise<void[]>;
+    preferredSendMaxFrameHeight: number;
+}

types/auto/modules/recording/JibriSession.d.ts

@@ -0,0 +1,165 @@
+/**
+ * Represents a recording session.
+ */
+export default class JibriSession {
+    /**
+     * Initializes a new JibriSession instance.
+     *
+     * @constructor
+     */
+    constructor(options?: {});
+    _connection: any;
+    _mode: any;
+    /**
+     * Returns the error related to the session instance, if any.
+     *
+     * @returns {string|undefined}
+     */
+    getError(): string | undefined;
+    /**
+     * Returns the session ID of the session instance.
+     *
+     * @returns {string|undefined}
+     */
+    getID(): string | undefined;
+    /**
+     * Returns the initiator of the session instance.
+     *
+     * @returns {JitsiParticipant|string} The participant that started the session.
+     */
+    getInitiator(): any | string;
+    /**
+     * Returns the streaming URL of the session.
+     *
+     * @returns {string|undefined}
+     */
+    getLiveStreamViewURL(): string | undefined;
+    /**
+     * Returns the current status of the session.
+     *
+     * @returns {string|undefined}
+     */
+    getStatus(): string | undefined;
+    /**
+     * Returns the jid of the participant that stopped the session.
+     *
+     * @returns {JitsiParticipant|string} The participant that stopped the session.
+     */
+    getTerminator(): any | string;
+    /**
+     * Returns the current recording mode of the session, such as "file".
+     *
+     * @returns {string}
+     */
+    getMode(): string;
+    /**
+     * Sets the last known error message related to the session.
+     *
+     * @param {string} error - The error string explaining why the session
+     * entered an error state.
+     * @returns {void}
+     */
+    setError(error: string): void;
+    _error: string;
+    /**
+     * Sets the last live stream URL for the session instance. Usually this is
+     * a YouTube URL and usually this is only set for "stream" sessions.
+     *
+     * @param {string} url - The live stream URL associated with the session.
+     * @returns {void}
+     */
+    setLiveStreamViewURL(url: string): void;
+    _liveStreamViewURL: string;
+    /**
+     * Sets the last known status for this recording session.
+     *
+     * @param {string} status - The new status to set.
+     * @returns {void}
+     */
+    setStatus(status: string): void;
+    _status: string;
+    /**
+     * Sets the participant that started the session.
+     * @param {JitsiParticipant | string} participant - The participant or resource id
+     * if local participant.
+     */
+    setInitiator(participant: any | string): void;
+    _initiator: any;
+    /**
+     * Sets the participant that stopped the session.
+     * @param {JitsiParticipant | string} participant - The participant or the resource id
+     * if local participant.
+     */
+    setTerminator(participant: any | string): void;
+    _terminator: any;
+    /**
+     * Sends a message to start the actual recording.
+     *
+     * @param {Object} options - Additional arguments for starting the
+     * recording.
+     * @param {string} [options.appData] - Data specific to the app/service that
+     * the result file will be uploaded.
+     * @param {string} [options.broadcastId] - The broadcast ID of an
+     * associated YouTube stream, used for knowing the URL from which the stream
+     * can be viewed.
+     * @param {string} options.focusMucJid - The JID of the focus participant
+     * that controls recording.
+     * @param {streamId} options.streamId - Necessary for live streaming, this
+     * is the stream key needed to start a live streaming session with the
+     * streaming service provider.
+     * @returns Promise
+     */
+    start({ appData, broadcastId, focusMucJid, streamId }: {
+        appData?: string;
+        broadcastId?: string;
+        focusMucJid: string;
+        streamId: any;
+    }): Promise<any>;
+    /**
+     * Sends a message to actually stop the recording session.
+     *
+     * @param {Object} options - Additional arguments for stopping the
+     * recording.
+     * @param {Object} options.focusMucJid - The JID of the focus participant
+     * that controls recording.
+     * @returns Promise
+     */
+    stop({ focusMucJid }: {
+        focusMucJid: any;
+    }): Promise<any>;
+    /**
+     * Generates the message to change the status of the recording session.
+     *
+     * @param {string} status - The new status to which the recording session
+     * should transition.
+     * @param {string} [options.appData] - Data specific to the app/service that
+     * the result file will be uploaded.
+     * @param {string} [options.broadcastId] - The broadcast ID of an
+     * associated YouTube stream, used for knowing the URL from which the stream
+     * can be viewed.
+     * @param {string} options.focusMucJid - The JID of the focus participant
+     * that controls recording.
+     * @param {streamId} options.streamId - Necessary for live streaming, this
+     * is the stream key needed to start a live streaming session with the
+     * streaming service provider.
+     * @returns Object - The XMPP IQ message.
+     */
+    _createIQ({ action, appData, broadcastId, focusMucJid, streamId }: string): any;
+    /**
+     * Handles the error from an iq and stores the error.
+     *
+     * @param {Node} errorIq - The error response from an Iq.
+     * @private
+     * @returns {void}
+     */
+    private _setErrorFromIq;
+    /**
+     * Sets the known session ID for this recording session.
+     *
+     * @param {string} sessionID
+     * @private
+     * @returns {void}
+     */
+    private _setSessionID;
+    _sessionID: string;
+}

types/auto/modules/recording/RecordingManager.d.ts

@@ -0,0 +1,112 @@
+export default RecordingManager;
+/**
+ * A class responsible for starting and stopping recording sessions and emitting
+ * state updates for them.
+ */
+declare class RecordingManager {
+    /**
+     * Initialize {@code RecordingManager} with other objects that are necessary
+     * for starting a recording.
+     *
+     * @param {ChatRoom} chatRoom - The chat room to handle.
+     * @returns {void}
+     */
+    constructor(chatRoom: any);
+    /**
+     * All known recording sessions from the current conference.
+     */
+    _sessions: {};
+    _chatRoom: any;
+    /**
+     * Callback to invoke to parse through a presence update to find recording
+     * related updates (from Jibri participant doing the recording and the
+     * focus which controls recording).
+     *
+     * @param {Object} event - The presence data from the pubsub event.
+     * @param {Node} event.presence - An XMPP presence update.
+     * @param {boolean} event.fromHiddenDomain - Whether or not the update comes
+     * from a participant that is trusted but not visible, as would be the case
+     * with the Jibri recorder participant.
+     * @returns {void}
+     */
+    onPresence({ fromHiddenDomain, presence }: {
+        presence: Node;
+        fromHiddenDomain: boolean;
+    }): void;
+    /**
+     * Finds an existing recording session by session ID.
+     *
+     * @param {string} sessionID - The session ID associated with the recording.
+     * @returns {JibriSession|undefined}
+     */
+    getSession(sessionID: string): JibriSession | undefined;
+    /**
+     * Start a recording session.
+     *
+     * @param {Object} options - Configuration for the recording.
+     * @param {string} [options.appData] - Data specific to the app/service that
+     * the result file will be uploaded.
+     * @param {string} [optional] options.broadcastId - The channel on which a
+     * live stream will occur.
+     * @param {string} options.mode - The mode in which recording should be
+     * started. Recognized values are "file" and "stream".
+     * @param {string} [optional] options.streamId - The stream key to be used
+     * for live stream broadcasting. Required for live streaming.
+     * @returns {Promise} A promise for starting a recording, which will pass
+     * back the session on success. The promise resolves after receiving an
+     * acknowledgment of the start request success or fail.
+     */
+    startRecording(options: {
+        appData?: string;
+    }): Promise<any>;
+    /**
+     * Stop a recording session.
+     *
+     * @param {string} sessionID - The ID associated with the recording session
+     * to be stopped.
+     * @returns {Promise} The promise resolves after receiving an
+     * acknowledgment of the stop request success or fail.
+     */
+    stopRecording(sessionID: string): Promise<any>;
+    /**
+     * Stores a reference to the passed in JibriSession.
+     *
+     * @param {string} session - The JibriSession instance to store.
+     * @returns {void}
+     */
+    _addSession(session: string): void;
+    /**
+     * Create a new instance of a recording session and stores a reference to
+     * it.
+     *
+     * @param {string} sessionID - The session ID of the recording in progress.
+     * @param {string} status - The current status of the recording session.
+     * @param {string} mode - The recording mode of the session.
+     * @returns {JibriSession}
+     */
+    _createSession(sessionID: string, status: string, mode: string): JibriSession;
+    /**
+     * Notifies listeners of an update to a recording session.
+     *
+     * @param {JibriSession} session - The session that has been updated.
+     * @param {string|undefined} initiator - The jid of the initiator of the update.
+     */
+    _emitSessionUpdate(session: JibriSession, initiator: string | undefined): void;
+    /**
+     * Parses presence to update an existing JibriSession or to create a new
+     * JibriSession.
+     *
+     * @param {Node} presence - An XMPP presence update.
+     * @returns {void}
+     */
+    _handleFocusPresence(presence: Node): void;
+    /**
+     * Handles updates from the Jibri which can broadcast a YouTube URL that
+     * needs to be updated in a JibriSession.
+     *
+     * @param {Node} presence - An XMPP presence update.
+     * @returns {void}
+     */
+    _handleJibriPresence(presence: Node): void;
+}
+import JibriSession from "./JibriSession";

types/auto/modules/recording/recordingConstants.d.ts

@@ -0,0 +1,19 @@
+declare namespace _default {
+    namespace error {
+        const BUSY: string;
+        const ERROR: string;
+        const RESOURCE_CONSTRAINT: string;
+        const UNEXPECTED_REQUEST: string;
+        const SERVICE_UNAVAILABLE: string;
+    }
+    namespace mode {
+        const FILE: string;
+        const STREAM: string;
+    }
+    namespace status {
+        const OFF: string;
+        const ON: string;
+        const PENDING: string;
+    }
+}
+export default _default;

types/auto/modules/recording/recordingXMLUtils.d.ts

@@ -0,0 +1,77 @@
+declare namespace _default {
+    /**
+     * Parses the presence update of the focus and returns an object with the
+     * statuses related to recording.
+     *
+     * @param {Node} presence - An XMPP presence update.
+     * @returns {Object} The current presence values related to recording.
+     */
+    function getFocusRecordingUpdate(presence: Node): any;
+    /**
+     * Parses the presence update of the focus and returns an object with the
+     * statuses related to recording.
+     *
+     * @param {Node} presence - An XMPP presence update.
+     * @returns {Object} The current presence values related to recording.
+     */
+    function getFocusRecordingUpdate(presence: Node): any;
+    /**
+     * Parses the presence update from a hidden domain participant and returns
+     * an object with the statuses related to recording.
+     *
+     * @param {Node} presence - An XMPP presence update.
+     * @returns {Object} The current presence values related to recording.
+     */
+    function getHiddenDomainUpdate(presence: Node): any;
+    /**
+     * Parses the presence update from a hidden domain participant and returns
+     * an object with the statuses related to recording.
+     *
+     * @param {Node} presence - An XMPP presence update.
+     * @returns {Object} The current presence values related to recording.
+     */
+    function getHiddenDomainUpdate(presence: Node): any;
+    /**
+     * Returns the recording session ID from a successful IQ.
+     *
+     * @param {Node} response - The response from the IQ.
+     * @returns {string} The session ID of the recording session.
+     */
+    function getSessionIdFromIq(response: Node): string;
+    /**
+     * Returns the recording session ID from a successful IQ.
+     *
+     * @param {Node} response - The response from the IQ.
+     * @returns {string} The session ID of the recording session.
+     */
+    function getSessionIdFromIq(response: Node): string;
+    /**
+     * Returns the recording session ID from a presence, if it exists.
+     *
+     * @param {Node} presence - An XMPP presence update.
+     * @returns {string|undefined} The session ID of the recording session.
+     */
+    function getSessionId(presence: Node): string;
+    /**
+     * Returns the recording session ID from a presence, if it exists.
+     *
+     * @param {Node} presence - An XMPP presence update.
+     * @returns {string|undefined} The session ID of the recording session.
+     */
+    function getSessionId(presence: Node): string;
+    /**
+     * Returns whether or not a presence is from the focus.
+     *
+     * @param {Node} presence - An XMPP presence update.
+     * @returns {boolean} True if the presence is from the focus.
+     */
+    function isFromFocus(presence: Node): boolean;
+    /**
+     * Returns whether or not a presence is from the focus.
+     *
+     * @param {Node} presence - An XMPP presence update.
+     * @returns {boolean} True if the presence is from the focus.
+     */
+    function isFromFocus(presence: Node): boolean;
+}
+export default _default;

types/auto/modules/sdp/LocalSdpMunger.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Fakes local SDP exposed to {@link JingleSessionPC} through the local
+ * description getter. Modifies the SDP, so that it will contain muted local
+ * video tracks description, even though their underlying {MediaStreamTrack}s
+ * are no longer in the WebRTC peerconnection. That prevents from SSRC updates
+ * being sent to Jicofo/remote peer and prevents sRD/sLD cycle on the remote
+ * side.
+ */
+export default class LocalSdpMunger {
+    /**
+     * Creates new <tt>LocalSdpMunger</tt> instance.
+     *
+     * @param {TraceablePeerConnection} tpc
+     * @param {string} localEndpointId - The endpoint id of the local user.
+     */
+    constructor(tpc: any, localEndpointId: string);
+    tpc: any;
+    localEndpointId: string;
+    /**
+     * Makes sure that muted local video tracks associated with the parent
+     * {@link TraceablePeerConnection} are described in the local SDP. It's done
+     * in order to prevent from sending 'source-remove'/'source-add' Jingle
+     * notifications when local video track is muted (<tt>MediaStream</tt> is
+     * removed from the peerconnection).
+     *
+     * NOTE 1 video track is assumed
+     *
+     * @param {SdpTransformWrap} transformer the transformer instance which will
+     * be used to process the SDP.
+     * @return {boolean} <tt>true</tt> if there were any modifications to
+     * the SDP wrapped by <tt>transformer</tt>.
+     * @private
+     */
+    private _addMutedLocalVideoTracksToSDP;
+    /**
+     * Returns a string that can be set as the MSID attribute for a source.
+     *
+     * @param {string} mediaType - Media type of the source.
+     * @param {string} trackId - Id of the MediaStreamTrack associated with the source.
+     * @param {string} streamId - Id of the MediaStream associated with the source.
+     * @returns {string|null}
+     */
+    _generateMsidAttribute(mediaType: string, trackId: string, streamId?: string): string | null;
+    /**
+     * Modifies 'cname', 'msid', 'label' and 'mslabel' by appending
+     * the id of {@link LocalSdpMunger#tpc} at the end, preceding by a dash
+     * sign.
+     *
+     * @param {MLineWrap} mediaSection - The media part (audio or video) of the
+     * session description which will be modified in place.
+     * @returns {void}
+     * @private
+     */
+    private _transformMediaIdentifiers;
+    /**
+     * Maybe modifies local description to fake local video tracks SDP when
+     * those are muted.
+     *
+     * @param {object} desc the WebRTC SDP object instance for the local
+     * description.
+     * @returns {RTCSessionDescription}
+     */
+    maybeAddMutedLocalVideoTracksToSDP(desc: object): RTCSessionDescription;
+    /**
+     * This transformation will make sure that stream identifiers are unique
+     * across all of the local PeerConnections even if the same stream is used
+     * by multiple instances at the same time.
+     * Each PeerConnection assigns different SSRCs to the same local
+     * MediaStream, but the MSID remains the same as it's used to identify
+     * the stream by the WebRTC backend. The transformation will append
+     * {@link TraceablePeerConnection#id} at the end of each stream's identifier
+     * ("cname", "msid", "label" and "mslabel").
+     *
+     * @param {RTCSessionDescription} sessionDesc - The local session
+     * description (this instance remains unchanged).
+     * @return {RTCSessionDescription} - Transformed local session description
+     * (a modified copy of the one given as the input).
+     */
+    transformStreamIdentifiers(sessionDesc: RTCSessionDescription): RTCSessionDescription;
+    /**
+     * Injects source names. Source names are need to for multiple streams per endpoint support. The final plan is to
+     * use the "mid" attribute for source names, but because the SDP to Jingle conversion still operates in the Plan-B
+     * semantics (one source name per media), a custom "name" attribute is injected into SSRC lines..
+     *
+     * @param {MLineWrap} mediaSection - The media part (audio or video) of the session description which will be
+     * modified in place.
+     * @returns {void}
+     * @private
+     */
+    private _injectSourceNames;
+}

types/auto/modules/sdp/RtxModifier.d.ts

@@ -0,0 +1,49 @@
+/**
+ * End helper functions
+ */
+/**
+ * Adds any missing RTX streams for video streams
+ *  and makes sure that they remain consistent
+ */
+export default class RtxModifier {
+    /**
+     * Map of video ssrc to corresponding RTX
+     *  ssrc
+     */
+    correspondingRtxSsrcs: Map<any, any>;
+    /**
+     * Clear the cached map of primary video ssrcs to
+     *  their corresponding rtx ssrcs so that they will
+     *  not be used for the next call to modifyRtxSsrcs
+     */
+    clearSsrcCache(): void;
+    /**
+     * Explicitly set the primary video ssrc -> rtx ssrc
+     *  mapping to be used in modifyRtxSsrcs
+     * @param {Map} ssrcMapping a mapping of primary video
+     *  ssrcs to their corresponding rtx ssrcs
+     */
+    setSsrcCache(ssrcMapping: Map<any, any>): void;
+    /**
+     * Adds RTX ssrcs for any video ssrcs that don't
+     *  already have them.  If the video ssrc has been
+     *  seen before, and already had an RTX ssrc generated,
+     *  the same RTX ssrc will be used again.
+     * @param {string} sdpStr sdp in raw string format
+     */
+    modifyRtxSsrcs(sdpStr: string): string;
+    /**
+     * Does the same thing as {@link modifyRtxSsrcs}, but takes the
+     *  {@link MLineWrap} instance wrapping video media as an argument.
+     * @param {MLineWrap} videoMLine
+     * @return {boolean} <tt>true</tt> if the SDP wrapped by
+     *  {@link SdpTransformWrap} has been modified or <tt>false</tt> otherwise.
+     */
+    modifyRtxSsrcs2(videoMLine: any): boolean;
+    /**
+     * Strip all rtx streams from the given sdp
+     * @param {string} sdpStr sdp in raw string format
+     * @returns {string} sdp string with all rtx streams stripped
+     */
+    stripRtx(sdpStr: string): string;
+}

types/auto/modules/sdp/SDP.d.ts

@@ -0,0 +1,48 @@
+/**
+ *
+ * @param sdp
+ */
+export default function SDP(sdp: any): void;
+export default class SDP {
+    /**
+     *
+     * @param sdp
+     */
+    constructor(sdp: any);
+    media: any;
+    raw: string;
+    session: string;
+    /**
+     * A flag will make {@link transportToJingle} and {@link jingle2media} replace
+     * ICE candidates IPs with invalid value of '1.1.1.1' which will cause ICE
+     * failure. The flag is used in the automated testing.
+     * @type {boolean}
+     */
+    failICE: boolean;
+    /**
+     * Whether or not to remove TCP ice candidates when translating from/to jingle.
+     * @type {boolean}
+     */
+    removeTcpCandidates: boolean;
+    /**
+     * Whether or not to remove UDP ice candidates when translating from/to jingle.
+     * @type {boolean}
+     */
+    removeUdpCandidates: boolean;
+    /**
+     * Returns map of MediaChannel mapped per channel idx.
+     */
+    getMediaSsrcMap(): {};
+    /**
+     * Returns <tt>true</tt> if this SDP contains given SSRC.
+     * @param ssrc the ssrc to check.
+     * @returns {boolean} <tt>true</tt> if this SDP contains given SSRC.
+     */
+    containsSSRC(ssrc: any): boolean;
+    toJingle(elem: any, thecreator: any): any;
+    transportToJingle(mediaindex: any, elem: any): void;
+    rtcpFbToJingle(mediaindex: any, elem: any, payloadtype: any): void;
+    rtcpFbFromJingle(elem: any, payloadtype: any): string;
+    fromJingle(jingle: any): void;
+    jingle2media(content: any): string;
+}

types/auto/modules/sdp/SDPDiffer.d.ts

@@ -0,0 +1,25 @@
+/**
+ *
+ * @param mySDP
+ * @param otherSDP
+ */
+export default function SDPDiffer(mySDP: any, otherSDP: any): void;
+export default class SDPDiffer {
+    /**
+     *
+     * @param mySDP
+     * @param otherSDP
+     */
+    constructor(mySDP: any, otherSDP: any);
+    mySDP: any;
+    otherSDP: any;
+    /**
+     * Returns map of MediaChannel that contains media contained in
+     * 'mySDP', but not contained in 'otherSdp'. Mapped by channel idx.
+     */
+    getNewMedia(): {};
+    /**
+     * TODO: document!
+     */
+    toJingle(modify: any): boolean;
+}

types/auto/modules/sdp/SDPUtil.d.ts

@@ -0,0 +1,335 @@
+export default SDPUtil;
+declare namespace SDPUtil {
+    function filterSpecialChars(text: any): any;
+    function filterSpecialChars(text: any): any;
+    function iceparams(mediadesc: any, sessiondesc: any): {
+        ufrag: any;
+        pwd: any;
+    };
+    function iceparams(mediadesc: any, sessiondesc: any): {
+        ufrag: any;
+        pwd: any;
+    };
+    function parseICEUfrag(line: any): any;
+    function parseICEUfrag(line: any): any;
+    function buildICEUfrag(frag: any): string;
+    function buildICEUfrag(frag: any): string;
+    function parseICEPwd(line: any): any;
+    function parseICEPwd(line: any): any;
+    function buildICEPwd(pwd: any): string;
+    function buildICEPwd(pwd: any): string;
+    function parseMID(line: any): any;
+    function parseMID(line: any): any;
+    /**
+     * Finds the MSID attribute in the given array of SSRC attribute lines and returns the value.
+     *
+     * @param {string[]} ssrcLines - an array of lines similar to 'a:213123 msid:stream-id track-id'.
+     * @returns {undefined|string}
+     */
+    function parseMSIDAttribute(ssrcLines: string[]): string;
+    /**
+     * Finds the MSID attribute in the given array of SSRC attribute lines and returns the value.
+     *
+     * @param {string[]} ssrcLines - an array of lines similar to 'a:213123 msid:stream-id track-id'.
+     * @returns {undefined|string}
+     */
+    function parseMSIDAttribute(ssrcLines: string[]): string;
+    function parseMLine(line: any): {
+        media: any;
+        port: any;
+        proto: any;
+        fmt: any;
+    };
+    function parseMLine(line: any): {
+        media: any;
+        port: any;
+        proto: any;
+        fmt: any;
+    };
+    function buildMLine(mline: any): string;
+    function buildMLine(mline: any): string;
+    function parseRTPMap(line: any): {
+        id: any;
+        name: any;
+        clockrate: any;
+        channels: any;
+    };
+    function parseRTPMap(line: any): {
+        id: any;
+        name: any;
+        clockrate: any;
+        channels: any;
+    };
+    /**
+     * Parses SDP line "a=sctpmap:..." and extracts SCTP port from it.
+     * @param line eg. "a=sctpmap:5000 webrtc-datachannel"
+     * @returns [SCTP port number, protocol, streams]
+     */
+    function parseSCTPMap(line: any): any[];
+    /**
+     * Parses SDP line "a=sctpmap:..." and extracts SCTP port from it.
+     * @param line eg. "a=sctpmap:5000 webrtc-datachannel"
+     * @returns [SCTP port number, protocol, streams]
+     */
+    function parseSCTPMap(line: any): any[];
+    function parseSCTPPort(line: any): any;
+    function parseSCTPPort(line: any): any;
+    function buildRTPMap(el: any): string;
+    function buildRTPMap(el: any): string;
+    function parseCrypto(line: any): {
+        tag: any;
+        'crypto-suite': any;
+        'key-params': any;
+        'session-params': any;
+    };
+    function parseCrypto(line: any): {
+        tag: any;
+        'crypto-suite': any;
+        'key-params': any;
+        'session-params': any;
+    };
+    function parseFingerprint(line: any): {
+        hash: any;
+        fingerprint: any;
+    };
+    function parseFingerprint(line: any): {
+        hash: any;
+        fingerprint: any;
+    };
+    function parseFmtp(line: any): {
+        name: any;
+        value: any;
+    }[];
+    function parseFmtp(line: any): {
+        name: any;
+        value: any;
+    }[];
+    function parseICECandidate(line: any): {
+        foundation: any;
+        component: any;
+        protocol: any;
+        priority: any;
+        ip: any;
+        port: any;
+        type: any;
+        generation: any;
+        'rel-addr': any;
+        'rel-port': any;
+        tcptype: any;
+        network: string;
+        id: string;
+    };
+    function parseICECandidate(line: any): {
+        foundation: any;
+        component: any;
+        protocol: any;
+        priority: any;
+        ip: any;
+        port: any;
+        type: any;
+        generation: any;
+        'rel-addr': any;
+        'rel-port': any;
+        tcptype: any;
+        network: string;
+        id: string;
+    };
+    function buildICECandidate(cand: any): string;
+    function buildICECandidate(cand: any): string;
+    function parseSSRC(desc: any): Map<any, any>;
+    function parseSSRC(desc: any): Map<any, any>;
+    /**
+     * Gets the source name out of the name attribute "a=ssrc:254321 name:name1".
+     *
+     * @param {string[]} ssrcLines
+     * @returns {string | undefined}
+     */
+    function parseSourceNameLine(ssrcLines: string[]): string;
+    /**
+     * Gets the source name out of the name attribute "a=ssrc:254321 name:name1".
+     *
+     * @param {string[]} ssrcLines
+     * @returns {string | undefined}
+     */
+    function parseSourceNameLine(ssrcLines: string[]): string;
+    function parseRTCPFB(line: any): {
+        pt: any;
+        type: any;
+        params: any;
+    };
+    function parseRTCPFB(line: any): {
+        pt: any;
+        type: any;
+        params: any;
+    };
+    function parseExtmap(line: any): {
+        value: any;
+        direction: any;
+        uri: any;
+        params: any;
+    };
+    function parseExtmap(line: any): {
+        value: any;
+        direction: any;
+        uri: any;
+        params: any;
+    };
+    function findLine(haystack: any, needle: any, sessionpart: any): any;
+    function findLine(haystack: any, needle: any, sessionpart: any): any;
+    function findLines(haystack: any, needle: any, sessionpart: any): any[];
+    function findLines(haystack: any, needle: any, sessionpart: any): any[];
+    function candidateToJingle(line: any): {
+        foundation: any;
+        component: any;
+        protocol: any;
+        priority: any;
+        ip: any;
+        port: any;
+        type: any;
+        generation: any;
+        'rel-addr': any;
+        'rel-port': any;
+        tcptype: any;
+        network: string;
+        id: string;
+    };
+    function candidateToJingle(line: any): {
+        foundation: any;
+        component: any;
+        protocol: any;
+        priority: any;
+        ip: any;
+        port: any;
+        type: any;
+        generation: any;
+        'rel-addr': any;
+        'rel-port': any;
+        tcptype: any;
+        network: string;
+        id: string;
+    };
+    function candidateFromJingle(cand: any): string;
+    function candidateFromJingle(cand: any): string;
+    /**
+     * Parse the 'most' primary video ssrc from the given m line
+     * @param {object} mLine object as parsed from transform.parse
+     * @return {number} the primary video ssrc from the given m line
+     */
+    function parsePrimaryVideoSsrc(videoMLine: any): number;
+    /**
+     * Parse the 'most' primary video ssrc from the given m line
+     * @param {object} mLine object as parsed from transform.parse
+     * @return {number} the primary video ssrc from the given m line
+     */
+    function parsePrimaryVideoSsrc(videoMLine: any): number;
+    /**
+     * Generate an ssrc
+     * @returns {number} an ssrc
+     */
+    function generateSsrc(): number;
+    /**
+     * Generate an ssrc
+     * @returns {number} an ssrc
+     */
+    function generateSsrc(): number;
+    /**
+     * Get an attribute for the given ssrc with the given attributeName
+     *  from the given mline
+     * @param {object} mLine an mLine object as parsed from transform.parse
+     * @param {number} ssrc the ssrc for which an attribute is desired
+     * @param {string} attributeName the name of the desired attribute
+     * @returns {string} the value corresponding to the given ssrc
+     *  and attributeName
+     */
+    function getSsrcAttribute(mLine: any, ssrc: number, attributeName: string): string;
+    /**
+     * Get an attribute for the given ssrc with the given attributeName
+     *  from the given mline
+     * @param {object} mLine an mLine object as parsed from transform.parse
+     * @param {number} ssrc the ssrc for which an attribute is desired
+     * @param {string} attributeName the name of the desired attribute
+     * @returns {string} the value corresponding to the given ssrc
+     *  and attributeName
+     */
+    function getSsrcAttribute(mLine: any, ssrc: number, attributeName: string): string;
+    /**
+     * Parses the ssrcs from the group sdp line and
+     *  returns them as a list of numbers
+     * @param {object} the ssrcGroup object as parsed from
+     *  sdp-transform
+     * @returns {list<number>} a list of the ssrcs in the group
+     *  parsed as numbers
+     */
+    function parseGroupSsrcs(ssrcGroup: any): any;
+    /**
+     * Parses the ssrcs from the group sdp line and
+     *  returns them as a list of numbers
+     * @param {object} the ssrcGroup object as parsed from
+     *  sdp-transform
+     * @returns {list<number>} a list of the ssrcs in the group
+     *  parsed as numbers
+     */
+    function parseGroupSsrcs(ssrcGroup: any): any;
+    /**
+     * Get the mline of the given type from the given sdp
+     * @param {object} sdp sdp as parsed from transform.parse
+     * @param {string} type the type of the desired mline (e.g. "video")
+     * @returns {object} a media object
+     */
+    function getMedia(sdp: any, type: string): any;
+    /**
+     * Get the mline of the given type from the given sdp
+     * @param {object} sdp sdp as parsed from transform.parse
+     * @param {string} type the type of the desired mline (e.g. "video")
+     * @returns {object} a media object
+     */
+    function getMedia(sdp: any, type: string): any;
+    /**
+     * Extracts the ICE username fragment from an SDP string.
+     * @param {string} sdp the SDP in raw text format
+     */
+    function getUfrag(sdp: string): string;
+    /**
+     * Extracts the ICE username fragment from an SDP string.
+     * @param {string} sdp the SDP in raw text format
+     */
+    function getUfrag(sdp: string): string;
+    /**
+     * Sets the given codecName as the preferred codec by moving it to the beginning
+     * of the payload types list (modifies the given mline in place). All instances
+     * of the codec are moved up.
+     * @param {object} mLine the mline object from an sdp as parsed by transform.parse
+     * @param {string} codecName the name of the preferred codec
+     */
+    function preferCodec(mline: any, codecName: string): void;
+    /**
+     * Sets the given codecName as the preferred codec by moving it to the beginning
+     * of the payload types list (modifies the given mline in place). All instances
+     * of the codec are moved up.
+     * @param {object} mLine the mline object from an sdp as parsed by transform.parse
+     * @param {string} codecName the name of the preferred codec
+     */
+    function preferCodec(mline: any, codecName: string): void;
+    /**
+     * Strips the given codec from the given mline. All related RTX payload
+     * types are also stripped. If the resulting mline would have no codecs,
+     * it's disabled.
+     *
+     * @param {object} mLine the mline object from an sdp as parsed by transform.parse.
+     * @param {string} codecName the name of the codec which will be stripped.
+     * @param {boolean} highProfile determines if only the high profile H264 codec needs to be
+     * stripped from the sdp when the passed codecName is H264.
+     */
+    function stripCodec(mLine: any, codecName: string, highProfile?: boolean): void;
+    /**
+     * Strips the given codec from the given mline. All related RTX payload
+     * types are also stripped. If the resulting mline would have no codecs,
+     * it's disabled.
+     *
+     * @param {object} mLine the mline object from an sdp as parsed by transform.parse.
+     * @param {string} codecName the name of the codec which will be stripped.
+     * @param {boolean} highProfile determines if only the high profile H264 codec needs to be
+     * stripped from the sdp when the passed codecName is H264.
+     */
+    function stripCodec(mLine: any, codecName: string, highProfile?: boolean): void;
+}

types/auto/modules/sdp/SampleSdpStrings.d.ts

@@ -0,0 +1,2 @@
+declare namespace _default { }
+export default _default;

types/auto/modules/sdp/SdpConsistency.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Handles the work of keeping video ssrcs consistent across multiple
+ * o/a cycles, making it such that all stream operations can be
+ * kept local and do not need to be signaled.
+ * NOTE: This only keeps the 'primary' video ssrc consistent: meaning
+ * the primary video stream
+ */
+export default class SdpConsistency {
+    /**
+     * Constructor
+     * @param {string} logPrefix the log prefix appended to every logged
+     * message, currently used to distinguish for which
+     * <tt>TraceablePeerConnection</tt> the instance works.
+     */
+    constructor(logPrefix: string);
+    logPrefix: string;
+    /**
+     * Clear the cached video primary and primary rtx ssrcs so that
+     *  they will not be used for the next call to
+     *  makeVideoPrimarySsrcsConsistent
+     */
+    clearVideoSsrcCache(): void;
+    cachedPrimarySsrc: number;
+    injectRecvOnly: boolean;
+    /**
+     * Explicitly set the primary ssrc to be used in
+     *  makeVideoPrimarySsrcsConsistent
+     * @param {number} primarySsrc the primarySsrc to be used
+     *  in future calls to makeVideoPrimarySsrcsConsistent
+     * @throws Error if <tt>primarySsrc</tt> is not a number
+     */
+    setPrimarySsrc(primarySsrc: number): void;
+    /**
+     * Checks whether or not there is a primary video SSRC cached already.
+     * @return {boolean}
+     */
+    hasPrimarySsrcCached(): boolean;
+    /**
+     * Given an sdp string, either:
+     *  1) record the primary video and primary rtx ssrcs to be
+     *   used in future calls to makeVideoPrimarySsrcsConsistent or
+     *  2) change the primary and primary rtx ssrcs in the given sdp
+     *   to match the ones previously cached
+     * @param {string} sdpStr the sdp string to (potentially)
+     *  change to make the video ssrcs consistent
+     * @returns {string} a (potentially) modified sdp string
+     *  with ssrcs consistent with this class' cache
+     */
+    makeVideoPrimarySsrcsConsistent(sdpStr: string): string;
+}

types/auto/modules/sdp/SdpTransformUtil.d.ts

@@ -0,0 +1,218 @@
+/**
+ * Parses the primary SSRC of given SSRC group.
+ * @param {object} group the SSRC group object as defined by the 'sdp-transform'
+ * @return {Number} the primary SSRC number
+ */
+export function parsePrimarySSRC(group: object): number;
+/**
+ * Parses the secondary SSRC of given SSRC group.
+ * @param {object} group the SSRC group object as defined by the 'sdp-transform'
+ * @return {Number} the secondary SSRC number
+ */
+export function parseSecondarySSRC(group: object): number;
+/**
+ * Utility class for SDP manipulation using the 'sdp-transform' library.
+ *
+ * Typical use usage scenario:
+ *
+ * const transformer = new SdpTransformWrap(rawSdp);
+ * const videoMLine = transformer.selectMedia('video);
+ * if (videoMLine) {
+ *     videoMLiner.addSSRCAttribute({
+ *         id: 2342343,
+ *         attribute: "cname",
+ *         value: "someCname"
+ *     });
+ *     rawSdp = transformer.toRawSdp();
+ * }
+ */
+export class SdpTransformWrap {
+    /**
+     * Creates new instance and parses the raw SDP into objects using
+     * 'sdp-transform' lib.
+     * @param {string} rawSDP the SDP in raw text format.
+     */
+    constructor(rawSDP: string);
+    parsedSDP: any;
+    /**
+     * Selects the first media SDP of given name.
+     * @param {string} mediaType the name of the media e.g. 'audio', 'video',
+     * 'data'.
+     * @return {MLineWrap|null} return {@link MLineWrap} instance for the media
+     * line or <tt>null</tt> if not found. The object returned references
+     * the underlying SDP state held by this <tt>SdpTransformWrap</tt> instance
+     * (it's not a copy).
+     */
+    selectMedia(mediaType: string): MLineWrap | null;
+    /**
+     * Converts the currently stored SDP state in this instance to raw text SDP
+     * format.
+     * @return {string}
+     */
+    toRawSDP(): string;
+}
+/**
+ * A wrapper around 'sdp-transform' media description object which provides
+ * utility methods for common SDP/SSRC related operations.
+ */
+declare class MLineWrap {
+    /**
+     * Creates new <tt>MLineWrap</t>>
+     * @param {Object} mLine the media line object as defined by 'sdp-transform'
+     * lib.
+     */
+    constructor(mLine: any);
+    mLine: any;
+    /**
+     * Setter for the mLine's "ssrcs" array.
+     *
+     * @param {Array<Object>} ssrcs an array of 'sdp-transform' SSRC attributes
+     * objects.
+     */
+    set ssrcs(arg: any[]);
+    /**
+     * Getter for the mLine's "ssrcs" array. If the array was undefined an empty
+     * one will be preassigned.
+     *
+     * @return {Array<Object>} an array of 'sdp-transform' SSRC attributes
+     * objects.
+     */
+    get ssrcs(): any[];
+    /**
+     * Modifies the direction of the underlying media description.
+     * @param {string} direction the new direction to be set
+     */
+    set direction(arg: string);
+    /**
+     * Returns the direction of the underlying media description.
+     * @return {string} the media direction name as defined in the SDP.
+     */
+    get direction(): string;
+    /**
+     * Modifies the SSRC groups array of the underlying media description
+     * object.
+     * @param {Array.<Object>} ssrcGroups
+     */
+    set ssrcGroups(arg: any[]);
+    /**
+     * Exposes the SSRC group array of the underlying media description object.
+     * @return {Array.<Object>}
+     */
+    get ssrcGroups(): any[];
+    /**
+     * Obtains value from SSRC attribute.
+     * @param {number} ssrcNumber the SSRC number for which attribute is to be
+     * found
+     * @param {string} attrName the name of the SSRC attribute to be found.
+     * @return {string|undefined} the value of SSRC attribute or
+     * <tt>undefined</tt> if no such attribute exists.
+     */
+    getSSRCAttrValue(ssrcNumber: number, attrName: string): string | undefined;
+    /**
+     * Removes all attributes for given SSRC number.
+     * @param {number} ssrcNum the SSRC number for which all attributes will be
+     * removed.
+     */
+    removeSSRC(ssrcNum: number): void;
+    /**
+     * Adds SSRC attribute
+     * @param {object} ssrcObj the SSRC attribute object as defined in
+     * the 'sdp-transform' lib.
+     */
+    addSSRCAttribute(ssrcObj: object): void;
+    /**
+     * Finds a SSRC group matching both semantics and SSRCs in order.
+     * @param {string} semantics the name of the semantics
+     * @param {string} [ssrcs] group SSRCs as a string (like it's defined in
+     * SSRC group object of the 'sdp-transform' lib) e.g. "1232546 342344 25434"
+     * @return {object|undefined} the SSRC group object or <tt>undefined</tt> if
+     * not found.
+     */
+    findGroup(semantics: string, ssrcs?: string): object | undefined;
+    /**
+     * Finds all groups matching given semantic's name.
+     * @param {string} semantics the name of the semantics
+     * @return {Array.<object>} an array of SSRC group objects as defined by
+     * the 'sdp-transform' lib.
+     */
+    findGroups(semantics: string): Array<object>;
+    /**
+     * Finds all groups matching given semantic's name and group's primary SSRC.
+     * @param {string} semantics the name of the semantics
+     * @param {number} primarySSRC the primary SSRC number to be matched
+     * @return {Object} SSRC group object as defined by the 'sdp-transform' lib.
+     */
+    findGroupByPrimarySSRC(semantics: string, primarySSRC: number): any;
+    /**
+     * @param {string|null} msid the media stream id or <tt>null</tt> to match
+     * the first SSRC object with any 'msid' value.
+     * @return {Object|undefined} the SSRC object as defined by 'sdp-transform'
+     * lib.
+     */
+    findSSRCByMSID(msid: string | null): any | undefined;
+    /**
+     * Gets the SSRC count for the underlying media description.
+     * @return {number}
+     */
+    getSSRCCount(): number;
+    /**
+     * Checks whether the underlying media description contains any SSRC groups.
+     * @return {boolean} <tt>true</tt> if there are any SSRC groups or
+     * <tt>false</tt> otherwise.
+     */
+    containsAnySSRCGroups(): boolean;
+    /**
+     * Finds the primary video SSRC.
+     * @returns {number|undefined} the primary video ssrc
+     * @throws Error if the underlying media description is not a video
+     */
+    getPrimaryVideoSsrc(): number | undefined;
+    /**
+     * Obtains RTX SSRC from the underlying video description (the
+     * secondary SSRC of the first "FID" group found)
+     * @param {number} primarySsrc the video ssrc for which to find the
+     * corresponding rtx ssrc
+     * @returns {number|undefined} the rtx ssrc (or undefined if there isn't
+     * one)
+     */
+    getRtxSSRC(primarySsrc: number): number | undefined;
+    /**
+     * Obtains all SSRCs contained in the underlying media description.
+     * @return {Array.<number>} an array with all SSRC as numbers.
+     */
+    getSSRCs(): Array<number>;
+    /**
+     * Obtains primary video SSRCs.
+     * @return {Array.<number>} an array of all primary video SSRCs as numbers.
+     * @throws Error if the wrapped media description is not a video.
+     */
+    getPrimaryVideoSSRCs(): Array<number>;
+    /**
+     * Dumps all SSRC groups of this media description to JSON.
+     */
+    dumpSSRCGroups(): string;
+    /**
+     * Removes all SSRC groups which contain given SSRC number at any position.
+     * @param {number} ssrc the SSRC for which all matching groups are to be
+     * removed.
+     */
+    removeGroupsWithSSRC(ssrc: number): void;
+    /**
+     * Removes groups that match given semantics.
+     * @param {string} semantics e.g. "SIM" or "FID"
+     */
+    removeGroupsBySemantics(semantics: string): void;
+    /**
+     * Replaces SSRC (does not affect SSRC groups, but only attributes).
+     * @param {number} oldSSRC the old SSRC number
+     * @param {number} newSSRC the new SSRC number
+     */
+    replaceSSRC(oldSSRC: number, newSSRC: number): void;
+    /**
+     * Adds given SSRC group to this media description.
+     * @param {object} group the SSRC group object as defined by
+     * the 'sdp-transform' lib.
+     */
+    addSSRCGroup(group: object): void;
+}
+export {};

types/auto/modules/settings/Settings.d.ts

@@ -0,0 +1,18 @@
+declare namespace _default {
+    export { jitsiLocalStorage as _storage };
+    /**
+     * Initializes the Settings class.
+     *
+     * @param {Storage|undefined} externalStorage - Object that implements the Storage interface. This object will be
+     * used for storing data instead of jitsiLocalStorage if specified.
+     */
+    export function init(externalStorage: Storage): void;
+    /**
+     * Initializes the Settings class.
+     *
+     * @param {Storage|undefined} externalStorage - Object that implements the Storage interface. This object will be
+     * used for storing data instead of jitsiLocalStorage if specified.
+     */
+    export function init(externalStorage: Storage): void;
+}
+export default _default;

types/auto/modules/statistics/AnalyticsAdapter.d.ts

@@ -0,0 +1,155 @@
+declare var _default: AnalyticsAdapter;
+export default _default;
+/**
+ * This class provides an API to lib-jitsi-meet and its users for sending
+ * analytics events. It serves as a bridge to different backend implementations
+ * ("analytics handlers") and a cache for events attempted to be sent before
+ * the analytics handlers were enabled.
+ *
+ * The API is designed to be an easy replacement for the previous version of
+ * this adapter, and is meant to be extended with more convenience methods.
+ *
+ *
+ * The API calls are translated to objects with the following structure, which
+ * are then passed to the sendEvent(event) function of the underlying handlers:
+ *
+ * {
+ *    type,
+ *
+ *    action,
+ *    actionSubject,
+ *    actionSubjectId,
+ *    attributes,
+ *    categories,
+ *    containerId,
+ *    containerType,
+ *    name,
+ *    objectId,
+ *    objectType,
+ *    source,
+ *    tags
+ * }
+ *
+ * The 'type' is one of 'operational', 'page', 'track' or 'ui', and some of the
+ * other properties are considered required according to the type.
+ *
+ * For events with type 'page', the required properties are: name.
+ *
+ * For events with type 'operational' and 'ui', the required properties are:
+ * action, actionSubject, source
+ *
+ * For events with type 'page', the required properties are:
+ * action, actionSubject, source, containerType, containerId, objectType,
+ * objectId
+ */
+declare class AnalyticsAdapter {
+    /**
+     * Reset the state to the initial one.
+     *
+     * @returns {void}
+     */
+    reset(): void;
+    /**
+     * Whether this AnalyticsAdapter has been disposed of or not. Once this
+     * is set to true, the AnalyticsAdapter is disabled and does not accept
+     * any more events, and it can not be re-enabled.
+     * @type {boolean}
+     */
+    disposed: boolean;
+    /**
+     * The set of handlers to which events will be sent.
+     * @type {Set<any>}
+     */
+    analyticsHandlers: Set<any>;
+    /**
+     * The cache of events which are not sent yet. The cache is enabled
+     * while this field is truthy, and disabled otherwise.
+     * @type {Array}
+     */
+    cache: any[];
+    /**
+     * Map of properties that will be added to every event. Note that the
+     * keys will be prefixed with "permanent.".
+     */
+    permanentProperties: any;
+    /**
+     * The name of the conference that this AnalyticsAdapter is associated
+     * with.
+     * @type {null}
+     */
+    conferenceName: any;
+    /**
+     * Dispose analytics. Clears all handlers.
+     */
+    dispose(): void;
+    /**
+     * Sets the handlers that are going to be used to send analytics. Sends any
+     * cached events.
+     * @param {Array} handlers the handlers
+     */
+    setAnalyticsHandlers(handlers: any[]): void;
+    /**
+     * Set the user properties to the analytics handlers.
+     *
+     * @returns {void}
+     */
+    _setUserProperties(): void;
+    /**
+     * Adds a set of permanent properties to this this AnalyticsAdapter.
+     * Permanent properties will be added as "attributes" to events sent to
+     * the underlying "analytics handlers", and their keys will be prefixed
+     * by "permanent_", i.e. adding a permanent property {key: "value"} will
+     * result in {"permanent_key": "value"} object to be added to the
+     * "attributes" field of events.
+     *
+     * @param {Object} properties the properties to add
+     */
+    addPermanentProperties(properties: any): void;
+    /**
+     * Sets the name of the conference that this AnalyticsAdapter is associated
+     * with.
+     * @param name the name to set.
+     */
+    setConferenceName(name: any): void;
+    /**
+     * Sends an event with a given name and given properties. The first
+     * parameter is either a string or an object. If it is a string, it is used
+     * as the event name and the second parameter is used at the attributes to
+     * attach to the event. If it is an object, it represents the whole event,
+     * including any desired attributes, and the second parameter is ignored.
+     *
+     * @param {String|Object} eventName either a string to be used as the name
+     * of the event, or an event object. If an event object is passed, the
+     * properties parameters is ignored.
+     * @param {Object} properties the properties/attributes to attach to the
+     * event, if eventName is a string.
+     */
+    sendEvent(eventName: string | any, properties?: any): void;
+    /**
+     * Checks whether an event has all of the required fields set, and tries
+     * to fill in some of the missing fields with reasonable default values.
+     * Returns true if after this operation the event has all of the required
+     * fields set, and false otherwise (if some of the required fields were not
+     * set and the attempt to fill them in with a default failed).
+     *
+     * @param event the event object.
+     * @return {boolean} true if the event (after the call to this function)
+     * contains all of the required fields, and false otherwise.
+     * @private
+     */
+    private _verifyRequiredFields;
+    /**
+     * Saves an event to the cache, if the cache is enabled.
+     * @param event the event to save.
+     * @returns {boolean} true if the event was saved, and false otherwise (i.e.
+     * if the cache was disabled).
+     * @private
+     */
+    private _maybeCacheEvent;
+    /**
+     *
+     * @param event
+     * @private
+     */
+    private _sendEvent;
+}

types/auto/modules/statistics/AudioOutputProblemDetector.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Collects the average audio levels per participant from the local stats and the stats received by every remote
+ * participant and compares them to detect potential audio problem for a participant.
+ */
+export default class AudioOutputProblemDetector {
+    /**
+     * Creates new <tt>AudioOutputProblemDetector</tt> instance.
+     *
+     * @param {JitsiCofnerence} conference - The conference instance to be monitored.
+     */
+    constructor(conference: any);
+    _conference: any;
+    _localAudioLevelCache: {};
+    _reportedParticipants: any[];
+    _audioProblemCandidates: {};
+    _numberOfRemoteAudioLevelsReceived: {};
+    /**
+     * A listener for audio level data retrieved by the local stats.
+     *
+     * @param {TraceablePeerConnection} tpc - The <tt>TraceablePeerConnection</tt> instance used to gather the data.
+     * @param {Object} avgAudioLevels - The average audio levels per participant.
+     * @returns {void}
+     */
+    _onLocalAudioLevelsReport(tpc: any, { avgAudioLevels }: any): void;
+    /**
+     * A listener for audio level data received by a remote participant.
+     *
+     * @param {string} userID - The user id of the participant that sent the data.
+     * @param {number} audioLevel - The average audio level value.
+     * @returns {void}
+     */
+    _onRemoteAudioLevelReceived(userID: string, { avgAudioLevels }: number): void;
+    /**
+     * Clears the data stored for a participant.
+     *
+     * @param {string} userID - The id of the participant.
+     * @returns {void}
+     */
+    _clearUserData(userID: string): void;
+    /**
+     * Disposes the allocated resources.
+     *
+     * @returns {void}
+     */
+    dispose(): void;
+}

types/auto/modules/statistics/AvgRTPStatsReporter.d.ts

@@ -0,0 +1,386 @@
+/**
+ * Reports average RTP statistics values (arithmetic mean) to the analytics
+ * module for things like bit rate, bandwidth, packet loss etc. It keeps track
+ * of the P2P vs JVB conference modes and submits the values under different
+ * namespaces (the events for P2P mode have 'p2p.' prefix). Every switch between
+ * P2P mode resets the data collected so far and averages are calculated from
+ * scratch.
+ */
+export default class AvgRTPStatsReporter {
+    /**
+     * Creates new instance of <tt>AvgRTPStatsReporter</tt>
+     * @param {JitsiConference} conference
+     * @param {number} n the number of samples, before arithmetic mean is to be
+     * calculated and values submitted to the analytics module.
+     */
+    constructor(conference: any, n: number);
+    /**
+     * How many {@link ConnectionQualityEvents.LOCAL_STATS_UPDATED} samples
+     * are to be included in arithmetic mean calculation.
+     * @type {number}
+     * @private
+     */
+    private _n;
+    /**
+     * The current sample index. Starts from 0 and goes up to {@link _n})
+     * when analytics report will be submitted.
+     * @type {number}
+     * @private
+     */
+    private _sampleIdx;
+    /**
+     * The conference for which stats will be collected and reported.
+     * @type {JitsiConference}
+     * @private
+     */
+    private _conference;
+    /**
+     * Average audio upload bitrate
+     * XXX What are the units?
+     * @type {AverageStatReport}
+     * @private
+     */
+    private _avgAudioBitrateUp;
+    /**
+     * Average audio download bitrate
+     * XXX What are the units?
+     * @type {AverageStatReport}
+     * @private
+     */
+    private _avgAudioBitrateDown;
+    /**
+     * Average video upload bitrate
+     * XXX What are the units?
+     * @type {AverageStatReport}
+     * @private
+     */
+    private _avgVideoBitrateUp;
+    /**
+     * Average video download bitrate
+     * XXX What are the units?
+     * @type {AverageStatReport}
+     * @private
+     */
+    private _avgVideoBitrateDown;
+    /**
+     * Average upload bandwidth
+     * XXX What are the units?
+     * @type {AverageStatReport}
+     * @private
+     */
+    private _avgBandwidthUp;
+    /**
+     * Average download bandwidth
+     * XXX What are the units?
+     * @type {AverageStatReport}
+     * @private
+     */
+    private _avgBandwidthDown;
+    /**
+     * Average total packet loss
+     * XXX What are the units?
+     * @type {AverageStatReport}
+     * @private
+     */
+    private _avgPacketLossTotal;
+    /**
+     * Average upload packet loss
+     * XXX What are the units?
+     * @type {AverageStatReport}
+     * @private
+     */
+    private _avgPacketLossUp;
+    /**
+     * Average download packet loss
+     * XXX What are the units?
+     * @type {AverageStatReport}
+     * @private
+     */
+    private _avgPacketLossDown;
+    /**
+     * Average FPS for remote videos
+     * @type {AverageStatReport}
+     * @private
+     */
+    private _avgRemoteFPS;
+    /**
+     * Average FPS for remote screen streaming videos (reported only if not
+     * a <tt>NaN</tt>).
+     * @type {AverageStatReport}
+     * @private
+     */
+    private _avgRemoteScreenFPS;
+    /**
+     * Average FPS for local video (camera)
+     * @type {AverageStatReport}
+     * @private
+     */
+    private _avgLocalFPS;
+    /**
+     * Average FPS for local screen streaming video (reported only if not
+     * a <tt>NaN</tt>).
+     * @type {AverageStatReport}
+     * @private
+     */
+    private _avgLocalScreenFPS;
+    /**
+     * Average pixels for remote screen streaming videos (reported only if
+     * not a <tt>NaN</tt>).
+     * @type {AverageStatReport}
+     * @private
+     */
+    private _avgRemoteCameraPixels;
+    /**
+     * Average pixels for remote screen streaming videos (reported only if
+     * not a <tt>NaN</tt>).
+     * @type {AverageStatReport}
+     * @private
+     */
+    private _avgRemoteScreenPixels;
+    /**
+     * Average pixels for local video (camera)
+     * @type {AverageStatReport}
+     * @private
+     */
+    private _avgLocalCameraPixels;
+    /**
+     * Average pixels for local screen streaming video (reported only if not
+     * a <tt>NaN</tt>).
+     * @type {AverageStatReport}
+     * @private
+     */
+    private _avgLocalScreenPixels;
+    /**
+     * Average connection quality as defined by
+     * the {@link ConnectionQuality} module.
+     * @type {AverageStatReport}
+     * @private
+     */
+    private _avgCQ;
+    _cachedTransportStats: {
+        p2p: any;
+        local_candidate_type: any;
+        remote_candidate_type: any;
+        transport_type: any;
+    };
+    _onLocalStatsUpdated: (data: any) => void;
+    _onP2PStatusChanged: () => void;
+    _onJvb121StatusChanged: (oldStatus: any, newStatus: any) => void;
+    jvbStatsMonitor: ConnectionAvgStats;
+    p2pStatsMonitor: ConnectionAvgStats;
+    /**
+     * Processes next batch of stats reported on
+     * {@link ConnectionQualityEvents.LOCAL_STATS_UPDATED}.
+     * @param {go figure} data
+     * @private
+     */
+    private _calculateAvgStats;
+    /**
+     * Calculates average number of pixels for the report
+     *
+     * @param {map} peerResolutions a map of peer resolutions
+     * @param {boolean} isLocal if the average is to be calculated for the local
+     * video or <tt>false</tt> if for remote videos.
+     * @param {VideoType} videoType
+     * @return {number|NaN} average number of pixels or <tt>NaN</tt> if there
+     * are no samples.
+     * @private
+     */
+    private _calculateAvgVideoPixels;
+    /**
+     * Calculate average pixels for either remote or local participant
+     * @param {object} videos maps resolution per video SSRC
+     * @param {JitsiParticipant|null} participant remote participant or
+     * <tt>null</tt> for local video pixels calculation.
+     * @param {VideoType} videoType the type of the video for which an average
+     * will be calculated.
+     * @return {number|NaN} average video pixels of all participant's videos or
+     * <tt>NaN</tt> if currently not available
+     * @private
+     */
+    private _calculatePeerAvgVideoPixels;
+    /**
+     * Calculates average FPS for the report
+     * @param {go figure} frameRate
+     * @param {boolean} isLocal if the average is to be calculated for the local
+     * video or <tt>false</tt> if for remote videos.
+     * @param {VideoType} videoType
+     * @return {number|NaN} average FPS or <tt>NaN</tt> if there are no samples.
+     * @private
+     */
+    private _calculateAvgVideoFps;
+    /**
+     * Calculate average FPS for either remote or local participant
+     * @param {object} videos maps FPS per video SSRC
+     * @param {JitsiParticipant|null} participant remote participant or
+     * <tt>null</tt> for local FPS calculation.
+     * @param {VideoType} videoType the type of the video for which an average
+     * will be calculated.
+     * @return {number|NaN} average FPS of all participant's videos or
+     * <tt>NaN</tt> if currently not available
+     * @private
+     */
+    private _calculatePeerAvgVideoFps;
+    /**
+     * Sends the 'transport.stats' analytics event whenever we detect that
+     * there is a change in the local or remote candidate type on the transport
+     * that is currently selected.
+     * @param {*} data
+     * @private
+     */
+    private _maybeSendTransportAnalyticsEvent;
+    /**
+     * Resets the stats related to JVB connection. Must not be called when in
+     * P2P mode, because then the {@link AverageStatReport} instances are
+     * tracking P2P stats. Note that this should never happen unless something
+     * is wrong with the P2P and JVB121 events.
+     * @private
+     */
+    private _resetAvgJvbStats;
+    /**
+     * Reset cache of all averages and {@link _sampleIdx}.
+     * @private
+     */
+    private _resetAvgStats;
+    /**
+     * Unregisters all event listeners and stops working.
+     */
+    dispose(): void;
+}
+/**
+ * Class gathers the stats that are calculated and reported for a
+ * {@link TraceablePeerConnection} even if it's not currently active. For
+ * example we want to monitor RTT for the JVB connection while in P2P mode.
+ */
+declare class ConnectionAvgStats {
+    /**
+     * Creates new <tt>ConnectionAvgStats</tt>
+     * @param {AvgRTPStatsReporter} avgRtpStatsReporter
+     * @param {boolean} isP2P
+     * @param {number} n the number of samples, before arithmetic mean is to be
+     * calculated and values submitted to the analytics module.
+     */
+    constructor(avgRtpStatsReporter: AvgRTPStatsReporter, isP2P: boolean, n: number);
+    /**
+     * Is this instance for JVB or P2P connection ?
+     * @type {boolean}
+     */
+    isP2P: boolean;
+    /**
+     * How many samples are to be included in arithmetic mean calculation.
+     * @type {number}
+     * @private
+     */
+    private _n;
+    /**
+     * The current sample index. Starts from 0 and goes up to {@link _n})
+     * when analytics report will be submitted.
+     * @type {number}
+     * @private
+     */
+    private _sampleIdx;
+    /**
+     * Average round trip time reported by the ICE candidate pair.
+     * @type {AverageStatReport}
+     */
+    _avgRTT: AverageStatReport;
+    /**
+     * Map stores average RTT to the JVB reported by remote participants.
+     * Mapped per participant id {@link JitsiParticipant.getId}.
+     *
+     * This is used only when {@link ConnectionAvgStats.isP2P} equals to
+     * <tt>false</tt>.
+     *
+     * @type {Map<string,AverageStatReport>}
+     * @private
+     */
+    private _avgRemoteRTTMap;
+    /**
+     * The conference for which stats will be collected and reported.
+     * @type {JitsiConference}
+     * @private
+     */
+    private _avgRtpStatsReporter;
+    /**
+     * The latest average E2E RTT for the JVB connection only.
+     *
+     * This is used only when {@link ConnectionAvgStats.isP2P} equals to
+     * <tt>false</tt>.
+     *
+     * @type {number}
+     */
+    _avgEnd2EndRTT: number;
+    _onConnectionStats: (tpc: any, stats: any) => void;
+    _onUserLeft: (id: any) => boolean;
+    _onRemoteStatsUpdated: (id: any, data: any) => void;
+    /**
+     * Processes next batch of stats.
+     * @param {go figure} data
+     * @private
+     */
+    private _calculateAvgStats;
+    /**
+     * Calculates arithmetic mean of all RTTs towards the JVB reported by
+     * participants.
+     * @return {number|NaN} NaN if not available (not enough data)
+     * @private
+     */
+    private _calculateAvgRemoteRTT;
+    /**
+     * Processes {@link ConnectionQualityEvents.REMOTE_STATS_UPDATED} to analyse
+     * RTT towards the JVB reported by each participant.
+     * @param {string} id {@link JitsiParticipant.getId}
+     * @param {go figure in ConnectionQuality.js} data
+     * @private
+     */
+    private _processRemoteStats;
+    /**
+     * Reset cache of all averages and {@link _sampleIdx}.
+     * @private
+     */
+    private _resetAvgStats;
+    /**
+     *
+     */
+    dispose(): void;
+}
+/**
+ * This will calculate an average for one, named stat and submit it to
+ * the analytics module when requested. It automatically counts the samples.
+ */
+declare class AverageStatReport {
+    /**
+     * Creates new <tt>AverageStatReport</tt> for given name.
+     * @param {string} name that's the name of the event that will be reported
+     * to the analytics module.
+     */
+    constructor(name: string);
+    name: string;
+    count: number;
+    sum: number;
+    samples: any[];
+    /**
+     * Adds the next value that will be included in the average when
+     * {@link calculate} is called.
+     * @param {number} nextValue
+     */
+    addNext(nextValue: number): void;
+    /**
+     * Calculates an average for the samples collected using {@link addNext}.
+     * @return {number|NaN} an average of all collected samples or <tt>NaN</tt>
+     * if no samples were collected.
+     */
+    calculate(): number | number;
+    /**
+     * Appends the report to the analytics "data" object. The object will be
+     * set under <tt>prefix</tt> + {@link this.name} key.
+     * @param {Object} report the analytics "data" object
+     */
+    appendReport(report: any): void;
+    /**
+     * Clears all memory of any samples collected, so that new average can be
+     * calculated using this instance.
+     */
+    reset(): void;
+}
+export {};

types/auto/modules/statistics/CallStats.d.ts

@@ -0,0 +1,249 @@
+/**
+ * An instance of this class is a wrapper for the CallStats API fabric. A fabric
+ * reports one peer connection to the CallStats backend and is allocated with
+ * {@link callstats.addNewFabric}. It has a bunch of instance methods for
+ * reporting various events. A fabric is considered disposed when
+ * {@link CallStats.sendTerminateEvent} is executed.
+ *
+ * Currently only one backend instance can be created ever and it's done using
+ * {@link CallStats.initBackend}. At the time of this writing there is no way to
+ * explicitly shutdown the backend, but it's supposed to close it's connection
+ * automatically, after all fabrics have been terminated.
+ */
+declare class CallStats {
+    /**
+     * A callback passed to {@link callstats.addNewFabric}.
+     * @param {string} error 'success' means ok
+     * @param {string} msg some more details
+     * @private
+     */
+    private static _addNewFabricCallback;
+    /**
+     * Callback passed to {@link callstats.initialize} (backend initialization)
+     * @param {string} error 'success' means ok
+     * @param {String} msg
+     * @private
+     */
+    private static _initCallback;
+    /**
+     * Empties report queue.
+     *
+     * @param {CallStats} csInstance - The callstats instance.
+     * @private
+     */
+    private static _emptyReportQueue;
+    /**
+     * Reports an error to callstats.
+     *
+     * @param {CallStats} [cs]
+     * @param type the type of the error, which will be one of the wrtcFuncNames
+     * @param error the error
+     * @param pc the peerconnection
+     * @private
+     */
+    private static _reportError;
+    /**
+     * Reports an error to callstats.
+     *
+     * @param {CallStats} cs
+     * @param event the type of the event, which will be one of the fabricEvent
+     * @param eventData additional data to pass to event
+     * @private
+     */
+    private static _reportEvent;
+    /**
+     * Wraps some of the CallStats API method and logs their calls with
+     * arguments on the debug logging level. Also wraps some of the backend
+     * methods execution into try catch blocks to not crash the app in case
+     * there is a problem with the backend itself.
+     * @param {callstats} theBackend
+     * @private
+     */
+    private static _traceAndCatchBackendCalls;
+    /**
+     * Returns the Set with the currently existing {@link CallStats} instances.
+     * Lazily initializes the Set to allow any Set polyfills to be applied.
+     * @type {Set<CallStats>}
+     */
+    static get fabrics(): Set<CallStats>;
+    /**
+     * Initializes the CallStats backend. Should be called only if
+     * {@link CallStats.isBackendInitialized} returns <tt>false</tt>.
+     * @param {object} options
+     * @param {String} options.callStatsID CallStats credentials - ID
+     * @param {String} options.callStatsSecret CallStats credentials - secret
+     * @param {string} options.aliasName the <tt>aliasName</tt> part of
+     * the <tt>userID</tt> aka endpoint ID, see CallStats docs for more info.
+     * @param {string} options.userName the <tt>userName</tt> part of
+     * the <tt>userID</tt> aka display name, see CallStats docs for more info.
+     * @param {object} options.configParams the set of parameters
+     * to enable/disable certain features in the library. See CallStats docs for more info.
+     *
+     */
+    static initBackend(options: {
+        callStatsID: string;
+        callStatsSecret: string;
+        aliasName: string;
+        userName: string;
+        configParams: object;
+    }): boolean;
+    /**
+     * Checks if the CallStats backend has been created. It does not mean that
+     * it has been initialized, but only that the API instance has been
+     * allocated successfully.
+     * @return {boolean} <tt>true</tt> if backend exists or <tt>false</tt>
+     * otherwise
+     */
+    static isBackendInitialized(): boolean;
+    /**
+     * Notifies CallStats about active device.
+     * @param {{deviceList: {String:String}}} devicesData list of devices with
+     * their data
+     * @param {CallStats} cs callstats instance related to the event
+     */
+    static sendActiveDeviceListEvent(devicesData: {
+        deviceList: {
+            String: string;
+        };
+    }, cs: CallStats): void;
+    /**
+     * Notifies CallStats that there is a log we want to report.
+     *
+     * @param {Error} e error to send or {String} message
+     * @param {CallStats} cs callstats instance related to the error (optional)
+     */
+    static sendApplicationLog(e: Error, cs: CallStats): void;
+    /**
+     * Sends the given feedback through CallStats.
+     *
+     * @param {string} conferenceID the conference ID for which the feedback
+     * will be reported.
+     * @param overall an integer between 1 and 5 indicating the
+     * user feedback
+     * @param comment detailed feedback from the user.
+     */
+    static sendFeedback(conferenceID: string, overall: any, comment: any): Promise<any>;
+    /**
+     * Notifies CallStats that getUserMedia failed.
+     *
+     * @param {Error} e error to send
+     * @param {CallStats} cs callstats instance related to the error (optional)
+     */
+    static sendGetUserMediaFailed(e: Error, cs: CallStats): void;
+    /**
+     * Notifies CallStats for mute events
+     * @param mute {boolean} true for muted and false for not muted
+     * @param type {String} "audio"/"video"
+     * @param {CallStats} cs callstats instance related to the event
+     */
+    static sendMuteEvent(mute: boolean, type: string, cs: CallStats): void;
+    /**
+     * Creates new CallStats instance that handles all callstats API calls for
+     * given {@link TraceablePeerConnection}. Each instance is meant to handle
+     * one CallStats fabric added with 'addFabric' API method for the
+     * {@link TraceablePeerConnection} instance passed in the constructor.
+     * @param {TraceablePeerConnection} tpc
+     * @param {Object} options
+     * @param {string} options.confID the conference ID that wil be used to
+     * report the session.
+     * @param {string} [options.remoteUserID='jitsi'] the remote user ID to
+     * which given <tt>tpc</tt> is connected.
+     */
+    constructor(tpc: any, options: {
+        confID: string;
+        remoteUserID?: string;
+    });
+    confID: string;
+    tpc: any;
+    peerconnection: any;
+    remoteUserID: string;
+    hasFabric: boolean;
+    /**
+     * Initializes CallStats fabric by calling "addNewFabric" for
+     * the peer connection associated with this instance.
+     * @return {boolean} true if the call was successful or false otherwise.
+     */
+    _addNewFabric(): boolean;
+    /**
+     * Lets CallStats module know where is given SSRC rendered by providing
+     * renderer tag ID.
+     * If the lib is not initialized yet queue the call for later, when it's
+     * ready.
+     * @param {number} ssrc the SSRC of the stream
+     * @param {boolean} isLocal indicates whether this the stream is local
+     * @param {string|null} streamEndpointId if the stream is not local the it
+     * needs to contain the stream owner's ID
+     * @param {string} usageLabel meaningful usage label of this stream like
+     *        'microphone', 'camera' or 'screen'.
+     * @param {string} containerId  the id of media 'audio' or 'video' tag which
+     *        renders the stream.
+     */
+    associateStreamWithVideoTag(ssrc: number, isLocal: boolean, streamEndpointId: string | null, usageLabel: string, containerId: string): void;
+    /**
+     * Notifies CallStats that we are the new dominant speaker in the
+     * conference.
+     */
+    sendDominantSpeakerEvent(): void;
+    /**
+     * Notifies CallStats that the fabric for the underlying peerconnection was
+     * closed and no evens should be reported, after this call.
+     */
+    sendTerminateEvent(): void;
+    /**
+     * Notifies CallStats for ice connection failed
+     */
+    sendIceConnectionFailedEvent(): void;
+    /**
+     * Notifies CallStats that peer connection failed to create offer.
+     *
+     * @param {Error} e error to send
+     */
+    sendCreateOfferFailed(e: Error): void;
+    /**
+     * Notifies CallStats that peer connection failed to create answer.
+     *
+     * @param {Error} e error to send
+     */
+    sendCreateAnswerFailed(e: Error): void;
+    /**
+     * Sends either resume or hold event for the fabric associated with
+     * the underlying peerconnection.
+     * @param {boolean} isResume true to resume or false to hold
+     */
+    sendResumeOrHoldEvent(isResume: boolean): void;
+    /**
+     * Notifies CallStats for screen sharing events
+     * @param {boolean} start true for starting screen sharing and
+     * false for not stopping
+     * @param {string|null} ssrc - optional ssrc value, used only when
+     * starting screen sharing.
+     */
+    sendScreenSharingEvent(start: boolean, ssrc: string | null): void;
+    /**
+     * Notifies CallStats that peer connection failed to set local description.
+     *
+     * @param {Error} e error to send
+     */
+    sendSetLocalDescFailed(e: Error): void;
+    /**
+     * Notifies CallStats that peer connection failed to set remote description.
+     *
+     * @param {Error} e error to send
+     */
+    sendSetRemoteDescFailed(e: Error): void;
+    /**
+     * Notifies CallStats that peer connection failed to add ICE candidate.
+     *
+     * @param {Error} e error to send
+     */
+    sendAddIceCandidateFailed(e: Error): void;
+}
+declare namespace CallStats {
+    const backend: any;
+    const reportsQueue: any[];
+    const backendInitialized: boolean;
+    const callStatsID: string;
+    const callStatsSecret: string;
+    const userID: object;
+}
+export default CallStats;

types/auto/modules/statistics/LocalStatsCollector.d.ts

@@ -0,0 +1,43 @@
+/**
+ * <tt>LocalStatsCollector</tt> calculates statistics for the local stream.
+ *
+ * @param stream the local stream
+ * @param interval stats refresh interval given in ms.
+ * @param callback function that receives the audio levels.
+ * @constructor
+ */
+declare function LocalStatsCollector(stream: any, interval: any, callback: any): void;
+declare class LocalStatsCollector {
+    /**
+     * <tt>LocalStatsCollector</tt> calculates statistics for the local stream.
+     *
+     * @param stream the local stream
+     * @param interval stats refresh interval given in ms.
+     * @param callback function that receives the audio levels.
+     * @constructor
+     */
+    constructor(stream: any, interval: any, callback: any);
+    stream: any;
+    intervalId: NodeJS.Timer;
+    intervalMilis: any;
+    audioLevel: number;
+    callback: any;
+    /**
+     * Starts the collecting the statistics.
+     */
+    start(): void;
+    /**
+     * Stops collecting the statistics.
+     */
+    stop(): void;
+}
+declare namespace LocalStatsCollector {
+    /**
+     * Checks if the environment has the necessary conditions to support
+     * collecting stats from local streams.
+     *
+     * @returns {boolean}
+     */
+    function isLocalStatsSupported(): boolean;
+}
+export default LocalStatsCollector;

types/auto/modules/statistics/PerformanceObserverStats.d.ts

@@ -0,0 +1,42 @@
+/**
+ * This class creates an observer that monitors browser's performance measurement events
+ * as they are recorded in the browser's performance timeline and computes an average and
+ * a maximum value for the long task events. Tasks are classified as long tasks if they take
+ * longer than 50ms to execute on the main thread.
+ */
+export class PerformanceObserverStats {
+    /**
+     * Creates a new instance of Performance observer statistics.
+     *
+     * @param {*} emitter Event emitter for emitting stats periodically
+     * @param {*} statsInterval interval for calculating the stats
+     */
+    constructor(emitter: any, statsInterval: any);
+    eventEmitter: any;
+    longTasks: number;
+    maxDuration: number;
+    performanceStatsInterval: any;
+    stats: RunningAverage;
+    /**
+     * Obtains the average rate of long tasks observed per min and the
+     * duration of the longest task recorded by the observer.
+     * @returns {Object}
+     */
+    getLongTasksStats(): any;
+    /**
+     * Starts the performance observer by registering the callback function
+     * that calculates the performance statistics periodically.
+     * @returns {void}
+     */
+    startObserver(): void;
+    longTaskEventHandler: (list: any) => void;
+    observer: PerformanceObserver;
+    longTasksIntervalId: NodeJS.Timer;
+    _lastTimeStamp: number;
+    /**
+     * Stops the performance observer.
+     * @returns {void}
+     */
+    stopObserver(): void;
+}
+import { RunningAverage } from "../util/MathUtil";

types/auto/modules/statistics/PrecallTest.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Loads the callstats script and initializes the library.
+ *
+ * @param {Function} onResult - The callback to be invoked when results are received.
+ * @returns {Promise<void>}
+ */
+export function init(options: any): Promise<void>;
+/**
+ * Executes a pre call test.
+ *
+ * @typedef PrecallTestResults
+ * @type {Object}
+ * @property {boolean} mediaConnectivity - If there is media connectivity or not.
+ * @property {number} throughput  - The average throughput.
+ * @property {number} fractionalLoss - The packet loss.
+ * @property {number} rtt - The round trip time.
+ * @property {string} provider - It is usually 'callstats'.
+ *
+ * @returns {Promise<{PrecallTestResults}>}
+ */
+export function execute(): Promise<{
+    PrecallTestResults;
+}>;
+declare namespace _default {
+    export { init };
+    export { execute };
+}
+export default _default;
+/**
+ * Initializes the callstats lib and registers a callback to be invoked
+ * when there are 'preCallTestResults'.
+ */
+export type PrecallTestOptions = {
+    /**
+     * - Callstats credentials - the id.
+     */
+    callStatsID: string;
+    /**
+     * - Callstats credentials - the secret.
+     */
+    callStatsSecret: string;
+    /**
+     * - The user name to use when initializing callstats.
+     */
+    statisticsId: string;
+    /**
+     * - The user display name.
+     */
+    statisticsDisplayName: string;
+};
+/**
+ * Executes a pre call test.
+ */
+export type PrecallTestResults = {
+    /**
+     * - If there is media connectivity or not.
+     */
+    mediaConnectivity: boolean;
+    /**
+     * - The average throughput.
+     */
+    throughput: number;
+    /**
+     * - The packet loss.
+     */
+    fractionalLoss: number;
+    /**
+     * - The round trip time.
+     */
+    rtt: number;
+    /**
+     * - It is usually 'callstats'.
+     */
+    provider: string;
+};

types/auto/modules/statistics/RTPStatsCollector.d.ts

@@ -0,0 +1,151 @@
+/**
+ * <tt>StatsCollector</tt> registers for stats updates of given
+ * <tt>peerconnection</tt> in given <tt>interval</tt>. On each update particular
+ * stats are extracted and put in {@link SsrcStats} objects. Once the processing
+ * is done <tt>audioLevelsUpdateCallback</tt> is called with <tt>this</tt>
+ * instance as an event source.
+ *
+ * @param peerconnection WebRTC PeerConnection object.
+ * @param audioLevelsInterval
+ * @param statsInterval stats refresh interval given in ms.
+ * @param eventEmitter
+ * @constructor
+ */
+export default function StatsCollector(peerconnection: any, audioLevelsInterval: any, statsInterval: any, eventEmitter: any): void;
+export default class StatsCollector {
+    /**
+     * <tt>StatsCollector</tt> registers for stats updates of given
+     * <tt>peerconnection</tt> in given <tt>interval</tt>. On each update particular
+     * stats are extracted and put in {@link SsrcStats} objects. Once the processing
+     * is done <tt>audioLevelsUpdateCallback</tt> is called with <tt>this</tt>
+     * instance as an event source.
+     *
+     * @param peerconnection WebRTC PeerConnection object.
+     * @param audioLevelsInterval
+     * @param statsInterval stats refresh interval given in ms.
+     * @param eventEmitter
+     * @constructor
+     */
+    constructor(peerconnection: any, audioLevelsInterval: any, statsInterval: any, eventEmitter: any);
+    peerconnection: any;
+    baselineAudioLevelsReport: any;
+    currentAudioLevelsReport: any;
+    currentStatsReport: any;
+    previousStatsReport: any;
+    audioLevelReportHistory: {};
+    audioLevelsIntervalId: NodeJS.Timer;
+    eventEmitter: any;
+    conferenceStats: ConferenceStats;
+    audioLevelsIntervalMilis: any;
+    speakerList: any[];
+    statsIntervalId: NodeJS.Timer;
+    statsIntervalMilis: any;
+    /**
+     * Maps SSRC numbers to {@link SsrcStats}.
+     * @type {Map<number,SsrcStats}
+     */
+    ssrc2stats: Map<number, SsrcStats>;
+    /**
+     * Set the list of the remote speakers for which audio levels are to be calculated.
+     *
+     * @param {Array<string>} speakerList - Endpoint ids.
+     * @returns {void}
+     */
+    setSpeakerList(speakerList: Array<string>): void;
+    /**
+     * Stops stats updates.
+     */
+    stop(): void;
+    /**
+     * Callback passed to <tt>getStats</tt> method.
+     * @param error an error that occurred on <tt>getStats</tt> call.
+     */
+    errorCallback(error: any): void;
+    /**
+     * Starts stats updates.
+     */
+    start(startAudioLevelStats: any): void;
+    /**
+     *
+     */
+    _processAndEmitReport(): void;
+    private getNonNegativeValue;
+    private _calculateBitrate;
+    /**
+     * Stats processing for spec-compliant RTCPeerConnection#getStats.
+     */
+    processStatsReport(): void;
+    /**
+     * Stats processing logic.
+     */
+    processAudioLevelReport(): void;
+}
+/**
+ *
+ */
+declare function ConferenceStats(): void;
+declare class ConferenceStats {
+    /**
+     * The bandwidth
+     * @type {{}}
+     */
+    bandwidth: {};
+    /**
+     * The bit rate
+     * @type {{}}
+     */
+    bitrate: {};
+    /**
+     * The packet loss rate
+     * @type {{}}
+     */
+    packetLoss: {};
+    /**
+     * Array with the transport information.
+     * @type {Array}
+     */
+    transport: any[];
+}
+/**
+ * Holds "statistics" for a single SSRC.
+ * @constructor
+ */
+declare function SsrcStats(): void;
+declare class SsrcStats {
+    loss: {};
+    bitrate: {
+        download: number;
+        upload: number;
+    };
+    resolution: {};
+    framerate: number;
+    codec: string;
+    /**
+     * Sets the "loss" object.
+     * @param loss the value to set.
+     */
+    setLoss(loss: any): void;
+    /**
+     * Sets resolution that belong to the ssrc represented by this instance.
+     * @param resolution new resolution value to be set.
+     */
+    setResolution(resolution: any): void;
+    /**
+     * Adds the "download" and "upload" fields from the "bitrate" parameter to
+     * the respective fields of the "bitrate" field of this object.
+     * @param bitrate an object holding the values to add.
+     */
+    addBitrate(bitrate: any): void;
+    /**
+     * Resets the bit rate for given <tt>ssrc</tt> that belong to the peer
+     * represented by this instance.
+     */
+    resetBitrate(): void;
+    /**
+     * Sets the "framerate".
+     * @param framerate the value to set.
+     */
+    setFramerate(framerate: any): void;
+    setCodec(codec: any): void;
+}
+export {};

types/auto/modules/statistics/SpeakerStats.d.ts

@@ -0,0 +1,114 @@
+export = SpeakerStats;
+/**
+ * A model for keeping track of each user's total
+ * time as a dominant speaker. The model also
+ * keeps track of the user's last known name
+ * in case the user has left the meeting,
+ * which is also tracked.
+ */
+declare class SpeakerStats {
+    /**
+     * Initializes a new SpeakerStats instance.
+     *
+     * @constructor
+     * @param {string} userId - The id of the user being tracked.
+     * @param {string} displayName - The name of the user being tracked.
+     * @param {boolean} isLocalStats - True if the stats model tracks
+     * the local user.
+     * @returns {void}
+     */
+    constructor(userId: string, displayName: string, isLocalStats: boolean);
+    _userId: string;
+    _isLocalStats: boolean;
+    totalDominantSpeakerTime: number;
+    _dominantSpeakerStart: number;
+    _hasLeft: boolean;
+    _facialExpressions: {
+        happy: number;
+        neutral: number;
+        surprised: number;
+        angry: number;
+        fearful: number;
+        disgusted: number;
+        sad: number;
+    };
+    /**
+     * Get the user id being tracked.
+     *
+     * @returns {string} The user id.
+     */
+    getUserId(): string;
+    /**
+     * Get the name of the user being tracked.
+     *
+     * @returns {string} The user name.
+     */
+    getDisplayName(): string;
+    /**
+     * Updates the last known name of the user being tracked.
+     *
+     * @param {string} - The user name.
+     * @returns {void}
+     */
+    setDisplayName(newName: any): void;
+    displayName: any;
+    /**
+     * Returns true if the stats are tracking the local user.
+     *
+     * @returns {boolean}
+     */
+    isLocalStats(): boolean;
+    /**
+     * Returns true if the tracked user is currently a dominant speaker.
+     *
+     * @returns {boolean}
+     */
+    isDominantSpeaker(): boolean;
+    /**
+     * Returns true if the tracked user is currently a dominant speaker.
+     *
+     * @param {boolean} - If true, the user will being accumulating time
+     * as dominant speaker. If false, the user will not accumulate time
+     * and will record any time accumulated since starting as dominant speaker.
+     * @returns {void}
+     */
+    setDominantSpeaker(isNowDominantSpeaker: any): void;
+    /**
+     * Get how long the tracked user has been dominant speaker.
+     *
+     * @returns {number} - The speaker time in milliseconds.
+     */
+    getTotalDominantSpeakerTime(): number;
+    /**
+     * Get whether or not the user is still in the meeting.
+     *
+     * @returns {boolean} True if the user is no longer in the meeting.
+     */
+    hasLeft(): boolean;
+    /**
+     * Set the user as having left the meeting.
+     *
+     * @returns {void}
+     */
+    markAsHasLeft(): void;
+    /**
+     * Gets the facial expressions of the user.
+     *
+     * @returns {Object}
+     */
+    getFacialExpressions(): any;
+    /**
+     * Sets the facial expressions of the user.
+     *
+     * @param {Object} facialExpressions - object with facial expressions.
+     * @returns {void}
+     */
+    setFacialExpressions(facialExpressions: any): void;
+    /**
+     * Adds a new facial expression to speaker stats.
+     *
+     * @param  {string} facialExpression
+     * @param {number} duration
+     */
+    addFacialExpression(facialExpression: string, duration: number): void;
+}

types/auto/modules/statistics/SpeakerStatsCollector.d.ts

@@ -0,0 +1,79 @@
+/**
+ * A collection for tracking speaker stats. Attaches listeners
+ * to the conference to automatically update on tracked events.
+ */
+export default class SpeakerStatsCollector {
+    /**
+     * Initializes a new SpeakerStatsCollector instance.
+     *
+     * @constructor
+     * @param {JitsiConference} conference - The conference to track.
+     * @returns {void}
+     */
+    constructor(conference: any);
+    stats: {
+        users: {};
+        dominantSpeakerId: any;
+    };
+    conference: any;
+    /**
+     * Reacts to dominant speaker change events by changing its speaker stats
+     * models to reflect the current dominant speaker.
+     *
+     * @param {string} dominantSpeakerId - The user id of the new
+     * dominant speaker.
+     * @returns {void}
+     * @private
+     */
+    private _onDominantSpeaker;
+    /**
+     * Reacts to user join events by creating a new SpeakerStats model.
+     *
+     * @param {string} userId - The user id of the new user.
+     * @param {JitsiParticipant} - The JitsiParticipant model for the new user.
+     * @returns {void}
+     * @private
+     */
+    private _onUserJoin;
+    /**
+     * Reacts to user leave events by updating the associated user's
+     * SpeakerStats model.
+     *
+     * @param {string} userId - The user id of the user that left.
+     * @returns {void}
+     * @private
+     */
+    private _onUserLeave;
+    /**
+     * Reacts to user name change events by updating the last known name
+     * tracked in the associated SpeakerStats model.
+     *
+     * @param {string} userId - The user id of the user that left.
+     * @returns {void}
+     * @private
+     */
+    private _onDisplayNameChange;
+    /**
+     * Adds a new facial expression with its duration of a remote user.
+     *
+     * @param {string} userId - The user id of the user that left.
+     * @param {Object} data - The facial expression with its duration.
+     * @returns {void}
+     * @private
+     */
+    private _onFacialExpressionAdd;
+    /**
+     * Return a copy of the tracked SpeakerStats models.
+     *
+     * @returns {Object} The keys are the user ids and the values are the
+     * associated user's SpeakerStats model.
+     */
+    getStats(): any;
+    /**
+     * Updates of the current stats is requested, passing the new values.
+     *
+     * @param {Object} newStats - The new values used to update current one.
+     * @private
+     */
+    private _updateStats;
+}

types/auto/modules/statistics/constants.d.ts

@@ -0,0 +1,7 @@
+export const CALLSTATS_SCRIPT_URL: "https://api.callstats.io/static/callstats-ws.min.js";
+/**
+ * The number of remote speakers for which the audio levels will be calculated using
+ * RTCRtpReceiver#getSynchronizationSources. Limit the number of endpoints to save cpu on the client as this API call
+ * is known to take longer to execute when there are many audio receivers.
+ */
+export const SPEAKERS_AUDIO_LEVELS: 5;

types/auto/modules/statistics/statistics.d.ts

@@ -0,0 +1,353 @@
+/// <reference types="node" />
+/**
+ * The options to configure Statistics.
+ * @typedef {Object} StatisticsOptions
+ * @property {string} applicationName - The application name to pass to
+ * callstats.
+ * @property {string} aliasName - The alias name to use when initializing callstats.
+ * @property {string} userName - The user name to use when initializing callstats.
+ * @property {string} confID - The callstats conference ID to use.
+ * @property {string} callStatsID - Callstats credentials - the id.
+ * @property {string} callStatsSecret - Callstats credentials - the secret.
+ * @property {string} customScriptUrl - A custom lib url to use when downloading
+ * callstats library.
+ * @property {string} roomName - The room name we are currently in.
+ * @property {string} configParams - The set of parameters
+ * to enable/disable certain features in the library. See CallStats docs for more info.
+ */
+/**
+ *
+ * @param xmpp
+ * @param {StatisticsOptions} options - The options to use creating the
+ * Statistics.
+ */
+declare function Statistics(xmpp: any, options: StatisticsOptions): void;
+declare class Statistics {
+    /**
+     * The options to configure Statistics.
+     * @typedef {Object} StatisticsOptions
+     * @property {string} applicationName - The application name to pass to
+     * callstats.
+     * @property {string} aliasName - The alias name to use when initializing callstats.
+     * @property {string} userName - The user name to use when initializing callstats.
+     * @property {string} confID - The callstats conference ID to use.
+     * @property {string} callStatsID - Callstats credentials - the id.
+     * @property {string} callStatsSecret - Callstats credentials - the secret.
+     * @property {string} customScriptUrl - A custom lib url to use when downloading
+     * callstats library.
+     * @property {string} roomName - The room name we are currently in.
+     * @property {string} configParams - The set of parameters
+     * to enable/disable certain features in the library. See CallStats docs for more info.
+     */
+    /**
+     *
+     * @param xmpp
+     * @param {StatisticsOptions} options - The options to use creating the
+     * Statistics.
+     */
+    constructor(xmpp: any, options: StatisticsOptions);
+    /**
+     * {@link RTPStats} mapped by {@link TraceablePeerConnection.id} which
+     * collect RTP statistics for each peerconnection.
+     * @type {Map<string, RTPStats}
+     */
+    rtpStatsMap: Map<string, RTPStats>;
+    eventEmitter: EventEmitter;
+    xmpp: any;
+    options: {};
+    callStatsIntegrationEnabled: boolean;
+    callStatsApplicationLogsDisabled: any;
+    /**
+     * Stores {@link CallStats} instances for each
+     * {@link TraceablePeerConnection} (one {@link CallStats} instance serves
+     * one TPC). The instances are mapped by {@link TraceablePeerConnection.id}.
+     * @type {Map<number, CallStats>}
+     */
+    callsStatsInstances: Map<number, CallStats>;
+    /**
+     * Starts collecting RTP stats for given peerconnection.
+     * @param {TraceablePeerConnection} peerconnection
+     */
+    startRemoteStats(peerconnection: any): void;
+    addAudioLevelListener(listener: any): void;
+    removeAudioLevelListener(listener: any): void;
+    addBeforeDisposedListener(listener: any): void;
+    removeBeforeDisposedListener(listener: any): void;
+    addConnectionStatsListener(listener: any): void;
+    removeConnectionStatsListener(listener: any): void;
+    addByteSentStatsListener(listener: any): void;
+    removeByteSentStatsListener(listener: any): void;
+    /**
+     * Add a listener that would be notified on a LONG_TASKS_STATS event.
+     *
+     * @param {Function} listener a function that would be called when notified.
+     * @returns {void}
+     */
+    addLongTasksStatsListener(listener: Function): void;
+    /**
+     * Creates an instance of {@link PerformanceObserverStats} and starts the
+     * observer that records the stats periodically.
+     *
+     * @returns {void}
+     */
+    attachLongTasksStats(conference: any): void;
+    performanceObserverStats: PerformanceObserverStats;
+    /**
+     * Obtains the current value of the LongTasks event statistics.
+     *
+     * @returns {Object|null} stats object if the observer has been
+     * created, null otherwise.
+     */
+    getLongTasksStats(): any | null;
+    /**
+     * Removes the given listener for the LONG_TASKS_STATS event.
+     *
+     * @param {Function} listener the listener we want to remove.
+     * @returns {void}
+     */
+    removeLongTasksStatsListener(listener: Function): void;
+    /**
+     * Updates the list of speakers for which the audio levels are to be calculated. This is needed for the jvb pc only.
+     *
+     * @param {Array<string>} speakerList The list of remote endpoint ids.
+     * @returns {void}
+     */
+    setSpeakerList(speakerList: Array<string>): void;
+    dispose(): void;
+    private _stopRemoteStats;
+    /**
+     * Stops collecting RTP stats for given peerconnection
+     * @param {TraceablePeerConnection} tpc
+     */
+    stopRemoteStats(tpc: any): void;
+    /**
+     * Initializes the callstats.io API.
+     * @param {TraceablePeerConnection} tpc the {@link TraceablePeerConnection}
+     * instance for which CalStats will be started.
+     * @param {string} remoteUserID
+     */
+    startCallStats(tpc: any, remoteUserID: string): void;
+    /**
+     * Removes the callstats.io instances.
+     */
+    stopCallStats(tpc: any): void;
+    /**
+     * Returns true if the callstats integration is enabled, otherwise returns
+     * false.
+     *
+     * @returns true if the callstats integration is enabled, otherwise returns
+     * false.
+     */
+    isCallstatsEnabled(): boolean;
+    /**
+     * Logs either resume or hold event for the given peer connection.
+     * @param {TraceablePeerConnection} tpc the connection for which event will be
+     * reported
+     * @param {boolean} isResume true for resume or false for hold
+     */
+    sendConnectionResumeOrHoldEvent(tpc: any, isResume: boolean): void;
+    /**
+     * Notifies CallStats and analytics (if present) for ice connection failed
+     * @param {TraceablePeerConnection} tpc connection on which failure occurred.
+     */
+    sendIceConnectionFailedEvent(tpc: any): void;
+    /**
+     * Notifies CallStats for mute events
+     * @param {TraceablePeerConnection} tpc connection on which failure occurred.
+     * @param {boolean} muted true for muted and false for not muted
+     * @param {String} type "audio"/"video"
+     */
+    sendMuteEvent(tpc: any, muted: boolean, type: string): void;
+    /**
+     * Notifies CallStats for screen sharing events
+     * @param start {boolean} true for starting screen sharing and
+     * false for not stopping
+     * @param {string|null} ssrc - optional ssrc value, used only when
+     * starting screen sharing.
+     */
+    sendScreenSharingEvent(start: boolean, ssrc: string | null): void;
+    /**
+     * Notifies the statistics module that we are now the dominant speaker of the
+     * conference.
+     * @param {String} roomJid - The room jid where the speaker event occurred.
+     */
+    sendDominantSpeakerEvent(roomJid: string): void;
+    /**
+     * Lets the underlying statistics module know where is given SSRC rendered by
+     * providing renderer tag ID.
+     * @param {TraceablePeerConnection} tpc the connection to which the stream
+     * belongs to
+     * @param {number} ssrc the SSRC of the stream
+     * @param {boolean} isLocal
+     * @param {string} userId
+     * @param {string} usageLabel  meaningful usage label of this stream like
+     *        'microphone', 'camera' or 'screen'.
+     * @param {string} containerId the id of media 'audio' or 'video' tag which
+     *        renders the stream.
+     */
+    associateStreamWithVideoTag(tpc: any, ssrc: number, isLocal: boolean, userId: string, usageLabel: string, containerId: string): void;
+    /**
+     * Notifies CallStats that peer connection failed to create offer.
+     *
+     * @param {Error} e error to send
+     * @param {TraceablePeerConnection} tpc connection on which failure occurred.
+     */
+    sendCreateOfferFailed(e: Error, tpc: any): void;
+    /**
+     * Notifies CallStats that peer connection failed to create answer.
+     *
+     * @param {Error} e error to send
+     * @param {TraceablePeerConnection} tpc connection on which failure occured.
+     */
+    sendCreateAnswerFailed(e: Error, tpc: any): void;
+    /**
+     * Notifies CallStats that peer connection failed to set local description.
+     *
+     * @param {Error} e error to send
+     * @param {TraceablePeerConnection} tpc connection on which failure occurred.
+     */
+    sendSetLocalDescFailed(e: Error, tpc: any): void;
+    /**
+     * Notifies CallStats that peer connection failed to set remote description.
+     *
+     * @param {Error} e error to send
+     * @param {TraceablePeerConnection} tpc connection on which failure occurred.
+     */
+    sendSetRemoteDescFailed(e: Error, tpc: any): void;
+    /**
+     * Notifies CallStats that peer connection failed to add ICE candidate.
+     *
+     * @param {Error} e error to send
+     * @param {TraceablePeerConnection} tpc connection on which failure occurred.
+     */
+    sendAddIceCandidateFailed(e: Error, tpc: any): void;
+    /**
+     * Sends the given feedback through CallStats.
+     *
+     * @param overall an integer between 1 and 5 indicating the user's rating.
+     * @param comment the comment from the user.
+     * @returns {Promise} Resolves when callstats feedback has been submitted
+     * successfully.
+     */
+    sendFeedback(overall: any, comment: any): Promise<any>;
+}
+declare namespace Statistics {
+    /**
+     * Init statistic options
+     * @param options
+     */
+    export function init(options: any): void;
+    export const audioLevelsEnabled: boolean;
+    export const audioLevelsInterval: number;
+    export const pcStatsInterval: number;
+    export const disableThirdPartyRequests: boolean;
+    export { analytics };
+    export const instances: any;
+    export const localStats: any[];
+    export function startLocalStats(stream: any, callback: any): void;
+    export function stopLocalStats(stream: any): void;
+    /**
+     * Obtains the list of *all* {@link CallStats} instances collected from every
+     * valid {@link Statistics} instance.
+     * @return {Set<CallStats>}
+     * @private
+     */
+    export function _getAllCallStatsInstances(): Set<CallStats>;
+    /**
+     * Notifies about active device.
+     * @param {{deviceList: {String:String}}} devicesData - list of devices with
+     *      their data
+     */
+    export function sendActiveDeviceListEvent(devicesData: {
+        deviceList: {
+            String: string;
+        };
+    }): void;
+    /**
+     * Notifies CallStats that getUserMedia failed.
+     *
+     * @param {Error} e error to send
+     */
+    export function sendGetUserMediaFailed(e: Error): void;
+    /**
+     * Adds to CallStats an application log.
+     *
+     * @param {String} m a log message to send or an {Error} object to be reported
+     */
+    export function sendLog(m: string): void;
+    export const LOCAL_JID: string;
+    /**
+     * Reports global error to CallStats.
+     *
+     * @param {Error} error
+     */
+    export function reportGlobalError(error: Error): void;
+    /**
+     * Sends event to analytics and logs a message to the logger/console. Console
+     * messages might also be logged to callstats automatically.
+     *
+     * @param {string | Object} event the event name, or an object which
+     * represents the entire event.
+     * @param {Object} properties properties to attach to the event (if an event
+     * name as opposed to an event object is provided).
+     */
+    export function sendAnalyticsAndLog(event: any, properties?: any): void;
+    /**
+     * Sends event to analytics.
+     *
+     * @param {string | Object} eventName the event name, or an object which
+     * represents the entire event.
+     * @param {Object} properties properties to attach to the event
+     */
+    export function sendAnalytics(eventName: any, properties?: any): void;
+}
+export default Statistics;
+/**
+ * The options to configure Statistics.
+ */
+export type StatisticsOptions = {
+    /**
+     * - The application name to pass to
+     * callstats.
+     */
+    applicationName: string;
+    /**
+     * - The alias name to use when initializing callstats.
+     */
+    aliasName: string;
+    /**
+     * - The user name to use when initializing callstats.
+     */
+    userName: string;
+    /**
+     * - The callstats conference ID to use.
+     */
+    confID: string;
+    /**
+     * - Callstats credentials - the id.
+     */
+    callStatsID: string;
+    /**
+     * - Callstats credentials - the secret.
+     */
+    callStatsSecret: string;
+    /**
+     * - A custom lib url to use when downloading
+     * callstats library.
+     */
+    customScriptUrl: string;
+    /**
+     * - The room name we are currently in.
+     */
+    roomName: string;
+    /**
+     * - The set of parameters
+     * to enable/disable certain features in the library. See CallStats docs for more info.
+     */
+    configParams: string;
+};
+import RTPStats from "./RTPStatsCollector";
+import EventEmitter from "events";
+import CallStats from "./CallStats";
+import { PerformanceObserverStats } from "./PerformanceObserverStats";
+import analytics from "./AnalyticsAdapter";

types/auto/modules/transcription/audioRecorder.d.ts

@@ -0,0 +1,82 @@
+export default AudioRecorder;
+/**
+ * main exported object of the file, holding all
+ * relevant functions and variables for the outside world
+ * @param jitsiConference the jitsiConference which this object
+ * is going to record
+ */
+declare function AudioRecorder(jitsiConference: any): void;
+declare class AudioRecorder {
+    /**
+     * main exported object of the file, holding all
+     * relevant functions and variables for the outside world
+     * @param jitsiConference the jitsiConference which this object
+     * is going to record
+     */
+    constructor(jitsiConference: any);
+    recorders: any[];
+    fileType: string;
+    isRecording: boolean;
+    jitsiConference: any;
+    /**
+     * Adds a new TrackRecorder object to the array.
+     *
+     * @param track the track potentially holding an audio stream
+     */
+    addTrack(track: any): void;
+    /**
+     * Creates a TrackRecorder object. Also creates the MediaRecorder and
+     * data array for the trackRecorder.
+     * @param track the JitsiTrack holding the audio MediaStream(s)
+     */
+    instantiateTrackRecorder(track: any): TrackRecorder;
+    /**
+     * Notifies the module that a specific track has stopped, e.g participant left
+     * the conference.
+     * if the recording has not started yet, the TrackRecorder will be removed from
+     * the array. If the recording has started, the recorder will stop recording
+     * but not removed from the array so that the recorded stream can still be
+     * accessed
+     *
+     * @param {JitsiTrack} track the JitsiTrack to remove from the recording session
+     */
+    removeTrack(track: any): void;
+    /**
+     * Tries to update the name value of all TrackRecorder in the array.
+     * If it hasn't changed,it will keep the exiting name. If it changes to a
+     * undefined value, the old value will also be kept.
+     */
+    updateNames(): void;
+    /**
+     * Starts the audio recording of every local and remote track
+     */
+    start(): void;
+    /**
+     * Stops the audio recording of every local and remote track
+     */
+    stop(): void;
+    /**
+     * link hacking to download all recorded audio streams
+     */
+    download(): void;
+    /**
+     * returns the audio files of all recorders as an array of objects,
+     * which include the name of the owner of the track and the starting time stamp
+     * @returns {Array} an array of RecordingResult objects
+     */
+    getRecordingResults(): any[];
+    /**
+     * Gets the mime type of the recorder audio
+     * @returns {String} the mime type of the recorder audio
+     */
+    getFileType(): string;
+}
+declare namespace AudioRecorder {
+    export { determineCorrectFileType };
+}
+import TrackRecorder from "./trackRecorder";
+/**
+ * Determines which kind of audio recording the browser supports
+ * chrome supports "audio/webm" and firefox supports "audio/ogg"
+ */
+declare function determineCorrectFileType(): "audio/webm" | "audio/ogg";

types/auto/modules/transcription/recordingResult.d.ts

@@ -0,0 +1,18 @@
+/**
+ * This object stores variables needed around the recording of an audio stream
+ * and passing this recording along with additional information along to
+ * different processes
+ */
+export default class RecordingResult {
+    /**
+     * @param blob the recording audio stream as a single blob
+     * @param name the name of the person of the audio stream
+     * @param startTime the time in UTC when recording of the audiostream started
+     * @param wordArray the recorder audio stream transcribed as an array of Word objects
+     */
+    constructor(blob: any, name: any, startTime: any, wordArray: any);
+    blob: any;
+    name: any;
+    startTime: any;
+    wordArray: any;
+}

types/auto/modules/transcription/trackRecorder.d.ts

@@ -0,0 +1,16 @@
+/**
+ * A TrackRecorder object holds all the information needed for recording a
+ * single JitsiTrack (either remote or local)
+ * @param track The JitsiTrack the object is going to hold
+ */
+export default class TrackRecorder {
+    /**
+     * @param track The JitsiTrack the object is going to hold
+     */
+    constructor(track: any);
+    track: any;
+    recorder: any;
+    data: any;
+    name: any;
+    startTime: any;
+}

types/auto/modules/transcription/transcriber.d.ts

@@ -0,0 +1,79 @@
+export default Transcriber;
+/**
+ * This is the main object for handing the Transcription. It interacts with
+ * the audioRecorder to record every person in a conference and sends the
+ * recorder audio to a transcriptionService. The returned speech-to-text result
+ * will be merged to create a transcript
+ * @param {AudioRecorder} audioRecorder An audioRecorder recording a conference
+ */
+declare function Transcriber(): void;
+declare class Transcriber {
+    audioRecorder: AudioRecorder;
+    transcriptionService: SphinxService;
+    counter: any;
+    startTime: Date;
+    transcription: string;
+    callback: any;
+    results: any[];
+    state: string;
+    lineLength: number;
+    /**
+     * Method to start the transcription process. It will tell the audioRecorder
+     * to start storing all audio streams and record the start time for merging
+     * purposes
+     */
+    start(): void;
+    /**
+     * Method to stop the transcription process. It will tell the audioRecorder to
+     * stop, and get all the recorded audio to send it to the transcription service
+    
+     * @param callback a callback which will receive the transcription
+     */
+    stop(callback: any): void;
+    /**
+     * this method will check if the counter is zero. If it is, it will call
+     * the merging method
+     */
+    maybeMerge(): void;
+    /**
+     * This method will merge all speech-to-text arrays together in one
+     * readable transcription string
+     */
+    merge(): void;
+    /**
+     * Appends a word object to the transcription. It will make a new line with a
+     * name if a name is specified
+     * @param {Word} word the Word object holding the word to append
+     * @param {String|null} name the name of a new speaker. Null if not applicable
+     */
+    updateTranscription(word: any, name: string | null): void;
+    /**
+     * Gives the transcriber a JitsiTrack holding an audioStream to transcribe.
+     * The JitsiTrack is given to the audioRecorder. If it doesn't hold an
+     * audiostream, it will not be added by the audioRecorder
+     * @param {JitsiTrack} track the track to give to the audioRecorder
+     */
+    addTrack(track: any): void;
+    /**
+     * Remove the given track from the auioRecorder
+     * @param track
+     */
+    removeTrack(track: any): void;
+    /**
+     * Will return the created transcription if it's avialable or throw an error
+     * when it's not done yet
+     * @returns {String} the transcription as a String
+     */
+    getTranscription(): string;
+    /**
+     * Returns the current state of the transcription process
+     */
+    getState(): string;
+    /**
+     * Resets the state to the "before" state, such that it's again possible to
+     * call the start method
+     */
+    reset(): void;
+}
+import AudioRecorder from "./audioRecorder";
+import SphinxService from "./transcriptionServices/SphinxTranscriptionService";

types/auto/modules/transcription/transcriberHolder.d.ts

@@ -0,0 +1,3 @@
+export const transcribers: any[];
+export function add(transcriber: any): void;
+export function add(transcriber: any): void;

types/auto/modules/transcription/transcriptionServices/AbstractTranscriptionService.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Abstract class representing an interface to implement a speech-to-text
+ * service on.
+ */
+export default class TranscriptionService {
+    /**
+     * This method can be used to send the recorder audio stream and
+     * retrieve the answer from the transcription service from the callback
+     *
+     * @param {RecordingResult} recordingResult a recordingResult object which
+     * includes the recorded audio stream as a blob
+     * @param {Function} callback  which will retrieve the a RecordingResult with
+     *        the answer as a WordArray
+     */
+    send(recordingResult: any, callback: Function): void;
+    /**
+     * Abstract method which will rend the recorder audio stream to the implemented
+     * transcription service and will retrieve an answer, which will be
+     * called on the given callback method
+     *
+     * @param {Blob} audioBlob the recorded audio stream as a single Blob
+     * @param {function} callback function which will retrieve the answer
+     *                            from the service
+     */
+    sendRequest(audioBlob: Blob, callback: Function): void;
+    /**
+     * Abstract method which will parse the output from the implemented
+     * transcription service to the expected format
+     *
+     * The transcriber class expect an array of word objects, where each word
+     * object is one transcribed word by the service.
+     *
+     * The expected output of this method is an array of word objects, in
+     * the correct order. That is, the first object in the array is the first word
+     * being said, and the last word in the array is the last word being said
+     *
+     * @param response the answer from the speech-to-text server which needs to be
+     *                 formatted
+     * @return {Array<Word>} an array of Word objects
+     */
+    formatResponse(response: any): Array<any>;
+    /**
+     * Abstract method which will verify that the response from the server is valid
+     *
+     * @param response the response from the server
+     * @return {boolean} true if response is valid, false otherwise
+     */
+    verify(response: any): boolean;
+}

types/auto/modules/transcription/transcriptionServices/SphinxTranscriptionService.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Implements a TranscriptionService for a Sphinx4 http server
+ */
+export default class SphinxService extends AbstractTranscriptionService {
+    url: string;
+}
+import AbstractTranscriptionService from "./AbstractTranscriptionService";

types/auto/modules/transcription/word.d.ts

@@ -0,0 +1,32 @@
+/**
+ * An object representing a transcribed word, with some additional information
+ * @param word the word
+ * @param begin the time the word was started being uttered
+ * @param end the time the word stopped being uttered
+ */
+export default class Word {
+    /**
+     * @param word the word
+     * @param begin the time the word was started being uttered
+     * @param end the time the word stopped being uttered
+     */
+    constructor(word: any, begin: any, end: any);
+    word: any;
+    begin: any;
+    end: any;
+    /**
+     * Get the string representation of the word
+     * @returns {*} the word as a string
+     */
+    getWord(): any;
+    /**
+     * Get the time the word started being uttered
+     * @returns {*} the start time as an integer
+     */
+    getBeginTime(): any;
+    /**
+     * Get the time the word stopped being uttered
+     * @returns {*} the end time as an integer
+     */
+    getEndTime(): any;
+}

types/auto/modules/util/AsyncQueue.d.ts

@@ -0,0 +1,38 @@
+/**
+ * A queue for async task execution.
+ */
+export default class AsyncQueue {
+    _queue: any;
+    _stopped: boolean;
+    /**
+     * Removes any pending tasks from the queue.
+     */
+    clear(): void;
+    /**
+     * Internal task processing implementation which makes things work.
+     */
+    _processQueueTasks(task: any, finishedCallback: any): void;
+    /**
+     * The 'task' function will be given a callback it MUST call with either:
+     *  1) No arguments if it was successful or
+     *  2) An error argument if there was an error
+     * If the task wants to process the success or failure of the task, it
+     * should pass the {@code callback} to the push function, e.g.:
+     * queue.push(task, (err) => {
+     *     if (err) {
+     *         // error handling
+     *     } else {
+     *         // success handling
+     *     }
+     * });
+     *
+     * @param {function} task - The task to be executed. See the description above.
+     * @param {function} [callback] - Optional callback to be called after the task has been executed.
+     */
+    push(task: Function, callback?: Function): void;
+    /**
+     * Shutdowns the queue. All already queued tasks will execute, but no future tasks can be added. If a task is added
+     * after the queue has been shutdown then the callback will be called with an error.
+     */
+    shutdown(): void;
+}