@xmtp/wasm-bindings 0.0.1

package/dist/bindings_wasm.js

@@ -0,0 +1,3779 @@
+import { SQLite } from './snippets/diesel-wasm-sqlite-36e85657e47f3be3/src/js/wa-sqlite-diesel-bundle.js';
+
+let wasm;
+
+const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );
+
+if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); };
+
+let cachedUint8ArrayMemory0 = null;
+
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } );
+
+const 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 ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    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 > 0x7F) 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;
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+let 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 debugString(val) {
+    // primitive types
+    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';
+        }
+    }
+    // objects
+    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;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
+
+const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(state => {
+    wasm.__wbindgen_export_3.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) => {
+        // First up with a closure we increment the internal reference
+        // count. This ensures that the Rust closure environment won't
+        // be deallocated while we're invoking it.
+        state.cnt++;
+        const a = state.a;
+        state.a = 0;
+        try {
+            return f(a, state.b, ...args);
+        } finally {
+            if (--state.cnt === 0) {
+                wasm.__wbindgen_export_3.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 __wbg_adapter_44(arg0, arg1) {
+    wasm._dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hccdc993aebae1d0b(arg0, arg1);
+}
+
+function __wbg_adapter_47(arg0, arg1, arg2) {
+    wasm.closure2262_externref_shim(arg0, arg1, arg2);
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_export_2.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+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_2.get(mem.getUint32(i, true)));
+    }
+    wasm.__externref_drop_slice(ptr, len);
+    return result;
+}
+
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_export_2.set(idx, obj);
+    return idx;
+}
+
+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;
+}
+
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+    return instance.ptr;
+}
+/**
+ * @param {string} host
+ * @param {string} inbox_id
+ * @param {string} account_address
+ * @param {string} db_path
+ * @param {Uint8Array | undefined} [encryption_key]
+ * @param {string | undefined} [history_sync_url]
+ * @returns {Promise<WasmClient>}
+ */
+export function createClient(host, inbox_id, account_address, db_path, encryption_key, history_sync_url) {
+    const ptr0 = passStringToWasm0(host, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(inbox_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passStringToWasm0(account_address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ptr3 = passStringToWasm0(db_path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len3 = WASM_VECTOR_LEN;
+    var ptr4 = isLikeNone(history_sync_url) ? 0 : passStringToWasm0(history_sync_url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len4 = WASM_VECTOR_LEN;
+    const ret = wasm.createClient(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, isLikeNone(encryption_key) ? 0 : addToExternrefTable0(encryption_key), ptr4, len4);
+    return ret;
+}
+
+/**
+ * @param {string} host
+ * @param {string} account_address
+ * @returns {Promise<string | undefined>}
+ */
+export function getInboxIdForAddress(host, account_address) {
+    const ptr0 = passStringToWasm0(host, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(account_address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.getInboxIdForAddress(ptr0, len0, ptr1, len1);
+    return ret;
+}
+
+/**
+ * @param {string} account_address
+ * @returns {string}
+ */
+export function generateInboxId(account_address) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(account_address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.generateInboxId(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
+function notDefined(what) { return () => { throw new Error(`${what} is not defined`); }; }
+/**
+ * Handler for `console.log` invocations.
+ *
+ * If a test is currently running it takes the `args` array and stringifies
+ * it and appends it to the current output of the test. Otherwise it passes
+ * the arguments to the original `console.log` function, psased as
+ * `original`.
+ * @param {Array<any>} args
+ */
+export function __wbgtest_console_log(args) {
+    wasm.__wbgtest_console_log(args);
+}
+
+/**
+ * Handler for `console.debug` invocations. See above.
+ * @param {Array<any>} args
+ */
+export function __wbgtest_console_debug(args) {
+    wasm.__wbgtest_console_debug(args);
+}
+
+/**
+ * Handler for `console.info` invocations. See above.
+ * @param {Array<any>} args
+ */
+export function __wbgtest_console_info(args) {
+    wasm.__wbgtest_console_info(args);
+}
+
+/**
+ * Handler for `console.warn` invocations. See above.
+ * @param {Array<any>} args
+ */
+export function __wbgtest_console_warn(args) {
+    wasm.__wbgtest_console_warn(args);
+}
+
+/**
+ * Handler for `console.error` invocations. See above.
+ * @param {Array<any>} args
+ */
+export function __wbgtest_console_error(args) {
+    wasm.__wbgtest_console_error(args);
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+/**
+ * @returns {Uint8Array | undefined}
+ */
+export function __wbgtest_cov_dump() {
+    const ret = wasm.__wbgtest_cov_dump();
+    let v1;
+    if (ret[0] !== 0) {
+        v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    }
+    return v1;
+}
+
+function __wbg_adapter_523(arg0, arg1, arg2, arg3, arg4) {
+    wasm.closure3105_externref_shim(arg0, arg1, arg2, arg3, arg4);
+}
+
+function __wbg_adapter_566(arg0, arg1, arg2, arg3) {
+    wasm.closure3103_externref_shim(arg0, arg1, arg2, arg3);
+}
+
+export const WasmConsentEntityType = Object.freeze({ GroupId:0,"0":"GroupId",InboxId:1,"1":"InboxId",Address:2,"2":"Address", });
+
+export const WasmConsentState = Object.freeze({ Unknown:0,"0":"Unknown",Allowed:1,"1":"Allowed",Denied:2,"2":"Denied", });
+
+export const WasmDeliveryStatus = Object.freeze({ Unpublished:0,"0":"Unpublished",Published:1,"1":"Published",Failed:2,"2":"Failed", });
+
+export const WasmGroupMessageKind = Object.freeze({ Application:0,"0":"Application",MembershipChange:1,"1":"MembershipChange", });
+
+export const WasmGroupPermissionsOptions = Object.freeze({ AllMembers:0,"0":"AllMembers",AdminOnly:1,"1":"AdminOnly",CustomPolicy:2,"2":"CustomPolicy", });
+
+export const WasmPermissionLevel = Object.freeze({ Member:0,"0":"Member",Admin:1,"1":"Admin",SuperAdmin:2,"2":"SuperAdmin", });
+
+export const WasmPermissionPolicy = Object.freeze({ Allow:0,"0":"Allow",Deny:1,"1":"Deny",Admin:2,"2":"Admin",SuperAdmin:3,"3":"SuperAdmin",DoesNotExist:4,"4":"DoesNotExist",Other:5,"5":"Other", });
+
+export const WasmPermissionUpdateType = Object.freeze({ AddMember:0,"0":"AddMember",RemoveMember:1,"1":"RemoveMember",AddAdmin:2,"2":"AddAdmin",RemoveAdmin:3,"3":"RemoveAdmin",UpdateMetadata:4,"4":"UpdateMetadata", });
+
+export const WasmSignatureRequestType = Object.freeze({ AddWallet:0,"0":"AddWallet",CreateInbox:1,"1":"CreateInbox",RevokeWallet:2,"2":"RevokeWallet",RevokeInstallations:3,"3":"RevokeInstallations", });
+
+const __wbindgen_enum_BinaryType = ["blob", "arraybuffer"];
+
+const __wbindgen_enum_ReadableStreamReaderMode = ["byob"];
+
+const __wbindgen_enum_ReadableStreamType = ["bytes"];
+
+const __wbindgen_enum_RequestCredentials = ["omit", "same-origin", "include"];
+
+const __wbindgen_enum_RequestMode = ["same-origin", "no-cors", "cors", "navigate"];
+
+const IntoUnderlyingByteSourceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_intounderlyingbytesource_free(ptr >>> 0, 1));
+
+export class IntoUnderlyingByteSource {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        IntoUnderlyingByteSourceFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_intounderlyingbytesource_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    get type() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.intounderlyingbytesource_type(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);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    get autoAllocateChunkSize() {
+        const ret = wasm.intounderlyingbytesource_autoAllocateChunkSize(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @param {ReadableByteStreamController} controller
+     */
+    start(controller) {
+        wasm.intounderlyingbytesource_start(this.__wbg_ptr, controller);
+    }
+    /**
+     * @param {ReadableByteStreamController} controller
+     * @returns {Promise<any>}
+     */
+    pull(controller) {
+        const ret = wasm.intounderlyingbytesource_pull(this.__wbg_ptr, controller);
+        return ret;
+    }
+    cancel() {
+        const ptr = this.__destroy_into_raw();
+        wasm.intounderlyingbytesource_cancel(ptr);
+    }
+}
+
+const IntoUnderlyingSinkFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_intounderlyingsink_free(ptr >>> 0, 1));
+
+export class IntoUnderlyingSink {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        IntoUnderlyingSinkFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_intounderlyingsink_free(ptr, 0);
+    }
+    /**
+     * @param {any} chunk
+     * @returns {Promise<any>}
+     */
+    write(chunk) {
+        const ret = wasm.intounderlyingsink_write(this.__wbg_ptr, chunk);
+        return ret;
+    }
+    /**
+     * @returns {Promise<any>}
+     */
+    close() {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.intounderlyingsink_close(ptr);
+        return ret;
+    }
+    /**
+     * @param {any} reason
+     * @returns {Promise<any>}
+     */
+    abort(reason) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.intounderlyingsink_abort(ptr, reason);
+        return ret;
+    }
+}
+
+const IntoUnderlyingSourceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_intounderlyingsource_free(ptr >>> 0, 1));
+
+export class IntoUnderlyingSource {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        IntoUnderlyingSourceFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_intounderlyingsource_free(ptr, 0);
+    }
+    /**
+     * @param {ReadableStreamDefaultController} controller
+     * @returns {Promise<any>}
+     */
+    pull(controller) {
+        const ret = wasm.intounderlyingsource_pull(this.__wbg_ptr, controller);
+        return ret;
+    }
+    cancel() {
+        const ptr = this.__destroy_into_raw();
+        wasm.intounderlyingsource_cancel(ptr);
+    }
+}
+
+const VersionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_version_free(ptr >>> 0, 1));
+
+export class Version {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        VersionFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_version_free(ptr, 0);
+    }
+}
+
+const WasmBindgenTestContextFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmbindgentestcontext_free(ptr >>> 0, 1));
+/**
+ * Runtime test harness support instantiated in JS.
+ *
+ * The node.js entry script instantiates a `Context` here which is used to
+ * drive test execution.
+ */
+export class WasmBindgenTestContext {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmBindgenTestContextFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmbindgentestcontext_free(ptr, 0);
+    }
+    /**
+     * Creates a new context ready to run tests.
+     *
+     * A `Context` is the main structure through which test execution is
+     * coordinated, and this will collect output and results for all executed
+     * tests.
+     */
+    constructor() {
+        const ret = wasm.wasmbindgentestcontext_new();
+        this.__wbg_ptr = ret >>> 0;
+        WasmBindgenTestContextFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Inform this context about runtime arguments passed to the test
+     * harness.
+     * @param {any[]} args
+     */
+    args(args) {
+        const ptr0 = passArrayJsValueToWasm0(args, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.wasmbindgentestcontext_args(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Executes a list of tests, returning a promise representing their
+     * eventual completion.
+     *
+     * This is the main entry point for executing tests. All the tests passed
+     * in are the JS `Function` object that was plucked off the
+     * `WebAssembly.Instance` exports list.
+     *
+     * The promise returned resolves to either `true` if all tests passed or
+     * `false` if at least one test failed.
+     * @param {any[]} tests
+     * @returns {Promise<any>}
+     */
+    run(tests) {
+        const ptr0 = passArrayJsValueToWasm0(tests, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmbindgentestcontext_run(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+}
+
+const WasmClientFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmclient_free(ptr >>> 0, 1));
+
+export class WasmClient {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmClient.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmClientFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmClientFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmclient_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    get accountAddress() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmclient_accountAddress(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);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get inboxId() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmclient_inboxId(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);
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    get isRegistered() {
+        const ret = wasm.wasmclient_isRegistered(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {string}
+     */
+    get installationId() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmclient_installationId(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);
+        }
+    }
+    /**
+     * @param {(string)[]} account_addresses
+     * @returns {Promise<any>}
+     */
+    canMessage(account_addresses) {
+        const ptr0 = passArrayJsValueToWasm0(account_addresses, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmclient_canMessage(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    registerIdentity() {
+        const ret = wasm.wasmclient_registerIdentity(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {Promise<string | undefined>}
+     */
+    createInboxSignatureText() {
+        const ret = wasm.wasmclient_createInboxSignatureText(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {string} existing_wallet_address
+     * @param {string} new_wallet_address
+     * @returns {Promise<string>}
+     */
+    addWalletSignatureText(existing_wallet_address, new_wallet_address) {
+        const ptr0 = passStringToWasm0(existing_wallet_address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(new_wallet_address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmclient_addWalletSignatureText(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        return ret;
+    }
+    /**
+     * @param {string} wallet_address
+     * @returns {Promise<string>}
+     */
+    revokeWalletSignatureText(wallet_address) {
+        const ptr0 = passStringToWasm0(wallet_address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmclient_revokeWalletSignatureText(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @returns {Promise<string>}
+     */
+    revokeInstallationsSignatureText() {
+        const ret = wasm.wasmclient_revokeInstallationsSignatureText(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {WasmSignatureRequestType} signature_type
+     * @param {Uint8Array} signature_bytes
+     * @returns {Promise<void>}
+     */
+    addSignature(signature_type, signature_bytes) {
+        const ret = wasm.wasmclient_addSignature(this.__wbg_ptr, signature_type, signature_bytes);
+        return ret;
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    applySignatureRequests() {
+        const ret = wasm.wasmclient_applySignatureRequests(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    requestHistorySync() {
+        const ret = wasm.wasmclient_requestHistorySync(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {string} address
+     * @returns {Promise<string | undefined>}
+     */
+    findInboxIdByAddress(address) {
+        const ptr0 = passStringToWasm0(address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmclient_findInboxIdByAddress(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     *
+     *   * Get the client's inbox state.
+     *   *
+     *   * If `refresh_from_network` is true, the client will go to the network first to refresh the state.
+     *   * Otherwise, the state will be read from the local database.
+     *
+     * @param {boolean} refresh_from_network
+     * @returns {Promise<WasmInboxState>}
+     */
+    inboxState(refresh_from_network) {
+        const ret = wasm.wasmclient_inboxState(this.__wbg_ptr, refresh_from_network);
+        return ret;
+    }
+    /**
+     * @param {string} inbox_id
+     * @returns {Promise<WasmInboxState>}
+     */
+    getLatestInboxState(inbox_id) {
+        const ptr0 = passStringToWasm0(inbox_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmclient_getLatestInboxState(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @param {(WasmConsent)[]} records
+     * @returns {Promise<void>}
+     */
+    setConsentStates(records) {
+        const ptr0 = passArrayJsValueToWasm0(records, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmclient_setConsentStates(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @param {WasmConsentEntityType} entity_type
+     * @param {string} entity
+     * @returns {Promise<WasmConsentState>}
+     */
+    getConsentState(entity_type, entity) {
+        const ptr0 = passStringToWasm0(entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmclient_getConsentState(this.__wbg_ptr, entity_type, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @returns {WasmConversations}
+     */
+    conversations() {
+        const ret = wasm.wasmclient_conversations(this.__wbg_ptr);
+        return WasmConversations.__wrap(ret);
+    }
+}
+
+const WasmConsentFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmconsent_free(ptr >>> 0, 1));
+
+export class WasmConsent {
+
+    static __unwrap(jsValue) {
+        if (!(jsValue instanceof WasmConsent)) {
+            return 0;
+        }
+        return jsValue.__destroy_into_raw();
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmConsentFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmconsent_free(ptr, 0);
+    }
+    /**
+     * @returns {WasmConsentEntityType}
+     */
+    get entity_type() {
+        const ret = wasm.__wbg_get_wasmconsent_entity_type(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {WasmConsentEntityType} arg0
+     */
+    set entity_type(arg0) {
+        wasm.__wbg_set_wasmconsent_entity_type(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {WasmConsentState}
+     */
+    get state() {
+        const ret = wasm.__wbg_get_wasmconsent_state(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {WasmConsentState} arg0
+     */
+    set state(arg0) {
+        wasm.__wbg_set_wasmconsent_state(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {string}
+     */
+    get entity() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.__wbg_get_wasmconsent_entity(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);
+        }
+    }
+    /**
+     * @param {string} arg0
+     */
+    set entity(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_wasmconsent_entity(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {WasmConsentEntityType} entity_type
+     * @param {WasmConsentState} state
+     * @param {string} entity
+     */
+    constructor(entity_type, state, entity) {
+        const ptr0 = passStringToWasm0(entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmconsent_new(entity_type, state, ptr0, len0);
+        this.__wbg_ptr = ret >>> 0;
+        WasmConsentFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+
+const WasmContentTypeIdFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmcontenttypeid_free(ptr >>> 0, 1));
+
+export class WasmContentTypeId {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmContentTypeId.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmContentTypeIdFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmContentTypeIdFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmcontenttypeid_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    get authority_id() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.__wbg_get_wasmcontenttypeid_authority_id(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);
+        }
+    }
+    /**
+     * @param {string} arg0
+     */
+    set authority_id(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_wasmcontenttypeid_authority_id(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @returns {string}
+     */
+    get type_id() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.__wbg_get_wasmcontenttypeid_type_id(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);
+        }
+    }
+    /**
+     * @param {string} arg0
+     */
+    set type_id(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_wasmcontenttypeid_type_id(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @returns {number}
+     */
+    get version_major() {
+        const ret = wasm.__wbg_get_wasmcontenttypeid_version_major(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set version_major(arg0) {
+        wasm.__wbg_set_wasmcontenttypeid_version_major(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get version_minor() {
+        const ret = wasm.__wbg_get_wasmcontenttypeid_version_minor(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set version_minor(arg0) {
+        wasm.__wbg_set_wasmcontenttypeid_version_minor(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {string} authority_id
+     * @param {string} type_id
+     * @param {number} version_major
+     * @param {number} version_minor
+     */
+    constructor(authority_id, type_id, version_major, version_minor) {
+        const ptr0 = passStringToWasm0(authority_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(type_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmcontenttypeid_new(ptr0, len0, ptr1, len1, version_major, version_minor);
+        this.__wbg_ptr = ret >>> 0;
+        WasmContentTypeIdFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+
+const WasmConversationsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmconversations_free(ptr >>> 0, 1));
+
+export class WasmConversations {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmConversations.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmConversationsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmConversationsFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmconversations_free(ptr, 0);
+    }
+    /**
+     * @param {(string)[]} account_addresses
+     * @param {WasmCreateGroupOptions | undefined} [options]
+     * @returns {Promise<WasmGroup>}
+     */
+    create_group(account_addresses, options) {
+        const ptr0 = passArrayJsValueToWasm0(account_addresses, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        let ptr1 = 0;
+        if (!isLikeNone(options)) {
+            _assertClass(options, WasmCreateGroupOptions);
+            ptr1 = options.__destroy_into_raw();
+        }
+        const ret = wasm.wasmconversations_create_group(this.__wbg_ptr, ptr0, len0, ptr1);
+        return ret;
+    }
+    /**
+     * @param {string} group_id
+     * @returns {WasmGroup}
+     */
+    find_group_by_id(group_id) {
+        const ptr0 = passStringToWasm0(group_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmconversations_find_group_by_id(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmGroup.__wrap(ret[0]);
+    }
+    /**
+     * @param {string} message_id
+     * @returns {WasmMessage}
+     */
+    find_message_by_id(message_id) {
+        const ptr0 = passStringToWasm0(message_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmconversations_find_message_by_id(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmMessage.__wrap(ret[0]);
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    sync() {
+        const ret = wasm.wasmconversations_sync(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {WasmListConversationsOptions | undefined} [opts]
+     * @returns {Promise<Array<any>>}
+     */
+    list(opts) {
+        let ptr0 = 0;
+        if (!isLikeNone(opts)) {
+            _assertClass(opts, WasmListConversationsOptions);
+            ptr0 = opts.__destroy_into_raw();
+        }
+        const ret = wasm.wasmconversations_list(this.__wbg_ptr, ptr0);
+        return ret;
+    }
+}
+
+const WasmCreateGroupOptionsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmcreategroupoptions_free(ptr >>> 0, 1));
+
+export class WasmCreateGroupOptions {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmCreateGroupOptionsFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmcreategroupoptions_free(ptr, 0);
+    }
+    /**
+     * @returns {WasmGroupPermissionsOptions | undefined}
+     */
+    get permissions() {
+        const ret = wasm.__wbg_get_wasmcreategroupoptions_permissions(this.__wbg_ptr);
+        return ret === 3 ? undefined : ret;
+    }
+    /**
+     * @param {WasmGroupPermissionsOptions | undefined} [arg0]
+     */
+    set permissions(arg0) {
+        wasm.__wbg_set_wasmcreategroupoptions_permissions(this.__wbg_ptr, isLikeNone(arg0) ? 3 : arg0);
+    }
+    /**
+     * @returns {string | undefined}
+     */
+    get group_name() {
+        const ret = wasm.__wbg_get_wasmcreategroupoptions_group_name(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * @param {string | undefined} [arg0]
+     */
+    set group_name(arg0) {
+        var ptr0 = isLikeNone(arg0) ? 0 : passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_wasmcreategroupoptions_group_name(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @returns {string | undefined}
+     */
+    get group_image_url_square() {
+        const ret = wasm.__wbg_get_wasmcreategroupoptions_group_image_url_square(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * @param {string | undefined} [arg0]
+     */
+    set group_image_url_square(arg0) {
+        var ptr0 = isLikeNone(arg0) ? 0 : passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_wasmcreategroupoptions_group_image_url_square(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @returns {string | undefined}
+     */
+    get group_description() {
+        const ret = wasm.__wbg_get_wasmcreategroupoptions_group_description(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * @param {string | undefined} [arg0]
+     */
+    set group_description(arg0) {
+        var ptr0 = isLikeNone(arg0) ? 0 : passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_wasmcreategroupoptions_group_description(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @returns {string | undefined}
+     */
+    get group_pinned_frame_url() {
+        const ret = wasm.__wbg_get_wasmcreategroupoptions_group_pinned_frame_url(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * @param {string | undefined} [arg0]
+     */
+    set group_pinned_frame_url(arg0) {
+        var ptr0 = isLikeNone(arg0) ? 0 : passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_wasmcreategroupoptions_group_pinned_frame_url(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {WasmGroupPermissionsOptions | undefined} [permissions]
+     * @param {string | undefined} [group_name]
+     * @param {string | undefined} [group_image_url_square]
+     * @param {string | undefined} [group_description]
+     * @param {string | undefined} [group_pinned_frame_url]
+     */
+    constructor(permissions, group_name, group_image_url_square, group_description, group_pinned_frame_url) {
+        var ptr0 = isLikeNone(group_name) ? 0 : passStringToWasm0(group_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(group_image_url_square) ? 0 : passStringToWasm0(group_image_url_square, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        var ptr2 = isLikeNone(group_description) ? 0 : passStringToWasm0(group_description, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len2 = WASM_VECTOR_LEN;
+        var ptr3 = isLikeNone(group_pinned_frame_url) ? 0 : passStringToWasm0(group_pinned_frame_url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len3 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmcreategroupoptions_new(isLikeNone(permissions) ? 3 : permissions, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+        this.__wbg_ptr = ret >>> 0;
+        WasmCreateGroupOptionsFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+
+const WasmEncodedContentFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmencodedcontent_free(ptr >>> 0, 1));
+
+export class WasmEncodedContent {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmEncodedContent.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmEncodedContentFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmEncodedContentFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmencodedcontent_free(ptr, 0);
+    }
+    /**
+     * @returns {WasmContentTypeId | undefined}
+     */
+    get type() {
+        const ret = wasm.__wbg_get_wasmencodedcontent_type(this.__wbg_ptr);
+        return ret === 0 ? undefined : WasmContentTypeId.__wrap(ret);
+    }
+    /**
+     * @param {WasmContentTypeId | undefined} [arg0]
+     */
+    set type(arg0) {
+        let ptr0 = 0;
+        if (!isLikeNone(arg0)) {
+            _assertClass(arg0, WasmContentTypeId);
+            ptr0 = arg0.__destroy_into_raw();
+        }
+        wasm.__wbg_set_wasmencodedcontent_type(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * @returns {any}
+     */
+    get parameters() {
+        const ret = wasm.__wbg_get_wasmencodedcontent_parameters(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {any} arg0
+     */
+    set parameters(arg0) {
+        wasm.__wbg_set_wasmencodedcontent_parameters(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {string | undefined}
+     */
+    get fallback() {
+        const ret = wasm.__wbg_get_wasmencodedcontent_fallback(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * @param {string | undefined} [arg0]
+     */
+    set fallback(arg0) {
+        var ptr0 = isLikeNone(arg0) ? 0 : passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_wasmencodedcontent_fallback(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @returns {number | undefined}
+     */
+    get compression() {
+        const ret = wasm.__wbg_get_wasmencodedcontent_compression(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : ret[1];
+    }
+    /**
+     * @param {number | undefined} [arg0]
+     */
+    set compression(arg0) {
+        wasm.__wbg_set_wasmencodedcontent_compression(this.__wbg_ptr, !isLikeNone(arg0), isLikeNone(arg0) ? 0 : arg0);
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get content() {
+        const ret = wasm.__wbg_get_wasmencodedcontent_content(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {Uint8Array} arg0
+     */
+    set content(arg0) {
+        wasm.__wbg_set_wasmencodedcontent_content(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {WasmContentTypeId | undefined} type
+     * @param {any} parameters
+     * @param {string | undefined} fallback
+     * @param {number | undefined} compression
+     * @param {Uint8Array} content
+     */
+    constructor(type, parameters, fallback, compression, content) {
+        let ptr0 = 0;
+        if (!isLikeNone(type)) {
+            _assertClass(type, WasmContentTypeId);
+            ptr0 = type.__destroy_into_raw();
+        }
+        var ptr1 = isLikeNone(fallback) ? 0 : passStringToWasm0(fallback, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmencodedcontent_new(ptr0, parameters, ptr1, len1, !isLikeNone(compression), isLikeNone(compression) ? 0 : compression, content);
+        this.__wbg_ptr = ret >>> 0;
+        WasmEncodedContentFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+
+const WasmGroupFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmgroup_free(ptr >>> 0, 1));
+
+export class WasmGroup {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmGroup.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmGroupFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmGroupFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmgroup_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    id() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmgroup_id(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);
+        }
+    }
+    /**
+     * @param {WasmEncodedContent} encoded_content
+     * @returns {Promise<string>}
+     */
+    send(encoded_content) {
+        _assertClass(encoded_content, WasmEncodedContent);
+        var ptr0 = encoded_content.__destroy_into_raw();
+        const ret = wasm.wasmgroup_send(this.__wbg_ptr, ptr0);
+        return ret;
+    }
+    /**
+     * send a message without immediately publishing to the delivery service.
+     * @param {WasmEncodedContent} encoded_content
+     * @returns {string}
+     */
+    send_optimistic(encoded_content) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            _assertClass(encoded_content, WasmEncodedContent);
+            var ptr0 = encoded_content.__destroy_into_raw();
+            const ret = wasm.wasmgroup_send_optimistic(this.__wbg_ptr, ptr0);
+            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);
+        }
+    }
+    /**
+     * Publish all unpublished messages
+     * @returns {Promise<void>}
+     */
+    publish_messages() {
+        const ret = wasm.wasmgroup_publish_messages(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    sync() {
+        const ret = wasm.wasmgroup_sync(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {WasmListMessagesOptions | undefined} [opts]
+     * @returns {(WasmMessage)[]}
+     */
+    find_messages(opts) {
+        let ptr0 = 0;
+        if (!isLikeNone(opts)) {
+            _assertClass(opts, WasmListMessagesOptions);
+            ptr0 = opts.__destroy_into_raw();
+        }
+        const ret = wasm.wasmgroup_find_messages(this.__wbg_ptr, ptr0);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v2 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v2;
+    }
+    /**
+     * @returns {Promise<any>}
+     */
+    list_members() {
+        const ret = wasm.wasmgroup_list_members(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {(string)[]}
+     */
+    admin_list() {
+        const ret = wasm.wasmgroup_admin_list(this.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @returns {(string)[]}
+     */
+    super_admin_list() {
+        const ret = wasm.wasmgroup_super_admin_list(this.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @param {string} inbox_id
+     * @returns {boolean}
+     */
+    is_admin(inbox_id) {
+        const ptr0 = passStringToWasm0(inbox_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmgroup_is_admin(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * @param {string} inbox_id
+     * @returns {boolean}
+     */
+    is_super_admin(inbox_id) {
+        const ptr0 = passStringToWasm0(inbox_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmgroup_is_super_admin(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * @param {(string)[]} account_addresses
+     * @returns {Promise<void>}
+     */
+    add_members(account_addresses) {
+        const ptr0 = passArrayJsValueToWasm0(account_addresses, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmgroup_add_members(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @param {string} inbox_id
+     * @returns {Promise<void>}
+     */
+    add_admin(inbox_id) {
+        const ptr0 = passStringToWasm0(inbox_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmgroup_add_admin(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @param {string} inbox_id
+     * @returns {Promise<void>}
+     */
+    remove_admin(inbox_id) {
+        const ptr0 = passStringToWasm0(inbox_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmgroup_remove_admin(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @param {string} inbox_id
+     * @returns {Promise<void>}
+     */
+    add_super_admin(inbox_id) {
+        const ptr0 = passStringToWasm0(inbox_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmgroup_add_super_admin(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @param {string} inbox_id
+     * @returns {Promise<void>}
+     */
+    remove_super_admin(inbox_id) {
+        const ptr0 = passStringToWasm0(inbox_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmgroup_remove_super_admin(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @returns {WasmGroupPermissions}
+     */
+    group_permissions() {
+        const ret = wasm.wasmgroup_group_permissions(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmGroupPermissions.__wrap(ret[0]);
+    }
+    /**
+     * @param {(string)[]} inbox_ids
+     * @returns {Promise<void>}
+     */
+    add_members_by_inbox_id(inbox_ids) {
+        const ptr0 = passArrayJsValueToWasm0(inbox_ids, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmgroup_add_members_by_inbox_id(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @param {(string)[]} account_addresses
+     * @returns {Promise<void>}
+     */
+    remove_members(account_addresses) {
+        const ptr0 = passArrayJsValueToWasm0(account_addresses, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmgroup_remove_members(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @param {(string)[]} inbox_ids
+     * @returns {Promise<void>}
+     */
+    remove_members_by_inbox_id(inbox_ids) {
+        const ptr0 = passArrayJsValueToWasm0(inbox_ids, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmgroup_remove_members_by_inbox_id(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @param {string} group_name
+     * @returns {Promise<void>}
+     */
+    update_group_name(group_name) {
+        const ptr0 = passStringToWasm0(group_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmgroup_update_group_name(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @returns {string}
+     */
+    group_name() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.wasmgroup_group_name(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * @param {string} group_image_url_square
+     * @returns {Promise<void>}
+     */
+    update_group_image_url_square(group_image_url_square) {
+        const ptr0 = passStringToWasm0(group_image_url_square, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmgroup_update_group_image_url_square(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @returns {string}
+     */
+    group_image_url_square() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.wasmgroup_group_image_url_square(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * @param {string} group_description
+     * @returns {Promise<void>}
+     */
+    update_group_description(group_description) {
+        const ptr0 = passStringToWasm0(group_description, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmgroup_update_group_description(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @returns {string}
+     */
+    group_description() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.wasmgroup_group_description(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * @param {string} pinned_frame_url
+     * @returns {Promise<void>}
+     */
+    update_group_pinned_frame_url(pinned_frame_url) {
+        const ptr0 = passStringToWasm0(pinned_frame_url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmgroup_update_group_pinned_frame_url(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @returns {string}
+     */
+    group_pinned_frame_url() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.wasmgroup_group_pinned_frame_url(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * @returns {bigint}
+     */
+    created_at_ns() {
+        const ret = wasm.wasmgroup_created_at_ns(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {boolean}
+     */
+    is_active() {
+        const ret = wasm.wasmgroup_is_active(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * @returns {string}
+     */
+    added_by_inbox_id() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.wasmgroup_added_by_inbox_id(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * @returns {WasmGroupMetadata}
+     */
+    group_metadata() {
+        const ret = wasm.wasmgroup_group_metadata(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmGroupMetadata.__wrap(ret[0]);
+    }
+    /**
+     * @returns {WasmConsentState}
+     */
+    consent_state() {
+        const ret = wasm.wasmgroup_consent_state(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * @param {WasmConsentState} state
+     */
+    update_consent_state(state) {
+        const ret = wasm.wasmgroup_update_consent_state(this.__wbg_ptr, state);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+}
+
+const WasmGroupMemberFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmgroupmember_free(ptr >>> 0, 1));
+
+export class WasmGroupMember {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmGroupMemberFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmgroupmember_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    get inbox_id() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.__wbg_get_wasmgroupmember_inbox_id(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);
+        }
+    }
+    /**
+     * @param {string} arg0
+     */
+    set inbox_id(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_wasmconsent_entity(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @returns {(string)[]}
+     */
+    get account_addresses() {
+        const ret = wasm.__wbg_get_wasmgroupmember_account_addresses(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @param {(string)[]} arg0
+     */
+    set account_addresses(arg0) {
+        const ptr0 = passArrayJsValueToWasm0(arg0, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_wasmgroupmember_account_addresses(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @returns {(string)[]}
+     */
+    get installation_ids() {
+        const ret = wasm.__wbg_get_wasmgroupmember_installation_ids(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @param {(string)[]} arg0
+     */
+    set installation_ids(arg0) {
+        const ptr0 = passArrayJsValueToWasm0(arg0, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_wasmgroupmember_installation_ids(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @returns {WasmPermissionLevel}
+     */
+    get permission_level() {
+        const ret = wasm.__wbg_get_wasmgroupmember_permission_level(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {WasmPermissionLevel} arg0
+     */
+    set permission_level(arg0) {
+        wasm.__wbg_set_wasmgroupmember_permission_level(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {WasmConsentState}
+     */
+    get consent_state() {
+        const ret = wasm.__wbg_get_wasmgroupmember_consent_state(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {WasmConsentState} arg0
+     */
+    set consent_state(arg0) {
+        wasm.__wbg_set_wasmgroupmember_consent_state(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {string} inbox_id
+     * @param {(string)[]} account_addresses
+     * @param {(string)[]} installation_ids
+     * @param {WasmPermissionLevel} permission_level
+     * @param {WasmConsentState} consent_state
+     */
+    constructor(inbox_id, account_addresses, installation_ids, permission_level, consent_state) {
+        const ptr0 = passStringToWasm0(inbox_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayJsValueToWasm0(account_addresses, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArrayJsValueToWasm0(installation_ids, wasm.__wbindgen_malloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmgroupmember_new(ptr0, len0, ptr1, len1, ptr2, len2, permission_level, consent_state);
+        this.__wbg_ptr = ret >>> 0;
+        WasmGroupMemberFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+
+const WasmGroupMetadataFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmgroupmetadata_free(ptr >>> 0, 1));
+
+export class WasmGroupMetadata {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmGroupMetadata.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmGroupMetadataFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmGroupMetadataFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmgroupmetadata_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    creator_inbox_id() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmgroupmetadata_creator_inbox_id(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);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    conversation_type() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmgroupmetadata_conversation_type(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);
+        }
+    }
+}
+
+const WasmGroupPermissionsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmgrouppermissions_free(ptr >>> 0, 1));
+
+export class WasmGroupPermissions {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmGroupPermissions.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmGroupPermissionsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmGroupPermissionsFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmgrouppermissions_free(ptr, 0);
+    }
+    /**
+     * @returns {WasmGroupPermissionsOptions}
+     */
+    policy_type() {
+        const ret = wasm.wasmgrouppermissions_policy_type(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * @returns {WasmPermissionPolicySet}
+     */
+    policy_set() {
+        const ret = wasm.wasmgrouppermissions_policy_set(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmPermissionPolicySet.__wrap(ret[0]);
+    }
+}
+
+const WasmInboxStateFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasminboxstate_free(ptr >>> 0, 1));
+
+export class WasmInboxState {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmInboxState.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmInboxStateFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmInboxStateFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasminboxstate_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    get inbox_id() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.__wbg_get_wasminboxstate_inbox_id(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);
+        }
+    }
+    /**
+     * @param {string} arg0
+     */
+    set inbox_id(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_wasmconsent_entity(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @returns {string}
+     */
+    get recovery_address() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.__wbg_get_wasminboxstate_recovery_address(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);
+        }
+    }
+    /**
+     * @param {string} arg0
+     */
+    set recovery_address(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_wasminboxstate_recovery_address(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @returns {(WasmInstallation)[]}
+     */
+    get installations() {
+        const ret = wasm.__wbg_get_wasminboxstate_installations(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @param {(WasmInstallation)[]} arg0
+     */
+    set installations(arg0) {
+        const ptr0 = passArrayJsValueToWasm0(arg0, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_wasminboxstate_installations(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @returns {(string)[]}
+     */
+    get account_addresses() {
+        const ret = wasm.__wbg_get_wasminboxstate_account_addresses(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @param {(string)[]} arg0
+     */
+    set account_addresses(arg0) {
+        const ptr0 = passArrayJsValueToWasm0(arg0, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_wasminboxstate_account_addresses(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {string} inbox_id
+     * @param {string} recovery_address
+     * @param {(WasmInstallation)[]} installations
+     * @param {(string)[]} account_addresses
+     */
+    constructor(inbox_id, recovery_address, installations, account_addresses) {
+        const ptr0 = passStringToWasm0(inbox_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(recovery_address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArrayJsValueToWasm0(installations, wasm.__wbindgen_malloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passArrayJsValueToWasm0(account_addresses, wasm.__wbindgen_malloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ret = wasm.wasminboxstate_new(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+        this.__wbg_ptr = ret >>> 0;
+        WasmInboxStateFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+
+const WasmInstallationFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasminstallation_free(ptr >>> 0, 1));
+
+export class WasmInstallation {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmInstallation.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmInstallationFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    static __unwrap(jsValue) {
+        if (!(jsValue instanceof WasmInstallation)) {
+            return 0;
+        }
+        return jsValue.__destroy_into_raw();
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmInstallationFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasminstallation_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    get id() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.__wbg_get_wasminstallation_id(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);
+        }
+    }
+    /**
+     * @param {string} arg0
+     */
+    set id(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_wasminstallation_id(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @returns {bigint | undefined}
+     */
+    get client_timestamp_ns() {
+        const ret = wasm.__wbg_get_wasminstallation_client_timestamp_ns(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
+    }
+    /**
+     * @param {bigint | undefined} [arg0]
+     */
+    set client_timestamp_ns(arg0) {
+        wasm.__wbg_set_wasminstallation_client_timestamp_ns(this.__wbg_ptr, !isLikeNone(arg0), isLikeNone(arg0) ? BigInt(0) : arg0);
+    }
+    /**
+     * @param {string} id
+     * @param {bigint | undefined} [client_timestamp_ns]
+     */
+    constructor(id, client_timestamp_ns) {
+        const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasminstallation_new(ptr0, len0, !isLikeNone(client_timestamp_ns), isLikeNone(client_timestamp_ns) ? BigInt(0) : client_timestamp_ns);
+        this.__wbg_ptr = ret >>> 0;
+        WasmInstallationFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+
+const WasmListConversationsOptionsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmlistconversationsoptions_free(ptr >>> 0, 1));
+
+export class WasmListConversationsOptions {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmListConversationsOptionsFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmlistconversationsoptions_free(ptr, 0);
+    }
+    /**
+     * @returns {bigint | undefined}
+     */
+    get created_after_ns() {
+        const ret = wasm.__wbg_get_wasmlistconversationsoptions_created_after_ns(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : ret[1];
+    }
+    /**
+     * @param {bigint | undefined} [arg0]
+     */
+    set created_after_ns(arg0) {
+        wasm.__wbg_set_wasmlistconversationsoptions_created_after_ns(this.__wbg_ptr, !isLikeNone(arg0), isLikeNone(arg0) ? BigInt(0) : arg0);
+    }
+    /**
+     * @returns {bigint | undefined}
+     */
+    get created_before_ns() {
+        const ret = wasm.__wbg_get_wasmlistconversationsoptions_created_before_ns(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : ret[1];
+    }
+    /**
+     * @param {bigint | undefined} [arg0]
+     */
+    set created_before_ns(arg0) {
+        wasm.__wbg_set_wasmlistconversationsoptions_created_before_ns(this.__wbg_ptr, !isLikeNone(arg0), isLikeNone(arg0) ? BigInt(0) : arg0);
+    }
+    /**
+     * @returns {bigint | undefined}
+     */
+    get limit() {
+        const ret = wasm.__wbg_get_wasmlistconversationsoptions_limit(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : ret[1];
+    }
+    /**
+     * @param {bigint | undefined} [arg0]
+     */
+    set limit(arg0) {
+        wasm.__wbg_set_wasmlistconversationsoptions_limit(this.__wbg_ptr, !isLikeNone(arg0), isLikeNone(arg0) ? BigInt(0) : arg0);
+    }
+    /**
+     * @param {bigint | undefined} [created_after_ns]
+     * @param {bigint | undefined} [created_before_ns]
+     * @param {bigint | undefined} [limit]
+     */
+    constructor(created_after_ns, created_before_ns, limit) {
+        const ret = wasm.wasmlistconversationsoptions_new(!isLikeNone(created_after_ns), isLikeNone(created_after_ns) ? BigInt(0) : created_after_ns, !isLikeNone(created_before_ns), isLikeNone(created_before_ns) ? BigInt(0) : created_before_ns, !isLikeNone(limit), isLikeNone(limit) ? BigInt(0) : limit);
+        this.__wbg_ptr = ret >>> 0;
+        WasmListConversationsOptionsFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+
+const WasmListMessagesOptionsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmlistmessagesoptions_free(ptr >>> 0, 1));
+
+export class WasmListMessagesOptions {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmListMessagesOptionsFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmlistmessagesoptions_free(ptr, 0);
+    }
+    /**
+     * @returns {bigint | undefined}
+     */
+    get sent_before_ns() {
+        const ret = wasm.__wbg_get_wasmlistmessagesoptions_sent_before_ns(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : ret[1];
+    }
+    /**
+     * @param {bigint | undefined} [arg0]
+     */
+    set sent_before_ns(arg0) {
+        wasm.__wbg_set_wasmlistconversationsoptions_created_after_ns(this.__wbg_ptr, !isLikeNone(arg0), isLikeNone(arg0) ? BigInt(0) : arg0);
+    }
+    /**
+     * @returns {bigint | undefined}
+     */
+    get sent_after_ns() {
+        const ret = wasm.__wbg_get_wasmlistmessagesoptions_sent_after_ns(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : ret[1];
+    }
+    /**
+     * @param {bigint | undefined} [arg0]
+     */
+    set sent_after_ns(arg0) {
+        wasm.__wbg_set_wasmlistconversationsoptions_created_before_ns(this.__wbg_ptr, !isLikeNone(arg0), isLikeNone(arg0) ? BigInt(0) : arg0);
+    }
+    /**
+     * @returns {bigint | undefined}
+     */
+    get limit() {
+        const ret = wasm.__wbg_get_wasmlistmessagesoptions_limit(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : ret[1];
+    }
+    /**
+     * @param {bigint | undefined} [arg0]
+     */
+    set limit(arg0) {
+        wasm.__wbg_set_wasmlistconversationsoptions_limit(this.__wbg_ptr, !isLikeNone(arg0), isLikeNone(arg0) ? BigInt(0) : arg0);
+    }
+    /**
+     * @returns {WasmDeliveryStatus | undefined}
+     */
+    get delivery_status() {
+        const ret = wasm.__wbg_get_wasmlistmessagesoptions_delivery_status(this.__wbg_ptr);
+        return ret === 3 ? undefined : ret;
+    }
+    /**
+     * @param {WasmDeliveryStatus | undefined} [arg0]
+     */
+    set delivery_status(arg0) {
+        wasm.__wbg_set_wasmlistmessagesoptions_delivery_status(this.__wbg_ptr, isLikeNone(arg0) ? 3 : arg0);
+    }
+    /**
+     * @param {bigint | undefined} [sent_before_ns]
+     * @param {bigint | undefined} [sent_after_ns]
+     * @param {bigint | undefined} [limit]
+     * @param {WasmDeliveryStatus | undefined} [delivery_status]
+     */
+    constructor(sent_before_ns, sent_after_ns, limit, delivery_status) {
+        const ret = wasm.wasmlistmessagesoptions_new(!isLikeNone(sent_before_ns), isLikeNone(sent_before_ns) ? BigInt(0) : sent_before_ns, !isLikeNone(sent_after_ns), isLikeNone(sent_after_ns) ? BigInt(0) : sent_after_ns, !isLikeNone(limit), isLikeNone(limit) ? BigInt(0) : limit, isLikeNone(delivery_status) ? 3 : delivery_status);
+        this.__wbg_ptr = ret >>> 0;
+        WasmListMessagesOptionsFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+
+const WasmMessageFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmmessage_free(ptr >>> 0, 1));
+
+export class WasmMessage {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmMessage.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmMessageFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmMessageFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmmessage_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    get id() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.__wbg_get_wasmmessage_id(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);
+        }
+    }
+    /**
+     * @param {string} arg0
+     */
+    set id(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_wasmmessage_id(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @returns {bigint}
+     */
+    get sent_at_ns() {
+        const ret = wasm.__wbg_get_wasmmessage_sent_at_ns(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {bigint} arg0
+     */
+    set sent_at_ns(arg0) {
+        wasm.__wbg_set_wasmmessage_sent_at_ns(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {string}
+     */
+    get convo_id() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.__wbg_get_wasmmessage_convo_id(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);
+        }
+    }
+    /**
+     * @param {string} arg0
+     */
+    set convo_id(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_wasmmessage_convo_id(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @returns {string}
+     */
+    get sender_inbox_id() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.__wbg_get_wasmmessage_sender_inbox_id(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);
+        }
+    }
+    /**
+     * @param {string} arg0
+     */
+    set sender_inbox_id(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_wasmmessage_sender_inbox_id(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @returns {WasmEncodedContent}
+     */
+    get content() {
+        const ret = wasm.__wbg_get_wasmmessage_content(this.__wbg_ptr);
+        return WasmEncodedContent.__wrap(ret);
+    }
+    /**
+     * @param {WasmEncodedContent} arg0
+     */
+    set content(arg0) {
+        _assertClass(arg0, WasmEncodedContent);
+        var ptr0 = arg0.__destroy_into_raw();
+        wasm.__wbg_set_wasmmessage_content(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * @returns {WasmGroupMessageKind}
+     */
+    get kind() {
+        const ret = wasm.__wbg_get_wasmmessage_kind(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {WasmGroupMessageKind} arg0
+     */
+    set kind(arg0) {
+        wasm.__wbg_set_wasmmessage_kind(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {WasmDeliveryStatus}
+     */
+    get delivery_status() {
+        const ret = wasm.__wbg_get_wasmmessage_delivery_status(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {WasmDeliveryStatus} arg0
+     */
+    set delivery_status(arg0) {
+        wasm.__wbg_set_wasmmessage_delivery_status(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {string} id
+     * @param {bigint} sent_at_ns
+     * @param {string} convo_id
+     * @param {string} sender_inbox_id
+     * @param {WasmEncodedContent} content
+     * @param {WasmGroupMessageKind} kind
+     * @param {WasmDeliveryStatus} delivery_status
+     */
+    constructor(id, sent_at_ns, convo_id, sender_inbox_id, content, kind, delivery_status) {
+        const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(convo_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(sender_inbox_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        _assertClass(content, WasmEncodedContent);
+        var ptr3 = content.__destroy_into_raw();
+        const ret = wasm.wasmmessage_new(ptr0, len0, sent_at_ns, ptr1, len1, ptr2, len2, ptr3, kind, delivery_status);
+        this.__wbg_ptr = ret >>> 0;
+        WasmMessageFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+
+const WasmPermissionPolicySetFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmpermissionpolicyset_free(ptr >>> 0, 1));
+
+export class WasmPermissionPolicySet {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmPermissionPolicySet.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmPermissionPolicySetFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmPermissionPolicySetFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmpermissionpolicyset_free(ptr, 0);
+    }
+    /**
+     * @returns {WasmPermissionPolicy}
+     */
+    get add_member_policy() {
+        const ret = wasm.__wbg_get_wasmpermissionpolicyset_add_member_policy(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {WasmPermissionPolicy} arg0
+     */
+    set add_member_policy(arg0) {
+        wasm.__wbg_set_wasmpermissionpolicyset_add_member_policy(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {WasmPermissionPolicy}
+     */
+    get remove_member_policy() {
+        const ret = wasm.__wbg_get_wasmpermissionpolicyset_remove_member_policy(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {WasmPermissionPolicy} arg0
+     */
+    set remove_member_policy(arg0) {
+        wasm.__wbg_set_wasmpermissionpolicyset_remove_member_policy(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {WasmPermissionPolicy}
+     */
+    get add_admin_policy() {
+        const ret = wasm.__wbg_get_wasmpermissionpolicyset_add_admin_policy(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {WasmPermissionPolicy} arg0
+     */
+    set add_admin_policy(arg0) {
+        wasm.__wbg_set_wasmpermissionpolicyset_add_admin_policy(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {WasmPermissionPolicy}
+     */
+    get remove_admin_policy() {
+        const ret = wasm.__wbg_get_wasmpermissionpolicyset_remove_admin_policy(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {WasmPermissionPolicy} arg0
+     */
+    set remove_admin_policy(arg0) {
+        wasm.__wbg_set_wasmpermissionpolicyset_remove_admin_policy(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {WasmPermissionPolicy}
+     */
+    get update_group_name_policy() {
+        const ret = wasm.__wbg_get_wasmpermissionpolicyset_update_group_name_policy(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {WasmPermissionPolicy} arg0
+     */
+    set update_group_name_policy(arg0) {
+        wasm.__wbg_set_wasmpermissionpolicyset_update_group_name_policy(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {WasmPermissionPolicy}
+     */
+    get update_group_description_policy() {
+        const ret = wasm.__wbg_get_wasmpermissionpolicyset_update_group_description_policy(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {WasmPermissionPolicy} arg0
+     */
+    set update_group_description_policy(arg0) {
+        wasm.__wbg_set_wasmpermissionpolicyset_update_group_description_policy(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {WasmPermissionPolicy}
+     */
+    get update_group_image_url_square_policy() {
+        const ret = wasm.__wbg_get_wasmpermissionpolicyset_update_group_image_url_square_policy(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {WasmPermissionPolicy} arg0
+     */
+    set update_group_image_url_square_policy(arg0) {
+        wasm.__wbg_set_wasmpermissionpolicyset_update_group_image_url_square_policy(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {WasmPermissionPolicy}
+     */
+    get update_group_pinned_frame_url_policy() {
+        const ret = wasm.__wbg_get_wasmpermissionpolicyset_update_group_pinned_frame_url_policy(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {WasmPermissionPolicy} arg0
+     */
+    set update_group_pinned_frame_url_policy(arg0) {
+        wasm.__wbg_set_wasmpermissionpolicyset_update_group_pinned_frame_url_policy(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {WasmPermissionPolicy} add_member_policy
+     * @param {WasmPermissionPolicy} remove_member_policy
+     * @param {WasmPermissionPolicy} add_admin_policy
+     * @param {WasmPermissionPolicy} remove_admin_policy
+     * @param {WasmPermissionPolicy} update_group_name_policy
+     * @param {WasmPermissionPolicy} update_group_description_policy
+     * @param {WasmPermissionPolicy} update_group_image_url_square_policy
+     * @param {WasmPermissionPolicy} update_group_pinned_frame_url_policy
+     */
+    constructor(add_member_policy, remove_member_policy, add_admin_policy, remove_admin_policy, update_group_name_policy, update_group_description_policy, update_group_image_url_square_policy, update_group_pinned_frame_url_policy) {
+        const ret = wasm.wasmpermissionpolicyset_new(add_member_policy, remove_member_policy, add_admin_policy, remove_admin_policy, update_group_name_policy, update_group_description_policy, update_group_image_url_square_policy, update_group_pinned_frame_url_policy);
+        this.__wbg_ptr = ret >>> 0;
+        WasmPermissionPolicySetFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+
+async function __wbg_load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+
+            } catch (e) {
+                if (module.headers.get('Content-Type') != 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else {
+                    throw e;
+                }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+
+        } else {
+            return instance;
+        }
+    }
+}
+
+function __wbg_get_imports() {
+    const imports = {};
+    imports.wbg = {};
+    imports.wbg.__wbg_initmodule_6df8583bfed9380b = function(arg0) {
+        const ret = SQLite.init_module(arg0);
+        return ret;
+    };
+    imports.wbg.__wbindgen_error_new = function(arg0, arg1) {
+        const ret = new Error(getStringFromWasm0(arg0, arg1));
+        return ret;
+    };
+    imports.wbg.__wbindgen_number_new = function(arg0) {
+        const ret = arg0;
+        return ret;
+    };
+    imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
+        const ret = getStringFromWasm0(arg0, arg1);
+        return ret;
+    };
+    imports.wbg.__wbg_wasminstallation_new = function(arg0) {
+        const ret = WasmInstallation.__wrap(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_wasmgroup_new = function(arg0) {
+        const ret = WasmGroup.__wrap(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_wasminboxstate_new = function(arg0) {
+        const ret = WasmInboxState.__wrap(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_wasmmessage_new = function(arg0) {
+        const ret = WasmMessage.__wrap(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_wasmclient_new = function(arg0) {
+        const ret = WasmClient.__wrap(arg0);
+        return ret;
+    };
+    imports.wbg.__wbindgen_is_undefined = function(arg0) {
+        const ret = arg0 === undefined;
+        return ret;
+    };
+    imports.wbg.__wbindgen_in = function(arg0, arg1) {
+        const ret = arg0 in arg1;
+        return ret;
+    };
+    imports.wbg.__wbindgen_string_get = function(arg0, arg1) {
+        const obj = arg1;
+        const ret = typeof(obj) === 'string' ? obj : undefined;
+        var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
+    imports.wbg.__wbindgen_is_object = function(arg0) {
+        const val = arg0;
+        const ret = typeof(val) === 'object' && val !== null;
+        return ret;
+    };
+    imports.wbg.__wbindgen_number_get = function(arg0, arg1) {
+        const obj = arg1;
+        const ret = typeof(obj) === 'number' ? obj : undefined;
+        getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+    };
+    imports.wbg.__wbg_wasmconsent_unwrap = function(arg0) {
+        const ret = WasmConsent.__unwrap(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_wasminstallation_unwrap = function(arg0) {
+        const ret = WasmInstallation.__unwrap(arg0);
+        return ret;
+    };
+    imports.wbg.__wbindgen_as_number = function(arg0) {
+        const ret = +arg0;
+        return ret;
+    };
+    imports.wbg.__wbindgen_cb_drop = function(arg0) {
+        const obj = arg0.original;
+        if (obj.cnt-- == 1) {
+            obj.a = 0;
+            return true;
+        }
+        const ret = false;
+        return ret;
+    };
+    imports.wbg.__wbg_clearTimeout_541ac0980ffcef74 = typeof clearTimeout == 'function' ? clearTimeout : notDefined('clearTimeout');
+    imports.wbg.__wbg_setTimeout_7d81d052875b0f4f = function() { return handleError(function (arg0, arg1) {
+        const ret = setTimeout(arg0, arg1);
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_log_c9486ca5d8e2cbe8 = function(arg0, arg1) {
+        let deferred0_0;
+        let deferred0_1;
+        try {
+            deferred0_0 = arg0;
+            deferred0_1 = arg1;
+            console.log(getStringFromWasm0(arg0, arg1));
+        } finally {
+            wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+        }
+    };
+    imports.wbg.__wbg_log_aba5996d9bde071f = function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+        let deferred0_0;
+        let deferred0_1;
+        try {
+            deferred0_0 = arg0;
+            deferred0_1 = arg1;
+            console.log(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), getStringFromWasm0(arg4, arg5), getStringFromWasm0(arg6, arg7));
+        } finally {
+            wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+        }
+    };
+    imports.wbg.__wbg_mark_40e050a77cc39fea = function(arg0, arg1) {
+        performance.mark(getStringFromWasm0(arg0, arg1));
+    };
+    imports.wbg.__wbg_measure_aa7a73f17813f708 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
+        let deferred0_0;
+        let deferred0_1;
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            deferred0_0 = arg0;
+            deferred0_1 = arg1;
+            deferred1_0 = arg2;
+            deferred1_1 = arg3;
+            performance.measure(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3));
+        } finally {
+            wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }, arguments) };
+    imports.wbg.__wbg_fetch_f8d735ba6fe1b719 = typeof fetch == 'function' ? fetch : notDefined('fetch');
+    imports.wbg.__wbg_sqlite3_ae38011f61b040f1 = function(arg0) {
+        const ret = arg0.sqlite3;
+        return ret;
+    };
+    imports.wbg.__wbg_wasm_d435af5a2079512e = function(arg0) {
+        const ret = arg0.wasm;
+        return ret;
+    };
+    imports.wbg.__wbg_pstack_fc77b7165420650a = function(arg0) {
+        const ret = arg0.pstack;
+        return ret;
+    };
+    imports.wbg.__wbg_pointer_d3c7ebff6fec1c91 = function(arg0) {
+        const ret = arg0.pointer;
+        return ret;
+    };
+    imports.wbg.__wbg_alloc_3dc7f2dcc7f32fdb = function(arg0, arg1) {
+        const ret = arg0.alloc(arg1 >>> 0);
+        return ret;
+    };
+    imports.wbg.__wbg_alloc_412cbdfb204df090 = function(arg0, arg1) {
+        const ret = arg0.alloc(arg1 >>> 0);
+        return ret;
+    };
+    imports.wbg.__wbg_preparev3_b9722ce244c18dbc = function(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
+        const ret = arg0.prepare_v3(arg1, arg2 >>> 0, arg3, arg4 >>> 0, arg5, arg6);
+        return ret;
+    };
+    imports.wbg.__wbg_peekPtr_a3eb6c43e8226b33 = function(arg0, arg1) {
+        const ret = arg0.peekPtr(arg1);
+        return ret;
+    };
+    imports.wbg.__wbg_restore_f0dcf7e42f529814 = function(arg0, arg1) {
+        arg0.restore(arg1);
+    };
+    imports.wbg.__wbindgen_is_null = function(arg0) {
+        const ret = arg0 === null;
+        return ret;
+    };
+    imports.wbg.__wbg_alloc_12d3472bbd917658 = function(arg0) {
+        const ret = arg0.alloc;
+        return ret;
+    };
+    imports.wbg.__wbg_allocPtr_a9d5b0a7a6dfb5ab = function(arg0, arg1, arg2) {
+        const ret = arg0.allocPtr(arg1 >>> 0, arg2 !== 0);
+        return ret;
+    };
+    imports.wbg.__wbg_impl_3c42f6bcb7b4c19c = function(arg0, arg1) {
+        const ret = arg0.impl(arg1 >>> 0);
+        return ret;
+    };
+    imports.wbg.__wbg_bindnull_a579e45de8665932 = function(arg0, arg1, arg2) {
+        const ret = arg0.bind_null(arg1, arg2);
+        return ret;
+    };
+    imports.wbg.__wbg_bindtext_b0a790891eeafc66 = function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        const ret = arg0.bind_text(arg1, arg2, arg3 >>> 0, arg4, arg5);
+        return ret;
+    };
+    imports.wbg.__wbg_bindint_e1f4dcb68267a201 = function(arg0, arg1, arg2, arg3) {
+        const ret = arg0.bind_int(arg1, arg2, arg3);
+        return ret;
+    };
+    imports.wbg.__wbg_bindint64_4cb9d1672a18e57b = function(arg0, arg1, arg2, arg3) {
+        const ret = arg0.bind_int64(arg1, arg2, arg3);
+        return ret;
+    };
+    imports.wbg.__wbg_binddouble_1506f6b8c0c42d14 = function(arg0, arg1, arg2, arg3) {
+        const ret = arg0.bind_double(arg1, arg2, arg3);
+        return ret;
+    };
+    imports.wbg.__wbg_bindblob_f2a0872798d6b562 = function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        const ret = arg0.bind_blob(arg1, arg2, arg3 >>> 0, arg4, arg5);
+        return ret;
+    };
+    imports.wbg.__wbg_dbhandle_9fa910514462f201 = function(arg0, arg1) {
+        const ret = arg0.db_handle(arg1);
+        return ret;
+    };
+    imports.wbg.__wbg_dealloc_351653c7fd6f869c = function(arg0, arg1) {
+        arg0.dealloc(arg1 >>> 0);
+    };
+    imports.wbg.__wbg_finalize_7ee740fba804fefe = function() { return handleError(function (arg0, arg1) {
+        arg0.finalize(arg1);
+    }, arguments) };
+    imports.wbg.__wbg_reset_64daad59c50383d3 = function(arg0, arg1) {
+        const ret = arg0.reset(arg1);
+        return ret;
+    };
+    imports.wbg.__wbg_step_09504a247e0ba954 = function(arg0, arg1) {
+        const ret = arg0.step(arg1);
+        return ret;
+    };
+    imports.wbg.__wbg_columncount_da141db0617412dd = function(arg0, arg1) {
+        const ret = arg0.column_count(arg1);
+        return ret;
+    };
+    imports.wbg.__wbg_columnvalue_83d37aeaa7f4bef6 = function(arg0, arg1, arg2) {
+        const ret = arg0.column_value(arg1, arg2);
+        return ret;
+    };
+    imports.wbg.__wbindgen_link_42e73067c99cbdba = function(arg0) {
+        const ret = new URL('snippets/diesel-wasm-sqlite-36e85657e47f3be3/src/js/sqlite3-opfs-async-proxy.js', import.meta.url).toString();
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
+    imports.wbg.__wbg_heap8u_e5e9645d146c39a3 = function(arg0) {
+        const ret = arg0.heap8u();
+        return ret;
+    };
+    imports.wbg.__wbg_capi_74a1a04b4eb066db = function(arg0) {
+        const ret = arg0.capi;
+        return ret;
+    };
+    imports.wbg.__wbg_new_d2b35c9d7f4b1471 = function(arg0) {
+        const ret = new SQLite(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_version_7fb95c5a88d542ce = function(arg0) {
+        const ret = arg0.version();
+        return ret;
+    };
+    imports.wbg.__wbg_filename_9eb2d8c937e22432 = function(arg0, arg1, arg2, arg3, arg4) {
+        let deferred0_0;
+        let deferred0_1;
+        try {
+            deferred0_0 = arg3;
+            deferred0_1 = arg4;
+            const ret = arg1.filename(arg2, getStringFromWasm0(arg3, arg4));
+            const ptr2 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len2 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len2, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr2, true);
+        } finally {
+            wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+        }
+    };
+    imports.wbg.__wbg_errstr_5114edcda623dd5a = function(arg0, arg1, arg2) {
+        const ret = arg1.errstr(arg2);
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
+    imports.wbg.__wbg_errmsg_43ea55533a3ea740 = function(arg0, arg1, arg2) {
+        const ret = arg1.errmsg(arg2);
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
+    imports.wbg.__wbg_extendederrcode_2e0c706dd10fe107 = function(arg0, arg1) {
+        const ret = arg0.extended_errcode(arg1);
+        return ret;
+    };
+    imports.wbg.__wbg_valuedup_186941ef4d6d7d09 = function(arg0, arg1) {
+        const ret = arg0.value_dup(arg1 >>> 0);
+        return ret;
+    };
+    imports.wbg.__wbg_valueblob_80b0d28b673e9efc = function(arg0, arg1) {
+        const ret = arg0.value_blob(arg1 >>> 0);
+        return ret;
+    };
+    imports.wbg.__wbg_valuebytes_ae42a50aaa4db15e = function(arg0, arg1) {
+        const ret = arg0.value_bytes(arg1 >>> 0);
+        return ret;
+    };
+    imports.wbg.__wbg_valuefree_47295db839c6fbb4 = function(arg0, arg1) {
+        arg0.value_free(arg1 >>> 0);
+    };
+    imports.wbg.__wbg_valueint_b4d6710e3940d2d0 = function(arg0, arg1) {
+        const ret = arg0.value_int(arg1 >>> 0);
+        return ret;
+    };
+    imports.wbg.__wbg_valueint64_89f223f9f63833ee = function(arg0, arg1) {
+        const ret = arg0.value_int64(arg1 >>> 0);
+        return ret;
+    };
+    imports.wbg.__wbg_valuetext_503dfdd35d1a5d23 = function(arg0, arg1, arg2) {
+        const ret = arg1.value_text(arg2 >>> 0);
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
+    imports.wbg.__wbg_valuetype_10265d962173575d = function(arg0, arg1) {
+        const ret = arg0.value_type(arg1 >>> 0);
+        return ret;
+    };
+    imports.wbg.__wbg_open_630840f0e3bfa104 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+        const ret = arg0.open(getStringFromWasm0(arg1, arg2), arg3 === 0 ? undefined : arg4);
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_exec_891e7bcb242b8263 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
+        arg0.exec(arg1, getStringFromWasm0(arg2, arg3));
+    }, arguments) };
+    imports.wbg.__wbg_changes_449e8e7adde4811b = function(arg0, arg1) {
+        const ret = arg0.changes(arg1);
+        return ret;
+    };
+    imports.wbg.__wbg_close_f1e03beafae72a1f = function(arg0, arg1) {
+        const ret = arg0.close(arg1);
+        return ret;
+    };
+    imports.wbg.__wbg_columnname_ff3aa78d6aa3c952 = function(arg0, arg1, arg2, arg3) {
+        const ret = arg1.column_name(arg2, arg3);
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
+    imports.wbg.__wbg_registerdieselsqlfunctions_376c3851387d1a3a = function() { return handleError(function (arg0, arg1) {
+        arg0.register_diesel_sql_functions(arg1);
+    }, arguments) };
+    imports.wbg.__wbg_allocCString_42f27a0af479f779 = function(arg0, arg1, arg2) {
+        let deferred0_0;
+        let deferred0_1;
+        try {
+            deferred0_0 = arg1;
+            deferred0_1 = arg2;
+            const ret = arg0.allocCString(getStringFromWasm0(arg1, arg2));
+            return ret;
+        } finally {
+            wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+        }
+    };
+    imports.wbg.__wbg_SQLITENULL_00f5eb33b5b89690 = function(arg0) {
+        const ret = arg0.SQLITE_NULL;
+        return ret;
+    };
+    imports.wbg.__wbg_SQLITECONSTRAINTUNIQUE_1dea04a977c1e377 = function(arg0) {
+        const ret = arg0.SQLITE_CONSTRAINT_UNIQUE;
+        return ret;
+    };
+    imports.wbg.__wbg_SQLITEROW_a21779e78155c8ad = function(arg0) {
+        const ret = arg0.SQLITE_ROW;
+        return ret;
+    };
+    imports.wbg.__wbg_SQLITEOK_2d09a4e691645e98 = function(arg0) {
+        const ret = arg0.SQLITE_OK;
+        return ret;
+    };
+    imports.wbg.__wbg_SQLITEFLOAT_e0da134da12d25d0 = function(arg0) {
+        const ret = arg0.SQLITE_FLOAT;
+        return ret;
+    };
+    imports.wbg.__wbg_SQLITEINTEGER_9031dce8e01c166c = function(arg0) {
+        const ret = arg0.SQLITE_INTEGER;
+        return ret;
+    };
+    imports.wbg.__wbg_SQLITEDONE_fbfe18ce23a3b6da = function(arg0) {
+        const ret = arg0.SQLITE_DONE;
+        return ret;
+    };
+    imports.wbg.__wbg_SQLITEBLOB_394b61ff6fc173a6 = function(arg0) {
+        const ret = arg0.SQLITE_BLOB;
+        return ret;
+    };
+    imports.wbg.__wbg_SQLITECONSTRAINTPRIMARYKEY_3e2ad26d848575a2 = function(arg0) {
+        const ret = arg0.SQLITE_CONSTRAINT_PRIMARYKEY;
+        return ret;
+    };
+    imports.wbg.__wbg_SQLITESTATIC_b98299c993e94d35 = function(arg0) {
+        const ret = arg0.SQLITE_STATIC;
+        return ret;
+    };
+    imports.wbg.__wbg_SQLITECONSTRAINTCHECK_7b54e6702b2e57ba = function(arg0) {
+        const ret = arg0.SQLITE_CONSTRAINT_CHECK;
+        return ret;
+    };
+    imports.wbg.__wbg_SQLITECONSTRAINTFOREIGNKEY_741a343b3482effc = function(arg0) {
+        const ret = arg0.SQLITE_CONSTRAINT_FOREIGNKEY;
+        return ret;
+    };
+    imports.wbg.__wbg_SQLITECONSTRAINTNOTNULL_0f87885933517ad3 = function(arg0) {
+        const ret = arg0.SQLITE_CONSTRAINT_NOTNULL;
+        return ret;
+    };
+    imports.wbg.__wbg_SQLITEPREPAREPERSISTENT_d81d553ffa5c038c = function(arg0) {
+        const ret = arg0.SQLITE_PREPARE_PERSISTENT;
+        return ret;
+    };
+    imports.wbg.__wbg_SQLITETEXT_727e78d48f532f23 = function(arg0) {
+        const ret = arg0.SQLITE_TEXT;
+        return ret;
+    };
+    imports.wbg.__wbg_SQLITEOPENREADWRITE_a83b4615e4d0f3ab = function(arg0) {
+        const ret = arg0.SQLITE_OPEN_READWRITE;
+        return ret;
+    };
+    imports.wbg.__wbg_SQLITEOPENCREATE_9de5b9e000c4b114 = function(arg0) {
+        const ret = arg0.SQLITE_OPEN_CREATE;
+        return ret;
+    };
+    imports.wbg.__wbg_SQLITEOPENURI_553652ff6391f5f3 = function(arg0) {
+        const ret = arg0.SQLITE_OPEN_URI;
+        return ret;
+    };
+    imports.wbg.__wbindgen_jsval_loose_eq = function(arg0, arg1) {
+        const ret = arg0 == arg1;
+        return ret;
+    };
+    imports.wbg.__wbindgen_boolean_get = function(arg0) {
+        const v = arg0;
+        const ret = typeof(v) === 'boolean' ? (v ? 1 : 0) : 2;
+        return ret;
+    };
+    imports.wbg.__wbg_String_b9412f8799faab3e = function(arg0, arg1) {
+        const ret = String(arg1);
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
+    imports.wbg.__wbg_getwithrefkey_edc2c8960f0f1191 = function(arg0, arg1) {
+        const ret = arg0[arg1];
+        return ret;
+    };
+    imports.wbg.__wbg_set_f975102236d3c502 = function(arg0, arg1, arg2) {
+        arg0[arg1] = arg2;
+    };
+    imports.wbg.__wbg_log_491a5231a6310c13 = function(arg0, arg1) {
+        console.log(getStringFromWasm0(arg0, arg1));
+    };
+    imports.wbg.__wbg_self_fa85e99720202dd4 = function(arg0) {
+        const ret = arg0.self;
+        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    };
+    imports.wbg.__wbg_constructor_41b3ab5898fdf330 = function(arg0) {
+        const ret = arg0.constructor;
+        return ret;
+    };
+    imports.wbg.__wbg_name_963614637094aad8 = function(arg0, arg1) {
+        const ret = arg1.name;
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
+    imports.wbg.__wbg_Deno_a6da1a839b626101 = function(arg0) {
+        const ret = arg0.Deno;
+        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    };
+    imports.wbg.__wbg_stack_9dc96582e4822571 = function(arg0, arg1) {
+        const ret = arg1.stack;
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
+    imports.wbg.__wbg_String_c3b43c66a02c6ca8 = function(arg0, arg1) {
+        const ret = String(arg1);
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
+    imports.wbg.__wbg_settextcontent_ea3dfc9f7afe7f06 = function(arg0, arg1, arg2) {
+        arg0.textContent = getStringFromWasm0(arg1, arg2);
+    };
+    imports.wbg.__wbg_static_accessor_DOCUMENT_a5bca7f6e8b241cf = function() {
+        const ret = document;
+        return ret;
+    };
+    imports.wbg.__wbg_getElementById_605f2ff21c779a7e = function(arg0, arg1, arg2) {
+        const ret = arg0.getElementById(getStringFromWasm0(arg1, arg2));
+        return ret;
+    };
+    imports.wbg.__wbg_textcontent_6e4b01ce1801d4e6 = function(arg0, arg1) {
+        const ret = arg1.textContent;
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
+    imports.wbg.__wbg_stack_e7498cc287ef84ec = function(arg0) {
+        const ret = arg0.stack;
+        return ret;
+    };
+    imports.wbg.__wbg_wbgtestoutputwriteln_1db413808589922e = typeof __wbg_test_output_writeln == 'function' ? __wbg_test_output_writeln : notDefined('__wbg_test_output_writeln');
+    imports.wbg.__wbg_stack_660f03fff6667bdc = function(arg0) {
+        const ret = arg0.stack;
+        return ret;
+    };
+    imports.wbg.__wbg_new_abda76e883ba8a5f = function() {
+        const ret = new Error();
+        return ret;
+    };
+    imports.wbg.__wbg_stack_658279fe44541cf6 = function(arg0, arg1) {
+        const ret = arg1.stack;
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
+    imports.wbg.__wbg_error_f851667af71bcfc6 = function(arg0, arg1) {
+        let deferred0_0;
+        let deferred0_1;
+        try {
+            deferred0_0 = arg0;
+            deferred0_1 = arg1;
+            console.error(getStringFromWasm0(arg0, arg1));
+        } finally {
+            wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+        }
+    };
+    imports.wbg.__wbg_queueMicrotask_848aa4969108a57e = function(arg0) {
+        const ret = arg0.queueMicrotask;
+        return ret;
+    };
+    imports.wbg.__wbindgen_is_function = function(arg0) {
+        const ret = typeof(arg0) === 'function';
+        return ret;
+    };
+    imports.wbg.__wbg_queueMicrotask_c5419c06eab41e73 = typeof queueMicrotask == 'function' ? queueMicrotask : notDefined('queueMicrotask');
+    imports.wbg.__wbg_log_f740dc2253ea759b = typeof console.log == 'function' ? console.log : notDefined('console.log');
+    imports.wbg.__wbg_fetch_1fdc4448ed9eec00 = function(arg0, arg1) {
+        const ret = arg0.fetch(arg1);
+        return ret;
+    };
+    imports.wbg.__wbg_close_cfd08d9cf9f36856 = function() { return handleError(function (arg0) {
+        arg0.close();
+    }, arguments) };
+    imports.wbg.__wbg_enqueue_e693a6fb4f3261c1 = function() { return handleError(function (arg0, arg1) {
+        arg0.enqueue(arg1);
+    }, arguments) };
+    imports.wbg.__wbg_instanceof_Response_3c0e210a57ff751d = function(arg0) {
+        let result;
+        try {
+            result = arg0 instanceof Response;
+        } catch (_) {
+            result = false;
+        }
+        const ret = result;
+        return ret;
+    };
+    imports.wbg.__wbg_url_58af972663531d16 = function(arg0, arg1) {
+        const ret = arg1.url;
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
+    imports.wbg.__wbg_status_5f4e900d22140a18 = function(arg0) {
+        const ret = arg0.status;
+        return ret;
+    };
+    imports.wbg.__wbg_headers_1b9bf90c73fae600 = function(arg0) {
+        const ret = arg0.headers;
+        return ret;
+    };
+    imports.wbg.__wbg_arrayBuffer_144729e09879650e = function() { return handleError(function (arg0) {
+        const ret = arg0.arrayBuffer();
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_byobRequest_86ac467c94924d3c = function(arg0) {
+        const ret = arg0.byobRequest;
+        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    };
+    imports.wbg.__wbg_close_7cda9dd901230214 = function() { return handleError(function (arg0) {
+        arg0.close();
+    }, arguments) };
+    imports.wbg.__wbg_signal_9acfcec9e7dffc22 = function(arg0) {
+        const ret = arg0.signal;
+        return ret;
+    };
+    imports.wbg.__wbg_new_75169ae5a9683c55 = function() { return handleError(function () {
+        const ret = new AbortController();
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_abort_c57daab47a6c1215 = function(arg0) {
+        arg0.abort();
+    };
+    imports.wbg.__wbg_view_de0e81c5c00d2129 = function(arg0) {
+        const ret = arg0.view;
+        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    };
+    imports.wbg.__wbg_respond_ffb6928cd9b79c32 = function() { return handleError(function (arg0, arg1) {
+        arg0.respond(arg1 >>> 0);
+    }, arguments) };
+    imports.wbg.__wbg_newwithstrandinit_4b92c89af0a8e383 = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = new Request(getStringFromWasm0(arg0, arg1), arg2);
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_setbody_aa8b691bec428bf4 = function(arg0, arg1) {
+        arg0.body = arg1;
+    };
+    imports.wbg.__wbg_setcredentials_a4e661320cdb9738 = function(arg0, arg1) {
+        arg0.credentials = __wbindgen_enum_RequestCredentials[arg1];
+    };
+    imports.wbg.__wbg_setheaders_f5205d36e423a544 = function(arg0, arg1) {
+        arg0.headers = arg1;
+    };
+    imports.wbg.__wbg_setmethod_ce2da76000b02f6a = function(arg0, arg1, arg2) {
+        arg0.method = getStringFromWasm0(arg1, arg2);
+    };
+    imports.wbg.__wbg_setmode_4919fd636102c586 = function(arg0, arg1) {
+        arg0.mode = __wbindgen_enum_RequestMode[arg1];
+    };
+    imports.wbg.__wbg_setsignal_812ccb8269a7fd90 = function(arg0, arg1) {
+        arg0.signal = arg1;
+    };
+    imports.wbg.__wbg_new_a9ae04a5200606a5 = function() { return handleError(function () {
+        const ret = new Headers();
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_append_8b3e7f74a47ea7d5 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+        arg0.append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+    }, arguments) };
+    imports.wbg.__wbg_crypto_1d1f22824a6a080c = function(arg0) {
+        const ret = arg0.crypto;
+        return ret;
+    };
+    imports.wbg.__wbg_process_4a72847cc503995b = function(arg0) {
+        const ret = arg0.process;
+        return ret;
+    };
+    imports.wbg.__wbg_versions_f686565e586dd935 = function(arg0) {
+        const ret = arg0.versions;
+        return ret;
+    };
+    imports.wbg.__wbg_node_104a2ff8d6ea03a2 = function(arg0) {
+        const ret = arg0.node;
+        return ret;
+    };
+    imports.wbg.__wbindgen_is_string = function(arg0) {
+        const ret = typeof(arg0) === 'string';
+        return ret;
+    };
+    imports.wbg.__wbg_require_cca90b1a94a0255b = function() { return handleError(function () {
+        const ret = module.require;
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_msCrypto_eb05e62b530a1508 = function(arg0) {
+        const ret = arg0.msCrypto;
+        return ret;
+    };
+    imports.wbg.__wbg_getRandomValues_3aa56aa6edec874c = function() { return handleError(function (arg0, arg1) {
+        arg0.getRandomValues(arg1);
+    }, arguments) };
+    imports.wbg.__wbg_randomFillSync_5c9c955aa56b6049 = function() { return handleError(function (arg0, arg1) {
+        arg0.randomFillSync(arg1);
+    }, arguments) };
+    imports.wbg.__wbg_get_5419cf6b954aa11d = function(arg0, arg1) {
+        const ret = arg0[arg1 >>> 0];
+        return ret;
+    };
+    imports.wbg.__wbg_length_f217bbbf7e8e4df4 = function(arg0) {
+        const ret = arg0.length;
+        return ret;
+    };
+    imports.wbg.__wbg_new_034f913e7636e987 = function() {
+        const ret = new Array();
+        return ret;
+    };
+    imports.wbg.__wbg_newnoargs_1ede4bf2ebbaaf43 = function(arg0, arg1) {
+        const ret = new Function(getStringFromWasm0(arg0, arg1));
+        return ret;
+    };
+    imports.wbg.__wbg_new_7a87a0376e40533b = function() {
+        const ret = new Map();
+        return ret;
+    };
+    imports.wbg.__wbg_next_13b477da1eaa3897 = function(arg0) {
+        const ret = arg0.next;
+        return ret;
+    };
+    imports.wbg.__wbg_next_b06e115d1b01e10b = function() { return handleError(function (arg0) {
+        const ret = arg0.next();
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_done_983b5ffcaec8c583 = function(arg0) {
+        const ret = arg0.done;
+        return ret;
+    };
+    imports.wbg.__wbg_value_2ab8a198c834c26a = function(arg0) {
+        const ret = arg0.value;
+        return ret;
+    };
+    imports.wbg.__wbg_iterator_695d699a44d6234c = function() {
+        const ret = Symbol.iterator;
+        return ret;
+    };
+    imports.wbg.__wbg_get_ef828680c64da212 = function() { return handleError(function (arg0, arg1) {
+        const ret = Reflect.get(arg0, arg1);
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_call_a9ef466721e824f2 = function() { return handleError(function (arg0, arg1) {
+        const ret = arg0.call(arg1);
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_new_e69b5f66fda8f13c = function() {
+        const ret = new Object();
+        return ret;
+    };
+    imports.wbg.__wbg_self_bf91bf94d9e04084 = function() { return handleError(function () {
+        const ret = self.self;
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_window_52dd9f07d03fd5f8 = function() { return handleError(function () {
+        const ret = window.window;
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_globalThis_05c129bf37fcf1be = function() { return handleError(function () {
+        const ret = globalThis.globalThis;
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_global_3eca19bb09e9c484 = function() { return handleError(function () {
+        const ret = global.global;
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_set_425e70f7c64ac962 = function(arg0, arg1, arg2) {
+        arg0[arg1 >>> 0] = arg2;
+    };
+    imports.wbg.__wbg_forEach_678f416cbff9306a = function(arg0, arg1, arg2) {
+        try {
+            var state0 = {a: arg1, b: arg2};
+            var cb0 = (arg0, arg1, arg2) => {
+                const a = state0.a;
+                state0.a = 0;
+                try {
+                    return __wbg_adapter_523(a, state0.b, arg0, arg1, arg2);
+                } finally {
+                    state0.a = a;
+                }
+            };
+            arg0.forEach(cb0);
+        } finally {
+            state0.a = state0.b = 0;
+        }
+    };
+    imports.wbg.__wbg_push_36cf4d81d7da33d1 = function(arg0, arg1) {
+        const ret = arg0.push(arg1);
+        return ret;
+    };
+    imports.wbg.__wbg_instanceof_ArrayBuffer_74945570b4a62ec7 = function(arg0) {
+        let result;
+        try {
+            result = arg0 instanceof ArrayBuffer;
+        } catch (_) {
+            result = false;
+        }
+        const ret = result;
+        return ret;
+    };
+    imports.wbg.__wbg_new_70a2f23d1565c04c = function(arg0, arg1) {
+        const ret = new Error(getStringFromWasm0(arg0, arg1));
+        return ret;
+    };
+    imports.wbg.__wbg_message_00eebca8fa4dd7db = function(arg0) {
+        const ret = arg0.message;
+        return ret;
+    };
+    imports.wbg.__wbg_name_aa32a0ae51232604 = function(arg0) {
+        const ret = arg0.name;
+        return ret;
+    };
+    imports.wbg.__wbg_call_3bfa248576352471 = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = arg0.call(arg1, arg2);
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_set_277a63e77c89279f = function(arg0, arg1, arg2) {
+        const ret = arg0.set(arg1, arg2);
+        return ret;
+    };
+    imports.wbg.__wbg_isSafeInteger_b9dff570f01a9100 = function(arg0) {
+        const ret = Number.isSafeInteger(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_now_70af4fe37a792251 = function() {
+        const ret = Date.now();
+        return ret;
+    };
+    imports.wbg.__wbg_entries_c02034de337d3ee2 = function(arg0) {
+        const ret = Object.entries(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_new_1073970097e5a420 = function(arg0, arg1) {
+        try {
+            var state0 = {a: arg0, b: arg1};
+            var cb0 = (arg0, arg1) => {
+                const a = state0.a;
+                state0.a = 0;
+                try {
+                    return __wbg_adapter_566(a, state0.b, arg0, arg1);
+                } finally {
+                    state0.a = a;
+                }
+            };
+            const ret = new Promise(cb0);
+            return ret;
+        } finally {
+            state0.a = state0.b = 0;
+        }
+    };
+    imports.wbg.__wbg_resolve_0aad7c1484731c99 = function(arg0) {
+        const ret = Promise.resolve(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_then_748f75edfb032440 = function(arg0, arg1) {
+        const ret = arg0.then(arg1);
+        return ret;
+    };
+    imports.wbg.__wbg_then_4866a7d9f55d8f3e = function(arg0, arg1, arg2) {
+        const ret = arg0.then(arg1, arg2);
+        return ret;
+    };
+    imports.wbg.__wbg_buffer_ccaed51a635d8a2d = function(arg0) {
+        const ret = arg0.buffer;
+        return ret;
+    };
+    imports.wbg.__wbg_newwithbyteoffsetandlength_7e3eb787208af730 = function(arg0, arg1, arg2) {
+        const ret = new Uint8Array(arg0, arg1 >>> 0, arg2 >>> 0);
+        return ret;
+    };
+    imports.wbg.__wbg_new_fec2611eb9180f95 = function(arg0) {
+        const ret = new Uint8Array(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_set_ec2fcf81bc573fd9 = function(arg0, arg1, arg2) {
+        arg0.set(arg1, arg2 >>> 0);
+    };
+    imports.wbg.__wbg_length_9254c4bd3b9f23c4 = function(arg0) {
+        const ret = arg0.length;
+        return ret;
+    };
+    imports.wbg.__wbg_instanceof_Uint8Array_df0761410414ef36 = function(arg0) {
+        let result;
+        try {
+            result = arg0 instanceof Uint8Array;
+        } catch (_) {
+            result = false;
+        }
+        const ret = result;
+        return ret;
+    };
+    imports.wbg.__wbg_newwithlength_76462a666eca145f = function(arg0) {
+        const ret = new Uint8Array(arg0 >>> 0);
+        return ret;
+    };
+    imports.wbg.__wbg_buffer_95102df5554646dc = function(arg0) {
+        const ret = arg0.buffer;
+        return ret;
+    };
+    imports.wbg.__wbg_subarray_975a06f9dbd16995 = function(arg0, arg1, arg2) {
+        const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
+        return ret;
+    };
+    imports.wbg.__wbg_byteLength_5d623ba3d92a3a9c = function(arg0) {
+        const ret = arg0.byteLength;
+        return ret;
+    };
+    imports.wbg.__wbg_byteOffset_ec0928143c619cd7 = function(arg0) {
+        const ret = arg0.byteOffset;
+        return ret;
+    };
+    imports.wbg.__wbg_has_bd717f25f195f23d = function() { return handleError(function (arg0, arg1) {
+        const ret = Reflect.has(arg0, arg1);
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_new_fddd2773b9888ac9 = function() { return handleError(function (arg0) {
+        const ret = new WebAssembly.Memory(arg0);
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_stringify_eead5648c09faaf8 = function() { return handleError(function (arg0) {
+        const ret = JSON.stringify(arg0);
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {
+        const ret = debugString(arg1);
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
+    imports.wbg.__wbindgen_throw = function(arg0, arg1) {
+        throw new Error(getStringFromWasm0(arg0, arg1));
+    };
+    imports.wbg.__wbindgen_memory = function() {
+        const ret = wasm.memory;
+        return ret;
+    };
+    imports.wbg.__wbindgen_closure_wrapper7553 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 1618, __wbg_adapter_44);
+        return ret;
+    };
+    imports.wbg.__wbindgen_closure_wrapper11082 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 2263, __wbg_adapter_47);
+        return ret;
+    };
+    imports.wbg.__wbindgen_init_externref_table = function() {
+        const table = wasm.__wbindgen_export_2;
+        const offset = table.grow(4);
+        table.set(0, undefined);
+        table.set(offset + 0, undefined);
+        table.set(offset + 1, null);
+        table.set(offset + 2, true);
+        table.set(offset + 3, false);
+        ;
+    };
+
+    return imports;
+}
+
+function __wbg_init_memory(imports, memory) {
+
+}
+
+function __wbg_finalize_init(instance, module) {
+    wasm = instance.exports;
+    __wbg_init.__wbindgen_wasm_module = module;
+    cachedDataViewMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
+
+
+    wasm.__wbindgen_start();
+    return wasm;
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (typeof module !== 'undefined') {
+        if (Object.getPrototypeOf(module) === Object.prototype) {
+            ({module} = module)
+        } else {
+            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+        }
+    }
+
+    const imports = __wbg_get_imports();
+
+    __wbg_init_memory(imports);
+
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+
+    const instance = new WebAssembly.Instance(module, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(module_or_path) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (typeof module_or_path !== 'undefined') {
+        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+            ({module_or_path} = module_or_path)
+        } else {
+            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+        }
+    }
+
+    if (typeof module_or_path === 'undefined') {
+        module_or_path = new URL('bindings_wasm_bg.wasm', import.meta.url);
+    }
+    const imports = __wbg_get_imports();
+
+    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+        module_or_path = fetch(module_or_path);
+    }
+
+    __wbg_init_memory(imports);
+
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+export { initSync };
+export default __wbg_init;