@powersync/nuxt 0.0.0-dev-20260128023420

package/dist/runtime/pages/__powersync-inspector.vue

@@ -0,0 +1,153 @@
+<template>
+  <div
+    flex="~ justify-between"
+    border="b"
+    border-color="gray-100"
+    py="3"
+    mb="3"
+  >
+    <div flex="~ gap-2">
+      <NTip
+        :n="`${isConnected ? 'green' : isSyncing ? 'blue' : 'red'} xs`"
+        :icon="`${isConnected ? 'carbon:plug-filled' : isSyncing ? 'carbon:plug' : 'carbon:connection-signal-off'}`"
+      >
+        Powersync is
+        {{
+          isConnected ? "connected" : isSyncing ? "connecting..." : "disconnected"
+        }}
+      </NTip>
+      <NTip
+        :n="`${isSyncing ? 'blue' : hasSynced ? 'green' : 'yellow'} xs`"
+        :icon="`${isSyncing ? 'carbon:data-unreal' : hasSynced ? 'carbon:checkmark-filled' : 'carbon:async'}`"
+      >
+        {{ isSyncing ? "Syncing" : hasSynced ? "Synced" : "Not Synced" }}
+      </NTip>
+      <NTip
+        :n="`${isUploading ? 'green' : 'gray'} xs`"
+        :icon="isUploading ? 'carbon:cloud-upload' : 'carbon:pause-outline'"
+      >
+        {{ isUploading ? "Uploading" : "Upload Idle" }}
+      </NTip>
+      <NTip
+        :n="`${isDownloading ? 'green' : 'gray'} xs`"
+        :icon="isDownloading ? 'carbon:cloud-download' : 'carbon:pause-outline'"
+      >
+        {{ isDownloading ? "Downloading" : "Download Idle" }}
+      </NTip>
+      <NBadge
+        flex="~ gap-2 items-center"
+        n="gray xs"
+        icon="carbon:server-time"
+      >
+        Last Synced:
+        {{ lastSyncedFormatted }}
+      </NBadge>
+      <NBadge
+        flex="~ gap-2 items-center"
+        n="gray xs"
+        icon="carbon:user-admin"
+      >
+        Logged in as: {{ userID }}
+      </NBadge>
+    </div>
+
+    <div flex="~ gap-2">
+      <NButton
+        n="red sm"
+        icon="carbon:clean"
+        @click="resync"
+      >
+        Prune & Re-sync
+      </NButton>
+      <NDarkToggle />
+    </div>
+  </div>
+
+  <div flex="~ gap-4">
+    <NTip
+      v-if="downloadError || uploadError"
+      n="red sm"
+      mb="3"
+      icon="carbon:warning-hex-filled"
+    >
+      {{ downloadError?.message ?? uploadError?.message }}
+    </NTip>
+  </div>
+
+  <div
+    flex="~ gap-2"
+    mb="3"
+  >
+    <NSelectTabs
+      v-model="selectedTab"
+      n="amber6 dark:amber5"
+      cursor="pointer"
+      :options="tabs"
+      @update:model-value="handleTabChange"
+    />
+  </div>
+
+  <!-- switching tabs -->
+  <SyncStatusTab v-if="selectedTab === 'sync-status'" />
+  <DataInspectorTab v-if="selectedTab === 'data'" />
+  <ConfigInspectorTab v-if="selectedTab === 'config'" />
+  <BucketsInspectorTab v-if="selectedTab === 'buckets'" />
+  <LogsTab v-if="selectedTab === 'logs'" />
+  <PowerSyncInstanceTab v-if="selectedTab === 'powersync-instance'" />
+</template>
+
+<script setup>
+import { ref, onMounted, computed } from "vue";
+import { useTimeAgo } from "@vueuse/core";
+import { definePageMeta, usePowerSyncInspectorDiagnostics, useRoute, useRouter } from "#imports";
+import SyncStatusTab from "../components/SyncStatusTab.vue";
+import DataInspectorTab from "../components/DataInspectorTab.vue";
+import ConfigInspectorTab from "../components/ConfigInspectorTab.vue";
+import LogsTab from "../components/LogsTab.vue";
+import BucketsInspectorTab from "../components/BucketsInspectorTab.vue";
+import PowerSyncInstanceTab from "../components/PowerSyncInstanceTab.vue";
+definePageMeta({
+  layout: "powersync-inspector-layout"
+});
+const {
+  db,
+  isConnected,
+  isSyncing,
+  hasSynced,
+  isDownloading,
+  isUploading,
+  downloadError,
+  uploadError,
+  lastSyncedAt,
+  userID,
+  clearData
+} = usePowerSyncInspectorDiagnostics();
+onMounted(async () => {
+  await db.value?.waitForFirstSync();
+});
+const route = useRoute();
+const router = useRouter();
+const selectedTab = ref(route.query.tab || "sync-status");
+const handleTabChange = (tab) => {
+  router.push({ query: { tab } });
+};
+const tabs = [
+  { label: "Sync Status", value: "sync-status" },
+  { label: "Data Inspector", value: "data" },
+  { label: "Buckets Inspector", value: "buckets" },
+  { label: "Config Inspector", value: "config" },
+  { label: "Client Logs", value: "logs" }
+  // { label: 'PowerSync Instance', value: 'powersync-instance' },
+];
+const lastSyncedFormatted = computed(
+  () => lastSyncedAt.value ? useTimeAgo(new Date(lastSyncedAt.value)) : "NA"
+);
+const resync = async () => {
+  await clearData();
+  await db.value?.waitForFirstSync();
+};
+</script>
+
+<style>
+#__nuxt,#nuxt-test,body,html{background-color:transparent}
+</style>

package/dist/runtime/pages/__powersync-inspector.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/plugin.client.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/plugin.client.js

@@ -0,0 +1,11 @@
+import { defineNuxtPlugin, useRoute, useRuntimeConfig } from "#app";
+export default defineNuxtPlugin((nuxtApp) => {
+  const runtimeConfig = useRuntimeConfig();
+  nuxtApp.vueApp.config.globalProperties.$powerSyncModuleOptions = runtimeConfig.public.powerSyncModuleOptions;
+  const route = useRoute();
+  nuxtApp.hook("page:finish", () => {
+    if (route.path.startsWith("/__powersync-inspector")) {
+      import("virtual:uno.css");
+    }
+  });
+});

package/dist/runtime/utils/AppSchema.d.ts

@@ -0,0 +1,27 @@
+import { Schema, Table } from '@powersync/web';
+export declare const LOCAL_BUCKET_DATA_TABLE_NAME = "local_bucket_data";
+export declare const LOCAL_SCHEMA_TABLE_NAME = "local_schema";
+export declare const local_bucket_data: Table<{
+    total_operations: import("@powersync/common").BaseColumnType<number | null>;
+    last_op: import("@powersync/common").BaseColumnType<string | null>;
+    download_size: import("@powersync/common").BaseColumnType<number | null>;
+    downloaded_operations: import("@powersync/common").BaseColumnType<number | null>;
+    downloading: import("@powersync/common").BaseColumnType<number | null>;
+}>;
+export declare const local_schema: Table<{
+    data: import("@powersync/common").BaseColumnType<string | null>;
+}>;
+export declare const DiagnosticsAppSchema: Schema<{
+    local_bucket_data: Table<{
+        total_operations: import("@powersync/common").BaseColumnType<number | null>;
+        last_op: import("@powersync/common").BaseColumnType<string | null>;
+        download_size: import("@powersync/common").BaseColumnType<number | null>;
+        downloaded_operations: import("@powersync/common").BaseColumnType<number | null>;
+        downloading: import("@powersync/common").BaseColumnType<number | null>;
+    }>;
+    local_schema: Table<{
+        data: import("@powersync/common").BaseColumnType<string | null>;
+    }>;
+}>;
+export type Database = (typeof DiagnosticsAppSchema)['types'];
+export type LocalBucketData = Database['local_bucket_data'];

package/dist/runtime/utils/AppSchema.js

@@ -0,0 +1,23 @@
+import { column, Schema, Table } from "@powersync/web";
+export const LOCAL_BUCKET_DATA_TABLE_NAME = "local_bucket_data";
+export const LOCAL_SCHEMA_TABLE_NAME = "local_schema";
+export const local_bucket_data = new Table(
+  {
+    total_operations: column.integer,
+    last_op: column.text,
+    download_size: column.integer,
+    downloaded_operations: column.integer,
+    downloading: column.integer
+  },
+  { localOnly: true }
+);
+export const local_schema = new Table(
+  {
+    data: column.text
+  },
+  { localOnly: true }
+);
+export const DiagnosticsAppSchema = new Schema({
+  local_bucket_data,
+  local_schema
+});

package/dist/runtime/utils/DynamicSchemaManager.d.ts

@@ -0,0 +1,15 @@
+import type { DBAdapter, SyncDataBatch } from '@powersync/web';
+import { Schema } from '@powersync/web';
+/**
+ * Record fields from downloaded data, then build a schema from it.
+ */
+export declare class DynamicSchemaManager {
+    private tables;
+    private dirty;
+    constructor();
+    clear(): Promise<void>;
+    updateFromOperations(batch: SyncDataBatch): Promise<void>;
+    refreshSchema(db: DBAdapter): Promise<void>;
+    buildSchema(): Schema;
+    schemaToString(): string;
+}

package/dist/runtime/utils/DynamicSchemaManager.js

@@ -0,0 +1,91 @@
+import { Column, ColumnType, OpTypeEnum, Schema, Table } from "@powersync/web";
+import { DiagnosticsAppSchema as AppSchema } from "./AppSchema.js";
+import { JsSchemaGenerator } from "./JsSchemaGenerator.js";
+export class DynamicSchemaManager {
+  tables;
+  dirty = false;
+  constructor() {
+    const tables = localStorage.getItem("powersync_dynamic_schema");
+    this.tables = tables ? JSON.parse(tables) : {};
+  }
+  async clear() {
+    this.tables = {};
+    this.dirty = true;
+    localStorage.removeItem("powersync_dynamic_schema");
+  }
+  async updateFromOperations(batch) {
+    let schemaDirty = false;
+    for (const bucket of batch.buckets) {
+      for (const op of bucket.data) {
+        if (op.op.value == OpTypeEnum.PUT && op.data != null) {
+          this.tables[op.object_type] ??= {};
+          const table = this.tables[op.object_type];
+          const data = JSON.parse(op.data);
+          for (const [key, value] of Object.entries(data)) {
+            if (key == "id") {
+              continue;
+            }
+            if (table) {
+              const existing = table[key];
+              if (typeof value == "number" && Number.isInteger(value) && existing != ColumnType.REAL && existing != ColumnType.TEXT) {
+                if (table[key] != ColumnType.INTEGER) {
+                  schemaDirty = true;
+                }
+                table[key] = ColumnType.INTEGER;
+              } else if (typeof value == "number" && existing != ColumnType.TEXT) {
+                if (table[key] != ColumnType.REAL) {
+                  schemaDirty = true;
+                }
+                table[key] = ColumnType.REAL;
+              } else if (typeof value == "string") {
+                if (table[key] != ColumnType.TEXT) {
+                  schemaDirty = true;
+                }
+                table[key] = ColumnType.TEXT;
+              }
+            }
+          }
+        }
+      }
+    }
+    if (schemaDirty) {
+      localStorage.setItem(
+        "powersync_dynamic_schema",
+        JSON.stringify(this.tables)
+      );
+      this.dirty = true;
+    }
+  }
+  async refreshSchema(db) {
+    if (this.dirty) {
+      const json = this.buildSchema().toJSON();
+      await db.execute("SELECT powersync_replace_schema(?)", [
+        JSON.stringify(json)
+      ]);
+      this.dirty = false;
+    }
+  }
+  buildSchema() {
+    const base = AppSchema;
+    const tables = [...base.tables];
+    for (const [key, value] of Object.entries(this.tables)) {
+      const table = new Table({
+        name: key,
+        columns: Object.entries(value).map(
+          ([cname, ctype]) => new Column({
+            name: cname,
+            type: ctype
+          })
+        )
+      });
+      tables.push(table);
+    }
+    return new Schema(tables);
+  }
+  schemaToString() {
+    const filtered = this.buildSchema().tables.filter(
+      (table) => !table.localOnly
+    );
+    return new JsSchemaGenerator().generate(new Schema(filtered));
+  }
+}

package/dist/runtime/utils/JsSchemaGenerator.d.ts

@@ -0,0 +1,8 @@
+import type { Schema } from '@powersync/web';
+export declare class JsSchemaGenerator {
+    generate(schema: Schema): string;
+    private generateTables;
+    private generateTable;
+    private generateColumn;
+    private generateAppSchema;
+}

package/dist/runtime/utils/JsSchemaGenerator.js

@@ -0,0 +1,28 @@
+export class JsSchemaGenerator {
+  generate(schema) {
+    const tables = schema.tables;
+    return this.generateTables(tables) + "\n\n" + this.generateAppSchema(tables);
+  }
+  generateTables(tables) {
+    return tables.map((table) => this.generateTable(table.name, table.columns)).join("\n\n");
+  }
+  generateTable(name, columns) {
+    return `export const ${name} = new Table(
+  {
+    // id column (text) is automatically included
+    ${columns.map((column) => this.generateColumn(column)).join(",\n    ")}
+  },
+  { indexes: {} }
+);`;
+  }
+  generateColumn(column) {
+    return `${column.name}: column.${column.type.toLowerCase()}`;
+  }
+  generateAppSchema(tables) {
+    return `export const AppSchema = new Schema({
+  ${tables.map((table) => table.name).join(",\n  ")}
+});
+
+export type Database = (typeof AppSchema)['types'];`;
+  }
+}

package/dist/runtime/utils/NuxtPowerSyncDatabase.d.ts

@@ -0,0 +1,40 @@
+import { PowerSyncDatabase, type DisconnectAndClearOptions, type PowerSyncBackendConnector, type PowerSyncConnectionOptions, type RequiredAdditionalConnectionOptions, type StreamingSyncImplementation, type WebPowerSyncDatabaseOptions } from '@powersync/web';
+/**
+ * An extended PowerSync database class that includes diagnostic capabilities for use with the PowerSync Inspector.
+ *
+ * This class automatically configures diagnostics when `useDiagnostics: true` is set in the module configuration.
+ * It provides enhanced VFS support, schema management, and logging capabilities for the inspector.
+ *
+ * @example
+ * ```typescript
+ * import { NuxtPowerSyncDatabase } from '@powersync/nuxt'
+ *
+ * const db = new NuxtPowerSyncDatabase({
+ *   database: {
+ *     dbFilename: 'your-db-filename.sqlite',
+ *   },
+ *   schema: yourSchema,
+ * })
+ * ```
+ *
+ * @remarks
+ * - When diagnostics are enabled, automatically uses cooperative sync VFS for improved compatibility
+ * - Stores connector internally for inspector access
+ * - Integrates with dynamic schema management for inspector features
+ * - Automatically configures logging when diagnostics are enabled
+ * - When diagnostics are disabled, behaves like a standard `PowerSyncDatabase`
+ */
+export declare class NuxtPowerSyncDatabase extends PowerSyncDatabase {
+    private schemaManager;
+    private _connector;
+    private _connectionOptions;
+    private useDiagnostics;
+    get dbOptions(): WebPowerSyncDatabaseOptions;
+    get connector(): PowerSyncBackendConnector | null;
+    get connectionOptions(): PowerSyncConnectionOptions | null;
+    constructor(options: WebPowerSyncDatabaseOptions);
+    protected generateSyncStreamImplementation(connector: PowerSyncBackendConnector, options: RequiredAdditionalConnectionOptions): StreamingSyncImplementation;
+    connect(connector: PowerSyncBackendConnector, options?: PowerSyncConnectionOptions): Promise<void>;
+    disconnect(): Promise<void>;
+    disconnectAndClear(options?: DisconnectAndClearOptions): Promise<void>;
+}

package/dist/runtime/utils/NuxtPowerSyncDatabase.js

@@ -0,0 +1,117 @@
+import {
+  DEFAULT_SYNC_CLIENT_IMPLEMENTATION,
+  PowerSyncDatabase,
+  Schema,
+  SharedWebStreamingSyncImplementation,
+  SyncClientImplementation,
+  WebRemote,
+  WebStreamingSyncImplementation
+} from "@powersync/web";
+import { RecordingStorageAdapter } from "./RecordingStorageAdapter.js";
+import { usePowerSyncInspector } from "../composables/usePowerSyncInspector.js";
+import { useDiagnosticsLogger } from "../composables/useDiagnosticsLogger.js";
+import { ref } from "vue";
+import { useRuntimeConfig } from "#app";
+import { RustClientInterceptor } from "./RustClientInterceptor.js";
+export class NuxtPowerSyncDatabase extends PowerSyncDatabase {
+  schemaManager;
+  _connector = null;
+  _connectionOptions = null;
+  useDiagnostics = false;
+  get dbOptions() {
+    return this.options;
+  }
+  get connector() {
+    return this._connector ?? super.connector;
+  }
+  get connectionOptions() {
+    return this._connectionOptions ?? super.connectionOptions;
+  }
+  constructor(options) {
+    const useDiagnostics = useRuntimeConfig().public.powerSyncModuleOptions.useDiagnostics ?? false;
+    if (useDiagnostics) {
+      const { logger } = useDiagnosticsLogger();
+      const { getCurrentSchemaManager, diagnosticsSchema } = usePowerSyncInspector();
+      const currentSchemaManager = getCurrentSchemaManager();
+      options.flags = {
+        ...options.flags,
+        enableMultiTabs: true,
+        broadcastLogs: true
+      };
+      options.logger = logger;
+      options.schema = new Schema([...options.schema.tables, ...diagnosticsSchema.tables]);
+      super(options);
+      this.schemaManager = currentSchemaManager;
+      this.useDiagnostics = true;
+    } else {
+      super(options);
+      this.useDiagnostics = false;
+    }
+  }
+  generateSyncStreamImplementation(connector, options) {
+    if (this.useDiagnostics) {
+      const { logger } = useDiagnosticsLogger();
+      const { getCurrentSchemaManager } = usePowerSyncInspector();
+      const currentSchemaManager = getCurrentSchemaManager();
+      const schemaManager = currentSchemaManager || this.schemaManager;
+      const clientImplementation = this.connectionOptions?.clientImplementation ?? DEFAULT_SYNC_CLIENT_IMPLEMENTATION;
+      const adapter = clientImplementation === SyncClientImplementation.RUST ? new RustClientInterceptor(
+        ref(this),
+        new WebRemote(connector, logger),
+        ref(schemaManager)
+      ) : new RecordingStorageAdapter(
+        ref(this),
+        ref(schemaManager)
+      );
+      if (this.options.flags?.enableMultiTabs) {
+        if (!this.resolvedFlags.broadcastLogs) {
+          const warning = `
+            Multiple tabs are enabled, but broadcasting of logs is disabled.
+            Logs for shared sync worker will only be available in the shared worker context
+          `;
+          logger ? logger.warn(warning) : console.warn(warning);
+        }
+        return new SharedWebStreamingSyncImplementation({
+          ...options,
+          adapter,
+          remote: new WebRemote(connector, logger),
+          uploadCrud: async () => {
+            await this.waitForReady();
+            await connector.uploadData(this);
+          },
+          logger,
+          db: this.database
+        });
+      } else {
+        return new WebStreamingSyncImplementation({
+          ...options,
+          adapter,
+          remote: new WebRemote(connector, logger),
+          uploadCrud: async () => {
+            await this.waitForReady();
+            await connector.uploadData(this);
+          },
+          identifier: "dbFilename" in this.options.database ? this.options.database.dbFilename : "diagnostics-sync",
+          logger
+        });
+      }
+    } else {
+      return super.generateSyncStreamImplementation(connector, options);
+    }
+  }
+  async connect(connector, options) {
+    this._connector = connector;
+    this._connectionOptions = options ?? null;
+    await super.connect(connector, options);
+  }
+  async disconnect() {
+    this._connector = null;
+    this._connectionOptions = null;
+    await super.disconnect();
+  }
+  async disconnectAndClear(options) {
+    this._connector = null;
+    this._connectionOptions = null;
+    await super.disconnectAndClear(options);
+  }
+}

package/dist/runtime/utils/RecordingStorageAdapter.d.ts

@@ -0,0 +1,13 @@
+import type { Checkpoint, ColumnType, PowerSyncDatabase, SyncDataBatch } from '@powersync/web';
+import { SqliteBucketStorage } from '@powersync/web';
+import type { DynamicSchemaManager } from './DynamicSchemaManager.js';
+import type { Ref } from 'vue';
+export declare class RecordingStorageAdapter extends SqliteBucketStorage {
+    private rdb;
+    private schemaManager;
+    tables: Record<string, Record<string, ColumnType>>;
+    constructor(db: Ref<PowerSyncDatabase>, schemaManager: Ref<DynamicSchemaManager>);
+    setTargetCheckpoint(checkpoint: Checkpoint): Promise<void>;
+    syncLocalDatabase(checkpoint: Checkpoint, priority?: number): Promise<import("@powersync/common").SyncLocalDatabaseResult>;
+    saveSyncData(batch: SyncDataBatch): Promise<void>;
+}

package/dist/runtime/utils/RecordingStorageAdapter.js

@@ -0,0 +1,76 @@
+import { AbstractPowerSyncDatabase, SqliteBucketStorage } from "@powersync/web";
+export class RecordingStorageAdapter extends SqliteBucketStorage {
+  rdb;
+  schemaManager;
+  tables = {};
+  constructor(db, schemaManager) {
+    super(
+      db.value.database,
+      AbstractPowerSyncDatabase.transactionMutex
+    );
+    this.rdb = db.value.database;
+    this.schemaManager = schemaManager.value;
+  }
+  async setTargetCheckpoint(checkpoint) {
+    await super.setTargetCheckpoint(checkpoint);
+    await this.rdb.writeTransaction(async (tx) => {
+      for (const bucket of checkpoint.buckets) {
+        await tx.execute(
+          `INSERT OR REPLACE INTO local_bucket_data(id, total_operations, last_op, download_size, downloading, downloaded_operations)
+             VALUES (
+              ?,
+              ?,
+              IFNULL((SELECT last_op FROM local_bucket_data WHERE id = ?), '0'),
+              IFNULL((SELECT download_size FROM local_bucket_data WHERE id = ?), 0),
+              IFNULL((SELECT downloading FROM local_bucket_data WHERE id = ?), TRUE),
+              IFNULL((SELECT downloaded_operations FROM local_bucket_data WHERE id = ?), TRUE)
+              )`,
+          [
+            bucket.bucket,
+            bucket.count,
+            bucket.bucket,
+            bucket.bucket,
+            bucket.bucket,
+            bucket.bucket
+          ]
+        );
+      }
+    });
+  }
+  async syncLocalDatabase(checkpoint, priority) {
+    const r = await super.syncLocalDatabase(checkpoint, priority);
+    setTimeout(() => {
+      this.schemaManager.refreshSchema(this.rdb);
+    }, 60);
+    if (r.checkpointValid) {
+      await this.rdb.execute(
+        "UPDATE local_bucket_data SET downloading = FALSE"
+      );
+    }
+    return r;
+  }
+  async saveSyncData(batch) {
+    await super.saveSyncData(batch);
+    await this.rdb.writeTransaction(async (tx) => {
+      for (const bucket of batch.buckets) {
+        const size = JSON.stringify(bucket.data).length;
+        await tx.execute(
+          `UPDATE local_bucket_data SET
+                download_size = IFNULL(download_size, 0) + ?,
+                last_op = ?,
+                downloading = ?,
+                downloaded_operations = IFNULL(downloaded_operations, 0) + ?
+              WHERE id = ?`,
+          [
+            size,
+            bucket.next_after,
+            bucket.has_more,
+            bucket.data.length,
+            bucket.bucket
+          ]
+        );
+      }
+    });
+    await this.schemaManager.updateFromOperations(batch);
+  }
+}

package/dist/runtime/utils/RustClientInterceptor.d.ts

@@ -0,0 +1,24 @@
+import type { AbstractRemote, ColumnType, PowerSyncDatabase } from '@powersync/web';
+import { PowerSyncControlCommand, SqliteBucketStorage } from '@powersync/web';
+import type { DynamicSchemaManager } from './DynamicSchemaManager.js';
+import type { Ref } from 'vue';
+/**
+ * Tracks per-byte and per-operation progress for the Rust client.
+ *
+ * While per-operation progress is reported by the SDK as well, we need those counters for each bucket. Since that
+ * information is internal to the Rust client and inaccessible to JavaScript, this intercepts the raw
+ * `powersync_control` calls to decode sync lines and derive progress information.
+ */
+export declare class RustClientInterceptor extends SqliteBucketStorage {
+    private remote;
+    private schemaManager;
+    private rdb;
+    private lastStartedCheckpoint;
+    tables: Record<string, Record<string, ColumnType>>;
+    constructor(db: Ref<PowerSyncDatabase>, remote: AbstractRemote, schemaManager: Ref<DynamicSchemaManager>);
+    control(op: PowerSyncControlCommand, payload: string | Uint8Array | ArrayBuffer | null): Promise<string>;
+    private processTextLine;
+    private processBinaryLine;
+    private processParsedLine;
+    private trackCheckpoint;
+}