feat(ts) add hand-crafted type definitions

Include a type comparison utility to compare auto-generated vs hand-crafted
types.

Thanks @sapkra for working on these! ❤️

.gitignore

@@ -14,3 +14,5 @@ npm-*.log
 stats.json
 .vscode
 dist
+types/types-comparer/auto.json
+types/types-comparer/hand-crafted.json

types/hand-crafted/EventEmitter.d.ts

@@ -0,0 +1,3 @@
+export default class EventEmitter<T> { // TODO: is this defined somewhere?
+  emit: ( name: T, id: string, arguments: unknown ) => void; // TODO:
+}

types/hand-crafted/JitsiConference.d.ts

@@ -0,0 +1,151 @@
+import { JitsiConferenceEvents } from './JitsiConferenceEvents';
+import JitsiConnection from './JitsiConnection';
+import JitsiTrackError from './JitsiTrackError';
+import JitsiParticipant from './JitsiParticipant';
+import JitsiLocalTrack from './modules/RTC/JitsiLocalTrack';
+import JitsiRemoteTrack from './modules/RTC/JitsiLocalTrack';
+import JitsiTrack from './modules/RTC/JitsiTrack';
+import Transcriber from './modules/transcription/transcriber';
+import JitsiVideoSIPGWSession from './modules/videosipgw/JitsiVideoSIPGWSession';
+import TraceablePeerConnection from './modules/RTC/TraceablePeerConnection';
+import { MediaType } from './service/RTC/MediaType';
+
+export default class JitsiConference {
+  constructor( options: {
+    name: string;
+    config: {
+      avgRtpStatsN?: number,
+      enableIceRestart?: boolean,
+      p2p?: {
+        enabled: boolean,
+        backToP2PDelay?: number
+      },
+      channelLastN?: number,
+      forceJVB121Ratio?: number
+    },
+    connection: unknown
+  } ); // TODO:
+  join(password: string, replaceParticipant?: boolean): void;
+  authenticateAndUpgradeRole: ( options: unknown ) => Promise<unknown>; // TODO:
+  isJoined: () => boolean;
+  isP2PEnabled: () => boolean;
+  isP2PTestModeEnabled: () => boolean;
+  leave: () => Promise<unknown>; // TODO:
+  getName: () => string;
+  getConnection: () => JitsiConnection;
+  isAuthEnabled: () => boolean;
+  isLoggedIn: () => boolean;
+  getAuthLogin: () => unknown; // TODO:
+  isExternalAuthEnabled: () => boolean;
+  getExternalAuthUrl: ( urlForPopup: boolean ) => Promise<unknown>; // TODO: probably returns a Promise<string>
+  getLocalTracks: ( mediaType: MediaType ) => JitsiLocalTrack[];
+  getLocalAudioTrack: () => JitsiLocalTrack | null;
+  getLocalVideoTrack: () => JitsiLocalTrack | null;
+  getPerformanceStats: () => unknown | null; // TODO:
+  on: ( eventId: JitsiConferenceEvents, handler: () => unknown ) => void; // TODO:
+  off: ( eventId: JitsiConferenceEvents, handler: () => unknown ) => void; // TODO:
+  addEventListener: ( eventId: JitsiConferenceEvents, handler: () => unknown ) => void; // TODO:
+  removeEventListener: ( eventId: JitsiConferenceEvents, handler: () => unknown ) => void; // TODO:
+  addCommandListener: ( command: string, handler: () => unknown ) => void; // TODO:
+  removeCommandListener: ( command: string, handler: () => unknown ) => void; // TODO:
+  // sendTextMessage: (message: string, elementName: string) => void; // obsolete
+  // sendPrivateTextMessage: (id: string, message: string, elementName: string) => void; // obsolete
+  sendCommand: ( name: string, values: unknown ) => void; // TODO:
+  sendCommandOnce: ( name: string, values: unknown ) => void; // TODO:
+  removeCommand: ( name: string ) => void;
+  setDisplayName: ( name: string ) => void;
+  setSubject: ( name: string ) => void;
+  getTranscriber: () => Transcriber;
+  getTranscriptionStatus: () => 'on' | 'off';
+  addTrack: ( track: JitsiLocalTrack ) => Promise<JitsiLocalTrack>;
+  onLocalTrackRemoved: ( track: JitsiLocalTrack ) => void;
+  removeTrack: ( track: JitsiLocalTrack ) => void;
+  replaceTrack: ( oldTrack: JitsiLocalTrack, newTrack: JitsiLocalTrack ) => Promise<unknown | JitsiTrackError>;
+  getRole: () => string;
+  isHidden: () => boolean | null;
+  isModerator: () => boolean | null;
+  lock: ( password: string ) => Promise<unknown | Error>;
+  unlock: () => Promise<unknown | Error>;
+  selectParticipant: ( participantId: string ) => void;
+  selectParticipants: ( participantIds: string[] ) => void;
+  getLastN: () => number;
+  setLastN: ( lastN: number ) => void;
+  isInLastN: ( participantId: string ) => boolean;
+  getParticipants: () => JitsiParticipant[];
+  getParticipantCount: ( countHidden?: boolean ) => number;
+  getParticipantById: ( id: string ) => JitsiParticipant;
+  grantOwner: ( id: string ) => void;
+  revokeOwner: ( id: string ) => void;
+  kickParticipant: ( id: string, reason?: string ) => void;
+  muteParticipant: ( id: string, mediaType?: MediaType ) => void;
+  onMemberJoined: ( jid: string, nick: string, role: string, isHidden: boolean, statsID?: unknown, status?: string, identity?: unknown, botType?: unknown, fullJid?: string, features?: unknown, isReplaceParticipant?: boolean ) => void;
+  onMemberLeft: ( jid: string ) => void;
+  onMemberKicked: ( isSelfPresence: boolean, actorId: string, kickedParticipantId?: string, reason?: string, isReplaceParticipant?: boolean ) => void;
+  onLocalRoleChanged: ( role: string ) => void;
+  onUserRoleChanged: ( jid: string, role: string ) => void;
+  onDisplayNameChanged: ( jid: string, displayName: string ) => void;
+  onRemoteTrackAdded: ( track: JitsiRemoteTrack ) => void;
+  onCallAccepted: ( session: unknown, answer: JQuery ) => void; // TODO: answer is a jQuery object, unknown = JingleSessionPC which doesn't exist
+  onTransportInfo: ( session: unknown, transportInfo: JQuery ) => void; // TODO: transportInfo is a jQuery object, unknown = JingleSessionPC which doesn't exist
+  onRemoteTrackRemoved: ( removedTrack: JitsiRemoteTrack ) => void;
+  onIncomingCall: ( jingleSession: unknown, jingleOffer: unknown, now: unknown ) => void; // TODO: unknown = JingleSessionPC which doesn't exist
+  onCallEnded: ( jingleSession: unknown, reasonCondition: string, reasonText: string ) => void; // TODO: unknown = JingleSessionPC which doesn't exist
+  onSuspendDetected: ( jingleSession: unknown ) => void; // TODO: unknown = JingleSessionPC which doesn't exist
+  updateDTMFSupport: () => void;
+  isDTMFSupported: () => boolean;
+  myUserId: () => string;
+  sendTones: ( tones: unknown, duration: unknown, pause: unknown ) => void; // TODO:
+  startRecording: ( options: unknown ) => Promise<unknown>;
+  stopRecording: ( sessionID: string ) => Promise<unknown>;
+  isSIPCallingSupported: () => boolean;
+  dial: ( number: string ) => Promise<unknown>;
+  hangup: () => Promise<unknown>;
+  startTranscriber: () => Promise<unknown>;
+  stopTranscriber: () => Promise<unknown>;
+  getPhoneNumber: () => string | null;
+  getPhonePin: () => string | null;
+  getMeetingUniqueId: () => string | undefined;
+  getActivePeerConnection: () => TraceablePeerConnection | null;
+  getConnectionState: () => string | null;
+  setStartMutedPolicy: ( policy: { audio: boolean, video: boolean } ) => void;
+  getStartMutedPolicy: () => { audio: boolean, video: boolean };
+  isStartAudioMuted: () => boolean;
+  isStartVideoMuted: () => boolean;
+  getConnectionTimes: () => unknown;
+  setLocalParticipantProperty: ( name: string, value: unknown ) => void;
+  removeLocalParticipantProperty: ( name: string ) => void;
+  getLocalParticipantProperty: ( name: string ) => unknown;
+  sendFeedback: ( overallFeedback: number, detailedFeedback: unknown ) => Promise<unknown>;
+  isCallstatsEnabled: () => boolean;
+  getSsrcByTrack: ( track: JitsiTrack ) => number | undefined;
+  sendApplicationLog: ( message: string ) => void;
+  // sendEndpointMessage: (to: string, payload: unknown) => unknown; // TODO: deprecated
+  // broadcastEndpointMessage: (payload: unknown) => void; // TODO: deprecated
+  sendEndpointStatsMessage: ( payload: unknown ) => void; // TODO:
+  sendMessage: ( message: string | unknown, to?: string, sendThroughVideobridge?: boolean ) => void; // TODO: JSDoc is incorrect
+  isConnectionInterrupted: () => boolean;
+  getProperty: ( key: string ) => unknown; // TODO:
+  isP2PActive: () => boolean;
+  getP2PConnectionState: () => string | null;
+  setDesktopSharingFrameRate: (maxFps: number) => boolean;
+  startP2PSession: () => void;
+  stopP2PSession: () => void;
+  getSpeakerStats: () => unknown; // TODO:
+  setReceiverConstraints: ( videoConstraints: unknown ) => void; // TODO:
+  setReceiverVideoConstraint: ( maxFrameHeight: number ) => void;
+  setSenderVideoConstraint: ( maxFrameHeight: number ) => Promise<unknown>; // TODO:
+  isE2EEEnabled: () => boolean;
+  createVideoSIPGWSession: ( sipAddress: string, displayName: string ) => JitsiVideoSIPGWSession | Error;
+  toggleE2EE: ( enabled: boolean ) => void;
+  isLobbySupported: () => boolean;
+  isMembersOnly: () => boolean;
+  enableLobby: () => Promise<unknown>;
+  disableLobby: () => void;
+  joinLobby: ( displayName: string, email: string ) => Promise<never>;
+  lobbyDenyAccess: ( id: string ) => void;
+  lobbyApproveAccess: ( id: string ) => void;
+  isAVModerationSupported(): boolean;
+  enableAVModeration: ( mediaType: MediaType ) => void;
+  disableAVModeration: ( mediaType: MediaType ) => void;
+  avModerationApprove: ( mediaType: MediaType, id: string ) => void;
+}

types/hand-crafted/JitsiConferenceErrors.d.ts

@@ -0,0 +1,21 @@
+export enum JitsiConferenceErrors {
+  AUTHENTICATION_REQUIRED = 'conference.authenticationRequired',
+  CHAT_ERROR = 'conference.chatError',
+  CONFERENCE_DESTROYED = 'conference.destroyed',
+  CONFERENCE_MAX_USERS = 'conference.max_users',
+  CONNECTION_ERROR = 'conference.connectionError',
+  CONFERENCE_RESTARTED = 'conference.restarted',
+  NOT_ALLOWED_ERROR = 'conference.connectionError.notAllowed',
+  MEMBERS_ONLY_ERROR = 'conference.connectionError.membersOnly',
+  CONFERENCE_ACCESS_DENIED = 'conference.connectionError.accessDenied',
+  FOCUS_DISCONNECTED = 'conference.focusDisconnected',
+  FOCUS_LEFT = 'conference.focusLeft',
+  GRACEFUL_SHUTDOWN = 'conference.gracefulShutdown',
+  ICE_FAILED = 'conference.iceFailed',
+  INCOMPATIBLE_SERVER_VERSIONS = 'conference.incompatible_server_versions',
+  OFFER_ANSWER_FAILED = 'conference.offerAnswerFailed',
+  PASSWORD_NOT_SUPPORTED = 'conference.passwordNotSupported',
+  PASSWORD_REQUIRED = 'conference.passwordRequired',
+  RESERVATION_ERROR = 'conference.reservationError',
+  VIDEOBRIDGE_NOT_AVAILABLE = 'conference.videobridgeNotAvailable'
+}

types/hand-crafted/JitsiConferenceEvents.d.ts

@@ -0,0 +1,61 @@
+export enum JitsiConferenceEvents {
+  AUDIO_INPUT_STATE_CHANGE = 'conference.audio_input_state_changed',
+  AUTH_STATUS_CHANGED = 'conference.auth_status_changed',
+  BEFORE_STATISTICS_DISPOSED = 'conference.beforeStatisticsDisposed',
+  CONFERENCE_ERROR = 'conference.error',
+  CONFERENCE_FAILED = 'conference.failed',
+  CONFERENCE_JOINED = 'conference.joined',
+  CONFERENCE_LEFT = 'conference.left',
+  CONFERENCE_UNIQUE_ID_SET = 'conference.unique_id_set',
+  CONNECTION_ESTABLISHED = 'conference.connectionEstablished',
+  CONNECTION_INTERRUPTED = 'conference.connectionInterrupted',
+  CONNECTION_RESTORED = 'conference.connectionRestored',
+  DATA_CHANNEL_OPENED = 'conference.dataChannelOpened',
+  DISPLAY_NAME_CHANGED = 'conference.displayNameChanged',
+  DOMINANT_SPEAKER_CHANGED = 'conference.dominantSpeaker',
+  CONFERENCE_CREATED_TIMESTAMP = 'conference.createdTimestamp',
+  DTMF_SUPPORT_CHANGED = 'conference.dtmfSupportChanged',
+  ENDPOINT_MESSAGE_RECEIVED = 'conference.endpoint_message_received',
+  ENDPOINT_STATS_RECEIVED = 'conference.endpoint_stats_received',
+  JVB121_STATUS = 'conference.jvb121Status',
+  KICKED = 'conference.kicked',
+  PARTICIPANT_KICKED = 'conference.participant_kicked',
+  LAST_N_ENDPOINTS_CHANGED = 'conference.lastNEndpointsChanged',
+  LOCK_STATE_CHANGED = 'conference.lock_state_changed',
+  SERVER_REGION_CHANGED = 'conference.server_region_changed',
+  _MEDIA_SESSION_STARTED = 'conference.media_session.started',
+  _MEDIA_SESSION_ACTIVE_CHANGED = 'conference.media_session.active_changed',
+  MEMBERS_ONLY_CHANGED = 'conference.membersOnlyChanged',
+  MESSAGE_RECEIVED = 'conference.messageReceived',
+  NO_AUDIO_INPUT = 'conference.no_audio_input',
+  NOISY_MIC = 'conference.noisy_mic',
+  NON_PARTICIPANT_MESSAGE_RECEIVED = 'conference.non_participant_message_received',
+  PRIVATE_MESSAGE_RECEIVED = 'conference.privateMessageReceived',
+  PARTICIPANT_CONN_STATUS_CHANGED = 'conference.participant_conn_status_changed',
+  PARTCIPANT_FEATURES_CHANGED = 'conference.partcipant_features_changed',
+  PARTICIPANT_PROPERTY_CHANGED = 'conference.participant_property_changed',
+  P2P_STATUS = 'conference.p2pStatus',
+  PHONE_NUMBER_CHANGED = 'conference.phoneNumberChanged',
+  PROPERTIES_CHANGED = 'conference.propertiesChanged',
+  RECORDER_STATE_CHANGED = 'conference.recorderStateChanged',
+  VIDEO_SIP_GW_AVAILABILITY_CHANGED = 'conference.videoSIPGWAvailabilityChanged',
+  VIDEO_SIP_GW_SESSION_STATE_CHANGED = 'conference.videoSIPGWSessionStateChanged',
+  START_MUTED_POLICY_CHANGED = 'conference.start_muted_policy_changed',
+  STARTED_MUTED = 'conference.started_muted',
+  SUBJECT_CHANGED = 'conference.subjectChanged',
+  SUSPEND_DETECTED = 'conference.suspendDetected',
+  TALK_WHILE_MUTED = 'conference.talk_while_muted',
+  TRACK_ADDED = 'conference.trackAdded',
+  TRACK_AUDIO_LEVEL_CHANGED = 'conference.audioLevelsChanged',
+  TRACK_MUTE_CHANGED = 'conference.trackMuteChanged',
+  TRACK_REMOVED = 'conference.trackRemoved',
+  TRANSCRIPTION_STATUS_CHANGED = 'conference.transcriptionStatusChanged',
+  USER_JOINED = 'conference.userJoined',
+  USER_LEFT = 'conference.userLeft',
+  USER_ROLE_CHANGED = 'conference.roleChanged',
+  USER_STATUS_CHANGED = 'conference.statusChanged',
+  BOT_TYPE_CHANGED = 'conference.bot_type_changed',
+  LOBBY_USER_JOINED = 'conference.lobby.userJoined',
+  LOBBY_USER_UPDATED = 'conference.lobby.userUpdated',
+  LOBBY_USER_LEFT = 'conference.lobby.userLeft'
+}

types/hand-crafted/JitsiConnection.d.ts

@@ -0,0 +1,22 @@
+import JitsiConference from './JitsiConference';
+import { JitsiConnectionEvents } from './JitsiConnectionEvents';
+
+export type JitsiConferenceOptions = {
+  // TODO:
+}
+
+export default class JitsiConnection {
+  constructor( appID?: string, token?: unknown, options?: JitsiConferenceOptions );
+  connect: ( options: unknown ) => void; // TODO:
+  attach: ( options: unknown ) => void; // TODO:
+  disconnect: ( ...args: unknown[] ) => Promise<unknown>; // TODO:
+  getJid: () => string;
+  setToken: ( token: unknown ) => void;
+  initJitsiConference: ( name: string, options: JitsiConferenceOptions ) => JitsiConference;
+  addEventListener: ( event: JitsiConnectionEvents, listener: unknown ) => void; // TODO:
+  removeEventListener: ( event: JitsiConnectionEvents, listener: unknown ) => void; // TODO:
+  getConnectionTimes: () => number; // TODO: check
+  addFeature: ( feature: string, submit?: boolean ) => void;
+  removeFeature: ( feature: string, submit?: boolean ) => void;
+  getLogs: () => unknown | { metadata: { time: Date, url: string, ua: string, xmpp?: unknown } }; // TODO:
+}

types/hand-crafted/JitsiConnectionErrors.d.ts

@@ -0,0 +1,6 @@
+export enum JitsiConnectionErrors {
+  CONNECTION_DROPPED_ERROR = 'connection.droppedError',
+  OTHER_ERROR = 'connection.otherError',
+  PASSWORD_REQUIRED = 'connection.passwordRequired',
+  SERVER_ERROR = 'connection.serverError'
+}

types/hand-crafted/JitsiConnectionEvents.d.ts

@@ -0,0 +1,7 @@
+export enum JitsiConnectionEvents {
+  CONNECTION_DISCONNECTED = 'connection.connectionDisconnected',
+  CONNECTION_ESTABLISHED = 'connection.connectionEstablished',
+  CONNECTION_FAILED = 'connection.connectionFailed',
+  WRONG_STATE = 'connection.wrongState',
+  DISPLAY_NAME_REQUIRED = 'connection.display_name_required'
+}

types/hand-crafted/JitsiLogLevels.d.ts

@@ -0,0 +1,8 @@
+export enum JitsiLogLevels {
+  TRACE = 'trace',
+  DEBUG = 'debug',
+  INFO = 'info',
+  LOG = 'log',
+  WARN = 'warn',
+  ERROR = 'error'
+}

types/hand-crafted/JitsiMediaDevices.d.ts

@@ -0,0 +1,17 @@
+import { MediaType } from './service/RTC/MediaType';
+
+declare class JitsiMediaDevices {
+  enumerateDevices: ( callback: ( devices: MediaDeviceInfo[] ) => void ) => void;
+  isDeviceListAvailable: () => Promise<boolean>;
+  isDeviceChangeAvailable: ( deviceType: string ) => boolean;
+  isDevicePermissionGranted: ( type: MediaType ) => Promise<boolean>;
+  isMultipleAudioInputSupported: () => boolean;
+  getAudioOutputDevice: () => string;
+  setAudioOutputDevice: ( deviceId: string ) => Promise<unknown>; // TODO:
+  addEventListener: ( event: string, handler: unknown ) => void; // TODO: identify the enum for the event types and the strongly typed handlers
+  removeEventListener: ( event: string, handler: unknown ) => void; // TODO: identify the enum for the event types and the strongly typed handlers
+  emitEvent: ( event: string, ...args: unknown[] ) => void; // TODO: identify the enum for the event types
+}
+
+declare var _default: JitsiMediaDevices;
+export default _default;

types/hand-crafted/JitsiMediaDevicesEvents.d.ts

@@ -0,0 +1,6 @@
+export enum JitsiMediaDevicesEvents {
+  DEVICE_LIST_CHANGED = 'mediaDevices.devicechange',
+  PERMISSIONS_CHANGED = 'rtc.permissions_changed',
+  PERMISSION_PROMPT_IS_SHOWN = 'mediaDevices.permissionPromptIsShown',
+  SLOW_GET_USER_MEDIA = 'mediaDevices.slowGetUserMedia'
+}

types/hand-crafted/JitsiMeetJS.d.ts

@@ -0,0 +1,154 @@
+import Logger from 'jitsi-meet-logger';
+import JitsiConnection from './JitsiConnection';
+import JitsiMediaDevices from './JitsiMediaDevices';
+import { JitsiConferenceErrors } from './JitsiConferenceErrors';
+import { JitsiConnectionErrors } from './JitsiConnectionErrors';
+import { JitsiTrackErrors } from './JitsiTrackErrors';
+import { JitsiLogLevels } from './JitsiLogLevels';
+import { JitsiMediaDevicesEvents } from './JitsiMediaDevicesEvents';
+import { JitsiTrackEvents } from './JitsiTrackEvents';
+import { JitsiConnectionEvents } from './JitsiConnectionEvents';
+import { JitsiConferenceEvents } from './JitsiConferenceEvents';
+import { JitsiTranscriptionStatus } from './JitsiTranscriptionStatus';
+import BrowserCapabilities from './modules/browser/BrowserCapabilities';
+import { ParticipantConnectionStatus } from './modules/connectivity/ParticipantConnectionStatus';
+import { DetectionEvents } from './modules/detection/DetectionEvents';
+import TrackVADEmitter, { VADProcessor } from './modules/detection/TrackVADEmitter';
+import RecordingConstants from './modules/recording/recordingConstants';
+import JitsiLocalTrack from './modules/RTC/JitsiLocalTrack';
+import PrecallTest from './modules/statistics/PrecallTest';
+import AuthUtil from './modules/util/AuthUtil';
+import ScriptUtil from './modules/util/ScriptUtil';
+import { VideoSIPGWConstants } from './modules/videosipgw/VideoSIPGWConstants';
+import AudioMixer from './modules/webaudio/AudioMixer';
+import { ConnectionQualityEvents } from './service/connectivity/ConnectionQualityEvents';
+import { E2ePingEvents } from './service/e2eping/E2ePingEvents';
+
+export type CreateLocalTracksOptions = {
+  effects?: Array<unknown>; // TODO: work out what unknown is
+  devices?: Array<string>;
+  resolution?: string;
+  cameraDeviceId?: string;
+  micDeviceId?: string;
+  interval?: number;
+  checkAgain?: () => boolean;
+  listener?: () => void;
+  frameRate?: {
+    min?: string,
+    max?: string,
+  },
+  desktopSharingFrameRate?: {
+    min?: string,
+    max?: string,
+  },
+  constraints?: any // TODO: figure out this type
+}
+
+export type InitOptions = {
+  disableAudioLevels?: boolean,
+  useIPv6?: unknown,
+  disableSimulcast?: unknown,
+  enableWindowOnErrorHandler?: unknown,
+  disableThirdPartyRequests?: unknown,
+  enableAnalyticsLogging?: unknown,
+  externalStorage?: unknown,
+  callStatsCustomScriptUrl?: unknown,
+  disableRtx?: unknown,
+  disabledCodec?: unknown,
+  preferredCodec?: unknown,
+  useTurnUdp?: unknown
+}
+
+export type JitsiMeetJSType = {
+  version: string;
+
+  JitsiConnection: typeof JitsiConnection;
+
+  ProxyConnectionService: unknown; // TODO:
+
+  //USER_MEDIA_SLOW_PROMISE_TIMEOUT: 1000;
+
+  constants: {
+    participantConnectionStatus: typeof ParticipantConnectionStatus,
+    recording: typeof RecordingConstants,
+    sipVideoGW: typeof VideoSIPGWConstants,
+    transcriptionStatus: typeof JitsiTranscriptionStatus,
+  };
+
+  events: {
+    conference: typeof JitsiConferenceEvents,
+    connection: typeof JitsiConnectionEvents,
+    detection: typeof DetectionEvents,
+    track: typeof JitsiTrackEvents,
+    mediaDevices: typeof JitsiMediaDevicesEvents,
+    connectionQuality: typeof ConnectionQualityEvents,
+    e2eping: typeof E2ePingEvents
+  };
+
+  errors: {
+    conference: typeof JitsiConferenceErrors,
+    connection: typeof JitsiConnectionErrors,
+    track: typeof JitsiTrackErrors
+  };
+
+  errorTypes: {
+    JitsiTrackError: unknown // TODO:
+  };
+
+  logLevels: typeof JitsiLogLevels; // TODO: code refers to Logger.levels and that is in jitsi-meet-logger
+
+  mediaDevices: typeof JitsiMediaDevices;
+
+  analytics: unknown; // TODO: code referes to Statistics.analytics which comes from modules/statstics/AnalyticsAdapter.js
+
+  init: ( options: InitOptions ) => unknown; // TODO:
+
+  isDesktopSharingEnabled: () => boolean;
+
+  isWebRtcSupported: () => boolean;
+
+  setLogLevel: ( level: Logger.levels ) => void;
+
+  setLogLevelById: ( level: Logger.levels, id: unknown ) => void; // TODO:
+
+  addGlobalLogTransport: ( globalTransport: unknown ) => void; // TODO:
+
+  removeGlobalLogTransport: ( globalTransport: unknown ) => void; // TODO:
+
+  setGlobalLogOptions: ( options: unknown ) => void; // TODO:
+
+  createLocalTracks: ( options: CreateLocalTracksOptions, firePermissionPromptIsShownEvent?: boolean, originalOptions?: CreateLocalTracksOptions ) => Promise<Array<JitsiLocalTrack> | JitsiConferenceErrors>; // TODO:
+
+  createTrackVADEmitter: ( localAudioDeviceId: string, sampleRate: 256 | 512 | 1024 | 4096 | 8192 | 16384, vadProcessor: VADProcessor ) => Promise<TrackVADEmitter>;
+
+  createAudioMixer: () => AudioMixer;
+
+  getActiveAudioDevice: () => Promise<Object>; // TODO: can we improve on object?
+
+  // isDeviceListAvailable: () => boolean; // obsosete
+
+  // isDeviceChangeAvailable: ( deviceType: string ) => boolean; // obsosete
+
+  isMultipleAudioInputSupported: () => boolean;
+
+  isCollectingLocalStats: () => boolean;
+
+  enumerateDevices: ( callback: ( availableDevices: MediaDeviceInfo[] ) => void ) => void;
+
+  getGlobalOnErrorHandler: ( message: string, source: string, lineno?: number, colno?: number, error?: Error ) => void;
+
+  setNetworkInfo: ( { isOnline: boolean } ) => void;
+
+  setVideoTrackContentHints: ( track: MediaStreamTrack, hint: string ) => void;
+
+  precallTest: PrecallTest;
+
+  util: {
+    AuthUtil: { getTokenAuthUrl: typeof AuthUtil.getTokenAuthUrl },
+    ScriptUtil: { loadScript: typeof ScriptUtil.loadScript },
+    browser: BrowserCapabilities
+  }
+}
+
+declare var _default: JitsiMeetJSType;
+export default _default;

types/hand-crafted/JitsiParticipant.d.ts

@@ -0,0 +1,35 @@
+import JitsiConference from './JitsiConference';
+import JitsiTrack from './modules/RTC/JitsiTrack';
+import { MediaType } from './service/RTC/MediaType';
+
+export default class JitsiParticipant {
+  constructor( jid: unknown, conference: unknown, displayName: unknown, hidden: boolean, statsID: string, status: string, identity: unknown, isReplacing?: boolean, isReplaced?: boolean ); // TODO:
+  getConference: () => JitsiConference;
+  getProperty: ( name: string ) => string;
+  hasAnyVideoTrackWebRTCMuted: () => boolean;
+  getConnectionStatus: () => string;
+  setProperty: ( name: string, value: string ) => void;
+  getTracks: () => JitsiTrack[];
+  getTracksByMediaType: ( mediaType: MediaType ) => JitsiTrack[];
+  getId: () => string;
+  getJid: () => string;
+  getDisplayName: () => string;
+  getStatsID: () => string;
+  getStatus: () => string;
+  isModerator: () => boolean;
+  isHidden: () => boolean;
+  isReplacing: () => boolean;
+  isReplaced: () => boolean;
+  isAudioMuted: () => boolean;
+  isVideoMuted: () => boolean;
+  getRole: () => string;
+  setRole: ( role: string ) => void;
+  setIsReplacing: (newIsReplacing: string) => void;
+  setIsReplaced: (newIsReplaced: boolean) => void;
+  supportsDTMF: () => boolean;
+  hasFeature: ( feature: string ) => boolean;
+  getFeatures: () => Promise<Set<string> | Error>;
+  setFeatures: ( newFeatures: Set<string> | undefined ) => void;
+  getBotType: () => string | undefined;
+  setBotType: ( newBotType: string ) => void;
+}

types/hand-crafted/JitsiTrackError.d.ts

@@ -0,0 +1,9 @@
+export default function JitsiTrackError( error: unknown | string, options: unknown | string, devices: ( 'audio' | 'video' | 'desktop' | 'screen' | 'audiooutput' )[] ): void; // TODO:
+
+export default class JitsiTrackError {
+  constructor( error: unknown | string, options: unknown | string, devices: ( 'audio' | 'video' | 'desktop' | 'screen' | 'audiooutput' )[] ); // TODO:
+  gum?: { error: Error, constraints: unknown, devices: ( 'audio' | 'video' | 'desktop' | 'screen' | 'audiooutput' )[] }; // TODO:
+  name?: string;
+  message?: string;
+  stack: unknown[]; // TODO:
+}

types/hand-crafted/JitsiTrackErrors.d.ts

@@ -0,0 +1,14 @@
+export enum JitsiTrackErrors {
+  CONSTRAINT_FAILED = 'gum.constraint_failed',
+  ELECTRON_DESKTOP_PICKER_ERROR = 'gum.electron_desktop_picker_error',
+  ELECTRON_DESKTOP_PICKER_NOT_FOUND = 'gum.electron_desktop_picker_not_found',
+  GENERAL = 'gum.general',
+  NOT_FOUND = 'gum.not_found',
+  PERMISSION_DENIED = 'gum.permission_denied',
+  SCREENSHARING_GENERIC_ERROR = 'gum.screensharing_generic_error',
+  SCREENSHARING_USER_CANCELED = 'gum.screensharing_user_canceled',
+  TIMEOUT = 'gum.timeout',
+  TRACK_IS_DISPOSED = 'trac =track_is_disposed',
+  TRACK_NO_STREAM_FOUND = 'track.no_stream_found',
+  UNSUPPORTED_RESOLUTION = 'gum.unsupported_resolution'
+}

types/hand-crafted/JitsiTrackEvents.d.ts

@@ -0,0 +1,9 @@
+export enum JitsiTrackEvents {
+  LOCAL_TRACK_STOPPED = 'track.stopped',
+  TRACK_AUDIO_LEVEL_CHANGED = 'track.audioLevelsChanged',
+  TRACK_AUDIO_OUTPUT_CHANGED = 'track.audioOutputChanged',
+  TRACK_MUTE_CHANGED = 'track.trackMuteChanged',
+  TRACK_VIDEOTYPE_CHANGED = 'track.videoTypeChanged',
+  NO_DATA_FROM_SOURCE = 'track.no_data_from_source',
+  NO_AUDIO_INPUT = 'track.no_audio_input'
+}

types/hand-crafted/JitsiTranscriptionStatus.d.ts

@@ -0,0 +1,4 @@
+export enum JitsiTranscriptionStatus {
+  ON = 'on',
+  OFF = 'off'
+}

types/hand-crafted/authenticateAndUpgradeRole.d.ts

@@ -0,0 +1,13 @@
+import JitsiConnectionErrors from '../../JitsiConnectionErrors';
+
+export default function authenticateAndUpgradeRole( options: { id: string, password: string, roomPassword?: string, onLoginSuccessful?: ( params: unknown ) => unknown } ): unknown;
+
+export type UpgradeRoleError = {
+  connectionError?: JitsiConnectionErrors,
+  authenticationError?: string;
+  message?: string;
+  credentials?: {
+    jid: string,
+    password: string
+  }
+}

types/hand-crafted/modules/RTC/BridgeChannel.d.ts

@@ -0,0 +1,13 @@
+export default class BridgeChannel {
+  constructor( peerconnection: unknown, wsUrl: unknown, emitter: unknown ); // TODO:
+  mode: () => null | "datachannel" | "websocket";
+  close: () => void;
+  isOpen: () => boolean;
+  sendMessage: ( to: string, payload: unknown ) => void; // TODO:
+  sendSetLastNMessage: ( value: number ) => void;
+  sendSelectedEndpointsMessage: ( endpointIds: string[] ) => void;
+  sendReceiverVideoConstraintMessage: ( maxFrameHeightPixels: number ) => void;
+  sendEndpointStatsMessage: ( payload: unknown ) => void; // TODO:
+  sendNewReceiverVideoConstraintsMessage: ( constraints: ReceiverVideoConstraints ) => void; // TODO:
+  sendVideoTypeMessage: ( videoType: string ) => void;
+}

types/hand-crafted/modules/RTC/CodecSelection.d.ts

@@ -0,0 +1,7 @@
+import JitsiConference from '../../JitsiConference';
+import { CodecMimeType } from '../../service/RTC/CodecMimeType';
+
+export class CodecSelection {
+  constructor( conference: JitsiConference, options: { disabledCodec: string, enforcePreferredCodec: boolean, jvbCodec: string, p2pCodec: string } );  // TODO:
+  getPreferredCodec: () => CodecMimeType;
+}

types/hand-crafted/modules/RTC/JitsiLocalTrack.d.ts

@@ -0,0 +1,19 @@
+import JitsiTrack from './JitsiTrack';
+import { CameraFacingMode } from '../../service/RTC/CameraFacingMode';
+
+export default class JitsiLocalTrack extends JitsiTrack {
+  constructor( trackInfo: { rtcId: number, stream: unknown, track: unknown, mediaType: unknown, videoType: unknown, effects: unknown, resolution: unknown, deviceId: string, facingMode: CameraFacingMode, sourceId: unknown } ) // TODO:
+  isEnded: () => boolean;
+  setEffect: ( effect: unknown ) => Promise<unknown>; // TODO:
+  mute: () => Promise<void>;
+  unmute: () => Promise<void>;
+  dispose: () => Promise<void>;
+  isMuted: () => boolean;
+  isLocal: () => true;
+  getDeviceId: () => string;
+  getParticipantId: () => string;
+  getCameraFacingMode: () => CameraFacingMode | undefined;
+  stopStream: () => void;
+  isReceivingData: () => boolean;
+  toString: () => string;
+}

types/hand-crafted/modules/RTC/JitsiRemoteTrack.d.ts

@@ -0,0 +1,17 @@
+import JitsiTrack from './JitsiTrack';
+import RTC from './RTC';
+import JitsiConference from '../../JitsiConference';
+
+export default class JitsiRemoteTrack extends JitsiTrack {
+  constructor(rtc: RTC, conference: JitsiConference, ownerEndpointId: string, stream: MediaStream, track: MediaStreamTrack, mediaType: any, videoType: any, ssrc: number, muted: boolean, isP2P: boolean);
+  setMute: ( value: boolean ) => void;
+  isMuted: () => boolean;
+  getParticipantId: () => string;
+  isLocal: () => false;
+  getSSRC: () => number;
+  toString: () => string;
+
+  containerEvents: [ 'abort', 'canplay', 'canplaythrough', 'emptied', 'ended', 'error', 'loadeddata',
+    'loadedmetadata', 'loadstart', 'pause', 'play', 'playing', 'ratechange', 'stalled', 'suspend',
+    'waiting' ]; // TODO: this might be private
+}

types/hand-crafted/modules/RTC/JitsiTrack.d.ts

@@ -0,0 +1,32 @@
+import JitsiConference from '../../JitsiConference';
+import { MediaType } from '../../service/RTC/MediaType';
+import { VideoType } from '../../service/RTC/VideoType';
+import TraceablePeerConnection from './TraceablePeerConnection';
+
+export default class JitsiTrack {
+  constructor( conference: JitsiConference, stream: unknown, track: unknown, streamInactiveHandler: unknown, trackMediaType: unknown, videoType: unknown ); // TODO:
+  disposed: boolean;
+  getVideoType: () => VideoType;
+  getType: () => MediaType;
+  isAudioTrack: () => boolean;
+  isWebRTCTrackMuted: () => boolean;
+  isVideoTrack: () => boolean;
+  isLocal: () => boolean;
+  isLocalAudioTrack: () => boolean;
+  getOriginalStream: () => MediaStream;
+  getStreamId: () => string | null;
+  getTrack: () => MediaStreamTrack;
+  getTrackLabel: () => string;
+  getTrackId: () => string | null;
+  getUsageLabel: () => string;
+  attach: ( container: HTMLElement ) => void;
+  detach: ( container: HTMLElement ) => void;
+  dispose: () => void;
+  isScreenSharing: () => boolean;
+  getId: () => string | null;
+  isActive: () => boolean;
+  setAudioLevel: ( audioLevel: number, tpc: TraceablePeerConnection ) => void;
+  getMSID: () => string | null;
+  setAudioOutput: ( audioOutputDeviceId: '' | string ) => Promise<unknown>; // TODO: what will this promise contain?
+  addEventListener: (type: string, listener: (event: any) => void) => void;
+}

types/hand-crafted/modules/RTC/RTC.d.ts

@@ -0,0 +1,54 @@
+import Listenable from '../util/Listenable';
+import JitsiLocalTrack from './JitsiLocalTrack';
+import JitsiRemoteTrack from './JitsiRemoteTrack';
+import TraceablePeerConnection from './TraceablePeerConnection';
+import { MediaType } from '../../service/RTC/MediaType';
+import SignalingLayer from '../../service/RTC/SignalingLayer';
+
+export default class RTC extends Listenable {
+  destroy: () => void;
+  static createLocalTracks: ( tracksInfo: unknown[] ) => JitsiLocalTrack[]; // TODO:
+  static obtainAudioAndVideoPermissions: ( options: { devices: unknown[], resolution: string, cameraDeviceId: string, micDeviceId: string } ) => Promise<unknown>; // TODO:
+  initializeBridgeChannel: ( perrconnection: RTCPeerConnection, wsUrl: string ) => void;
+  onCallEnded: () => void;
+  setDesktopSharingFrameRate: (maxFps: number) => void;
+  setReceiverVideoConstraint: ( maxFrameHeight: number ) => void;
+  selectEndpoints: ( ids: string[] ) => void;
+  static addListener: ( eventType: string, listener: unknown ) => void; // TODO: this should be typed to an enum of eventTypes with appropriate definition for the listeners
+  static removeListener: ( eventType: string, listener: unknown ) => void; // TODO: this should be typed to an enum of eventTypes with appropriate definition for the listeners
+  static init: ( options: unknown ) => unknown; // TODO:
+  createPeerConnection: ( signalling: SignalingLayer, iceConfig: unknown, isP2P: boolean, options: { enableInsertableStreams: boolean, disableSimulcast: boolean, disableRtx: boolean, startSilent: boolean } ) => TraceablePeerConnection; // TODO:
+  addLocalTrack: ( track: unknown ) => void; // TODO:
+  getLocalVideoTrack: () => JitsiLocalTrack | undefined;
+  getLocalAudioTrack: () => JitsiLocalTrack | undefined;
+  getLocalEndpointId: () => string;
+  getLocalTracks: ( mediaType: MediaType ) => JitsiLocalTrack[];
+  getRemoteTracks: ( mediaType: MediaType ) => JitsiRemoteTrack[];
+  setAudioMute: ( value: unknown ) => Promise<unknown>; // TODO:
+  removeLocalTrack: ( track: unknown ) => void; // TODO:
+  static attachMediaStream: ( elSelector: unknown, stream: unknown ) => unknown; // TODO:
+  static getStreamID: ( stream: MediaStream ) => unknown; // TODO:
+  static getTrackID: ( track: MediaStreamTrack ) => unknown; // TODO:
+  static isDeviceListAvailable: () => unknown; // TODO:
+  static isDeviceChangeAvailable: ( deviceType: string ) => boolean; // TODO: check if deviceType should be an enum
+  static isWebRtcSupported: () => boolean;
+  static getAudioOutputDevice: () => string;
+  static getCurrentlyAvailableMediaDevices: () => unknown[]; // TODO:
+  static getEventDataForActiveDevice: () => MediaDeviceInfo;
+  static setAudioOutputDevice: ( deviceId: string ) => Promise<unknown>; // TODO:
+  static isUserStream: ( stream: MediaStream ) => boolean;
+  static isUserStreamById: ( streamId: string ) => boolean;
+  static enumerateDevices: ( callback: () => unknown ) => void; // TODO:
+  static stopMediaStream: ( mediaStream: MediaStream ) => void;
+  static isDesktopSharingEnabled: () => boolean;
+  closeBridgeChannel: () => void;
+  setAudioLevel: ( tpc: TraceablePeerConnection, ssrc: number, audioLevel: number, isLocal: boolean ) => void;
+  sendChannelMessage: ( to: string, payload: unknown ) => void; // TODO:
+  setLastN: ( value: number ) => void;
+  isInLastN: ( id: string ) => boolean;
+  setNewReceiverVideoConstraints: ( constraints: unknown ) => void; // TODO:
+  setVideoType: ( videoType: string ) => void;
+  setVideoMute: ( value: unknown ) => Promise<unknown>; // TODO:
+  arePermissionsGrantedForAvailableDevices: () => boolean;
+  sendEndpointStatsMessage: ( payload: unknown ) => void; // TODO:
+}

types/hand-crafted/modules/RTC/RTCUtils.d.ts

@@ -0,0 +1,22 @@
+import Listenable from '../util/Listenable';
+import { MediaType } from '../../service/RTC/MediaType';
+
+declare class RTCUtils extends Listenable {
+  init: ( options: unknown ) => void; // TODO:
+  getUserMediaWithConstraints: ( um: MediaType[], options: { resolution: string, bandwidth: number, fps: number, desktopStream: string, cameraDeviceId: string, micDeviceId: string, frameRate: { min: unknown, max: unknown }, screenShareAudio: boolean, timeout: number } ) => Promise<unknown>; // TODO:
+  obtainAudioAndVideoPermissions: ( options: { devices: unknown[], resolution: string, cameraDeviceId: string, micDeviceId: string, desktopSharingFrameRate: { min: unknown, max: unknown } } ) => Promise<unknown>; // TODO:
+  isDeviceListAvailable: () => boolean;
+  isDeviceChangeAvailable: ( deviceType: string ) => boolean;
+  stopMediaStream: ( mediaStream: MediaStream ) => void;
+  isDesktopSharingEnabled: () => boolean;
+  setAudioOutputDevice: ( deviceId: string ) => Promise<unknown>; // TODO:
+  setDesktopSharingFrameRate: (maxFps: number) => void;
+  getAudioOutputDevice: () => string;
+  getCurrentlyAvailableMediaDevices: () => unknown[]; // TODO:
+  getEventDataForActiveDevice: ( device: MediaDeviceInfo ) => unknown; // TODO:
+  setSuspendVideo: ( constraints: unknown, enable: boolean ) => void; // TODO:
+  arePermissionsGrantedForAvailableDevices: () => boolean;
+}
+
+declare const rtcUtils: RTCUtils;
+export default rtcUtils;

types/hand-crafted/modules/RTC/ScreenObtainer.d.ts

@@ -0,0 +1,13 @@
+import JitsiTrackError from '../../JitsiTrackError';
+
+declare namespace ScreenObtainer {
+  const obtainStream: unknown, // TODO:
+  init: ( options: unknown ) => void, // TODO:
+  isSupported: () => boolean,
+  obtainScreenOnElectron: ( onSuccess: () => unknown, onFailure: ( err: JitsiTrackError ) => unknown ) => void, // TODO:
+  obtainScreenFromGetDisplayMedia: ( callback: () => unknown, errorCallback: () => unknown ) => void, // TODO:
+  obtainScreenFromGetDisplayMediaRN: ( callback: () => unknown, errorCallback: ( err: JitsiTrackError ) => unknown ) => void, // TODO:
+  setDesktopSharingFrameRate: (maxFps: number) => void
+}
+
+export default ScreenObtainer;

types/hand-crafted/modules/RTC/TPCUtils.d.ts

@@ -0,0 +1,20 @@
+import JitsiLocalTrack from './JitsiLocalTrack';
+import { MediaType } from '../../service/RTC/MediaType';
+
+export const SIM_LAYER_RIDS: string[];
+
+export default class TPCUtils {
+  constructor(peerconnection: unknown, videoBitrates: unknown); // TODO:
+  ensureCorrectOrderOfSsrcs: ( description: unknown ) => RTCSessionDescription; // TODO:
+  insertUnifiedPlanSimulcastReceive: ( desc: { type: string, sdp: string } ) => RTCSessionDescription;
+  addTrack: ( localTrack: JitsiLocalTrack, isInitiator: boolean ) => void;
+  addTrackUnmute: ( localTrack: JitsiLocalTrack ) => Promise<void>;
+  getLocalStreamHeightConstraints: ( localTrack: JitsiLocalTrack ) => number[];
+  removeTrackMute: ( localTrack: JitsiLocalTrack ) => Promise<void>;
+  replaceTrack: ( oldTrack: JitsiLocalTrack, newTrack: JitsiLocalTrack ) => Promise<void>;
+  setAudioTransferActive: ( active: boolean ) => void;
+  setEncodings: ( track: JitsiLocalTrack ) => Promise<void>;
+  setMediaTransferActive: ( mediaType: MediaType, active: boolean ) => void;
+  setVideoTransferActive: ( active: boolean ) => void;
+  updateEncodingsResolution: ( parameters: RTCRtpEncodingParameters ) => void;
+}

types/hand-crafted/modules/RTC/TraceablePeerConnection.d.ts

@@ -0,0 +1,124 @@
+import RTC from './RTC';
+import JitsiTrack from './JitsiTrack';
+import JitsiRemoteTrack from './JitsiRemoteTrack';
+import JitsiLocalTrack from './JitsiLocalTrack';
+import LocalSdpMunger from '../sdp/LocalSdpMunger';
+import SdpConsistency from '../sdp/SdpConsistency';
+import RtxModifier from '../sdp/RtxModifier';
+import SignalingLayer from '../../service/RTC/SignalingLayer';
+import { MediaType } from '../../service/RTC/MediaType';
+import { CodecMimeType } from '../../service/RTC/CodecMimeType';
+import TPCUtils from './TPCUtils';
+
+export default function TraceablePeerConnection( rtc: RTC, id: number, signalingLayer: unknown, iceConfig: unknown, constraints: unknown, isP2P: boolean, options: {
+  disableSimulcast: boolean;
+  disableRtx: boolean;
+  disabledCodec: string;
+  preferredCodec: string;
+  startSilent: boolean;
+  usesUnifiedPlan: boolean;
+} ): void; // TODO:
+
+export default class TraceablePeerConnection {
+  audioTransferActive: boolean;
+  videoTransferActive: boolean;
+  id: number;
+  isP2P: boolean;
+  remoteTracks: Map<number, Map<MediaType, JitsiRemoteTrack>>; // TODO:
+  localTracks: Map<number, JitsiLocalTrack>; // TODO:
+  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>;
+    }[];
+  }>;
+  localUfrag: unknown; // TODO:
+  signalingLayer: SignalingLayer; // TODO:
+  options: unknown; // TODO:
+  peerconnection: RTCPeerConnection; // TODO: JSDocs refers to RTCPeerConnectionType = RTCPeerConnection
+  videoBitrates: unknown; // TODO:
+  tpcUtils: TPCUtils;
+  updateLog: Array<unknown>; // TODO:
+  stats: unknown; // TODO:
+  statsinterval: number;
+  maxstats: unknown; // TODO:
+  interop: unknown; // TODO: unknown = Interop refers to @jitsi/sdp-interop
+  simulcast: unknown; // TODO: unknown = Simulcast refers to @jitsi/sdp-simulcast
+  sdpConsistency: SdpConsistency; // TODO:
+  localSdpMunger: LocalSdpMunger; // TODO:
+  eventEmitter: unknown; // TODO:
+  rtxModifier: RtxModifier; // TODO:
+  senderVideoMaxHeight: unknown;
+  trace: ( what: unknown, info: unknown ) => void; // TODO:
+  onicecandidate: unknown; // TODO:
+  onsignalingstatechange: unknown; // TODO:
+  oniceconnectionstatechange: unknown; // TODO:
+  onnegotiationneeded: unknown; // TODO:
+  ondatachannel: unknown; // TODO:
+  getConnectionState: () => string;
+  isSimulcastOn: () => boolean;
+  getAudioLevels: ( speakerList?: Array<unknown> ) => Map<string, number>; // TODO:
+  getLocalTracks: ( mediaType: MediaType ) => JitsiLocalTrack[];
+  getLocalVideoTrack: () => JitsiLocalTrack | undefined;
+  hasAnyTracksOfType: ( mediaType: MediaType ) => boolean;
+  getRemoteTracks: ( endpointId: string, mediaType: MediaType ) => JitsiRemoteTrack[];
+  getRemoteSourceInfoByParticipant: ( id: string ) => string[]; // TODO:
+  getTargetVideoBitrates: () => unknown; // TODO:
+  getTrackBySSRC: ( ssrc: number ) => JitsiTrack | null;
+  getSsrcByTrackId: ( id: string ) => number | null;
+  removeRemoteTracks: ( owner: string ) => JitsiRemoteTrack[];
+  getLocalSSRC: ( localTrack: JitsiLocalTrack ) => string;
+  signalingState: unknown; // TODO:
+  iceConnectionState: unknown; // TODO:
+  localDescription: unknown; // TODO:
+  remoteDescription: unknown; // TODO:
+  containsTrack: ( track: JitsiLocalTrack | JitsiRemoteTrack ) => boolean;
+  addTrack: ( track: JitsiLocalTrack, isInitiator?: boolean ) => Promise<void>;
+  addTrackUnmute: ( track: JitsiLocalTrack ) => Promise<boolean>;
+  getConfiguredVideoCodec: () => CodecMimeType;
+  setDesktopSharingFrameRate: (maxFps: number) => void;
+  setVideoCodecs: ( preferredCodec?: CodecMimeType, disabledCodec?: CodecMimeType ) => void;
+  isMediaStreamInPc: ( mediaStream: MediaStream ) => boolean;
+  removeTrack: ( localTrack: JitsiLocalTrack ) => void;
+  findSenderByKind: ( mediaType: MediaType ) => RTCRtpSender | undefined; // TODO: possible bug in the JSDocs
+  findReceiverForTrack: ( track: MediaStreamTrack ) => RTCRtpReceiver | undefined;
+  findSenderForTrack: ( track: MediaStreamTrack ) => RTCRtpSender | undefined;
+  replaceTrack: ( oldTrack: JitsiLocalTrack | null, newTrack: JitsiLocalTrack | null ) => Promise<boolean>;
+  removeTrackMute: ( localTrack: JitsiLocalTrack ) => Promise<boolean>;
+  createDataChannel: ( label: unknown, opts: unknown ) => unknown; // TODO:
+  setLocalDescription: ( description: unknown ) => Promise<unknown>;
+  setAudioTransferActive: ( active: boolean ) => boolean;
+  setSenderVideoDegradationPreference: () => Promise<void>;
+  setMaxBitRate: () => Promise<void>; // TODO: definite bug in the JSDocs
+  setRemoteDescription: ( description: unknown ) => unknown; // TODO:
+  setSenderVideoConstraint: ( frameHeight: number ) => Promise<void>;
+  setVideoTransferActive: ( active: boolean ) => boolean;
+  sendTones: ( tones: string, duration: number, interToneGap: number ) => void;
+  generateRecvonlySsrc: () => void;
+  clearRecvonlySsrc: () => void;
+  close: () => void;
+  createAnswer: ( constraints: unknown ) => unknown; // TODO:
+  createOffer: ( constraints: unknown ) => unknown; // TODO:
+  addIceCandidate: ( candidate: unknown ) => unknown; // TODO:
+  generateNewStreamSSRCInfo: (track: JitsiLocalTrack) => TraceablePeerConnection['localSSRCs'];
+  usesUnifiedPlan: () => boolean;
+  getActiveSimulcastStreams: () => number;
+  getStats: () => unknown; // TODO:
+  toString: () => string;
+}

types/hand-crafted/modules/browser/BrowserCapabilities.d.ts

@@ -0,0 +1,24 @@
+export default class BrowserCapabilities {
+  doesVideoMuteByStreamRemove: () => boolean;
+  isWebKitBased: () => boolean;
+  isChromiumBased: () => boolean;
+  isTwa: () => boolean;
+  isSupported: () => boolean;
+  isUserInteractionRequiredForUnmute: () => boolean;
+  supportsVideoMuteOnConnInterrupted: () => boolean;
+  supportsBandwidthStatistics: () => boolean;
+  supportsCodecPreferences: () => boolean;
+  supportsDeviceChangeEvent: () => boolean;
+  supportsLocalCandidateRttStatistics: () => boolean;
+  supportsPerformanceObserver: () => boolean;
+  supportsReceiverStats: () => boolean;
+  supportsRTTStatistics: () => boolean;
+  usesSdpMungingForSimulcast: () => boolean;
+  usesAdapter: () => boolean;
+  usesRidsForSimulcast: () => boolean;
+  supportsGetDisplayMedia: () => boolean;
+  supportsInsertableStreams: () => boolean;
+  supportsAudioRed: () => boolean;
+  supportsUnifiedPlan: () => boolean;
+  supportsVADDetection: () => boolean;
+}

types/hand-crafted/modules/connectivity/ConnectionQuality.d.ts

@@ -0,0 +1,9 @@
+import JitsiConference from '../../JitsiConference';
+import EventEmitter from '../../EventEmitter';
+import { ConnectionQualityEvents } from '../../service/connectivity/ConnectionQualityEvents';
+
+export default class ConnectionQuality {
+  constructor( conference: JitsiConference, eventEmitter: EventEmitter<ConnectionQualityEvents>, options: { config: { startBitrate: number; } } );
+  getTarget: ( simulcast: boolean, resolution: Resolution, millisSinceStart: number, videoQualitySettings: unknown ) => number; // TODO:
+  getStats: () => unknown; // TODO:
+}

types/hand-crafted/modules/connectivity/IceFailedHandling.d.ts

@@ -0,0 +1,7 @@
+import JitsiConference from "../../JitsiConference";
+
+export default class IceFailedHandling {
+  constructor( conference: JitsiConference );
+  start: () => void;
+  cancel: () => void;
+}

types/hand-crafted/modules/connectivity/NetworkInfo.d.ts

@@ -0,0 +1,11 @@
+import Listenable from '../util/Listenable';
+
+export const NETWORK_INFO_EVENT: "NETWORK_INFO_CHANGED";
+
+export class NetworkInfo extends Listenable {
+  updateNetworkInfo: ( { isOnline: boolean } ) => void;
+  isOnline: () => boolean;
+}
+
+declare const networkInfo: NetworkInfo;
+export default networkInfo;

types/hand-crafted/modules/connectivity/ParticipantConnectionStatus.d.ts

@@ -0,0 +1,32 @@
+import JitsiConference from '../../JitsiConference';
+import RTC from '../RTC/RTC';
+import JitsiRemoteTrack from '../RTC/JitsiRemoteTrack';
+import JitsiParticipant from '../../JitsiParticipant';
+import { VideoType } from '../../service/RTC/VideoType';
+
+export enum ParticipantConnectionStatus {
+  ACTIVE = 'active',
+  INACTIVE = 'inactive',
+  INTERRUPTED = 'interrupted',
+  RESTORING = 'restoring'
+}
+
+export default class ParticipantConnectionStatusHandler {
+  constructor( rtc: RTC, conference: JitsiConference, options: { rtcMuteTimeout: number, outOfLastNTimeout: number } );
+  init: () => void;
+  dispose: () => void;
+  onEndpointConnStatusChanged: ( endpointId: string, isActive: boolean ) => void;
+  clearTimeout: ( participantId: string ) => void;
+  clearRtcMutedTimestamp: ( participantId: string ) => void;
+  onRemoteTrackAdded: ( remoteTrack: JitsiRemoteTrack ) => void;
+  onRemoteTrackRemoved: ( remoteTrack: JitsiRemoteTrack ) => void;
+  isVideoTrackFrozen: ( participant: JitsiParticipant ) => boolean;
+  refreshConnectionStatusForAll: () => void;
+  figureOutConnectionStatus: ( id: string ) => void;
+  maybeSendParticipantConnectionStatusEvent: ( id: string, nowMs: number ) => void;
+  onUserLeft: ( id: string ) => void;
+  onTrackRtcMuted: ( track: JitsiRemoteTrack ) => void;
+  onTrackRtcUnmuted: ( track: JitsiRemoteTrack ) => void;
+  onSignallingMuteChanged: ( track: JitsiRemoteTrack ) => void;
+  onTrackVideoTypeChanged: ( track: JitsiRemoteTrack, type: VideoType ) => void;
+}

types/hand-crafted/modules/detection/ActiveDeviceDetector.d.ts

@@ -0,0 +1 @@
+export default function getActiveAudioDevice(): Promise<unknown>;  // TODO

types/hand-crafted/modules/detection/DetectionEvents.d.ts

@@ -0,0 +1,9 @@
+export enum DetectionEvents {
+  DETECTOR_STATE_CHANGE = 'detector_state_change',
+  AUDIO_INPUT_STATE_CHANGE = 'audio_input_state_changed',
+  NO_AUDIO_INPUT = 'no_audio_input_detected',
+  VAD_NOISY_DEVICE = 'detection.vad_noise_device',
+  VAD_REPORT_PUBLISHED = 'vad-report-published',
+  VAD_SCORE_PUBLISHED = 'detection.vad_score_published',
+  VAD_TALK_WHILE_MUTED = 'detection.vad_talk_while_muted'
+}

types/hand-crafted/modules/detection/NoAudioSignalDetection.d.ts

@@ -0,0 +1,6 @@
+import JitsiConference from '../../JitsiConference';
+import EventEmitter from '../../EventEmitter';
+
+export default class NoAudioSignalDetection extends EventEmitter<unknown> { // TODO:
+  constructor( conference: JitsiConference ); // TODO
+}

types/hand-crafted/modules/detection/P2PDominantSpeakerDetection.d.ts

@@ -0,0 +1,5 @@
+import JitsiConference from '../../JitsiConference';
+
+export default class P2PDominantSpeakerDetection {
+  constructor( conference: JitsiConference );
+}

types/hand-crafted/modules/detection/TrackVADEmitter.d.ts

@@ -0,0 +1,18 @@
+import EventEmitter from '../../EventEmitter';
+import JitsiLocalTrack from '../RTC/JitsiLocalTrack';
+
+export type VADProcessor = {
+  getRequiredPCMFrequency: () => number;
+  getSampleLength: () => number;
+  calculateAudioFrameVAD: ( samples: Array<unknown> ) => number; // TODO: work out what this is an array of
+}
+
+export default class TrackVADEmitter extends EventEmitter<unknown> {
+  constructor( procNodeSampleRate: number, vadProcessor: VADProcessor, jitsiLocalTrack: JitsiLocalTrack );
+  static create: ( micDeviceId: string, procNodeSampleRate: number, vadProcessor: VADProcessor ) => Promise<TrackVADEmitter>;
+  getDeviceId: () => string;
+  getTrackLabel: () => string;
+  start: () => void;
+  stop: () => void;
+  destroy: () => void;
+}

types/hand-crafted/modules/detection/VADAudioAnalyser.d.ts

@@ -0,0 +1,8 @@
+import { VADProcessor } from "./TrackVADEmitter";
+import JitsiConference from '../../JitsiConference';
+import EventEmitter from '../../EventEmitter';
+
+export default class VADAudioAnalyser extends EventEmitter<unknown> { // TODO:
+  constructor( conference: JitsiConference, createVADProcessor: () => VADProcessor );
+  addVADDetectionService: ( vadService: unknown ) => void;
+}

types/hand-crafted/modules/detection/VADNoiseDetection.d.ts

@@ -0,0 +1,16 @@
+import EventEmitter from '../../EventEmitter';
+
+export type VADScore = {
+  timestamp: Date;
+  score: number;
+  pcmData: number[];
+  deviceId: string;
+}
+
+declare class VADNoiseDetection extends EventEmitter<unknown> { // TODO:
+  constructor();
+  changeMuteState: ( isMuted: boolean ) => void;
+  isActive: () => boolean;
+  reset: () => void;
+  processVADScore: ( vadScore: VADScore ) => void;
+}

types/hand-crafted/modules/detection/VADReportingService.d.ts

@@ -0,0 +1,8 @@
+import { VADProcessor } from "./TrackVADEmitter";
+import EventEmitter from '../../EventEmitter';
+
+export default class VADReportingService extends EventEmitter<unknown> { // TODO:
+  constructor( intervalDelay: number );
+  static create: ( micDeviceList: MediaDeviceInfo[], intervalDelay: number, createVADProcessor: () => VADProcessor ) => Promise<VADReportingService>;
+  destroy: () => void;
+}

types/hand-crafted/modules/detection/VADTalkMutedDetection.d.ts

@@ -0,0 +1,10 @@
+import { VADScore } from "./VADNoiseDetection";
+import EventEmitter from '../../EventEmitter';
+
+export default class VADTalkMutedDetection extends EventEmitter<unknown> { // TODO:
+  constructor();
+  changeMuteState: ( isMuted: boolean ) => void;
+  isActive: () => boolean;
+  processVADScore: ( vadScore: VADScore ) => void;
+  reset: () => void;
+}

types/hand-crafted/modules/e2ee/Context.d.ts

@@ -0,0 +1,6 @@
+export class Context {
+  constructor( id: string );
+  setKey: ( keyBytes: number[] | false, keyIndex: number ) => Promise<void>; // TODO: jsdoc has different parameter name
+  encodeFunction: ( encodedFrame: RTCEncodedVideoFrame | RTCEncodedAudioFrame, controller: TransformStreamDefaultController ) => void;
+  decodeFunction: ( encodedFrame: RTCEncodedVideoFrame | RTCEncodedAudioFrame, controller: TransformStreamDefaultController ) => Promise<unknown>; // TODO:
+}

types/hand-crafted/modules/e2ee/E2EEContext.d.ts

@@ -0,0 +1,7 @@
+export default class E2EEcontext {
+  constructor();
+  cleanup: ( participantId: string ) => void;
+  handleReceiver: ( receiver: RTCRtpReceiver, kind: string, participantId: string ) => void;
+  handleSender: ( sender: RTCRtpSender, kind: string, participantId: string ) => void;
+  setKey: ( participantId: string, key: Uint8Array[] | boolean, keyIndex: number ) => void;
+}

types/hand-crafted/modules/e2ee/E2EEncryption.d.ts

@@ -0,0 +1,8 @@
+import JitsiConference from '../../JitsiConference';
+
+declare class E2EEncryption {
+  constructor( conference: JitsiConference );
+  static isSupported: ( config: { testing: { disableE2EE: boolean } } ) => boolean;
+  isEnabled: () => boolean;
+  setEnabled: ( enabled: boolean ) => Promise<void>;
+}

types/hand-crafted/modules/e2ee/OlmAdapter.d.ts

@@ -0,0 +1,12 @@
+import JitsiConference from '../../JitsiConference';
+import Listenable from '../util/Listenable';
+
+export class OlmAdapter extends Listenable {
+  constructor( conference: JitsiConference );
+  initSessions: () => Promise<unknown>; // TODO:
+  static isSupported: () => boolean;
+  updateCurrentKey: ( key: Uint8Array | boolean ) => number;
+  clearParticipantSession: ( participant: unknown ) => void; // TODO:
+  clearAllParticipantsSessions: () => void;
+  updateKey: ( key: Uint8Array | boolean ) => Promise<number>;
+}

types/hand-crafted/modules/e2ee/crypto-utils.d.ts

@@ -0,0 +1,5 @@
+export function deriveKeys( material: CryptoKey ): Promise<unknown>; // TODO:
+
+export function ratchet( material: CryptoKey ): Promise<ArrayBuffer>; // TODO: check promise
+
+export function importKey( keyBytes: ArrayBuffer, keyUsages: Array<unknown> ): Promise<CryptoKey>; // TODO: check promise

types/hand-crafted/modules/e2ee/utils.d.ts

@@ -0,0 +1,4 @@
+export function polyFillEncodedFrameMetadata( encodedFrame: RTCEncodedAudioFrame | RTCEncodedVideoFrame, controller: unknown ): void; // TODO:
+
+export function isArrayEqual<T>( a1: Array<T>, a2: Array<T> ): boolean;
+

types/hand-crafted/modules/e2eping/e2eping.d.ts

@@ -0,0 +1,32 @@
+import JitsiConference from '../../JitsiConference';
+import JitsiParticipant from '../../JitsiParticipant';
+
+declare type E2ePingOptions = {
+  e2eping?: {
+    pingInterval?: number;
+    analyticsInterval?: number;
+  }
+}
+
+declare type E2ePayload = {
+  type: 'e2e-ping-request' | 'e2e-ping-response'
+}
+
+declare type E2eResponse = E2ePayload | {
+  id: string
+}
+
+declare type E2eRequest = {
+  id: string
+}
+
+export default class E2ePing {
+  constructor( conference: JitsiConference, options: E2ePingOptions, sendMessage: ( response: E2eResponse, participant: string ) => void ); // TODO: jsdoc arguments are in the wrong order
+  dataChannelOpened: () => void;
+  messageReceived: ( participant: unknown, payload: unknown ) => void; // TODO:
+  participantJoined: ( id: string, participant: JitsiParticipant ) => void;
+  participantLeft: ( id: string ) => void;
+  handleRequest: ( participantId: string, request: E2eRequest ) => void;
+  handleResponse: ( participantId: string, response: unknown ) => void; // TODO:
+  stop: () => void;
+}

types/hand-crafted/modules/event/Jvb121EventGenerator.d.ts

@@ -0,0 +1,6 @@
+import JitsiConference from '../../JitsiConference';
+
+export default class Jvb121EventGenerator {
+  constructor( conference: JitsiConference );
+  evaluateStatus: () => void;
+}

types/hand-crafted/modules/proxyconnection/ProxyConnectionPC.d.ts

@@ -0,0 +1,16 @@
+import JitsiLocalTrack from '../RTC/JitsiLocalTrack';
+
+export default class ProxyConnectionPC {
+  constructor( options?: {
+    iceConfig: unknown; // TODO:
+    isInitiator: boolean;
+    onRemoteStream: ( params: unknown ) => unknown; // TODO:
+    peerJid: string;
+    receiveVideo: boolean;
+    onSendMessage: ( params: unknown ) => unknown; // TODO:
+  } );
+  getPeerJid: () => string;
+  processMessage: ( $jingle: JQuery ) => void; // TODO: surely there shouldn't be a dependency on jQuery
+  start: ( localTracks?: JitsiLocalTrack[] ) => void;
+  stop: () => void;
+}

types/hand-crafted/modules/proxyconnection/ProxyConnectionService.d.ts

@@ -0,0 +1,15 @@
+import JitsiConnection from '../../JitsiConnection';
+import JitsiLocalTrack from '../RTC/JitsiLocalTrack';
+
+export default class ProxyConnectionService {
+  constructor( options: {
+    convertVideoToDesktop: boolean,
+    iceConfig: unknown, // TODO:
+    jitsiConnection: JitsiConnection,
+    onRemoteStream: ( params: unknown ) => unknown, // TODO:
+    onSendMessage: ( params: unknown ) => unknown // TODO:
+  } );
+  processMessage: ( message: { data: { iq: string }, from: string } ) => void;
+  start: ( peerJid: string, localTracks?: JitsiLocalTrack[] ) => void;
+  stop: () => void;
+}

types/hand-crafted/modules/proxyconnection/constants.d.ts

@@ -0,0 +1,8 @@
+export enum ACTIONS {
+  ACCEPT = 'session-accept',
+  CONNECTION_ERROR = 'connection-error-encountered',
+  INITIATE = 'session-initiate',
+  TERMINATE = 'session-terminate',
+  TRANSPORT_INFO = 'transport-info',
+  UNAVAILABLE = 'unavailable'
+}

types/hand-crafted/modules/qualitycontrol/ReceiveVideoController.d.ts

@@ -0,0 +1,19 @@
+import JitsiConference from '../../JitsiConference';
+import RTC from '../RTC/RTC';
+
+export class ReceiverVideoConstraints {
+  readonly constraints: unknown; // TODO:
+  updateLastN: ( value: number ) => boolean;
+  updateReceiveResolution: ( maxFrameHeight: number ) => boolean;
+  updateReceiverVideoConstraints: ( videoConstraints: ReceiverVideoConstraints ) => boolean; // TODO:
+  updateSelectedEndpoints: ( ids: unknown ) => void; // TODO:
+}
+
+export class ReceiveVideoController {
+  constructor( conference: JitsiConference, rtc: RTC );
+  getLastN: () => number;
+  selectEndpoints: ( ids: unknown ) => unknown; // TODO:
+  setLastN: ( value: number ) => void;
+  setPreferredReceiveMaxFrameHeight: ( maxFrameHeight: number ) => void;
+  setReceiverConstraints: ( constraints: ReceiverVideoConstraints ) => void;
+}

types/hand-crafted/modules/qualitycontrol/SendVideoController.d.ts

@@ -0,0 +1,8 @@
+import JitsiConference from '../../JitsiConference';
+import RTC from '../RTC/RTC';
+
+export class SendVideoController {
+  constructor( conference: JitsiConference, rtc: RTC );
+  selectSendMaxFrameHeight: () => number | undefined;
+  setPreferredSendMaxFrameHeight: ( maxFrameHeight: number ) => Promise<void[]>;
+}

types/hand-crafted/modules/recording/JibriSession.d.ts

@@ -0,0 +1,23 @@
+import JitsiParticipant from '../../JitsiParticipant';
+import Jibri from './recordingConstants';
+
+export default class JibriSession {
+  constructor( options?: {
+    connection: unknown, // TODO:
+    mode: unknown, // TODO:
+    sessionID: unknown, // TODO:
+    status: unknown // TODO:
+  } );
+  getError: () => Jibri.error | undefined;
+  getID: () => string | undefined;
+  getInitiator: () => JitsiParticipant | string;
+  getLiveStreamViewURL: () => string | undefined;
+  getStatus: () => Jibri.status | undefined;
+  getTerminator: () => JitsiParticipant | string;
+  getMode: () => Jibri.mode;
+  setError: ( error: Jibri.error ) => void;
+  setLiveStreamViewURL: ( url: string ) => void;
+  setStatus: ( status: Jibri.status ) => void;
+  setInitiator: ( participant: JitsiParticipant | string ) => void;
+  setTerminator: ( participant: JitsiParticipant | string ) => void;
+}

types/hand-crafted/modules/recording/RecordingManager.d.ts

@@ -0,0 +1,11 @@
+import ChatRoom from '../xmpp/ChatRoom';
+import JibriSession from './JibriSession';
+import Jibri from './recordingConstants';
+
+export default class RecordingManager {
+  constructor( chatRoom: ChatRoom ); // TODO: jsdocs says return type is void
+  getSession: ( sessionID: string ) => JibriSession | undefined;
+  onPresence: ( { fromHiddenDomain: Node, presence: boolean } ) => void;
+  startRecording: ( options: { appData: string, broadcastId?: string, mode: Jibri.mode, streamId?: string } ) => Promise<unknown>;
+  stopRecording: ( sessionID: string ) => Promise<unknown>;
+}

types/hand-crafted/modules/recording/recordingConstants.d.ts

@@ -0,0 +1,21 @@
+declare namespace recordingConstants {
+  enum error {
+    BUSY = 'busy',
+    ERROR = 'error',
+    RESOURCE_CONSTRAINT = 'resource-constraint',
+    SERVICE_UNAVAILABLE = 'service-unavailable'
+  }
+
+  enum mode {
+    FILE = 'file',
+    STREAM = 'stream'
+  }
+
+  enum status {
+    OFF = 'off',
+    ON = 'on',
+    PENDING = 'pending'
+  }
+}
+
+export default recordingConstants;

types/hand-crafted/modules/recording/recordingXMLUtils.d.ts

@@ -0,0 +1,21 @@
+declare type RecordingXMLUtils = {
+  getFocusRecordingUpdate: ( presence: Node ) => {
+    error: string,
+    initiator: string,
+    recordingMode: string,
+    sessionID: string,
+    status: string
+  };
+
+  getHiddenDomainUpdate: ( presence: Node ) => {
+    liveStreamViewURL: string,
+    mode: string,
+    sessionID: string
+  };
+
+  getSessionIdFromIq: ( response: Node ) => string;
+  getSessionId: ( presence: Node ) => string;
+  isFromFocus: ( presence: Node ) => boolean;
+}
+
+export default RecordingXMLUtils;

types/hand-crafted/modules/sdp/LocalSdpMunger.d.ts

@@ -0,0 +1,7 @@
+import TraceablePeerConnection from '../RTC/TraceablePeerConnection';
+
+export default class LocalSdpMunger {
+  constructor( tpc: TraceablePeerConnection, localEndpointId: string );
+  maybeAddMutedLocalVideoTracksToSDP: ( desc: unknown ) => RTCSessionDescription; // TODO:
+  transformStreamIdentifiers: ( sessionDesc: RTCSessionDescription ) => RTCSessionDescription;
+}

types/hand-crafted/modules/sdp/RtxModifier.d.ts

@@ -0,0 +1,9 @@
+import { MLineWrap } from './SdpTransformUtil';
+
+export default class RtxModifier {
+  clearSsrcCache: () => void;
+  setSsrcCache: ( ssrcMapping: Map<unknown, unknown> ) => void; // TODO:
+  modifyRtxSsrcs: ( sdpStr: string ) => void;
+  modifyRtxSsrcs2: ( videoMLine: MLineWrap ) => boolean; // TODO: what is an MLineWrap
+  stripRtx: ( sdpStr: string ) => string;
+}

types/hand-crafted/modules/sdp/SDP.d.ts

@@ -0,0 +1,16 @@
+export default function SDP( sdp: unknown ): void; // TODO:
+
+export default class SDP {
+  constructor( sdp: unknown ); // TODO:
+  failICE: boolean;
+  removeTcpCandidates: boolean;
+  removeUdpCandidates: boolean;
+  getMediaSsrcMap: () => unknown; // TODO:
+  containsSSRC: ( ssrc: unknown ) => boolean; // TODO:
+  toJingle: ( elem: unknown, thecreator: unknown ) => unknown; // TODO:
+  transportToJingle: ( mediaindex: unknown, elem: unknown ) => unknown; // TODO:
+  rtcpFbToJingle: ( mediaindex: unknown, elem: unknown, payloadtype: unknown ) => unknown; // TODO:
+  rtcpFbFromJingle: ( elem: unknown, payloadtype: unknown ) => unknown; // TODO:
+  fromJingle: ( jingle: unknown ) => unknown; // TODO:
+  jingle2media: ( content: unknown ) => unknown; // TODO:
+}

types/hand-crafted/modules/sdp/SDPDiffer.d.ts

@@ -0,0 +1,7 @@
+export default function SDPDiffer( mySDP: unknown, otherSDP: unknown ): void;
+
+export default class SDPDiffer {
+  constructor( mySDP: unknown, otherSDP: unknown ); // TODO:
+  getNewMedia: () => unknown; // TODO:
+  toJingle: ( modify: unknown ) => unknown; // TODO:
+}

types/hand-crafted/modules/sdp/SDPUtil.d.ts

@@ -0,0 +1,36 @@
+import SDP from './SDP';
+
+export type SDPUtil = {
+  filterSpecialChars: ( text: string ) => string;
+  iceparams: ( mediadesc: unknown, sessiondesc: unknown ) => unknown; // TODO:
+  parseICEUfrag: ( line: string ) => string;
+  buildICEUfrag: ( frag: unknown ) => string; // TODO:
+  parseICEPwd: ( line: string ) => string;
+  buildICEPwd: ( pwd: unknown ) => string; // TODO:
+  parseMID: ( line: string ) => string;
+  parseMLine: ( line: string ) => unknown; // TODO:
+  buildMLine: ( mline: unknown ) => string; // TODO:
+  parseRTPMap: ( line: string ) => unknown; // TODO:
+  parseSCTPMap: ( line: string ) => unknown[]; // TODO:
+  buildRTPMap: ( el: unknown ) => string; // TODO:
+  parseCrypto: ( line: string ) => unknown; // TODO:
+  parseFingerprint: ( line: string ) => unknown; // TODO:
+  parseFmtp: ( line: string ) => unknown; // TODO:
+  parseICECandidate: ( line: string ) => unknown; // TODO:
+  buildICECandidate: ( cand: unknown ) => unknown; // TODO:
+  parseSSRC: ( desc: unknown ) => unknown; // TODO:
+  parseRTCPFB: ( cand: unknown ) => unknown; // TODO:
+  parseExtmap: ( cand: unknown ) => unknown; // TODO:
+  findLine: ( haystack: string, needle: string, sessionpart?: string ) => boolean;
+  findLines: ( haystack: string, needle: string, sessionpart?: string ) => string[];
+  candidateToJingle: ( line: string ) => unknown; // TODO:
+  candidateFromJingle: ( cand: unknown ) => unknown; // TODO:
+  parsePrimaryVideoSsrc: ( videoMLine: unknown ) => number; // TODO:
+  generateSsrc: () => number;
+  getSsrcAttribute: ( mLine: unknown, ssrc: number, attributeName: string ) => string;
+  parseGroupSsrcs: ( ssrcGroup: unknown ) => number[]; // TODO:
+  getMedia: ( sdp: SDP, type: unknown ) => unknown; // TODO:
+  getUfrag: ( sdp: SDP ) => string;
+  preferCodec: ( mline: unknown, codecName: string ) => void; // TODO:
+  stripCodec: ( mLine: unknown, codecName: string, highProfile?: boolean ) => void; // TODO:
+}

types/hand-crafted/modules/sdp/SdpConsistency.d.ts

@@ -0,0 +1,7 @@
+export default class SdpConsistency {
+  constructor( logPrefix: string );
+  clearVideoSsrcCache: () => void;
+  setPrimarySsrc: ( primarySsrc: number ) => void;
+  hasPrimarySsrcCached: () => void;
+  makeVideoPrimarySsrcsConsistent: ( sdpStr: string ) => string;
+}

types/hand-crafted/modules/sdp/SdpTransformUtil.d.ts

@@ -0,0 +1,33 @@
+import { MediaDirection } from '../../service/RTC/MediaDirection';
+import { MediaType } from '../../service/RTC/MediaType';
+
+export function parsePrimarySSRC( group: unknown ): number; // TODO:
+
+export class MLineWrap {
+  ssrcs: unknown[]; // TODO:
+  direction: MediaDirection;
+  ssrcGroups: unknown[]; // TODO:
+  getSSRCAttrValue: ( ssrcNumber: number, attrName: string ) => string | undefined;
+  removeSSRC: ( ssrcNum: number ) => void;
+  addSSRCAttribute: ( ssrcObj: unknown ) => void; // TODO:
+  findGroup: ( semantics: string, ssrcs: string ) => unknown | undefined;
+  findGroups: ( semantics: string ) => unknown[];
+  findGroupByPrimarySSRC: ( semantics: string, primarySSRC: number ) => unknown; // TODO:
+  findSSRCByMSID: ( msid: string | null ) => unknown | undefined; // TODO:
+  getSSRCCount: () => number;
+  containsAnySSRCGroups: () => boolean;
+  getPrimaryVideoSsrc: () => number | undefined;
+  getRtxSSRC: ( primarySsrc: number ) => number | undefined;
+  getSSRCs: () => number[];
+  getPrimaryVideoSSRCs: () => number[];
+  dumpSSRCGroups: () => string;
+  removeGroupsWithSSRC: ( ssrc: string ) => void;
+  removeGroupsBySemantics: ( semantics: string ) => void;
+  replaceSSRC: ( oldSSRC: number, newSSRC: number ) => void;
+  addSSRCGroup: ( group: unknown ) => void; // TODO:
+}
+
+export class SdpTransformWrap {
+  selectMedia: ( mediaType: MediaType ) => MLineWrap | null;
+  toRawSDP: () => string;
+}

types/hand-crafted/modules/settings/Settings.d.ts

@@ -0,0 +1,8 @@
+declare namespace Settings {
+  export function init( externalStorage: Storage | undefined ): void;
+  const callStatsUserName: string;
+  const machineId: string;
+  const sessionId: string;
+}
+
+export default Settings;

types/hand-crafted/modules/statistics/AnalyticsAdapter.d.ts

@@ -0,0 +1,11 @@
+declare class AnalyticsAdapter {
+  reset: () => void;
+  dispose: () => void;
+  setAnalyticsHandlers: ( handlers: Array<unknown> ) => void; // TODO:
+  addPermanentProperties: ( properties: unknown ) => void; // TODO:
+  setConferenceName: ( name: string ) => void;
+  sendEvent: ( eventName: string | unknown, properties?: unknown ) => void; // TODO:
+}
+
+declare const analyticsAdapter: AnalyticsAdapter;
+export default analyticsAdapter;

types/hand-crafted/modules/statistics/AudioOutputProblemDetector.d.ts

@@ -0,0 +1,6 @@
+import JitsiConference from '../../JitsiConference';
+
+export default class AudioOutputProblemDetector {
+  constructor( conference: JitsiConference );
+  dispose: () => void;
+}

types/hand-crafted/modules/statistics/AvgRTPStatsReporter.d.ts

@@ -0,0 +1,6 @@
+import JitsiConference from '../../JitsiConference';
+
+export default class AvgRTPStatsReporter {
+  constructor( conference: JitsiConference, n: number );
+  dispose: () => void;
+}

types/hand-crafted/modules/statistics/CallStats.d.ts

@@ -0,0 +1,34 @@
+import TraceablePeerConnection from '../RTC/TraceablePeerConnection';
+
+declare class CallStats {
+  constructor( tpc: TraceablePeerConnection, options: {
+    confID: string,
+    remoteUserID?: string
+  } );
+  static readonly fabrics: Set<CallStats>;
+  static initBackend: ( options: {
+    callStatsID: string,
+    callStatsSecret: string,
+    aliasName: string
+    userName: string
+  } ) => boolean;
+  static isBackendInitialized: () => boolean;
+  static sendActiveDeviceListEvent: ( devicesData: { deviceList: { string: string } }, cs: CallStats ) => void; // TODO: not convinced by this definition
+  static sendApplicationLog: ( e: Error, cs: CallStats ) => void;
+  static sendFeedback: ( conferenceID: string, overall: 1 | 2 | 3 | 4 | 5, comment: unknown ) => Promise<unknown>; // TODO:
+  static sendGetUserMediaFailed: ( e: Error, cs: CallStats ) => void;
+  static sendMuteEvent: ( mute: boolean, type: "audio" | "video", cs: CallStats ) => void;
+  associateStreamWithVideoTag: ( ssrc: number, isLocal: boolean, streamEndpointId: string | null, usageLabel: string, containerId: string ) => void;
+  sendDominantSpeakerEvent: () => void;
+  sendTerminateEvent: () => void;
+  sendIceConnectionFailedEvent: () => void;
+  sendCreateOfferFailed: ( e: Error ) => void;
+  sendCreateAnswerFailed: ( e: Error ) => void;
+  sendResumeOrHoldEvent: ( isResume: boolean ) => void;
+  sendScreenSharingEvent: ( start: boolean, ssrc: string | null ) => void;
+  sendSetLocalDescFailed: ( e: Error ) => void;
+  sendSetRemoteDescFailed: ( e: Error ) => void;
+  sendAddIceCandidateFailed: ( e: Error ) => void;
+}
+
+export default CallStats;

types/hand-crafted/modules/statistics/LocalStatsCollector.d.ts

@@ -0,0 +1,10 @@
+declare function LocalStatsCollector( stream: unknown, interval: unknown, callback: unknown ): void;
+
+declare class LocalStatsCollector {
+  constructor( stream: unknown, interval: unknown, callback: unknown );
+  start: () => void;
+  stop: () => void;
+  static isLocalStatsSupported: () => boolean;
+} // TODO: check this definition - it looks like an old school class but might be a mixin
+
+export default LocalStatsCollector;

types/hand-crafted/modules/statistics/PerformanceObserverStats.d.ts

@@ -0,0 +1,6 @@
+export class PerformanceObserverStats {
+  constructor( emitter: unknown, statsInterval: unknown ); // TODO:
+  getLongTasksStats: () => unknown; // TODO:
+  startObserver: () => void;
+  stopObserver: () => void;
+}

types/hand-crafted/modules/statistics/PrecallTest.d.ts

@@ -0,0 +1,22 @@
+export function init( options: unknown ): Promise<void>; // TODO:
+
+export type PrecallTestOptions = {
+  callStatsID: string;
+  callStatsSecret: string;
+  statisticsId: string;
+  statisticsDisplayName: string;
+  disableThirdPartyRequests?: boolean; // undocumented but used in the method
+}
+
+export type PrecallTestResults = {
+  mediaConnectivity: boolean
+  throughput: number;
+  fractionalLoss: number;
+  rtt: number;
+  provider: string;
+}
+
+export default class PrecallTest {
+  init: ( options: PrecallTestOptions ) => Promise<void>;
+  execute: () => Promise<string | PrecallTestResults>;
+}

types/hand-crafted/modules/statistics/RTPStatsCollector.d.ts

@@ -0,0 +1,13 @@
+export default function StatsCollector( peerconnection: unknown, audioLevelsInterval: unknown, statsInterval: unknown, eventEmitter: unknown ): void; // TODO:
+
+export default class StatsCollector {
+  constructor( peerconnection: unknown, audioLevelsInterval: unknown, statsInterval: unknown, eventEmitter: unknown ); // TODO:
+  stop: () => void;
+  errorCallback: ( error: Error ) => void;
+  start: ( startAudioLevelStats: unknown ) => void;
+  getNonNegativeStat: ( report: unknown, name: string ) => number;
+  processStatsReport: () => void;
+  processAudioLevelReport: () => void;
+  getNonNegativeValue: ( v: unknown ) => number; // TODO:
+  setSpeakerList: ( speakerList: Array<string> ) => void;
+}

types/hand-crafted/modules/statistics/SpeakerStats.d.ts

@@ -0,0 +1,12 @@
+export class SpeakerStats {
+  constructor( userId: string, displayName: string, isLocalStats: boolean );
+  getUserId: () => string;
+  getDisplayName: () => string;
+  setDisplayName: ( name: string ) => void;
+  isLocalStats: () => boolean;
+  isDominantSpeaker: () => boolean;
+  setDominantSpeaker: ( isNowDominantSpeaker: boolean ) => void;
+  getTotalDominantSpeakerTime: () => number;
+  hasLeft: () => boolean;
+  markAsHasLeft: () => void;
+}

types/hand-crafted/modules/statistics/SpeakerStatsCollector.d.ts

@@ -0,0 +1,6 @@
+import JitsiConference from '../../JitsiConference';
+
+export default class SpeakerStatsCollector {
+  constructor( conference: JitsiConference );
+  getStats: () => unknown; // TODO:
+}

types/hand-crafted/modules/statistics/constants.d.ts

@@ -0,0 +1 @@
+export const CALLSTATS_SCRIPT_URL = 'https://api.callstats.io/static/callstats-ws.min.js';

types/hand-crafted/modules/statistics/statistics.d.ts

@@ -0,0 +1,61 @@
+import TraceablePeerConnection from '../RTC/TraceablePeerConnection';
+
+export type StatisticsOptions = {
+  applicationName: string,
+  aliasName: string,
+  userName: string,
+  confID: string,
+  callStatsID: string,
+  callStatsSecret: string,
+  customScriptUrl: string,
+  roomName: string
+}
+
+declare function Statistics( xmpp: unknown, options: StatisticsOptions ): void;
+
+declare class Statistics {
+  constructor( xmpp: unknown, options: StatisticsOptions ); // TODO:
+  readonly instances: Set<Statistics>;
+  localStats: unknown[]; // TODO:
+  startRemoteStats: ( peerconnection: TraceablePeerConnection ) => void;
+  startLocalStats: ( stream: unknown, callback: unknown ) => void; // TODO:
+  addAudioLevelListener: ( listener: unknown ) => void; // TODO:
+  removeAudioLevelListener: ( listener: unknown ) => void; // TODO:
+  addBeforeDisposedListener: ( listener: unknown ) => void; // TODO:
+  removeBeforeDisposedListener: ( listener: unknown ) => void; // TODO:
+  addConnectionStatsListener: ( listener: unknown ) => void; // TODO:
+  removeConnectionStatsListener: ( listener: unknown ) => void; // TODO:
+  addByteSentStatsListener: ( listener: unknown ) => void; // TODO:
+  removeByteSentStatsListener: ( listener: unknown ) => void; // TODO:
+  addLongTasksStatsListener: ( listener: unknown ) => void; // TODO:
+  attachLongTasksStats: ( conference: unknown ) => void; // TODO:
+  getLongTasksStats: () => unknown | null; // TODO:
+  removeLongTasksStatsListener: ( listener: unknown ) => void; // TODO:
+  setSpeakerList: ( speakerList: Array<string> ) => void;
+  dispose: () => void;
+  stopLocalStats: ( stream: unknown ) => void;
+  stopRemoteStats: ( tpc: TraceablePeerConnection ) => void;
+  startCallStats: ( tpc: TraceablePeerConnection, remoteUserID: string ) => void;
+  stopCallStats: ( tpc: TraceablePeerConnection ) => void;
+  isCallstatsEnabled: () => boolean;
+  sendConnectionResumeOrHoldEvent: ( tpc: TraceablePeerConnection, isResume: boolean ) => void;
+  sendIceConnectionFailedEvent: ( tpc: TraceablePeerConnection ) => void;
+  sendMuteEvent: ( tpc: TraceablePeerConnection, muted: boolean, type: "audio" | "video" ) => void;
+  sendScreenSharingEvent: ( start: boolean, ssrc: string | null ) => void;
+  sendDominantSpeakerEvent: ( roomJid: string ) => void;
+  sendActiveDeviceListEvent: ( devicesData: { deviceList: { String: string } } ) => void; // TODO: check this definition
+  associateStreamWithVideoTag: ( tpc: TraceablePeerConnection, ssrc: number, isLocal: boolean, userId: string, usageLabel: string, containerId: string ) => void;
+  sendGetUserMediaFailed: ( e: Error ) => void;
+  sendCreateOfferFailed: ( e: Error, tpc: TraceablePeerConnection ) => void;
+  sendCreateAnswerFailed: ( e: Error, tpc: TraceablePeerConnection ) => void;
+  sendSetLocalDescFailed: ( e: Error, tpc: TraceablePeerConnection ) => void;
+  sendSetRemoteDescFailed: ( e: Error, tpc: TraceablePeerConnection ) => void;
+  sendAddIceCandidateFailed: ( e: Error, tpc: TraceablePeerConnection ) => void;
+  sendFeedback: ( overall: 1 | 2 | 3 | 4 | 5, comment: string ) => Promise<void>;
+  static reportGlobalError: ( error: Error ) => void;
+  static sendLog: ( m: string ) => void;
+  static sendAnalyticsAndLog: ( event: string | unknown, properties?: unknown ) => void; // TODO
+  static sendAnalytics: ( eventName: string | unknown, properties?: unknown ) => void; // TODO
+}
+
+export default Statistics;

types/hand-crafted/modules/transcription/audioRecorder.d.ts

@@ -0,0 +1,16 @@
+import JitsiConference from '../../JitsiConference';
+import JitsiTrack from '../RTC/JitsiTrack';
+
+export class AudioRecorder {
+  constructor( jitsiConference: JitsiConference );
+  determineCorrectFileType: unknown; // TODO:
+  addTrack: ( track: JitsiTrack ) => void;
+  instantiateTrackRecorder: ( track: JitsiTrack ) => void;
+  removeTrack: ( track: JitsiTrack ) => void;
+  updateNames: () => void;
+  start: () => void;
+  stop: () => void;
+  download: () => void;
+  getRecordingResults: () => Array<unknown>; // TODO:
+  getFileType: () => string;
+}

types/hand-crafted/modules/transcription/recordingResult.d.ts

@@ -0,0 +1,7 @@
+export default class RecordingResult {
+  constructor( blob: unknown, name: unknown, startTime: unknown, wordArray: unknown ); // TODO:
+  readonly blob: unknown; // TODO:
+  readonly name: unknown; // TODO:
+  readonly startTime: unknown; // TODO:
+  readonly wordArray: unknown; // TODO:
+}

types/hand-crafted/modules/transcription/transcriber.d.ts

@@ -0,0 +1,14 @@
+import JitsiTrack from '../RTC/JitsiTrack';
+
+export default class Transcriber {
+  start: () => void;
+  stop: () => void;
+  maybeMerge: () => void;
+  merge: () => void;
+  updateTranscription: ( word: string, name?: string ) => void;
+  addTrack: ( track: JitsiTrack ) => void;
+  removeTrack: ( track: JitsiTrack ) => void;
+  getTranscription: () => string;
+  getState: () => unknown; // TODO:
+  reset: () => void;
+}

types/hand-crafted/modules/transcription/transcriberHolder.d.ts

@@ -0,0 +1,4 @@
+export type transcriberHolder = {
+  transcribers: unknown[], // TODO
+  add: ( transcriber: unknown ) => void; // TODO:
+}

types/hand-crafted/modules/transcription/transcriptionServices/AbstractTranscriptionService.d.ts

@@ -0,0 +1,9 @@
+import Word from '../word';
+import RecordingResult from '../recordingResult';
+
+export class TranscriptionService {
+  send: ( recordingResult: RecordingResult, callback: ( params: unknown ) => unknown ) => void; // TODO:
+  sendRequest: ( audioBlob: Blob, callback: ( params: unknown ) => unknown ) => void; // TODO:
+  formatResponse: ( response: unknown ) => Word[]; // TODO:
+  verify: ( response: unknown ) => boolean; // TODO:
+}

types/hand-crafted/modules/transcription/transcriptionServices/SphinxTranscriptionService.d.ts

@@ -0,0 +1,7 @@
+import Word from '../word';
+
+export type SphinxService = {
+  sendRequest: ( audioFileBlob: unknown, callback: ( params: unknown ) => unknown ) => void; // TODO:
+  formatResponse: ( response: unknown ) => Word[]; // TODO:
+  verify: ( response: unknown ) => boolean; // TODO:
+}

types/hand-crafted/modules/transcription/word.d.ts

@@ -0,0 +1,8 @@
+export default class Word {
+  word: string;
+  begin: number;
+  end: number;
+  getWord: () => string;
+  getBeginTime: () => number;
+  getEndTime: () => number;
+}

types/hand-crafted/modules/util/AsyncQueue.d.ts

@@ -0,0 +1,6 @@
+export default class AsyncQueue {
+  constructor();
+  push: ( task: ( callback: ( err?: Error ) => void ) => void, callback?: ( err: Error ) => void ) => void; // TODO: check this
+  clear: () => void;
+  shutdown: () => void;
+}

types/hand-crafted/modules/util/AuthUtil.d.ts

@@ -0,0 +1 @@
+export function getTokenAuthUrl( urlPattern: string, roomName: string, roleUpgrade: boolean ): string;

types/hand-crafted/modules/util/Deferred.d.ts

@@ -0,0 +1,5 @@
+export default class Deferred {
+  constructor();
+  clearRejectTimeout: () => void;
+  setRejectTimeout: ( ms: number ) => void;
+}

types/hand-crafted/modules/util/EventEmitterForwarder.d.ts

@@ -0,0 +1,8 @@
+declare function EventEmitterForwarder( src: { addListener: ( params: unknown ) => unknown }, dest: { emit: ( params: unknown ) => void } ): void;
+
+declare class EventEmitterForwarder {
+  constructor( src: { addListener: ( params: unknown ) => unknown }, dest: { emit: ( params: unknown ) => void } ); // TODO:
+  forward: ( srcEvent: string, dstyEvent: string, ...args: any[] ) => void;
+}
+
+export = EventEmitterForwarder;

types/hand-crafted/modules/util/GlobalOnErrorHandlerImpl.d.ts

@@ -0,0 +1,5 @@
+export function addHandler( handler: unknown ): void;
+
+export function callErrorHandler( error: Error ): void;
+
+export function callUnhandledRejectionHandler( error: Error ): void;

types/hand-crafted/modules/util/Listenable.d.ts

@@ -0,0 +1,7 @@
+import EventEmitter from '../../EventEmitter';
+
+export default class Listenable {
+  constructor( eventEmitter?: EventEmitter<unknown> ); // TODO:
+  addListener: ( eventName: string, listener: () => unknown ) => () => unknown; // TODO: returns remote listener func
+  removeListener: ( eventName: string, listener: () => unknown ) => void;
+}

types/hand-crafted/modules/util/MathUtil.d.ts

@@ -0,0 +1,13 @@
+export function safeCounterIncrement( number: number ): number;
+
+export function calculateAverage( valueArray: Float32Array ): number;
+
+export function hashString( string: string ): number;
+
+export function filterPositiveValues( valueArray: Float32Array ): Float32Array;
+
+export class RunningAverage {
+  constructor();
+  addNext: ( value: number ) => void;
+  getAverage: () => number;
+}

types/hand-crafted/modules/util/RandomUtil.d.ts

@@ -0,0 +1,9 @@
+export function randomHexDigit(): string;
+
+export function randomHexString( len: number ): string;
+
+export function randomElement<T>( arr: Array<T> | string ): T | string;
+
+export function randomAlphanumStr( length: number ): string;
+
+export function randomInt( min: number, max: number ): number;

types/hand-crafted/modules/util/Retry.d.ts

@@ -0,0 +1 @@
+export function getJitterDelay( retry: number, minDelay?: number, base?: number ): number;

types/hand-crafted/modules/util/ScriptUtil.d.ts

@@ -0,0 +1 @@
+export function loadScript( src: string, async: boolean, prepend: boolean, relativeURL: boolean, loadCallback: ( ev: Event ) => void, errorCallback: ( event: string | Event, source?: string, lineno?: number, colno?: number, error?: Error ) => void ): void;

types/hand-crafted/modules/util/StringUtils.d.ts

@@ -0,0 +1 @@
+export function integerHash( string: string ): number;

types/hand-crafted/modules/util/TestUtils.d.ts

@@ -0,0 +1 @@
+declare const nextTick: ( advanceTimer?: number ) => Promise<void>;