@lix-js/sdk 0.12.3 → 0.15.0

package/dist/wasm/lix_js_sdk.js

@@ -53,13 +53,6 @@ export class WasmLix {
         const ret = wasm.wasmlix_createBranch(this.__wbg_ptr, addHeapObject(options));
         return takeObject(ret);
     }
-    /**
-     * @returns {Promise<any>}
-     */
-    createCheckpoint() {
-        const ret = wasm.wasmlix_createCheckpoint(this.__wbg_ptr);
-        return takeObject(ret);
-    }
     /**
      * @param {string} sql
      * @param {any} params
@@ -82,10 +75,18 @@ export class WasmLix {
         return takeObject(ret);
     }
     /**
-     * @returns {Promise<Uint8Array>}
+     * @returns {WasmSnapshotExport}
      */
     exportSnapshot() {
         const ret = wasm.wasmlix_exportSnapshot(this.__wbg_ptr);
+        return WasmSnapshotExport.__wrap(ret);
+    }
+    /**
+     * @param {any} _paths
+     * @returns {Promise<void>}
+     */
+    importFilesystemPaths(_paths) {
+        const ret = wasm.wasmlix_importFilesystemPaths(this.__wbg_ptr, addHeapObject(_paths));
         return takeObject(ret);
     }
     /**
@@ -115,6 +116,32 @@ export class WasmLix {
         const ret = wasm.wasmlix_observe(this.__wbg_ptr, ptr0, len0, addHeapObject(params));
         return takeObject(ret);
     }
+    /**
+     * @param {any} options
+     * @returns {Promise<WasmLix>}
+     */
+    openAnotherSession(options) {
+        const ret = wasm.wasmlix_openAnotherSession(this.__wbg_ptr, addHeapObject(options));
+        return takeObject(ret);
+    }
+    /**
+     * @returns {any}
+     */
+    openReport() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmlix_openReport(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * @returns {Promise<any>}
      */
@@ -122,6 +149,22 @@ export class WasmLix {
         const ret = wasm.wasmlix_redo(this.__wbg_ptr);
         return takeObject(ret);
     }
+    /**
+     * @param {any | null} [parent]
+     */
+    setTelemetryParent(parent) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmlix_setTelemetryParent(retptr, this.__wbg_ptr, isLikeNone(parent) ? 0 : addHeapObject(parent));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * @param {any} options
      * @returns {Promise<any>}
@@ -130,6 +173,13 @@ export class WasmLix {
         const ret = wasm.wasmlix_switchBranch(this.__wbg_ptr, addHeapObject(options));
         return takeObject(ret);
     }
+    /**
+     * @returns {Promise<void>}
+     */
+    syncDiskToLix() {
+        const ret = wasm.wasmlix_syncDiskToLix(this.__wbg_ptr);
+        return takeObject(ret);
+    }
     /**
      * @returns {Promise<any>}
      */
@@ -213,61 +263,416 @@ export class WasmObserveEvents {
         const ret = wasm.wasmobserveevents_next(this.__wbg_ptr);
         return takeObject(ret);
     }
+    /**
+     * @param {any | null} [parent]
+     */
+    setTelemetryParent(parent) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmobserveevents_setTelemetryParent(retptr, this.__wbg_ptr, isLikeNone(parent) ? 0 : addHeapObject(parent));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
 }
 if (Symbol.dispose) WasmObserveEvents.prototype[Symbol.dispose] = WasmObserveEvents.prototype.free;
 
+export class WasmRemoteLix {
+    static __wrap(ptr) {
+        const obj = Object.create(WasmRemoteLix.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmRemoteLixFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmRemoteLixFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmremotelix_free(ptr, 0);
+    }
+    /**
+     * @returns {Promise<string>}
+     */
+    activeAccountId() {
+        const ret = wasm.wasmremotelix_activeAccountId(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {Promise<string>}
+     */
+    activeBranchId() {
+        const ret = wasm.wasmremotelix_activeBranchId(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {Promise<WasmRemoteLixTransaction>}
+     */
+    beginTransaction() {
+        const ret = wasm.wasmremotelix_beginTransaction(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    close() {
+        const ret = wasm.wasmremotelix_close(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * @param {any} options
+     * @returns {Promise<any>}
+     */
+    createBranch(options) {
+        const ret = wasm.wasmremotelix_createBranch(this.__wbg_ptr, addHeapObject(options));
+        return takeObject(ret);
+    }
+    /**
+     * @param {string} sql
+     * @param {any} params
+     * @param {any | null} [options]
+     * @returns {Promise<any>}
+     */
+    execute(sql, params, options) {
+        const ptr0 = passStringToWasm0(sql, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmremotelix_execute(this.__wbg_ptr, ptr0, len0, addHeapObject(params), isLikeNone(options) ? 0 : addHeapObject(options));
+        return takeObject(ret);
+    }
+    /**
+     * @param {any} statements
+     * @param {any | null} [options]
+     * @returns {Promise<any>}
+     */
+    executeBatch(statements, options) {
+        const ret = wasm.wasmremotelix_executeBatch(this.__wbg_ptr, addHeapObject(statements), isLikeNone(options) ? 0 : addHeapObject(options));
+        return takeObject(ret);
+    }
+    /**
+     * @returns {WasmSnapshotExport}
+     */
+    exportSnapshot() {
+        const ret = wasm.wasmremotelix_exportSnapshot(this.__wbg_ptr);
+        return WasmSnapshotExport.__wrap(ret);
+    }
+    /**
+     * @param {any} _paths
+     * @returns {Promise<void>}
+     */
+    importFilesystemPaths(_paths) {
+        const ret = wasm.wasmremotelix_importFilesystemPaths(this.__wbg_ptr, addHeapObject(_paths));
+        return takeObject(ret);
+    }
+    /**
+     * @param {any} options
+     * @returns {Promise<any>}
+     */
+    mergeBranch(options) {
+        const ret = wasm.wasmremotelix_mergeBranch(this.__wbg_ptr, addHeapObject(options));
+        return takeObject(ret);
+    }
+    /**
+     * @param {any} options
+     * @returns {Promise<any>}
+     */
+    mergeBranchPreview(options) {
+        const ret = wasm.wasmremotelix_mergeBranchPreview(this.__wbg_ptr, addHeapObject(options));
+        return takeObject(ret);
+    }
+    /**
+     * @param {string} sql
+     * @param {any} params
+     * @returns {Promise<WasmRemoteObserveEvents>}
+     */
+    observe(sql, params) {
+        const ptr0 = passStringToWasm0(sql, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmremotelix_observe(this.__wbg_ptr, ptr0, len0, addHeapObject(params));
+        return takeObject(ret);
+    }
+    /**
+     * @param {any} options
+     * @returns {Promise<WasmRemoteLix>}
+     */
+    openAnotherSession(options) {
+        const ret = wasm.wasmremotelix_openAnotherSession(this.__wbg_ptr, addHeapObject(options));
+        return takeObject(ret);
+    }
+    /**
+     * @returns {Promise<any>}
+     */
+    redo() {
+        const ret = wasm.wasmremotelix_redo(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * @param {any | null} [_parent]
+     */
+    setTelemetryParent(_parent) {
+        wasm.wasmremotelix_setTelemetryParent(this.__wbg_ptr, isLikeNone(_parent) ? 0 : addHeapObject(_parent));
+    }
+    /**
+     * @param {any} options
+     * @returns {Promise<any>}
+     */
+    switchBranch(options) {
+        const ret = wasm.wasmremotelix_switchBranch(this.__wbg_ptr, addHeapObject(options));
+        return takeObject(ret);
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    syncDiskToLix() {
+        const ret = wasm.wasmremotelix_syncDiskToLix(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {Promise<any>}
+     */
+    undo() {
+        const ret = wasm.wasmremotelix_undo(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+}
+if (Symbol.dispose) WasmRemoteLix.prototype[Symbol.dispose] = WasmRemoteLix.prototype.free;
+
+export class WasmRemoteLixTransaction {
+    static __wrap(ptr) {
+        const obj = Object.create(WasmRemoteLixTransaction.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmRemoteLixTransactionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmRemoteLixTransactionFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmremotelixtransaction_free(ptr, 0);
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    commit() {
+        const ret = wasm.wasmremotelixtransaction_commit(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * @param {string} sql
+     * @param {any} params
+     * @param {any | null} [options]
+     * @returns {Promise<any>}
+     */
+    execute(sql, params, options) {
+        const ptr0 = passStringToWasm0(sql, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmremotelixtransaction_execute(this.__wbg_ptr, ptr0, len0, addHeapObject(params), isLikeNone(options) ? 0 : addHeapObject(options));
+        return takeObject(ret);
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    rollback() {
+        const ret = wasm.wasmremotelixtransaction_rollback(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+}
+if (Symbol.dispose) WasmRemoteLixTransaction.prototype[Symbol.dispose] = WasmRemoteLixTransaction.prototype.free;
+
+export class WasmRemoteObserveEvents {
+    static __wrap(ptr) {
+        const obj = Object.create(WasmRemoteObserveEvents.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmRemoteObserveEventsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmRemoteObserveEventsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmremoteobserveevents_free(ptr, 0);
+    }
+    close() {
+        wasm.wasmremoteobserveevents_close(this.__wbg_ptr);
+    }
+    /**
+     * @returns {Promise<any>}
+     */
+    next() {
+        const ret = wasm.wasmremoteobserveevents_next(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * @param {any | null} [_parent]
+     */
+    setTelemetryParent(_parent) {
+        wasm.wasmremoteobserveevents_setTelemetryParent(this.__wbg_ptr, isLikeNone(_parent) ? 0 : addHeapObject(_parent));
+    }
+}
+if (Symbol.dispose) WasmRemoteObserveEvents.prototype[Symbol.dispose] = WasmRemoteObserveEvents.prototype.free;
+
+export class WasmSnapshotExport {
+    static __wrap(ptr) {
+        const obj = Object.create(WasmSnapshotExport.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmSnapshotExportFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmSnapshotExportFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmsnapshotexport_free(ptr, 0);
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    cancel() {
+        const ret = wasm.wasmsnapshotexport_cancel(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {Promise<Uint8Array | undefined>}
+     */
+    next() {
+        const ret = wasm.wasmsnapshotexport_next(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+}
+if (Symbol.dispose) WasmSnapshotExport.prototype[Symbol.dispose] = WasmSnapshotExport.prototype.free;
+
+export class WasmSnapshotRestore {
+    static __wrap(ptr) {
+        const obj = Object.create(WasmSnapshotRestore.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmSnapshotRestoreFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmSnapshotRestoreFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmsnapshotrestore_free(ptr, 0);
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    cancel() {
+        const ret = wasm.wasmsnapshotrestore_cancel(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {Promise<WasmLix>}
+     */
+    finish() {
+        const ret = wasm.wasmsnapshotrestore_finish(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isComplete() {
+        const ret = wasm.wasmsnapshotrestore_isComplete(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {Uint8Array} chunk
+     * @returns {Promise<void>}
+     */
+    write(chunk) {
+        const ptr0 = passArray8ToWasm0(chunk, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmsnapshotrestore_write(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+}
+if (Symbol.dispose) WasmSnapshotRestore.prototype[Symbol.dispose] = WasmSnapshotRestore.prototype.free;
+
 /**
- * @param {any} backend
+ * @param {any} provider
  * @param {Function | null} [telemetry_dispatch]
+ * @param {any | null} [telemetry_parent]
+ * @param {any | null} [server]
+ * @param {Function | null} [open_progress_dispatch]
  * @returns {Promise<WasmLix>}
  */
-export function openIndexedDb(backend, telemetry_dispatch) {
-    const ret = wasm.openIndexedDb(addHeapObject(backend), isLikeNone(telemetry_dispatch) ? 0 : addHeapObject(telemetry_dispatch));
+export function openJsStorage(provider, telemetry_dispatch, telemetry_parent, server, open_progress_dispatch) {
+    const ret = wasm.openJsStorage(addHeapObject(provider), isLikeNone(telemetry_dispatch) ? 0 : addHeapObject(telemetry_dispatch), isLikeNone(telemetry_parent) ? 0 : addHeapObject(telemetry_parent), isLikeNone(server) ? 0 : addHeapObject(server), isLikeNone(open_progress_dispatch) ? 0 : addHeapObject(open_progress_dispatch));
     return takeObject(ret);
 }
 
 /**
+ * @param {any} provider
  * @param {Function | null} [telemetry_dispatch]
- * @returns {Promise<WasmLix>}
+ * @param {any | null} [telemetry_parent]
+ * @param {Function | null} [open_progress_dispatch]
+ * @returns {WasmSnapshotRestore}
  */
-export function openMemory(telemetry_dispatch) {
-    const ret = wasm.openMemory(isLikeNone(telemetry_dispatch) ? 0 : addHeapObject(telemetry_dispatch));
-    return takeObject(ret);
+export function openJsStorageFromSnapshot(provider, telemetry_dispatch, telemetry_parent, open_progress_dispatch) {
+    const ret = wasm.openJsStorageFromSnapshot(addHeapObject(provider), isLikeNone(telemetry_dispatch) ? 0 : addHeapObject(telemetry_dispatch), isLikeNone(telemetry_parent) ? 0 : addHeapObject(telemetry_parent), isLikeNone(open_progress_dispatch) ? 0 : addHeapObject(open_progress_dispatch));
+    return WasmSnapshotRestore.__wrap(ret);
 }
 
 /**
  * @param {Function | null} [telemetry_dispatch]
- * @param {Uint8Array | null} [snapshot]
+ * @param {any | null} [telemetry_parent]
+ * @param {any | null} [server]
+ * @param {Function | null} [open_progress_dispatch]
  * @returns {Promise<WasmLix>}
  */
-export function openMemoryFromSnapshot(telemetry_dispatch, snapshot) {
-    var ptr0 = isLikeNone(snapshot) ? 0 : passArray8ToWasm0(snapshot, wasm.__wbindgen_export);
-    var len0 = WASM_VECTOR_LEN;
-    const ret = wasm.openMemoryFromSnapshot(isLikeNone(telemetry_dispatch) ? 0 : addHeapObject(telemetry_dispatch), ptr0, len0);
+export function openMemory(telemetry_dispatch, telemetry_parent, server, open_progress_dispatch) {
+    const ret = wasm.openMemory(isLikeNone(telemetry_dispatch) ? 0 : addHeapObject(telemetry_dispatch), isLikeNone(telemetry_parent) ? 0 : addHeapObject(telemetry_parent), isLikeNone(server) ? 0 : addHeapObject(server), isLikeNone(open_progress_dispatch) ? 0 : addHeapObject(open_progress_dispatch));
     return takeObject(ret);
 }
 
 /**
- * @param {string} sql
- * @param {number} provided_param_count
- * @returns {any}
+ * @param {Function | null} [telemetry_dispatch]
+ * @param {any | null} [telemetry_parent]
+ * @param {Function | null} [open_progress_dispatch]
+ * @returns {WasmSnapshotRestore}
  */
-export function parseSqlScript(sql, provided_param_count) {
-    try {
-        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        const ptr0 = passStringToWasm0(sql, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.parseSqlScript(retptr, ptr0, len0, provided_param_count);
-        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-        if (r2) {
-            throw takeObject(r1);
-        }
-        return takeObject(r0);
-    } finally {
-        wasm.__wbindgen_add_to_stack_pointer(16);
-    }
+export function openMemoryFromSnapshot(telemetry_dispatch, telemetry_parent, open_progress_dispatch) {
+    const ret = wasm.openMemoryFromSnapshot(isLikeNone(telemetry_dispatch) ? 0 : addHeapObject(telemetry_dispatch), isLikeNone(telemetry_parent) ? 0 : addHeapObject(telemetry_parent), isLikeNone(open_progress_dispatch) ? 0 : addHeapObject(open_progress_dispatch));
+    return WasmSnapshotRestore.__wrap(ret);
+}
+
+/**
+ * @param {string} url
+ * @param {Function} fetch
+ * @param {any} headers
+ * @param {string | null} [initial_active_branch_id]
+ * @returns {Promise<WasmRemoteLix>}
+ */
+export function openRemote(url, fetch, headers, initial_active_branch_id) {
+    const ptr0 = passStringToWasm0(url, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len0 = WASM_VECTOR_LEN;
+    var ptr1 = isLikeNone(initial_active_branch_id) ? 0 : passStringToWasm0(initial_active_branch_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    var len1 = WASM_VECTOR_LEN;
+    const ret = wasm.openRemote(ptr0, len0, addHeapObject(fetch), addHeapObject(headers), ptr1, len1);
+    return takeObject(ret);
 }
 function __wbg_get_imports() {
     const import0 = {
@@ -362,10 +767,26 @@ function __wbg_get_imports() {
         __wbg__wbg_cb_unref_61db23ac97f16c31: function(arg0) {
             getObject(arg0)._wbg_cb_unref();
         },
-        __wbg_applyChanges_fa5b3bf30f8b61a3: function(arg0, arg1) {
-            const ret = getObject(arg0).applyChanges(takeObject(arg1));
+        __wbg_acquireSession_57f1f2cd5f681c2d: function(arg0) {
+            const ret = getObject(arg0).acquireSession();
+            return addHeapObject(ret);
+        },
+        __wbg_beginRead_1138c26c0b47afd3: function(arg0, arg1) {
+            const ret = getObject(arg0).beginRead(takeObject(arg1));
             return addHeapObject(ret);
         },
+        __wbg_beginScan_d935bfe04519622e: function(arg0, arg1, arg2, arg3) {
+            const ret = getObject(arg0).beginScan(takeObject(arg1), takeObject(arg2), takeObject(arg3));
+            return addHeapObject(ret);
+        },
+        __wbg_beginWrite_4d84cc1cbfc72fa9: function(arg0, arg1) {
+            const ret = getObject(arg0).beginWrite(takeObject(arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_call_40e4174f169eaca7: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3));
+            return addHeapObject(ret);
+        }, arguments); },
         __wbg_call_8a89609d89f6608a: function() { return handleError(function (arg0, arg1) {
             const ret = getObject(arg0).call(getObject(arg1));
             return addHeapObject(ret);
@@ -374,10 +795,33 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
             return addHeapObject(ret);
         }, arguments); },
-        __wbg_close_65d6792c6f40ad89: function(arg0) {
+        __wbg_changed_8b3c117efdd37fbf: function(arg0) {
+            const ret = getObject(arg0).changed();
+            return addHeapObject(ret);
+        },
+        __wbg_close_70069a5308f6a3d8: function(arg0) {
             const ret = getObject(arg0).close();
             return addHeapObject(ret);
         },
+        __wbg_close_eb44b04eda5115d4: function(arg0) {
+            getObject(arg0).close();
+        },
+        __wbg_commit_9dc6a608a8f559f7: function(arg0) {
+            const ret = getObject(arg0).commit();
+            return addHeapObject(ret);
+        },
+        __wbg_construct_e0f002bb615dbba1: function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.construct(getObject(arg0), getObject(arg1));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_deleteMany_15f48563982d361e: function(arg0, arg1, arg2) {
+            const ret = getObject(arg0).deleteMany(takeObject(arg1), takeObject(arg2));
+            return addHeapObject(ret);
+        },
+        __wbg_deleteRange_29b8dd1d129b1f8c: function(arg0, arg1, arg2) {
+            const ret = getObject(arg0).deleteRange(takeObject(arg1), takeObject(arg2));
+            return addHeapObject(ret);
+        },
         __wbg_done_60cf307fcc680536: function(arg0) {
             const ret = getObject(arg0).done;
             return ret;
@@ -401,6 +845,10 @@ function __wbg_get_imports() {
             const ret = Array.from(getObject(arg0));
             return addHeapObject(ret);
         },
+        __wbg_getMany_946bf213edc127f3: function(arg0, arg1) {
+            const ret = getObject(arg0).getMany(takeObject(arg1));
+            return addHeapObject(ret);
+        },
         __wbg_getRandomValues_3f44b700395062e5: function() { return handleError(function (arg0, arg1) {
             globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
         }, arguments); },
@@ -451,6 +899,16 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
+        __wbg_instanceof_Promise_d0db99486956c8e8: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Promise;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
         __wbg_instanceof_Uint8Array_86f30649f63ef9c2: function(arg0) {
             let result;
             try {
@@ -481,8 +939,8 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).length;
             return ret;
         },
-        __wbg_loadEntries_032470abc2177798: function(arg0) {
-            const ret = getObject(arg0).loadEntries();
+        __wbg_message_40300ed2d1f8bdc6: function(arg0) {
+            const ret = getObject(arg0).message;
             return addHeapObject(ret);
         },
         __wbg_new_0_445c13a750296eb6: function() {
@@ -505,6 +963,24 @@ function __wbg_get_imports() {
             const ret = new Map();
             return addHeapObject(ret);
         },
+        __wbg_new_b682b81e8eaaf027: function(arg0, arg1) {
+            try {
+                var state0 = {a: arg0, b: arg1};
+                var cb0 = (arg0, arg1) => {
+                    const a = state0.a;
+                    state0.a = 0;
+                    try {
+                        return __wasm_bindgen_func_elem_92637(a, state0.b, arg0, arg1);
+                    } finally {
+                        state0.a = a;
+                    }
+                };
+                const ret = new Promise(cb0);
+                return addHeapObject(ret);
+            } finally {
+                state0.a = 0;
+            }
+        },
         __wbg_new_ce1ab61c1c2b300d: function() {
             const ret = new Object();
             return addHeapObject(ret);
@@ -513,6 +989,10 @@ function __wbg_get_imports() {
             const ret = new Array();
             return addHeapObject(ret);
         },
+        __wbg_new_from_slice_18fa1f71286d66b8: function(arg0, arg1) {
+            const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        },
         __wbg_new_typed_bf31d18f92484486: function(arg0, arg1) {
             try {
                 var state0 = {a: arg0, b: arg1};
@@ -520,7 +1000,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return __wasm_bindgen_func_elem_119240(a, state0.b, arg0, arg1);
+                        return __wasm_bindgen_func_elem_92637(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -531,6 +1011,10 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         },
+        __wbg_nextPage_6902443bcbff10d3: function(arg0, arg1) {
+            const ret = getObject(arg0).nextPage(arg1 >>> 0);
+            return addHeapObject(ret);
+        },
         __wbg_next_9e03acdf51c4960d: function(arg0) {
             const ret = getObject(arg0).next;
             return addHeapObject(ret);
@@ -551,6 +1035,10 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).now();
             return ret;
         },
+        __wbg_of_57145fdec12d159f: function(arg0) {
+            const ret = Array.of(getObject(arg0));
+            return addHeapObject(ret);
+        },
         __wbg_performance_3fcf6e32a7e1ed0a: function(arg0) {
             const ret = getObject(arg0).performance;
             return addHeapObject(ret);
@@ -558,6 +1046,14 @@ function __wbg_get_imports() {
         __wbg_prototypesetcall_3249fc62a0fafa30: function(arg0, arg1, arg2) {
             Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
         },
+        __wbg_push_a6822215aa43e71c: function(arg0, arg1) {
+            const ret = getObject(arg0).push(getObject(arg1));
+            return ret;
+        },
+        __wbg_putMany_168141e3afba203c: function(arg0, arg1, arg2) {
+            const ret = getObject(arg0).putMany(takeObject(arg1), takeObject(arg2));
+            return addHeapObject(ret);
+        },
         __wbg_queueMicrotask_35c611f4a14830b2: function(arg0) {
             queueMicrotask(getObject(arg0));
         },
@@ -565,10 +1061,18 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).queueMicrotask;
             return addHeapObject(ret);
         },
+        __wbg_replaceMany_b2dc402a4ff6b772: function(arg0, arg1, arg2) {
+            const ret = getObject(arg0).replaceMany(takeObject(arg1), takeObject(arg2));
+            return addHeapObject(ret);
+        },
         __wbg_resolve_25a7e548d5881dca: function(arg0) {
             const ret = Promise.resolve(getObject(arg0));
             return addHeapObject(ret);
         },
+        __wbg_rollback_5632fb7c3f6f9b08: function(arg0) {
+            const ret = getObject(arg0).rollback();
+            return addHeapObject(ret);
+        },
         __wbg_set_52b1e1eb5bed906a: function(arg0, arg1, arg2) {
             const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
             return addHeapObject(ret);
@@ -609,6 +1113,10 @@ function __wbg_get_imports() {
             const ret = typeof window === 'undefined' ? null : window;
             return isLikeNone(ret) ? 0 : addHeapObject(ret);
         },
+        __wbg_stringify_8286df6dcc591521: function() { return handleError(function (arg0) {
+            const ret = JSON.stringify(getObject(arg0));
+            return addHeapObject(ret);
+        }, arguments); },
         __wbg_then_18f476d590e58992: function(arg0, arg1, arg2) {
             const ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
             return addHeapObject(ret);
@@ -633,37 +1141,58 @@ function __wbg_get_imports() {
             const ret = WasmObserveEvents.__wrap(arg0);
             return addHeapObject(ret);
         },
+        __wbg_wasmremotelix_new: function(arg0) {
+            const ret = WasmRemoteLix.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_wasmremotelixtransaction_new: function(arg0) {
+            const ret = WasmRemoteLixTransaction.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_wasmremoteobserveevents_new: function(arg0) {
+            const ret = WasmRemoteObserveEvents.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_watchForChanges_465d4036436d28da: function(arg0) {
+            const ret = getObject(arg0).watchForChanges();
+            return addHeapObject(ret);
+        },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 28366, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_119238);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 21338, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_92635);
             return addHeapObject(ret);
         },
-        __wbindgen_cast_0000000000000002: function(arg0) {
+        __wbindgen_cast_0000000000000002: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 1647, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_16813);
+            return addHeapObject(ret);
+        },
+        __wbindgen_cast_0000000000000003: function(arg0) {
             // Cast intrinsic for `F64 -> Externref`.
             const ret = arg0;
             return addHeapObject(ret);
         },
-        __wbindgen_cast_0000000000000003: function(arg0) {
+        __wbindgen_cast_0000000000000004: function(arg0) {
             // Cast intrinsic for `I64 -> Externref`.
             const ret = arg0;
             return addHeapObject(ret);
         },
-        __wbindgen_cast_0000000000000004: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000005: function(arg0, arg1) {
             // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
             const ret = getArrayU8FromWasm0(arg0, arg1);
             return addHeapObject(ret);
         },
-        __wbindgen_cast_0000000000000005: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000006: function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return addHeapObject(ret);
         },
-        __wbindgen_cast_0000000000000006: function(arg0) {
+        __wbindgen_cast_0000000000000007: function(arg0) {
             // Cast intrinsic for `U64 -> Externref`.
             const ret = BigInt.asUintN(64, arg0);
             return addHeapObject(ret);
         },
-        __wbindgen_cast_0000000000000007: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000008: function(arg0, arg1) {
             var v0 = getArrayU8FromWasm0(arg0, arg1).slice();
             wasm.__wbindgen_export4(arg0, arg1 * 1, 1);
             // Cast intrinsic for `Vector(U8) -> Externref`.
@@ -684,10 +1213,14 @@ function __wbg_get_imports() {
     };
 }
 
-function __wasm_bindgen_func_elem_119238(arg0, arg1, arg2) {
+function __wasm_bindgen_func_elem_16813(arg0, arg1) {
+    wasm.__wasm_bindgen_func_elem_16813(arg0, arg1);
+}
+
+function __wasm_bindgen_func_elem_92635(arg0, arg1, arg2) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.__wasm_bindgen_func_elem_119238(retptr, arg0, arg1, addHeapObject(arg2));
+        wasm.__wasm_bindgen_func_elem_92635(retptr, arg0, arg1, addHeapObject(arg2));
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         if (r1) {
@@ -698,8 +1231,8 @@ function __wasm_bindgen_func_elem_119238(arg0, arg1, arg2) {
     }
 }
 
-function __wasm_bindgen_func_elem_119240(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_119240(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wasm_bindgen_func_elem_92637(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_92637(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
 const WasmLixFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -711,6 +1244,21 @@ const WasmLixTransactionFinalization = (typeof FinalizationRegistry === 'undefin
 const WasmObserveEventsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmobserveevents_free(ptr, 1));
+const WasmRemoteLixFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmremotelix_free(ptr, 1));
+const WasmRemoteLixTransactionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmremotelixtransaction_free(ptr, 1));
+const WasmRemoteObserveEventsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmremoteobserveevents_free(ptr, 1));
+const WasmSnapshotExportFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmsnapshotexport_free(ptr, 1));
+const WasmSnapshotRestoreFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmsnapshotrestore_free(ptr, 1));
 
 function addHeapObject(obj) {
     if (heap_next === heap.length) heap.push(heap.length + 1);
@@ -992,26 +1540,6 @@ async function __wbg_load(module, imports) {
     }
 }
 
-function initSync(module) {
-    if (wasm !== undefined) return wasm;
-
-
-    if (module !== undefined) {
-        if (Object.getPrototypeOf(module) === Object.prototype) {
-            ({module} = module)
-        } else {
-            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
-        }
-    }
-
-    const imports = __wbg_get_imports();
-    if (!(module instanceof WebAssembly.Module)) {
-        module = new WebAssembly.Module(module);
-    }
-    const instance = new WebAssembly.Instance(module, imports);
-    return __wbg_finalize_init(instance, module);
-}
-
 async function __wbg_init(module_or_path) {
     if (wasm !== undefined) return wasm;
 
@@ -1038,4 +1566,4 @@ async function __wbg_init(module_or_path) {
     return __wbg_finalize_init(instance, module);
 }
 
-export { initSync, __wbg_init as default };
+export { __wbg_init as default };