@wireapp/core-crypto 0.6.0-rc.3 → 0.6.0-rc.5

package/platforms/web/corecrypto.js

@@ -26,6 +26,28 @@ function __classPrivateFieldSet(receiver, state, value, kind, f) {
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 }
 
+class CoreCryptoError extends Error {
+        constructor(message, rustStackTrace, ...params) {
+            super(...params);
+
+            if (Error.captureStackTrace) {
+                Error.captureStackTrace(this, CoreCryptoError);
+            }
+
+            this.name = "CoreCryptoError";
+            this.rustStackTrace = rustStackTrace;
+            this.proteusErrorCode = 0;
+        }
+
+        setProteusErrorCode(code) {
+            this.proteusErrorCode = code;
+        }
+
+        proteusError() {
+            return this.proteusErrorCode;
+        }
+    }
+
 let wasm$1;
 
 const heap = new Array(32).fill(undefined);
@@ -57,6 +79,37 @@ function takeObject(idx) {
     return ret;
 }
 
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+let cachedFloat64Memory0 = new Float64Array();
+
+function getFloat64Memory0() {
+    if (cachedFloat64Memory0.byteLength === 0) {
+        cachedFloat64Memory0 = new Float64Array(wasm$1.memory.buffer);
+    }
+    return cachedFloat64Memory0;
+}
+
+let cachedInt32Memory0 = new Int32Array();
+
+function getInt32Memory0() {
+    if (cachedInt32Memory0.byteLength === 0) {
+        cachedInt32Memory0 = new Int32Array(wasm$1.memory.buffer);
+    }
+    return cachedInt32Memory0;
+}
+
+let cachedBigInt64Memory0 = new BigInt64Array();
+
+function getBigInt64Memory0() {
+    if (cachedBigInt64Memory0.byteLength === 0) {
+        cachedBigInt64Memory0 = new BigInt64Array(wasm$1.memory.buffer);
+    }
+    return cachedBigInt64Memory0;
+}
+
 const cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
 
 cachedTextDecoder.decode();
@@ -129,37 +182,6 @@ function passStringToWasm0(arg, malloc, realloc) {
     return ptr;
 }
 
-function isLikeNone(x) {
-    return x === undefined || x === null;
-}
-
-let cachedInt32Memory0 = new Int32Array();
-
-function getInt32Memory0() {
-    if (cachedInt32Memory0.byteLength === 0) {
-        cachedInt32Memory0 = new Int32Array(wasm$1.memory.buffer);
-    }
-    return cachedInt32Memory0;
-}
-
-let cachedFloat64Memory0 = new Float64Array();
-
-function getFloat64Memory0() {
-    if (cachedFloat64Memory0.byteLength === 0) {
-        cachedFloat64Memory0 = new Float64Array(wasm$1.memory.buffer);
-    }
-    return cachedFloat64Memory0;
-}
-
-let cachedBigInt64Memory0 = new BigInt64Array();
-
-function getBigInt64Memory0() {
-    if (cachedBigInt64Memory0.byteLength === 0) {
-        cachedBigInt64Memory0 = new BigInt64Array(wasm$1.memory.buffer);
-    }
-    return cachedBigInt64Memory0;
-}
-
 function debugString(val) {
     // primitive types
     const type = typeof val;
@@ -252,7 +274,7 @@ function makeMutClosure(arg0, arg1, dtor, f) {
 function __wbg_adapter_52(arg0, arg1, arg2) {
     try {
         const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
-        wasm$1._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h5a2d63dc59f76e61(retptr, arg0, arg1, addHeapObject(arg2));
+        wasm$1._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h577395c5a39b7036(retptr, arg0, arg1, addHeapObject(arg2));
         var r0 = getInt32Memory0()[retptr / 4 + 0];
         var r1 = getInt32Memory0()[retptr / 4 + 1];
         if (r1) {
@@ -264,31 +286,7 @@ function __wbg_adapter_52(arg0, arg1, arg2) {
 }
 
 function __wbg_adapter_55(arg0, arg1, arg2) {
-    wasm$1._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h6d113a8418e47593(arg0, arg1, addHeapObject(arg2));
-}
-
-/**
-* Returns the current version of CoreCrypto
-* @returns {string}
-*/
-function version() {
-    try {
-        const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
-        wasm$1.version(retptr);
-        var r0 = getInt32Memory0()[retptr / 4 + 0];
-        var r1 = getInt32Memory0()[retptr / 4 + 1];
-        return getStringFromWasm0(r0, r1);
-    } finally {
-        wasm$1.__wbindgen_add_to_stack_pointer(16);
-        wasm$1.__wbindgen_free(r0, r1);
-    }
-}
-
-function passArray8ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 1);
-    getUint8Memory0().set(arg, ptr / 1);
-    WASM_VECTOR_LEN = arg.length;
-    return ptr;
+    wasm$1._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h6fecff61d3f85de1(arg0, arg1, addHeapObject(arg2));
 }
 
 function _assertClass(instance, klass) {
@@ -317,6 +315,39 @@ function passArrayJsValueToWasm0(array, malloc) {
     return ptr;
 }
 
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1);
+    getUint8Memory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function getArrayJsValueFromWasm0(ptr, len) {
+    const mem = getUint32Memory0();
+    const slice = mem.subarray(ptr / 4, ptr / 4 + len);
+    const result = [];
+    for (let i = 0; i < slice.length; i++) {
+        result.push(takeObject(slice[i]));
+    }
+    return result;
+}
+/**
+* Returns the current version of CoreCrypto
+* @returns {string}
+*/
+function version() {
+    try {
+        const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+        wasm$1.version(retptr);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm$1.__wbindgen_add_to_stack_pointer(16);
+        wasm$1.__wbindgen_free(r0, r1);
+    }
+}
+
 function handleError(f, args) {
     try {
         return f.apply(this, args);
@@ -328,8 +359,8 @@ function handleError(f, args) {
 function getArrayU8FromWasm0(ptr, len) {
     return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len);
 }
-function __wbg_adapter_220(arg0, arg1, arg2, arg3) {
-    wasm$1.wasm_bindgen__convert__closures__invoke2_mut__h05b8fb12110402b0(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wbg_adapter_264(arg0, arg1, arg2, arg3) {
+    wasm$1.wasm_bindgen__convert__closures__invoke2_mut__ha446eb95921e2107(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
 /**
@@ -377,8 +408,16 @@ MLS_256_DHKEMX448_CHACHA20POLY1305_SHA512_Ed448:6,"6":"MLS_256_DHKEMX448_CHACHA2
 */
 MLS_256_DHKEMP384_AES256GCM_SHA384_P384:7,"7":"MLS_256_DHKEMP384_AES256GCM_SHA384_P384", });
 /**
+* See [core_crypto::e2e_identity::types::E2eiAcmeChallenge]
 */
-class CommitBundle {
+class AcmeChallenge {
+
+    static __wrap(ptr) {
+        const obj = Object.create(AcmeChallenge.prototype);
+        obj.ptr = ptr;
+
+        return obj;
+    }
 
     __destroy_into_raw() {
         const ptr = this.ptr;
@@ -389,37 +428,48 @@ class CommitBundle {
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm$1.__wbg_commitbundle_free(ptr);
+        wasm$1.__wbg_acmechallenge_free(ptr);
     }
     /**
-    * @returns {Uint8Array}
+    * @param {Uint8Array} delegate
+    * @param {string} url
     */
-    get commit() {
-        const ret = wasm$1.commitbundle_commit(this.ptr);
-        return takeObject(ret);
+    constructor(delegate, url) {
+        const ptr0 = passStringToWasm0(url, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm$1.acmechallenge_new(addHeapObject(delegate), ptr0, len0);
+        return AcmeChallenge.__wrap(ret);
     }
     /**
-    * @returns {Uint8Array | undefined}
+    * @returns {Uint8Array}
     */
-    get welcome() {
-        const ret = wasm$1.commitbundle_welcome(this.ptr);
+    get delegate() {
+        const ret = wasm$1.acmechallenge_delegate(this.ptr);
         return takeObject(ret);
     }
     /**
-    * @returns {PublicGroupStateBundle}
+    * @returns {string}
     */
-    get public_group_state() {
-        const ret = wasm$1.commitbundle_public_group_state(this.ptr);
-        return PublicGroupStateBundle.__wrap(ret);
+    get url() {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            wasm$1.acmechallenge_url(retptr, this.ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+            wasm$1.__wbindgen_free(r0, r1);
+        }
     }
 }
 /**
-* see [core_crypto::prelude::MlsConversationConfiguration]
+* See [core_crypto::e2e_identity::types::E2eiAcmeDirectory]
 */
-class ConversationConfiguration {
+class AcmeDirectory {
 
     static __wrap(ptr) {
-        const obj = Object.create(ConversationConfiguration.prototype);
+        const obj = Object.create(AcmeDirectory.prototype);
         obj.ptr = ptr;
 
         return obj;
@@ -434,24 +484,80 @@ class ConversationConfiguration {
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm$1.__wbg_conversationconfiguration_free(ptr);
+        wasm$1.__wbg_acmedirectory_free(ptr);
     }
     /**
-    * @param {number | undefined} ciphersuite
-    * @param {(Uint8Array)[] | undefined} external_senders
-    * @param {number | undefined} key_rotation_span
-    * @param {number | undefined} wire_policy
+    * @param {string} new_nonce
+    * @param {string} new_account
+    * @param {string} new_order
     */
-    constructor(ciphersuite, external_senders, key_rotation_span, wire_policy) {
-        var ptr0 = isLikeNone(external_senders) ? 0 : passArrayJsValueToWasm0(external_senders, wasm$1.__wbindgen_malloc);
-        var len0 = WASM_VECTOR_LEN;
-        const ret = wasm$1.conversationconfiguration_new(isLikeNone(ciphersuite) ? 8 : ciphersuite, ptr0, len0, !isLikeNone(key_rotation_span), isLikeNone(key_rotation_span) ? 0 : key_rotation_span, isLikeNone(wire_policy) ? 3 : wire_policy);
-        return ConversationConfiguration.__wrap(ret);
+    constructor(new_nonce, new_account, new_order) {
+        const ptr0 = passStringToWasm0(new_nonce, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(new_account, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(new_order, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm$1.acmedirectory_new(ptr0, len0, ptr1, len1, ptr2, len2);
+        return AcmeDirectory.__wrap(ret);
+    }
+    /**
+    * @returns {string}
+    */
+    get new_nonce() {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            wasm$1.acmedirectory_new_nonce(retptr, this.ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+            wasm$1.__wbindgen_free(r0, r1);
+        }
+    }
+    /**
+    * @returns {string}
+    */
+    get new_account() {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            wasm$1.acmechallenge_url(retptr, this.ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+            wasm$1.__wbindgen_free(r0, r1);
+        }
+    }
+    /**
+    * @returns {string}
+    */
+    get new_order() {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            wasm$1.acmedirectory_new_order(retptr, this.ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+            wasm$1.__wbindgen_free(r0, r1);
+        }
     }
 }
 /**
+* See [core_crypto::e2e_identity::types::E2eiAcmeFinalize]
 */
-class ConversationInitBundle {
+class AcmeFinalize {
+
+    static __wrap(ptr) {
+        const obj = Object.create(AcmeFinalize.prototype);
+        obj.ptr = ptr;
+
+        return obj;
+    }
 
     __destroy_into_raw() {
         const ptr = this.ptr;
@@ -462,20 +568,68 @@ class ConversationInitBundle {
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm$1.__wbg_conversationinitbundle_free(ptr);
+        wasm$1.__wbg_acmefinalize_free(ptr);
+    }
+    /**
+    * @param {Uint8Array} delegate
+    * @param {string} certificate_url
+    */
+    constructor(delegate, certificate_url) {
+        const ptr0 = passStringToWasm0(certificate_url, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm$1.acmechallenge_new(addHeapObject(delegate), ptr0, len0);
+        return AcmeFinalize.__wrap(ret);
     }
     /**
     * @returns {Uint8Array}
     */
-    get conversation_id() {
-        const ret = wasm$1.commitbundle_commit(this.ptr);
+    get delegate() {
+        const ret = wasm$1.acmechallenge_delegate(this.ptr);
         return takeObject(ret);
     }
     /**
+    * @returns {string}
+    */
+    get certificate_url() {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            wasm$1.acmechallenge_url(retptr, this.ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+            wasm$1.__wbindgen_free(r0, r1);
+        }
+    }
+}
+/**
+*/
+class CommitBundle {
+
+    __destroy_into_raw() {
+        const ptr = this.ptr;
+        this.ptr = 0;
+
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm$1.__wbg_commitbundle_free(ptr);
+    }
+    /**
     * @returns {Uint8Array}
     */
     get commit() {
-        const ret = wasm$1.conversationinitbundle_commit(this.ptr);
+        const ret = wasm$1.commitbundle_commit(this.ptr);
+        return takeObject(ret);
+    }
+    /**
+    * @returns {Uint8Array | undefined}
+    */
+    get welcome() {
+        const ret = wasm$1.commitbundle_welcome(this.ptr);
         return takeObject(ret);
     }
     /**
@@ -487,11 +641,84 @@ class ConversationInitBundle {
     }
 }
 /**
+* see [core_crypto::prelude::MlsConversationConfiguration]
 */
-class CoreCrypto$1 {
+class ConversationConfiguration {
 
     static __wrap(ptr) {
-        const obj = Object.create(CoreCrypto$1.prototype);
+        const obj = Object.create(ConversationConfiguration.prototype);
+        obj.ptr = ptr;
+
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.ptr;
+        this.ptr = 0;
+
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm$1.__wbg_conversationconfiguration_free(ptr);
+    }
+    /**
+    * @param {number | undefined} ciphersuite
+    * @param {(Uint8Array)[] | undefined} external_senders
+    * @param {number | undefined} key_rotation_span
+    * @param {number | undefined} wire_policy
+    */
+    constructor(ciphersuite, external_senders, key_rotation_span, wire_policy) {
+        var ptr0 = isLikeNone(external_senders) ? 0 : passArrayJsValueToWasm0(external_senders, wasm$1.__wbindgen_malloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm$1.conversationconfiguration_new(isLikeNone(ciphersuite) ? 8 : ciphersuite, ptr0, len0, !isLikeNone(key_rotation_span), isLikeNone(key_rotation_span) ? 0 : key_rotation_span, isLikeNone(wire_policy) ? 3 : wire_policy);
+        return ConversationConfiguration.__wrap(ret);
+    }
+}
+/**
+*/
+class ConversationInitBundle {
+
+    __destroy_into_raw() {
+        const ptr = this.ptr;
+        this.ptr = 0;
+
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm$1.__wbg_conversationinitbundle_free(ptr);
+    }
+    /**
+    * @returns {Uint8Array}
+    */
+    get conversation_id() {
+        const ret = wasm$1.commitbundle_commit(this.ptr);
+        return takeObject(ret);
+    }
+    /**
+    * @returns {Uint8Array}
+    */
+    get commit() {
+        const ret = wasm$1.conversationinitbundle_commit(this.ptr);
+        return takeObject(ret);
+    }
+    /**
+    * @returns {PublicGroupStateBundle}
+    */
+    get public_group_state() {
+        const ret = wasm$1.commitbundle_public_group_state(this.ptr);
+        return PublicGroupStateBundle.__wrap(ret);
+    }
+}
+/**
+*/
+class CoreCrypto$1 {
+
+    static __wrap(ptr) {
+        const obj = Object.create(CoreCrypto$1.prototype);
         obj.ptr = ptr;
 
         return obj;
@@ -1233,6 +1460,15 @@ class CoreCrypto$1 {
         const ret = wasm$1.corecrypto_get_client_ids(this.ptr, ptr0, len0);
         return takeObject(ret);
     }
+    /**
+    * see [core_crypto::MlsCentral::new_acme_enrollment]
+    * @param {number} ciphersuite
+    * @returns {Promise<WireE2eIdentity>}
+    */
+    new_acme_enrollment(ciphersuite) {
+        const ret = wasm$1.corecrypto_new_acme_enrollment(this.ptr, ciphersuite);
+        return takeObject(ret);
+    }
 }
 /**
 * see [core_crypto::prelude::CoreCryptoCallbacks]
@@ -1469,6 +1705,130 @@ class MemberAddedMessages {
     }
 }
 /**
+* See [core_crypto::e2e_identity::types::E2eiNewAcmeAuthz]
+*/
+class NewAcmeAuthz {
+
+    static __wrap(ptr) {
+        const obj = Object.create(NewAcmeAuthz.prototype);
+        obj.ptr = ptr;
+
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.ptr;
+        this.ptr = 0;
+
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm$1.__wbg_newacmeauthz_free(ptr);
+    }
+    /**
+    * @param {string} identifier
+    * @param {AcmeChallenge | undefined} wire_http_challenge
+    * @param {AcmeChallenge | undefined} wire_oidc_challenge
+    */
+    constructor(identifier, wire_http_challenge, wire_oidc_challenge) {
+        const ptr0 = passStringToWasm0(identifier, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        let ptr1 = 0;
+        if (!isLikeNone(wire_http_challenge)) {
+            _assertClass(wire_http_challenge, AcmeChallenge);
+            ptr1 = wire_http_challenge.ptr;
+            wire_http_challenge.ptr = 0;
+        }
+        let ptr2 = 0;
+        if (!isLikeNone(wire_oidc_challenge)) {
+            _assertClass(wire_oidc_challenge, AcmeChallenge);
+            ptr2 = wire_oidc_challenge.ptr;
+            wire_oidc_challenge.ptr = 0;
+        }
+        const ret = wasm$1.newacmeauthz_new(ptr0, len0, ptr1, ptr2);
+        return NewAcmeAuthz.__wrap(ret);
+    }
+    /**
+    * @returns {string}
+    */
+    get identifier() {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            wasm$1.acmedirectory_new_nonce(retptr, this.ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+            wasm$1.__wbindgen_free(r0, r1);
+        }
+    }
+    /**
+    * @returns {AcmeChallenge | undefined}
+    */
+    get wire_http_challenge() {
+        const ret = wasm$1.newacmeauthz_wire_http_challenge(this.ptr);
+        return ret === 0 ? undefined : AcmeChallenge.__wrap(ret);
+    }
+    /**
+    * @returns {AcmeChallenge | undefined}
+    */
+    get wire_oidc_challenge() {
+        const ret = wasm$1.newacmeauthz_wire_oidc_challenge(this.ptr);
+        return ret === 0 ? undefined : AcmeChallenge.__wrap(ret);
+    }
+}
+/**
+* See [core_crypto::e2e_identity::types::E2eiNewAcmeOrder]
+*/
+class NewAcmeOrder {
+
+    static __wrap(ptr) {
+        const obj = Object.create(NewAcmeOrder.prototype);
+        obj.ptr = ptr;
+
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.ptr;
+        this.ptr = 0;
+
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm$1.__wbg_newacmeorder_free(ptr);
+    }
+    /**
+    * @param {Uint8Array} delegate
+    * @param {(Uint8Array)[]} authorizations
+    */
+    constructor(delegate, authorizations) {
+        const ptr0 = passArrayJsValueToWasm0(authorizations, wasm$1.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm$1.newacmeorder_new(addHeapObject(delegate), ptr0, len0);
+        return NewAcmeOrder.__wrap(ret);
+    }
+    /**
+    * @returns {Uint8Array}
+    */
+    get delegate() {
+        const ret = wasm$1.acmechallenge_delegate(this.ptr);
+        return takeObject(ret);
+    }
+    /**
+    * @returns {Array<any>}
+    */
+    get authorizations() {
+        const ret = wasm$1.newacmeorder_authorizations(this.ptr);
+        return takeObject(ret);
+    }
+}
+/**
 */
 class ProposalBundle {
 
@@ -1549,6 +1909,413 @@ class PublicGroupStateBundle {
         return takeObject(ret);
     }
 }
+/**
+*/
+class WireE2eIdentity$1 {
+
+    static __wrap(ptr) {
+        const obj = Object.create(WireE2eIdentity$1.prototype);
+        obj.ptr = ptr;
+
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.ptr;
+        this.ptr = 0;
+
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm$1.__wbg_wiree2eidentity_free(ptr);
+    }
+    /**
+    * See [core_crypto::e2e_identity::WireE2eIdentity::directory_response]
+    * @param {Uint8Array} directory
+    * @returns {any}
+    */
+    directory_response(directory) {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(directory, wasm$1.__wbindgen_malloc);
+            const len0 = WASM_VECTOR_LEN;
+            wasm$1.wiree2eidentity_directory_response(retptr, this.ptr, ptr0, len0);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * See [core_crypto::e2e_identity::WireE2eIdentity::new_account_request]
+    * @param {any} directory
+    * @param {string} previous_nonce
+    * @returns {Uint8Array}
+    */
+    new_account_request(directory, previous_nonce) {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(previous_nonce, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            wasm$1.wiree2eidentity_new_account_request(retptr, this.ptr, addHeapObject(directory), ptr0, len0);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * See [core_crypto::e2e_identity::WireE2eIdentity::new_account_response]
+    * @param {Uint8Array} account
+    * @returns {Uint8Array}
+    */
+    new_account_response(account) {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            wasm$1.wiree2eidentity_new_account_response(retptr, this.ptr, addHeapObject(account));
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * See [core_crypto::e2e_identity::WireE2eIdentity::new_order_request]
+    * @param {string} handle
+    * @param {string} client_id
+    * @param {number} expiry_days
+    * @param {any} directory
+    * @param {Uint8Array} account
+    * @param {string} previous_nonce
+    * @returns {Uint8Array}
+    */
+    new_order_request(handle, client_id, expiry_days, directory, account, previous_nonce) {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(handle, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(client_id, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passStringToWasm0(previous_nonce, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+            const len2 = WASM_VECTOR_LEN;
+            wasm$1.wiree2eidentity_new_order_request(retptr, this.ptr, ptr0, len0, ptr1, len1, expiry_days, addHeapObject(directory), addHeapObject(account), ptr2, len2);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * See [core_crypto::e2e_identity::WireE2eIdentity::new_order_response]
+    * @param {Uint8Array} order
+    * @returns {any}
+    */
+    new_order_response(order) {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            wasm$1.wiree2eidentity_new_order_response(retptr, this.ptr, addHeapObject(order));
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * See [core_crypto::e2e_identity::WireE2eIdentity::new_authz_request]
+    * @param {string} url
+    * @param {Uint8Array} account
+    * @param {string} previous_nonce
+    * @returns {Uint8Array}
+    */
+    new_authz_request(url, account, previous_nonce) {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(url, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(previous_nonce, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            wasm$1.wiree2eidentity_new_authz_request(retptr, this.ptr, ptr0, len0, addHeapObject(account), ptr1, len1);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * See [core_crypto::e2e_identity::WireE2eIdentity::new_authz_response]
+    * @param {Uint8Array} authz
+    * @returns {any}
+    */
+    new_authz_response(authz) {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            wasm$1.wiree2eidentity_new_authz_response(retptr, this.ptr, addHeapObject(authz));
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * See [core_crypto::e2e_identity::WireE2eIdentity::create_dpop_token]
+    * @param {string} access_token_url
+    * @param {string} user_id
+    * @param {bigint} client_id
+    * @param {string} domain
+    * @param {any} client_id_challenge
+    * @param {string} backend_nonce
+    * @param {number} expiry_days
+    * @returns {string}
+    */
+    create_dpop_token(access_token_url, user_id, client_id, domain, client_id_challenge, backend_nonce, expiry_days) {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(access_token_url, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(user_id, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passStringToWasm0(domain, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passStringToWasm0(backend_nonce, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+            const len3 = WASM_VECTOR_LEN;
+            wasm$1.wiree2eidentity_create_dpop_token(retptr, this.ptr, ptr0, len0, ptr1, len1, client_id, ptr2, len2, addHeapObject(client_id_challenge), ptr3, len3, expiry_days);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            var r3 = getInt32Memory0()[retptr / 4 + 3];
+            var ptr4 = r0;
+            var len4 = r1;
+            if (r3) {
+                ptr4 = 0; len4 = 0;
+                throw takeObject(r2);
+            }
+            return getStringFromWasm0(ptr4, len4);
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+            wasm$1.__wbindgen_free(ptr4, len4);
+        }
+    }
+    /**
+    * See [core_crypto::e2e_identity::WireE2eIdentity::new_challenge_request]
+    * @param {any} handle_challenge
+    * @param {Uint8Array} account
+    * @param {string} previous_nonce
+    * @returns {Uint8Array}
+    */
+    new_challenge_request(handle_challenge, account, previous_nonce) {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(previous_nonce, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            wasm$1.wiree2eidentity_new_challenge_request(retptr, this.ptr, addHeapObject(handle_challenge), addHeapObject(account), ptr0, len0);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * See [core_crypto::e2e_identity::WireE2eIdentity::new_challenge_response]
+    * @param {Uint8Array} challenge
+    */
+    new_challenge_response(challenge) {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            wasm$1.wiree2eidentity_new_challenge_response(retptr, this.ptr, addHeapObject(challenge));
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * See [core_crypto::e2e_identity::WireE2eIdentity::check_order_request]
+    * @param {string} order_url
+    * @param {Uint8Array} account
+    * @param {string} previous_nonce
+    * @returns {Uint8Array}
+    */
+    check_order_request(order_url, account, previous_nonce) {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(order_url, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(previous_nonce, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            wasm$1.wiree2eidentity_check_order_request(retptr, this.ptr, ptr0, len0, addHeapObject(account), ptr1, len1);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * See [core_crypto::e2e_identity::WireE2eIdentity::check_order_response]
+    * @param {Uint8Array} order
+    * @returns {Uint8Array}
+    */
+    check_order_response(order) {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            wasm$1.wiree2eidentity_check_order_response(retptr, this.ptr, addHeapObject(order));
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * See [core_crypto::e2e_identity::WireE2eIdentity::finalize_request]
+    * @param {(Uint8Array)[]} domains
+    * @param {Uint8Array} order
+    * @param {Uint8Array} account
+    * @param {string} previous_nonce
+    * @returns {Uint8Array}
+    */
+    finalize_request(domains, order, account, previous_nonce) {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayJsValueToWasm0(domains, wasm$1.__wbindgen_malloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(previous_nonce, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            wasm$1.wiree2eidentity_finalize_request(retptr, this.ptr, ptr0, len0, addHeapObject(order), addHeapObject(account), ptr1, len1);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * See [core_crypto::e2e_identity::WireE2eIdentity::finalize_response]
+    * @param {Uint8Array} finalize
+    * @returns {any}
+    */
+    finalize_response(finalize) {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            wasm$1.wiree2eidentity_finalize_response(retptr, this.ptr, addHeapObject(finalize));
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * See [core_crypto::e2e_identity::WireE2eIdentity::certificate_request]
+    * @param {any} finalize
+    * @param {Uint8Array} account
+    * @param {string} previous_nonce
+    * @returns {Uint8Array}
+    */
+    certificate_request(finalize, account, previous_nonce) {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(previous_nonce, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            wasm$1.wiree2eidentity_certificate_request(retptr, this.ptr, addHeapObject(finalize), addHeapObject(account), ptr0, len0);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * See [core_crypto::e2e_identity::WireE2eIdentity::certificate_response]
+    * @param {string} certificate_chain
+    * @returns {(Uint8Array)[]}
+    */
+    certificate_response(certificate_chain) {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(certificate_chain, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            wasm$1.wiree2eidentity_certificate_response(retptr, this.ptr, ptr0, len0);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            var r3 = getInt32Memory0()[retptr / 4 + 3];
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
+            wasm$1.__wbindgen_free(r0, r1 * 4);
+            return v1;
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+}
 
 async function load(module, imports) {
     if (typeof Response === 'function' && module instanceof Response) {
@@ -1588,54 +2355,30 @@ function getImports() {
         const ret = getObject(arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
-        takeObject(arg0);
-    };
     imports.wbg.__wbindgen_is_object = function(arg0) {
         const val = getObject(arg0);
         const ret = typeof(val) === 'object' && val !== null;
         return ret;
     };
+    imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
+        takeObject(arg0);
+    };
     imports.wbg.__wbg_getwithrefkey_15c62c2b8546208d = function(arg0, arg1) {
         const ret = getObject(arg0)[getObject(arg1)];
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_is_undefined = function(arg0) {
-        const ret = getObject(arg0) === undefined;
-        return ret;
-    };
-    imports.wbg.__wbindgen_in = function(arg0, arg1) {
-        const ret = getObject(arg0) in getObject(arg1);
-        return ret;
-    };
-    imports.wbg.__wbg_objectStoreNames_8c06c40d2b05141c = function(arg0) {
-        const ret = getObject(arg0).objectStoreNames;
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_length_b59f358f797fd9f4 = function(arg0) {
-        const ret = getObject(arg0).length;
-        return ret;
-    };
-    imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
-        const ret = getStringFromWasm0(arg0, arg1);
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbindgen_string_get = function(arg0, arg1) {
-        const obj = getObject(arg1);
-        const ret = typeof(obj) === 'string' ? obj : undefined;
-        var ptr0 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
-        var len0 = WASM_VECTOR_LEN;
-        getInt32Memory0()[arg0 / 4 + 1] = len0;
-        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    imports.wbg.__wbindgen_is_undefined = function(arg0) {
+        const ret = getObject(arg0) === undefined;
+        return ret;
+    };
+    imports.wbg.__wbindgen_in = function(arg0, arg1) {
+        const ret = getObject(arg0) in getObject(arg1);
+        return ret;
     };
     imports.wbg.__wbg_length_6e3bbe7c8bd4dbd8 = function(arg0) {
         const ret = getObject(arg0).length;
         return ret;
     };
-    imports.wbg.__wbindgen_error_new = function(arg0, arg1) {
-        const ret = new Error(getStringFromWasm0(arg0, arg1));
-        return addHeapObject(ret);
-    };
     imports.wbg.__wbg_new0_a57059d72c5b7aee = function() {
         const ret = new Date();
         return addHeapObject(ret);
@@ -1685,6 +2428,18 @@ function getImports() {
         const ret = BigInt.asUintN(64, arg0);
         return addHeapObject(ret);
     };
+    imports.wbg.__wbindgen_error_new = function(arg0, arg1) {
+        const ret = new Error(getStringFromWasm0(arg0, arg1));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_string_get = function(arg0, arg1) {
+        const obj = getObject(arg1);
+        const ret = typeof(obj) === 'string' ? obj : undefined;
+        var ptr0 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    };
     imports.wbg.__wbg_isArray_27c46c67f498e15d = function(arg0) {
         const ret = Array.isArray(getObject(arg0));
         return ret;
@@ -1697,6 +2452,10 @@ function getImports() {
         const ret = getObject(arg0)[arg1 >>> 0];
         return addHeapObject(ret);
     };
+    imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
+        const ret = getStringFromWasm0(arg0, arg1);
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbg_corecrypto_new = function(arg0) {
         const ret = CoreCrypto$1.__wrap(arg0);
         return addHeapObject(ret);
@@ -1704,22 +2463,45 @@ function getImports() {
     imports.wbg.__wbg_set_20cbc34131e76824 = function(arg0, arg1, arg2) {
         getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
     };
-    imports.wbg.__wbindgen_number_new = function(arg0) {
-        const ret = arg0;
-        return addHeapObject(ret);
-    };
     imports.wbg.__wbg_new_0b9bfdd97583284e = function() {
         const ret = new Object();
         return addHeapObject(ret);
     };
+    imports.wbg.__wbindgen_number_new = function(arg0) {
+        const ret = arg0;
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbg_call_168da88779e35f61 = function() { return handleError(function (arg0, arg1, arg2) {
         const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
         return addHeapObject(ret);
     }, arguments) };
+    imports.wbg.__wbg_new_1d9a920c6bfc44a8 = function() {
+        const ret = new Array();
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbg_new_8c3f0052272a457a = function(arg0) {
         const ret = new Uint8Array(getObject(arg0));
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_push_740e4b286702d964 = function(arg0, arg1) {
+        const ret = getObject(arg0).push(getObject(arg1));
+        return ret;
+    };
+    imports.wbg.__wbg_wiree2eidentity_new = function(arg0) {
+        const ret = WireE2eIdentity$1.__wrap(arg0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_set_a68214f35c417fa9 = function(arg0, arg1, arg2) {
+        getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
+    };
+    imports.wbg.__wbg_new_268f7b7dd3430798 = function() {
+        const ret = new Map();
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_set_933729cf5b66ac11 = function(arg0, arg1, arg2) {
+        const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbg_new_9962f939219f1820 = function(arg0, arg1) {
         try {
             var state0 = {a: arg0, b: arg1};
@@ -1727,7 +2509,7 @@ function getImports() {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wbg_adapter_220(a, state0.b, arg0, arg1);
+                    return __wbg_adapter_264(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -1738,24 +2520,16 @@ function getImports() {
             state0.a = state0.b = 0;
         }
     };
-    imports.wbg.__wbg_new_1d9a920c6bfc44a8 = function() {
-        const ret = new Array();
+    imports.wbg.__wbg_objectStoreNames_8c06c40d2b05141c = function(arg0) {
+        const ret = getObject(arg0).objectStoreNames;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_set_a68214f35c417fa9 = function(arg0, arg1, arg2) {
-        getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
-    };
-    imports.wbg.__wbg_push_740e4b286702d964 = function(arg0, arg1) {
-        const ret = getObject(arg0).push(getObject(arg1));
+    imports.wbg.__wbg_length_b59f358f797fd9f4 = function(arg0) {
+        const ret = getObject(arg0).length;
         return ret;
     };
-    imports.wbg.__wbg_new_268f7b7dd3430798 = function() {
-        const ret = new Map();
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_set_933729cf5b66ac11 = function(arg0, arg1, arg2) {
-        const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
-        return addHeapObject(ret);
+    imports.wbg.__wbg_setproteuserrorcode_5c292d4c4f7e5b6e = function(arg0, arg1) {
+        getObject(arg0).set_proteus_error_code(arg1 >>> 0);
     };
     imports.wbg.__wbg_call_3999bee59e9f7719 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
         const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3));
@@ -1773,6 +2547,23 @@ function getImports() {
         const ret = ProposalBundle.__wrap(arg0);
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_new_141b86f11ac9df62 = function(arg0, arg1, arg2, arg3) {
+        try {
+            const ret = new CoreCryptoError(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3));
+            return addHeapObject(ret);
+        } finally {
+            wasm$1.__wbindgen_free(arg0, arg1);
+            wasm$1.__wbindgen_free(arg2, arg3);
+        }
+    };
+    imports.wbg.__wbg_now_4d4a1d65c7a8c0ba = function() {
+        const ret = Date.now();
+        return ret;
+    };
+    imports.wbg.__wbg_now_78244d2ced74c026 = function() {
+        const ret = performance.now();
+        return ret;
+    };
     imports.wbg.__wbg_new_abda76e883ba8a5f = function() {
         const ret = new Error();
         return addHeapObject(ret);
@@ -1824,23 +2615,18 @@ function getImports() {
         const ret = false;
         return ret;
     };
-    imports.wbg.__wbg_open_a31c3fe1fdc244eb = function() { return handleError(function (arg0, arg1, arg2) {
-        const ret = getObject(arg0).open(getStringFromWasm0(arg1, arg2));
+    imports.wbg.__wbg_get_6285bf458a1ee758 = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg0).get(getObject(arg1));
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_open_c5d5fb2df44b9d10 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
-        const ret = getObject(arg0).open(getStringFromWasm0(arg1, arg2), arg3 >>> 0);
+    imports.wbg.__wbg_put_84e7fc93eee27b28 = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = getObject(arg0).put(getObject(arg1), getObject(arg2));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_put_f2763b05a07f3233 = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg0).put(getObject(arg1));
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_setonupgradeneeded_17d0b9530f1e0cac = function(arg0, arg1) {
-        getObject(arg0).onupgradeneeded = getObject(arg1);
-    };
-    imports.wbg.__wbg_setonsuccess_5f71593bc51653a3 = function(arg0, arg1) {
-        getObject(arg0).onsuccess = getObject(arg1);
-    };
-    imports.wbg.__wbg_setonerror_d5771cc5bf9ea74c = function(arg0, arg1) {
-        getObject(arg0).onerror = getObject(arg1);
-    };
     imports.wbg.__wbg_delete_8abedd1043b4105d = function() { return handleError(function (arg0, arg1) {
         const ret = getObject(arg0).delete(getObject(arg1));
         return addHeapObject(ret);
@@ -1853,18 +2639,6 @@ function getImports() {
         const ret = getObject(arg0).count(getObject(arg1));
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_get_6285bf458a1ee758 = function() { return handleError(function (arg0, arg1) {
-        const ret = getObject(arg0).get(getObject(arg1));
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_put_84e7fc93eee27b28 = function() { return handleError(function (arg0, arg1, arg2) {
-        const ret = getObject(arg0).put(getObject(arg1), getObject(arg2));
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_put_f2763b05a07f3233 = function() { return handleError(function (arg0, arg1) {
-        const ret = getObject(arg0).put(getObject(arg1));
-        return addHeapObject(ret);
-    }, arguments) };
     imports.wbg.__wbg_openCursor_e036069f0e326708 = function() { return handleError(function (arg0, arg1) {
         const ret = getObject(arg0).openCursor(getObject(arg1));
         return addHeapObject(ret);
@@ -1873,6 +2647,23 @@ function getImports() {
         const ret = getObject(arg0).openCursor();
         return addHeapObject(ret);
     }, arguments) };
+    imports.wbg.__wbg_setonsuccess_5f71593bc51653a3 = function(arg0, arg1) {
+        getObject(arg0).onsuccess = getObject(arg1);
+    };
+    imports.wbg.__wbg_open_a31c3fe1fdc244eb = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = getObject(arg0).open(getStringFromWasm0(arg1, arg2));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_open_c5d5fb2df44b9d10 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
+        const ret = getObject(arg0).open(getStringFromWasm0(arg1, arg2), arg3 >>> 0);
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_setonupgradeneeded_17d0b9530f1e0cac = function(arg0, arg1) {
+        getObject(arg0).onupgradeneeded = getObject(arg1);
+    };
+    imports.wbg.__wbg_setonerror_d5771cc5bf9ea74c = function(arg0, arg1) {
+        getObject(arg0).onerror = getObject(arg1);
+    };
     imports.wbg.__wbg_index_86861edf1478f49c = function() { return handleError(function (arg0, arg1, arg2) {
         const ret = getObject(arg0).index(getStringFromWasm0(arg1, arg2));
         return addHeapObject(ret);
@@ -1893,13 +2684,13 @@ function getImports() {
         const ret = getObject(arg0).openCursor(getObject(arg1));
         return addHeapObject(ret);
     }, arguments) };
+    imports.wbg.__wbg_close_5a04b9ce11dade22 = function(arg0) {
+        getObject(arg0).close();
+    };
     imports.wbg.__wbg_deleteDatabase_f6454de6a88aebde = function() { return handleError(function (arg0, arg1, arg2) {
         const ret = getObject(arg0).deleteDatabase(getStringFromWasm0(arg1, arg2));
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_close_5a04b9ce11dade22 = function(arg0) {
-        getObject(arg0).close();
-    };
     imports.wbg.__wbg_randomFillSync_6894564c2c334c42 = function() { return handleError(function (arg0, arg1, arg2) {
         getObject(arg0).randomFillSync(getArrayU8FromWasm0(arg1, arg2));
     }, arguments) };
@@ -2021,10 +2812,6 @@ function getImports() {
         const ret = getObject(arg0).result;
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_error_aacf5ac191e54ed0 = function() { return handleError(function (arg0) {
-        const ret = getObject(arg0).error;
-        return isLikeNone(ret) ? 0 : addHeapObject(ret);
-    }, arguments) };
     imports.wbg.__wbg_contains_6cf516181cd86571 = function(arg0, arg1, arg2) {
         const ret = getObject(arg0).contains(getStringFromWasm0(arg1, arg2));
         return ret;
@@ -2051,6 +2838,10 @@ function getImports() {
     imports.wbg.__wbg_deleteObjectStore_1b698c5fd1bc077d = function() { return handleError(function (arg0, arg1, arg2) {
         getObject(arg0).deleteObjectStore(getStringFromWasm0(arg1, arg2));
     }, arguments) };
+    imports.wbg.__wbg_error_aacf5ac191e54ed0 = function() { return handleError(function (arg0) {
+        const ret = getObject(arg0).error;
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    }, arguments) };
     imports.wbg.__wbindgen_is_falsy = function(arg0) {
         const ret = !getObject(arg0);
         return ret;
@@ -2076,6 +2867,24 @@ function getImports() {
         const ret = getObject(arg0).toString();
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_instanceof_Window_acc97ff9f5d2c7b4 = function(arg0) {
+        let result;
+        try {
+            result = getObject(arg0) instanceof Window;
+        } catch {
+            result = false;
+        }
+        const ret = result;
+        return ret;
+    };
+    imports.wbg.__wbg_crypto_9f07beb1e97bfa1b = function() { return handleError(function (arg0) {
+        const ret = getObject(arg0).crypto;
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_getRandomValues_f134f772d240c51f = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = getObject(arg0).getRandomValues(getArrayU8FromWasm0(arg1, arg2));
+        return addHeapObject(ret);
+    }, arguments) };
     imports.wbg.__wbg_instanceof_Uint8Array_971eeda69eb75003 = function(arg0) {
         let result;
         try {
@@ -2151,12 +2960,12 @@ function getImports() {
         const ret = getObject(arg0).objectStore(getStringFromWasm0(arg1, arg2));
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbindgen_closure_wrapper2373 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 122, __wbg_adapter_52);
+    imports.wbg.__wbindgen_closure_wrapper2699 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 141, __wbg_adapter_52);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper3847 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 122, __wbg_adapter_55);
+    imports.wbg.__wbindgen_closure_wrapper4619 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 141, __wbg_adapter_55);
         return addHeapObject(ret);
     };
 
@@ -2189,9 +2998,7 @@ function initSync(module) {
 }
 
 async function init(input) {
-    if (typeof input === 'undefined') {
-        input = new URL('index_bg.wasm', import.meta.url);
-    }
+
     const imports = getImports();
 
     if (typeof input === 'string' || (typeof Request === 'function' && input instanceof Request) || (typeof URL === 'function' && input instanceof URL)) {
@@ -2208,6 +3015,9 @@ var exports = /*#__PURE__*/Object.freeze({
     version: version,
     WirePolicy: WirePolicy$1,
     Ciphersuite: Ciphersuite$1,
+    AcmeChallenge: AcmeChallenge,
+    AcmeDirectory: AcmeDirectory,
+    AcmeFinalize: AcmeFinalize,
     CommitBundle: CommitBundle,
     ConversationConfiguration: ConversationConfiguration,
     ConversationInitBundle: ConversationInitBundle,
@@ -2217,8 +3027,11 @@ var exports = /*#__PURE__*/Object.freeze({
     DecryptedMessage: DecryptedMessage,
     Invitee: Invitee,
     MemberAddedMessages: MemberAddedMessages,
+    NewAcmeAuthz: NewAcmeAuthz,
+    NewAcmeOrder: NewAcmeOrder,
     ProposalBundle: ProposalBundle,
     PublicGroupStateBundle: PublicGroupStateBundle,
+    WireE2eIdentity: WireE2eIdentity$1,
     initSync: initSync,
     'default': init
 });
@@ -2226,7 +3039,7 @@ var exports = /*#__PURE__*/Object.freeze({
 var wasm = async (opt = {}) => {
                 let {importHook, serverPath} = opt;
 
-                let path = "assets/core_crypto_ffi-69d2b02f.wasm";
+                let path = "assets/core_crypto_ffi-2b0ceda6.wasm";
 
                 if (serverPath != null) {
                     path = serverPath + /[^\/\\]*$/.exec(path)[0];
@@ -2242,39 +3055,39 @@ var wasm = async (opt = {}) => {
 
 // Wire
 // Copyright (C) 2022 Wire Swiss GmbH
-var _a, _CoreCrypto_module, _CoreCrypto_cc;
+var _a, _CoreCrypto_module, _CoreCrypto_cc, _b, _WireE2eIdentity_module, _WireE2eIdentity_e2ei;
 /**
-* see [core_crypto::prelude::CiphersuiteName]
-*/
+ * see [core_crypto::prelude::CiphersuiteName]
+ */
 var Ciphersuite;
 (function (Ciphersuite) {
     /**
-    * DH KEM x25519 | AES-GCM 128 | SHA2-256 | Ed25519
-    */
+     * DH KEM x25519 | AES-GCM 128 | SHA2-256 | Ed25519
+     */
     Ciphersuite[Ciphersuite["MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519"] = 1] = "MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519";
     /**
-    * DH KEM P256 | AES-GCM 128 | SHA2-256 | EcDSA P256
-    */
+     * DH KEM P256 | AES-GCM 128 | SHA2-256 | EcDSA P256
+     */
     Ciphersuite[Ciphersuite["MLS_128_DHKEMP256_AES128GCM_SHA256_P256"] = 2] = "MLS_128_DHKEMP256_AES128GCM_SHA256_P256";
     /**
-    * DH KEM x25519 | Chacha20Poly1305 | SHA2-256 | Ed25519
-    */
+     * DH KEM x25519 | Chacha20Poly1305 | SHA2-256 | Ed25519
+     */
     Ciphersuite[Ciphersuite["MLS_128_DHKEMX25519_CHACHA20POLY1305_SHA256_Ed25519"] = 3] = "MLS_128_DHKEMX25519_CHACHA20POLY1305_SHA256_Ed25519";
     /**
-    * DH KEM x448 | AES-GCM 256 | SHA2-512 | Ed448
-    */
+     * DH KEM x448 | AES-GCM 256 | SHA2-512 | Ed448
+     */
     Ciphersuite[Ciphersuite["MLS_256_DHKEMX448_AES256GCM_SHA512_Ed448"] = 4] = "MLS_256_DHKEMX448_AES256GCM_SHA512_Ed448";
     /**
-    * DH KEM P521 | AES-GCM 256 | SHA2-512 | EcDSA P521
-    */
+     * DH KEM P521 | AES-GCM 256 | SHA2-512 | EcDSA P521
+     */
     Ciphersuite[Ciphersuite["MLS_256_DHKEMP521_AES256GCM_SHA512_P521"] = 5] = "MLS_256_DHKEMP521_AES256GCM_SHA512_P521";
     /**
-    * DH KEM x448 | Chacha20Poly1305 | SHA2-512 | Ed448
-    */
+     * DH KEM x448 | Chacha20Poly1305 | SHA2-512 | Ed448
+     */
     Ciphersuite[Ciphersuite["MLS_256_DHKEMX448_CHACHA20POLY1305_SHA512_Ed448"] = 6] = "MLS_256_DHKEMX448_CHACHA20POLY1305_SHA512_Ed448";
     /**
-    * DH KEM P384 | AES-GCM 256 | SHA2-384 | EcDSA P384
-    */
+     * DH KEM P384 | AES-GCM 256 | SHA2-384 | EcDSA P384
+     */
     Ciphersuite[Ciphersuite["MLS_256_DHKEMP384_AES256GCM_SHA384_P384"] = 7] = "MLS_256_DHKEMP384_AES256GCM_SHA384_P384";
 })(Ciphersuite || (Ciphersuite = {}));
 /**
@@ -2820,7 +3633,7 @@ class CoreCrypto {
      * **CAUTION**: only use this when you had an explicit response from the Delivery Service
      * e.g. 403. Do not use otherwise e.g. 5xx responses, timeout etc..
      * **DO NOT** use when Delivery Service responds 409, pending state will be renewed
-     * in {@link CoreCrypto.decrypt_message}
+     * in {@link CoreCrypto.decryptMessage}
      *
      * @param conversationId - The group's ID
      */
@@ -3006,7 +3819,7 @@ class CoreCrypto {
      *
      * @param prekey - the prekey bundle to get the fingerprint from
      * @returns Hex-encoded public key string
-    **/
+     **/
     static proteusFingerprintPrekeybundle(prekey) {
         return __classPrivateFieldGet(this, _a, "f", _CoreCrypto_module).CoreCrypto.proteus_fingerprint_prekeybundle(prekey);
     }
@@ -3018,6 +3831,18 @@ class CoreCrypto {
     async proteusCryptoboxMigrate(storeName) {
         return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").proteus_cryptobox_migrate(storeName);
     }
+    /**
+     * Creates an enrollment instance with private key material you can use in order to fetch
+     * a new x509 certificate from the acme server.
+     * Make sure to call [WireE2eIdentity::free] (not yet available) to dispose this instance and its associated
+     * keying material.
+     *
+     * @param ciphersuite - For generating signing key material. Only {@link Ciphersuite.MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519} is supported currently
+     */
+    async newAcmeEnrollment() {
+        const e2ei = await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").new_acme_enrollment(Ciphersuite.MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519);
+        return new WireE2eIdentity(e2ei, __classPrivateFieldGet(CoreCrypto, _a, "f", _CoreCrypto_module));
+    }
     /**
      * Returns the current version of {@link CoreCrypto}
      *
@@ -3033,5 +3858,197 @@ class CoreCrypto {
 _a = CoreCrypto, _CoreCrypto_cc = new WeakMap();
 /** @hidden */
 _CoreCrypto_module = { value: void 0 };
+class WireE2eIdentity {
+    /** @hidden */
+    constructor(e2ei, module) {
+        /** @hidden */
+        _WireE2eIdentity_e2ei.set(this, void 0);
+        __classPrivateFieldSet(this, _WireE2eIdentity_e2ei, e2ei, "f");
+        if (!__classPrivateFieldGet(WireE2eIdentity, _b, "f", _WireE2eIdentity_module)) {
+            __classPrivateFieldSet(WireE2eIdentity, _b, module, "f", _WireE2eIdentity_module);
+        }
+    }
+    /**
+     * Parses the response from `GET /acme/{provisioner-name}/directory`.
+     * Use this {@link AcmeDirectory} in the next step to fetch the first nonce from the acme server. Use
+     * {@link AcmeDirectory.newNonce}.
+     *
+     * @param directory HTTP response body
+     * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.1.1
+     */
+    directoryResponse(directory) {
+        return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").directory_response(directory);
+    }
+    /**
+     * For creating a new acme account. This returns a signed JWS-alike request body to send to
+     * `POST /acme/{provisioner-name}/new-account`.
+     *
+     * @param directory you got from {@link directoryResponse}
+     * @param previousNonce you got from calling `HEAD {@link AcmeDirectory.newNonce}`
+     * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.3
+     */
+    newAccountRequest(directory, previousNonce) {
+        return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").new_account_request(directory, previousNonce);
+    }
+    /**
+     * Parses the response from `POST /acme/{provisioner-name}/new-account`.
+     * @param account HTTP response body
+     * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.3
+     */
+    newAccountResponse(account) {
+        return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").new_account_response(account);
+    }
+    /**
+     * Creates a new acme order for the handle (userId + display name) and the clientId.
+     *
+     * @param handle domain of the authorization server e.g. `idp.example.org`
+     * @param clientId domain of the wire-server e.g. `wire.example.org`
+     * @param expiryDays generated x509 certificate expiry
+     * @param directory you got from {@link directoryResponse}
+     * @param account you got from {@link newAccountResponse}
+     * @param previousNonce `replay-nonce` response header from `POST /acme/{provisioner-name}/new-account`
+     * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.4
+     */
+    newOrderRequest(handle, clientId, expiryDays, directory, account, previousNonce) {
+        return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").new_order_request(handle, clientId, expiryDays, directory, account, previousNonce);
+    }
+    /**
+     * Parses the response from `POST /acme/{provisioner-name}/new-order`.
+     *
+     * @param order HTTP response body
+     * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.4
+     */
+    newOrderResponse(order) {
+        return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").new_order_response(order);
+    }
+    /**
+     * Creates a new authorization request.
+     *
+     * @param url one of the URL in new order's authorizations (use {@link NewAcmeOrder.authorizations} from {@link newOrderResponse})
+     * @param account you got from {@link newAccountResponse}
+     * @param previousNonce `replay-nonce` response header from `POST /acme/{provisioner-name}/new-order` (or from the
+     * previous to this method if you are creating the second authorization)
+     * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.5
+     */
+    newAuthzRequest(url, account, previousNonce) {
+        return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").new_authz_request(url, account, previousNonce);
+    }
+    /**
+     * Parses the response from `POST /acme/{provisioner-name}/authz/{authz-id}`
+     *
+     * You then have to map the challenge from this authorization object. The `client_id_challenge`
+     * will be the one with the `client_id_host` (you supplied to {@link newOrderRequest}) identifier,
+     * the other will be your `handle_challenge`.
+     *
+     * @param authz HTTP response body
+     * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.5
+     */
+    newAuthzResponse(authz) {
+        return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").new_authz_response(authz);
+    }
+    /**
+     * Generates a new client Dpop JWT token. It demonstrates proof of possession of the nonces
+     * (from wire-server & acme server) and will be verified by the acme server when verifying the
+     * challenge (in order to deliver a certificate).
+     *
+     * Then send it to `POST /clients/{id}/access-token`
+     * {@link https://staging-nginz-https.zinfra.io/api/swagger-ui/#/default/post_clients__cid__access_token} on wire-server.
+     *
+     * @param accessTokenUrl backend endpoint where this token will be sent. Should be this one {@link https://staging-nginz-https.zinfra.io/api/swagger-ui/#/default/post_clients__cid__access_token}
+     * @param userId an UUIDv4 uniquely identifying the user
+     * @param clientId client identifier
+     * @param domain owning backend domain e.g. `wire.com`
+     * @param clientIdChallenge you found after {@link newAuthzResponse}
+     * @param backendNonce you get by calling `GET /clients/token/nonce` on wire-server as defined here {@link https://staging-nginz-https.zinfra.io/api/swagger-ui/#/default/get_clients__client__nonce}
+     * @param expiryDays token expiry in days
+     */
+    createDpopToken(accessTokenUrl, userId, clientId, domain, clientIdChallenge, backendNonce, expiryDays) {
+        return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").create_dpop_token(accessTokenUrl, userId, clientId, domain, clientIdChallenge, backendNonce, expiryDays);
+    }
+    /**
+     * Creates a new challenge request.
+     *
+     * @param handleChallenge you found after {@link newAuthzResponse}
+     * @param account you found after {@link newAccountResponse}
+     * @param previousNonce `replay-nonce` response header from `POST /acme/{provisioner-name}/authz/{authz-id}`
+     * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.5.1
+     */
+    newChallengeRequest(handleChallenge, account, previousNonce) {
+        return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").new_challenge_request(handleChallenge, account, previousNonce);
+    }
+    /**
+     * Parses the response from `POST /acme/{provisioner-name}/challenge/{challenge-id}`.
+     *
+     * @param challenge HTTP response body
+     * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.5.1
+     */
+    newChallengeResponse(challenge) {
+        return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").new_challenge_response(challenge);
+    }
+    /**
+     * Verifies that the previous challenge has been completed.
+     *
+     * @param orderUrl `location` header from http response you got from {@link newOrderResponse}
+     * @param account you found after {@link newAccountResponse}
+     * @param previousNonce `replay-nonce` response header from `POST /acme/{provisioner-name}/challenge/{challenge-id}`
+     * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.4
+     */
+    checkOrderRequest(orderUrl, account, previousNonce) {
+        return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").check_order_request(orderUrl, account, previousNonce);
+    }
+    /**
+     * Parses the response from `POST /acme/{provisioner-name}/order/{order-id}`.
+     *
+     * @param order HTTP response body
+     * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.4
+     */
+    checkOrderResponse(order) {
+        return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").check_order_response(order);
+    }
+    /**
+     * Final step before fetching the certificate.
+     *
+     * @param domains you want to generate a certificate for e.g. `["wire.com"]`
+     * @param order you got from {@link checkOrderResponse}
+     * @param account you found after {@link newAccountResponse}
+     * @param previousNonce `replay-nonce` response header from `POST /acme/{provisioner-name}/order/{order-id}`
+     * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.4
+     */
+    finalizeRequest(domains, order, account, previousNonce) {
+        return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").finalize_request(domains, order, account, previousNonce);
+    }
+    /**
+     * Parses the response from `POST /acme/{provisioner-name}/order/{order-id}/finalize`.
+     *
+     * @param finalize HTTP response body
+     * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.4
+     */
+    finalizeResponse(finalize) {
+        return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").finalize_response(finalize);
+    }
+    /**
+     * Creates a request for finally fetching the x509 certificate.
+     *
+     * @param finalize you got from {@link finalizeResponse}
+     * @param account you got from {@link newAccountResponse}
+     * @param previousNonce `replay-nonce` response header from `POST /acme/{provisioner-name}/order/{order-id}/finalize`
+     * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.4.2
+     */
+    certificateRequest(finalize, account, previousNonce) {
+        return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").certificate_request(finalize, account, previousNonce);
+    }
+    /**
+     * Parses the response from `POST /acme/{provisioner-name}/certificate/{certificate-id}`.
+     *
+     * @param certificateChain HTTP string response body
+     * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.4.2
+     */
+    certificateResponse(certificateChain) {
+        return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").certificate_response(certificateChain);
+    }
+}
+_b = WireE2eIdentity, _WireE2eIdentity_e2ei = new WeakMap();
+/** @hidden */
+_WireE2eIdentity_module = { value: void 0 };
 
-export { Ciphersuite, CoreCrypto, ExternalProposalType, ProposalType, PublicGroupStateEncryptionType, RatchetTreeType, WirePolicy };
+export { Ciphersuite, CoreCrypto, ExternalProposalType, ProposalType, PublicGroupStateEncryptionType, RatchetTreeType, WireE2eIdentity, WirePolicy };