@sudoplatform/sudo-secure-communications 0.0.1 → 5.0.1

package/vendor/matrix-js-sdk/lib/crypto-api.js

@@ -0,0 +1,491 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// node_modules/@babel/runtime/helpers/esm/typeof.js
+function _typeof(o) {
+  "@babel/helpers - typeof";
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
+    return typeof o2;
+  } : function(o2) {
+    return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
+  }, _typeof(o);
+}
+__name(_typeof, "_typeof");
+
+// node_modules/@babel/runtime/helpers/esm/toPrimitive.js
+function toPrimitive(t, r) {
+  if ("object" != _typeof(t) || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != _typeof(i)) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+__name(toPrimitive, "toPrimitive");
+
+// node_modules/@babel/runtime/helpers/esm/toPropertyKey.js
+function toPropertyKey(t) {
+  var i = toPrimitive(t, "string");
+  return "symbol" == _typeof(i) ? i : i + "";
+}
+__name(toPropertyKey, "toPropertyKey");
+
+// node_modules/@babel/runtime/helpers/esm/defineProperty.js
+function _defineProperty(e, r, t) {
+  return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  }) : e[r] = t, e;
+}
+__name(_defineProperty, "_defineProperty");
+
+// node_modules/matrix-js-sdk/lib/crypto-api/verification.js
+var VerificationRequestEvent = /* @__PURE__ */ (function(VerificationRequestEvent2) {
+  VerificationRequestEvent2["Change"] = "change";
+  return VerificationRequestEvent2;
+})({});
+var VerificationPhase = /* @__PURE__ */ (function(VerificationPhase2) {
+  VerificationPhase2[VerificationPhase2["Unsent"] = 1] = "Unsent";
+  VerificationPhase2[VerificationPhase2["Requested"] = 2] = "Requested";
+  VerificationPhase2[VerificationPhase2["Ready"] = 3] = "Ready";
+  VerificationPhase2[VerificationPhase2["Started"] = 4] = "Started";
+  VerificationPhase2[VerificationPhase2["Cancelled"] = 5] = "Cancelled";
+  VerificationPhase2[VerificationPhase2["Done"] = 6] = "Done";
+  return VerificationPhase2;
+})({});
+var VerifierEvent = /* @__PURE__ */ (function(VerifierEvent2) {
+  VerifierEvent2["Cancel"] = "cancel";
+  VerifierEvent2["ShowSas"] = "show_sas";
+  VerifierEvent2["ShowReciprocateQr"] = "show_reciprocate_qr";
+  return VerifierEvent2;
+})({});
+function canAcceptVerificationRequest(req) {
+  return req.phase < VerificationPhase.Ready && !req.accepting && !req.declining;
+}
+__name(canAcceptVerificationRequest, "canAcceptVerificationRequest");
+
+// node_modules/base-x/src/esm/index.js
+function base(ALPHABET2) {
+  if (ALPHABET2.length >= 255) {
+    throw new TypeError("Alphabet too long");
+  }
+  const BASE_MAP = new Uint8Array(256);
+  for (let j = 0; j < BASE_MAP.length; j++) {
+    BASE_MAP[j] = 255;
+  }
+  for (let i = 0; i < ALPHABET2.length; i++) {
+    const x = ALPHABET2.charAt(i);
+    const xc = x.charCodeAt(0);
+    if (BASE_MAP[xc] !== 255) {
+      throw new TypeError(x + " is ambiguous");
+    }
+    BASE_MAP[xc] = i;
+  }
+  const BASE = ALPHABET2.length;
+  const LEADER = ALPHABET2.charAt(0);
+  const FACTOR = Math.log(BASE) / Math.log(256);
+  const iFACTOR = Math.log(256) / Math.log(BASE);
+  function encode(source) {
+    if (source instanceof Uint8Array) {
+    } else if (ArrayBuffer.isView(source)) {
+      source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+    } else if (Array.isArray(source)) {
+      source = Uint8Array.from(source);
+    }
+    if (!(source instanceof Uint8Array)) {
+      throw new TypeError("Expected Uint8Array");
+    }
+    if (source.length === 0) {
+      return "";
+    }
+    let zeroes = 0;
+    let length = 0;
+    let pbegin = 0;
+    const pend = source.length;
+    while (pbegin !== pend && source[pbegin] === 0) {
+      pbegin++;
+      zeroes++;
+    }
+    const size = (pend - pbegin) * iFACTOR + 1 >>> 0;
+    const b58 = new Uint8Array(size);
+    while (pbegin !== pend) {
+      let carry = source[pbegin];
+      let i = 0;
+      for (let it1 = size - 1; (carry !== 0 || i < length) && it1 !== -1; it1--, i++) {
+        carry += 256 * b58[it1] >>> 0;
+        b58[it1] = carry % BASE >>> 0;
+        carry = carry / BASE >>> 0;
+      }
+      if (carry !== 0) {
+        throw new Error("Non-zero carry");
+      }
+      length = i;
+      pbegin++;
+    }
+    let it2 = size - length;
+    while (it2 !== size && b58[it2] === 0) {
+      it2++;
+    }
+    let str = LEADER.repeat(zeroes);
+    for (; it2 < size; ++it2) {
+      str += ALPHABET2.charAt(b58[it2]);
+    }
+    return str;
+  }
+  __name(encode, "encode");
+  function decodeUnsafe(source) {
+    if (typeof source !== "string") {
+      throw new TypeError("Expected String");
+    }
+    if (source.length === 0) {
+      return new Uint8Array();
+    }
+    let psz = 0;
+    let zeroes = 0;
+    let length = 0;
+    while (source[psz] === LEADER) {
+      zeroes++;
+      psz++;
+    }
+    const size = (source.length - psz) * FACTOR + 1 >>> 0;
+    const b256 = new Uint8Array(size);
+    while (psz < source.length) {
+      const charCode = source.charCodeAt(psz);
+      if (charCode > 255) {
+        return;
+      }
+      let carry = BASE_MAP[charCode];
+      if (carry === 255) {
+        return;
+      }
+      let i = 0;
+      for (let it3 = size - 1; (carry !== 0 || i < length) && it3 !== -1; it3--, i++) {
+        carry += BASE * b256[it3] >>> 0;
+        b256[it3] = carry % 256 >>> 0;
+        carry = carry / 256 >>> 0;
+      }
+      if (carry !== 0) {
+        throw new Error("Non-zero carry");
+      }
+      length = i;
+      psz++;
+    }
+    let it4 = size - length;
+    while (it4 !== size && b256[it4] === 0) {
+      it4++;
+    }
+    const vch = new Uint8Array(zeroes + (size - it4));
+    let j = zeroes;
+    while (it4 !== size) {
+      vch[j++] = b256[it4++];
+    }
+    return vch;
+  }
+  __name(decodeUnsafe, "decodeUnsafe");
+  function decode(string) {
+    const buffer = decodeUnsafe(string);
+    if (buffer) {
+      return buffer;
+    }
+    throw new Error("Non-base" + BASE + " character");
+  }
+  __name(decode, "decode");
+  return {
+    encode,
+    decodeUnsafe,
+    decode
+  };
+}
+__name(base, "base");
+var esm_default = base;
+
+// node_modules/bs58/src/esm/index.js
+var ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+var esm_default2 = esm_default(ALPHABET);
+
+// node_modules/matrix-js-sdk/lib/crypto-api/recovery-key.js
+var OLM_RECOVERY_KEY_PREFIX = [139, 1];
+var KEY_SIZE = 32;
+function encodeRecoveryKey(key) {
+  var _base58key$match;
+  var buf = new Uint8Array(OLM_RECOVERY_KEY_PREFIX.length + key.length + 1);
+  buf.set(OLM_RECOVERY_KEY_PREFIX, 0);
+  buf.set(key, OLM_RECOVERY_KEY_PREFIX.length);
+  var parity = 0;
+  for (var i = 0; i < buf.length - 1; ++i) {
+    parity ^= buf[i];
+  }
+  buf[buf.length - 1] = parity;
+  var base58key = esm_default2.encode(buf);
+  return (_base58key$match = base58key.match(/.{1,4}/g)) === null || _base58key$match === void 0 ? void 0 : _base58key$match.join(" ");
+}
+__name(encodeRecoveryKey, "encodeRecoveryKey");
+function decodeRecoveryKey(recoveryKey) {
+  var result = esm_default2.decode(recoveryKey.replace(/ /g, ""));
+  var parity = 0;
+  for (var b of result) {
+    parity ^= b;
+  }
+  if (parity !== 0) {
+    throw new Error("Incorrect parity");
+  }
+  for (var i = 0; i < OLM_RECOVERY_KEY_PREFIX.length; ++i) {
+    if (result[i] !== OLM_RECOVERY_KEY_PREFIX[i]) {
+      throw new Error("Incorrect prefix");
+    }
+  }
+  if (result.length !== OLM_RECOVERY_KEY_PREFIX.length + KEY_SIZE + 1) {
+    throw new Error("Incorrect length");
+  }
+  return Uint8Array.from(result.slice(OLM_RECOVERY_KEY_PREFIX.length, OLM_RECOVERY_KEY_PREFIX.length + KEY_SIZE));
+}
+__name(decodeRecoveryKey, "decodeRecoveryKey");
+
+// node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js
+function asyncGeneratorStep(n, t, e, r, o, a, c) {
+  try {
+    var i = n[a](c), u = i.value;
+  } catch (n2) {
+    return void e(n2);
+  }
+  i.done ? t(u) : Promise.resolve(u).then(r, o);
+}
+__name(asyncGeneratorStep, "asyncGeneratorStep");
+function _asyncToGenerator(n) {
+  return function() {
+    var t = this, e = arguments;
+    return new Promise(function(r, o) {
+      var a = n.apply(t, e);
+      function _next(n2) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "next", n2);
+      }
+      __name(_next, "_next");
+      function _throw(n2) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "throw", n2);
+      }
+      __name(_throw, "_throw");
+      _next(void 0);
+    });
+  };
+}
+__name(_asyncToGenerator, "_asyncToGenerator");
+
+// node_modules/matrix-js-sdk/lib/crypto-api/key-passphrase.js
+var DEFAULT_BIT_SIZE = 256;
+function deriveRecoveryKeyFromPassphrase(_x, _x2, _x3) {
+  return _deriveRecoveryKeyFromPassphrase.apply(this, arguments);
+}
+__name(deriveRecoveryKeyFromPassphrase, "deriveRecoveryKeyFromPassphrase");
+function _deriveRecoveryKeyFromPassphrase() {
+  _deriveRecoveryKeyFromPassphrase = _asyncToGenerator(function* (passphrase, salt, iterations) {
+    var numBits = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : DEFAULT_BIT_SIZE;
+    if (!globalThis.crypto.subtle || !TextEncoder) {
+      throw new Error("Password-based backup is not available on this platform");
+    }
+    var key = yield globalThis.crypto.subtle.importKey("raw", new TextEncoder().encode(passphrase), {
+      name: "PBKDF2"
+    }, false, ["deriveBits"]);
+    var keybits = yield globalThis.crypto.subtle.deriveBits({
+      name: "PBKDF2",
+      salt: new TextEncoder().encode(salt),
+      iterations,
+      hash: "SHA-512"
+    }, key, numBits);
+    return new Uint8Array(keybits);
+  });
+  return _deriveRecoveryKeyFromPassphrase.apply(this, arguments);
+}
+__name(_deriveRecoveryKeyFromPassphrase, "_deriveRecoveryKeyFromPassphrase");
+
+// node_modules/matrix-js-sdk/lib/crypto-api/CryptoEvent.js
+var CryptoEvent = /* @__PURE__ */ (function(CryptoEvent2) {
+  CryptoEvent2["UserTrustStatusChanged"] = "userTrustStatusChanged";
+  CryptoEvent2["KeyBackupStatus"] = "crypto.keyBackupStatus";
+  CryptoEvent2["KeyBackupFailed"] = "crypto.keyBackupFailed";
+  CryptoEvent2["KeyBackupSessionsRemaining"] = "crypto.keyBackupSessionsRemaining";
+  CryptoEvent2["KeyBackupDecryptionKeyCached"] = "crypto.keyBackupDecryptionKeyCached";
+  CryptoEvent2["VerificationRequestReceived"] = "crypto.verificationRequestReceived";
+  CryptoEvent2["WillUpdateDevices"] = "crypto.willUpdateDevices";
+  CryptoEvent2["DevicesUpdated"] = "crypto.devicesUpdated";
+  CryptoEvent2["KeysChanged"] = "crossSigning.keysChanged";
+  CryptoEvent2["LegacyCryptoStoreMigrationProgress"] = "crypto.legacyCryptoStoreMigrationProgress";
+  CryptoEvent2["DehydratedDeviceCreated"] = "dehydration.DehydratedDeviceCreated";
+  CryptoEvent2["DehydratedDeviceUploaded"] = "dehydration.DehydratedDeviceUploaded";
+  CryptoEvent2["RehydrationStarted"] = "dehydration.RehydrationStarted";
+  CryptoEvent2["RehydrationProgress"] = "dehydration.RehydrationProgress";
+  CryptoEvent2["RehydrationCompleted"] = "dehydration.RehydrationCompleted";
+  CryptoEvent2["RehydrationError"] = "dehydration.RehydrationError";
+  CryptoEvent2["DehydrationKeyCached"] = "dehydration.DehydrationKeyCached";
+  CryptoEvent2["DehydratedDeviceRotationError"] = "dehydration.DehydratedDeviceRotationError";
+  return CryptoEvent2;
+})({});
+
+// node_modules/matrix-js-sdk/lib/crypto-api/index.js
+var DecryptionFailureCode = /* @__PURE__ */ (function(DecryptionFailureCode2) {
+  DecryptionFailureCode2["MEGOLM_UNKNOWN_INBOUND_SESSION_ID"] = "MEGOLM_UNKNOWN_INBOUND_SESSION_ID";
+  DecryptionFailureCode2["MEGOLM_KEY_WITHHELD"] = "MEGOLM_KEY_WITHHELD";
+  DecryptionFailureCode2["MEGOLM_KEY_WITHHELD_FOR_UNVERIFIED_DEVICE"] = "MEGOLM_KEY_WITHHELD_FOR_UNVERIFIED_DEVICE";
+  DecryptionFailureCode2["OLM_UNKNOWN_MESSAGE_INDEX"] = "OLM_UNKNOWN_MESSAGE_INDEX";
+  DecryptionFailureCode2["HISTORICAL_MESSAGE_NO_KEY_BACKUP"] = "HISTORICAL_MESSAGE_NO_KEY_BACKUP";
+  DecryptionFailureCode2["HISTORICAL_MESSAGE_BACKUP_UNCONFIGURED"] = "HISTORICAL_MESSAGE_BACKUP_UNCONFIGURED";
+  DecryptionFailureCode2["HISTORICAL_MESSAGE_WORKING_BACKUP"] = "HISTORICAL_MESSAGE_WORKING_BACKUP";
+  DecryptionFailureCode2["HISTORICAL_MESSAGE_USER_NOT_JOINED"] = "HISTORICAL_MESSAGE_USER_NOT_JOINED";
+  DecryptionFailureCode2["SENDER_IDENTITY_PREVIOUSLY_VERIFIED"] = "SENDER_IDENTITY_PREVIOUSLY_VERIFIED";
+  DecryptionFailureCode2["UNSIGNED_SENDER_DEVICE"] = "UNSIGNED_SENDER_DEVICE";
+  DecryptionFailureCode2["UNKNOWN_SENDER_DEVICE"] = "UNKNOWN_SENDER_DEVICE";
+  DecryptionFailureCode2["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
+  return DecryptionFailureCode2;
+})({});
+var DeviceIsolationModeKind = /* @__PURE__ */ (function(DeviceIsolationModeKind2) {
+  DeviceIsolationModeKind2[DeviceIsolationModeKind2["AllDevicesIsolationMode"] = 0] = "AllDevicesIsolationMode";
+  DeviceIsolationModeKind2[DeviceIsolationModeKind2["OnlySignedDevicesIsolationMode"] = 1] = "OnlySignedDevicesIsolationMode";
+  return DeviceIsolationModeKind2;
+})({});
+var _AllDevicesIsolationMode = class _AllDevicesIsolationMode {
+  /**
+   *
+   * @param errorOnVerifiedUserProblems - Behavior when sharing keys to remote devices.
+   *
+   * If set to `true`, sharing keys will fail (i.e. message sending will fail) with an error if:
+   *   - The user was previously verified but is not anymore, or:
+   *   - A verified user has some unverified devices (not cross-signed).
+   *
+   * If `false`, the keys will be distributed as usual. In this case, the client UX should display
+   * warnings to inform the user about problematic devices/users, and stop them hitting this case.
+   */
+  constructor(errorOnVerifiedUserProblems) {
+    this.errorOnVerifiedUserProblems = errorOnVerifiedUserProblems;
+    _defineProperty(this, "kind", DeviceIsolationModeKind.AllDevicesIsolationMode);
+  }
+};
+__name(_AllDevicesIsolationMode, "AllDevicesIsolationMode");
+var AllDevicesIsolationMode = _AllDevicesIsolationMode;
+var _OnlySignedDevicesIsolationMode = class _OnlySignedDevicesIsolationMode {
+  constructor() {
+    _defineProperty(this, "kind", DeviceIsolationModeKind.OnlySignedDevicesIsolationMode);
+  }
+};
+__name(_OnlySignedDevicesIsolationMode, "OnlySignedDevicesIsolationMode");
+var OnlySignedDevicesIsolationMode = _OnlySignedDevicesIsolationMode;
+var _UserVerificationStatus = class _UserVerificationStatus {
+  constructor(crossSigningVerified, crossSigningVerifiedBefore, tofu) {
+    var needsUserApproval = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : false;
+    this.crossSigningVerified = crossSigningVerified;
+    this.crossSigningVerifiedBefore = crossSigningVerifiedBefore;
+    this.tofu = tofu;
+    _defineProperty(this, "needsUserApproval", void 0);
+    this.needsUserApproval = needsUserApproval;
+  }
+  /**
+   * @returns true if this user is verified via any means
+   */
+  isVerified() {
+    return this.isCrossSigningVerified();
+  }
+  /**
+   * @returns true if this user is verified via cross signing
+   */
+  isCrossSigningVerified() {
+    return this.crossSigningVerified;
+  }
+  /**
+   * @returns true if we ever verified this user before (at least for
+   * the history of verifications observed by this device).
+   */
+  wasCrossSigningVerified() {
+    return this.crossSigningVerifiedBefore;
+  }
+  /**
+   * @returns true if this user's key is trusted on first use
+   *
+   * @deprecated No longer supported, with the Rust crypto stack.
+   */
+  isTofu() {
+    return this.tofu;
+  }
+};
+__name(_UserVerificationStatus, "UserVerificationStatus");
+var UserVerificationStatus = _UserVerificationStatus;
+var _DeviceVerificationStatus = class _DeviceVerificationStatus {
+  constructor(opts) {
+    var _opts$signedByOwner, _opts$crossSigningVer, _opts$tofu, _opts$localVerified, _opts$trustCrossSigne;
+    _defineProperty(this, "signedByOwner", void 0);
+    _defineProperty(this, "crossSigningVerified", void 0);
+    _defineProperty(this, "tofu", void 0);
+    _defineProperty(this, "localVerified", void 0);
+    _defineProperty(this, "trustCrossSignedDevices", void 0);
+    this.signedByOwner = (_opts$signedByOwner = opts.signedByOwner) !== null && _opts$signedByOwner !== void 0 ? _opts$signedByOwner : false;
+    this.crossSigningVerified = (_opts$crossSigningVer = opts.crossSigningVerified) !== null && _opts$crossSigningVer !== void 0 ? _opts$crossSigningVer : false;
+    this.tofu = (_opts$tofu = opts.tofu) !== null && _opts$tofu !== void 0 ? _opts$tofu : false;
+    this.localVerified = (_opts$localVerified = opts.localVerified) !== null && _opts$localVerified !== void 0 ? _opts$localVerified : false;
+    this.trustCrossSignedDevices = (_opts$trustCrossSigne = opts.trustCrossSignedDevices) !== null && _opts$trustCrossSigne !== void 0 ? _opts$trustCrossSigne : false;
+  }
+  /**
+   * Check if we should consider this device "verified".
+   *
+   * A device is "verified" if either:
+   *  * it has been manually marked as such via {@link CryptoApi.setDeviceVerified}.
+   *  * it has been cross-signed with a verified signing key, **and** the client has been configured to trust
+   *    cross-signed devices via {@link CryptoApi.setTrustCrossSignedDevices}.
+   *
+   * @returns true if this device is verified via any means.
+   */
+  isVerified() {
+    return this.localVerified || this.trustCrossSignedDevices && this.crossSigningVerified;
+  }
+};
+__name(_DeviceVerificationStatus, "DeviceVerificationStatus");
+var DeviceVerificationStatus = _DeviceVerificationStatus;
+var ImportRoomKeyStage = /* @__PURE__ */ (function(ImportRoomKeyStage2) {
+  ImportRoomKeyStage2["Fetch"] = "fetch";
+  ImportRoomKeyStage2["LoadKeys"] = "load_keys";
+  return ImportRoomKeyStage2;
+})({});
+var CrossSigningKey = /* @__PURE__ */ (function(CrossSigningKey2) {
+  CrossSigningKey2["Master"] = "master";
+  CrossSigningKey2["SelfSigning"] = "self_signing";
+  CrossSigningKey2["UserSigning"] = "user_signing";
+  return CrossSigningKey2;
+})({});
+var EventShieldColour = /* @__PURE__ */ (function(EventShieldColour2) {
+  EventShieldColour2[EventShieldColour2["NONE"] = 0] = "NONE";
+  EventShieldColour2[EventShieldColour2["GREY"] = 1] = "GREY";
+  EventShieldColour2[EventShieldColour2["RED"] = 2] = "RED";
+  return EventShieldColour2;
+})({});
+var EventShieldReason = /* @__PURE__ */ (function(EventShieldReason2) {
+  EventShieldReason2[EventShieldReason2["UNKNOWN"] = 0] = "UNKNOWN";
+  EventShieldReason2[EventShieldReason2["UNVERIFIED_IDENTITY"] = 1] = "UNVERIFIED_IDENTITY";
+  EventShieldReason2[EventShieldReason2["UNSIGNED_DEVICE"] = 2] = "UNSIGNED_DEVICE";
+  EventShieldReason2[EventShieldReason2["UNKNOWN_DEVICE"] = 3] = "UNKNOWN_DEVICE";
+  EventShieldReason2[EventShieldReason2["AUTHENTICITY_NOT_GUARANTEED"] = 4] = "AUTHENTICITY_NOT_GUARANTEED";
+  EventShieldReason2[EventShieldReason2["MISMATCHED_SENDER_KEY"] = 5] = "MISMATCHED_SENDER_KEY";
+  EventShieldReason2[EventShieldReason2["SENT_IN_CLEAR"] = 6] = "SENT_IN_CLEAR";
+  EventShieldReason2[EventShieldReason2["VERIFICATION_VIOLATION"] = 7] = "VERIFICATION_VIOLATION";
+  EventShieldReason2[EventShieldReason2["MISMATCHED_SENDER"] = 8] = "MISMATCHED_SENDER";
+  return EventShieldReason2;
+})({});
+export {
+  AllDevicesIsolationMode,
+  CrossSigningKey,
+  CryptoEvent,
+  DecryptionFailureCode,
+  DeviceIsolationModeKind,
+  DeviceVerificationStatus,
+  EventShieldColour,
+  EventShieldReason,
+  ImportRoomKeyStage,
+  OnlySignedDevicesIsolationMode,
+  UserVerificationStatus,
+  VerificationPhase,
+  VerificationRequestEvent,
+  VerifierEvent,
+  canAcceptVerificationRequest,
+  decodeRecoveryKey,
+  deriveRecoveryKeyFromPassphrase,
+  encodeRecoveryKey
+};