@wireapp/core-crypto/src/corecrypto.js

CoreCrypto bindings for the Web

var __create = Object.create;
var __getProtoOf = Object.getPrototypeOf;
var __defProp = Object.defineProperty;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __toESM = (mod, isNodeMode, target) => {
  target = mod != null ? __create(__getProtoOf(mod)) : {};
  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
  for (let key of __getOwnPropNames(mod))
    if (!__hasOwnProp.call(to, key))
      __defProp(to, key, {
        get: () => mod[key],
        enumerable: true
      });
  return to;
};
var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
}) : x)(function(x) {
  if (typeof require !== "undefined")
    return require.apply(this, arguments);
  throw Error('Dynamic require of "' + x + '" is not supported');
});

// src/Ciphersuite.ts
var Ciphersuite;
((Ciphersuite2) => {
  Ciphersuite2[Ciphersuite2["MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519"] = 1] = "MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519";
  Ciphersuite2[Ciphersuite2["MLS_128_DHKEMP256_AES128GCM_SHA256_P256"] = 2] = "MLS_128_DHKEMP256_AES128GCM_SHA256_P256";
  Ciphersuite2[Ciphersuite2["MLS_128_DHKEMX25519_CHACHA20POLY1305_SHA256_Ed25519"] = 3] = "MLS_128_DHKEMX25519_CHACHA20POLY1305_SHA256_Ed25519";
  Ciphersuite2[Ciphersuite2["MLS_256_DHKEMX448_AES256GCM_SHA512_Ed448"] = 4] = "MLS_256_DHKEMX448_AES256GCM_SHA512_Ed448";
  Ciphersuite2[Ciphersuite2["MLS_256_DHKEMP521_AES256GCM_SHA512_P521"] = 5] = "MLS_256_DHKEMP521_AES256GCM_SHA512_P521";
  Ciphersuite2[Ciphersuite2["MLS_256_DHKEMX448_CHACHA20POLY1305_SHA512_Ed448"] = 6] = "MLS_256_DHKEMX448_CHACHA20POLY1305_SHA512_Ed448";
  Ciphersuite2[Ciphersuite2["MLS_256_DHKEMP384_AES256GCM_SHA384_P384"] = 7] = "MLS_256_DHKEMP384_AES256GCM_SHA384_P384";
})(Ciphersuite ||= {});
// src/CoreCryptoError.ts
class CoreCryptoError extends Error {
  errorStack;
  proteusErrorCode;
  constructor(richError, ...params) {
    super(richError.message, ...params);
    Object.setPrototypeOf(this, new.target.prototype);
    if (richError.error_name) {
      this.name = richError.error_name;
    }
    if (richError.error_stack) {
      this.errorStack = richError.error_stack;
    } else {
      this.errorStack = [];
    }
    if (richError.proteus_error_code) {
      this.proteusErrorCode = richError.proteus_error_code;
    } else {
      this.proteusErrorCode = null;
    }
  }
  static fallback(msg, ...params) {
    console.warn(`Cannot build CoreCryptoError, falling back to standard Error! ctx: ${msg}`);
    return new Error(msg, ...params);
  }
  static build(msg, ...params) {
    try {
      const richError = JSON.parse(msg);
      return new this(richError, ...params);
    } catch {
      return this.fallback(msg, ...params);
    }
  }
  static fromStdError(e) {
    if (e instanceof CoreCryptoError) {
      return e;
    }
    const opts = {
      cause: e.cause || undefined,
      stack: e.stack || undefined
    };
    return this.build(e.message, opts);
  }
  static async asyncMapErr(p) {
    const mappedErrorPromise = p.catch((e) => {
      if (e instanceof CoreCryptoError) {
        throw e;
      } else {
        throw this.fromStdError(e);
      }
    });
    return await mappedErrorPromise;
  }
}
// src/core-crypto-ffi.js
var wasm;
var WASM_VECTOR_LEN = 0;
var cachedUint8ArrayMemory0 = null;
function getUint8ArrayMemory0() {
  if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
    cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
  }
  return cachedUint8ArrayMemory0;
}
var cachedTextEncoder = typeof TextEncoder !== "undefined" ? new TextEncoder("utf-8") : { encode: () => {
  throw Error("TextEncoder not available");
} };
var encodeString = typeof cachedTextEncoder.encodeInto === "function" ? function(arg, view) {
  return cachedTextEncoder.encodeInto(arg, view);
} : function(arg, view) {
  const buf = cachedTextEncoder.encode(arg);
  view.set(buf);
  return {
    read: arg.length,
    written: buf.length
  };
};
function passStringToWasm0(arg, malloc, realloc) {
  if (realloc === undefined) {
    const buf = cachedTextEncoder.encode(arg);
    const ptr2 = malloc(buf.length, 1) >>> 0;
    getUint8ArrayMemory0().subarray(ptr2, ptr2 + buf.length).set(buf);
    WASM_VECTOR_LEN = buf.length;
    return ptr2;
  }
  let len = arg.length;
  let ptr = malloc(len, 1) >>> 0;
  const mem = getUint8ArrayMemory0();
  let offset = 0;
  for (;offset < len; offset++) {
    const code = arg.charCodeAt(offset);
    if (code > 127)
      break;
    mem[ptr + offset] = code;
  }
  if (offset !== len) {
    if (offset !== 0) {
      arg = arg.slice(offset);
    }
    ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
    const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
    const ret = encodeString(arg, view);
    offset += ret.written;
    ptr = realloc(ptr, len, offset, 1) >>> 0;
  }
  WASM_VECTOR_LEN = offset;
  return ptr;
}
var cachedDataViewMemory0 = null;
function getDataViewMemory0() {
  if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer) {
    cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
  }
  return cachedDataViewMemory0;
}
function addToExternrefTable0(obj) {
  const idx = wasm.__externref_table_alloc();
  wasm.__wbindgen_export_4.set(idx, obj);
  return idx;
}
function handleError(f, args) {
  try {
    return f.apply(this, args);
  } catch (e) {
    const idx = addToExternrefTable0(e);
    wasm.__wbindgen_exn_store(idx);
  }
}
var cachedTextDecoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf-8", { ignoreBOM: true, fatal: true }) : { decode: () => {
  throw Error("TextDecoder not available");
} };
if (typeof TextDecoder !== "undefined") {
  cachedTextDecoder.decode();
}
function getStringFromWasm0(ptr, len) {
  ptr = ptr >>> 0;
  return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
}
function isLikeNone(x) {
  return x === undefined || x === null;
}
function getArrayU8FromWasm0(ptr, len) {
  ptr = ptr >>> 0;
  return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
}
var CLOSURE_DTORS = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry((state) => {
  wasm.__wbindgen_export_6.get(state.dtor)(state.a, state.b);
});
function makeMutClosure(arg0, arg1, dtor, f) {
  const state = { a: arg0, b: arg1, cnt: 1, dtor };
  const real = (...args) => {
    state.cnt++;
    const a = state.a;
    state.a = 0;
    try {
      return f(a, state.b, ...args);
    } finally {
      if (--state.cnt === 0) {
        wasm.__wbindgen_export_6.get(state.dtor)(a, state.b);
        CLOSURE_DTORS.unregister(state);
      } else {
        state.a = a;
      }
    }
  };
  real.original = state;
  CLOSURE_DTORS.register(real, state, state);
  return real;
}
function debugString(val) {
  const type = typeof val;
  if (type == "number" || type == "boolean" || val == null) {
    return `${val}`;
  }
  if (type == "string") {
    return `"${val}"`;
  }
  if (type == "symbol") {
    const description = val.description;
    if (description == null) {
      return "Symbol";
    } else {
      return `Symbol(${description})`;
    }
  }
  if (type == "function") {
    const name = val.name;
    if (typeof name == "string" && name.length > 0) {
      return `Function(${name})`;
    } else {
      return "Function";
    }
  }
  if (Array.isArray(val)) {
    const length = val.length;
    let debug = "[";
    if (length > 0) {
      debug += debugString(val[0]);
    }
    for (let i = 1;i < length; i++) {
      debug += ", " + debugString(val[i]);
    }
    debug += "]";
    return debug;
  }
  const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
  let className;
  if (builtInMatches && builtInMatches.length > 1) {
    className = builtInMatches[1];
  } else {
    return toString.call(val);
  }
  if (className == "Object") {
    try {
      return "Object(" + JSON.stringify(val) + ")";
    } catch (_) {
      return "Object";
    }
  }
  if (val instanceof Error) {
    return `${val.name}: ${val.message}
${val.stack}`;
  }
  return className;
}
function passArray8ToWasm0(arg, malloc) {
  const ptr = malloc(arg.length * 1, 1) >>> 0;
  getUint8ArrayMemory0().set(arg, ptr / 1);
  WASM_VECTOR_LEN = arg.length;
  return ptr;
}
function _assertClass(instance, klass) {
  if (!(instance instanceof klass)) {
    throw new Error(`expected instance of ${klass.name}`);
  }
}
function getArrayJsValueFromWasm0(ptr, len) {
  ptr = ptr >>> 0;
  const mem = getDataViewMemory0();
  const result = [];
  for (let i = ptr;i < ptr + 4 * len; i += 4) {
    result.push(wasm.__wbindgen_export_4.get(mem.getUint32(i, true)));
  }
  wasm.__externref_drop_slice(ptr, len);
  return result;
}
function takeFromExternrefTable0(idx) {
  const value = wasm.__wbindgen_export_4.get(idx);
  wasm.__externref_table_dealloc(idx);
  return value;
}
var cachedUint16ArrayMemory0 = null;
function getUint16ArrayMemory0() {
  if (cachedUint16ArrayMemory0 === null || cachedUint16ArrayMemory0.byteLength === 0) {
    cachedUint16ArrayMemory0 = new Uint16Array(wasm.memory.buffer);
  }
  return cachedUint16ArrayMemory0;
}
function passArray16ToWasm0(arg, malloc) {
  const ptr = malloc(arg.length * 2, 2) >>> 0;
  getUint16ArrayMemory0().set(arg, ptr / 2);
  WASM_VECTOR_LEN = arg.length;
  return ptr;
}
function passArrayJsValueToWasm0(array, malloc) {
  const ptr = malloc(array.length * 4, 4) >>> 0;
  for (let i = 0;i < array.length; i++) {
    const add = addToExternrefTable0(array[i]);
    getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
  }
  WASM_VECTOR_LEN = array.length;
  return ptr;
}
function migrateDatabaseKeyTypeToBytes(name, old_key, new_key) {
  const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
  const len0 = WASM_VECTOR_LEN;
  const ptr1 = passStringToWasm0(old_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
  const len1 = WASM_VECTOR_LEN;
  _assertClass(new_key, DatabaseKey);
  const ret = wasm.migrateDatabaseKeyTypeToBytes(ptr0, len0, ptr1, len1, new_key.__wbg_ptr);
  return ret;
}
function version() {
  let deferred1_0;
  let deferred1_1;
  try {
    const ret = wasm.version();
    deferred1_0 = ret[0];
    deferred1_1 = ret[1];
    return getStringFromWasm0(ret[0], ret[1]);
  } finally {
    wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
  }
}
function build_metadata() {
  const ret = wasm.build_metadata();
  return BuildMetadata.__wrap(ret);
}
function __wbg_adapter_60(arg0, arg1, arg2) {
  wasm.closure971_externref_shim(arg0, arg1, arg2);
}
function __wbg_adapter_63(arg0, arg1, arg2) {
  wasm.closure2664_externref_shim(arg0, arg1, arg2);
}
function __wbg_adapter_66(arg0, arg1, arg2) {
  wasm.closure2864_externref_shim(arg0, arg1, arg2);
}
function __wbg_adapter_555(arg0, arg1, arg2, arg3) {
  wasm.closure2959_externref_shim(arg0, arg1, arg2, arg3);
}
var CoreCryptoLogLevel = Object.freeze({
  Off: 1,
  "1": "Off",
  Trace: 2,
  "2": "Trace",
  Debug: 3,
  "3": "Debug",
  Info: 4,
  "4": "Info",
  Warn: 5,
  "5": "Warn",
  Error: 6,
  "6": "Error"
});
var CredentialType = Object.freeze({
  Basic: 1,
  "1": "Basic",
  X509: 2,
  "2": "X509"
});
var DeviceStatus = Object.freeze({
  Valid: 1,
  "1": "Valid",
  Expired: 2,
  "2": "Expired",
  Revoked: 3,
  "3": "Revoked"
});
var E2eiConversationState = Object.freeze({
  Verified: 1,
  "1": "Verified",
  NotVerified: 2,
  "2": "NotVerified",
  NotEnabled: 3,
  "3": "NotEnabled"
});
var MlsGroupInfoEncryptionType = Object.freeze({
  Plaintext: 1,
  "1": "Plaintext",
  JweEncrypted: 2,
  "2": "JweEncrypted"
});
var MlsRatchetTreeType = Object.freeze({
  Full: 1,
  "1": "Full",
  Delta: 2,
  "2": "Delta",
  ByRef: 3,
  "3": "ByRef"
});
var MlsTransportResponseVariant = Object.freeze({
  Success: 1,
  "1": "Success",
  Retry: 2,
  "2": "Retry",
  Abort: 3,
  "3": "Abort"
});
var WirePolicy = Object.freeze({
  Plaintext: 1,
  "1": "Plaintext",
  Ciphertext: 2,
  "2": "Ciphertext"
});
var __wbindgen_enum_IdbCursorDirection = ["next", "nextunique", "prev", "prevunique"];
var __wbindgen_enum_IdbTransactionMode = ["readonly", "readwrite", "versionchange", "readwriteflush", "cleanup"];
var AcmeChallengeFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry((ptr) => wasm.__wbg_acmechallenge_free(ptr >>> 0, 1));

class AcmeChallenge {
  static __wrap(ptr) {
    ptr = ptr >>> 0;
    const obj = Object.create(AcmeChallenge.prototype);
    obj.__wbg_ptr = ptr;
    AcmeChallengeFinalization.register(obj, obj.__wbg_ptr, obj);
    return obj;
  }
  __destroy_into_raw() {
    const ptr = this.__wbg_ptr;
    this.__wbg_ptr = 0;
    AcmeChallengeFinalization.unregister(this);
    return ptr;
  }
  free() {
    const ptr = this.__destroy_into_raw();
    wasm.__wbg_acmechallenge_free(ptr, 0);
  }
  get delegate() {
    const ret = wasm.__wbg_get_acmechallenge_delegate(this.__wbg_ptr);
    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
    return v1;
  }
  get url() {
    let deferred1_0;
    let deferred1_1;
    try {
      const ret = wasm.__wbg_get_acmechallenge_url(this.__wbg_ptr);
      deferred1_0 = ret[0];
      deferred1_1 = ret[1];
      return getStringFromWasm0(ret[0], ret[1]);
    } finally {
      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
    }
  }
  get target() {
    let deferred1_0;
    let deferred1_1;
    try {
      const ret = wasm.__wbg_get_acmechallenge_target(this.__wbg_ptr);
      deferred1_0 = ret[0];
      deferred1_1 = ret[1];
      return getStringFromWasm0(ret[0], ret[1]);
    } finally {
      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
    }
  }
}
var AcmeDirectoryFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry((ptr) => wasm.__wbg_acmedirectory_free(ptr >>> 0, 1));

class AcmeDirectory {
  static __wrap(ptr) {
    ptr = ptr >>> 0;
    const obj = Object.create(AcmeDirectory.prototype);
    obj.__wbg_ptr = ptr;
    AcmeDirectoryFinalization.register(obj, obj.__wbg_ptr, obj);
    return obj;
  }
  __destroy_into_raw() {
    const ptr = this.__wbg_ptr;
    this.__wbg_ptr = 0;
    AcmeDirectoryFinalization.unregister(this);
    return ptr;
  }
  free() {
    const ptr = this.__destroy_into_raw();
    wasm.__wbg_acmedirectory_free(ptr, 0);
  }
  get newNonce() {
    let deferred1_0;
    let deferred1_1;
    try {
      const ret = wasm.__wbg_get_acmedirectory_newNonce(this.__wbg_ptr);
      deferred1_0 = ret[0];
      deferred1_1 = ret[1];
      return getStringFromWasm0(ret[0], ret[1]);
    } finally {
      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
    }
  }
  get newAccount() {
    let deferred1_0;
    let deferred1_1;
    try {
      const ret = wasm.__wbg_get_acmedirectory_newAccount(this.__wbg_ptr);
      deferred1_0 = ret[0];
      deferred1_1 = ret[1];
      return getStringFromWasm0(ret[0], ret[1]);
    } finally {
      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
    }
  }
  get newOrder() {
    let deferred1_0;
    let deferred1_1;
    try {
      const ret = wasm.__wbg_get_acmedirectory_newOrder(this.__wbg_ptr);
      deferred1_0 = ret[0];
      deferred1_1 = ret[1];
      return getStringFromWasm0(ret[0], ret[1]);
    } finally {
      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
    }
  }
  get revokeCert() {
    let deferred1_0;
    let deferred1_1;
    try {
      const ret = wasm.__wbg_get_acmedirectory_revokeCert(this.__wbg_ptr);
      deferred1_0 = ret[0];
      deferred1_1 = ret[1];
      return getStringFromWasm0(ret[0], ret[1]);
    } finally {
      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
    }
  }
}
var ArrayOfByteArrayFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry((ptr) => wasm.__wbg_arrayofbytearray_free(ptr >>> 0, 1));

class ArrayOfByteArray {
  static __wrap(ptr) {
    ptr = ptr >>> 0;
    const obj = Object.create(ArrayOfByteArray.prototype);
    obj.__wbg_ptr = ptr;
    ArrayOfByteArrayFinalization.register(obj, obj.__wbg_ptr, obj);
    return obj;
  }
  __destroy_into_raw() {
    const ptr = this.__wbg_ptr;
    this.__wbg_ptr = 0;
    ArrayOfByteArrayFinalization.unregister(this);
    return ptr;
  }
  free() {
    const ptr = this.__destroy_into_raw();
    wasm.__wbg_arrayofbytearray_free(ptr, 0);
  }
  constructor(aoba) {
    const ptr0 = passArrayJsValueToWasm0(aoba, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.arrayofbytearray_new(ptr0, len0);
    this.__wbg_ptr = ret >>> 0;
    ArrayOfByteArrayFinalization.register(this, this.__wbg_ptr, this);
    return this;
  }
  as_arrays() {
    const ret = wasm.arrayofbytearray_as_arrays(this.__wbg_ptr);
    var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
    return v1;
  }
}
var BufferedDecryptedMessageFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry((ptr) => wasm.__wbg_buffereddecryptedmessage_free(ptr >>> 0, 1));

class BufferedDecryptedMessage {
  static __wrap(ptr) {
    ptr = ptr >>> 0;
    const obj = Object.create(BufferedDecryptedMessage.prototype);
    obj.__wbg_ptr = ptr;
    BufferedDecryptedMessageFinalization.register(obj, obj.__wbg_ptr, obj);
    return obj;
  }
  __destroy_into_raw() {
    const ptr = this.__wbg_ptr;
    this.__wbg_ptr = 0;
    BufferedDecryptedMessageFinalization.unregister(this);
    return ptr;
  }
  free() {
    const ptr = this.__destroy_into_raw();
    wasm.__wbg_buffereddecryptedmessage_free(ptr, 0);
  }
  get message() {
    const ret = wasm.__wbg_get_buffereddecryptedmessage_message(this.__wbg_ptr);
    let v1;
    if (ret[0] !== 0) {
      v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
      wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
    }
    return v1;
  }
  get isActive() {
    const ret = wasm.__wbg_get_buffereddecryptedmessage_isActive(this.__wbg_ptr);
    return ret !== 0;
  }
  get commitDelay() {
    const ret = wasm.__wbg_get_buffereddecryptedmessage_commitDelay(this.__wbg_ptr);
    return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
  }
  get senderClientId() {
    const ret = wasm.__wbg_get_buffereddecryptedmessage_senderClientId(this.__wbg_ptr);
    return ret === 0 ? undefined : ClientId.__wrap(ret);
  }
  get hasEpochChanged() {
    const ret = wasm.__wbg_get_buffereddecryptedmessage_hasEpochChanged(this.__wbg_ptr);
    return ret !== 0;
  }
  get identity() {
    const ret = wasm.__wbg_get_buffereddecryptedmessage_identity(this.__wbg_ptr);
    return WireIdentity.__wrap(ret);
  }
  get crlNewDistributionPoints() {
    const ret = wasm.__wbg_get_buffereddecryptedmessage_crlNewDistributionPoints(this.__wbg_ptr);
    return NewCrlDistributionPoints.__wrap(ret);
  }
}
var BuildMetadataFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry((ptr) => wasm.__wbg_buildmetadata_free(ptr >>> 0, 1));

class BuildMetadata {
  static __wrap(ptr) {
    ptr = ptr >>> 0;
    const obj = Object.create(BuildMetadata.prototype);
    obj.__wbg_ptr = ptr;
    BuildMetadataFinalization.register(obj, obj.__wbg_ptr, obj);
    return obj;
  }
  toJSON() {
    return {
      timestamp: this.timestamp,
      cargoDebug: this.cargoDebug,
      cargoFeatures: this.cargoFeatures,
      optLevel: this.optLevel,
      targetTriple: this.targetTriple,
      gitBranch: this.gitBranch,
      gitDescribe: this.gitDescribe,
      gitSha: this.gitSha,
      gitDirty: this.gitDirty
    };
  }
  toString() {
    return JSON.stringify(this);
  }
  __destroy_into_raw() {
    const ptr = this.__wbg_ptr;
    this.__wbg_ptr = 0;
    BuildMetadataFinalization.unregister(this);
    return ptr;
  }
  free() {
    const ptr = this.__destroy_into_raw();
    wasm.__wbg_buildmetadata_free(ptr, 0);
  }
  get timestamp() {
    const ret = wasm.__wbg_get_buildmetadata_timestamp(this.__wbg_ptr);
    return getStringFromWasm0(ret[0], ret[1]);
  }
  get cargoDebug() {
    const ret = wasm.__wbg_get_buildmetadata_cargoDebug(this.__wbg_ptr);
    return getStringFromWasm0(ret[0], ret[1]);
  }
  get cargoFeatures() {
    const ret = wasm.__wbg_get_buildmetadata_cargoFeatures(this.__wbg_ptr);
    return getStringFromWasm0(ret[0], ret[1]);
  }
  get optLevel() {
    const ret = wasm.__wbg_get_buildmetadata_optLevel(this.__wbg_ptr);
    return getStringFromWasm0(ret[0], ret[1]);
  }
  get targetTriple() {
    const ret = wasm.__wbg_get_buildmetadata_targetTriple(this.__wbg_ptr);
    return getStringFromWasm0(ret[0], ret[1]);
  }
  get gitBranch() {
    const ret = wasm.__wbg_get_buildmetadata_gitBranch(this.__wbg_ptr);
    return getStringFromWasm0(ret[0], ret[1]);
  }
  get gitDescribe() {
    const ret = wasm.__wbg_get_buildmetadata_gitDescribe(this.__wbg_ptr);
    return getStringFromWasm0(ret[0], ret[1]);
  }
  get gitSha() {
    const ret = wasm.__wbg_get_buildmetadata_gitSha(this.__wbg_ptr);
    return getStringFromWasm0(ret[0], ret[1]);
  }
  get gitDirty() {
    const ret = wasm.__wbg_get_buildmetadata_gitDirty(this.__wbg_ptr);
    return getStringFromWasm0(ret[0], ret[1]);
  }
}
var CiphersuiteFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry((ptr) => wasm.__wbg_ciphersuite_free(ptr >>> 0, 1));

class Ciphersuite2 {
  static __wrap(ptr) {
    ptr = ptr >>> 0;
    const obj = Object.create(Ciphersuite2.prototype);
    obj.__wbg_ptr = ptr;
    CiphersuiteFinalization.register(obj, obj.__wbg_ptr, obj);
    return obj;
  }
  __destroy_into_raw() {
    const ptr = this.__wbg_ptr;
    this.__wbg_ptr = 0;
    CiphersuiteFinalization.unregister(this);
    return ptr;
  }
  free() {
    const ptr = this.__destroy_into_raw();
    wasm.__wbg_ciphersuite_free(ptr, 0);
  }
  as_u16() {
    const ret = wasm.ciphersuite_as_u16(this.__wbg_ptr);
    return ret;
  }
  constructor(discriminant) {
    const ret = wasm.ciphersuite_new(discriminant);
    if (ret[2]) {
      throw takeFromExternrefTable0(ret[1]);
    }
    this.__wbg_ptr = ret[0] >>> 0;
    CiphersuiteFinalization.register(this, this.__wbg_ptr, this);
    return this;
  }
}
var CiphersuitesFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry((ptr) => wasm.__wbg_ciphersuites_free(ptr >>> 0, 1));

class Ciphersuites {
  __destroy_into_raw() {
    const ptr = this.__wbg_ptr;
    this.__wbg_ptr = 0;
    CiphersuitesFinalization.unregister(this);
    return ptr;
  }
  free() {
    const ptr = this.__destroy_into_raw();
    wasm.__wbg_ciphersuites_free(ptr, 0);
  }
  constructor(ids) {
    const ptr0 = passArray16ToWasm0(ids, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.ciphersuites_from_u16s(ptr0, len0);
    if (ret[2]) {
      throw takeFromExternrefTable0(ret[1]);
    }
    this.__wbg_ptr = ret[0] >>> 0;
    CiphersuitesFinalization.register(this, this.__wbg_ptr, this);
    return this;
  }
}
var ClientIdFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry((ptr) => wasm.__wbg_clientid_free(ptr >>> 0, 1));

class ClientId {
  static __wrap(ptr) {
    ptr = ptr >>> 0;
    const obj = Object.create(ClientId.prototype);
    obj.__wbg_ptr = ptr;
    ClientIdFinalization.register(obj, obj.__wbg_ptr, obj);
    return obj;
  }
  static __unwrap(jsValue) {
    if (!(jsValue instanceof ClientId)) {
      return 0;
    }
    return jsValue.__destroy_into_raw();
  }
  __destroy_into_raw() {
    const ptr = this.__wbg_ptr;
    this.__wbg_ptr = 0;
    ClientIdFinalization.unregister(this);
    return ptr;
  }
  free() {
    const ptr = this.__destroy_into_raw();
    wasm.__wbg_clientid_free(ptr, 0);
  }
  constructor(bytes) {
    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.clientid_new(ptr0, len0);
    this.__wbg_ptr = ret >>> 0;
    ClientIdFinalization.register(this, this.__wbg_ptr, this);
    return this;
  }
  as_bytes() {
    const ret = wasm.clientid_as_bytes(this.__wbg_ptr);
    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
    return v1;
  }
}
var CommitBundleFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry((ptr) => wasm.__wbg_commitbundle_free(ptr >>> 0, 1));

class CommitBundle {
  static __wrap(ptr) {
    ptr = ptr >>> 0;
    const obj = Object.create(CommitBundle.prototype);
    obj.__wbg_ptr = ptr;
    CommitBundleFinalization.register(obj, obj.__wbg_ptr, obj);
    return obj;
  }
  __destroy_into_raw() {
    const ptr = this.__wbg_ptr;
    this.__wbg_ptr = 0;
    CommitBundleFinalization.unregister(this);
    return ptr;
  }
  free() {
    const ptr = this.__destroy_into_raw();
    wasm.__wbg_commitbundle_free(ptr, 0);
  }
  get welcome() {
    const ret = wasm.__wbg_get_commitbundle_welcome(this.__wbg_ptr);
    let v1;
    if (ret[0] !== 0) {
      v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
      wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
    }
    return v1;
  }
  set welcome(arg0) {
    var ptr0 = isLikeNone(arg0) ? 0 : passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
    var len0 = WASM_VECTOR_LEN;
    wasm.__wbg_set_commitbundle_welcome(this.__wbg_ptr, ptr0, len0);
  }
  get commit() {
    const ret = wasm.__wbg_get_commitbundle_commit(this.__wbg_ptr);
    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
    return v1;
  }
  set commit(arg0) {
    const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    wasm.__wbg_set_commitbundle_commit(this.__wbg_ptr, ptr0, len0);
  }
  get group_info() {
    const ret = wasm.__wbg_get_commitbundle_group_info(this.__wbg_ptr);
    return GroupInfoBundle.__wrap(ret);
  }
  set group_info(arg0) {
    _assertClass(arg0, GroupInfoBundle);
    var ptr0 = arg0.__destroy_into_raw();
    wasm.__wbg_set_commitbundle_group_info(this.__wbg_ptr, ptr0);
  }
}
var ConversationConfigurationFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry((ptr) => wasm.__wbg_conversationconfiguration_free(ptr >>> 0, 1));

class ConversationConfiguration {
  __destroy_into_raw() {
    const ptr = this.__wbg_ptr;
    this.__wbg_ptr = 0;
    ConversationConfigurationFinalization.unregister(this);
    return ptr;
  }
  free() {
    const ptr = this.__destroy_into_raw();
    wasm.__wbg_conversationconfiguration_free(ptr, 0);
  }
  get ciphersuite() {
    const ret = wasm.__wbg_get_conversationconfiguration_ciphersuite(this.__wbg_ptr);
    return ret === 0 ? undefined : Ciphersuite2.__wrap(ret);
  }
  get custom() {
    const ret = wasm.__wbg_get_conversationconfiguration_custom(this.__wbg_ptr);
    return CustomConfiguration.__wrap(ret);
  }
  constructor(ciphersuite, external_senders, key_rotation_span, wire_policy) {
    let ptr0 = 0;
    if (!isLikeNone(ciphersuite)) {
      _assertClass(ciphersuite, Ciphersuite2);
      ptr0 = ciphersuite.__destroy_into_raw();
    }
    var ptr1 = isLikeNone(external_senders) ? 0 : passArrayJsValueToWasm0(external_senders, wasm.__wbindgen_malloc);
    var len1 = WASM_VECTOR_LEN;
    const ret = wasm.conversationconfiguration_new(ptr0, ptr1, len1, isLikeNone(key_rotation_span) ? 4294967297 : key_rotation_span >>> 0, isLikeNone(wire_policy) ? 0 : wire_policy);
    if (ret[2]) {
      throw takeFromExternrefTable0(ret[1]);
    }
    this.__wbg_ptr = ret[0] >>> 0;
    ConversationConfigurationFinalization.register(this, this.__wbg_ptr, this);
    return this;
  }
  get externalSenders() {
    const ret = wasm.conversationconfiguration_externalSenders(this.__wbg_ptr);
    var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
    return v1;
  }
}
var CoreCryptoFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry((ptr) => wasm.__wbg_corecrypto_free(ptr >>> 0, 1));

class CoreCrypto {
  static __wrap(ptr) {
    ptr = ptr >>> 0;
    const obj = Object.create(CoreCrypto.prototype);
    obj.__wbg_ptr = ptr;
    CoreCryptoFinalization.register(obj, obj.__wbg_ptr, obj);
    return obj;
  }
  __destroy_into_raw() {
    const ptr = this.__wbg_ptr;
    this.__wbg_ptr = 0;
    CoreCryptoFinalization.unregister(this);
    return ptr;
  }
  free() {
    const ptr = this.__destroy_into_raw();
    wasm.__wbg_corecrypto_free(ptr, 0);
  }
  client_public_key(ciphersuite, credential_type) {
    _assertClass(ciphersuite, Ciphersuite2);
    var ptr0 = ciphersuite.__destroy_into_raw();
    const ret = wasm.corecrypto_client_public_key(this.__wbg_ptr, ptr0, credential_type);
    return ret;
  }
  transaction(command) {
    const ret = wasm.corecrypto_transaction(this.__wbg_ptr, command);
    return ret;
  }
  conversation_epoch(conversation_id) {
    const ret = wasm.corecrypto_conversation_epoch(this.__wbg_ptr, conversation_id);
    return ret;
  }
  conversation_ciphersuite(conversation_id) {
    const ret = wasm.corecrypto_conversation_ciphersuite(this.__wbg_ptr, conversation_id);
    return ret;
  }
  conversation_exists(conversation_id) {
    const ret = wasm.corecrypto_conversation_exists(this.__wbg_ptr, conversation_id);
    return ret;
  }
  get_client_ids(conversation_id) {
    const ret = wasm.corecrypto_get_client_ids(this.__wbg_ptr, conversation_id);
    return ret;
  }
  get_external_sender(conversation_id) {
    const ret = wasm.corecrypto_get_external_sender(this.__wbg_ptr, conversation_id);
    return ret;
  }
  export_secret_key(conversation_id, key_length) {
    const ret = wasm.corecrypto_export_secret_key(this.__wbg_ptr, conversation_id, key_length);
    return ret;
  }
  get_device_identities(conversation_id, device_ids) {
    const ptr0 = passArrayJsValueToWasm0(device_ids, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.corecrypto_get_device_identities(this.__wbg_ptr, conversation_id, ptr0, len0);
    return ret;
  }
  get_user_identities(conversation_id, user_ids) {
    const ptr0 = passArrayJsValueToWasm0(user_ids, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.corecrypto_get_user_identities(this.__wbg_ptr, conversation_id, ptr0, len0);
    return ret;
  }
  get_credential_in_use(group_info, credential_type) {
    const ptr0 = passArray8ToWasm0(group_info, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.corecrypto_get_credential_in_use(this.__wbg_ptr, ptr0, len0, credential_type);
    return ret;
  }
  e2ei_dump_pki_env() {
    const ret = wasm.corecrypto_e2ei_dump_pki_env(this.__wbg_ptr);
    return ret;
  }
  e2ei_is_pki_env_setup() {
    const ret = wasm.corecrypto_e2ei_is_pki_env_setup(this.__wbg_ptr);
    return ret;
  }
  e2ei_is_enabled(ciphersuite) {
    _assertClass(ciphersuite, Ciphersuite2);
    var ptr0 = ciphersuite.__destroy_into_raw();
    const ret = wasm.corecrypto_e2ei_is_enabled(this.__wbg_ptr, ptr0);
    return ret;
  }
  register_epoch_observer(epoch_observer) {
    _assertClass(epoch_observer, EpochObserver);
    var ptr0 = epoch_observer.__destroy_into_raw();
    const ret = wasm.corecrypto_register_epoch_observer(this.__wbg_ptr, ptr0);
    return ret;
  }
  static set_logger(logger) {
    _assertClass(logger, CoreCryptoLogger);
    var ptr0 = logger.__destroy_into_raw();
    wasm.corecrypto_set_logger(ptr0);
  }
  static set_max_log_level(level) {
    wasm.corecrypto_set_max_log_level(level);
  }
  provide_transport(callbacks) {
    _assertClass(callbacks, MlsTransport);
    var ptr0 = callbacks.__destroy_into_raw();
    const ret = wasm.corecrypto_provide_transport(this.__wbg_ptr, ptr0);
    return ret;
  }
  proteus_session_exists(session_id) {
    const ptr0 = passStringToWasm0(session_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.corecrypto_proteus_session_exists(this.__wbg_ptr, ptr0, len0);
    return ret;
  }
  proteus_fingerprint() {
    const ret = wasm.corecrypto_proteus_fingerprint(this.__wbg_ptr);
    return ret;
  }
  proteus_fingerprint_local(session_id) {
    const ptr0 = passStringToWasm0(session_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.corecrypto_proteus_fingerprint_local(this.__wbg_ptr, ptr0, len0);
    return ret;
  }
  proteus_fingerprint_remote(session_id) {
    const ptr0 = passStringToWasm0(session_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.corecrypto_proteus_fingerprint_remote(this.__wbg_ptr, ptr0, len0);
    return ret;
  }
  static proteus_last_resort_prekey_id() {
    const ret = wasm.corecrypto_proteus_last_resort_prekey_id();
    if (ret[2]) {
      throw takeFromExternrefTable0(ret[1]);
    }
    return ret[0];
  }
  static proteus_fingerprint_prekeybundle(prekey) {
    let deferred3_0;
    let deferred3_1;
    try {
      const ptr0 = passArray8ToWasm0(prekey, wasm.__wbindgen_malloc);
      const len0 = WASM_VECTOR_LEN;
      const ret = wasm.corecrypto_proteus_fingerprint_prekeybundle(ptr0, len0);
      var ptr2 = ret[0];
      var len2 = ret[1];
      if (ret[3]) {
        ptr2 = 0;
        len2 = 0;
        throw takeFromExternrefTable0(ret[2]);
      }
      deferred3_0 = ptr2;
      deferred3_1 = len2;
      return getStringFromWasm0(ptr2, len2);
    } finally {
      wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
    }
  }
  random_bytes(len) {
    const ret = wasm.corecrypto_random_bytes(this.__wbg_ptr, len);
    return ret;
  }
  reseed_rng(seed) {
    const ptr0 = passArray8ToWasm0(seed, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.corecrypto_reseed_rng(this.__wbg_ptr, ptr0, len0);
    return ret;
  }
  static async_new(path, key, client_id, ciphersuites, entropy_seed, nb_key_package) {
    const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    _assertClass(key, DatabaseKey);
    var ptr1 = key.__destroy_into_raw();
    var ptr2 = isLikeNone(client_id) ? 0 : passArray8ToWasm0(client_id, wasm.__wbindgen_malloc);
    var len2 = WASM_VECTOR_LEN;
    let ptr3 = 0;
    if (!isLikeNone(ciphersuites)) {
      _assertClass(ciphersuites, Ciphersuites);
      ptr3 = ciphersuites.__destroy_into_raw();
    }
    var ptr4 = isLikeNone(entropy_seed) ? 0 : passArray8ToWasm0(entropy_seed, wasm.__wbindgen_malloc);
    var len4 = WASM_VECTOR_LEN;
    const ret = wasm.corecrypto_async_new(ptr0, len0, ptr1, ptr2, len2, ptr3, ptr4, len4, isLikeNone(nb_key_package) ? 4294967297 : nb_key_package >>> 0);
    return ret;
  }
  static deferred_init(path, key, entropy_seed) {
    const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    _assertClass(key, DatabaseKey);
    var ptr1 = key.__destroy_into_raw();
    var ptr2 = isLikeNone(entropy_seed) ? 0 : passArray8ToWasm0(entropy_seed, wasm.__wbindgen_malloc);
    var len2 = WASM_VECTOR_LEN;
    const ret = wasm.corecrypto_deferred_init(ptr0, len0, ptr1, ptr2, len2);
    return ret;
  }
  close() {
    const ptr = this.__destroy_into_raw();
    const ret = wasm.corecrypto_close(ptr);
    return ret;
  }
  can_close() {
    const ret = wasm.corecrypto_can_close(this.__wbg_ptr);
    return ret;
  }
  static history_client(history_secret) {
    const ptr0 = passArray8ToWasm0(history_secret, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.corecrypto_history_client(ptr0, len0);
    return ret;
  }
}
var CoreCryptoContextFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry((ptr) => wasm.__wbg_corecryptocontext_free(ptr >>> 0, 1));

class CoreCryptoContext {
  static __wrap(ptr) {
    ptr = ptr >>> 0;
    const obj = Object.create(CoreCryptoContext.prototype);
    obj.__wbg_ptr = ptr;
    CoreCryptoContextFinalization.register(obj, obj.__wbg_ptr, obj);
    return obj;
  }
  __destroy_into_raw() {
    const ptr = this.__wbg_ptr;
    this.__wbg_ptr = 0;
    CoreCryptoContextFinalization.unregister(this);
    return ptr;
  }
  free() {
    const ptr = this.__destroy_into_raw();
    wasm.__wbg_corecryptocontext_free(ptr, 0);
  }
  e2ei_new_enrollment(client_id, display_name, handle, team, expiry_sec, ciphersuite) {
    const ptr0 = passStringToWasm0(client_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ptr1 = passStringToWasm0(display_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len1 = WASM_VECTOR_LEN;
    const ptr2 = passStringToWasm0(handle, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len2 = WASM_VECTOR_LEN;
    var ptr3 = isLikeNone(team) ? 0 : passStringToWasm0(team, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    var len3 = WASM_VECTOR_LEN;
    _assertClass(ciphersuite, Ciphersuite2);
    var ptr4 = ciphersuite.__destroy_into_raw();
    const ret = wasm.corecryptocontext_e2ei_new_enrollment(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, expiry_sec, ptr4);
    return ret;
  }
  e2ei_new_activation_enrollment(display_name, handle, team, expiry_sec, ciphersuite) {
    const ptr0 = passStringToWasm0(display_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ptr1 = passStringToWasm0(handle, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len1 = WASM_VECTOR_LEN;
    var ptr2 = isLikeNone(team) ? 0 : passStringToWasm0(team, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    var len2 = WASM_VECTOR_LEN;
    _assertClass(ciphersuite, Ciphersuite2);
    var ptr3 = ciphersuite.__destroy_into_raw();
    const ret = wasm.corecryptocontext_e2ei_new_activation_enrollment(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, expiry_sec, ptr3);
    return ret;
  }
  e2ei_new_rotate_enrollment(display_name, handle, team, expiry_sec, ciphersuite) {
    var ptr0 = isLikeNone(display_name) ? 0 : passStringToWasm0(display_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    var len0 = WASM_VECTOR_LEN;
    var ptr1 = isLikeNone(handle) ? 0 : passStringToWasm0(handle, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    var len1 = WASM_VECTOR_LEN;
    var ptr2 = isLikeNone(team) ? 0 : passStringToWasm0(team, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    var len2 = WASM_VECTOR_LEN;
    _assertClass(ciphersuite, Ciphersuite2);
    var ptr3 = ciphersuite.__destroy_into_raw();
    const ret = wasm.corecryptocontext_e2ei_new_rotate_enrollment(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, expiry_sec, ptr3);
    return ret;
  }
  e2ei_register_acme_ca(trust_anchor_pem) {
    const ptr0 = passStringToWasm0(trust_anchor_pem, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_e2ei_register_acme_ca(this.__wbg_ptr, ptr0, len0);
    return ret;
  }
  e2ei_register_intermediate_ca(cert_pem) {
    const ptr0 = passStringToWasm0(cert_pem, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_e2ei_register_intermediate_ca(this.__wbg_ptr, ptr0, len0);
    return ret;
  }
  e2ei_register_crl(crl_dp, crl_der) {
    const ptr0 = passStringToWasm0(crl_dp, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ptr1 = passArray8ToWasm0(crl_der, wasm.__wbindgen_malloc);
    const len1 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_e2ei_register_crl(this.__wbg_ptr, ptr0, len0, ptr1, len1);
    return ret;
  }
  e2ei_mls_init_only(enrollment, certificate_chain, nb_key_package) {
    _assertClass(enrollment, FfiWireE2EIdentity);
    var ptr0 = enrollment.__destroy_into_raw();
    const ptr1 = passStringToWasm0(certificate_chain, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len1 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_e2ei_mls_init_only(this.__wbg_ptr, ptr0, ptr1, len1, isLikeNone(nb_key_package) ? 4294967297 : nb_key_package >>> 0);
    return ret;
  }
  e2ei_rotate(conversation_id) {
    const ret = wasm.corecryptocontext_e2ei_rotate(this.__wbg_ptr, conversation_id);
    return ret;
  }
  save_x509_credential(enrollment, certificate_chain) {
    _assertClass(enrollment, FfiWireE2EIdentity);
    var ptr0 = enrollment.__destroy_into_raw();
    const ptr1 = passStringToWasm0(certificate_chain, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len1 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_save_x509_credential(this.__wbg_ptr, ptr0, ptr1, len1);
    return ret;
  }
  delete_stale_key_packages(ciphersuite) {
    _assertClass(ciphersuite, Ciphersuite2);
    var ptr0 = ciphersuite.__destroy_into_raw();
    const ret = wasm.corecryptocontext_delete_stale_key_packages(this.__wbg_ptr, ptr0);
    return ret;
  }
  e2ei_enrollment_stash(enrollment) {
    _assertClass(enrollment, FfiWireE2EIdentity);
    var ptr0 = enrollment.__destroy_into_raw();
    const ret = wasm.corecryptocontext_e2ei_enrollment_stash(this.__wbg_ptr, ptr0);
    return ret;
  }
  e2ei_enrollment_stash_pop(handle) {
    const ptr0 = passArray8ToWasm0(handle, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_e2ei_enrollment_stash_pop(this.__wbg_ptr, ptr0, len0);
    return ret;
  }
  e2ei_conversation_state(conversation_id) {
    const ret = wasm.corecryptocontext_e2ei_conversation_state(this.__wbg_ptr, conversation_id);
    return ret;
  }
  e2ei_is_enabled(ciphersuite) {
    _assertClass(ciphersuite, Ciphersuite2);
    var ptr0 = ciphersuite.__destroy_into_raw();
    const ret = wasm.corecryptocontext_e2ei_is_enabled(this.__wbg_ptr, ptr0);
    return ret;
  }
  get_device_identities(conversation_id, device_ids) {
    const ptr0 = passArrayJsValueToWasm0(device_ids, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_get_device_identities(this.__wbg_ptr, conversation_id, ptr0, len0);
    return ret;
  }
  get_user_identities(conversation_id, user_ids) {
    const ptr0 = passArrayJsValueToWasm0(user_ids, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_get_user_identities(this.__wbg_ptr, conversation_id, ptr0, len0);
    return ret;
  }
  get_credential_in_use(group_info, credential_type) {
    const ptr0 = passArray8ToWasm0(group_info, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_get_credential_in_use(this.__wbg_ptr, ptr0, len0, credential_type);
    return ret;
  }
  e2ei_dump_pki_env() {
    const ret = wasm.corecryptocontext_e2ei_dump_pki_env(this.__wbg_ptr);
    return ret;
  }
  e2ei_is_pki_env_setup() {
    const ret = wasm.corecryptocontext_e2ei_is_pki_env_setup(this.__wbg_ptr);
    return ret;
  }
  mls_init(client_id, ciphersuites, nb_key_package) {
    _assertClass(client_id, ClientId);
    var ptr0 = client_id.__destroy_into_raw();
    _assertClass(ciphersuites, Ciphersuites);
    var ptr1 = ciphersuites.__destroy_into_raw();
    const ret = wasm.corecryptocontext_mls_init(this.__wbg_ptr, ptr0, ptr1, isLikeNone(nb_key_package) ? 4294967297 : nb_key_package >>> 0);
    return ret;
  }
  mls_generate_keypairs(ciphersuites) {
    _assertClass(ciphersuites, Ciphersuites);
    var ptr0 = ciphersuites.__destroy_into_raw();
    const ret = wasm.corecryptocontext_mls_generate_keypairs(this.__wbg_ptr, ptr0);
    return ret;
  }
  mls_init_with_client_id(client_id, tmp_client_ids, ciphersuites) {
    _assertClass(client_id, ClientId);
    var ptr0 = client_id.__destroy_into_raw();
    const ptr1 = passArrayJsValueToWasm0(tmp_client_ids, wasm.__wbindgen_malloc);
    const len1 = WASM_VECTOR_LEN;
    _assertClass(ciphersuites, Ciphersuites);
    var ptr2 = ciphersuites.__destroy_into_raw();
    const ret = wasm.corecryptocontext_mls_init_with_client_id(this.__wbg_ptr, ptr0, ptr1, len1, ptr2);
    return ret;
  }
  client_public_key(ciphersuite, credential_type) {
    _assertClass(ciphersuite, Ciphersuite2);
    var ptr0 = ciphersuite.__destroy_into_raw();
    const ret = wasm.corecryptocontext_client_public_key(this.__wbg_ptr, ptr0, credential_type);
    return ret;
  }
  conversation_epoch(conversation_id) {
    const ret = wasm.corecryptocontext_conversation_epoch(this.__wbg_ptr, conversation_id);
    return ret;
  }
  conversation_ciphersuite(conversation_id) {
    const ret = wasm.corecryptocontext_conversation_ciphersuite(this.__wbg_ptr, conversation_id);
    return ret;
  }
  conversation_exists(conversation_id) {
    const ret = wasm.corecryptocontext_conversation_exists(this.__wbg_ptr, conversation_id);
    return ret;
  }
  get_client_ids(conversation_id) {
    const ret = wasm.corecryptocontext_get_client_ids(this.__wbg_ptr, conversation_id);
    return ret;
  }
  export_secret_key(conversation_id, key_length) {
    const ret = wasm.corecryptocontext_export_secret_key(this.__wbg_ptr, conversation_id, key_length);
    return ret;
  }
  get_external_sender(conversation_id) {
    const ret = wasm.corecryptocontext_get_external_sender(this.__wbg_ptr, conversation_id);
    return ret;
  }
  client_keypackages(ciphersuite, credential_type, amount_requested) {
    _assertClass(ciphersuite, Ciphersuite2);
    var ptr0 = ciphersuite.__destroy_into_raw();
    const ret = wasm.corecryptocontext_client_keypackages(this.__wbg_ptr, ptr0, credential_type, amount_requested);
    return ret;
  }
  client_valid_keypackages_count(ciphersuite, credential_type) {
    _assertClass(ciphersuite, Ciphersuite2);
    var ptr0 = ciphersuite.__destroy_into_raw();
    const ret = wasm.corecryptocontext_client_valid_keypackages_count(this.__wbg_ptr, ptr0, credential_type);
    return ret;
  }
  delete_keypackages(refs) {
    _assertClass(refs, ArrayOfByteArray);
    var ptr0 = refs.__destroy_into_raw();
    const ret = wasm.corecryptocontext_delete_keypackages(this.__wbg_ptr, ptr0);
    return ret;
  }
  create_conversation(conversation_id, creator_credential_type, config) {
    _assertClass(config, ConversationConfiguration);
    var ptr0 = config.__destroy_into_raw();
    const ret = wasm.corecryptocontext_create_conversation(this.__wbg_ptr, conversation_id, creator_credential_type, ptr0);
    return ret;
  }
  process_welcome_message(welcome_message, custom_configuration) {
    const ptr0 = passArray8ToWasm0(welcome_message, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    _assertClass(custom_configuration, CustomConfiguration);
    var ptr1 = custom_configuration.__destroy_into_raw();
    const ret = wasm.corecryptocontext_process_welcome_message(this.__wbg_ptr, ptr0, len0, ptr1);
    return ret;
  }
  add_clients_to_conversation(conversation_id, key_packages) {
    _assertClass(key_packages, ArrayOfByteArray);
    var ptr0 = key_packages.__destroy_into_raw();
    const ret = wasm.corecryptocontext_add_clients_to_conversation(this.__wbg_ptr, conversation_id, ptr0);
    return ret;
  }
  remove_clients_from_conversation(conversation_id, clients) {
    const ptr0 = passArrayJsValueToWasm0(clients, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_remove_clients_from_conversation(this.__wbg_ptr, conversation_id, ptr0, len0);
    return ret;
  }
  mark_conversation_as_child_of(child_id, parent_id) {
    const ret = wasm.corecryptocontext_mark_conversation_as_child_of(this.__wbg_ptr, child_id, parent_id);
    return ret;
  }
  update_keying_material(conversation_id) {
    const ret = wasm.corecryptocontext_update_keying_material(this.__wbg_ptr, conversation_id);
    return ret;
  }
  commit_pending_proposals(conversation_id) {
    const ret = wasm.corecryptocontext_commit_pending_proposals(this.__wbg_ptr, conversation_id);
    return ret;
  }
  wipe_conversation(conversation_id) {
    const ret = wasm.corecryptocontext_wipe_conversation(this.__wbg_ptr, conversation_id);
    return ret;
  }
  decrypt_message(conversation_id, payload) {
    const ptr0 = passArray8ToWasm0(payload, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_decrypt_message(this.__wbg_ptr, conversation_id, ptr0, len0);
    return ret;
  }
  encrypt_message(conversation_id, message) {
    const ptr0 = passArray8ToWasm0(message, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_encrypt_message(this.__wbg_ptr, conversation_id, ptr0, len0);
    return ret;
  }
  join_by_external_commit(group_info, custom_configuration, credential_type) {
    const ptr0 = passArray8ToWasm0(group_info, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    _assertClass(custom_configuration, CustomConfiguration);
    var ptr1 = custom_configuration.__destroy_into_raw();
    const ret = wasm.corecryptocontext_join_by_external_commit(this.__wbg_ptr, ptr0, len0, ptr1, credential_type);
    return ret;
  }
  proteus_init() {
    const r