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

CoreCrypto bindings for the Web

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/CoreCryptoError.ts
class CoreCryptoError extends Error {
  errorStack;
  context;
  type;
  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.context && richError.type && Object.values(ErrorType).includes(richError.type)) {
      this.context = richError.context;
      this.type = richError.type;
    }
  }
  static fallback(message, ...params) {
    return new CoreCryptoError({ message }, ...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 (isCcErrorGeneric(e)) {
      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 (isCcErrorGeneric(e)) {
        throw e;
      } else {
        throw this.fromStdError(e);
      }
    });
    return await mappedErrorPromise;
  }
}
var ErrorType;
((ErrorType2) => {
  ErrorType2["Mls"] = "Mls";
  ErrorType2["Proteus"] = "Proteus";
  ErrorType2["E2ei"] = "E2ei";
  ErrorType2["TransactionFailed"] = "TransactionFailed";
  ErrorType2["Other"] = "Other";
})(ErrorType ||= {});
function isCcErrorGeneric(error) {
  return typeof error === "object" && error !== null && "errorStack" in error && "context" in error && "type" in error;
}
function isCcError(error, errorType) {
  return isCcErrorGeneric(error) && error.type === errorType;
}
function isE2eiError(error) {
  return isCcError(error, "E2ei" /* E2ei */);
}
function isTransactionFailedError(error) {
  return isCcError(error, "TransactionFailed" /* TransactionFailed */);
}
function isOtherError(error) {
  return isCcError(error, "Other" /* Other */);
}
var MlsErrorType;
((MlsErrorType2) => {
  MlsErrorType2["ConversationAlreadyExists"] = "ConversationAlreadyExists";
  MlsErrorType2["DuplicateMessage"] = "DuplicateMessage";
  MlsErrorType2["BufferedFutureMessage"] = "BufferedFutureMessage";
  MlsErrorType2["WrongEpoch"] = "WrongEpoch";
  MlsErrorType2["BufferedCommit"] = "BufferedCommit";
  MlsErrorType2["MessageEpochTooOld"] = "MessageEpochTooOld";
  MlsErrorType2["SelfCommitIgnored"] = "SelfCommitIgnored";
  MlsErrorType2["UnmergedPendingGroup"] = "UnmergedPendingGroup";
  MlsErrorType2["StaleProposal"] = "StaleProposal";
  MlsErrorType2["StaleCommit"] = "StaleCommit";
  MlsErrorType2["OrphanWelcome"] = "OrphanWelcome";
  MlsErrorType2["MessageRejected"] = "MessageRejected";
  MlsErrorType2["Other"] = "Other";
})(MlsErrorType ||= {});
function isMlsError(error, errorType) {
  return isCcError(error, "Mls" /* Mls */) && error.context !== undefined && error.context.type === errorType;
}
function isMlsConversationAlreadyExistsError(error) {
  return isMlsError(error, "ConversationAlreadyExists" /* ConversationAlreadyExists */);
}
function isMlsDuplicateMessageError(error) {
  return isMlsError(error, "DuplicateMessage" /* DuplicateMessage */);
}
function isMlsBufferedFutureMessageError(error) {
  return isMlsError(error, "BufferedFutureMessage" /* BufferedFutureMessage */);
}
function isMlsWrongEpochError(error) {
  return isMlsError(error, "WrongEpoch" /* WrongEpoch */);
}
function isMlsBufferedCommitError(error) {
  return isMlsError(error, "BufferedCommit" /* BufferedCommit */);
}
function isMlsSelfCommitIgnoredError(error) {
  return isMlsError(error, "SelfCommitIgnored" /* SelfCommitIgnored */);
}
function isMlsUnmergedPendingGroupError(error) {
  return isMlsError(error, "UnmergedPendingGroup" /* UnmergedPendingGroup */);
}
function isMlsStaleProposalError(error) {
  return isMlsError(error, "StaleProposal" /* StaleProposal */);
}
function isMlsStaleCommitError(error) {
  return isMlsError(error, "StaleCommit" /* StaleCommit */);
}
function isMlsOrphanWelcomeError(error) {
  return isMlsError(error, "OrphanWelcome" /* OrphanWelcome */);
}
function isMlsMessageRejectedError(error) {
  return isMlsError(error, "MessageRejected" /* MessageRejected */);
}
function isMlsOtherError(error) {
  return isMlsError(error, "Other" /* Other */);
}
var ProteusErrorType;
((ProteusErrorType2) => {
  ProteusErrorType2["SessionNotFound"] = "SessionNotFound";
  ProteusErrorType2["DuplicateMessage"] = "DuplicateMessage";
  ProteusErrorType2["RemoteIdentityChanged"] = "RemoteIdentityChanged";
  ProteusErrorType2["Other"] = "Other";
})(ProteusErrorType ||= {});
function isProteusError(error, errorType) {
  return isCcError(error, "Proteus" /* Proteus */) && error.context !== undefined && error.context.type === errorType;
}
function isProteusSessionNotFoundError(error) {
  return isProteusError(error, "SessionNotFound" /* SessionNotFound */);
}
function isProteusDuplicateMessageError(error) {
  return isProteusError(error, "DuplicateMessage" /* DuplicateMessage */);
}
function isProteusRemoteIdentityChangedError(error) {
  return isProteusError(error, "RemoteIdentityChanged" /* RemoteIdentityChanged */);
}
function isProteusOtherError(error) {
  return isProteusError(error, "Other" /* Other */);
}
// src/autogenerated/core-crypto-ffi.js
var wasm;
var cachedUint8ArrayMemory0 = null;
function getUint8ArrayMemory0() {
  if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
    cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
  }
  return cachedUint8ArrayMemory0;
}
var cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
cachedTextDecoder.decode();
var MAX_SAFARI_DECODE_BYTES = 2146435072;
var numBytesDecoded = 0;
function decodeText(ptr, len) {
  numBytesDecoded += len;
  if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
    cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
    cachedTextDecoder.decode();
    numBytesDecoded = len;
  }
  return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
}
function getStringFromWasm0(ptr, len) {
  ptr = ptr >>> 0;
  return decodeText(ptr, len);
}
var WASM_VECTOR_LEN = 0;
var cachedTextEncoder = new TextEncoder;
if (!("encodeInto" in cachedTextEncoder)) {
  cachedTextEncoder.encodeInto = 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 = cachedTextEncoder.encodeInto(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);
  }
}
function isLikeNone(x) {
  return x === undefined || x === null;
}
function getArrayU8FromWasm0(ptr, len) {
  ptr = ptr >>> 0;
  return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
}
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 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;
}
var CLOSURE_DTORS = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry((state) => {
  wasm.__wbindgen_export_7.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_7.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 ciphersuiteDefault() {
  const ret = wasm.ciphersuiteDefault();
  return ret;
}
function takeFromExternrefTable0(idx) {
  const value = wasm.__wbindgen_export_4.get(idx);
  wasm.__externref_table_dealloc(idx);
  return value;
}
function ciphersuiteFromU16(discriminant) {
  const ret = wasm.ciphersuiteFromU16(discriminant);
  if (ret[2]) {
    throw takeFromExternrefTable0(ret[1]);
  }
  return ret[0];
}
function _assertClass(instance, klass) {
  if (!(instance instanceof klass)) {
    throw new Error(`expected instance of ${klass.name}`);
  }
}
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 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 openDatabase(name, key) {
  const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
  const len0 = WASM_VECTOR_LEN;
  _assertClass(key, DatabaseKey);
  var ptr1 = key.__destroy_into_raw();
  const ret = wasm.openDatabase(ptr0, len0, ptr1);
  return ret;
}
function migrateDatabaseKeyTypeToBytes(path, old_key, new_key) {
  const ptr0 = passStringToWasm0(path, 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 updateDatabaseKey(name, old_key, new_key) {
  const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
  const len0 = WASM_VECTOR_LEN;
  _assertClass(old_key, DatabaseKey);
  _assertClass(new_key, DatabaseKey);
  const ret = wasm.updateDatabaseKey(ptr0, len0, old_key.__wbg_ptr, 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_8(arg0, arg1, arg2) {
  wasm.closure2505_externref_shim(arg0, arg1, arg2);
}
function __wbg_adapter_19(arg0, arg1, arg2) {
  wasm.closure2882_externref_shim(arg0, arg1, arg2);
}
function __wbg_adapter_22(arg0, arg1, arg2) {
  wasm.closure942_externref_shim(arg0, arg1, arg2);
}
function __wbg_adapter_479(arg0, arg1, arg2, arg3) {
  wasm.closure2985_externref_shim(arg0, arg1, arg2, arg3);
}
var Ciphersuite = Object.freeze({
  MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519: 1,
  "1": "MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519",
  MLS_128_DHKEMP256_AES128GCM_SHA256_P256: 2,
  "2": "MLS_128_DHKEMP256_AES128GCM_SHA256_P256",
  MLS_128_DHKEMX25519_CHACHA20POLY1305_SHA256_Ed25519: 3,
  "3": "MLS_128_DHKEMX25519_CHACHA20POLY1305_SHA256_Ed25519",
  MLS_256_DHKEMX448_AES256GCM_SHA512_Ed448: 4,
  "4": "MLS_256_DHKEMX448_AES256GCM_SHA512_Ed448",
  MLS_256_DHKEMP521_AES256GCM_SHA512_P521: 5,
  "5": "MLS_256_DHKEMP521_AES256GCM_SHA512_P521",
  MLS_256_DHKEMX448_CHACHA20POLY1305_SHA512_Ed448: 6,
  "6": "MLS_256_DHKEMX448_CHACHA20POLY1305_SHA512_Ed448",
  MLS_256_DHKEMP384_AES256GCM_SHA384_P384: 7,
  "7": "MLS_256_DHKEMP384_AES256GCM_SHA384_P384"
});
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_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);
    }
  }
}
if (Symbol.dispose)
  AcmeChallenge.prototype[Symbol.dispose] = AcmeChallenge.prototype.free;
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);
    }
  }
}
if (Symbol.dispose)
  AcmeDirectory.prototype[Symbol.dispose] = AcmeDirectory.prototype.free;
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);
    let v1;
    if (ret[0] !== 0) {
      v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
      wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
    }
    return v1;
  }
}
if (Symbol.dispose)
  BufferedDecryptedMessage.prototype[Symbol.dispose] = BufferedDecryptedMessage.prototype.free;
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]);
  }
}
if (Symbol.dispose)
  BuildMetadata.prototype[Symbol.dispose] = BuildMetadata.prototype.free;
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);
  }
  copyBytes() {
    const ret = wasm.clientid_copyBytes(this.__wbg_ptr);
    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
    return v1;
  }
  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;
  }
}
if (Symbol.dispose)
  ClientId.prototype[Symbol.dispose] = ClientId.prototype.free;
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);
    return ret === 0 ? undefined : Welcome.__wrap(ret);
  }
  set welcome(arg0) {
    let ptr0 = 0;
    if (!isLikeNone(arg0)) {
      _assertClass(arg0, Welcome);
      ptr0 = arg0.__destroy_into_raw();
    }
    wasm.__wbg_set_commitbundle_welcome(this.__wbg_ptr, ptr0);
  }
  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);
  }
  get encryptedMessage() {
    const ret = wasm.__wbg_get_commitbundle_encryptedMessage(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;
  }
}
if (Symbol.dispose)
  CommitBundle.prototype[Symbol.dispose] = CommitBundle.prototype.free;
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 : ret;
  }
  get externalSenders() {
    const ret = wasm.__wbg_get_conversationconfiguration_externalSenders(this.__wbg_ptr);
    var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
    return v1;
  }
  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) {
    var ptr0 = isLikeNone(external_senders) ? 0 : passArrayJsValueToWasm0(external_senders, wasm.__wbindgen_malloc);
    var len0 = WASM_VECTOR_LEN;
    const ret = wasm.conversationconfiguration_new(isLikeNone(ciphersuite) ? 0 : ciphersuite, ptr0, len0, 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;
  }
}
if (Symbol.dispose)
  ConversationConfiguration.prototype[Symbol.dispose] = ConversationConfiguration.prototype.free;
var ConversationIdFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry((ptr) => wasm.__wbg_conversationid_free(ptr >>> 0, 1));

class ConversationId {
  static __wrap(ptr) {
    ptr = ptr >>> 0;
    const obj = Object.create(ConversationId.prototype);
    obj.__wbg_ptr = ptr;
    ConversationIdFinalization.register(obj, obj.__wbg_ptr, obj);
    return obj;
  }
  __destroy_into_raw() {
    const ptr = this.__wbg_ptr;
    this.__wbg_ptr = 0;
    ConversationIdFinalization.unregister(this);
    return ptr;
  }
  free() {
    const ptr = this.__destroy_into_raw();
    wasm.__wbg_conversationid_free(ptr, 0);
  }
  copyBytes() {
    const ret = wasm.conversationid_copyBytes(this.__wbg_ptr);
    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
    return v1;
  }
  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;
    ConversationIdFinalization.register(this, this.__wbg_ptr, this);
    return this;
  }
}
if (Symbol.dispose)
  ConversationId.prototype[Symbol.dispose] = ConversationId.prototype.free;
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);
  }
  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;
  }
  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();
    let ptr2 = 0;
    if (!isLikeNone(client_id)) {
      _assertClass(client_id, ClientId);
      ptr2 = client_id.__destroy_into_raw();
    }
    var ptr3 = isLikeNone(ciphersuites) ? 0 : passArrayJsValueToWasm0(ciphersuites, wasm.__wbindgen_malloc);
    var len3 = WASM_VECTOR_LEN;
    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, ptr3, len3, ptr4, len4, isLikeNone(nb_key_package) ? 4294967297 : nb_key_package >>> 0);
    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;
  }
  random_bytes(len) {
    const ret = wasm.corecrypto_random_bytes(this.__wbg_ptr, len);
    return ret;
  }
  get_client_ids(conversation_id) {
    _assertClass(conversation_id, ConversationId);
    const ret = wasm.corecrypto_get_client_ids(this.__wbg_ptr, conversation_id.__wbg_ptr);
    return ret;
  }
  export_secret_key(conversation_id, key_length) {
    _assertClass(conversation_id, ConversationId);
    const ret = wasm.corecrypto_export_secret_key(this.__wbg_ptr, conversation_id.__wbg_ptr, key_length);
    return ret;
  }
  conversation_epoch(conversation_id) {
    _assertClass(conversation_id, ConversationId);
    const ret = wasm.corecrypto_conversation_epoch(this.__wbg_ptr, conversation_id.__wbg_ptr);
    return ret;
  }
  conversation_exists(conversation_id) {
    _assertClass(conversation_id, ConversationId);
    const ret = wasm.corecrypto_conversation_exists(this.__wbg_ptr, conversation_id.__wbg_ptr);
    return ret;
  }
  get_external_sender(conversation_id) {
    _assertClass(conversation_id, ConversationId);
    const ret = wasm.corecrypto_get_external_sender(this.__wbg_ptr, conversation_id.__wbg_ptr);
    return ret;
  }
  conversation_ciphersuite(conversation_id) {
    _assertClass(conversation_id, ConversationId);
    const ret = wasm.corecrypto_conversation_ciphersuite(this.__wbg_ptr, conversation_id.__wbg_ptr);
    return ret;
  }
  is_history_sharing_enabled(conversation_id) {
    _assertClass(conversation_id, ConversationId);
    const ret = wasm.corecrypto_is_history_sharing_enabled(this.__wbg_ptr, conversation_id.__wbg_ptr);
    return ret;
  }
  provide_transport(callbacks) {
    _assertClass(callbacks, MlsTransport);
    var ptr0 = callbacks.__destroy_into_raw();
    const ret = wasm.corecrypto_provide_transport(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;
  }
  register_history_observer(history_observer) {
    _assertClass(history_observer, HistoryObserver);
    var ptr0 = history_observer.__destroy_into_raw();
    const ret = wasm.corecrypto_register_history_observer(this.__wbg_ptr, ptr0);
    return ret;
  }
  get_user_identities(conversation_id, user_ids) {
    _assertClass(conversation_id, ConversationId);
    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.__wbg_ptr, ptr0, len0);
    return ret;
  }
  get_device_identities(conversation_id, device_ids) {
    _assertClass(conversation_id, ConversationId);
    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.__wbg_ptr, ptr0, len0);
    return ret;
  }
  e2ei_is_enabled(ciphersuite) {
    const ret = wasm.corecrypto_e2ei_is_enabled(this.__wbg_ptr, ciphersuite);
    return ret;
  }
  e2ei_is_pki_env_setup() {
    const ret = wasm.corecrypto_e2ei_is_pki_env_setup(this.__wbg_ptr);
    return ret;
  }
  e2ei_conversation_state(conversation_id) {
    _assertClass(conversation_id, ConversationId);
    const ret = wasm.corecrypto_e2ei_conversation_state(this.__wbg_ptr, conversation_id.__wbg_ptr);
    return ret;
  }
  client_public_key(ciphersuite, credential_type) {
    const ret = wasm.corecrypto_client_public_key(this.__wbg_ptr, ciphersuite, credential_type);
    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);
  }
  transaction(command) {
    const ret = wasm.corecrypto_transaction(this.__wbg_ptr, command);
    return ret;
  }
  proteus_fingerprint() {
    const ret = wasm.corecrypto_proteus_fingerprint(this.__wbg_ptr);
    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_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);
    }
  }
  static history_client(history_secret) {
    _assertClass(history_secret, HistorySecret);
    var ptr0 = history_secret.__destroy_into_raw();
    const ret = wasm.corecrypto_history_client(ptr0);
    return ret;
  }
}
if (Symbol.dispose)
  CoreCrypto.prototype[Symbol.dispose] = CoreCrypto.prototype.free;
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);
  }
  random_bytes(len) {
    const ret = wasm.corecryptocontext_random_bytes(this.__wbg_ptr, len);
    return ret;
  }
  get_data() {
    const ret = wasm.corecryptocontext_get_data(this.__wbg_ptr);
    return ret;
  }
  set_data(data) {
    const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_set_data(this.__wbg_ptr, ptr0, len0);
    return ret;
  }
  get_client_ids(conversation_id) {
    _assertClass(conversation_id, ConversationId);
    const ret = wasm.corecryptocontext_get_client_ids(this.__wbg_ptr, conversation_id.__wbg_ptr);
    return ret;
  }
  decrypt_message(conversation_id, payload) {
    _assertClass(conversation_id, ConversationId);
    const ptr0 = passArray8ToWasm0(payload, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_decrypt_message(this.__wbg_ptr, conversation_id.__wbg_ptr, ptr0, len0);
    return ret;
  }
  encrypt_message(conversation_id, message) {
    _assertClass(conversation_id, ConversationId);
    const ptr0 = passArray8ToWasm0(message, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_encrypt_message(this.__wbg_ptr, conversation_id.__wbg_ptr, ptr0, len0);
    return ret;
  }
  client_public_key(ciphersuite, credential_type) {
    const ret = wasm.corecryptocontext_client_public_key(this.__wbg_ptr, ciphersuite, credential_type);
    return ret;
  }
  export_secret_key(conversation_id, key_length) {
    _assertClass(conversation_id, ConversationId);
    const ret = wasm.corecryptocontext_export_secret_key(this.__wbg_ptr, conversation_id.__wbg_ptr, key_length);
    return ret;
  }
  wipe_conversation(conversation_id) {
    _assertClass(conversation_id, ConversationId);
    const ret = wasm.corecryptocontext_wipe_conversation(this.__wbg_ptr, conversation_id.__wbg_ptr);
    return ret;
  }
  client_keypackages(ciphersuite, credential_type, amount_requested) {
    const ret = wasm.corecryptocontext_client_keypackages(this.__wbg_ptr, ciphersuite, credential_type, amount_requested);
    return ret;
  }
  conversation_epoch(conversation_id) {
    _assertClass(conversation_id, ConversationId);
    const ret = wasm.corecryptocontext_conversation_epoch(this.__wbg_ptr, conversation_id.__wbg_ptr);
    return ret;
  }
  conversation_exists(conversation_id) {
    _assertClass(conversation_id, ConversationId);
    const ret = wasm.corecryptocontext_conversation_exists(this.__wbg_ptr, conversation_id.__wbg_ptr);
    return ret;
  }
  create_conversation(conversation_id, creator_credential_type, config) {
    _assertClass(conversation_id, ConversationId);
    _assertClass(config, ConversationConfiguration);
    var ptr0 = config.__destroy_into_raw();
    const ret = wasm.corecryptocontext_create_conversation(this.__wbg_ptr, conversation_id.__wbg_ptr, creator_credential_type, ptr0);
    return ret;
  }
  get_external_sender(conversation_id) {
    _assertClass(conversation_id, ConversationId);
    const ret = wasm.corecryptocontext_get_external_sender(this.__wbg_ptr, conversation_id.__wbg_ptr);
    return ret;
  }
  enable_history_sharing(conversation_id) {
    _assertClass(conversation_id, ConversationId);
    const ret = wasm.corecryptocontext_enable_history_sharing(this.__wbg_ptr, conversation_id.__wbg_ptr);
    return ret;
  }
  update_keying_material(conversation_id) {
    _assertClass(conversation_id, ConversationId);
    const ret = wasm.corecryptocontext_update_keying_material(this.__wbg_ptr, conversation_id.__wbg_ptr);
    return ret;
  }
  disable_history_sharing(conversation_id) {
    _assertClass(conversation_id, ConversationId);
    const ret = wasm.corecryptocontext_disable_history_sharing(this.__wbg_ptr, conversation_id.__wbg_ptr);
    return ret;
  }
  join_by_external_commit(group_info, custom_configuration, credential_type) {
    _assertClass(group_info, GroupInfo);
    var ptr0 = group_info.__destroy_into_raw();
    _assertClass(custom_configuration, CustomConfiguration);
    var ptr1 = custom_configuration.__destroy_into_raw();
    const ret = wasm.corecryptocontext_join_by_external_commit(this.__wbg_ptr, ptr0, ptr1, credential_type);
    return ret;
  }
  process_welcome_message(welcome_message, custom_configuration) {
    _assertClass(welcome_message, Welcome);
    var ptr0 = welcome_message.__destroy_into_raw();
    _assertClass(custom_configuration, CustomConfiguration);
    var ptr1 = custom_configuration.__destroy_into_raw();
    const ret = wasm.corecryptocontext_process_welcome_message(this.__wbg_ptr, ptr0, ptr1);
    return ret;
  }
  commit_pending_proposals(conversation_id) {
    _assertClass(conversation_id, ConversationId);
    const ret = wasm.corecryptocontext_commit_pending_proposals(this.__wbg_ptr, conversation_id.__wbg_ptr);
    return ret;
  }
  conversation_ciphersuite(conversation_id) {
    _assertClass(conversation_id, ConversationId);
    const ret = wasm.corecryptocontext_conversation_ciphersuite(this.__wbg_ptr, conversation_id.__wbg_ptr);
    return ret;
  }
  add_clients_to_conversation(conversation_id, key_packages) {
    _assertClass(conversation_id, ConversationId);
    const ptr0 = passArrayJsValueToWasm0(key_packages, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_add_clients_to_conversation(this.__wbg_ptr, conversation_id.__wbg_ptr, ptr0, len0);
    return ret;
  }
  mark_conversation_as_child_of(child_id, parent_id) {
    _assertClass(child_id, ConversationId);
    _assertClass(parent_id, ConversationId);
    const ret = wasm.corecryptocontext_mark_conversation_as_child_of(this.__wbg_ptr, child_id.__wbg_ptr, parent_id.__wbg_ptr);
    return ret;
  }
  client_valid_keypackages_count(ciphersuite, credential_type) {
    const ret = wasm.corecryptocontext_client_valid_keypackages_count(this.__wbg_ptr, ciphersuite, credential_type);
    return ret;
  }
  remove_clients_from_conversation(conversation_id, clients) {
    _assertClass(conversation_id, ConversationId);
    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.__wbg_ptr, ptr0, len0);
    return ret;
  }
  mls_init(client_id, ciphersuites, nb_key_package) {
    _assertClass(client_id, ClientId);
    var ptr0 = client_id.__destroy_into_raw();
    const ptr1 = passArrayJsValueToWasm0(ciphersuites, wasm.__wbindgen_malloc);
    const len1 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_mls_init(this.__wbg_ptr, ptr0, ptr1, len1, isLikeNone(nb_key_package) ? 4294967297 : nb_key_package >>> 0);
    return ret;
  }
  e2ei_rotate(conversation_id) {
    _assertClass(conversation_id, ConversationId);
    const ret = wasm.corecryptocontext_e2ei_rotate(this.__wbg_ptr, conversation_id.__wbg_ptr);
    return ret;
  }
  e2ei_is_enabled(ciphersuite) {
    const ret = wasm.corecryptocontext_e2ei_is_enabled(this.__wbg_ptr, ciphersuite);
    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_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;
    const ret = wasm.corecryptocontext_e2ei_new_enrollment(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, expiry_sec, ciphersuite);
    return ret;
  }
  get_user_identities(conversation_id, user_ids) {
    _assertClass(conversation_id, ConversationId);
    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.__wbg_ptr, ptr0, len0);
    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;
  }
  e2ei_enrollment_stash(enrollment) {
    _assertClass(enrollment, FfiWire