@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/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 (cause) {
      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 getArrayU8FromWasm0(ptr, len) {
  ptr = ptr >>> 0;
  return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
}
function isLikeNone(x) {
  return x === undefined || x === null;
}
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 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 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;
  const mem = getDataViewMemory0();
  for (let i = 0;i < array.length; i++) {
    mem.setUint32(ptr + 4 * i, addToExternrefTable0(array[i]), true);
  }
  WASM_VECTOR_LEN = array.length;
  return ptr;
}
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 _assertClass(instance, klass) {
  if (!(instance instanceof klass)) {
    throw new Error(`expected instance of ${klass.name}`);
  }
}
function takeFromExternrefTable0(idx) {
  const value = wasm.__wbindgen_export_4.get(idx);
  wasm.__externref_table_dealloc(idx);
  return value;
}
function __wbg_adapter_60(arg0, arg1, arg2) {
  wasm.closure896_externref_shim(arg0, arg1, arg2);
}
function __wbg_adapter_63(arg0, arg1, arg2) {
  wasm.closure2579_externref_shim(arg0, arg1, arg2);
}
function __wbg_adapter_66(arg0, arg1, arg2) {
  wasm.closure2776_externref_shim(arg0, arg1, arg2);
}
function __wbg_adapter_506(arg0, arg1, arg2, arg3) {
  wasm.closure2864_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 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 new_nonce() {
    let deferred1_0;
    let deferred1_1;
    try {
      const ret = wasm.__wbg_get_acmedirectory_new_nonce(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 new_account() {
    let deferred1_0;
    let deferred1_1;
    try {
      const ret = wasm.__wbg_get_acmedirectory_new_account(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 new_order() {
    let deferred1_0;
    let deferred1_1;
    try {
      const ret = wasm.__wbg_get_acmedirectory_new_order(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 revoke_cert() {
    let deferred1_0;
    let deferred1_1;
    try {
      const ret = wasm.__wbg_get_acmedirectory_revoke_cert(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 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.buffereddecryptedmessage_message(this.__wbg_ptr);
    return ret;
  }
  get proposals() {
    const ret = wasm.buffereddecryptedmessage_proposals(this.__wbg_ptr);
    return ret;
  }
  get is_active() {
    const ret = wasm.buffereddecryptedmessage_is_active(this.__wbg_ptr);
    return ret !== 0;
  }
  get commit_delay() {
    const ret = wasm.buffereddecryptedmessage_commit_delay(this.__wbg_ptr);
    return ret === 4294967297 ? undefined : ret;
  }
  get sender_client_id() {
    const ret = wasm.buffereddecryptedmessage_sender_client_id(this.__wbg_ptr);
    return ret;
  }
  get has_epoch_changed() {
    const ret = wasm.buffereddecryptedmessage_has_epoch_changed(this.__wbg_ptr);
    return ret !== 0;
  }
  get identity() {
    const ret = wasm.buffereddecryptedmessage_identity(this.__wbg_ptr);
    return WireIdentity.__wrap(ret);
  }
  get crl_new_distribution_points() {
    const ret = wasm.buffereddecryptedmessage_crl_new_distribution_points(this.__wbg_ptr);
    return 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 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 commit() {
    const ret = wasm.commitbundle_commit(this.__wbg_ptr);
    return ret;
  }
  get welcome() {
    const ret = wasm.commitbundle_welcome(this.__wbg_ptr);
    return ret;
  }
  get group_info() {
    const ret = wasm.commitbundle_group_info(this.__wbg_ptr);
    return GroupInfoBundle.__wrap(ret);
  }
}
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);
  }
  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;
  }
  get externalSenders() {
    const ret = wasm.conversationconfiguration_externalSenders(this.__wbg_ptr);
    return ret;
  }
  get ciphersuite() {
    const ret = wasm.__wbg_get_conversationconfiguration_ciphersuite(this.__wbg_ptr);
    return ret === 0 ? undefined : ret;
  }
  get custom() {
    const ret = wasm.__wbg_get_conversationconfiguration_custom(this.__wbg_ptr);
    return CustomConfiguration.__wrap(ret);
  }
}
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);
  }
  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) {
    const ret = wasm.corecrypto_e2ei_is_enabled(this.__wbg_ptr, ciphersuite);
    return ret;
  }
  get_device_identities(conversation_id, device_ids) {
    const ptr0 = passArray8ToWasm0(conversation_id, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ptr1 = passArrayJsValueToWasm0(device_ids, wasm.__wbindgen_malloc);
    const len1 = WASM_VECTOR_LEN;
    const ret = wasm.corecrypto_get_device_identities(this.__wbg_ptr, ptr0, len0, ptr1, len1);
    return ret;
  }
  get_user_identities(conversation_id, user_ids) {
    const ptr0 = passArray8ToWasm0(conversation_id, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ptr1 = passArrayJsValueToWasm0(user_ids, wasm.__wbindgen_malloc);
    const len1 = WASM_VECTOR_LEN;
    const ret = wasm.corecrypto_get_user_identities(this.__wbg_ptr, ptr0, len0, ptr1, len1);
    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;
  }
  static version() {
    let deferred1_0;
    let deferred1_1;
    try {
      const ret = wasm.corecrypto_version();
      deferred1_0 = ret[0];
      deferred1_1 = ret[1];
      return getStringFromWasm0(ret[0], ret[1]);
    } finally {
      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
    }
  }
  static build_metadata() {
    const ret = wasm.corecrypto_build_metadata();
    return BuildMetadata.__wrap(ret);
  }
  static _internal_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;
    const ptr1 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len1 = WASM_VECTOR_LEN;
    const ptr2 = passArray8ToWasm0(client_id, wasm.__wbindgen_malloc);
    const len2 = WASM_VECTOR_LEN;
    const ptr3 = passArray16ToWasm0(ciphersuites, wasm.__wbindgen_malloc);
    const 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__internal_new(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, 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;
    const ptr1 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len1 = WASM_VECTOR_LEN;
    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, len1, ptr2, len2);
    return ret;
  }
  has_outstanding_refs() {
    const ret = wasm.corecrypto_has_outstanding_refs(this.__wbg_ptr);
    return ret !== 0;
  }
  close() {
    const ptr = this.__destroy_into_raw();
    const ret = wasm.corecrypto_close(ptr);
    return ret;
  }
  static set_logger(logger) {
    _assertClass(logger, CoreCryptoWasmLogger);
    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, MlsTransportProvider);
    var ptr0 = callbacks.__destroy_into_raw();
    const ret = wasm.corecrypto_provide_transport(this.__wbg_ptr, ptr0);
    return ret;
  }
  client_public_key(ciphersuite, credential_type) {
    const ret = wasm.corecrypto_client_public_key(this.__wbg_ptr, ciphersuite, credential_type);
    return ret;
  }
  conversation_epoch(conversation_id) {
    const ptr0 = passArray8ToWasm0(conversation_id, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.corecrypto_conversation_epoch(this.__wbg_ptr, ptr0, len0);
    return ret;
  }
  conversation_ciphersuite(conversation_id) {
    const ptr0 = passArray8ToWasm0(conversation_id, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.corecrypto_conversation_ciphersuite(this.__wbg_ptr, ptr0, len0);
    return ret;
  }
  conversation_exists(conversation_id) {
    const ptr0 = passArray8ToWasm0(conversation_id, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.corecrypto_conversation_exists(this.__wbg_ptr, ptr0, len0);
    return ret;
  }
  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;
  }
  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;
  }
  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];
  }
  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_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);
    }
  }
  export_secret_key(conversation_id, key_length) {
    const ptr0 = passArray8ToWasm0(conversation_id, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.corecrypto_export_secret_key(this.__wbg_ptr, ptr0, len0, key_length);
    return ret;
  }
  get_external_sender(id) {
    const ptr0 = passArray8ToWasm0(id, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.corecrypto_get_external_sender(this.__wbg_ptr, ptr0, len0);
    return ret;
  }
  get_client_ids(conversation_id) {
    const ptr0 = passArray8ToWasm0(conversation_id, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.corecrypto_get_client_ids(this.__wbg_ptr, ptr0, len0);
    return ret;
  }
  register_epoch_observer(epoch_observer) {
    const ret = wasm.corecrypto_register_epoch_observer(this.__wbg_ptr, epoch_observer);
    return ret;
  }
  transaction(command) {
    const ret = wasm.corecrypto_transaction(this.__wbg_ptr, command);
    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);
  }
  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_data() {
    const ret = wasm.corecryptocontext_get_data(this.__wbg_ptr);
    return ret;
  }
  mls_init(client_id, ciphersuites, nb_key_package) {
    const ptr0 = passArray8ToWasm0(client_id, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ptr1 = passArray16ToWasm0(ciphersuites, wasm.__wbindgen_malloc);
    const len1 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_mls_init(this.__wbg_ptr, ptr0, len0, ptr1, len1, isLikeNone(nb_key_package) ? 4294967297 : nb_key_package >>> 0);
    return ret;
  }
  mls_generate_keypair(ciphersuites) {
    const ptr0 = passArray16ToWasm0(ciphersuites, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_mls_generate_keypair(this.__wbg_ptr, ptr0, len0);
    return ret;
  }
  mls_init_with_client_id(client_id, signature_public_keys, ciphersuites) {
    const ptr0 = passArray8ToWasm0(client_id, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ptr1 = passArrayJsValueToWasm0(signature_public_keys, wasm.__wbindgen_malloc);
    const len1 = WASM_VECTOR_LEN;
    const ptr2 = passArray16ToWasm0(ciphersuites, wasm.__wbindgen_malloc);
    const len2 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_mls_init_with_client_id(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
    return ret;
  }
  client_public_key(ciphersuite, credential_type) {
    const ret = wasm.corecryptocontext_client_public_key(this.__wbg_ptr, ciphersuite, credential_type);
    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;
  }
  client_valid_keypackages_count(ciphersuite, credential_type) {
    const ret = wasm.corecryptocontext_client_valid_keypackages_count(this.__wbg_ptr, ciphersuite, credential_type);
    return ret;
  }
  delete_keypackages(refs) {
    const ptr0 = passArrayJsValueToWasm0(refs, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_delete_keypackages(this.__wbg_ptr, ptr0, len0);
    return ret;
  }
  create_conversation(conversation_id, creator_credential_type, config) {
    const ptr0 = passArray8ToWasm0(conversation_id, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    _assertClass(config, ConversationConfiguration);
    var ptr1 = config.__destroy_into_raw();
    const ret = wasm.corecryptocontext_create_conversation(this.__wbg_ptr, ptr0, len0, creator_credential_type, ptr1);
    return ret;
  }
  conversation_epoch(conversation_id) {
    const ptr0 = passArray8ToWasm0(conversation_id, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_conversation_epoch(this.__wbg_ptr, ptr0, len0);
    return ret;
  }
  conversation_ciphersuite(conversation_id) {
    const ptr0 = passArray8ToWasm0(conversation_id, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_conversation_ciphersuite(this.__wbg_ptr, ptr0, len0);
    return ret;
  }
  conversation_exists(conversation_id) {
    const ptr0 = passArray8ToWasm0(conversation_id, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_conversation_exists(this.__wbg_ptr, ptr0, len0);
    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) {
    const ptr0 = passArray8ToWasm0(conversation_id, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ptr1 = passArrayJsValueToWasm0(key_packages, wasm.__wbindgen_malloc);
    const len1 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_add_clients_to_conversation(this.__wbg_ptr, ptr0, len0, ptr1, len1);
    return ret;
  }
  remove_clients_from_conversation(conversation_id, clients) {
    const ptr0 = passArray8ToWasm0(conversation_id, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ptr1 = passArrayJsValueToWasm0(clients, wasm.__wbindgen_malloc);
    const len1 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_remove_clients_from_conversation(this.__wbg_ptr, ptr0, len0, ptr1, len1);
    return ret;
  }
  mark_conversation_as_child_of(child_id, parent_id) {
    const ptr0 = passArray8ToWasm0(child_id, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ptr1 = passArray8ToWasm0(parent_id, wasm.__wbindgen_malloc);
    const len1 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_mark_conversation_as_child_of(this.__wbg_ptr, ptr0, len0, ptr1, len1);
    return ret;
  }
  update_keying_material(conversation_id) {
    const ptr0 = passArray8ToWasm0(conversation_id, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_update_keying_material(this.__wbg_ptr, ptr0, len0);
    return ret;
  }
  commit_pending_proposals(conversation_id) {
    const ptr0 = passArray8ToWasm0(conversation_id, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_commit_pending_proposals(this.__wbg_ptr, ptr0, len0);
    return ret;
  }
  wipe_conversation(conversation_id) {
    const ptr0 = passArray8ToWasm0(conversation_id, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_wipe_conversation(this.__wbg_ptr, ptr0, len0);
    return ret;
  }
  decrypt_message(conversation_id, payload) {
    const ptr0 = passArray8ToWasm0(conversation_id, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ptr1 = passArray8ToWasm0(payload, wasm.__wbindgen_malloc);
    const len1 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_decrypt_message(this.__wbg_ptr, ptr0, len0, ptr1, len1);
    return ret;
  }
  encrypt_message(conversation_id, message) {
    const ptr0 = passArray8ToWasm0(conversation_id, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ptr1 = passArray8ToWasm0(message, wasm.__wbindgen_malloc);
    const len1 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_encrypt_message(this.__wbg_ptr, ptr0, len0, ptr1, len1);
    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;
  }
  random_bytes(len) {
    const ret = wasm.corecryptocontext_random_bytes(this.__wbg_ptr, len);
    return ret;
  }
  export_secret_key(conversation_id, key_length) {
    const ptr0 = passArray8ToWasm0(conversation_id, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_export_secret_key(this.__wbg_ptr, ptr0, len0, key_length);
    return ret;
  }
  get_external_sender(id) {
    const ptr0 = passArray8ToWasm0(id, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_get_external_sender(this.__wbg_ptr, ptr0, len0);
    return ret;
  }
  get_client_ids(conversation_id) {
    const ptr0 = passArray8ToWasm0(conversation_id, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_get_client_ids(this.__wbg_ptr, ptr0, len0);
    return ret;
  }
  proteus_init() {
    const ret = wasm.corecryptocontext_proteus_init(this.__wbg_ptr);
    return ret;
  }
  proteus_session_from_prekey(session_id, prekey) {
    const ptr0 = passStringToWasm0(session_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ptr1 = passArray8ToWasm0(prekey, wasm.__wbindgen_malloc);
    const len1 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_proteus_session_from_prekey(this.__wbg_ptr, ptr0, len0, ptr1, len1);
    return ret;
  }
  proteus_session_from_message(session_id, envelope) {
    const ptr0 = passStringToWasm0(session_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ptr1 = passArray8ToWasm0(envelope, wasm.__wbindgen_malloc);
    const len1 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_proteus_session_from_message(this.__wbg_ptr, ptr0, len0, ptr1, len1);
    return ret;
  }
  proteus_session_save(session_id) {
    const ptr0 = passStringToWasm0(session_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_proteus_session_save(this.__wbg_ptr, ptr0, len0);
    return ret;
  }
  proteus_session_delete(session_id) {
    const ptr0 = passStringToWasm0(session_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_proteus_session_delete(this.__wbg_ptr, ptr0, len0);
    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.corecryptocontext_proteus_session_exists(this.__wbg_ptr, ptr0, len0);
    return ret;
  }
  proteus_decrypt(session_id, ciphertext) {
    const ptr0 = passStringToWasm0(session_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ptr1 = passArray8ToWasm0(ciphertext, wasm.__wbindgen_malloc);
    const len1 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_proteus_decrypt(this.__wbg_ptr, ptr0, len0, ptr1, len1);
    return ret;
  }
  proteus_encrypt(session_id, plaintext) {
    const ptr0 = passStringToWasm0(session_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ptr1 = passArray8ToWasm0(plaintext, wasm.__wbindgen_malloc);
    const len1 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_proteus_encrypt(this.__wbg_ptr, ptr0, len0, ptr1, len1);
    return ret;
  }
  proteus_encrypt_batched(sessions, plaintext) {
    const ptr0 = passArrayJsValueToWasm0(sessions, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ptr1 = passArray8ToWasm0(plaintext, wasm.__wbindgen_malloc);
    const len1 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_proteus_encrypt_batched(this.__wbg_ptr, ptr0, len0, ptr1, len1);
    return ret;
  }
  proteus_new_prekey(prekey_id) {
    const ret = wasm.corecryptocontext_proteus_new_prekey(this.__wbg_ptr, prekey_id);
    return ret;
  }
  proteus_new_prekey_auto() {
    const ret = wasm.corecryptocontext_proteus_new_prekey_auto(this.__wbg_ptr);
    return ret;
  }
  proteus_last_resort_prekey() {
    const ret = wasm.corecryptocontext_proteus_last_resort_prekey(this.__wbg_ptr);
    return ret;
  }
  static proteus_last_resort_prekey_id() {
    const ret = wasm.corecryptocontext_proteus_last_resort_prekey_id();
    if (ret[2]) {
      throw takeFromExternrefTable0(ret[1]);
    }
    return ret[0];
  }
  proteus_fingerprint() {
    const ret = wasm.corecryptocontext_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.corecryptocontext_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.corecryptocontext_proteus_fingerprint_remote(this.__wbg_ptr, ptr0, len0);
    return ret;
  }
  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.corecryptocontext_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);
    }
  }
  proteus_cryptobox_migrate(path) {
    const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_proteus_cryptobox_migrate(this.__wbg_ptr, ptr0, len0);
    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;
  }
  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;
    const ret = wasm.corecryptocontext_e2ei_new_activation_enrollment(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, expiry_sec, ciphersuite);
    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;
    const ret = wasm.corecryptocontext_e2ei_new_rotate_enrollment(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, expiry_sec, ciphersuite);
    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;
  }
  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 ptr0 = passArray8ToWasm0(conversation_id, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_e2ei_rotate(this.__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;
  }
  delete_stale_key_packages(cipher_suite) {
    const ret = wasm.corecryptocontext_delete_stale_key_packages(this.__wbg_ptr, cipher_suite);
    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 ptr0 = passArray8ToWasm0(conversation_id, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.corecryptocontext_e2ei_conversation_state(this.__wbg_ptr, ptr0, len0);
    return ret;
  }
  e2ei_is_enabled(ciphersuite) {
    const ret = wasm.corecryptocontext_e2ei_is_enabled(this.__wbg_ptr, ciphersuite);
    return ret;
  }
  get_device_identities(conversation_id, device_ids) {
    const ptr0 = passArray8ToWasm0(conversation_id, wasm.__wbindgen_malloc);
    const len0 = WASM_VECTOR_LEN;
    const ptr1 = passArrayJsValueToWasm0(device_ids, wasm.__wbindgen