@laboverwire/stitch-wasm 0.1.0

package/stitch_wasm_bg.js

@@ -0,0 +1,3536 @@
+export class ConnectOptions {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ConnectOptionsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_connectoptions_free(ptr, 0);
+    }
+    /**
+     * @param {string} url
+     */
+    addBackupUrl(url) {
+        const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.connectoptions_addBackupUrl(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {string} key
+     * @param {string} value
+     */
+    addUserProperty(key, value) {
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.connectoptions_addUserProperty(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+    }
+    /**
+     * @returns {string | undefined}
+     */
+    get authenticationMethod() {
+        const ret = wasm.connectoptions_authenticationMethod(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;
+    }
+    /**
+     * @returns {boolean}
+     */
+    get cleanStart() {
+        const ret = wasm.connectoptions_cleanStart(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    clearBackupUrls() {
+        wasm.connectoptions_clearBackupUrls(this.__wbg_ptr);
+    }
+    clearUserProperties() {
+        wasm.connectoptions_clearUserProperties(this.__wbg_ptr);
+    }
+    clearWill() {
+        wasm.connectoptions_clearWill(this.__wbg_ptr);
+    }
+    /**
+     * @returns {string[]}
+     */
+    getBackupUrls() {
+        const ret = wasm.connectoptions_getBackupUrls(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @returns {number}
+     */
+    get keepAlive() {
+        const ret = wasm.connectoptions_keepAlive(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number | undefined}
+     */
+    get maximumPacketSize() {
+        const ret = wasm.connectoptions_maximumPacketSize(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
+    constructor() {
+        const ret = wasm.connectoptions_new();
+        this.__wbg_ptr = ret;
+        ConnectOptionsFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {number}
+     */
+    get protocolVersion() {
+        const ret = wasm.connectoptions_protocolVersion(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number | undefined}
+     */
+    get receiveMaximum() {
+        const ret = wasm.connectoptions_receiveMaximum(this.__wbg_ptr);
+        return ret === 0xFFFFFF ? undefined : ret;
+    }
+    /**
+     * @returns {boolean | undefined}
+     */
+    get requestProblemInformation() {
+        const ret = wasm.connectoptions_requestProblemInformation(this.__wbg_ptr);
+        return ret === 0xFFFFFF ? undefined : ret !== 0;
+    }
+    /**
+     * @returns {boolean | undefined}
+     */
+    get requestResponseInformation() {
+        const ret = wasm.connectoptions_requestResponseInformation(this.__wbg_ptr);
+        return ret === 0xFFFFFF ? undefined : ret !== 0;
+    }
+    /**
+     * @returns {number | undefined}
+     */
+    get sessionExpiryInterval() {
+        const ret = wasm.connectoptions_sessionExpiryInterval(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
+    /**
+     * @param {WillMessage} will
+     */
+    setWill(will) {
+        _assertClass(will, WillMessage);
+        var ptr0 = will.__destroy_into_raw();
+        wasm.connectoptions_setWill(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * @param {Uint8Array} value
+     */
+    set authenticationData(value) {
+        const ptr0 = passArray8ToWasm0(value, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.connectoptions_set_authenticationData(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {string | null} [value]
+     */
+    set authenticationMethod(value) {
+        var ptr0 = isLikeNone(value) ? 0 : passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.connectoptions_set_authenticationMethod(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {boolean} value
+     */
+    set cleanStart(value) {
+        wasm.connectoptions_set_cleanStart(this.__wbg_ptr, value);
+    }
+    /**
+     * @param {number} value
+     */
+    set keepAlive(value) {
+        wasm.connectoptions_set_keepAlive(this.__wbg_ptr, value);
+    }
+    /**
+     * @param {number | null} [value]
+     */
+    set maximumPacketSize(value) {
+        wasm.connectoptions_set_maximumPacketSize(this.__wbg_ptr, isLikeNone(value) ? Number.MAX_SAFE_INTEGER : (value) >>> 0);
+    }
+    /**
+     * @param {Uint8Array} value
+     */
+    set password(value) {
+        const ptr0 = passArray8ToWasm0(value, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.connectoptions_set_password(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {number} value
+     */
+    set protocolVersion(value) {
+        wasm.connectoptions_set_protocolVersion(this.__wbg_ptr, value);
+    }
+    /**
+     * @param {number | null} [value]
+     */
+    set receiveMaximum(value) {
+        wasm.connectoptions_set_receiveMaximum(this.__wbg_ptr, isLikeNone(value) ? 0xFFFFFF : value);
+    }
+    /**
+     * @param {boolean | null} [value]
+     */
+    set requestProblemInformation(value) {
+        wasm.connectoptions_set_requestProblemInformation(this.__wbg_ptr, isLikeNone(value) ? 0xFFFFFF : value ? 1 : 0);
+    }
+    /**
+     * @param {boolean | null} [value]
+     */
+    set requestResponseInformation(value) {
+        wasm.connectoptions_set_requestResponseInformation(this.__wbg_ptr, isLikeNone(value) ? 0xFFFFFF : value ? 1 : 0);
+    }
+    /**
+     * @param {number | null} [value]
+     */
+    set sessionExpiryInterval(value) {
+        wasm.connectoptions_set_sessionExpiryInterval(this.__wbg_ptr, isLikeNone(value) ? Number.MAX_SAFE_INTEGER : (value) >>> 0);
+    }
+    /**
+     * @param {number | null} [value]
+     */
+    set topicAliasMaximum(value) {
+        wasm.connectoptions_set_topicAliasMaximum(this.__wbg_ptr, isLikeNone(value) ? 0xFFFFFF : value);
+    }
+    /**
+     * @param {string | null} [value]
+     */
+    set username(value) {
+        var ptr0 = isLikeNone(value) ? 0 : passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.connectoptions_set_username(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @returns {number | undefined}
+     */
+    get topicAliasMaximum() {
+        const ret = wasm.connectoptions_topicAliasMaximum(this.__wbg_ptr);
+        return ret === 0xFFFFFF ? undefined : ret;
+    }
+    /**
+     * @returns {string | undefined}
+     */
+    get username() {
+        const ret = wasm.connectoptions_username(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;
+    }
+}
+if (Symbol.dispose) ConnectOptions.prototype[Symbol.dispose] = ConnectOptions.prototype.free;
+
+export class Cursor {
+    static __wrap(ptr) {
+        const obj = Object.create(Cursor.prototype);
+        obj.__wbg_ptr = ptr;
+        CursorFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CursorFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_cursor_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    count() {
+        const ret = wasm.cursor_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {boolean}
+     */
+    hasMore() {
+        const ret = wasm.cursor_hasMore(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Returns up to N items from the cursor as an array.
+     *
+     * # Errors
+     * Returns an error if serialization fails.
+     * @param {number} size
+     * @returns {any}
+     */
+    nextBatch(size) {
+        const ret = wasm.cursor_nextBatch(this.__wbg_ptr, size);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Returns the next item from the cursor.
+     *
+     * # Errors
+     * Returns an error if serialization fails.
+     * @returns {any}
+     */
+    nextItem() {
+        const ret = wasm.cursor_nextItem(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {number}
+     */
+    position() {
+        const ret = wasm.cursor_position(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    reset() {
+        wasm.cursor_reset(this.__wbg_ptr);
+    }
+}
+if (Symbol.dispose) Cursor.prototype[Symbol.dispose] = Cursor.prototype.free;
+
+export class Database {
+    static __wrap(ptr) {
+        const obj = Object.create(Database.prototype);
+        obj.__wbg_ptr = ptr;
+        DatabaseFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DatabaseFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_database_free(ptr, 0);
+    }
+    /**
+     * Adds a foreign key constraint.
+     *
+     * # Errors
+     * This function does not currently return errors but the signature allows for future validation.
+     * @param {string} source_entity
+     * @param {string} source_field
+     * @param {string} target_entity
+     * @param {string} target_field
+     * @param {string} on_delete
+     */
+    addForeignKey(source_entity, source_field, target_entity, target_field, on_delete) {
+        const ptr0 = passStringToWasm0(source_entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(source_field, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(target_entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(target_field, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ptr4 = passStringToWasm0(on_delete, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len4 = WASM_VECTOR_LEN;
+        const ret = wasm.database_addForeignKey(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Adds a foreign key constraint and persists to storage.
+     *
+     * # Errors
+     * Returns an error if storage fails.
+     * @param {string} source_entity
+     * @param {string} source_field
+     * @param {string} target_entity
+     * @param {string} target_field
+     * @param {string} on_delete
+     * @returns {Promise<void>}
+     */
+    addForeignKeyAsync(source_entity, source_field, target_entity, target_field, on_delete) {
+        const ptr0 = passStringToWasm0(source_entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(source_field, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(target_entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(target_field, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ptr4 = passStringToWasm0(on_delete, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len4 = WASM_VECTOR_LEN;
+        const ret = wasm.database_addForeignKeyAsync(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4);
+        return ret;
+    }
+    /**
+     * Adds an index on the specified fields and backfills from existing records (sync, memory only).
+     *
+     * # Errors
+     * Returns an error if the backend is not memory-based or backfill fails.
+     * @param {string} entity
+     * @param {string[]} fields
+     */
+    addIndex(entity, fields) {
+        const ptr0 = passStringToWasm0(entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayJsValueToWasm0(fields, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.database_addIndex(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Adds an index on the specified fields and backfills from existing records (async).
+     *
+     * # Errors
+     * Returns an error if the storage operation fails during backfill.
+     * @param {string} entity
+     * @param {string[]} fields
+     * @returns {Promise<void>}
+     */
+    addIndexAsync(entity, fields) {
+        const ptr0 = passStringToWasm0(entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayJsValueToWasm0(fields, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.database_addIndexAsync(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        return ret;
+    }
+    /**
+     * Adds a NOT NULL constraint on the specified field.
+     *
+     * # Errors
+     * This function does not currently return errors but the signature allows for future validation.
+     * @param {string} entity
+     * @param {string} field
+     */
+    addNotNull(entity, field) {
+        const ptr0 = passStringToWasm0(entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(field, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.database_addNotNull(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Adds a NOT NULL constraint and persists to storage.
+     *
+     * # Errors
+     * Returns an error if storage fails.
+     * @param {string} entity
+     * @param {string} field
+     * @returns {Promise<void>}
+     */
+    addNotNullAsync(entity, field) {
+        const ptr0 = passStringToWasm0(entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(field, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.database_addNotNullAsync(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        return ret;
+    }
+    /**
+     * Adds a relationship definition for eager loading.
+     *
+     * # Errors
+     * This function does not currently return errors but the signature allows for future validation.
+     * @param {string} source_entity
+     * @param {string} field
+     * @param {string} target_entity
+     */
+    addRelationship(source_entity, field, target_entity) {
+        const ptr0 = passStringToWasm0(source_entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(field, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(target_entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.database_addRelationship(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Adds a relationship definition and persists to storage.
+     *
+     * # Errors
+     * Returns an error if storage fails.
+     * @param {string} source_entity
+     * @param {string} field
+     * @param {string} target_entity
+     * @returns {Promise<void>}
+     */
+    addRelationshipAsync(source_entity, field, target_entity) {
+        const ptr0 = passStringToWasm0(source_entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(field, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(target_entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.database_addRelationshipAsync(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+        return ret;
+    }
+    /**
+     * Adds a schema definition for an entity (sync, memory backend only).
+     *
+     * # Errors
+     * Returns an error if the schema definition is invalid.
+     * @param {string} entity
+     * @param {any} schema_js
+     */
+    addSchema(entity, schema_js) {
+        const ptr0 = passStringToWasm0(entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.database_addSchema(this.__wbg_ptr, ptr0, len0, schema_js);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Adds a schema definition for an entity and persists to storage.
+     *
+     * # Errors
+     * Returns an error if the schema definition is invalid or storage fails.
+     * @param {string} entity
+     * @param {any} schema_js
+     * @returns {Promise<void>}
+     */
+    addSchemaAsync(entity, schema_js) {
+        const ptr0 = passStringToWasm0(entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.database_addSchemaAsync(this.__wbg_ptr, ptr0, len0, schema_js);
+        return ret;
+    }
+    /**
+     * Adds a unique constraint on the specified fields.
+     *
+     * # Errors
+     * This function does not currently return errors but the signature allows for future validation.
+     * @param {string} entity
+     * @param {string[]} fields
+     */
+    addUniqueConstraint(entity, fields) {
+        const ptr0 = passStringToWasm0(entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayJsValueToWasm0(fields, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.database_addUniqueConstraint(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Adds a unique constraint and persists to storage.
+     *
+     * # Errors
+     * Returns an error if storage fails.
+     * @param {string} entity
+     * @param {string[]} fields
+     * @returns {Promise<void>}
+     */
+    addUniqueConstraintAsync(entity, fields) {
+        const ptr0 = passStringToWasm0(entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayJsValueToWasm0(fields, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.database_addUniqueConstraintAsync(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        return ret;
+    }
+    /**
+     * Counts records matching optional filters, using indexes when available.
+     *
+     * # Errors
+     * Returns an error if options are invalid or the storage operation fails.
+     * @param {string} entity
+     * @param {any} options
+     * @returns {Promise<number>}
+     */
+    count(entity, options) {
+        const ptr0 = passStringToWasm0(entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.database_count(this.__wbg_ptr, ptr0, len0, options);
+        return ret;
+    }
+    /**
+     * # Errors
+     * Returns an error if options are invalid or the backend is not memory-based.
+     * @param {string} entity
+     * @param {any} options
+     * @returns {number}
+     */
+    countSync(entity, options) {
+        const ptr0 = passStringToWasm0(entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.database_countSync(this.__wbg_ptr, ptr0, len0, options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * Creates a new record in the specified entity.
+     *
+     * # Errors
+     * Returns an error if validation fails or the storage operation fails.
+     * @param {string} entity
+     * @param {any} data
+     * @returns {Promise<any>}
+     */
+    create(entity, data) {
+        const ptr0 = passStringToWasm0(entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.database_create(this.__wbg_ptr, ptr0, len0, data);
+        return ret;
+    }
+    /**
+     * # Errors
+     * Returns an error if validation fails or the backend is not memory-based.
+     * @param {string} entity
+     * @param {any} data
+     * @returns {any}
+     */
+    createSync(entity, data) {
+        const ptr0 = passStringToWasm0(entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.database_createSync(this.__wbg_ptr, ptr0, len0, data);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Creates a cursor for streaming iteration over records.
+     *
+     * # Errors
+     * Returns an error if options are invalid or the storage operation fails.
+     * @param {string} entity
+     * @param {any} options
+     * @returns {Promise<Cursor>}
+     */
+    cursor(entity, options) {
+        const ptr0 = passStringToWasm0(entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.database_cursor(this.__wbg_ptr, ptr0, len0, options);
+        return ret;
+    }
+    /**
+     * Deletes a record by entity and ID.
+     *
+     * # Errors
+     * Returns an error if the record is not found or foreign key constraints prevent deletion.
+     * @param {string} entity
+     * @param {string} id
+     * @returns {Promise<void>}
+     */
+    delete(entity, id) {
+        const ptr0 = passStringToWasm0(entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.database_delete(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        return ret;
+    }
+    /**
+     * # Errors
+     * Returns an error if the record is not found, foreign key constraints prevent deletion, or the backend is not memory-based.
+     * @param {string} entity
+     * @param {string} id
+     */
+    deleteSync(entity, id) {
+        const ptr0 = passStringToWasm0(entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.database_deleteSync(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Executes a database operation based on an MQTT-style topic.
+     *
+     * # Errors
+     * Returns an error if the topic is invalid or the operation fails.
+     * @param {string} topic
+     * @param {any} payload
+     * @returns {Promise<any>}
+     */
+    execute(topic, payload) {
+        const ptr0 = passStringToWasm0(topic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.database_execute(this.__wbg_ptr, ptr0, len0, payload);
+        return ret;
+    }
+    /**
+     * # Errors
+     * Returns `JsValue` if the database is currently borrowed.
+     * @param {string} group_name
+     * @returns {any}
+     */
+    getConsumerGroup(group_name) {
+        const ptr0 = passStringToWasm0(group_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.database_getConsumerGroup(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Gets the schema definition for an entity.
+     *
+     * # Errors
+     * Returns an error if serialization fails.
+     * @param {string} entity
+     * @returns {any}
+     */
+    getSchema(entity) {
+        const ptr0 = passStringToWasm0(entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.database_getSchema(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * # Errors
+     * Returns `JsValue` if the database is currently borrowed.
+     * @param {string} sub_id
+     * @returns {any}
+     */
+    getSubscriptionInfo(sub_id) {
+        const ptr0 = passStringToWasm0(sub_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.database_getSubscriptionInfo(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * # Errors
+     * Returns `JsValue` if the database is currently borrowed.
+     * @param {string} sub_id
+     * @returns {boolean}
+     */
+    heartbeat(sub_id) {
+        const ptr0 = passStringToWasm0(sub_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.database_heartbeat(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * @returns {boolean}
+     */
+    isMemoryBackend() {
+        const ret = wasm.database_isMemoryBackend(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Lists records from an entity with optional filtering, sorting, and pagination.
+     *
+     * # Errors
+     * Returns an error if options are invalid or the storage operation fails.
+     * @param {string} entity
+     * @param {any} options
+     * @returns {Promise<any>}
+     */
+    list(entity, options) {
+        const ptr0 = passStringToWasm0(entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.database_list(this.__wbg_ptr, ptr0, len0, options);
+        return ret;
+    }
+    /**
+     * @param {string} entity
+     * @returns {any}
+     */
+    listConstraints(entity) {
+        const ptr0 = passStringToWasm0(entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.database_listConstraints(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * # Errors
+     * Returns `JsValue` if the database is currently borrowed.
+     * @returns {any}
+     */
+    listConsumerGroups() {
+        const ret = wasm.database_listConsumerGroups(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {string} entity
+     * @returns {any}
+     */
+    listRelationships(entity) {
+        const ptr0 = passStringToWasm0(entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.database_listRelationships(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * # Errors
+     * Returns an error if options are invalid or the backend is not memory-based.
+     * @param {string} entity
+     * @param {any} options
+     * @returns {any}
+     */
+    listSync(entity, options) {
+        const ptr0 = passStringToWasm0(entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.database_listSync(this.__wbg_ptr, ptr0, len0, options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    constructor() {
+        const ret = wasm.database_new();
+        this.__wbg_ptr = ret;
+        DatabaseFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {string} db_name
+     * @param {string} passphrase
+     * @returns {Promise<Database>}
+     */
+    static openEncrypted(db_name, passphrase) {
+        const ptr0 = passStringToWasm0(db_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(passphrase, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.database_openEncrypted(ptr0, len0, ptr1, len1);
+        return ret;
+    }
+    /**
+     * @param {string} db_name
+     * @returns {Promise<Database>}
+     */
+    static openPersistent(db_name) {
+        const ptr0 = passStringToWasm0(db_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.database_openPersistent(ptr0, len0);
+        return ret;
+    }
+    /**
+     * Reads a record by entity and ID.
+     *
+     * # Errors
+     * Returns an error if the record is not found or deserialization fails.
+     * @param {string} entity
+     * @param {string} id
+     * @returns {Promise<any>}
+     */
+    read(entity, id) {
+        const ptr0 = passStringToWasm0(entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.database_read(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        return ret;
+    }
+    /**
+     * # Errors
+     * Returns an error if the record is not found or the backend is not memory-based.
+     * @param {string} entity
+     * @param {string} id
+     * @returns {any}
+     */
+    readSync(entity, id) {
+        const ptr0 = passStringToWasm0(entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.database_readSync(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Reads a record with related entities eagerly loaded.
+     *
+     * # Errors
+     * Returns an error if the record is not found or includes cannot be loaded.
+     * @param {string} entity
+     * @param {string} id
+     * @param {any} includes
+     * @returns {Promise<any>}
+     */
+    readWithIncludes(entity, id, includes) {
+        const ptr0 = passStringToWasm0(entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.database_readWithIncludes(this.__wbg_ptr, ptr0, len0, ptr1, len1, includes);
+        return ret;
+    }
+    /**
+     * # Errors
+     * Returns `JsValue` if the database is currently borrowed.
+     * @param {string} pattern
+     * @param {string | null | undefined} entity
+     * @param {Function} callback
+     * @returns {string}
+     */
+    subscribe(pattern, entity, callback) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const ptr0 = passStringToWasm0(pattern, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            var ptr1 = isLikeNone(entity) ? 0 : passStringToWasm0(entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len1 = WASM_VECTOR_LEN;
+            const ret = wasm.database_subscribe(this.__wbg_ptr, ptr0, len0, ptr1, len1, callback);
+            var ptr3 = ret[0];
+            var len3 = ret[1];
+            if (ret[3]) {
+                ptr3 = 0; len3 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred4_0 = ptr3;
+            deferred4_1 = len3;
+            return getStringFromWasm0(ptr3, len3);
+        } finally {
+            wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+        }
+    }
+    /**
+     * # Errors
+     * Returns `JsValue` if the database is currently borrowed.
+     * @param {string} pattern
+     * @param {string | null | undefined} entity
+     * @param {string} group
+     * @param {string} mode
+     * @param {Function} callback
+     * @returns {string}
+     */
+    subscribeShared(pattern, entity, group, mode, callback) {
+        let deferred6_0;
+        let deferred6_1;
+        try {
+            const ptr0 = passStringToWasm0(pattern, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            var ptr1 = isLikeNone(entity) ? 0 : passStringToWasm0(entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len1 = WASM_VECTOR_LEN;
+            const ptr2 = passStringToWasm0(group, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passStringToWasm0(mode, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len3 = WASM_VECTOR_LEN;
+            const ret = wasm.database_subscribeShared(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, callback);
+            var ptr5 = ret[0];
+            var len5 = ret[1];
+            if (ret[3]) {
+                ptr5 = 0; len5 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred6_0 = ptr5;
+            deferred6_1 = len5;
+            return getStringFromWasm0(ptr5, len5);
+        } finally {
+            wasm.__wbindgen_free(deferred6_0, deferred6_1, 1);
+        }
+    }
+    /**
+     * # Errors
+     * Returns `JsValue` if the database is currently borrowed.
+     * @param {string} sub_id
+     * @returns {boolean}
+     */
+    unsubscribe(sub_id) {
+        const ptr0 = passStringToWasm0(sub_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.database_unsubscribe(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * Updates an existing record with new field values.
+     *
+     * # Errors
+     * Returns an error if the record is not found or validation fails.
+     * @param {string} entity
+     * @param {string} id
+     * @param {any} fields
+     * @returns {Promise<any>}
+     */
+    update(entity, id, fields) {
+        const ptr0 = passStringToWasm0(entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.database_update(this.__wbg_ptr, ptr0, len0, ptr1, len1, fields);
+        return ret;
+    }
+    /**
+     * # Errors
+     * Returns an error if the record is not found, validation fails, or the backend is not memory-based.
+     * @param {string} entity
+     * @param {string} id
+     * @param {any} fields
+     * @returns {any}
+     */
+    updateSync(entity, id, fields) {
+        const ptr0 = passStringToWasm0(entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.database_updateSync(this.__wbg_ptr, ptr0, len0, ptr1, len1, fields);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+}
+if (Symbol.dispose) Database.prototype[Symbol.dispose] = Database.prototype.free;
+
+export class MessageProperties {
+    static __wrap(ptr) {
+        const obj = Object.create(MessageProperties.prototype);
+        obj.__wbg_ptr = ptr;
+        MessagePropertiesFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MessagePropertiesFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_messageproperties_free(ptr, 0);
+    }
+    /**
+     * @returns {string | undefined}
+     */
+    get contentType() {
+        const ret = wasm.messageproperties_contentType(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;
+    }
+    /**
+     * @returns {Uint8Array | undefined}
+     */
+    get correlationData() {
+        const ret = wasm.messageproperties_correlationData(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * @returns {Array<any>}
+     */
+    getUserProperties() {
+        const ret = wasm.messageproperties_getUserProperties(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number | undefined}
+     */
+    get messageExpiryInterval() {
+        const ret = wasm.messageproperties_messageExpiryInterval(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
+    /**
+     * @returns {boolean | undefined}
+     */
+    get payloadFormatIndicator() {
+        const ret = wasm.messageproperties_payloadFormatIndicator(this.__wbg_ptr);
+        return ret === 0xFFFFFF ? undefined : ret !== 0;
+    }
+    /**
+     * @returns {string | undefined}
+     */
+    get responseTopic() {
+        const ret = wasm.messageproperties_responseTopic(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;
+    }
+    /**
+     * @returns {Uint32Array}
+     */
+    get subscriptionIdentifiers() {
+        const ret = wasm.messageproperties_subscriptionIdentifiers(this.__wbg_ptr);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+}
+if (Symbol.dispose) MessageProperties.prototype[Symbol.dispose] = MessageProperties.prototype.free;
+
+export class MqttClient {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MqttClientFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_mqttclient_free(ptr, 0);
+    }
+    /**
+     * # Errors
+     * Returns an error if connection fails.
+     * @param {string} url
+     * @returns {Promise<void>}
+     */
+    connect(url) {
+        const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.mqttclient_connect(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * # Errors
+     * Returns an error if connection fails.
+     * @param {string} channelName
+     * @returns {Promise<void>}
+     */
+    connectBroadcastChannel(channelName) {
+        const ptr0 = passStringToWasm0(channelName, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.mqttclient_connectBroadcastChannel(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * # Errors
+     * Returns an error if connection fails.
+     * @param {MessagePort} port
+     * @returns {Promise<void>}
+     */
+    connectMessagePort(port) {
+        const ret = wasm.mqttclient_connectMessagePort(this.__wbg_ptr, port);
+        return ret;
+    }
+    /**
+     * # Errors
+     * Returns an error if connection fails.
+     * @param {MessagePort} port
+     * @param {ConnectOptions} config
+     * @returns {Promise<void>}
+     */
+    connectMessagePortWithOptions(port, config) {
+        _assertClass(config, ConnectOptions);
+        const ret = wasm.mqttclient_connectMessagePortWithOptions(this.__wbg_ptr, port, config.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * # Errors
+     * Returns an error if connection fails.
+     * @param {string} url
+     * @param {ConnectOptions} config
+     * @returns {Promise<void>}
+     */
+    connectWithOptions(url, config) {
+        const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        _assertClass(config, ConnectOptions);
+        const ret = wasm.mqttclient_connectWithOptions(this.__wbg_ptr, ptr0, len0, config.__wbg_ptr);
+        return ret;
+    }
+    destroy() {
+        wasm.mqttclient_destroy(this.__wbg_ptr);
+    }
+    /**
+     * # Errors
+     * Returns an error if disconnect fails.
+     * @returns {Promise<void>}
+     */
+    disconnect() {
+        const ret = wasm.mqttclient_disconnect(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {boolean} enabled
+     */
+    enableAutoReconnect(enabled) {
+        wasm.mqttclient_enableAutoReconnect(this.__wbg_ptr, enabled);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isBrowserOnline() {
+        const ret = wasm.mqttclient_isBrowserOnline(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {boolean}
+     */
+    isConnected() {
+        const ret = wasm.mqttclient_isConnected(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReconnecting() {
+        const ret = wasm.mqttclient_isReconnecting(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {string} clientId
+     */
+    constructor(clientId) {
+        const ptr0 = passStringToWasm0(clientId, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.mqttclient_new(ptr0, len0);
+        this.__wbg_ptr = ret;
+        MqttClientFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {Function} callback
+     */
+    onAuthChallenge(callback) {
+        wasm.mqttclient_onAuthChallenge(this.__wbg_ptr, callback);
+    }
+    /**
+     * @param {Function} callback
+     */
+    onConnect(callback) {
+        wasm.mqttclient_onConnect(this.__wbg_ptr, callback);
+    }
+    /**
+     * @param {Function} callback
+     */
+    onConnectivityChange(callback) {
+        wasm.mqttclient_onConnectivityChange(this.__wbg_ptr, callback);
+    }
+    /**
+     * @param {Function} callback
+     */
+    onDisconnect(callback) {
+        wasm.mqttclient_onDisconnect(this.__wbg_ptr, callback);
+    }
+    /**
+     * @param {Function} callback
+     */
+    onError(callback) {
+        wasm.mqttclient_onError(this.__wbg_ptr, callback);
+    }
+    /**
+     * @param {Function} callback
+     */
+    onReconnectFailed(callback) {
+        wasm.mqttclient_onReconnectFailed(this.__wbg_ptr, callback);
+    }
+    /**
+     * @param {Function} callback
+     */
+    onReconnecting(callback) {
+        wasm.mqttclient_onReconnecting(this.__wbg_ptr, callback);
+    }
+    /**
+     * # Errors
+     * Returns an error if not connected or publish fails.
+     * @param {string} topic
+     * @param {Uint8Array} payload
+     * @returns {Promise<void>}
+     */
+    publish(topic, payload) {
+        const ptr0 = passStringToWasm0(topic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(payload, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.mqttclient_publish(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        return ret;
+    }
+    /**
+     * # Errors
+     * Returns an error if not connected or publish fails.
+     * @param {string} topic
+     * @param {Uint8Array} payload
+     * @param {Function} callback
+     * @returns {Promise<number>}
+     */
+    publishQos1(topic, payload, callback) {
+        const ptr0 = passStringToWasm0(topic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(payload, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.mqttclient_publishQos1(this.__wbg_ptr, ptr0, len0, ptr1, len1, callback);
+        return ret;
+    }
+    /**
+     * # Errors
+     * Returns an error if not connected or publish fails.
+     * @param {string} topic
+     * @param {Uint8Array} payload
+     * @param {Function} callback
+     * @returns {Promise<number>}
+     */
+    publishQos2(topic, payload, callback) {
+        const ptr0 = passStringToWasm0(topic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(payload, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.mqttclient_publishQos2(this.__wbg_ptr, ptr0, len0, ptr1, len1, callback);
+        return ret;
+    }
+    /**
+     * # Errors
+     * Returns an error if not connected or publish fails.
+     * @param {string} topic
+     * @param {Uint8Array} payload
+     * @param {PublishOptions} options
+     * @returns {Promise<void>}
+     */
+    publishWithOptions(topic, payload, options) {
+        const ptr0 = passStringToWasm0(topic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(payload, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        _assertClass(options, PublishOptions);
+        const ret = wasm.mqttclient_publishWithOptions(this.__wbg_ptr, ptr0, len0, ptr1, len1, options.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * # Errors
+     * Returns an error if no auth method is set or send fails.
+     * @param {Uint8Array} authData
+     */
+    respondAuth(authData) {
+        const ptr0 = passArray8ToWasm0(authData, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.mqttclient_respondAuth(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {ReconnectOptions} options
+     */
+    setReconnectOptions(options) {
+        _assertClass(options, ReconnectOptions);
+        wasm.mqttclient_setReconnectOptions(this.__wbg_ptr, options.__wbg_ptr);
+    }
+    /**
+     * # Errors
+     * Returns an error if not connected or subscribe fails.
+     * @param {string} topic
+     * @returns {Promise<number>}
+     */
+    subscribe(topic) {
+        const ptr0 = passStringToWasm0(topic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.mqttclient_subscribe(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * # Errors
+     * Returns an error if not connected or subscribe fails.
+     * @param {string} topic
+     * @param {Function} callback
+     * @returns {Promise<number>}
+     */
+    subscribeWithCallback(topic, callback) {
+        const ptr0 = passStringToWasm0(topic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.mqttclient_subscribeWithCallback(this.__wbg_ptr, ptr0, len0, callback);
+        return ret;
+    }
+    /**
+     * # Errors
+     * Returns an error if not connected or subscribe fails.
+     * @param {string} topic
+     * @param {Function} callback
+     * @param {SubscribeOptions} options
+     * @returns {Promise<number>}
+     */
+    subscribeWithOptions(topic, callback, options) {
+        const ptr0 = passStringToWasm0(topic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        _assertClass(options, SubscribeOptions);
+        const ret = wasm.mqttclient_subscribeWithOptions(this.__wbg_ptr, ptr0, len0, callback, options.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * # Errors
+     * Returns an error if not connected or unsubscribe fails.
+     * @param {string} topic
+     * @returns {Promise<number>}
+     */
+    unsubscribe(topic) {
+        const ptr0 = passStringToWasm0(topic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.mqttclient_unsubscribe(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+}
+if (Symbol.dispose) MqttClient.prototype[Symbol.dispose] = MqttClient.prototype.free;
+
+export class PublishOptions {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PublishOptionsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_publishoptions_free(ptr, 0);
+    }
+    /**
+     * @param {string} key
+     * @param {string} value
+     */
+    addUserProperty(key, value) {
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.publishoptions_addUserProperty(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+    }
+    clearUserProperties() {
+        wasm.publishoptions_clearUserProperties(this.__wbg_ptr);
+    }
+    /**
+     * @returns {string | undefined}
+     */
+    get contentType() {
+        const ret = wasm.publishoptions_contentType(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;
+    }
+    /**
+     * @returns {number | undefined}
+     */
+    get messageExpiryInterval() {
+        const ret = wasm.publishoptions_messageExpiryInterval(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
+    constructor() {
+        const ret = wasm.publishoptions_new();
+        this.__wbg_ptr = ret;
+        PublishOptionsFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {boolean | undefined}
+     */
+    get payloadFormatIndicator() {
+        const ret = wasm.publishoptions_payloadFormatIndicator(this.__wbg_ptr);
+        return ret === 0xFFFFFF ? undefined : ret !== 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get qos() {
+        const ret = wasm.publishoptions_qos(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {string | undefined}
+     */
+    get responseTopic() {
+        const ret = wasm.publishoptions_responseTopic(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;
+    }
+    /**
+     * @returns {boolean}
+     */
+    get retain() {
+        const ret = wasm.publishoptions_retain(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {string | null} [value]
+     */
+    set contentType(value) {
+        var ptr0 = isLikeNone(value) ? 0 : passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.publishoptions_set_contentType(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {Uint8Array} value
+     */
+    set correlationData(value) {
+        const ptr0 = passArray8ToWasm0(value, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.publishoptions_set_correlationData(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {number | null} [value]
+     */
+    set messageExpiryInterval(value) {
+        wasm.publishoptions_set_messageExpiryInterval(this.__wbg_ptr, isLikeNone(value) ? Number.MAX_SAFE_INTEGER : (value) >>> 0);
+    }
+    /**
+     * @param {boolean | null} [value]
+     */
+    set payloadFormatIndicator(value) {
+        wasm.publishoptions_set_payloadFormatIndicator(this.__wbg_ptr, isLikeNone(value) ? 0xFFFFFF : value ? 1 : 0);
+    }
+    /**
+     * @param {number} value
+     */
+    set qos(value) {
+        wasm.publishoptions_set_qos(this.__wbg_ptr, value);
+    }
+    /**
+     * @param {string | null} [value]
+     */
+    set responseTopic(value) {
+        var ptr0 = isLikeNone(value) ? 0 : passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.publishoptions_set_responseTopic(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {boolean} value
+     */
+    set retain(value) {
+        wasm.publishoptions_set_retain(this.__wbg_ptr, value);
+    }
+    /**
+     * @param {number | null} [value]
+     */
+    set topicAlias(value) {
+        wasm.publishoptions_set_topicAlias(this.__wbg_ptr, isLikeNone(value) ? 0xFFFFFF : value);
+    }
+    /**
+     * @returns {number | undefined}
+     */
+    get topicAlias() {
+        const ret = wasm.publishoptions_topicAlias(this.__wbg_ptr);
+        return ret === 0xFFFFFF ? undefined : ret;
+    }
+}
+if (Symbol.dispose) PublishOptions.prototype[Symbol.dispose] = PublishOptions.prototype.free;
+
+export class ReconnectOptions {
+    static __wrap(ptr) {
+        const obj = Object.create(ReconnectOptions.prototype);
+        obj.__wbg_ptr = ptr;
+        ReconnectOptionsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ReconnectOptionsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_reconnectoptions_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get backoffFactor() {
+        const ret = wasm.reconnectoptions_backoffFactor(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {ReconnectOptions}
+     */
+    static disabled() {
+        const ret = wasm.reconnectoptions_disabled();
+        return ReconnectOptions.__wrap(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    get enabled() {
+        const ret = wasm.reconnectoptions_enabled(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get initialDelayMs() {
+        const ret = wasm.reconnectoptions_initialDelayMs(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number | undefined}
+     */
+    get maxAttempts() {
+        const ret = wasm.reconnectoptions_maxAttempts(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get maxDelayMs() {
+        const ret = wasm.reconnectoptions_maxDelayMs(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    constructor() {
+        const ret = wasm.reconnectoptions_new();
+        this.__wbg_ptr = ret;
+        ReconnectOptionsFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {number} value
+     */
+    set backoffFactor(value) {
+        wasm.reconnectoptions_set_backoffFactor(this.__wbg_ptr, value);
+    }
+    /**
+     * @param {boolean} value
+     */
+    set enabled(value) {
+        wasm.reconnectoptions_set_enabled(this.__wbg_ptr, value);
+    }
+    /**
+     * @param {number} value
+     */
+    set initialDelayMs(value) {
+        wasm.reconnectoptions_set_initialDelayMs(this.__wbg_ptr, value);
+    }
+    /**
+     * @param {number | null} [value]
+     */
+    set maxAttempts(value) {
+        wasm.reconnectoptions_set_maxAttempts(this.__wbg_ptr, isLikeNone(value) ? Number.MAX_SAFE_INTEGER : (value) >>> 0);
+    }
+    /**
+     * @param {number} value
+     */
+    set maxDelayMs(value) {
+        wasm.reconnectoptions_set_maxDelayMs(this.__wbg_ptr, value);
+    }
+}
+if (Symbol.dispose) ReconnectOptions.prototype[Symbol.dispose] = ReconnectOptions.prototype.free;
+
+/**
+ * Reactive state-sync store, browser flavour. Construct with [`create_store`],
+ * call [`Store::initialize`] once, then issue CRUD calls.
+ */
+export class Store {
+    static __wrap(ptr) {
+        const obj = Object.create(Store.prototype);
+        obj.__wbg_ptr = ptr;
+        StoreFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        StoreFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_store_free(ptr, 0);
+    }
+    /**
+     * Defer memory-bus notifications until [`Store::end_batch`]; rapid bursts
+     * collapse to one event per `(scope, entity)`.
+     *
+     * # Errors
+     * Returns an error if the store is not initialized.
+     */
+    beginBatch() {
+        const ret = wasm.store_beginBatch(this.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Clear a scope from the in-memory cache. Equivalent to TS `clearScope`.
+     *
+     * # Errors
+     * Returns an error if the operation fails.
+     * @param {string} scope_id
+     * @returns {Promise<void>}
+     */
+    clearScope(scope_id) {
+        const ptr0 = passStringToWasm0(scope_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.store_clearScope(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * Unsubscribe from a scope's remote topics and clear it from the active
+     * scope if it was current.
+     *
+     * # Errors
+     * Returns an error if the operation fails.
+     * @param {string} scope_id
+     * @returns {Promise<void>}
+     */
+    closeScope(scope_id) {
+        const ptr0 = passStringToWasm0(scope_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.store_closeScope(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * Current remote connection status as a string (`"Offline"`,
+     * `"Connecting"`, `"Connected"`, `"Disconnected"`, `"Error"`). `"Offline"`
+     * when no remote is configured.
+     *
+     * # Errors
+     * Returns an error if the store is not initialized.
+     * @returns {string}
+     */
+    connectionStatus() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.store_connectionStatus(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);
+        }
+    }
+    /**
+     * Insert a row into `entity` under `scopeId`. Returns the new row's id.
+     *
+     * # Errors
+     * Returns an error if the write fails.
+     * @param {string} entity
+     * @param {string} scope_id
+     * @param {any} data
+     * @param {string | null} [tag]
+     * @returns {Promise<string>}
+     */
+    create(entity, scope_id, data, tag) {
+        const ptr0 = passStringToWasm0(entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(scope_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        var ptr2 = isLikeNone(tag) ? 0 : passStringToWasm0(tag, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len2 = WASM_VECTOR_LEN;
+        const ret = wasm.store_create(this.__wbg_ptr, ptr0, len0, ptr1, len1, data, ptr2, len2);
+        return ret;
+    }
+    /**
+     * Delete a row. No-op if absent.
+     *
+     * # Errors
+     * Returns an error if the write fails.
+     * @param {string} entity
+     * @param {string} id
+     * @param {string | null} [tag]
+     * @returns {Promise<void>}
+     */
+    delete(entity, id, tag) {
+        const ptr0 = passStringToWasm0(entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        var ptr2 = isLikeNone(tag) ? 0 : passStringToWasm0(tag, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len2 = WASM_VECTOR_LEN;
+        const ret = wasm.store_delete(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+        return ret;
+    }
+    /**
+     * Disconnect the remote, close persistence, and abort background tasks.
+     *
+     * # Errors
+     * Returns an error if the operation fails.
+     * @returns {Promise<void>}
+     */
+    destroy() {
+        const ret = wasm.store_destroy(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Disconnect the remote client. Memory and persistence are unaffected.
+     *
+     * # Errors
+     * Returns an error if the disconnect fails.
+     * @returns {Promise<void>}
+     */
+    disconnect() {
+        const ret = wasm.store_disconnect(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Flush the batch opened by [`Store::begin_batch`].
+     *
+     * # Errors
+     * Returns an error if the store is not initialized.
+     */
+    endBatch() {
+        const ret = wasm.store_endBatch(this.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Count of rows of `entity` within `scopeId`.
+     *
+     * # Errors
+     * Returns an error if the read fails.
+     * @param {string} entity
+     * @param {string} scope_id
+     * @returns {number}
+     */
+    getChildCount(entity, scope_id) {
+        const ptr0 = passStringToWasm0(entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(scope_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.store_getChildCount(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * Snapshot of all rows for `entity` within `scopeId`. Equivalent to TS
+     * `getSnapshot`.
+     *
+     * # Errors
+     * Returns an error if the read fails.
+     * @param {string} entity
+     * @param {string} scope_id
+     * @returns {any}
+     */
+    getSnapshot(entity, scope_id) {
+        const ptr0 = passStringToWasm0(entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(scope_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.store_getSnapshot(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Snapshot of `entity` within `scopeId` as an object keyed by row id.
+     *
+     * # Errors
+     * Returns an error if the read fails.
+     * @param {string} entity
+     * @param {string} scope_id
+     * @returns {any}
+     */
+    getSnapshotAsMap(entity, scope_id) {
+        const ptr0 = passStringToWasm0(entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(scope_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.store_getSnapshotAsMap(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Change token for `(scopeId, entity)`: increments on every mutation and on
+     * scope load, and resets to `0` when the scope is cleared or replaced by
+     * loading another scope. Top-level (global) entities are versioned under the
+     * empty scope. Lets the JS layer cache snapshots and re-fetch whenever this
+     * differs from the last seen value (referential stability for React).
+     *
+     * # Errors
+     * Returns an error if the store is not initialized.
+     * @param {string} scope_id
+     * @param {string} entity
+     * @returns {number}
+     */
+    getVersion(scope_id, entity) {
+        const ptr0 = passStringToWasm0(scope_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.store_getVersion(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * `true` if durable IndexedDB persistence is configured.
+     *
+     * # Errors
+     * Returns an error if the store is not initialized.
+     * @returns {boolean}
+     */
+    hasPersistence() {
+        const ret = wasm.store_hasPersistence(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * `true` if remote sync is configured.
+     *
+     * # Errors
+     * Returns an error if the store is not initialized.
+     * @returns {boolean}
+     */
+    hasRemote() {
+        const ret = wasm.store_hasRemote(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * Open the store (in-memory + persistence) and, when a remote is
+     * configured, connect to the broker. Idempotent.
+     *
+     * # Errors
+     * Returns an error if the underlying database fails to open.
+     * @returns {Promise<void>}
+     */
+    initialize() {
+        const ret = wasm.store_initialize(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * `true` while the remote client is between connections.
+     *
+     * # Errors
+     * Returns an error if the store is not initialized.
+     * @returns {boolean}
+     */
+    isReconnecting() {
+        const ret = wasm.store_isReconnecting(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * List rows of `entity`, optionally filtered/sorted. `filter` is
+     * `{ scopeId?, sort?: [{ field, direction }], projection?: [string] }`.
+     *
+     * # Errors
+     * Returns an error if the read fails or `filter` is malformed.
+     * @param {string} entity
+     * @param {any} filter
+     * @returns {Promise<any>}
+     */
+    list(entity, filter) {
+        const ptr0 = passStringToWasm0(entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.store_list(this.__wbg_ptr, ptr0, len0, filter);
+        return ret;
+    }
+    /**
+     * List all root entities across scopes, optionally sorted (`[{ field,
+     * direction }]`).
+     *
+     * # Errors
+     * Returns an error if the read fails or `sort` is malformed.
+     * @param {any} sort
+     * @returns {Promise<any>}
+     */
+    listRootEntities(sort) {
+        const ret = wasm.store_listRootEntities(this.__wbg_ptr, sort);
+        return ret;
+    }
+    /**
+     * Load a scope's rows into the in-memory cache from caller-supplied data,
+     * `{ entity: [records] }`, replacing any currently-loaded scope. Equivalent
+     * to TS `loadScope`.
+     *
+     * # Errors
+     * Returns an error if `data` is malformed or the load fails.
+     * @param {string} scope_id
+     * @param {any} data
+     * @returns {Promise<void>}
+     */
+    loadScope(scope_id, data) {
+        const ptr0 = passStringToWasm0(scope_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.store_loadScope(this.__wbg_ptr, ptr0, len0, data);
+        return ret;
+    }
+    /**
+     * Number of offline-queued mutations buffered for `scopeId` (the
+     * authenticated user's pending writes). `0` when no remote/queue is
+     * configured.
+     *
+     * # Errors
+     * Returns an error if the store is not initialized.
+     * @param {string} scope_id
+     * @returns {Promise<number>}
+     */
+    pendingMutationCount(scope_id) {
+        const ptr0 = passStringToWasm0(scope_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.store_pendingMutationCount(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * Read a single row from the in-memory cache, or `null` if absent.
+     *
+     * # Errors
+     * Returns an error if the read fails.
+     * @param {string} entity
+     * @param {string} id
+     * @returns {any}
+     */
+    read(entity, id) {
+        const ptr0 = passStringToWasm0(entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.store_read(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Read a row straight from durable persistence, bypassing the in-memory
+     * cache. Returns `null` if absent. Falls back to memory when the store has
+     * no persistence configured.
+     *
+     * # Errors
+     * Returns an error if the read fails.
+     * @param {string} entity
+     * @param {string} id
+     * @returns {Promise<any>}
+     */
+    readLocalState(entity, id) {
+        const ptr0 = passStringToWasm0(entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.store_readLocalState(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        return ret;
+    }
+    /**
+     * `true` once [`Store::initialize`] has completed.
+     * @returns {boolean}
+     */
+    ready() {
+        const ret = wasm.store_ready(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Reconnect the remote client, optionally with a fresh JWT ticket or
+     * fresh username + password.
+     *
+     * # Errors
+     * Returns an error if no remote is configured or the reconnect fails.
+     * @param {string} server_url
+     * @param {string | null} [ticket]
+     * @param {string | null} [username]
+     * @param {string | null} [password]
+     * @returns {Promise<void>}
+     */
+    reconnect(server_url, ticket, username, password) {
+        const ptr0 = passStringToWasm0(server_url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(ticket) ? 0 : passStringToWasm0(ticket, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        var ptr2 = isLikeNone(username) ? 0 : passStringToWasm0(username, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len2 = WASM_VECTOR_LEN;
+        var ptr3 = isLikeNone(password) ? 0 : passStringToWasm0(password, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len3 = WASM_VECTOR_LEN;
+        const ret = wasm.store_reconnect(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+        return ret;
+    }
+    /**
+     * Switch the active scope, loading its rows from persistence into the
+     * in-memory cache. Use after reopening a persistent store to rehydrate a
+     * scope's snapshot.
+     *
+     * # Errors
+     * Returns an error if the load fails.
+     * @param {string} scope_id
+     * @returns {Promise<void>}
+     */
+    replaceScope(scope_id) {
+        const ptr0 = passStringToWasm0(scope_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.store_replaceScope(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * Send an arbitrary MQTT request and await the broker's response.
+     *
+     * # Errors
+     * Returns an error if no remote is configured or the request fails.
+     * @param {string} topic
+     * @param {any} payload
+     * @returns {Promise<any>}
+     */
+    request(topic, payload) {
+        const ptr0 = passStringToWasm0(topic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.store_request(this.__wbg_ptr, ptr0, len0, payload);
+        return ret;
+    }
+    /**
+     * Disconnect, clear auth + sync state. Persistence and the offline queue
+     * stay alive; drop the store to fully reset.
+     *
+     * # Errors
+     * Returns an error if the operation fails.
+     * @returns {Promise<void>}
+     */
+    resetForLogout() {
+        const ret = wasm.store_resetForLogout(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Set (or clear, with `null`/`undefined`) the authenticated user. Offline
+     * writes are scoped to this user and are dropped while it is unset, so call
+     * this before issuing writes you want queued for replay.
+     *
+     * # Errors
+     * Returns an error if the store is not initialized.
+     * @param {string | null} [user_id]
+     */
+    setAuthenticatedUser(user_id) {
+        var ptr0 = isLikeNone(user_id) ? 0 : passStringToWasm0(user_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.store_setAuthenticatedUser(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Register a callback fired when the broker rejects the session
+     * (`MQTT_DISCONNECT_AUTH_FAILURE`). Use it to clear cached auth and route
+     * the user to re-login. No-op if no remote is configured.
+     *
+     * # Errors
+     * Returns an error if the store is not initialized.
+     * @param {Function} callback
+     */
+    setSessionInvalidHandler(callback) {
+        const ret = wasm.store_setSessionInvalidHandler(this.__wbg_ptr, callback);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Subscribe to remote connection-status changes; the callback receives the
+     * status string. Returns an unsubscribe function (a no-op when no remote is
+     * configured).
+     *
+     * # Errors
+     * Returns an error if the store is not initialized.
+     * @param {Function} callback
+     * @returns {any}
+     */
+    subscribeToConnectionStatus(callback) {
+        const ret = wasm.store_subscribeToConnectionStatus(this.__wbg_ptr, callback);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Subscribe to mutations for `entity`. The callback receives
+     * `(data | null, op)` where `op` is `"insert" | "update" | "delete"`.
+     * Returns an unsubscribe function.
+     *
+     * # Errors
+     * Returns an error if the store is not initialized.
+     * @param {string} entity
+     * @param {Function} callback
+     * @returns {any}
+     */
+    subscribeToEntity(entity, callback) {
+        const ptr0 = passStringToWasm0(entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.store_subscribeToEntity(this.__wbg_ptr, ptr0, len0, callback);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Subscribe to mutations for `(scopeId, entity)`. The callback takes no
+     * args (a "scope changed" signal). Returns an unsubscribe function.
+     *
+     * # Errors
+     * Returns an error if the store is not initialized.
+     * @param {string} scope_id
+     * @param {string} entity
+     * @param {Function} callback
+     * @returns {any}
+     */
+    subscribeToScope(scope_id, entity, callback) {
+        const ptr0 = passStringToWasm0(scope_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.store_subscribeToScope(this.__wbg_ptr, ptr0, len0, ptr1, len1, callback);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Partial-update a row.
+     *
+     * # Errors
+     * Returns an error if the write fails.
+     * @param {string} entity
+     * @param {string} id
+     * @param {any} fields
+     * @param {string | null} [tag]
+     * @returns {Promise<void>}
+     */
+    update(entity, id, fields, tag) {
+        const ptr0 = passStringToWasm0(entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        var ptr2 = isLikeNone(tag) ? 0 : passStringToWasm0(tag, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len2 = WASM_VECTOR_LEN;
+        const ret = wasm.store_update(this.__wbg_ptr, ptr0, len0, ptr1, len1, fields, ptr2, len2);
+        return ret;
+    }
+    /**
+     * Upsert into persistence directly, bypassing memory and remote.
+     *
+     * # Errors
+     * Returns an error if the write fails.
+     * @param {string} entity
+     * @param {string} id
+     * @param {any} fields
+     * @returns {Promise<void>}
+     */
+    updateLocalState(entity, id, fields) {
+        const ptr0 = passStringToWasm0(entity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.store_updateLocalState(this.__wbg_ptr, ptr0, len0, ptr1, len1, fields);
+        return ret;
+    }
+}
+if (Symbol.dispose) Store.prototype[Symbol.dispose] = Store.prototype.free;
+
+export class SubscribeOptions {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SubscribeOptionsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_subscribeoptions_free(ptr, 0);
+    }
+    constructor() {
+        const ret = wasm.subscribeoptions_new();
+        this.__wbg_ptr = ret;
+        SubscribeOptionsFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {boolean}
+     */
+    get noLocal() {
+        const ret = wasm.subscribeoptions_noLocal(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get qos() {
+        const ret = wasm.subscribeoptions_qos(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {boolean}
+     */
+    get retainAsPublished() {
+        const ret = wasm.subscribeoptions_retainAsPublished(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get retainHandling() {
+        const ret = wasm.subscribeoptions_retainHandling(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {boolean} value
+     */
+    set noLocal(value) {
+        wasm.subscribeoptions_set_noLocal(this.__wbg_ptr, value);
+    }
+    /**
+     * @param {number} value
+     */
+    set qos(value) {
+        wasm.subscribeoptions_set_qos(this.__wbg_ptr, value);
+    }
+    /**
+     * @param {boolean} value
+     */
+    set retainAsPublished(value) {
+        wasm.subscribeoptions_set_retainAsPublished(this.__wbg_ptr, value);
+    }
+    /**
+     * @param {number} value
+     */
+    set retainHandling(value) {
+        wasm.subscribeoptions_set_retainHandling(this.__wbg_ptr, value);
+    }
+    /**
+     * @param {number | null} [value]
+     */
+    set subscriptionIdentifier(value) {
+        wasm.subscribeoptions_set_subscriptionIdentifier(this.__wbg_ptr, isLikeNone(value) ? Number.MAX_SAFE_INTEGER : (value) >>> 0);
+    }
+    /**
+     * @returns {number | undefined}
+     */
+    get subscriptionIdentifier() {
+        const ret = wasm.subscribeoptions_subscriptionIdentifier(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
+}
+if (Symbol.dispose) SubscribeOptions.prototype[Symbol.dispose] = SubscribeOptions.prototype.free;
+
+export class WillMessage {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WillMessageFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_willmessage_free(ptr, 0);
+    }
+    /**
+     * @returns {string | undefined}
+     */
+    get contentType() {
+        const ret = wasm.willmessage_contentType(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;
+    }
+    /**
+     * @returns {number | undefined}
+     */
+    get messageExpiryInterval() {
+        const ret = wasm.willmessage_messageExpiryInterval(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
+    /**
+     * @param {string} topic
+     * @param {Uint8Array} payload
+     */
+    constructor(topic, payload) {
+        const ptr0 = passStringToWasm0(topic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(payload, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.willmessage_new(ptr0, len0, ptr1, len1);
+        this.__wbg_ptr = ret;
+        WillMessageFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {number}
+     */
+    get qos() {
+        const ret = wasm.willmessage_qos(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {string | undefined}
+     */
+    get responseTopic() {
+        const ret = wasm.willmessage_responseTopic(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;
+    }
+    /**
+     * @returns {boolean}
+     */
+    get retain() {
+        const ret = wasm.willmessage_retain(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {string | null} [value]
+     */
+    set contentType(value) {
+        var ptr0 = isLikeNone(value) ? 0 : passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.willmessage_set_contentType(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {number | null} [value]
+     */
+    set messageExpiryInterval(value) {
+        wasm.willmessage_set_messageExpiryInterval(this.__wbg_ptr, isLikeNone(value) ? Number.MAX_SAFE_INTEGER : (value) >>> 0);
+    }
+    /**
+     * @param {number} value
+     */
+    set qos(value) {
+        wasm.willmessage_set_qos(this.__wbg_ptr, value);
+    }
+    /**
+     * @param {string | null} [value]
+     */
+    set responseTopic(value) {
+        var ptr0 = isLikeNone(value) ? 0 : passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.willmessage_set_responseTopic(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {boolean} value
+     */
+    set retain(value) {
+        wasm.willmessage_set_retain(this.__wbg_ptr, value);
+    }
+    /**
+     * @param {string} value
+     */
+    set topic(value) {
+        const ptr0 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.willmessage_set_topic(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {number | null} [value]
+     */
+    set willDelayInterval(value) {
+        wasm.willmessage_set_willDelayInterval(this.__wbg_ptr, isLikeNone(value) ? Number.MAX_SAFE_INTEGER : (value) >>> 0);
+    }
+    /**
+     * @returns {string}
+     */
+    get topic() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.willmessage_topic(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 | undefined}
+     */
+    get willDelayInterval() {
+        const ret = wasm.willmessage_willDelayInterval(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
+}
+if (Symbol.dispose) WillMessage.prototype[Symbol.dispose] = WillMessage.prototype.free;
+
+/**
+ * Build an unopened [`Store`] from a config object
+ * (`{ entities, scope: { rootEntity, childEntities, scopeField } }`).
+ *
+ * Pass an optional second argument to enable durable IndexedDB persistence
+ * and/or remote MQTT-over-WebSocket sync:
+ * `{ persistence: { dbName, passphrase? }, remote: { url, clientId?, ticket?, username?, password? } }`.
+ * With a persistence `passphrase` the store is AES-GCM encrypted. `remote.url`
+ * must be a `ws://`/`wss://` endpoint; `remote.ticket` is a JWT used for MQTT v5
+ * enhanced auth, and `remote.username` + `remote.password` drive classic MQTT
+ * password auth when the broker isn't in JWT mode (ticket takes precedence).
+ * `initialize` then connects and live
+ * mutations flow through `subscribeToEntity`/`getSnapshot`. Omit the argument
+ * for an in-memory store.
+ *
+ * # Errors
+ * Returns an error if the config or options object is malformed.
+ * @param {any} config
+ * @param {any} options
+ * @returns {Store}
+ */
+export function createStore(config, options) {
+    const ret = wasm.createStore(config, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return Store.__wrap(ret[0]);
+}
+
+export function init() {
+    wasm.init();
+}
+export function __wbg_Error_92b29b0548f8b746(arg0, arg1) {
+    const ret = Error(getStringFromWasm0(arg0, arg1));
+    return ret;
+}
+export function __wbg_Number_9a4e0ecb0fa16705(arg0) {
+    const ret = Number(arg0);
+    return ret;
+}
+export function __wbg_String_8564e559799eccda(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);
+}
+export function __wbg___wbindgen_bigint_get_as_i64_d968e41184ae354f(arg0, arg1) {
+    const v = arg1;
+    const ret = typeof(v) === 'bigint' ? v : undefined;
+    getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+}
+export function __wbg___wbindgen_boolean_get_fa956cfa2d1bd751(arg0) {
+    const v = arg0;
+    const ret = typeof(v) === 'boolean' ? v : undefined;
+    return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
+}
+export function __wbg___wbindgen_debug_string_c25d447a39f5578f(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);
+}
+export function __wbg___wbindgen_in_aca499c5de7ff5e5(arg0, arg1) {
+    const ret = arg0 in arg1;
+    return ret;
+}
+export function __wbg___wbindgen_is_bigint_2f76dc55065b4273(arg0) {
+    const ret = typeof(arg0) === 'bigint';
+    return ret;
+}
+export function __wbg___wbindgen_is_function_1ff95bcc5517c252(arg0) {
+    const ret = typeof(arg0) === 'function';
+    return ret;
+}
+export function __wbg___wbindgen_is_null_ea9085d691f535d3(arg0) {
+    const ret = arg0 === null;
+    return ret;
+}
+export function __wbg___wbindgen_is_object_a27215656b807791(arg0) {
+    const val = arg0;
+    const ret = typeof(val) === 'object' && val !== null;
+    return ret;
+}
+export function __wbg___wbindgen_is_undefined_c05833b95a3cf397(arg0) {
+    const ret = arg0 === undefined;
+    return ret;
+}
+export function __wbg___wbindgen_jsval_eq_e659fcf7b0e32763(arg0, arg1) {
+    const ret = arg0 === arg1;
+    return ret;
+}
+export function __wbg___wbindgen_jsval_loose_eq_db4c3b15f63fc170(arg0, arg1) {
+    const ret = arg0 == arg1;
+    return ret;
+}
+export function __wbg___wbindgen_number_get_394265ed1e1b84ee(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);
+}
+export function __wbg___wbindgen_string_get_b0ca35b86a603356(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);
+}
+export function __wbg___wbindgen_throw_344f42d3211c4765(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+}
+export function __wbg__wbg_cb_unref_fffb441def202758(arg0) {
+    arg0._wbg_cb_unref();
+}
+export function __wbg_abort_8a4b90d8b05efcf8() { return handleError(function (arg0) {
+    arg0.abort();
+}, arguments); }
+export function __wbg_addEventListener_520e749bbae24529() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+    arg0.addEventListener(getStringFromWasm0(arg1, arg2), arg3, arg4);
+}, arguments); }
+export function __wbg_addEventListener_d85450ee1320c989() { return handleError(function (arg0, arg1, arg2, arg3) {
+    arg0.addEventListener(getStringFromWasm0(arg1, arg2), arg3);
+}, arguments); }
+export function __wbg_bound_0382866a50c2df81() { return handleError(function (arg0, arg1) {
+    const ret = IDBKeyRange.bound(arg0, arg1);
+    return ret;
+}, arguments); }
+export function __wbg_buffer_54b87055582c8a81(arg0) {
+    const ret = arg0.buffer;
+    return ret;
+}
+export function __wbg_call_44b7209e1e252e6a() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+    const ret = arg0.call(arg1, arg2, arg3, arg4);
+    return ret;
+}, arguments); }
+export function __wbg_call_8a2dd23819f8a60a() { return handleError(function (arg0, arg1) {
+    const ret = arg0.call(arg1);
+    return ret;
+}, arguments); }
+export function __wbg_call_a6e5c5dce5018821() { return handleError(function (arg0, arg1, arg2) {
+    const ret = arg0.call(arg1, arg2);
+    return ret;
+}, arguments); }
+export function __wbg_call_e3b662382210db98() { return handleError(function (arg0, arg1, arg2, arg3) {
+    const ret = arg0.call(arg1, arg2, arg3);
+    return ret;
+}, arguments); }
+export function __wbg_clearTimeout_3629d6209dfcc46e(arg0) {
+    const ret = clearTimeout(arg0);
+    return ret;
+}
+export function __wbg_close_3423cc7dafc477bb(arg0) {
+    arg0.close();
+}
+export function __wbg_close_463f5a813b1d0317(arg0) {
+    arg0.close();
+}
+export function __wbg_close_c65ca0257e895318() { return handleError(function (arg0) {
+    arg0.close();
+}, arguments); }
+export function __wbg_contains_72b3d3ec2e94729e(arg0, arg1, arg2) {
+    const ret = arg0.contains(getStringFromWasm0(arg1, arg2));
+    return ret;
+}
+export function __wbg_continue_97ad9c8cd4cf7f86() { return handleError(function (arg0) {
+    arg0.continue();
+}, arguments); }
+export function __wbg_createObjectStore_c7a1db4a996dc8ac() { return handleError(function (arg0, arg1, arg2, arg3) {
+    const ret = arg0.createObjectStore(getStringFromWasm0(arg1, arg2), arg3);
+    return ret;
+}, arguments); }
+export function __wbg_crypto_29a13c24f21f7c72() { return handleError(function (arg0) {
+    const ret = arg0.crypto;
+    return ret;
+}, arguments); }
+export function __wbg_cursor_new(arg0) {
+    const ret = Cursor.__wrap(arg0);
+    return ret;
+}
+export function __wbg_data_328de4280640da92(arg0) {
+    const ret = arg0.data;
+    return ret;
+}
+export function __wbg_database_new(arg0) {
+    const ret = Database.__wrap(arg0);
+    return ret;
+}
+export function __wbg_decrypt_beffd62d32dfd2ac() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+    const ret = arg0.decrypt(arg1, arg2, getArrayU8FromWasm0(arg3, arg4));
+    return ret;
+}, arguments); }
+export function __wbg_delete_e7e50168de5ef96e() { return handleError(function (arg0, arg1) {
+    const ret = arg0.delete(arg1);
+    return ret;
+}, arguments); }
+export function __wbg_deriveKey_ea5de45ca2f3aac6() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
+    const ret = arg0.deriveKey(arg1, arg2, arg3, arg4 !== 0, arg5);
+    return ret;
+}, arguments); }
+export function __wbg_done_89b2b13e91a60321(arg0) {
+    const ret = arg0.done;
+    return ret;
+}
+export function __wbg_encrypt_e5b8f6e6306e1edf() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+    const ret = arg0.encrypt(arg1, arg2, getArrayU8FromWasm0(arg3, arg4));
+    return ret;
+}, arguments); }
+export function __wbg_entries_015dc610cd81ede0(arg0) {
+    const ret = Object.entries(arg0);
+    return ret;
+}
+export function __wbg_error_744744ff0c9861e6(arg0) {
+    console.error(arg0);
+}
+export function __wbg_error_a6fa202b58aa1cd3(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);
+    }
+}
+export function __wbg_from_13e323c65fc8f464(arg0) {
+    const ret = Array.from(arg0);
+    return ret;
+}
+export function __wbg_getRandomValues_4d75c4f1f63e1972() { return handleError(function (arg0, arg1, arg2) {
+    const ret = arg0.getRandomValues(getArrayU8FromWasm0(arg1, arg2));
+    return ret;
+}, arguments); }
+export function __wbg_getRandomValues_ef12552bf5acd2fe() { return handleError(function (arg0, arg1) {
+    globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
+}, arguments); }
+export function __wbg_get_507a50627bffa49b(arg0, arg1) {
+    const ret = arg0[arg1 >>> 0];
+    return ret;
+}
+export function __wbg_get_c7eb1f358a7654df() { return handleError(function (arg0, arg1) {
+    const ret = Reflect.get(arg0, arg1);
+    return ret;
+}, arguments); }
+export function __wbg_get_cefddcaffca4fbb7() { return handleError(function (arg0, arg1) {
+    const ret = arg0.get(arg1);
+    return ret;
+}, arguments); }
+export function __wbg_get_unchecked_6e0ad6d2a41b06f6(arg0, arg1) {
+    const ret = arg0[arg1 >>> 0];
+    return ret;
+}
+export function __wbg_get_with_ref_key_6412cf3094599694(arg0, arg1) {
+    const ret = arg0[arg1];
+    return ret;
+}
+export function __wbg_importKey_10a137b5a53c66ba() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+    const ret = arg0.importKey(getStringFromWasm0(arg1, arg2), arg3, getStringFromWasm0(arg4, arg5), arg6 !== 0, arg7);
+    return ret;
+}, arguments); }
+export function __wbg_indexedDB_c7dd741e3b661da5() { return handleError(function (arg0) {
+    const ret = arg0.indexedDB;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+}, arguments); }
+export function __wbg_instanceof_ArrayBuffer_4480b9e0068a8adb(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof ArrayBuffer;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+}
+export function __wbg_instanceof_Map_e5b5e3db98422fcc(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof Map;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+}
+export function __wbg_instanceof_Uint8Array_309b927aaf7a3fc7(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof Uint8Array;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+}
+export function __wbg_instanceof_Window_05ba1ee4f6781663(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof Window;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+}
+export function __wbg_isArray_0677c962b281d01a(arg0) {
+    const ret = Array.isArray(arg0);
+    return ret;
+}
+export function __wbg_isSafeInteger_04f36e4056f1b851(arg0) {
+    const ret = Number.isSafeInteger(arg0);
+    return ret;
+}
+export function __wbg_iterator_6f722e4a93058b71() {
+    const ret = Symbol.iterator;
+    return ret;
+}
+export function __wbg_key_b74c6cd401e5906b() { return handleError(function (arg0) {
+    const ret = arg0.key;
+    return ret;
+}, arguments); }
+export function __wbg_length_1f0964f4a5e2c6d8(arg0) {
+    const ret = arg0.length;
+    return ret;
+}
+export function __wbg_length_370319915dc99107(arg0) {
+    const ret = arg0.length;
+    return ret;
+}
+export function __wbg_log_d267660666346fb3(arg0) {
+    console.log(arg0);
+}
+export function __wbg_messageproperties_new(arg0) {
+    const ret = MessageProperties.__wrap(arg0);
+    return ret;
+}
+export function __wbg_navigator_99621db14b3f1099(arg0) {
+    const ret = arg0.navigator;
+    return ret;
+}
+export function __wbg_new_227d7c05414eb861() {
+    const ret = new Error();
+    return ret;
+}
+export function __wbg_new_245322ac8cd2a4ae() { return handleError(function (arg0, arg1) {
+    const ret = new BroadcastChannel(getStringFromWasm0(arg0, arg1));
+    return ret;
+}, arguments); }
+export function __wbg_new_32b398fb48b6d94a() {
+    const ret = new Array();
+    return ret;
+}
+export function __wbg_new_aec3e25493d729fe(arg0, arg1) {
+    try {
+        var state0 = {a: arg0, b: arg1};
+        var cb0 = (arg0, arg1) => {
+            const a = state0.a;
+            state0.a = 0;
+            try {
+                return wasm_bindgen__convert__closures_____invoke__h6cdd13954d61bb31(a, state0.b, arg0, arg1);
+            } finally {
+                state0.a = a;
+            }
+        };
+        const ret = new Promise(cb0);
+        return ret;
+    } finally {
+        state0.a = 0;
+    }
+}
+export function __wbg_new_cd45aabdf6073e84(arg0) {
+    const ret = new Uint8Array(arg0);
+    return ret;
+}
+export function __wbg_new_da52cf8fe3429cb2() {
+    const ret = new Object();
+    return ret;
+}
+export function __wbg_new_from_slice_77cdfb7977362f3c(arg0, arg1) {
+    const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
+    return ret;
+}
+export function __wbg_new_no_args_ae97b3efc0e29062(arg0, arg1) {
+    const ret = new Function(getStringFromWasm0(arg0, arg1));
+    return ret;
+}
+export function __wbg_new_typed_1824d93f294193e5(arg0, arg1) {
+    try {
+        var state0 = {a: arg0, b: arg1};
+        var cb0 = (arg0, arg1) => {
+            const a = state0.a;
+            state0.a = 0;
+            try {
+                return wasm_bindgen__convert__closures_____invoke__h6cdd13954d61bb31(a, state0.b, arg0, arg1);
+            } finally {
+                state0.a = a;
+            }
+        };
+        const ret = new Promise(cb0);
+        return ret;
+    } finally {
+        state0.a = 0;
+    }
+}
+export function __wbg_new_with_str_3f0451631559a818() { return handleError(function (arg0, arg1, arg2, arg3) {
+    const ret = new WebSocket(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3));
+    return ret;
+}, arguments); }
+export function __wbg_next_6dbf2c0ac8cde20f(arg0) {
+    const ret = arg0.next;
+    return ret;
+}
+export function __wbg_next_71f2aa1cb3d1e37e() { return handleError(function (arg0) {
+    const ret = arg0.next();
+    return ret;
+}, arguments); }
+export function __wbg_now_0cce8c6798af1870() { return handleError(function () {
+    const ret = Date.now();
+    return ret;
+}, arguments); }
+export function __wbg_now_86c0d4ba3fa605b8() {
+    const ret = Date.now();
+    return ret;
+}
+export function __wbg_objectStoreNames_146ab25540bff6db(arg0) {
+    const ret = arg0.objectStoreNames;
+    return ret;
+}
+export function __wbg_objectStore_d5f47956b6c741e3() { return handleError(function (arg0, arg1, arg2) {
+    const ret = arg0.objectStore(getStringFromWasm0(arg1, arg2));
+    return ret;
+}, arguments); }
+export function __wbg_onLine_37be2d67e8996819(arg0) {
+    const ret = arg0.onLine;
+    return ret;
+}
+export function __wbg_openCursor_04059a89749928f3() { return handleError(function (arg0, arg1) {
+    const ret = arg0.openCursor(arg1);
+    return ret;
+}, arguments); }
+export function __wbg_open_72e5234a49d5f85d() { return handleError(function (arg0, arg1, arg2, arg3) {
+    const ret = arg0.open(getStringFromWasm0(arg1, arg2), arg3 >>> 0);
+    return ret;
+}, arguments); }
+export function __wbg_parse_1c0d8a8656d7e016() { return handleError(function (arg0, arg1) {
+    const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
+    return ret;
+}, arguments); }
+export function __wbg_postMessage_b80f20949a4b4f55() { return handleError(function (arg0, arg1) {
+    arg0.postMessage(arg1);
+}, arguments); }
+export function __wbg_postMessage_dd820b768b365613() { return handleError(function (arg0, arg1) {
+    arg0.postMessage(arg1);
+}, arguments); }
+export function __wbg_prototypesetcall_4770620bbe4688a0(arg0, arg1, arg2) {
+    Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+}
+export function __wbg_push_d2ae3af0c1217ae6(arg0, arg1) {
+    const ret = arg0.push(arg1);
+    return ret;
+}
+export function __wbg_put_a368805e3dcab3a7() { return handleError(function (arg0, arg1, arg2) {
+    const ret = arg0.put(arg1, arg2);
+    return ret;
+}, arguments); }
+export function __wbg_queueMicrotask_0ab5b2d2393e99b9(arg0) {
+    const ret = arg0.queueMicrotask;
+    return ret;
+}
+export function __wbg_queueMicrotask_6a09b7bc46549209(arg0) {
+    queueMicrotask(arg0);
+}
+export function __wbg_random_039a7d5d06e0d333() {
+    const ret = Math.random();
+    return ret;
+}
+export function __wbg_removeEventListener_a3f23c70077bdcc1() { return handleError(function (arg0, arg1, arg2, arg3) {
+    arg0.removeEventListener(getStringFromWasm0(arg1, arg2), arg3);
+}, arguments); }
+export function __wbg_resolve_2191a4dfe481c25b(arg0) {
+    const ret = Promise.resolve(arg0);
+    return ret;
+}
+export function __wbg_result_2b1294a2bf8dc773() { return handleError(function (arg0) {
+    const ret = arg0.result;
+    return ret;
+}, arguments); }
+export function __wbg_send_a321b376d40ec867() { return handleError(function (arg0, arg1, arg2) {
+    arg0.send(getArrayU8FromWasm0(arg1, arg2));
+}, arguments); }
+export function __wbg_setTimeout_56bcdccbad22fd44() { return handleError(function (arg0, arg1) {
+    const ret = setTimeout(arg0, arg1);
+    return ret;
+}, arguments); }
+export function __wbg_setTimeout_e28675318d4194f4(arg0, arg1) {
+    const ret = setTimeout(arg0, arg1);
+    return ret;
+}
+export function __wbg_set_8535240470bf2500() { return handleError(function (arg0, arg1, arg2) {
+    const ret = Reflect.set(arg0, arg1, arg2);
+    return ret;
+}, arguments); }
+export function __wbg_set_additional_data_18e1cb74f3f32864(arg0, arg1) {
+    arg0.additionalData = arg1;
+}
+export function __wbg_set_binaryType_a37b086c78ca7c29(arg0, arg1) {
+    arg0.binaryType = __wbindgen_enum_BinaryType[arg1];
+}
+export function __wbg_set_hash_8fcaef147d95108f(arg0, arg1) {
+    arg0.hash = arg1;
+}
+export function __wbg_set_iterations_37c9c9d5d631e5d7(arg0, arg1) {
+    arg0.iterations = arg1 >>> 0;
+}
+export function __wbg_set_iv_3e6d5e431df58a93(arg0, arg1) {
+    arg0.iv = arg1;
+}
+export function __wbg_set_length_ee8e5a826b98e0c4(arg0, arg1) {
+    arg0.length = arg1;
+}
+export function __wbg_set_name_35acf0ca654b7d26(arg0, arg1, arg2) {
+    arg0.name = getStringFromWasm0(arg1, arg2);
+}
+export function __wbg_set_name_6ff1f3d52f53eda3(arg0, arg1, arg2) {
+    arg0.name = getStringFromWasm0(arg1, arg2);
+}
+export function __wbg_set_name_ca0910cc3b07587b(arg0, arg1, arg2) {
+    arg0.name = getStringFromWasm0(arg1, arg2);
+}
+export function __wbg_set_once_51a9fb6b8af8a72b(arg0, arg1) {
+    arg0.once = arg1 !== 0;
+}
+export function __wbg_set_onclose_f706475385ecce07(arg0, arg1) {
+    arg0.onclose = arg1;
+}
+export function __wbg_set_onerror_3488a474171ed56d(arg0, arg1) {
+    arg0.onerror = arg1;
+}
+export function __wbg_set_onerror_9f5773fd31512333(arg0, arg1) {
+    arg0.onerror = arg1;
+}
+export function __wbg_set_onmessage_7fa6f7ccf8ee2d7a(arg0, arg1) {
+    arg0.onmessage = arg1;
+}
+export function __wbg_set_onmessage_836d2f72130b4706(arg0, arg1) {
+    arg0.onmessage = arg1;
+}
+export function __wbg_set_onmessage_d511b70365304094(arg0, arg1) {
+    arg0.onmessage = arg1;
+}
+export function __wbg_set_onopen_4f65470ae522a61a(arg0, arg1) {
+    arg0.onopen = arg1;
+}
+export function __wbg_set_onsuccess_cd0c3642a2873e66(arg0, arg1) {
+    arg0.onsuccess = arg1;
+}
+export function __wbg_set_onupgradeneeded_7b2cf4ba1c57e655(arg0, arg1) {
+    arg0.onupgradeneeded = arg1;
+}
+export function __wbg_set_salt_d41a4905149f81e2(arg0, arg1) {
+    arg0.salt = arg1;
+}
+export function __wbg_stack_3b0d974bbf31e44f(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);
+}
+export function __wbg_start_d0cdf16ff965b3f3(arg0) {
+    arg0.start();
+}
+export function __wbg_static_accessor_GLOBAL_4ef717fb391d88b7() {
+    const ret = typeof global === 'undefined' ? null : global;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+}
+export function __wbg_static_accessor_GLOBAL_THIS_8d1badc68b5a74f4() {
+    const ret = typeof globalThis === 'undefined' ? null : globalThis;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+}
+export function __wbg_static_accessor_SELF_146583524fe1469b() {
+    const ret = typeof self === 'undefined' ? null : self;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+}
+export function __wbg_static_accessor_WINDOW_f2829a2234d7819e() {
+    const ret = typeof window === 'undefined' ? null : window;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+}
+export function __wbg_stringify_b54333f60f1e4dad() { return handleError(function (arg0) {
+    const ret = JSON.stringify(arg0);
+    return ret;
+}, arguments); }
+export function __wbg_subtle_ed1dfcaede24af07(arg0) {
+    const ret = arg0.subtle;
+    return ret;
+}
+export function __wbg_target_e759594a8d965ed7(arg0) {
+    const ret = arg0.target;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+}
+export function __wbg_then_16d107c451e9905d(arg0, arg1, arg2) {
+    const ret = arg0.then(arg1, arg2);
+    return ret;
+}
+export function __wbg_then_6ec10ae38b3e92f7(arg0, arg1) {
+    const ret = arg0.then(arg1);
+    return ret;
+}
+export function __wbg_transaction_d911d96b4b0af154() { return handleError(function (arg0, arg1, arg2, arg3) {
+    const ret = arg0.transaction(getStringFromWasm0(arg1, arg2), __wbindgen_enum_IdbTransactionMode[arg3]);
+    return ret;
+}, arguments); }
+export function __wbg_value_361064aa58a53344() { return handleError(function (arg0) {
+    const ret = arg0.value;
+    return ret;
+}, arguments); }
+export function __wbg_value_a5d5488a9589444a(arg0) {
+    const ret = arg0.value;
+    return ret;
+}
+export function __wbg_warn_b1370d804fa3e259(arg0) {
+    console.warn(arg0);
+}
+export function __wbindgen_cast_0000000000000001(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 1012, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h9efe92496f0b7d96);
+    return ret;
+}
+export function __wbindgen_cast_0000000000000002(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 533, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h09f8c77406c99033);
+    return ret;
+}
+export function __wbindgen_cast_0000000000000003(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("CloseEvent")], shim_idx: 533, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h09f8c77406c99033_2);
+    return ret;
+}
+export function __wbindgen_cast_0000000000000004(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("ErrorEvent")], shim_idx: 533, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h09f8c77406c99033_3);
+    return ret;
+}
+export function __wbindgen_cast_0000000000000005(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("Event")], shim_idx: 979, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h80d264b987904cc4);
+    return ret;
+}
+export function __wbindgen_cast_0000000000000006(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("IDBVersionChangeEvent")], shim_idx: 979, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h80d264b987904cc4_5);
+    return ret;
+}
+export function __wbindgen_cast_0000000000000007(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 533, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h09f8c77406c99033_6);
+    return ret;
+}
+export function __wbindgen_cast_0000000000000008(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 524, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__hee5f925a602b3a9a);
+    return ret;
+}
+export function __wbindgen_cast_0000000000000009(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 537, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__hd5b519e296d8647e);
+    return ret;
+}
+export function __wbindgen_cast_000000000000000a(arg0) {
+    // Cast intrinsic for `F64 -> Externref`.
+    const ret = arg0;
+    return ret;
+}
+export function __wbindgen_cast_000000000000000b(arg0) {
+    // Cast intrinsic for `I64 -> Externref`.
+    const ret = arg0;
+    return ret;
+}
+export function __wbindgen_cast_000000000000000c(arg0, arg1) {
+    // Cast intrinsic for `Ref(String) -> Externref`.
+    const ret = getStringFromWasm0(arg0, arg1);
+    return ret;
+}
+export function __wbindgen_cast_000000000000000d(arg0) {
+    // Cast intrinsic for `U64 -> Externref`.
+    const ret = BigInt.asUintN(64, arg0);
+    return ret;
+}
+export function __wbindgen_init_externref_table() {
+    const table = wasm.__wbindgen_externrefs;
+    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);
+}
+function wasm_bindgen__convert__closures_____invoke__hee5f925a602b3a9a(arg0, arg1) {
+    wasm.wasm_bindgen__convert__closures_____invoke__hee5f925a602b3a9a(arg0, arg1);
+}
+
+function wasm_bindgen__convert__closures_____invoke__hd5b519e296d8647e(arg0, arg1) {
+    wasm.wasm_bindgen__convert__closures_____invoke__hd5b519e296d8647e(arg0, arg1);
+}
+
+function wasm_bindgen__convert__closures_____invoke__h09f8c77406c99033(arg0, arg1, arg2) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h09f8c77406c99033(arg0, arg1, arg2);
+}
+
+function wasm_bindgen__convert__closures_____invoke__h09f8c77406c99033_2(arg0, arg1, arg2) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h09f8c77406c99033_2(arg0, arg1, arg2);
+}
+
+function wasm_bindgen__convert__closures_____invoke__h09f8c77406c99033_3(arg0, arg1, arg2) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h09f8c77406c99033_3(arg0, arg1, arg2);
+}
+
+function wasm_bindgen__convert__closures_____invoke__h80d264b987904cc4(arg0, arg1, arg2) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h80d264b987904cc4(arg0, arg1, arg2);
+}
+
+function wasm_bindgen__convert__closures_____invoke__h80d264b987904cc4_5(arg0, arg1, arg2) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h80d264b987904cc4_5(arg0, arg1, arg2);
+}
+
+function wasm_bindgen__convert__closures_____invoke__h09f8c77406c99033_6(arg0, arg1, arg2) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h09f8c77406c99033_6(arg0, arg1, arg2);
+}
+
+function wasm_bindgen__convert__closures_____invoke__h9efe92496f0b7d96(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h9efe92496f0b7d96(arg0, arg1, arg2);
+    if (ret[1]) {
+        throw takeFromExternrefTable0(ret[0]);
+    }
+}
+
+function wasm_bindgen__convert__closures_____invoke__h6cdd13954d61bb31(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h6cdd13954d61bb31(arg0, arg1, arg2, arg3);
+}
+
+
+const __wbindgen_enum_BinaryType = ["blob", "arraybuffer"];
+
+
+const __wbindgen_enum_IdbTransactionMode = ["readonly", "readwrite", "versionchange", "readwriteflush", "cleanup"];
+const ConnectOptionsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_connectoptions_free(ptr, 1));
+const CursorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_cursor_free(ptr, 1));
+const DatabaseFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_database_free(ptr, 1));
+const MessagePropertiesFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_messageproperties_free(ptr, 1));
+const MqttClientFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_mqttclient_free(ptr, 1));
+const PublishOptionsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_publishoptions_free(ptr, 1));
+const ReconnectOptionsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_reconnectoptions_free(ptr, 1));
+const StoreFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_store_free(ptr, 1));
+const SubscribeOptionsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_subscribeoptions_free(ptr, 1));
+const WillMessageFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_willmessage_free(ptr, 1));
+
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
+    return idx;
+}
+
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+
+const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(state => wasm.__wbindgen_destroy_closure(state.a, state.b));
+
+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 && 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;
+}
+
+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_externrefs.get(mem.getUint32(i, true)));
+    }
+    wasm.__externref_drop_slice(ptr, len);
+    return result;
+}
+
+function getArrayU32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+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 getStringFromWasm0(ptr, len) {
+    return decodeText(ptr >>> 0, len);
+}
+
+let cachedUint32ArrayMemory0 = null;
+function getUint32ArrayMemory0() {
+    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
+    }
+    return cachedUint32ArrayMemory0;
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function makeMutClosure(arg0, arg1, f) {
+    const state = { a: arg0, b: arg1, cnt: 1 };
+    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 {
+            state.a = a;
+            real._wbg_cb_unref();
+        }
+    };
+    real._wbg_cb_unref = () => {
+        if (--state.cnt === 0) {
+            wasm.__wbindgen_destroy_closure(state.a, state.b);
+            state.a = 0;
+            CLOSURE_DTORS.unregister(state);
+        }
+    };
+    CLOSURE_DTORS.register(real, state, state);
+    return real;
+}
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passArrayJsValueToWasm0(array, malloc) {
+    const ptr = malloc(array.length * 4, 4) >>> 0;
+    for (let i = 0; i < array.length; i++) {
+        const add = addToExternrefTable0(array[i]);
+        getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
+    }
+    WASM_VECTOR_LEN = array.length;
+    return ptr;
+}
+
+function 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 = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_externrefs.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+
+let wasm;
+export function __wbg_set_wasm(val) {
+    wasm = val;
+}