@powersync/common 0.0.0-dev-20260503073249 → 0.0.0-dev-20260630141119

package/dist/index.d.cts

@@ -1,4391 +0,0 @@
-import Logger, { ILogger, ILogLevel } from 'js-logger';
-export { GlobalLogger, ILogHandler, ILogLevel, ILogger, ILoggerOpts } from 'js-logger';
-import { BSON } from 'bson';
-import { fetch } from 'cross-fetch';
-
-interface Disposable {
-    dispose: () => Promise<void> | void;
-}
-type BaseListener = Record<string, ((...event: any) => any) | undefined>;
-interface BaseObserverInterface<T extends BaseListener> {
-    registerListener(listener: Partial<T>): () => void;
-}
-declare class BaseObserver<T extends BaseListener = BaseListener> implements BaseObserverInterface<T> {
-    protected listeners: Set<Partial<T>>;
-    constructor();
-    dispose(): void;
-    /**
-     * Register a listener for updates to the PowerSync client.
-     */
-    registerListener(listener: Partial<T>): () => void;
-    iterateListeners(cb: (listener: Partial<T>) => any): void;
-    iterateAsyncListeners(cb: (listener: Partial<T>) => Promise<any>): Promise<void>;
-}
-
-/**
- * Set of generic interfaces to allow PowerSync compatibility with
- * different SQLite DB implementations.
- */
-
-/**
- * TODO most of these types could be exported to a common `types` package
- * which is used by the DB adapter libraries as well.
- */
-/**
- * Object returned by SQL Query executions.
- */
-type QueryResult = {
-    /** Represents the auto-generated row id if applicable. */
-    insertId?: number;
-    /**
-     * Number of affected rows reported by SQLite for a write query.
-     *
-     * When using the default client-side [JSON-based view system](https://docs.powersync.com/architecture/client-architecture#client-side-schema-and-sqlite-database-structure),
-     * `rowsAffected` may be `0` for successful `UPDATE` and `DELETE` statements.
-     * Use a `RETURNING` clause and inspect `rows` when you need to confirm which rows changed.
-     */
-    rowsAffected: number;
-    /** if status is undefined or 0 this object will contain the query results */
-    rows?: {
-        /** Raw array with all dataset */
-        _array: any[];
-        /** The length of the dataset */
-        length: number;
-        /** A convenience function to acess the index based the row object
-         * @param idx the row index
-         * @returns the row structure identified by column names
-         */
-        item: (idx: number) => any;
-    };
-};
-interface DBGetUtils {
-    /** Execute a read-only query and return results. */
-    getAll<T>(sql: string, parameters?: any[]): Promise<T[]>;
-    /** Execute a read-only query and return the first result, or null if the ResultSet is empty. */
-    getOptional<T>(sql: string, parameters?: any[]): Promise<T | null>;
-    /** Execute a read-only query and return the first result, error if the ResultSet is empty. */
-    get<T>(sql: string, parameters?: any[]): Promise<T>;
-}
-interface SqlExecutor {
-    /** Execute a single write statement. */
-    execute: (query: string, params?: any[] | undefined) => Promise<QueryResult>;
-    /**
-     * Execute a single write statement and return raw results.
-     * Unlike `execute`, which returns an object with structured key-value pairs,
-     * `executeRaw` returns a nested array of raw values, where each row is
-     * represented as an array of column values without field names.
-     *
-     * Example result:
-     *
-     * ```[ [ '1', 'list 1', '33', 'Post content', '1' ] ]```
-     *
-     * Where as `execute`'s `rows._array` would have been:
-     *
-     * ```[ { id: '33', name: 'list 1', content: 'Post content', list_id: '1' } ]```
-     */
-    executeRaw: (query: string, params?: any[] | undefined) => Promise<any[][]>;
-    executeBatch: (query: string, params?: any[][]) => Promise<QueryResult>;
-}
-interface LockContext extends SqlExecutor, DBGetUtils {
-}
-/**
- * Implements {@link DBGetUtils} on a {@link SqlRunner}.
- */
-declare function DBGetUtilsDefaultMixin<TBase extends new (...args: any[]) => Omit<SqlExecutor, 'executeBatch'>>(Base: TBase): {
-    new (...args: any[]): {
-        getAll<T>(sql: string, parameters?: any[]): Promise<T[]>;
-        getOptional<T>(sql: string, parameters?: any[]): Promise<T | null>;
-        get<T>(sql: string, parameters?: any[]): Promise<T>;
-        executeBatch(query: string, params?: any[][]): Promise<QueryResult>;
-        execute: (query: string, params?: any[] | undefined) => Promise<QueryResult>;
-        executeRaw: (query: string, params?: any[] | undefined) => Promise<any[][]>;
-    };
-} & TBase;
-interface Transaction extends LockContext {
-    /** Commit multiple changes to the local DB using the Transaction context. */
-    commit: () => Promise<QueryResult>;
-    /** Roll back multiple attempted changes using the Transaction context. */
-    rollback: () => Promise<QueryResult>;
-}
-/**
- * Update table operation numbers from SQLite
- */
-declare enum RowUpdateType {
-    SQLITE_INSERT = 18,
-    SQLITE_DELETE = 9,
-    SQLITE_UPDATE = 23
-}
-interface TableUpdateOperation {
-    opType: RowUpdateType;
-    rowId: number;
-}
-/**
- * Notification of an update to one or more tables, for the purpose of realtime change notifications.
- */
-interface UpdateNotification extends TableUpdateOperation {
-    table: string;
-}
-interface BatchedUpdateNotification {
-    rawUpdates: UpdateNotification[];
-    tables: string[];
-    groupedUpdates: Record<string, TableUpdateOperation[]>;
-}
-interface DBAdapterListener extends BaseListener {
-    /**
-     * Listener for table updates.
-     * Allows for single table updates in order to maintain API compatibility
-     * without the need for a major version bump
-     * The DB adapter can also batch update notifications if supported.
-     */
-    tablesUpdated: (updateNotification: BatchedUpdateNotification | UpdateNotification) => void;
-}
-interface DBLockOptions {
-    timeoutMs?: number;
-}
-interface ConnectionPool extends BaseObserverInterface<DBAdapterListener> {
-    name: string;
-    close: () => void | Promise<void>;
-    readLock: <T>(fn: (tx: LockContext) => Promise<T>, options?: DBLockOptions) => Promise<T>;
-    writeLock: <T>(fn: (tx: LockContext) => Promise<T>, options?: DBLockOptions) => Promise<T>;
-    /**
-     * This method refreshes the schema information across all connections. This is for advanced use cases, and should generally not be needed.
-     */
-    refreshSchema: () => Promise<void>;
-}
-interface DBAdapter extends ConnectionPool, SqlExecutor, DBGetUtils {
-    readTransaction: <T>(fn: (tx: Transaction) => Promise<T>, options?: DBLockOptions) => Promise<T>;
-    writeTransaction: <T>(fn: (tx: Transaction) => Promise<T>, options?: DBLockOptions) => Promise<T>;
-}
-/**
- * A mixin to implement {@link DBAdapter} by delegating to {@link ConnectionPool.readLock} and
- * {@link ConnectionPool.writeLock}.
- */
-declare function DBAdapterDefaultMixin<TBase extends new (...args: any[]) => ConnectionPool>(Base: TBase): {
-    new (...args: any[]): {
-        readTransaction<T>(fn: (tx: Transaction) => Promise<T>, options?: DBLockOptions): Promise<T>;
-        writeTransaction<T>(fn: (tx: Transaction) => Promise<T>, options?: DBLockOptions): Promise<T>;
-        getAll<T>(sql: string, parameters?: any[]): Promise<T[]>;
-        getOptional<T>(sql: string, parameters?: any[]): Promise<T | null>;
-        get<T>(sql: string, parameters?: any[]): Promise<T>;
-        execute(query: string, params?: any[]): Promise<QueryResult>;
-        executeRaw(query: string, params?: any[]): Promise<any[][]>;
-        executeBatch(query: string, params?: any[][]): Promise<QueryResult>;
-        name: string;
-        close: () => void | Promise<void>;
-        readLock: <T>(fn: (tx: LockContext) => Promise<T>, options?: DBLockOptions) => Promise<T>;
-        writeLock: <T>(fn: (tx: LockContext) => Promise<T>, options?: DBLockOptions) => Promise<T>;
-        /**
-         * This method refreshes the schema information across all connections. This is for advanced use cases, and should generally not be needed.
-         */
-        refreshSchema: () => Promise<void>;
-        registerListener(listener: Partial<DBAdapterListener>): () => void;
-    };
-} & TBase;
-declare function isBatchedUpdateNotification(update: BatchedUpdateNotification | UpdateNotification): update is BatchedUpdateNotification;
-declare function extractTableUpdates(update: BatchedUpdateNotification | UpdateNotification): string[];
-
-/**
- * 64-bit unsigned integer stored as a string in base-10.
- *
- * Not sortable as a string.
- */
-type OpId = string;
-/**
- * Type of local change.
- */
-declare enum UpdateType {
-    /** Insert or replace existing row. All non-null columns are included in the data. Generated by INSERT statements. */
-    PUT = "PUT",
-    /** Update existing row. Contains the id, and value of each changed column. Generated by UPDATE statements. */
-    PATCH = "PATCH",
-    /** Delete existing row. Contains the id. Generated by DELETE statements. */
-    DELETE = "DELETE"
-}
-type CrudEntryJSON = {
-    id: string;
-    data: string;
-    tx_id?: number;
-};
-/**
- * The output JSON seems to be a third type of JSON, not the same as the input JSON.
- */
-type CrudEntryOutputJSON = {
-    op_id: number;
-    op: UpdateType;
-    type: string;
-    id: string;
-    tx_id?: number;
-    data?: Record<string, any>;
-    old?: Record<string, any>;
-    metadata?: string;
-};
-/**
- * A single client-side change.
- */
-declare class CrudEntry {
-    /**
-     * Auto-incrementing client-side id.
-     */
-    clientId: number;
-    /**
-     * ID of the changed row.
-     */
-    id: string;
-    /**
-     * Type of change.
-     */
-    op: UpdateType;
-    /**
-     * Data associated with the change.
-     */
-    opData?: Record<string, any>;
-    /**
-     * For tables where the `trackPreviousValues` option has been enabled, this tracks previous values for
-     * `UPDATE` and `DELETE` statements.
-     */
-    previousValues?: Record<string, any>;
-    /**
-     * Table that contained the change.
-     */
-    table: string;
-    /**
-     * Auto-incrementing transaction id. This is the same for all operations within the same transaction.
-     */
-    transactionId?: number;
-    /**
-     * Client-side metadata attached with this write.
-     *
-     * This field is only available when the `trackMetadata` option was set to `true` when creating a table
-     * and the insert or update statement set the `_metadata` column.
-     */
-    metadata?: string;
-    static fromRow(dbRow: CrudEntryJSON): CrudEntry;
-    constructor(clientId: number, op: UpdateType, table: string, id: string, transactionId?: number, opData?: Record<string, any>, previousValues?: Record<string, any>, metadata?: string);
-    /**
-     * Converts the change to JSON format.
-     */
-    toJSON(): CrudEntryOutputJSON;
-    equals(entry: CrudEntry): boolean;
-    /**
-     * The hash code for this object.
-     * @deprecated This should not be necessary in the JS SDK.
-     * Use the  @see CrudEntry#equals method instead.
-     * TODO remove in the next major release.
-     */
-    hashCode(): string;
-    /**
-     * Generates an array for use in deep comparison operations
-     */
-    toComparisonArray(): (string | number | Record<string, any> | undefined)[];
-}
-
-/**
- * A batch of client-side changes.
- */
-declare class CrudBatch {
-    /**
-     * List of client-side changes.
-     */
-    crud: CrudEntry[];
-    /**
-     * true if there are more changes in the local queue.
-     */
-    haveMore: boolean;
-    /**
-     * Call to remove the changes from the local queue, once successfully uploaded.
-     */
-    complete: (writeCheckpoint?: string) => Promise<void>;
-    constructor(
-    /**
-     * List of client-side changes.
-     */
-    crud: CrudEntry[], 
-    /**
-     * true if there are more changes in the local queue.
-     */
-    haveMore: boolean, 
-    /**
-     * Call to remove the changes from the local queue, once successfully uploaded.
-     */
-    complete: (writeCheckpoint?: string) => Promise<void>);
-}
-
-declare enum OpTypeEnum {
-    CLEAR = 1,
-    MOVE = 2,
-    PUT = 3,
-    REMOVE = 4
-}
-type OpTypeJSON = string;
-/**
- * Used internally for sync buckets.
- */
-declare class OpType {
-    value: OpTypeEnum;
-    static fromJSON(jsonValue: OpTypeJSON): OpType;
-    constructor(value: OpTypeEnum);
-    toJSON(): string;
-}
-
-interface OplogEntryJSON {
-    checksum: number;
-    data?: string;
-    object_id?: string;
-    object_type?: string;
-    op_id: string;
-    op: OpTypeJSON;
-    subkey?: string;
-}
-declare class OplogEntry {
-    op_id: OpId;
-    op: OpType;
-    checksum: number;
-    subkey?: string | undefined;
-    object_type?: string | undefined;
-    object_id?: string | undefined;
-    data?: string | undefined;
-    static fromRow(row: OplogEntryJSON): OplogEntry;
-    constructor(op_id: OpId, op: OpType, checksum: number, subkey?: string | undefined, object_type?: string | undefined, object_id?: string | undefined, data?: string | undefined);
-    toJSON(fixedKeyEncoding?: boolean): OplogEntryJSON;
-}
-
-type SyncDataBucketJSON = {
-    bucket: string;
-    has_more?: boolean;
-    after?: string;
-    next_after?: string;
-    data: OplogEntryJSON[];
-};
-declare class SyncDataBucket {
-    bucket: string;
-    data: OplogEntry[];
-    /**
-     * True if the response does not contain all the data for this bucket, and another request must be made.
-     */
-    has_more: boolean;
-    /**
-     * The `after` specified in the request.
-     */
-    after?: OpId | undefined;
-    /**
-     * Use this for the next request.
-     */
-    next_after?: OpId | undefined;
-    static fromRow(row: SyncDataBucketJSON): SyncDataBucket;
-    constructor(bucket: string, data: OplogEntry[], 
-    /**
-     * True if the response does not contain all the data for this bucket, and another request must be made.
-     */
-    has_more: boolean, 
-    /**
-     * The `after` specified in the request.
-     */
-    after?: OpId | undefined, 
-    /**
-     * Use this for the next request.
-     */
-    next_after?: OpId | undefined);
-    toJSON(fixedKeyEncoding?: boolean): SyncDataBucketJSON;
-}
-
-declare class SyncDataBatch {
-    buckets: SyncDataBucket[];
-    static fromJSON(json: any): SyncDataBatch;
-    constructor(buckets: SyncDataBucket[]);
-}
-
-interface BucketDescription {
-    name: string;
-    priority: number;
-}
-interface Checkpoint {
-    last_op_id: OpId;
-    buckets: BucketChecksum[];
-    write_checkpoint?: string;
-    streams?: any[];
-}
-interface BucketState {
-    bucket: string;
-    op_id: string;
-}
-interface ChecksumCache {
-    checksums: Map<string, {
-        checksum: BucketChecksum;
-        last_op_id: OpId;
-    }>;
-    lastOpId: OpId;
-}
-interface SyncLocalDatabaseResult {
-    ready: boolean;
-    checkpointValid: boolean;
-    checkpointFailures?: string[];
-}
-type SavedProgress = {
-    atLast: number;
-    sinceLast: number;
-};
-type BucketOperationProgress = Record<string, SavedProgress>;
-interface BucketChecksum {
-    bucket: string;
-    priority?: number;
-    /**
-     * 32-bit unsigned hash.
-     */
-    checksum: number;
-    /**
-     * Count of operations - informational only.
-     */
-    count?: number;
-    /**
-     * The JavaScript client does not use this field, which is why it's defined to be `any`. We rely on the structure of
-     * this interface to pass custom `BucketChecksum`s to the Rust client in unit tests, which so all fields need to be
-     * present.
-     */
-    subscriptions?: any;
-}
-declare enum PSInternalTable {
-    DATA = "ps_data",
-    CRUD = "ps_crud",
-    BUCKETS = "ps_buckets",
-    OPLOG = "ps_oplog",
-    UNTYPED = "ps_untyped"
-}
-declare enum PowerSyncControlCommand {
-    PROCESS_TEXT_LINE = "line_text",
-    PROCESS_BSON_LINE = "line_binary",
-    STOP = "stop",
-    START = "start",
-    NOTIFY_TOKEN_REFRESHED = "refreshed_token",
-    NOTIFY_CRUD_UPLOAD_COMPLETED = "completed_upload",
-    UPDATE_SUBSCRIPTIONS = "update_subscriptions"
-}
-interface BucketStorageListener extends BaseListener {
-    crudUpdate: () => void;
-}
-interface BucketStorageAdapter extends BaseObserverInterface<BucketStorageListener>, Disposable {
-    init(): Promise<void>;
-    saveSyncData(batch: SyncDataBatch, fixedKeyFormat?: boolean): Promise<void>;
-    removeBuckets(buckets: string[]): Promise<void>;
-    setTargetCheckpoint(checkpoint: Checkpoint): Promise<void>;
-    startSession(): void;
-    getBucketStates(): Promise<BucketState[]>;
-    getBucketOperationProgress(): Promise<BucketOperationProgress>;
-    hasMigratedSubkeys(): Promise<boolean>;
-    migrateToFixedSubkeys(): Promise<void>;
-    syncLocalDatabase(checkpoint: Checkpoint, priority?: number): Promise<{
-        checkpointValid: boolean;
-        ready: boolean;
-        failures?: any[];
-    }>;
-    nextCrudItem(): Promise<CrudEntry | undefined>;
-    hasCrud(): Promise<boolean>;
-    getCrudBatch(limit?: number): Promise<CrudBatch | null>;
-    hasCompletedSync(): Promise<boolean>;
-    updateLocalTarget(cb: () => Promise<string>): Promise<boolean>;
-    getMaxOpId(): string;
-    /**
-     * Get an unique client id.
-     */
-    getClientId(): Promise<string>;
-    /**
-     * Invokes the `powersync_control` function for the sync client.
-     */
-    control(op: PowerSyncControlCommand, payload: string | Uint8Array | null): Promise<string>;
-}
-
-interface PowerSyncCredentials {
-    endpoint: string;
-    token: string;
-    expiresAt?: Date;
-}
-
-/**
- * For sync2.json
- */
-interface ContinueCheckpointRequest {
-    /**
-     * Existing bucket states. Only these buckets are synchronized.
-     */
-    buckets: BucketRequest[];
-    checkpoint_token: string;
-    limit?: number;
-}
-interface SyncNewCheckpointRequest {
-    /**
-     * Existing bucket states. Used if include_data is specified.
-     */
-    buckets?: BucketRequest[];
-    request_checkpoint: {
-        /**
-         * Whether or not to include an initial data request.
-         */
-        include_data: boolean;
-        /**
-         * Whether or not to compute a checksum.
-         */
-        include_checksum: boolean;
-    };
-    limit?: number;
-}
-type SyncRequest = ContinueCheckpointRequest | SyncNewCheckpointRequest;
-interface SyncResponse {
-    /**
-     * Data for the buckets returned. May not have an an entry for each bucket in the request.
-     */
-    data?: SyncDataBucketJSON[];
-    /**
-     * True if the response limit has been reached, and another request must be made.
-     */
-    has_more: boolean;
-    checkpoint_token?: string;
-    checkpoint?: Checkpoint;
-}
-type JSONValue = string | number | boolean | null | undefined | JSONObject | JSONArray;
-interface JSONObject {
-    [key: string]: JSONValue;
-}
-type JSONArray = JSONValue[];
-type StreamingSyncRequestParameterType = JSONValue;
-interface StreamingSyncRequest {
-    /**
-     * Existing bucket states.
-     */
-    buckets?: BucketRequest[];
-    /**
-     * If specified, limit the response to only include these buckets.
-     */
-    only?: string[];
-    /**
-     * Whether or not to compute a checksum for each checkpoint
-     */
-    include_checksum: boolean;
-    /**
-     * Changes the response to stringified data in each OplogEntry
-     */
-    raw_data: boolean;
-    /**
-     * Client parameters to be passed to the sync rules.
-     */
-    parameters?: Record<string, StreamingSyncRequestParameterType>;
-    /**
-     * Application metadata to be included in service logs.
-     */
-    app_metadata?: Record<string, string>;
-    client_id?: string;
-}
-interface StreamingSyncCheckpoint {
-    checkpoint: Checkpoint;
-}
-interface StreamingSyncCheckpointDiff {
-    checkpoint_diff: {
-        last_op_id: OpId;
-        updated_buckets: BucketChecksum[];
-        removed_buckets: string[];
-        write_checkpoint?: string;
-    };
-}
-interface StreamingSyncDataJSON {
-    data: SyncDataBucketJSON;
-}
-interface StreamingSyncCheckpointComplete {
-    checkpoint_complete: {
-        last_op_id: OpId;
-    };
-}
-interface StreamingSyncCheckpointPartiallyComplete {
-    partial_checkpoint_complete: {
-        priority: number;
-        last_op_id: OpId;
-    };
-}
-interface StreamingSyncKeepalive {
-    /** If specified, token expires in this many seconds. */
-    token_expires_in: number;
-}
-type StreamingSyncLine = StreamingSyncDataJSON | StreamingSyncCheckpoint | StreamingSyncCheckpointDiff | StreamingSyncCheckpointComplete | StreamingSyncCheckpointPartiallyComplete | StreamingSyncKeepalive;
-type CrudUploadNotification = {
-    crud_upload_completed: null;
-};
-type StreamingSyncLineOrCrudUploadComplete = StreamingSyncLine | CrudUploadNotification;
-interface BucketRequest {
-    name: string;
-    /**
-     * Base-10 number. Sync all data from this bucket with op_id > after.
-     */
-    after: OpId;
-}
-declare function isStreamingSyncData(line: StreamingSyncLine): line is StreamingSyncDataJSON;
-declare function isStreamingKeepalive(line: StreamingSyncLine): line is StreamingSyncKeepalive;
-declare function isStreamingSyncCheckpoint(line: StreamingSyncLine): line is StreamingSyncCheckpoint;
-declare function isStreamingSyncCheckpointComplete(line: StreamingSyncLine): line is StreamingSyncCheckpointComplete;
-declare function isStreamingSyncCheckpointPartiallyComplete(line: StreamingSyncLine): line is StreamingSyncCheckpointPartiallyComplete;
-declare function isStreamingSyncCheckpointDiff(line: StreamingSyncLine): line is StreamingSyncCheckpointDiff;
-declare function isContinueCheckpointRequest(request: SyncRequest): request is ContinueCheckpointRequest;
-declare function isSyncNewCheckpointRequest(request: SyncRequest): request is SyncNewCheckpointRequest;
-/**
- * For crud.json
- */
-interface CrudRequest {
-    data: CrudEntry[];
-}
-interface CrudResponse {
-    /**
-     * A sync response with a checkpoint >= this checkpoint would contain all the changes in this request.
-     *
-     * Any earlier checkpoint may or may not contain these changes.
-     *
-     * May be empty when the request contains no ops.
-     */
-    checkpoint?: OpId;
-}
-
-/**
- * An async iterator that can't be cancelled.
- *
- * To keep data flow simple, we always pass an explicit cancellation token when subscribing to async streams. Once the
- * {@link AbortSignal} aborts, iterators are supposed to clean up and then emit a final `{done: true}` event. This means
- * that there's no way to distinguish between streams that have completed normally and streams that have been cancelled,
- * but that is acceptable for our uses of this.
- */
-type SimpleAsyncIterator<T> = Pick<AsyncIterator<T>, 'next'>;
-
-type BSONImplementation = typeof BSON;
-type RemoteConnector = {
-    fetchCredentials: () => Promise<PowerSyncCredentials | null>;
-    invalidateCredentials?: () => void;
-};
-declare const DEFAULT_REMOTE_LOGGER: Logger.ILogger;
-type SyncStreamOptions = {
-    path: string;
-    data: StreamingSyncRequest;
-    headers?: Record<string, string>;
-    abortSignal: AbortSignal;
-    fetchOptions?: Request;
-};
-declare enum FetchStrategy {
-    /**
-     * Queues multiple sync events before processing, reducing round-trips.
-     * This comes at the cost of more processing overhead, which may cause ACK timeouts on older/weaker devices for big enough datasets.
-     */
-    Buffered = "buffered",
-    /**
-     * Processes each sync event immediately before requesting the next.
-     * This reduces processing overhead and improves real-time responsiveness.
-     */
-    Sequential = "sequential"
-}
-type SocketSyncStreamOptions = SyncStreamOptions & {
-    fetchStrategy: FetchStrategy;
-};
-type FetchImplementation = typeof fetch;
-/**
- * Class wrapper for providing a fetch implementation.
- * The class wrapper is used to distinguish the fetchImplementation
- * option in [AbstractRemoteOptions] from the general fetch method
- * which is typeof "function"
- */
-declare class FetchImplementationProvider {
-    getFetch(): FetchImplementation;
-}
-type AbstractRemoteOptions = {
-    /**
-     * Transforms the PowerSync base URL which might contain
-     * `http(s)://` to the corresponding WebSocket variant
-     * e.g. `ws(s)://`
-     */
-    socketUrlTransformer: (url: string) => string;
-    /**
-     * Optionally provide the fetch implementation to use.
-     * Note that this usually needs to be bound to the global scope.
-     * Binding should be done before passing here.
-     */
-    fetchImplementation: FetchImplementation | FetchImplementationProvider;
-    /**
-     * Optional options to pass directly to all `fetch` calls.
-     *
-     * This can include fields such as `dispatcher` (e.g. for proxy support),
-     * `cache`, or any other fetch-compatible options.
-     */
-    fetchOptions?: {};
-};
-declare const DEFAULT_REMOTE_OPTIONS: AbstractRemoteOptions;
-declare abstract class AbstractRemote {
-    protected connector: RemoteConnector;
-    protected logger: ILogger;
-    protected credentials: PowerSyncCredentials | null;
-    protected options: AbstractRemoteOptions;
-    constructor(connector: RemoteConnector, logger?: ILogger, options?: Partial<AbstractRemoteOptions>);
-    /**
-     * @returns a fetch implementation (function)
-     * which can be called to perform fetch requests
-     */
-    get fetch(): FetchImplementation;
-    /**
-     * Get credentials currently cached, or fetch new credentials if none are
-     * available.
-     *
-     * These credentials may have expired already.
-     */
-    getCredentials(): Promise<PowerSyncCredentials | null>;
-    /**
-     * Fetch a new set of credentials and cache it.
-     *
-     * Until this call succeeds, `getCredentials` will still return the
-     * old credentials.
-     *
-     * This may be called before the current credentials have expired.
-     */
-    prefetchCredentials(): Promise<PowerSyncCredentials | null>;
-    /**
-     * Get credentials for PowerSync.
-     *
-     * This should always fetch a fresh set of credentials - don't use cached
-     * values.
-     */
-    fetchCredentials(): Promise<PowerSyncCredentials | null>;
-    /***
-     * Immediately invalidate credentials.
-     *
-     * This may be called when the current credentials have expired.
-     */
-    invalidateCredentials(): void;
-    getUserAgent(): string;
-    protected buildRequest(path: string): Promise<{
-        url: string;
-        headers: {
-            'content-type': string;
-            Authorization: string;
-            'x-user-agent': string;
-        };
-    }>;
-    post(path: string, data: any, headers?: Record<string, string>): Promise<any>;
-    get(path: string, headers?: Record<string, string>): Promise<any>;
-    /**
-     * Provides a BSON implementation. The import nature of this varies depending on the platform
-     */
-    abstract getBSON(): Promise<BSONImplementation>;
-    /**
-     * @returns A text decoder decoding UTF-8. This is a method to allow patching it for Hermes which doesn't support the
-     * builtin, without forcing us to bundle a polyfill with `@powersync/common`.
-     */
-    createTextDecoder(): TextDecoder;
-    protected createSocket(url: string): WebSocket;
-    /**
-     * Returns a data stream of sync line data, fetched via RSocket-over-WebSocket.
-     *
-     * The only mechanism to abort the returned stream is to use the abort signal in {@link SocketSyncStreamOptions}.
-     *
-     * @param bson A BSON encoder and decoder. When set, the data stream will be requested with a BSON payload
-     * (required for compatibility with older sync services).
-     */
-    socketStreamRaw(options: SocketSyncStreamOptions, bson?: typeof BSON): Promise<SimpleAsyncIterator<Uint8Array>>;
-    /**
-     * @returns Whether the HTTP implementation on this platform can receive streamed binary responses. This is true on
-     * all platforms except React Native (who would have guessed...), where we must not request BSON responses.
-     *
-     * @see https://github.com/react-native-community/fetch?tab=readme-ov-file#motivation
-     */
-    protected get supportsStreamingBinaryResponses(): boolean;
-    /**
-     * Posts a `/sync/stream` request, asserts that it completes successfully and returns the streaming response as an
-     * async iterator of byte blobs.
-     *
-     * To cancel the async iterator, use the abort signal from {@link SyncStreamOptions} passed to this method.
-     */
-    protected fetchStreamRaw(options: SyncStreamOptions): Promise<{
-        isBson: boolean;
-        stream: SimpleAsyncIterator<Uint8Array>;
-    }>;
-    /**
-     * Posts a `/sync/stream` request.
-     *
-     * Depending on the `Content-Type` of the response, this returns strings for sync lines or encoded BSON documents as
-     * {@link Uint8Array}s.
-     */
-    fetchStream(options: SyncStreamOptions): Promise<SimpleAsyncIterator<Uint8Array | string>>;
-}
-
-declare enum LockType {
-    CRUD = "crud",
-    SYNC = "sync"
-}
-declare enum SyncStreamConnectionMethod {
-    HTTP = "http",
-    WEB_SOCKET = "web-socket"
-}
-declare enum SyncClientImplementation {
-    /**
-     * Decodes and handles sync lines received from the sync service in JavaScript.
-     *
-     * This is the default option.
-     *
-     * @deprecated We recommend the {@link RUST} client implementation for all apps. If you have issues with
-     * the Rust client, please file an issue or reach out to us. The JavaScript client will be removed in a future
-     * version of the PowerSync SDK.
-     */
-    JAVASCRIPT = "js",
-    /**
-     * This implementation offloads the sync line decoding and handling into the PowerSync
-     * core extension.
-     *
-     * This option is more performant than the {@link JAVASCRIPT} client, enabled by default and the
-     * recommended client implementation for all apps.
-     *
-     * ## Compatibility warning
-     *
-     * The Rust sync client stores sync data in a format that is slightly different than the one used
-     * by the old {@link JAVASCRIPT} implementation. When adopting the {@link RUST} client on existing
-     * databases, the PowerSync SDK will migrate the format automatically.
-     * Further, the {@link JAVASCRIPT} client in recent versions of the PowerSync JS SDK (starting from
-     * the version introducing {@link RUST} as an option) also supports the new format, so you can switch
-     * back to {@link JAVASCRIPT} later.
-     *
-     * __However__: Upgrading the SDK version, then adopting {@link RUST} as a sync client and later
-     * downgrading the SDK to an older version (necessarily using the JavaScript-based implementation then)
-     * can lead to sync issues.
-     */
-    RUST = "rust"
-}
-/**
- * The default {@link SyncClientImplementation} to use, {@link SyncClientImplementation.RUST}.
- */
-declare const DEFAULT_SYNC_CLIENT_IMPLEMENTATION = SyncClientImplementation.RUST;
-/**
- * Abstract Lock to be implemented by various JS environments
- */
-interface LockOptions<T> {
-    callback: () => Promise<T>;
-    type: LockType;
-    signal?: AbortSignal;
-}
-interface AbstractStreamingSyncImplementationOptions extends RequiredAdditionalConnectionOptions {
-    adapter: BucketStorageAdapter;
-    subscriptions: SubscribedStream[];
-    uploadCrud: () => Promise<void>;
-    /**
-     * An identifier for which PowerSync DB this sync implementation is
-     * linked to. Most commonly DB name, but not restricted to DB name.
-     */
-    identifier?: string;
-    logger?: ILogger;
-    remote: AbstractRemote;
-}
-interface StreamingSyncImplementationListener extends BaseListener {
-    /**
-     * Triggered whenever a status update has been attempted to be made or
-     * refreshed.
-     */
-    statusUpdated?: ((statusUpdate: SyncStatusOptions) => void) | undefined;
-    /**
-     * Triggers whenever the status' members have changed in value
-     */
-    statusChanged?: ((status: SyncStatus) => void) | undefined;
-}
-/**
- * Configurable options to be used when connecting to the PowerSync
- * backend instance.
- */
-type PowerSyncConnectionOptions = Omit<InternalConnectionOptions, 'serializedSchema'>;
-interface InternalConnectionOptions extends BaseConnectionOptions, AdditionalConnectionOptions {
-}
-/** @internal */
-interface BaseConnectionOptions {
-    /**
-     * A set of metadata to be included in service logs.
-     */
-    appMetadata?: Record<string, string>;
-    /**
-     * Whether to use a JavaScript implementation to handle received sync lines from the sync
-     * service, or whether this work should be offloaded to the PowerSync core extension.
-     *
-     * This defaults to the JavaScript implementation ({@link SyncClientImplementation.JAVASCRIPT})
-     * since the ({@link SyncClientImplementation.RUST}) implementation is experimental at the moment.
-     */
-    clientImplementation?: SyncClientImplementation;
-    /**
-     * The connection method to use when streaming updates from
-     * the PowerSync backend instance.
-     * Defaults to a HTTP streaming connection.
-     */
-    connectionMethod?: SyncStreamConnectionMethod;
-    /**
-     * The fetch strategy to use when streaming updates from the PowerSync backend instance.
-     */
-    fetchStrategy?: FetchStrategy;
-    /**
-     * These parameters are passed to the sync rules, and will be available under the`user_parameters` object.
-     */
-    params?: Record<string, StreamingSyncRequestParameterType>;
-    /**
-     * Whether to include streams that have `auto_subscribe: true` in their definition.
-     *
-     * This defaults to `true`.
-     */
-    includeDefaultStreams?: boolean;
-    /**
-     * The serialized schema - mainly used to forward information about raw tables to the sync client.
-     */
-    serializedSchema?: any;
-}
-/** @internal */
-interface AdditionalConnectionOptions {
-    /**
-     * Delay for retrying sync streaming operations
-     * from the PowerSync backend after an error occurs.
-     */
-    retryDelayMs?: number;
-    /**
-     * Backend Connector CRUD operations are throttled
-     * to occur at most every `crudUploadThrottleMs`
-     * milliseconds.
-     */
-    crudUploadThrottleMs?: number;
-}
-/** @internal */
-interface RequiredAdditionalConnectionOptions extends Required<AdditionalConnectionOptions> {
-    subscriptions: SubscribedStream[];
-}
-interface StreamingSyncImplementation extends BaseObserverInterface<StreamingSyncImplementationListener>, Disposable {
-    /**
-     * Connects to the sync service
-     */
-    connect(options?: InternalConnectionOptions): Promise<void>;
-    /**
-     * Disconnects from the sync services.
-     * @throws if not connected or if abort is not controlled internally
-     */
-    disconnect(): Promise<void>;
-    getWriteCheckpoint: () => Promise<string>;
-    hasCompletedSync: () => Promise<boolean>;
-    isConnected: boolean;
-    lastSyncedAt?: Date;
-    syncStatus: SyncStatus;
-    triggerCrudUpload: () => void;
-    waitForReady(): Promise<void>;
-    waitForStatus(status: SyncStatusOptions): Promise<void>;
-    waitUntilStatusMatches(predicate: (status: SyncStatus) => boolean): Promise<void>;
-    updateSubscriptions(subscriptions: SubscribedStream[]): void;
-    markConnectionMayHaveChanged(): void;
-}
-declare const DEFAULT_CRUD_UPLOAD_THROTTLE_MS = 1000;
-declare const DEFAULT_RETRY_DELAY_MS = 5000;
-declare const DEFAULT_STREAMING_SYNC_OPTIONS: {
-    retryDelayMs: number;
-    crudUploadThrottleMs: number;
-};
-type RequiredPowerSyncConnectionOptions = Required<BaseConnectionOptions>;
-declare const DEFAULT_STREAM_CONNECTION_OPTIONS: RequiredPowerSyncConnectionOptions;
-type SubscribedStream = {
-    name: string;
-    params: Record<string, any> | null;
-};
-declare abstract class AbstractStreamingSyncImplementation extends BaseObserver<StreamingSyncImplementationListener> implements StreamingSyncImplementation {
-    protected _lastSyncedAt: Date | null;
-    protected options: AbstractStreamingSyncImplementationOptions;
-    protected abortController: AbortController | null;
-    protected uploadAbortController: AbortController | null;
-    protected crudUpdateListener?: () => void;
-    protected streamingSyncPromise?: Promise<void>;
-    protected logger: ILogger;
-    private activeStreams;
-    private connectionMayHaveChanged;
-    private isUploadingCrud;
-    private notifyCompletedUploads?;
-    private handleActiveStreamsChange?;
-    syncStatus: SyncStatus;
-    triggerCrudUpload: () => void;
-    constructor(options: AbstractStreamingSyncImplementationOptions);
-    waitForReady(): Promise<void>;
-    waitForStatus(status: SyncStatusOptions): Promise<void>;
-    waitUntilStatusMatches(predicate: (status: SyncStatus) => boolean): Promise<void>;
-    get lastSyncedAt(): Date | undefined;
-    get isConnected(): boolean;
-    dispose(): Promise<void>;
-    abstract obtainLock<T>(lockOptions: LockOptions<T>): Promise<T>;
-    hasCompletedSync(): Promise<boolean>;
-    getWriteCheckpoint(): Promise<string>;
-    protected _uploadAllCrud(): Promise<void>;
-    connect(options?: PowerSyncConnectionOptions): Promise<void>;
-    disconnect(): Promise<void>;
-    /**
-     * @deprecated use [connect instead]
-     */
-    streamingSync(signal?: AbortSignal, options?: PowerSyncConnectionOptions): Promise<void>;
-    markConnectionMayHaveChanged(): void;
-    private collectLocalBucketState;
-    /**
-     * Older versions of the JS SDK used to encode subkeys as JSON in {@link OplogEntry.toJSON}.
-     * Because subkeys are always strings, this leads to quotes being added around them in `ps_oplog`.
-     * While this is not a problem as long as it's done consistently, it causes issues when a database
-     * created by the JS SDK is used with other SDKs, or (more likely) when the new Rust sync client
-     * is enabled.
-     *
-     * So, we add a migration from the old key format (with quotes) to the new one (no quotes). The
-     * migration is only triggered when necessary (for now). The function returns whether the new format
-     * should be used, so that the JS SDK is able to write to updated databases.
-     *
-     * @param requireFixedKeyFormat Whether we require the new format or also support the old one.
-     *        The Rust client requires the new subkey format.
-     * @returns Whether the database is now using the new, fixed subkey format.
-     */
-    private requireKeyFormat;
-    protected streamingSyncIteration(signal: AbortSignal, options?: PowerSyncConnectionOptions): Promise<RustIterationResult | null>;
-    private receiveSyncLines;
-    private legacyStreamingSyncIteration;
-    private rustSyncIteration;
-    private updateSyncStatusForStartingCheckpoint;
-    private applyCheckpoint;
-    protected updateSyncStatus(options: SyncStatusOptions): void;
-    private delayRetry;
-    updateSubscriptions(subscriptions: SubscribedStream[]): void;
-}
-interface RustIterationResult {
-    immediateRestart: boolean;
-}
-
-interface CoreStreamSubscription {
-    progress: {
-        total: number;
-        downloaded: number;
-    };
-    name: string;
-    parameters: any;
-    priority: number | null;
-    active: boolean;
-    is_default: boolean;
-    has_explicit_subscription: boolean;
-    expires_at: number | null;
-    last_synced_at: number | null;
-}
-interface BucketProgress {
-    priority: number;
-    at_last: number;
-    since_last: number;
-    target_count: number;
-}
-
-/**
- * A description of a sync stream, consisting of its {@link name} and the {@link parameters} used when subscribing.
- */
-interface SyncStreamDescription {
-    /**
-     * The name of the stream as it appears in the stream definition for the PowerSync service.
-     */
-    name: string;
-    /**
-     * The parameters used to subscribe to the stream, if any.
-     *
-     * The same stream can be subscribed to multiple times with different parameters.
-     */
-    parameters: Record<string, any> | null;
-}
-/**
- * Information about a subscribed sync stream.
- *
- * This includes the {@link SyncStreamDescription}, along with information about the current sync status.
- */
-interface SyncSubscriptionDescription extends SyncStreamDescription {
-    active: boolean;
-    /**
-     * Whether this stream subscription is included by default, regardless of whether the stream has explicitly been
-     * subscribed to or not.
-     *
-     * It's possible for both {@link isDefault} and {@link hasExplicitSubscription} to be true at the same time - this
-     * happens when a default stream was subscribed explicitly.
-     */
-    isDefault: boolean;
-    /**
-     * Whether this stream has been subscribed to explicitly.
-     *
-     * It's possible for both {@link isDefault} and {@link hasExplicitSubscription} to be true at the same time - this
-     * happens when a default stream was subscribed explicitly.
-     */
-    hasExplicitSubscription: boolean;
-    /**
-     * For sync streams that have a time-to-live, the current time at which the stream would expire if not subscribed to
-     * again.
-     */
-    expiresAt: Date | null;
-    /**
-     * Whether this stream subscription has been synced at least once.
-     */
-    hasSynced: boolean;
-    /**
-     * If {@link hasSynced} is true, the last time data from this stream has been synced.
-     */
-    lastSyncedAt: Date | null;
-}
-interface SyncStreamSubscribeOptions {
-    /**
-     * A "time to live" for this stream subscription, in seconds.
-     *
-     * The TTL control when a stream gets evicted after not having an active {@link SyncStreamSubscription} object
-     * attached to it.
-     */
-    ttl?: number;
-    /**
-     * A priority to assign to this subscription. This overrides the default priority that may have been set on streams.
-     *
-     * For details on priorities, see [priotized sync](https://docs.powersync.com/usage/use-case-examples/prioritized-sync).
-     */
-    priority?: 0 | 1 | 2 | 3;
-}
-/**
- * A handle to a {@link SyncStreamDescription} that allows subscribing to the stream.
- *
- * To obtain an instance of {@link SyncStream}, call {@link AbstractPowerSyncDatabase.syncStream}.
- */
-interface SyncStream extends SyncStreamDescription {
-    /**
-     * Adds a subscription to this stream, requesting it to be included when connecting to the sync service.
-     *
-     * You should keep a reference to the returned {@link SyncStreamSubscription} object along as you need data for that
-     * stream. As soon as {@link SyncStreamSubscription.unsubscribe} is called for all subscriptions on this stream
-     * (including subscriptions created on other tabs), the {@link SyncStreamSubscribeOptions.ttl} starts ticking and will
-     * eventually evict the stream (unless {@link subscribe} is called again).
-     */
-    subscribe(options?: SyncStreamSubscribeOptions): Promise<SyncStreamSubscription>;
-    /**
-     * Clears all subscriptions attached to this stream and resets the TTL for the stream.
-     *
-     * This is a potentially dangerous operations, as it interferes with other stream subscriptions.
-     */
-    unsubscribeAll(): Promise<void>;
-}
-interface SyncStreamSubscription extends SyncStreamDescription {
-    /**
-     * A promise that resolves once data from in this sync stream has been synced and applied.
-     */
-    waitForFirstSync(abort?: AbortSignal): Promise<void>;
-    /**
-     * Removes this stream subscription.
-     */
-    unsubscribe(): void;
-}
-
-/** @internal */
-type InternalProgressInformation = Record<string, BucketProgress>;
-/**
- * Information about a progressing download made by the PowerSync SDK.
- *
- * To obtain these values, use {@link SyncProgress}, available through
- * {@link SyncStatus#downloadProgress}.
- */
-interface ProgressWithOperations {
-    /**
-     * The total amount of operations to download for the current sync iteration
-     * to complete.
-     */
-    totalOperations: number;
-    /**
-     * The amount of operations that have already been downloaded.
-     */
-    downloadedOperations: number;
-    /**
-     * Relative progress, as {@link downloadedOperations} of {@link totalOperations}.
-     *
-     * This will be a number between `0.0` and `1.0` (inclusive).
-     *
-     * When this number reaches `1.0`, all changes have been received from the sync service.
-     * Actually applying these changes happens before the `downloadProgress` field is cleared from
-     * {@link SyncStatus}, so progress can stay at `1.0` for a short while before completing.
-     */
-    downloadedFraction: number;
-}
-/**
- * Provides realtime progress on how PowerSync is downloading rows.
- *
- * The progress until the next complete sync is available through the fields on {@link ProgressWithOperations},
- * which this class implements.
- * Additionally, the {@link SyncProgress.untilPriority} method can be used to otbain progress towards
- * a specific priority (instead of the progress for the entire download).
- *
- * The reported progress always reflects the status towards the end of a sync iteration (after
- * which a consistent snapshot of all buckets is available locally).
- *
- * In rare cases (in particular, when a [compacting](https://docs.powersync.com/usage/lifecycle-maintenance/compacting-buckets)
- * operation takes place between syncs), it's possible for the returned numbers to be slightly
- * inaccurate. For this reason, {@link SyncProgress} should be seen as an approximation of progress.
- * The information returned is good enough to build progress bars, but not exact enough to track
- * individual download counts.
- *
- * Also note that data is downloaded in bulk, which means that individual counters are unlikely
- * to be updated one-by-one.
- */
-declare class SyncProgress implements ProgressWithOperations {
-    protected internal: InternalProgressInformation;
-    totalOperations: number;
-    downloadedOperations: number;
-    downloadedFraction: number;
-    constructor(internal: InternalProgressInformation);
-    /**
-     * Returns download progress towards all data up until the specified priority being received.
-     *
-     * The returned {@link ProgressWithOperations} tracks the target amount of operations that need
-     * to be downloaded in total and how many of them have already been received.
-     */
-    untilPriority(priority: number): ProgressWithOperations;
-}
-
-type SyncDataFlowStatus = Partial<{
-    downloading: boolean;
-    uploading: boolean;
-    /**
-     * Error during downloading (including connecting).
-     *
-     * Cleared on the next successful data download.
-     */
-    downloadError?: Error;
-    /**
-     * Error during uploading.
-     * Cleared on the next successful upload.
-     */
-    uploadError?: Error;
-    /**
-     * Internal information about how far we are downloading operations in buckets.
-     *
-     * Please use the {@link SyncStatus#downloadProgress} property to track sync progress.
-     */
-    downloadProgress: InternalProgressInformation | null;
-    internalStreamSubscriptions: CoreStreamSubscription[] | null;
-}>;
-interface SyncPriorityStatus {
-    priority: number;
-    lastSyncedAt?: Date;
-    hasSynced?: boolean;
-}
-type SyncStatusOptions = {
-    connected?: boolean;
-    connecting?: boolean;
-    dataFlow?: SyncDataFlowStatus;
-    lastSyncedAt?: Date;
-    hasSynced?: boolean;
-    priorityStatusEntries?: SyncPriorityStatus[];
-    clientImplementation?: SyncClientImplementation;
-};
-declare class SyncStatus {
-    protected options: SyncStatusOptions;
-    constructor(options: SyncStatusOptions);
-    /**
-     * Returns the used sync client implementation (either the one implemented in JavaScript or the newer Rust-based
-     * implementation).
-     *
-     * This information is only available after a connection has been requested.
-     */
-    get clientImplementation(): SyncClientImplementation | undefined;
-    /**
-     * Indicates if the client is currently connected to the PowerSync service.
-     *
-     * @returns {boolean} True if connected, false otherwise. Defaults to false if not specified.
-     */
-    get connected(): boolean;
-    /**
-     * Indicates if the client is in the process of establishing a connection to the PowerSync service.
-     *
-     * @returns {boolean} True if connecting, false otherwise. Defaults to false if not specified.
-     */
-    get connecting(): boolean;
-    /**
-     * Time that a last sync has fully completed, if any.
-     * This timestamp is reset to null after a restart of the PowerSync service.
-     *
-     * @returns {Date | undefined} The timestamp of the last successful sync, or undefined if no sync has completed.
-     */
-    get lastSyncedAt(): Date | undefined;
-    /**
-     * Indicates whether there has been at least one full sync completed since initialization.
-     *
-     * @returns {boolean | undefined} True if at least one sync has completed, false if no sync has completed,
-     * or undefined when the state is still being loaded from the database.
-     */
-    get hasSynced(): boolean | undefined;
-    /**
-     * Provides the current data flow status regarding uploads and downloads.
-     *
-     * @returns {SyncDataFlowStatus} An object containing:
-     * - downloading: True if actively downloading changes (only when connected is also true)
-     * - uploading: True if actively uploading changes
-     * Defaults to {downloading: false, uploading: false} if not specified.
-     */
-    get dataFlowStatus(): Partial<{
-        downloading: boolean;
-        uploading: boolean;
-        /**
-         * Error during downloading (including connecting).
-         *
-         * Cleared on the next successful data download.
-         */
-        downloadError?: Error;
-        /**
-         * Error during uploading.
-         * Cleared on the next successful upload.
-         */
-        uploadError?: Error;
-        /**
-         * Internal information about how far we are downloading operations in buckets.
-         *
-         * Please use the {@link SyncStatus#downloadProgress} property to track sync progress.
-         */
-        downloadProgress: InternalProgressInformation | null;
-        internalStreamSubscriptions: CoreStreamSubscription[] | null;
-    }>;
-    /**
-     * All sync streams currently being tracked in teh database.
-     *
-     * This returns null when the database is currently being opened and we don't have reliable information about all
-     * included streams yet.
-     */
-    get syncStreams(): SyncStreamStatus[] | undefined;
-    /**
-     * If the `stream` appears in {@link syncStreams}, returns the current status for that stream.
-     */
-    forStream(stream: SyncStreamDescription): SyncStreamStatus | undefined;
-    /**
-     * Provides sync status information for all bucket priorities, sorted by priority (highest first).
-     *
-     * @returns {SyncPriorityStatus[]} An array of status entries for different sync priority levels,
-     * sorted with highest priorities (lower numbers) first.
-     */
-    get priorityStatusEntries(): SyncPriorityStatus[];
-    /**
-     * A realtime progress report on how many operations have been downloaded and
-     * how many are necessary in total to complete the next sync iteration.
-     *
-     * This field is only set when {@link SyncDataFlowStatus#downloading} is also true.
-     */
-    get downloadProgress(): SyncProgress | null;
-    /**
-     * Reports the sync status (a pair of {@link SyncStatus#hasSynced} and {@link SyncStatus#lastSyncedAt} fields)
-     * for a specific bucket priority level.
-     *
-     * When buckets with different priorities are declared, PowerSync may choose to synchronize higher-priority
-     * buckets first. When a consistent view over all buckets for all priorities up until the given priority is
-     * reached, PowerSync makes data from those buckets available before lower-priority buckets have finished
-     * syncing.
-     *
-     * This method returns the status for the requested priority or the next higher priority level that has
-     * status information available. This is because when PowerSync makes data for a given priority available,
-     * all buckets in higher-priorities are guaranteed to be consistent with that checkpoint.
-     *
-     * For example, if PowerSync just finished synchronizing buckets in priority level 3, calling this method
-     * with a priority of 1 may return information for priority level 3.
-     *
-     * @param {number} priority The bucket priority for which the status should be reported
-     * @returns {SyncPriorityStatus} Status information for the requested priority level or the next higher level with available status
-     */
-    statusForPriority(priority: number): SyncPriorityStatus;
-    /**
-     * Compares this SyncStatus instance with another to determine if they are equal.
-     * Equality is determined by comparing the serialized JSON representation of both instances.
-     *
-     * @param {SyncStatus} status The SyncStatus instance to compare against
-     * @returns {boolean} True if the instances are considered equal, false otherwise
-     */
-    isEqual(status: SyncStatus): boolean;
-    /**
-     * Creates a human-readable string representation of the current sync status.
-     * Includes information about connection state, sync completion, and data flow.
-     *
-     * @returns {string} A string representation of the sync status
-     */
-    getMessage(): string;
-    /**
-     * Serializes the SyncStatus instance to a plain object.
-     *
-     * @returns {SyncStatusOptions} A plain object representation of the sync status
-     */
-    toJSON(): SyncStatusOptions;
-    /**
-     * Not all errors are serializable over a MessagePort. E.g. some `DomExceptions` fail to be passed across workers.
-     * This explicitly serializes errors in the SyncStatus.
-     */
-    protected serializeError(error?: Error): {
-        name: string;
-        message: string;
-        stack: string | undefined;
-    } | undefined;
-    private static comparePriorities;
-}
-/**
- * Information about a sync stream subscription.
- */
-interface SyncStreamStatus {
-    progress: ProgressWithOperations | null;
-    subscription: SyncSubscriptionDescription;
-    priority: number | null;
-}
-
-declare class UploadQueueStats {
-    /**
-     * Number of records in the upload queue.
-     */
-    count: number;
-    /**
-     * Size of the upload queue in bytes.
-     */
-    size: number | null;
-    constructor(
-    /**
-     * Number of records in the upload queue.
-     */
-    count: number, 
-    /**
-     * Size of the upload queue in bytes.
-     */
-    size?: number | null);
-    toString(): string;
-}
-
-declare enum ColumnType {
-    TEXT = "TEXT",
-    INTEGER = "INTEGER",
-    REAL = "REAL"
-}
-interface ColumnOptions {
-    name: string;
-    type?: ColumnType;
-}
-type BaseColumnType<T extends number | string | null> = {
-    type: ColumnType;
-};
-type ColumnsType = Record<string, BaseColumnType<any>>;
-type ExtractColumnValueType<T extends BaseColumnType<any>> = T extends BaseColumnType<infer R> ? R : unknown;
-declare const MAX_AMOUNT_OF_COLUMNS = 1999;
-declare const column: {
-    text: BaseColumnType<string | null>;
-    integer: BaseColumnType<number | null>;
-    real: BaseColumnType<number | null>;
-};
-declare class Column {
-    protected options: ColumnOptions;
-    constructor(options: ColumnOptions);
-    get name(): string;
-    get type(): ColumnType | undefined;
-    toJSON(): {
-        name: string;
-        type: ColumnType | undefined;
-    };
-}
-
-interface IndexColumnOptions {
-    name: string;
-    ascending?: boolean;
-}
-declare const DEFAULT_INDEX_COLUMN_OPTIONS: Partial<IndexColumnOptions>;
-declare class IndexedColumn {
-    protected options: IndexColumnOptions;
-    static createAscending(column: string): IndexedColumn;
-    constructor(options: IndexColumnOptions);
-    get name(): string;
-    get ascending(): boolean | undefined;
-    toJSON(table: Table): {
-        name: string;
-        ascending: boolean | undefined;
-        type: ColumnType;
-    };
-}
-
-interface IndexOptions {
-    name: string;
-    columns?: IndexedColumn[];
-}
-declare const DEFAULT_INDEX_OPTIONS: Partial<IndexOptions>;
-declare class Index {
-    protected options: IndexOptions;
-    static createAscending(options: IndexOptions, columnNames: string[]): Index;
-    constructor(options: IndexOptions);
-    get name(): string;
-    get columns(): IndexedColumn[];
-    toJSON(table: Table): {
-        name: string;
-        columns: {
-            name: string;
-            ascending: boolean | undefined;
-            type: ColumnType;
-        }[];
-    };
-}
-
-/**
-  Generate a new table from the columns and indexes
-  @deprecated You should use {@link Table} instead as it now allows TableV2 syntax.
-  This will be removed in the next major release.
-*/
-declare class TableV2<Columns extends ColumnsType = ColumnsType> extends Table<Columns> {
-}
-
-/**
- * Options that apply both to JSON-based tables and raw tables.
- */
-interface TableOrRawTableOptions {
-    localOnly?: boolean;
-    insertOnly?: boolean;
-    trackPrevious?: boolean | TrackPreviousOptions;
-    trackMetadata?: boolean;
-    ignoreEmptyUpdates?: boolean;
-}
-interface SharedTableOptions extends TableOrRawTableOptions {
-    viewName?: string;
-}
-/** Whether to include previous column values when PowerSync tracks local changes.
- *
- * Including old values may be helpful for some backend connector implementations, which is
- * why it can be enabled on per-table or per-columm basis.
- */
-interface TrackPreviousOptions {
-    /** When defined, a list of column names for which old values should be tracked. */
-    columns?: string[];
-    /** When enabled, only include values that have actually been changed by an update. */
-    onlyWhenChanged?: boolean;
-}
-interface TableOptions extends SharedTableOptions {
-    /**
-     * The synced table name, matching sync rules
-     */
-    name: string;
-    columns: Column[];
-    indexes?: Index[];
-}
-type RowType<T extends TableV2<any>> = {
-    [K in keyof T['columnMap']]: ExtractColumnValueType<T['columnMap'][K]>;
-} & {
-    id: string;
-};
-type IndexShorthand = Record<string, string[]>;
-interface TableV2Options extends SharedTableOptions {
-    indexes?: IndexShorthand;
-}
-declare const DEFAULT_TABLE_OPTIONS: {
-    indexes: never[];
-    insertOnly: boolean;
-    localOnly: boolean;
-    trackPrevious: boolean;
-    trackMetadata: boolean;
-    ignoreEmptyUpdates: boolean;
-};
-declare const InvalidSQLCharacters: RegExp;
-declare class Table<Columns extends ColumnsType = ColumnsType> {
-    protected options: TableOptions;
-    protected _mappedColumns: Columns;
-    static createLocalOnly(options: TableOptions): Table<ColumnsType>;
-    static createInsertOnly(options: TableOptions): Table<ColumnsType>;
-    /**
-     * Create a table.
-     * @deprecated This was only only included for TableV2 and is no longer necessary.
-     * Prefer to use new Table() directly.
-     *
-     * TODO remove in the next major release.
-     */
-    static createTable(name: string, table: Table): Table<ColumnsType>;
-    /**
-     * Creates a new Table instance.
-     *
-     * This constructor supports two different versions:
-     * 1. New constructor: Using a Columns object and an optional TableV2Options object
-     * 2. Deprecated constructor: Using a TableOptions object (will be removed in the next major release)
-     *
-     * @constructor
-     * @param {Columns | TableOptions} optionsOrColumns - Either a Columns object (for V2 syntax) or a TableOptions object (for V1 syntax)
-     * @param {TableV2Options} [v2Options] - Optional configuration options for V2 syntax
-     *
-     * @example
-     * ```javascript
-     * // New Constructor
-     * const table = new Table(
-     *   {
-     *     name: column.text,
-     *     age: column.integer
-     *   },
-     *   { indexes: { nameIndex: ['name'] } }
-     * );
-     *```
-     *
-     *
-     * @example
-     * ```javascript
-     * // Deprecated Constructor
-     * const table = new Table({
-     *   name: 'users',
-     *   columns: [
-     *     new Column({ name: 'name', type: ColumnType.TEXT }),
-     *     new Column({ name: 'age', type: ColumnType.INTEGER })
-     *   ]
-     * });
-     *```
-     */
-    constructor(columns: Columns, options?: TableV2Options);
-    /**
-     * @deprecated This constructor will be removed in the next major release.
-     * Use the new constructor shown below instead as this does not show types.
-     * @example
-     * <caption>Use this instead</caption>
-     * ```javascript
-     *   const table = new Table(
-     *     {
-     *      name: column.text,
-     *      age: column.integer
-     *     },
-     *     { indexes: { nameIndex: ['name'] } }
-     *   );
-     *```
-     */
-    constructor(options: TableOptions);
-    copyWithName(name: string): Table;
-    private isTableV1;
-    private initTableV1;
-    private initTableV2;
-    private applyDefaultOptions;
-    get name(): string;
-    get viewNameOverride(): string | undefined;
-    get viewName(): string;
-    get columns(): Column[];
-    get columnMap(): Columns;
-    get indexes(): Index[];
-    get localOnly(): boolean;
-    get insertOnly(): boolean;
-    get trackPrevious(): boolean | TrackPreviousOptions;
-    get trackMetadata(): boolean;
-    get ignoreEmptyUpdates(): boolean;
-    get internalName(): string;
-    get validName(): boolean;
-    validate(): void;
-    toJSON(): {
-        local_only: boolean | undefined;
-        insert_only: boolean | undefined;
-        include_old: any;
-        include_old_only_when_changed: boolean;
-        include_metadata: boolean | undefined;
-        ignore_empty_update: boolean | undefined;
-        name: string;
-        view_name: string;
-        columns: {
-            name: string;
-            type: ColumnType | undefined;
-        }[];
-        indexes: {
-            name: string;
-            columns: {
-                name: string;
-                ascending: boolean | undefined;
-                type: ColumnType;
-            }[];
-        }[];
-    };
-}
-
-/**
- * Instructs PowerSync to sync data into a "raw" table.
- *
- * Since raw tables are not backed by JSON, running complex queries on them may be more efficient. Further, they allow
- * using client-side table and column constraints.
- *
- * To collect local writes to raw tables with PowerSync, custom triggers are required. See
- * {@link https://docs.powersync.com/usage/use-case-examples/raw-tables the documentation} for details and an example on
- * using raw tables.
- */
-type RawTableType = RawTableTypeWithStatements | InferredRawTableType;
-interface RawTableTypeWithStatements {
-    /**
-     * The statement to run when PowerSync detects that a row needs to be inserted or updated.
-     */
-    put: PendingStatement;
-    /**
-     * The statement to run when PowerSync detects that a row needs to be deleted.
-     */
-    delete: PendingStatement;
-    /**
-     * An optional statement to run when `disconnectAndClear()` is called on a PowerSync database.
-     */
-    clear?: string;
-}
-/**
- * The schema of a {@link RawTableType} in the local database.
- *
- * This information is optional when declaring raw tables. However, providing it allows the sync client to infer `put`
- * and `delete` statements automatically.
- */
-interface RawTableSchema extends TableOrRawTableOptions {
-    /**
-     * The actual name of the raw table in the local schema.
-     *
-     * Unlike {@link RawTable.name}, which describes the name of synced tables to match, this reflects  the SQLite table
-     * name. This is used to infer {@link RawTableType.put} and {@link RawTableType.delete} statements for the sync
-     * client. It can also be used to auto-generate triggers forwarding writes on raw tables into the CRUD upload queue
-     * (using the `powersync_create_raw_table_crud_trigger` SQL function).
-     *
-     * When absent, defaults to {@link RawTable.name}.
-     */
-    tableName?: string;
-    /**
-     * An optional filter of columns that should be synced.
-     *
-     * By default, all columns in a raw table are considered for sync. If a filter is specified, PowerSync treats
-     * unmatched columns as local-only and will not attempt to sync them.
-     */
-    syncedColumns?: string[];
-}
-interface InferredRawTableType extends Partial<RawTableTypeWithStatements> {
-    schema: RawTableSchema;
-}
-/**
- * A parameter to use as part of {@link PendingStatement}.
- *
- * For delete statements, only the `"Id"` value is supported - the sync client will replace it with the id of the row to
- * be synced.
- *
- * For insert and replace operations, the values of columns in the table are available as parameters through
- * `{Column: 'name'}`.
- * The `"Rest"` parameter gets resolved to a JSON object covering all values from the synced row that haven't been
- * covered by a `Column` parameter.
- */
-type PendingStatementParameter = 'Id' | {
-    Column: string;
-} | 'Rest';
-/**
- * A statement that the PowerSync client should use to insert or delete data into a table managed by the user.
- */
-type PendingStatement = {
-    sql: string;
-    params: PendingStatementParameter[];
-};
-/**
- * @internal
- */
-type RawTable<T extends RawTableType = RawTableType> = T & {
-    /**
-     * The name of the table.
-     *
-     * This does not have to match the actual table name in the schema - {@link RawTableType.put} and
-     * {@link RawTableType.delete} are free to use another table. Instead, this name is used by the sync client to
-     * recognize that operations on this table (as it appears in the source / backend database) are to be handled
-     * specially.
-     */
-    name: string;
-};
-
-type SchemaType = Record<string, Table<any>>;
-type SchemaTableType<S extends SchemaType> = {
-    [K in keyof S]: RowType<S[K]>;
-};
-/**
- * A schema is a collection of tables. It is used to define the structure of a database.
- */
-declare class Schema<S extends SchemaType = SchemaType> {
-    readonly types: SchemaTableType<S>;
-    readonly props: S;
-    readonly tables: Table[];
-    readonly rawTables: RawTable[];
-    constructor(tables: Table[] | S);
-    /**
-     * Adds raw tables to this schema. Raw tables are identified by their name, but entirely managed by the application
-     * developer instead of automatically by PowerSync.
-     * Since raw tables are not backed by JSON, running complex queries on them may be more efficient. Further, they allow
-     * using client-side table and column constraints.
-     *
-     * @param tables An object of (table name, raw table definition) entries.
-     */
-    withRawTables(tables: Record<string, RawTableType>): void;
-    validate(): void;
-    toJSON(): {
-        tables: {
-            local_only: boolean | undefined;
-            insert_only: boolean | undefined;
-            include_old: any;
-            include_old_only_when_changed: boolean;
-            include_metadata: boolean | undefined;
-            ignore_empty_update: boolean | undefined;
-            name: string;
-            view_name: string;
-            columns: {
-                name: string;
-                type: ColumnType | undefined;
-            }[];
-            indexes: {
-                name: string;
-                columns: {
-                    name: string;
-                    ascending: boolean | undefined;
-                    type: ColumnType;
-                }[];
-            }[];
-        }[];
-        raw_tables: unknown[];
-    };
-    /**
-     * Returns a representation of the raw table that is understood by the PowerSync SQLite core extension.
-     *
-     * The output of this can be passed through `JSON.serialize` and then used in `powersync_create_raw_table_crud_trigger`
-     * to define triggers for this table.
-     */
-    static rawTableToJson(table: RawTable): unknown;
-}
-
-interface PowerSyncBackendConnector {
-    /** Allows the PowerSync client to retrieve an authentication token from your backend
-     * which is used to authenticate against the PowerSync service.
-     *
-     * This should always fetch a fresh set of credentials - don't use cached
-     * values.
-     *
-     * Return null if the user is not signed in. Throw an error if credentials
-     * cannot be fetched due to a network error or other temporary error.
-     *
-     * This token is kept for the duration of a sync connection.
-     */
-    fetchCredentials: () => Promise<PowerSyncCredentials | null>;
-    /** Upload local changes to the app backend.
-     *
-     * Use {@link AbstractPowerSyncDatabase.getCrudBatch} to get a batch of changes to upload.
-     *
-     * Any thrown errors will result in a retry after the configured wait period (default: 5 seconds).
-     */
-    uploadData: (database: AbstractPowerSyncDatabase) => Promise<void>;
-}
-
-/**
- * @internal
- */
-interface ConnectionManagerSyncImplementationResult {
-    sync: StreamingSyncImplementation;
-    /**
-     * Additional cleanup function which is called after the sync stream implementation
-     * is disposed.
-     */
-    onDispose: () => Promise<void> | void;
-}
-/**
- * The subset of {@link AbstractStreamingSyncImplementationOptions} managed by the connection manager.
- *
- * @internal
- */
-interface CreateSyncImplementationOptions extends AdditionalConnectionOptions {
-    subscriptions: SubscribedStream[];
-}
-interface InternalSubscriptionAdapter {
-    firstStatusMatching(predicate: (status: SyncStatus) => any, abort?: AbortSignal): Promise<void>;
-    resolveOfflineSyncStatus(): Promise<void>;
-    rustSubscriptionsCommand(payload: any): Promise<void>;
-}
-/**
- * @internal
- */
-interface ConnectionManagerOptions {
-    createSyncImplementation(connector: PowerSyncBackendConnector, options: CreateSyncImplementationOptions): Promise<ConnectionManagerSyncImplementationResult>;
-    logger: ILogger;
-}
-type StoredConnectionOptions = {
-    connector: PowerSyncBackendConnector;
-    options: InternalConnectionOptions;
-};
-/**
- * @internal
- */
-interface ConnectionManagerListener extends BaseListener {
-    syncStreamCreated: (sync: StreamingSyncImplementation) => void;
-}
-/**
- * @internal
- */
-declare class ConnectionManager extends BaseObserver<ConnectionManagerListener> {
-    protected options: ConnectionManagerOptions;
-    /**
-     * Tracks active connection attempts
-     */
-    protected connectingPromise: Promise<void> | null;
-    /**
-     * Tracks actively instantiating a streaming sync implementation.
-     */
-    protected syncStreamInitPromise: Promise<void> | null;
-    /**
-     * Active disconnect operation. Calling disconnect multiple times
-     * will resolve to the same operation.
-     */
-    protected disconnectingPromise: Promise<void> | null;
-    /**
-     * Tracks the last parameters supplied to `connect` calls.
-     * Calling `connect` multiple times in succession will result in:
-     * - 1 pending connection operation which will be aborted.
-     * - updating the last set of parameters while waiting for the pending
-     *   attempt to be aborted
-     * - internally connecting with the last set of parameters
-     */
-    protected pendingConnectionOptions: StoredConnectionOptions | null;
-    syncStreamImplementation: StreamingSyncImplementation | null;
-    /**
-     * Additional cleanup function which is called after the sync stream implementation
-     * is disposed.
-     */
-    protected syncDisposer: (() => Promise<void> | void) | null;
-    /**
-     * Subscriptions managed in this connection manager.
-     *
-     * On the web, these local subscriptions are merged across tabs by a shared worker.
-     */
-    private locallyActiveSubscriptions;
-    constructor(options: ConnectionManagerOptions);
-    get connector(): PowerSyncBackendConnector | null;
-    get connectionOptions(): InternalConnectionOptions | null;
-    get logger(): ILogger;
-    close(): Promise<void>;
-    connect(connector: PowerSyncBackendConnector, options: InternalConnectionOptions): Promise<void>;
-    protected connectInternal(): Promise<void>;
-    /**
-     * Close the sync connection.
-     *
-     * Use {@link connect} to connect again.
-     */
-    disconnect(): Promise<void>;
-    protected disconnectInternal(): Promise<void>;
-    protected performDisconnect(): Promise<void>;
-    stream(adapter: InternalSubscriptionAdapter, name: string, parameters: Record<string, any> | null): SyncStream;
-    /**
-     * @internal exposed for testing
-     */
-    get activeStreams(): {
-        name: string;
-        params: Record<string, any> | null;
-    }[];
-    private subscriptionsMayHaveChanged;
-}
-
-/**
- * A basic comparator for incrementally watched queries. This performs a single comparison which
- * determines if the result set has changed. The {@link WatchedQuery} will only emit the new result
- * if a change has been detected.
- */
-interface WatchedQueryComparator<Data> {
-    checkEquality: (current: Data, previous: Data) => boolean;
-}
-/**
- * Options for {@link ArrayComparator}
- */
-type ArrayComparatorOptions<ItemType> = {
-    /**
-     * Returns a string to uniquely identify an item in the array.
-     */
-    compareBy: (item: ItemType) => string;
-};
-/**
- * An efficient comparator for {@link WatchedQuery} created with {@link Query#watch}. This has the ability to determine if a query
- * result has changes without necessarily processing all items in the result.
- */
-declare class ArrayComparator<ItemType> implements WatchedQueryComparator<ItemType[]> {
-    protected options: ArrayComparatorOptions<ItemType>;
-    constructor(options: ArrayComparatorOptions<ItemType>);
-    checkEquality(current: ItemType[], previous: ItemType[]): boolean;
-}
-/**
- * Watched query comparator that always reports changed result sets.
- */
-declare const FalsyComparator: WatchedQueryComparator<unknown>;
-
-interface CompilableQuery<T> {
-    execute(): Promise<T[]>;
-    compile(): CompiledQuery;
-}
-interface CompiledQuery {
-    readonly sql: string;
-    readonly parameters: ReadonlyArray<unknown>;
-}
-
-/**
- * Represents the counts of listeners for each event type in a BaseListener.
- */
-type ListenerCounts<Listener extends BaseListener> = Partial<Record<keyof Listener, number>> & {
-    total: number;
-};
-/**
- * Meta listener which reports the counts of listeners for each event type.
- */
-interface MetaListener<ParentListener extends BaseListener> extends BaseListener {
-    listenersChanged?: (counts: ListenerCounts<ParentListener>) => void;
-}
-interface ListenerMetaManager<Listener extends BaseListener> extends BaseObserverInterface<MetaListener<Listener>> {
-    counts: ListenerCounts<Listener>;
-}
-interface MetaBaseObserverInterface<Listener extends BaseListener> extends BaseObserverInterface<Listener> {
-    listenerMeta: ListenerMetaManager<Listener>;
-}
-/**
- * A BaseObserver that tracks the counts of listeners for each event type.
- */
-declare class MetaBaseObserver<Listener extends BaseListener> extends BaseObserver<Listener> implements MetaBaseObserverInterface<Listener> {
-    protected get listenerCounts(): ListenerCounts<Listener>;
-    get listenerMeta(): ListenerMetaManager<Listener>;
-    protected metaListener: BaseObserver<MetaListener<Listener>>;
-    constructor();
-    registerListener(listener: Partial<Listener>): () => void;
-}
-
-/**
- * State for {@link WatchedQuery} instances.
- */
-interface WatchedQueryState<Data> {
-    /**
-     * Indicates the initial loading state (hard loading).
-     * Loading becomes false once the first set of results from the watched query is available or an error occurs.
-     */
-    readonly isLoading: boolean;
-    /**
-     * Indicates whether the query is currently fetching data, is true during the initial load
-     * and any time when the query is re-evaluating (useful for large queries).
-     */
-    readonly isFetching: boolean;
-    /**
-     * The last error that occurred while executing the query.
-     */
-    readonly error: Error | null;
-    /**
-     * The last time the query was updated.
-     */
-    readonly lastUpdated: Date | null;
-    /**
-     * The last data returned by the query.
-     */
-    readonly data: Data;
-}
-/**
- * Options provided to the `execute` method of a {@link WatchCompatibleQuery}.
- */
-interface WatchExecuteOptions {
-    sql: string;
-    parameters: any[];
-    db: AbstractPowerSyncDatabase;
-}
-/**
- * Similar to {@link CompatibleQuery}, except the `execute` method
- * does not enforce an Array result type.
- */
-interface WatchCompatibleQuery<ResultType> {
-    execute(options: WatchExecuteOptions): Promise<ResultType>;
-    compile(): CompiledQuery;
-}
-interface WatchedQueryOptions {
-    /** The minimum interval between queries. */
-    throttleMs?: number;
-    /**
-     * If true (default) the watched query will update its state to report
-     * on the fetching state of the query.
-     * Setting to false reduces the number of state changes if the fetch status
-     * is not relevant to the consumer.
-     */
-    reportFetching?: boolean;
-    /**
-     * By default, watched queries requery the database on any change to any dependent table of the query.
-     * Supplying an override here can be used to limit the tables which trigger querying the database.
-     */
-    triggerOnTables?: string[];
-}
-declare enum WatchedQueryListenerEvent {
-    ON_DATA = "onData",
-    ON_ERROR = "onError",
-    ON_STATE_CHANGE = "onStateChange",
-    SETTINGS_WILL_UPDATE = "settingsWillUpdate",
-    CLOSED = "closed"
-}
-interface WatchedQueryListener<Data> extends BaseListener {
-    [WatchedQueryListenerEvent.ON_DATA]?: (data: Data) => void | Promise<void>;
-    [WatchedQueryListenerEvent.ON_ERROR]?: (error: Error) => void | Promise<void>;
-    [WatchedQueryListenerEvent.ON_STATE_CHANGE]?: (state: WatchedQueryState<Data>) => void | Promise<void>;
-    [WatchedQueryListenerEvent.SETTINGS_WILL_UPDATE]?: () => void;
-    [WatchedQueryListenerEvent.CLOSED]?: () => void | Promise<void>;
-}
-declare const DEFAULT_WATCH_THROTTLE_MS = 30;
-declare const DEFAULT_WATCH_QUERY_OPTIONS: WatchedQueryOptions;
-interface WatchedQuery<Data = unknown, Settings extends WatchedQueryOptions = WatchedQueryOptions, Listener extends WatchedQueryListener<Data> = WatchedQueryListener<Data>> extends MetaBaseObserverInterface<Listener> {
-    /**
-     * Current state of the watched query.
-     */
-    readonly state: WatchedQueryState<Data>;
-    readonly closed: boolean;
-    /**
-     * Subscribe to watched query events.
-     * @returns A function to unsubscribe from the events.
-     */
-    registerListener(listener: Listener): () => void;
-    /**
-     * Updates the underlying query options.
-     * This will trigger a re-evaluation of the query and update the state.
-     */
-    updateSettings(options: Settings): Promise<void>;
-    /**
-     * Close the watched query and end all subscriptions.
-     */
-    close(): Promise<void>;
-}
-
-/**
- * @internal
- */
-interface AbstractQueryProcessorOptions<Data, Settings extends WatchedQueryOptions = WatchedQueryOptions> {
-    db: AbstractPowerSyncDatabase;
-    watchOptions: Settings;
-    placeholderData: Data;
-}
-/**
- * @internal
- */
-interface LinkQueryOptions<Data, Settings extends WatchedQueryOptions = WatchedQueryOptions> {
-    abortSignal: AbortSignal;
-    settings: Settings;
-}
-type MutableDeep<T> = T extends ReadonlyArray<infer U> ? U[] : T;
-/**
- * @internal Mutable version of {@link WatchedQueryState}.
- * This is used internally to allow updates to the state.
- */
-type MutableWatchedQueryState<Data> = {
-    -readonly [P in keyof WatchedQueryState<Data>]: MutableDeep<WatchedQueryState<Data>[P]>;
-};
-type WatchedQueryProcessorListener<Data> = WatchedQueryListener<Data>;
-/**
- * Performs underlying watching and yields a stream of results.
- * @internal
- */
-declare abstract class AbstractQueryProcessor<Data = unknown[], Settings extends WatchedQueryOptions = WatchedQueryOptions> extends MetaBaseObserver<WatchedQueryProcessorListener<Data>> implements WatchedQuery<Data, Settings> {
-    protected options: AbstractQueryProcessorOptions<Data, Settings>;
-    readonly state: WatchedQueryState<Data>;
-    protected abortController: AbortController;
-    protected initialized: Promise<void>;
-    protected _closed: boolean;
-    protected disposeListeners: (() => void) | null;
-    get closed(): boolean;
-    constructor(options: AbstractQueryProcessorOptions<Data, Settings>);
-    protected constructInitialState(): WatchedQueryState<Data>;
-    protected get reportFetching(): boolean;
-    protected updateSettingsInternal(settings: Settings, signal: AbortSignal): Promise<void>;
-    /**
-     * Updates the underlying query.
-     */
-    updateSettings(settings: Settings): Promise<void>;
-    /**
-     * This method is used to link a query to the subscribers of this listener class.
-     * This method should perform actual query watching and report results via {@link updateState} method.
-     */
-    protected abstract linkQuery(options: LinkQueryOptions<Data>): Promise<void>;
-    protected updateState(update: Partial<MutableWatchedQueryState<Data>>): Promise<void>;
-    /**
-     * Configures base DB listeners and links the query to listeners.
-     */
-    protected init(signal: AbortSignal): Promise<void>;
-    close(): Promise<void>;
-    /**
-     * Runs a callback and reports errors to the error listeners.
-     */
-    protected runWithReporting<T>(callback: () => Promise<T>): Promise<void>;
-    /**
-     * Iterate listeners and reports errors to onError handlers.
-     */
-    protected iterateAsyncListenersWithError(callback: (listener: Partial<WatchedQueryProcessorListener<Data>>) => Promise<void> | void): Promise<void>;
-}
-
-/**
- * Represents an updated row in a differential watched query.
- * It contains both the current and previous state of the row.
- */
-interface WatchedQueryRowDifferential<RowType> {
-    readonly current: RowType;
-    readonly previous: RowType;
-}
-/**
- * Represents the result of a watched query that has been diffed.
- * {@link DifferentialWatchedQueryState#diff} is of the {@link WatchedQueryDifferential} form.
- */
-interface WatchedQueryDifferential<RowType> {
-    readonly added: ReadonlyArray<Readonly<RowType>>;
-    /**
-     * The entire current result set.
-     * Array item object references are preserved between updates if the item is unchanged.
-     *
-     * e.g. In the query
-     * ```sql
-     *  SELECT name, make FROM assets ORDER BY make ASC;
-     * ```
-     *
-     * If a previous result set contains an item (A) `{name: 'pc', make: 'Cool PC'}` and
-     * an update has been made which adds another item (B) to the result set (the item A is unchanged) - then
-     * the updated result set will be contain the same object reference, to item A, as the previous result set.
-     * This is regardless of the item A's position in the updated result set.
-     */
-    readonly all: ReadonlyArray<Readonly<RowType>>;
-    readonly removed: ReadonlyArray<Readonly<RowType>>;
-    readonly updated: ReadonlyArray<WatchedQueryRowDifferential<Readonly<RowType>>>;
-    readonly unchanged: ReadonlyArray<Readonly<RowType>>;
-}
-/**
- * Row comparator for differentially watched queries which keys and compares items in the result set.
- */
-interface DifferentialWatchedQueryComparator<RowType> {
-    /**
-     * Generates a unique key for the item.
-     */
-    keyBy: (item: RowType) => string;
-    /**
-     * Generates a token for comparing items with matching keys.
-     */
-    compareBy: (item: RowType) => string;
-}
-/**
- * Options for building a differential watched query with the {@link Query} builder.
- */
-interface DifferentialWatchedQueryOptions<RowType> extends WatchedQueryOptions {
-    /**
-     * Initial result data which is presented while the initial loading is executing.
-     */
-    placeholderData?: RowType[];
-    /**
-     * Row comparator used to identify and compare rows in the result set.
-     * If not provided, the default comparator will be used which keys items by their `id` property if available,
-     * otherwise it uses JSON stringification of the entire item for keying and comparison.
-     * @defaultValue {@link DEFAULT_ROW_COMPARATOR}
-     */
-    rowComparator?: DifferentialWatchedQueryComparator<RowType>;
-}
-/**
- * Settings for differential incremental watched queries using.
- */
-interface DifferentialWatchedQuerySettings<RowType> extends DifferentialWatchedQueryOptions<RowType> {
-    /**
-     * The query here must return an array of items that can be differentiated.
-     */
-    query: WatchCompatibleQuery<RowType[]>;
-}
-interface DifferentialWatchedQueryListener<RowType> extends WatchedQueryListener<ReadonlyArray<Readonly<RowType>>> {
-    onDiff?: (diff: WatchedQueryDifferential<RowType>) => void | Promise<void>;
-}
-type DifferentialWatchedQuery<RowType> = WatchedQuery<ReadonlyArray<Readonly<RowType>>, DifferentialWatchedQuerySettings<RowType>, DifferentialWatchedQueryListener<RowType>>;
-/**
- * @internal
- */
-interface DifferentialQueryProcessorOptions<RowType> extends AbstractQueryProcessorOptions<RowType[], DifferentialWatchedQuerySettings<RowType>> {
-    rowComparator?: DifferentialWatchedQueryComparator<RowType>;
-}
-type DataHashMap<RowType> = Map<string, {
-    hash: string;
-    item: RowType;
-}>;
-/**
- * An empty differential result set.
- * This is used as the initial state for differential incrementally watched queries.
- */
-declare const EMPTY_DIFFERENTIAL: {
-    added: never[];
-    all: never[];
-    removed: never[];
-    updated: never[];
-    unchanged: never[];
-};
-/**
- * Default implementation of the {@link DifferentialWatchedQueryComparator} for watched queries.
- * It keys items by their `id` property if available, alternatively it uses JSON stringification
- * of the entire item for the key and comparison.
- */
-declare const DEFAULT_ROW_COMPARATOR: DifferentialWatchedQueryComparator<any>;
-/**
- * Uses the PowerSync onChange event to trigger watched queries.
- * Results are emitted on every change of the relevant tables.
- * @internal
- */
-declare class DifferentialQueryProcessor<RowType> extends AbstractQueryProcessor<ReadonlyArray<Readonly<RowType>>, DifferentialWatchedQuerySettings<RowType>> implements DifferentialWatchedQuery<RowType> {
-    protected options: DifferentialQueryProcessorOptions<RowType>;
-    protected comparator: DifferentialWatchedQueryComparator<RowType>;
-    constructor(options: DifferentialQueryProcessorOptions<RowType>);
-    protected differentiate(current: RowType[], previousMap: DataHashMap<RowType>): {
-        diff: WatchedQueryDifferential<RowType>;
-        map: DataHashMap<RowType>;
-        hasChanged: boolean;
-    };
-    protected linkQuery(options: LinkQueryOptions<WatchedQueryDifferential<RowType>>): Promise<void>;
-}
-
-/**
- * Settings for {@link WatchedQuery} instances created via {@link Query#watch}.
- */
-interface WatchedQuerySettings<DataType> extends WatchedQueryOptions {
-    query: WatchCompatibleQuery<DataType>;
-}
-/**
- * {@link WatchedQuery} returned from {@link Query#watch}.
- */
-type StandardWatchedQuery<DataType> = WatchedQuery<DataType, WatchedQuerySettings<DataType>>;
-/**
- * @internal
- */
-interface OnChangeQueryProcessorOptions<Data> extends AbstractQueryProcessorOptions<Data, WatchedQuerySettings<Data>> {
-    comparator?: WatchedQueryComparator<Data>;
-}
-/**
- * Uses the PowerSync onChange event to trigger watched queries.
- * Results are emitted on every change of the relevant tables.
- * @internal
- */
-declare class OnChangeQueryProcessor<Data> extends AbstractQueryProcessor<Data, WatchedQuerySettings<Data>> {
-    protected options: OnChangeQueryProcessorOptions<Data>;
-    constructor(options: OnChangeQueryProcessorOptions<Data>);
-    /**
-     * @returns If the sets are equal
-     */
-    protected checkEquality(current: Data, previous: Data): boolean;
-    protected linkQuery(options: LinkQueryOptions<Data>): Promise<void>;
-}
-
-/**
- * Query parameters for {@link ArrayQueryDefinition#parameters}
- */
-type QueryParam = string | number | boolean | null | undefined | bigint | Uint8Array;
-/**
- * Options for building a query with {@link AbstractPowerSyncDatabase#query}.
- * This query will be executed with {@link AbstractPowerSyncDatabase#getAll}.
- */
-interface ArrayQueryDefinition<RowType = unknown> {
-    sql: string;
-    parameters?: ReadonlyArray<Readonly<QueryParam>>;
-    /**
-     * Maps the raw SQLite row to a custom typed object.
-     * @example
-     * ```javascript
-     * mapper: (row) => ({
-     *  ...row,
-     *  created_at: new Date(row.created_at as string),
-     * })
-     * ```
-     */
-    mapper?: (row: Record<string, unknown>) => RowType;
-}
-/**
- * Options for {@link Query#watch}.
- */
-interface StandardWatchedQueryOptions<RowType> extends WatchedQueryOptions {
-    /**
-     * The underlying watched query implementation (re)evaluates the query on any SQLite table change.
-     *
-     * Providing this optional comparator can be used to filter duplicate result set emissions when the result set is unchanged.
-     * The comparator compares the previous and current result set.
-     *
-     * For an efficient comparator see {@link ArrayComparator}.
-     *
-     * @example
-     * ```javascript
-     * comparator: new ArrayComparator({
-     *     compareBy: (item) => JSON.stringify(item)
-     * })
-     * ```
-     */
-    comparator?: WatchedQueryComparator<RowType[]>;
-    /**
-     * The initial data state reported while the query is loading for the first time.
-     * @default []
-     */
-    placeholderData?: RowType[];
-}
-interface Query<RowType> {
-    /**
-     * Creates a {@link WatchedQuery} which watches and emits results of the linked query.
-     *
-     * By default the returned watched query will emit changes whenever a change to the underlying SQLite tables is made.
-     * These changes might not be relevant to the query, but the query will emit a new result set.
-     *
-     * A {@link StandardWatchedQueryOptions#comparator} can be provided to limit the data emissions. The watched query will still
-     * query the underlying DB on underlying table changes, but the result will only be emitted if the comparator detects a change in the results.
-     *
-     * The comparator in this method is optimized and returns early as soon as it detects a change. Each data emission will correlate to a change in the result set,
-     * but note that the result set will not maintain internal object references to the previous result set. If internal object references are needed,
-     * consider using {@link Query#differentialWatch} instead.
-     */
-    watch(options?: StandardWatchedQueryOptions<RowType>): StandardWatchedQuery<ReadonlyArray<Readonly<RowType>>>;
-    /**
-     * Creates a {@link WatchedQuery} which watches and emits results of the linked query.
-     *
-     * This query method watches for changes in the underlying SQLite tables and runs the query on each table change.
-     * The difference between the current and previous result set is computed.
-     * The watched query will not emit changes if the result set is identical to the previous result set.
-     *
-     * If the result set is different, the watched query will emit the new result set and emit a detailed diff of the changes via the `onData` and `onDiff` listeners.
-     *
-     * The deep differentiation allows maintaining result set object references between result emissions.
-     * The {@link DifferentialWatchedQuery#state} `data` array will contain the previous row references for unchanged rows.
-     *
-     * @example
-     * ```javascript
-     * const watchedLists = powerSync.query({sql: 'SELECT * FROM lists'})
-     *  .differentialWatch();
-     *
-     * const disposeListener = watchedLists.registerListener({
-     *  onData: (lists) => {
-     *    console.log('The latest result set for the query is', lists);
-     *  },
-     *  onDiff: (diff) => {
-     *    console.log('The lists result set has changed since the last emission', diff.added, diff.removed, diff.updated, diff.all)
-     *  }
-     * })
-     * ```
-     */
-    differentialWatch(options?: DifferentialWatchedQueryOptions<RowType>): DifferentialWatchedQuery<RowType>;
-}
-
-interface SQLOpenOptions {
-    /**
-     * Filename for the database.
-     */
-    dbFilename: string;
-    /**
-     * Directory where the database file is located.
-     *
-     * When set, the directory must exist when the database is opened, it will
-     * not be created automatically.
-     */
-    dbLocation?: string;
-    /**
-     * Enable debugMode to log queries to the performance timeline.
-     *
-     * Defaults to false.
-     *
-     * To enable in development builds, use:
-     *
-     *    debugMode: process.env.NODE_ENV !== 'production'
-     */
-    debugMode?: boolean;
-}
-interface SQLOpenFactory {
-    /**
-     * Opens a connection adapter to a SQLite DB
-     */
-    openDB(): DBAdapter;
-}
-/**
- * Tests if the input is a {@link SQLOpenOptions}
- */
-declare const isSQLOpenOptions: (test: any) => test is SQLOpenOptions;
-/**
- * Tests if input is a {@link SQLOpenFactory}
- */
-declare const isSQLOpenFactory: (test: any) => test is SQLOpenFactory;
-/**
- * Tests if input is a {@link DBAdapter}
- */
-declare const isDBAdapter: (test: any) => test is DBAdapter;
-
-declare class CrudTransaction extends CrudBatch {
-    /**
-     * List of client-side changes.
-     */
-    crud: CrudEntry[];
-    /**
-     * Call to remove the changes from the local queue, once successfully uploaded.
-     */
-    complete: (checkpoint?: string) => Promise<void>;
-    /**
-     * If null, this contains a list of changes recorded without an explicit transaction associated.
-     */
-    transactionId?: number | undefined;
-    constructor(
-    /**
-     * List of client-side changes.
-     */
-    crud: CrudEntry[], 
-    /**
-     * Call to remove the changes from the local queue, once successfully uploaded.
-     */
-    complete: (checkpoint?: string) => Promise<void>, 
-    /**
-     * If null, this contains a list of changes recorded without an explicit transaction associated.
-     */
-    transactionId?: number | undefined);
-}
-
-/**
- * SQLite operations to track changes for with {@link TriggerManager}
- * @experimental
- */
-declare enum DiffTriggerOperation {
-    INSERT = "INSERT",
-    UPDATE = "UPDATE",
-    DELETE = "DELETE"
-}
-/**
- * @experimental
- * Diffs created by {@link TriggerManager#createDiffTrigger} are stored in a temporary table.
- * This is the base record structure for all diff records.
- *
- * @template TOperationId - The type for `operation_id`. Defaults to `number` as returned by default SQLite database queries.
- * Use `string` for full 64-bit precision when using `{ castOperationIdAsText: true }` option.
- */
-interface BaseTriggerDiffRecord<TOperationId extends string | number = number> {
-    /**
-     * The modified row's `id` column value.
-     */
-    id: string;
-    /**
-     * The operation performed which created this record.
-     */
-    operation: DiffTriggerOperation;
-    /**
-     * Auto-incrementing primary key for the operation.
-     * Defaults to number as returned by database queries (wa-sqlite returns lower 32 bits).
-     * Can be string for full 64-bit precision when using `{ castOperationIdAsText: true }` option.
-     */
-    operation_id: TOperationId;
-    /**
-     * Time the change operation was recorded.
-     * This is in ISO 8601 format, e.g. `2023-10-01T12:00:00.000Z`.
-     */
-    timestamp: string;
-}
-/**
- * @experimental
- * Represents a diff record for a SQLite UPDATE operation.
- * This record contains the new value and optionally the previous value.
- * Values are stored as JSON strings.
- */
-interface TriggerDiffUpdateRecord<TOperationId extends string | number = number> extends BaseTriggerDiffRecord<TOperationId> {
-    operation: DiffTriggerOperation.UPDATE;
-    /**
-     * The updated state of the row in JSON string format.
-     */
-    value: string;
-    /**
-     * The previous value of the row in JSON string format.
-     */
-    previous_value: string;
-}
-/**
- * @experimental
- * Represents a diff record for a SQLite INSERT operation.
- * This record contains the new value represented as a JSON string.
- */
-interface TriggerDiffInsertRecord<TOperationId extends string | number = number> extends BaseTriggerDiffRecord<TOperationId> {
-    operation: DiffTriggerOperation.INSERT;
-    /**
-     * The value of the row, at the time of INSERT, in JSON string format.
-     */
-    value: string;
-}
-/**
- * @experimental
- * Represents a diff record for a SQLite DELETE operation.
- * This record contains the new value represented as a JSON string.
- */
-interface TriggerDiffDeleteRecord<TOperationId extends string | number = number> extends BaseTriggerDiffRecord<TOperationId> {
-    operation: DiffTriggerOperation.DELETE;
-    /**
-     * The value of the row, before the DELETE operation, in JSON string format.
-     */
-    value: string;
-}
-/**
- * @experimental
- * Diffs created by {@link TriggerManager#createDiffTrigger} are stored in a temporary table.
- * This is the record structure for all diff records.
- *
- * Querying the DIFF table directly with {@link TriggerDiffHandlerContext#withDiff} will return records
- * with the structure of this type.
- *
- * @template TOperationId - The type for `operation_id`. Defaults to `number` as returned by database queries.
- * Use `string` for full 64-bit precision when using `{ castOperationIdAsText: true }` option.
- *
- * @example
- * ```typescript
- * // Default: operation_id is number
- * const diffs = await context.withDiff<TriggerDiffRecord>('SELECT * FROM DIFF');
- *
- * // With string operation_id for full precision
- * const diffsWithString = await context.withDiff<TriggerDiffRecord<string>>(
- *   'SELECT * FROM DIFF',
- *   undefined,
- *   { castOperationIdAsText: true }
- * );
- * ```
- */
-type TriggerDiffRecord<TOperationId extends string | number = number> = TriggerDiffUpdateRecord<TOperationId> | TriggerDiffInsertRecord<TOperationId> | TriggerDiffDeleteRecord<TOperationId>;
-/**
- * @experimental
- * Querying the DIFF table directly with {@link TriggerDiffHandlerContext#withExtractedDiff} will return records
- * with the tracked columns extracted from the JSON value.
- * This type represents the structure of such records.
- *
- * @template T - The type for the extracted columns from the tracked JSON value.
- * @template TOperationId - The type for `operation_id`. Defaults to `number` as returned by database queries.
- * Use `string` for full 64-bit precision when using `{ castOperationIdAsText: true }` option.
- *
- * @example
- * ```typescript
- * // Default: operation_id is number
- * const diffs = await context.withExtractedDiff<ExtractedTriggerDiffRecord<{id: string, name: string}>>('SELECT * FROM DIFF');
- *
- * // With string operation_id for full precision
- * const diffsWithString = await context.withExtractedDiff<ExtractedTriggerDiffRecord<{id: string, name: string}, string>>(
- *   'SELECT * FROM DIFF',
- *   undefined,
- *   { castOperationIdAsText: true }
- * );
- * ```
- */
-type ExtractedTriggerDiffRecord<T, TOperationId extends string | number = number> = T & {
-    [K in keyof Omit<BaseTriggerDiffRecord<TOperationId>, 'id'> as `__${string & K}`]: TriggerDiffRecord<TOperationId>[K];
-} & {
-    __previous_value?: string;
-};
-/**
- * @experimental
- * Hooks used in the creation of a table diff trigger.
- */
-interface TriggerCreationHooks {
-    /**
-     * Executed inside a write lock before the trigger is created.
-     */
-    beforeCreate?: (context: LockContext) => Promise<void>;
-}
-/**
- * Common interface for options used in creating a diff trigger.
- */
-interface BaseCreateDiffTriggerOptions {
-    /**
-     * PowerSync source table/view to trigger and track changes from.
-     * This should be present in the PowerSync database's schema.
-     */
-    source: string;
-    /**
-     * Columns to track and report changes for.
-     * Defaults to all columns in the source table.
-     * Use an empty array to track only the ID and operation.
-     */
-    columns?: string[];
-    /**
-     * Condition to filter when the triggers should fire.
-     * This corresponds to a SQLite [WHEN](https://sqlite.org/lang_createtrigger.html) clause in the trigger body.
-     * This is useful for only triggering on specific conditions.
-     * For example, you can use it to only trigger on certain values in the NEW row.
-     * Note that for PowerSync the row data is stored in a JSON column named `data`.
-     * The row id is available in the `id` column.
-     *
-     * NB! The WHEN clauses here are added directly to the SQLite trigger creation SQL.
-     * Any user input strings here should be sanitized externally. The {@link when} string template function performs
-     * some basic sanitization, extra external sanitization is recommended.
-     *
-     * @example
-     * {
-     *  'INSERT': sanitizeSQL`json_extract(NEW.data, '$.list_id') = ${sanitizeUUID(list.id)}`,
-     *  'INSERT': `TRUE`,
-     *  'UPDATE': sanitizeSQL`NEW.id = 'abcd' AND json_extract(NEW.data, '$.status') = 'active'`,
-     *  'DELETE': sanitizeSQL`json_extract(OLD.data, '$.list_id') = 'abcd'`
-     * }
-     */
-    when: Partial<Record<DiffTriggerOperation, string>>;
-    /**
-     * Hooks which allow execution during the trigger creation process.
-     */
-    hooks?: TriggerCreationHooks;
-    /**
-     * Use storage-backed (non-TEMP) tables and triggers that persist across sessions.
-     * These resources are still automatically disposed when no longer claimed.
-     */
-    useStorage?: boolean;
-}
-/**
- * @experimental
- * Options for {@link TriggerManager#createDiffTrigger}.
- */
-interface CreateDiffTriggerOptions extends BaseCreateDiffTriggerOptions {
-    /**
-     * Destination table to send changes to.
-     * This table is created internally as a SQLite temporary table.
-     * This table will be dropped once the trigger is removed.
-     */
-    destination: string;
-    /**
-     * Context to use for the setup operation.
-     * This is useful for when the setup operation needs to be executed in a specific context.
-     */
-    setupContext?: LockContext;
-}
-/**
- * @experimental
- * Options for {@link TriggerRemoveCallback}.
- */
-interface TriggerRemoveCallbackOptions {
-    context?: LockContext;
-}
-/**
- * @experimental
- * Callback to drop a trigger after it has been created.
- */
-type TriggerRemoveCallback = (options?: TriggerRemoveCallbackOptions) => Promise<void>;
-/**
- * @experimental
- * Options for {@link TriggerDiffHandlerContext#withDiff}.
- */
-interface WithDiffOptions {
-    /**
-     * If true, casts `operation_id` as TEXT in the internal CTE to preserve full 64-bit precision.
-     * Use this when you need to ensure `operation_id` is treated as a string to avoid precision loss
-     * for values exceeding JavaScript's Number.MAX_SAFE_INTEGER.
-     *
-     * When enabled, use {@link TriggerDiffRecord}<string> to type the result correctly.
-     */
-    castOperationIdAsText?: boolean;
-}
-/**
- * @experimental
- * Context for the `onChange` handler provided to {@link TriggerManager#trackTableDiff}.
- */
-interface TriggerDiffHandlerContext extends LockContext {
-    /**
-     * The name of the temporary destination table created by the trigger.
-     */
-    destinationTable: string;
-    /**
-     * Allows querying the database with access to the table containing DIFF records.
-     * The diff table is accessible via the `DIFF` accessor.
-     *
-     * The `DIFF` table is of the form described in {@link TriggerManager#createDiffTrigger}
-     * ```sql
-     * CREATE TEMP DIFF (
-     *       operation_id INTEGER PRIMARY KEY AUTOINCREMENT,
-     *       id TEXT,
-     *       operation TEXT,
-     *       timestamp TEXT,
-     *       value TEXT,
-     *       previous_value TEXT
-     *     );
-     * ```
-     *
-     * Note that the `value` and `previous_value` columns store the row state in JSON string format.
-     * To access the row state in an extracted form see {@link TriggerDiffHandlerContext#withExtractedDiff}.
-     *
-     * @example
-     * ```sql
-     * --- This fetches the current state of `todo` rows which have a diff operation present.
-     * --- The state of the row at the time of the operation is accessible in the DIFF records.
-     * SELECT
-     *  todos.*
-     * FROM
-     *    DIFF
-     * JOIN todos ON DIFF.id = todos.id
-     * WHERE json_extract(DIFF.value, '$.status') = 'active'
-     * ```
-     *
-     * @example
-     * ```typescript
-     * // With operation_id cast as TEXT for full precision
-     * const diffs = await context.withDiff<TriggerDiffRecord<string>>(
-     *   'SELECT * FROM DIFF',
-     *   undefined,
-     *   { castOperationIdAsText: true }
-     * );
-     * // diffs[0].operation_id is now typed as string
-     * ```
-     */
-    withDiff: <T = any>(query: string, params?: ReadonlyArray<Readonly<any>>, options?: WithDiffOptions) => Promise<T[]>;
-    /**
-     * Allows querying the database with access to the table containing diff records.
-     * The diff table is accessible via the `DIFF` accessor.
-     *
-     * This is similar to {@link withDiff} but extracts the row columns from the tracked JSON value. The diff operation
-     * data is aliased as `__` columns to avoid column conflicts.
-     *
-     * For {@link DiffTriggerOperation#DELETE} operations the previous_value columns are extracted for convenience.
-     *
-     *
-     * ```sql
-     * CREATE TEMP TABLE DIFF (
-     *       id TEXT,
-     *       replicated_column_1 COLUMN_TYPE,
-     *       replicated_column_2 COLUMN_TYPE,
-     *       __operation TEXT,
-     *       __timestamp TEXT,
-     *       __previous_value TEXT
-     *     );
-     * ```
-     *
-     * @example
-     * ```sql
-     * SELECT
-     *  todos.*
-     * FROM
-     *    DIFF
-     *  JOIN todos ON DIFF.id = todos.id
-     * --- The todo column names are extracted from json and are available as DIFF.name
-     * WHERE DIFF.name = 'example'
-     * ```
-     */
-    withExtractedDiff: <T = any>(query: string, params?: ReadonlyArray<Readonly<any>>) => Promise<T[]>;
-}
-/**
- * @experimental
- * Options for tracking changes to a table with {@link TriggerManager#trackTableDiff}.
- */
-interface TrackDiffOptions extends BaseCreateDiffTriggerOptions {
-    /**
-     * Handler for processing diff operations.
-     * Automatically invoked once diff items are present.
-     * Diff items are automatically cleared after the handler is invoked.
-     */
-    onChange: (context: TriggerDiffHandlerContext) => Promise<void>;
-    /**
-     * The minimum interval, in milliseconds, between {@link onChange} invocations.
-     *  @default {@link DEFAULT_WATCH_THROTTLE_MS}
-     */
-    throttleMs?: number;
-}
-/**
- * @experimental
- */
-interface TriggerManager {
-    /**
-     * @experimental
-     * Creates a temporary trigger which tracks changes to a source table
-     * and writes changes to a destination table.
-     * The temporary destination table is created internally and will be dropped when the trigger is removed.
-     * The temporary destination table is created with the structure:
-     *
-     * ```sql
-     * CREATE TEMP TABLE ${destination} (
-     *       operation_id INTEGER PRIMARY KEY AUTOINCREMENT,
-     *       id TEXT,
-     *       operation TEXT,
-     *       timestamp TEXT,
-     *       value TEXT,
-     *       previous_value TEXT
-     *     );
-     * ```
-     * The `value` column contains the JSON representation of the row's value at the change.
-     *
-     * For {@link DiffTriggerOperation#UPDATE} operations the `previous_value` column contains the previous value of the changed row
-     * in a JSON format.
-     *
-     * NB: The triggers created by this method might be invalidated by {@link AbstractPowerSyncDatabase#updateSchema} calls.
-     * These triggers should manually be dropped and recreated when updating the schema.
-     *
-     * @returns A callback to remove the trigger and drop the destination table.
-     *
-     * @example
-     * ```javascript
-     * const dispose = await database.triggers.createDiffTrigger({
-     *   source: 'lists',
-     *   destination: 'ps_temp_lists_diff',
-     *   columns: ['name'],
-     *   when: {
-     *    [DiffTriggerOperation.INSERT]: 'TRUE',
-     *    [DiffTriggerOperation.UPDATE]: 'TRUE',
-     *    [DiffTriggerOperation.DELETE]: 'TRUE'
-     *   }
-     * });
-     * ```
-     */
-    createDiffTrigger(options: CreateDiffTriggerOptions): Promise<TriggerRemoveCallback>;
-    /**
-     * @experimental
-     * Tracks changes for a table. Triggering a provided handler on changes.
-     * Uses {@link createDiffTrigger} internally to create a temporary destination table.
-     *
-     * @returns A callback to cleanup the trigger and stop tracking changes.
-     *
-     * NB: The triggers created by this method might be invalidated by {@link AbstractPowerSyncDatabase#updateSchema} calls.
-     * These triggers should manually be dropped and recreated when updating the schema.
-     *
-     * @example
-     * ```javascript
-     *  const dispose = database.triggers.trackTableDiff({
-     *        source: 'todos',
-     *        columns: ['list_id'],
-     *        when: {
-     *          [DiffTriggerOperation.INSERT]: sanitizeSQL`json_extract(NEW.data, '$.list_id') = ${sanitizeUUID(someIdVariable)}`
-     *        },
-     *        onChange: async (context) => {
-     *          // Fetches the todo records that were inserted during this diff
-     *          const newTodos = await context.withDiff<Database['todos']>(`
-     *            SELECT
-     *              todos.*
-     *            FROM
-     *              DIFF
-     *              JOIN todos ON DIFF.id = todos.id
-     *          `);
-     *
-     *          // Process newly created todos
-     *        },
-     *        hooks: {
-     *          beforeCreate: async (lockContext) => {
-     *            // This hook is executed inside the write lock before the trigger is created.
-     *            // It can be used to synchronize the current state of the table with processor logic.
-     *            // Any changes after this callback are guaranteed to trigger the `onChange` handler.
-     *
-     *            // Read the current state of the todos table
-     *            const currentTodos = await lockContext.getAll<Database['todos']>(
-     *              `
-     *                SELECT
-     *                  *
-     *                FROM
-     *                  todos
-     *                WHERE
-     *                  list_id = ?
-     *              `,
-     *              ['123']
-     *            );
-     *
-     *            // Process existing todos
-     *          }
-     *        }
-     *      });
-     * ```
-     */
-    trackTableDiff(options: TrackDiffOptions): Promise<TriggerRemoveCallback>;
-}
-/**
- * @experimental
- * @internal
- * Manages claims on persisted SQLite triggers and destination tables to enable proper cleanup
- * when they are no longer actively in use.
- *
- * When using persisted triggers (especially for OPFS multi-tab scenarios), we need a reliable way to determine which resources are still actively in use across different connections/tabs so stale resources can be safely cleaned up without interfering with active triggers.
- *
- * A cleanup process runs
- * on database creation (and every 2 minutes) that:
- * 1. Queries for existing managed persisted resources
- * 2. Checks with the claim manager if any consumer is actively using those resources
- * 3. Deletes unused resources
- */
-interface TriggerClaimManager {
-    /**
-     * Obtains or marks a claim on a certain identifier.
-     * @returns a callback to release the claim.
-     */
-    obtainClaim: (identifier: string) => Promise<() => Promise<void>>;
-    /**
-     * Checks if a claim is present for an identifier.
-     */
-    checkClaim: (identifier: string) => Promise<boolean>;
-}
-/**
- * @experimental
- * @internal
- */
-interface TriggerManagerConfig {
-    claimManager: TriggerClaimManager;
-}
-
-type TriggerManagerImplOptions = TriggerManagerConfig & {
-    db: AbstractPowerSyncDatabase;
-    schema: Schema;
-};
-type TriggerManagerImplConfiguration = {
-    useStorageByDefault: boolean;
-};
-/**
- * @internal
- * @experimental
- */
-declare class TriggerManagerImpl implements TriggerManager {
-    protected options: TriggerManagerImplOptions;
-    protected schema: Schema;
-    protected defaultConfig: TriggerManagerImplConfiguration;
-    protected cleanupTimeout: ReturnType<typeof setTimeout> | null;
-    protected isDisposed: boolean;
-    constructor(options: TriggerManagerImplOptions);
-    protected get db(): AbstractPowerSyncDatabase;
-    protected getUUID(): Promise<string>;
-    protected removeTriggers(tx: LockContext, triggerIds: string[]): Promise<void>;
-    dispose(): void;
-    /**
-     * Updates default config settings for platform specific use-cases.
-     */
-    updateDefaults(config: TriggerManagerImplConfiguration): void;
-    protected generateTriggerName(operation: DiffTriggerOperation, destinationTable: string, triggerId: string): string;
-    /**
-     * Cleanup any SQLite triggers or tables that are no longer in use.
-     */
-    cleanupResources(): Promise<void>;
-    createDiffTrigger(options: CreateDiffTriggerOptions): Promise<(options?: TriggerRemoveCallbackOptions) => Promise<void>>;
-    trackTableDiff(options: TrackDiffOptions): Promise<TriggerRemoveCallback>;
-}
-
-type UnlockFn = () => void;
-/**
- * An asynchronous semaphore implementation with associated items per lease.
- *
- * @internal This class is meant to be used in PowerSync SDKs only, and is not part of the public API.
- */
-declare class Semaphore<T> {
-    private readonly available;
-    readonly size: number;
-    private firstWaiter?;
-    private lastWaiter?;
-    constructor(elements: Iterable<T>);
-    private addWaiter;
-    private deactivateWaiter;
-    private requestPermits;
-    /**
-     * Requests a single item from the pool.
-     *
-     * The returned `release` callback must be invoked to return the item into the pool.
-     */
-    requestOne(abort?: AbortSignal): Promise<{
-        item: T;
-        release: UnlockFn;
-    }>;
-    /**
-     * Requests access to all items from the pool.
-     *
-     * The returned `release` callback must be invoked to return items into the pool.
-     */
-    requestAll(abort?: AbortSignal): Promise<{
-        items: T[];
-        release: UnlockFn;
-    }>;
-}
-/**
- * An asynchronous mutex implementation.
- *
- * @internal This class is meant to be used in PowerSync SDKs only, and is not part of the public API.
- */
-declare class Mutex {
-    private inner;
-    acquire(abort?: AbortSignal): Promise<UnlockFn>;
-    runExclusive<T>(fn: () => PromiseLike<T> | T, abort?: AbortSignal): Promise<T>;
-}
-/**
- * Creates a signal aborting after the set timeout.
- */
-declare function timeoutSignal(timeout: number): AbortSignal;
-declare function timeoutSignal(timeout?: number): AbortSignal | undefined;
-
-interface DisconnectAndClearOptions {
-    /** When set to false, data in local-only tables is preserved. */
-    clearLocal?: boolean;
-}
-interface BasePowerSyncDatabaseOptions extends AdditionalConnectionOptions {
-    /** Schema used for the local database. */
-    schema: Schema;
-    /**
-     * @deprecated Use {@link retryDelayMs} instead as this will be removed in future releases.
-     */
-    retryDelay?: number;
-    logger?: ILogger;
-}
-interface PowerSyncDatabaseOptions extends BasePowerSyncDatabaseOptions {
-    /**
-     * Source for a SQLite database connection.
-     * This can be either:
-     *  - A {@link DBAdapter} if providing an instantiated SQLite connection
-     *  - A {@link SQLOpenFactory} which will be used to open a SQLite connection
-     *  - {@link SQLOpenOptions} for opening a SQLite connection with a default {@link SQLOpenFactory}
-     */
-    database: DBAdapter | SQLOpenFactory | SQLOpenOptions;
-}
-interface PowerSyncDatabaseOptionsWithDBAdapter extends BasePowerSyncDatabaseOptions {
-    database: DBAdapter;
-}
-interface PowerSyncDatabaseOptionsWithOpenFactory extends BasePowerSyncDatabaseOptions {
-    database: SQLOpenFactory;
-}
-interface PowerSyncDatabaseOptionsWithSettings extends BasePowerSyncDatabaseOptions {
-    database: SQLOpenOptions;
-}
-interface SQLOnChangeOptions {
-    signal?: AbortSignal;
-    tables?: string[];
-    /** The minimum interval between queries. */
-    throttleMs?: number;
-    /**
-     * @deprecated All tables specified in {@link tables} will be watched, including PowerSync tables with prefixes.
-     *
-     * Allows for watching any SQL table
-     * by not removing PowerSync table name prefixes
-     */
-    rawTableNames?: boolean;
-    /**
-     * Emits an empty result set immediately
-     */
-    triggerImmediate?: boolean;
-}
-interface SQLWatchOptions extends SQLOnChangeOptions {
-    /**
-     * Optional comparator which will be used to compare the results of the query.
-     * The watched query will only yield results if the comparator returns false.
-     */
-    comparator?: WatchedQueryComparator<QueryResult>;
-}
-interface WatchOnChangeEvent {
-    changedTables: string[];
-}
-interface WatchHandler {
-    onResult: (results: QueryResult) => void;
-    onError?: (error: Error) => void;
-}
-interface WatchOnChangeHandler {
-    onChange: (event: WatchOnChangeEvent) => Promise<void> | void;
-    onError?: (error: Error) => void;
-}
-interface PowerSyncDBListener extends StreamingSyncImplementationListener {
-    initialized: () => void;
-    schemaChanged: (schema: Schema) => void;
-    closing: () => Promise<void> | void;
-    closed: () => Promise<void> | void;
-}
-interface PowerSyncCloseOptions {
-    /**
-     * Disconnect the sync stream client if connected.
-     * This is usually true, but can be false for Web when using
-     * multiple tabs and a shared sync provider.
-     */
-    disconnect?: boolean;
-}
-declare const DEFAULT_POWERSYNC_CLOSE_OPTIONS: PowerSyncCloseOptions;
-declare const DEFAULT_POWERSYNC_DB_OPTIONS: {
-    retryDelayMs: number;
-    crudUploadThrottleMs: number;
-};
-declare const DEFAULT_CRUD_BATCH_LIMIT = 100;
-/**
- * Requesting nested or recursive locks can block the application in some circumstances.
- * This default lock timeout will act as a failsafe to throw an error if a lock cannot
- * be obtained.
- */
-declare const DEFAULT_LOCK_TIMEOUT_MS = 120000;
-/**
- * Tests if the input is a {@link PowerSyncDatabaseOptionsWithSettings}
- * @internal
- */
-declare const isPowerSyncDatabaseOptionsWithSettings: (test: any) => test is PowerSyncDatabaseOptionsWithSettings;
-declare abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDBListener> {
-    protected options: PowerSyncDatabaseOptions;
-    /**
-     * Returns true if the connection is closed.
-     */
-    closed: boolean;
-    ready: boolean;
-    /**
-     * Current connection status.
-     */
-    currentStatus: SyncStatus;
-    sdkVersion: string;
-    protected bucketStorageAdapter: BucketStorageAdapter;
-    protected _isReadyPromise: Promise<void>;
-    protected connectionManager: ConnectionManager;
-    private subscriptions;
-    get syncStreamImplementation(): StreamingSyncImplementation | null;
-    /**
-     * The connector used to connect to the PowerSync service.
-     *
-     * @returns The connector used to connect to the PowerSync service or null if `connect()` has not been called.
-     */
-    get connector(): PowerSyncBackendConnector | null;
-    /**
-     * The resolved connection options used to connect to the PowerSync service.
-     *
-     * @returns The resolved connection options used to connect to the PowerSync service or null if `connect()` has not been called.
-     */
-    get connectionOptions(): InternalConnectionOptions | null;
-    protected _schema: Schema;
-    private _database;
-    protected runExclusiveMutex: Mutex;
-    /**
-     * @experimental
-     * Allows creating SQLite triggers which can be used to track various operations on SQLite tables.
-     */
-    readonly triggers: TriggerManager;
-    protected triggersImpl: TriggerManagerImpl;
-    logger: ILogger;
-    constructor(options: PowerSyncDatabaseOptionsWithDBAdapter);
-    constructor(options: PowerSyncDatabaseOptionsWithOpenFactory);
-    constructor(options: PowerSyncDatabaseOptionsWithSettings);
-    constructor(options: PowerSyncDatabaseOptions);
-    /**
-     * Schema used for the local database.
-     */
-    get schema(): Schema<{
-        [x: string]: Table<any>;
-    }>;
-    /**
-     * The underlying database.
-     *
-     * For the most part, behavior is the same whether querying on the underlying database, or on {@link AbstractPowerSyncDatabase}.
-     */
-    get database(): DBAdapter;
-    /**
-     * Whether a connection to the PowerSync service is currently open.
-     */
-    get connected(): boolean;
-    get connecting(): boolean;
-    /**
-     * Opens the DBAdapter given open options using a default open factory
-     */
-    protected abstract openDBAdapter(options: PowerSyncDatabaseOptionsWithSettings): DBAdapter;
-    /**
-     * Generates a base configuration for {@link TriggerManagerImpl}.
-     * Implementations should override this if necessary.
-     */
-    protected generateTriggerManagerConfig(): TriggerManagerConfig;
-    protected abstract generateSyncStreamImplementation(connector: PowerSyncBackendConnector, options: CreateSyncImplementationOptions & RequiredAdditionalConnectionOptions): StreamingSyncImplementation;
-    protected abstract generateBucketStorageAdapter(): BucketStorageAdapter;
-    /**
-     * @returns A promise which will resolve once initialization is completed.
-     */
-    waitForReady(): Promise<void>;
-    /**
-     * Wait for the first sync operation to complete.
-     *
-     * @param request Either an abort signal (after which the promise will complete regardless of
-     * whether a full sync was completed) or an object providing an abort signal and a priority target.
-     * When a priority target is set, the promise may complete when all buckets with the given (or higher)
-     * priorities have been synchronized. This can be earlier than a complete sync.
-     * @returns A promise which will resolve once the first full sync has completed.
-     */
-    waitForFirstSync(request?: AbortSignal | {
-        signal?: AbortSignal;
-        priority?: number;
-    }): Promise<void>;
-    /**
-     * Waits for the first sync status for which the `status` callback returns a truthy value.
-     */
-    waitForStatus(predicate: (status: SyncStatus) => any, signal?: AbortSignal): Promise<void>;
-    /**
-     * Allows for extended implementations to execute custom initialization
-     * logic as part of the total init process
-     */
-    abstract _initialize(): Promise<void>;
-    /**
-     * Entry point for executing initialization logic.
-     * This is to be automatically executed in the constructor.
-     */
-    protected initialize(): Promise<void>;
-    protected loadVersion(): Promise<void>;
-    protected resolveOfflineSyncStatus(): Promise<void>;
-    /**
-     * Replace the schema with a new version. This is for advanced use cases - typically the schema should just be specified once in the constructor.
-     *
-     * Cannot be used while connected - this should only be called before {@link AbstractPowerSyncDatabase.connect}.
-     */
-    updateSchema(schema: Schema): Promise<void>;
-    /**
-     * Wait for initialization to complete.
-     * While initializing is automatic, this helps to catch and report initialization errors.
-     */
-    init(): Promise<void>;
-    protected resolvedConnectionOptions(options: CreateSyncImplementationOptions): CreateSyncImplementationOptions & RequiredAdditionalConnectionOptions;
-    /**
-     * @deprecated Use {@link AbstractPowerSyncDatabase#close} instead.
-     * Clears all listeners registered by {@link AbstractPowerSyncDatabase#registerListener}.
-     */
-    dispose(): void;
-    /**
-     * Locking mechanism for exclusively running critical portions of connect/disconnect operations.
-     * Locking here is mostly only important on web for multiple tab scenarios.
-     */
-    protected runExclusive<T>(callback: () => Promise<T>): Promise<T>;
-    /**
-     * Connects to stream of events from the PowerSync instance.
-     */
-    connect(connector: PowerSyncBackendConnector, options?: PowerSyncConnectionOptions): Promise<void>;
-    /**
-     * Close the sync connection.
-     *
-     * Use {@link connect} to connect again.
-     */
-    disconnect(): Promise<void>;
-    /**
-     *  Disconnect and clear the database.
-     *  Use this when logging out.
-     *  The database can still be queried after this is called, but the tables
-     *  would be empty.
-     *
-     * To preserve data in local-only tables, set clearLocal to false.
-     */
-    disconnectAndClear(options?: DisconnectAndClearOptions): Promise<void>;
-    /**
-     * Create a sync stream to query its status or to subscribe to it.
-     *
-     * @param name The name of the stream to subscribe to.
-     * @param params Optional parameters for the stream subscription.
-     * @returns A {@link SyncStream} instance that can be subscribed to.
-     * @experimental Sync streams are currently in alpha.
-     */
-    syncStream(name: string, params?: Record<string, any>): SyncStream;
-    /**
-     * Close the database, releasing resources.
-     *
-     * Also disconnects any active connection.
-     *
-     * Once close is called, this connection cannot be used again - a new one
-     * must be constructed.
-     */
-    close(options?: PowerSyncCloseOptions): Promise<void>;
-    /**
-     * Get upload queue size estimate and count.
-     */
-    getUploadQueueStats(includeSize?: boolean): Promise<UploadQueueStats>;
-    /**
-     * Get a batch of CRUD data to upload.
-     *
-     * Returns null if there is no data to upload.
-     *
-     * Use this from the {@link PowerSyncBackendConnector.uploadData} callback.
-     *
-     * Once the data have been successfully uploaded, call {@link CrudBatch.complete} before
-     * requesting the next batch.
-     *
-     * Use {@link limit} to specify the maximum number of updates to return in a single
-     * batch.
-     *
-     * This method does include transaction ids in the result, but does not group
-     * data by transaction. One batch may contain data from multiple transactions,
-     * and a single transaction may be split over multiple batches.
-     *
-     * @param limit Maximum number of CRUD entries to include in the batch
-     * @returns A batch of CRUD operations to upload, or null if there are none
-     */
-    getCrudBatch(limit?: number): Promise<CrudBatch | null>;
-    /**
-     * Get the next recorded transaction to upload.
-     *
-     * Returns null if there is no data to upload.
-     *
-     * Use this from the {@link PowerSyncBackendConnector.uploadData} callback.
-     *
-     * Once the data have been successfully uploaded, call {@link CrudTransaction.complete} before
-     * requesting the next transaction.
-     *
-     * Unlike {@link getCrudBatch}, this only returns data from a single transaction at a time.
-     * All data for the transaction is loaded into memory.
-     *
-     * @returns A transaction of CRUD operations to upload, or null if there are none
-     */
-    getNextCrudTransaction(): Promise<CrudTransaction | null>;
-    /**
-     * Returns an async iterator of completed transactions with local writes against the database.
-     *
-     * This is typically used from the {@link PowerSyncBackendConnector.uploadData} callback. Each entry emitted by the
-     * returned iterator is a full transaction containing all local writes made while that transaction was active.
-     *
-     * Unlike {@link getNextCrudTransaction}, which always returns the oldest transaction that hasn't been
-     * {@link CrudTransaction.complete}d yet, this iterator can be used to receive multiple transactions. Calling
-     * {@link CrudTransaction.complete} will mark that and all prior transactions emitted by the iterator as completed.
-     *
-     * This can be used to upload multiple transactions in a single batch, e.g with:
-     *
-     * ```JavaScript
-     * let lastTransaction = null;
-     * let batch = [];
-     *
-     * for await (const transaction of database.getCrudTransactions()) {
-     *   batch.push(...transaction.crud);
-     *   lastTransaction = transaction;
-     *
-     *   if (batch.length > 10) {
-     *     break;
-     *    }
-     * }
-     * ```
-     *
-     * If there is no local data to upload, the async iterator complete without emitting any items.
-     *
-     * Note that iterating over async iterables requires a [polyfill](https://github.com/powersync-ja/powersync-js/tree/main/packages/react-native#babel-plugins-watched-queries)
-     * for React Native.
-     */
-    getCrudTransactions(): AsyncIterable<CrudTransaction, null>;
-    /**
-     * Get an unique client id for this database.
-     *
-     * The id is not reset when the database is cleared, only when the database is deleted.
-     *
-     * @returns A unique identifier for the database instance
-     */
-    getClientId(): Promise<string>;
-    private handleCrudCheckpoint;
-    /**
-     * Execute a SQL write (INSERT/UPDATE/DELETE) query
-     * and optionally return results.
-     *
-     * When using the default client-side [JSON-based view system](https://docs.powersync.com/architecture/client-architecture#client-side-schema-and-sqlite-database-structure),
-     * the returned result's `rowsAffected` may be `0` for successful `UPDATE` and `DELETE` statements.
-     * Use a `RETURNING` clause and inspect `result.rows` when you need to confirm which rows changed.
-     *
-     * @param sql The SQL query to execute
-     * @param parameters Optional array of parameters to bind to the query
-     * @returns The query result as an object with structured key-value pairs
-     */
-    execute(sql: string, parameters?: any[]): Promise<QueryResult>;
-    /**
-     * Execute a SQL write (INSERT/UPDATE/DELETE) query directly on the database without any PowerSync processing.
-     * This bypasses certain PowerSync abstractions and is useful for accessing the raw database results.
-     *
-     * @param sql The SQL query to execute
-     * @param parameters Optional array of parameters to bind to the query
-     * @returns The raw query result from the underlying database as a nested array of raw values, where each row is
-     * represented as an array of column values without field names.
-     */
-    executeRaw(sql: string, parameters?: any[]): Promise<any[][]>;
-    /**
-     * Execute a write query (INSERT/UPDATE/DELETE) multiple times with each parameter set
-     * and optionally return results.
-     * This is faster than executing separately with each parameter set.
-     *
-     * @param sql The SQL query to execute
-     * @param parameters Optional 2D array of parameter sets, where each inner array is a set of parameters for one execution
-     * @returns The query result
-     */
-    executeBatch(sql: string, parameters?: any[][]): Promise<QueryResult>;
-    /**
-     *  Execute a read-only query and return results.
-     *
-     * @param sql The SQL query to execute
-     * @param parameters Optional array of parameters to bind to the query
-     * @returns An array of results
-     */
-    getAll<T>(sql: string, parameters?: any[]): Promise<T[]>;
-    /**
-     * Execute a read-only query and return the first result, or null if the ResultSet is empty.
-     *
-     * @param sql The SQL query to execute
-     * @param parameters Optional array of parameters to bind to the query
-     * @returns The first result if found, or null if no results are returned
-     */
-    getOptional<T>(sql: string, parameters?: any[]): Promise<T | null>;
-    /**
-     * Execute a read-only query and return the first result, error if the ResultSet is empty.
-     *
-     * @param sql The SQL query to execute
-     * @param parameters Optional array of parameters to bind to the query
-     * @returns The first result matching the query
-     * @throws Error if no rows are returned
-     */
-    get<T>(sql: string, parameters?: any[]): Promise<T>;
-    /**
-     * Takes a read lock, without starting a transaction.
-     * In most cases, {@link readTransaction} should be used instead.
-     */
-    readLock<T>(callback: (db: DBAdapter) => Promise<T>): Promise<T>;
-    /**
-     * Takes a global lock, without starting a transaction.
-     * In most cases, {@link writeTransaction} should be used instead.
-     */
-    writeLock<T>(callback: (db: DBAdapter) => Promise<T>): Promise<T>;
-    /**
-     * Open a read-only transaction.
-     * Read transactions can run concurrently to a write transaction.
-     * Changes from any write transaction are not visible to read transactions started before it.
-     *
-     * @param callback Function to execute within the transaction
-     * @param lockTimeout Time in milliseconds to wait for a lock before throwing an error
-     * @returns The result of the callback
-     * @throws Error if the lock cannot be obtained within the timeout period
-     */
-    readTransaction<T>(callback: (tx: Transaction) => Promise<T>, lockTimeout?: number): Promise<T>;
-    /**
-     * Open a read-write transaction.
-     * This takes a global lock - only one write transaction can execute against the database at a time.
-     * Statements within the transaction must be done on the provided {@link Transaction} interface.
-     *
-     * @param callback Function to execute within the transaction
-     * @param lockTimeout Time in milliseconds to wait for a lock before throwing an error
-     * @returns The result of the callback
-     * @throws Error if the lock cannot be obtained within the timeout period
-     */
-    writeTransaction<T>(callback: (tx: Transaction) => Promise<T>, lockTimeout?: number): Promise<T>;
-    /**
-     * This version of `watch` uses {@link AsyncGenerator}, for documentation see {@link watchWithAsyncGenerator}.
-     * Can be overloaded to use a callback handler instead, for documentation see {@link watchWithCallback}.
-     *
-     * @example
-     * ```javascript
-     * async *attachmentIds() {
-     *   for await (const result of this.powersync.watch(
-     *     `SELECT photo_id as id FROM todos WHERE photo_id IS NOT NULL`,
-     *     []
-     *   )) {
-     *     yield result.rows?._array.map((r) => r.id) ?? [];
-     *   }
-     * }
-     * ```
-     */
-    watch(sql: string, parameters?: any[], options?: SQLWatchOptions): AsyncIterable<QueryResult>;
-    /**
-     * See {@link watchWithCallback}.
-     *
-     * @example
-     * ```javascript
-     * onAttachmentIdsChange(onResult) {
-     *   this.powersync.watch(
-     *     `SELECT photo_id as id FROM todos WHERE photo_id IS NOT NULL`,
-     *     [],
-     *     {
-     *       onResult: (result) => onResult(result.rows?._array.map((r) => r.id) ?? [])
-     *     }
-     *   );
-     * }
-     * ```
-     */
-    watch(sql: string, parameters?: any[], handler?: WatchHandler, options?: SQLWatchOptions): void;
-    /**
-     * Allows defining a query which can be used to build a {@link WatchedQuery}.
-     * The defined query will be executed with {@link AbstractPowerSyncDatabase#getAll}.
-     * An optional mapper function can be provided to transform the results.
-     *
-     * @example
-     * ```javascript
-     * const watchedTodos = powersync.query({
-     *  sql: `SELECT photo_id as id FROM todos WHERE photo_id IS NOT NULL`,
-     *  parameters: [],
-     *  mapper: (row) => ({
-     *    ...row,
-     *    created_at: new Date(row.created_at as string)
-     *  })
-     * })
-     * .watch()
-     * // OR use .differentialWatch() for fine-grained watches.
-     * ```
-     */
-    query<RowType>(query: ArrayQueryDefinition<RowType>): Query<RowType>;
-    /**
-     * Allows building a {@link WatchedQuery} using an existing {@link WatchCompatibleQuery}.
-     * The watched query will use the provided {@link WatchCompatibleQuery.execute} method to query results.
-     *
-     * @example
-     * ```javascript
-     *
-     * // Potentially a query from an ORM like Drizzle
-     * const query = db.select().from(lists);
-     *
-     * const watchedTodos = powersync.customQuery(query)
-     * .watch()
-     * // OR use .differentialWatch() for fine-grained watches.
-     * ```
-     */
-    customQuery<RowType>(query: WatchCompatibleQuery<RowType[]>): Query<RowType>;
-    /**
-     * Execute a read query every time the source tables are modified.
-     * Use {@link SQLWatchOptions.throttleMs} to specify the minimum interval between queries.
-     * Source tables are automatically detected using `EXPLAIN QUERY PLAN`.
-     *
-     * Note that the `onChange` callback member of the handler is required.
-     *
-     * @param sql The SQL query to execute
-     * @param parameters Optional array of parameters to bind to the query
-     * @param handler Callbacks for handling results and errors
-     * @param options Options for configuring watch behavior
-     */
-    watchWithCallback(sql: string, parameters?: any[], handler?: WatchHandler, options?: SQLWatchOptions): void;
-    /**
-     * Execute a read query every time the source tables are modified.
-     * Use {@link SQLWatchOptions.throttleMs} to specify the minimum interval between queries.
-     * Source tables are automatically detected using `EXPLAIN QUERY PLAN`.
-     *
-     * @param sql The SQL query to execute
-     * @param parameters Optional array of parameters to bind to the query
-     * @param options Options for configuring watch behavior
-     * @returns An AsyncIterable that yields QueryResults whenever the data changes
-     */
-    watchWithAsyncGenerator(sql: string, parameters?: any[], options?: SQLWatchOptions): AsyncIterable<QueryResult>;
-    /**
-     * Resolves the list of tables that are used in a SQL query.
-     * If tables are specified in the options, those are used directly.
-     * Otherwise, analyzes the query using EXPLAIN to determine which tables are accessed.
-     *
-     * @param sql The SQL query to analyze
-     * @param parameters Optional parameters for the SQL query
-     * @param options Optional watch options that may contain explicit table list
-     * @returns Array of table names that the query depends on
-     */
-    resolveTables(sql: string, parameters?: any[], options?: SQLWatchOptions): Promise<string[]>;
-    /**
-     * This version of `onChange` uses {@link AsyncGenerator}, for documentation see {@link onChangeWithAsyncGenerator}.
-     * Can be overloaded to use a callback handler instead, for documentation see {@link onChangeWithCallback}.
-     *
-     * @example
-     * ```javascript
-     * async monitorChanges() {
-     *   for await (const event of this.powersync.onChange({tables: ['todos']})) {
-     *     console.log('Detected change event:', event);
-     *   }
-     * }
-     * ```
-     */
-    onChange(options?: SQLOnChangeOptions): AsyncIterable<WatchOnChangeEvent>;
-    /**
-     * See {@link onChangeWithCallback}.
-     *
-     * @example
-     * ```javascript
-     * monitorChanges() {
-     *   this.powersync.onChange({
-     *     onChange: (event) => {
-     *       console.log('Change detected:', event);
-     *     }
-     *   }, { tables: ['todos'] });
-     * }
-     * ```
-     */
-    onChange(handler?: WatchOnChangeHandler, options?: SQLOnChangeOptions): () => void;
-    /**
-     * Invoke the provided callback on any changes to any of the specified tables.
-     *
-     * This is preferred over {@link watchWithCallback} when multiple queries need to be performed
-     * together when data is changed.
-     *
-     * Note that the `onChange` callback member of the handler is required.
-     *
-     * @param handler Callbacks for handling change events and errors
-     * @param options Options for configuring watch behavior
-     * @returns A dispose function to stop watching for changes
-     */
-    onChangeWithCallback(handler?: WatchOnChangeHandler, options?: SQLOnChangeOptions): () => void;
-    /**
-     * Create a Stream of changes to any of the specified tables.
-     *
-     * This is preferred over {@link watchWithAsyncGenerator} when multiple queries need to be performed
-     * together when data is changed.
-     *
-     * Note: do not declare this as `async *onChange` as it will not work in React Native.
-     *
-     * @param options Options for configuring watch behavior
-     * @returns An AsyncIterable that yields change events whenever the specified tables change
-     */
-    onChangeWithAsyncGenerator(options?: SQLWatchOptions): AsyncIterable<WatchOnChangeEvent>;
-    private handleTableChanges;
-    private processTableUpdates;
-    /**
-     * @ignore
-     */
-    private executeReadOnly;
-}
-
-declare const LogLevel: {
-    TRACE: Logger.ILogLevel;
-    DEBUG: Logger.ILogLevel;
-    INFO: Logger.ILogLevel;
-    TIME: Logger.ILogLevel;
-    WARN: Logger.ILogLevel;
-    ERROR: Logger.ILogLevel;
-    OFF: Logger.ILogLevel;
-};
-interface CreateLoggerOptions {
-    logLevel?: ILogLevel;
-}
-/**
- * Retrieves the base (default) logger instance.
- *
- * This base logger controls the default logging configuration and is shared
- * across all loggers created with `createLogger`. Adjusting settings on this
- * base logger affects all loggers derived from it unless explicitly overridden.
- *
- */
-declare function createBaseLogger(): typeof Logger;
-/**
- * Creates and configures a new named logger based on the base logger.
- *
- * Named loggers allow specific modules or areas of your application to have
- * their own logging levels and behaviors. These loggers inherit configuration
- * from the base logger by default but can override settings independently.
- */
-declare function createLogger(name: string, options?: CreateLoggerOptions): ILogger;
-
-declare const ATTACHMENT_TABLE = "attachments";
-/**
- * AttachmentRecord represents an attachment in the local database.
- *
- * @experimental
- */
-interface AttachmentRecord {
-    id: string;
-    filename: string;
-    localUri?: string;
-    size?: number;
-    mediaType?: string;
-    timestamp?: number;
-    metaData?: string;
-    hasSynced?: boolean;
-    state: AttachmentState;
-}
-/**
- * Maps a database row to an AttachmentRecord.
- *
- * @param row - The database row object
- * @returns The corresponding AttachmentRecord
- *
- * @experimental
- */
-declare function attachmentFromSql(row: any): AttachmentRecord;
-/**
- * AttachmentState represents the current synchronization state of an attachment.
- *
- * @experimental
- */
-declare enum AttachmentState {
-    QUEUED_UPLOAD = 0,// Attachment to be uploaded
-    QUEUED_DOWNLOAD = 1,// Attachment to be downloaded
-    QUEUED_DELETE = 2,// Attachment to be deleted
-    SYNCED = 3,// Attachment has been synced
-    ARCHIVED = 4
-}
-interface AttachmentTableOptions extends Omit<TableV2Options, 'name' | 'columns'> {
-}
-/**
- * AttachmentTable defines the schema for the attachment queue table.
- *
- * @internal
- */
-declare class AttachmentTable extends Table {
-    constructor(options?: AttachmentTableOptions);
-}
-
-/**
- * AttachmentContext provides database operations for managing attachment records.
- *
- * Provides methods to query, insert, update, and delete attachment records with
- * proper transaction management through PowerSync.
- *
- * @internal
- */
-declare class AttachmentContext {
-    /** PowerSync database instance for executing queries */
-    db: AbstractPowerSyncDatabase;
-    /** Name of the database table storing attachment records */
-    tableName: string;
-    /** Logger instance for diagnostic information */
-    logger: ILogger;
-    /** Maximum number of archived attachments to keep before cleanup */
-    archivedCacheLimit: number;
-    /**
-     * Creates a new AttachmentContext instance.
-     *
-     * @param db - PowerSync database instance
-     * @param tableName - Name of the table storing attachment records. Default: 'attachments'
-     * @param logger - Logger instance for diagnostic output
-     */
-    constructor(db: AbstractPowerSyncDatabase, tableName: string | undefined, logger: ILogger, archivedCacheLimit: number);
-    /**
-     * Retrieves all active attachments that require synchronization.
-     * Active attachments include those queued for upload, download, or delete.
-     * Results are ordered by timestamp in ascending order.
-     *
-     * @returns Promise resolving to an array of active attachment records
-     */
-    getActiveAttachments(): Promise<AttachmentRecord[]>;
-    /**
-     * Retrieves all archived attachments.
-     *
-     * Archived attachments are no longer referenced but haven't been permanently deleted.
-     * These are candidates for cleanup operations to free up storage space.
-     *
-     * @returns Promise resolving to an array of archived attachment records
-     */
-    getArchivedAttachments(): Promise<AttachmentRecord[]>;
-    /**
-     * Retrieves all attachment records regardless of state.
-     * Results are ordered by timestamp in ascending order.
-     *
-     * @returns Promise resolving to an array of all attachment records
-     */
-    getAttachments(): Promise<AttachmentRecord[]>;
-    /**
-     * Inserts or updates an attachment record within an existing transaction.
-     *
-     * Performs an upsert operation (INSERT OR REPLACE). Must be called within
-     * an active database transaction context.
-     *
-     * @param attachment - The attachment record to upsert
-     * @param context - Active database transaction context
-     */
-    upsertAttachment(attachment: AttachmentRecord, context: Transaction): Promise<void>;
-    getAttachment(id: string): Promise<AttachmentRecord | undefined>;
-    /**
-     * Permanently deletes an attachment record from the database.
-     *
-     * This operation removes the attachment record but does not delete
-     * the associated local or remote files. File deletion should be handled
-     * separately through the appropriate storage adapters.
-     *
-     * @param attachmentId - Unique identifier of the attachment to delete
-     */
-    deleteAttachment(attachmentId: string): Promise<void>;
-    clearQueue(): Promise<void>;
-    deleteArchivedAttachments(callback?: (attachments: AttachmentRecord[]) => Promise<void>): Promise<boolean>;
-    /**
-     * Saves multiple attachment records in a single transaction.
-     *
-     * All updates are saved in a single batch after processing.
-     * If the attachments array is empty, no database operations are performed.
-     *
-     * @param attachments - Array of attachment records to save
-     */
-    saveAttachments(attachments: AttachmentRecord[]): Promise<void>;
-}
-
-/**
- * SyncErrorHandler provides custom error handling for attachment sync operations.
- * Implementations determine whether failed operations should be retried or archived.
- *
- * @experimental
- * @alpha This is currently experimental and may change without a major version bump.
- */
-interface AttachmentErrorHandler {
-    /**
-     * Handles a download error for a specific attachment.
-     * @param attachment The attachment that failed to download
-     * @param error The error encountered during the download
-     * @returns `true` to retry the operation, `false` to archive the attachment
-     */
-    onDownloadError(attachment: AttachmentRecord, error: unknown): Promise<boolean>;
-    /**
-     * Handles an upload error for a specific attachment.
-     * @param attachment The attachment that failed to upload
-     * @param error The error encountered during the upload
-     * @returns `true` to retry the operation, `false` to archive the attachment
-     */
-    onUploadError(attachment: AttachmentRecord, error: unknown): Promise<boolean>;
-    /**
-     * Handles a delete error for a specific attachment.
-     * @param attachment The attachment that failed to delete
-     * @param error The error encountered during the delete
-     * @returns `true` to retry the operation, `false` to archive the attachment
-     */
-    onDeleteError(attachment: AttachmentRecord, error: unknown): Promise<boolean>;
-}
-
-type AttachmentData = ArrayBuffer | string;
-declare enum EncodingType {
-    UTF8 = "utf8",
-    Base64 = "base64"
-}
-/**
- * LocalStorageAdapter defines the interface for local file storage operations.
- * Implementations handle file I/O, directory management, and storage initialization.
- *
- * @experimental
- * @alpha This is currently experimental and may change without a major version bump.
- */
-interface LocalStorageAdapter {
-    /**
-     * Saves data to a local file.
-     * @param filePath Path where the file will be stored
-     * @param data Data to store (ArrayBuffer, Blob, or string)
-     * @returns Number of bytes written
-     */
-    saveFile(filePath: string, data: AttachmentData): Promise<number>;
-    /**
-     * Retrieves file data as an ArrayBuffer.
-     * @param filePath Path where the file is stored
-     * @returns ArrayBuffer containing the file data
-     */
-    readFile(filePath: string): Promise<ArrayBuffer>;
-    /**
-     * Deletes the file at the given path.
-     * @param filePath Path where the file is stored
-     */
-    deleteFile(filePath: string): Promise<void>;
-    /**
-     * Checks if a file exists at the given path.
-     * @param filePath Path where the file is stored
-     * @returns True if the file exists, false otherwise
-     */
-    fileExists(filePath: string): Promise<boolean>;
-    /**
-     * Creates a directory at the specified path.
-     * @param path The full path to the directory
-     */
-    makeDir(path: string): Promise<void>;
-    /**
-     * Removes a directory at the specified path.
-     * @param path The full path to the directory
-     */
-    rmDir(path: string): Promise<void>;
-    /**
-     * Initializes the storage adapter (e.g., creating necessary directories).
-     */
-    initialize(): Promise<void>;
-    /**
-     * Clears all files in the storage.
-     */
-    clear(): Promise<void>;
-    /**
-     * Returns the file path for the provided filename in the storage directory.
-     * @param filename The filename to get the path for
-     * @returns The full file path
-     */
-    getLocalUri(filename: string): string;
-}
-
-/**
- * RemoteStorageAdapter defines the interface for remote storage operations.
- * Implementations handle uploading, downloading, and deleting files from remote storage.
- *
- * @experimental
- * @alpha This is currently experimental and may change without a major version bump.
- */
-interface RemoteStorageAdapter {
-    /**
-     * Uploads a file to remote storage.
-     * @param fileData The binary content of the file to upload
-     * @param attachment The associated attachment metadata
-     */
-    uploadFile(fileData: ArrayBuffer, attachment: AttachmentRecord): Promise<void>;
-    /**
-     * Downloads a file from remote storage.
-     * @param attachment The attachment describing the file to download
-     * @returns The binary data of the downloaded file
-     */
-    downloadFile(attachment: AttachmentRecord): Promise<ArrayBuffer>;
-    /**
-     * Deletes a file from remote storage.
-     * @param attachment The attachment describing the file to delete
-     */
-    deleteFile(attachment: AttachmentRecord): Promise<void>;
-}
-
-/**
- * WatchedAttachmentItem represents an attachment reference in your application's data model.
- * Use either filename OR fileExtension (not both).
- *
- * @experimental
- */
-type WatchedAttachmentItem = {
-    id: string;
-    filename: string;
-    fileExtension?: never;
-    metaData?: string;
-} | {
-    id: string;
-    fileExtension: string;
-    filename?: never;
-    metaData?: string;
-};
-
-/**
- * AttachmentQueue manages the lifecycle and synchronization of attachments
- * between local and remote storage.
- * Provides automatic synchronization, upload/download queuing, attachment monitoring,
- * verification and repair of local files, and cleanup of archived attachments.
- *
- * @experimental
- * @alpha This is currently experimental and may change without a major version bump.
- */
-declare class AttachmentQueue {
-    /** Timer for periodic synchronization operations */
-    private periodicSyncTimer?;
-    /** Service for synchronizing attachments between local and remote storage */
-    private readonly syncingService;
-    /** Adapter for local file storage operations */
-    readonly localStorage: LocalStorageAdapter;
-    /** Adapter for remote file storage operations */
-    readonly remoteStorage: RemoteStorageAdapter;
-    /**
-     * Callback function to watch for changes in attachment references in your data model.
-     *
-     * This should be implemented by the user of AttachmentQueue to monitor changes in your application's
-     * data that reference attachments. When attachments are added, removed, or modified,
-     * this callback should trigger the onUpdate function with the current set of attachments.
-     */
-    private readonly watchAttachments;
-    /** Name of the database table storing attachment records */
-    readonly tableName: string;
-    /** Logger instance for diagnostic information */
-    readonly logger: ILogger;
-    /** Interval in milliseconds between periodic sync operations. Acts as a polling timer to retry
-     *  failed uploads/downloads, especially after the app goes offline. Default: 30000 (30 seconds) */
-    readonly syncIntervalMs: number;
-    /** Throttle duration in milliseconds for the reactive watch query on the attachments table.
-     *  When attachment records change, a watch query detects the change and triggers a sync.
-     *  This throttle prevents the sync from firing too rapidly when many changes happen in
-     *  quick succession (e.g., bulk inserts). This is distinct from syncIntervalMs — it controls
-     *  how quickly the queue reacts to changes, while syncIntervalMs controls how often it polls
-     *  for retries. Default: 30 (from DEFAULT_WATCH_THROTTLE_MS) */
-    readonly syncThrottleDuration: number;
-    /** Whether to automatically download remote attachments. Default: true */
-    readonly downloadAttachments: boolean;
-    /** Maximum number of archived attachments to keep before cleanup. Default: 100 */
-    readonly archivedCacheLimit: number;
-    /** Service for managing attachment-related database operations */
-    private readonly attachmentService;
-    /** PowerSync database instance */
-    private readonly db;
-    /** Cleanup function for status change listener */
-    private statusListenerDispose?;
-    private watchActiveAttachments;
-    private watchAttachmentsAbortController;
-    /**
-     * Creates a new AttachmentQueue instance.
-     *
-     * @param options - Configuration options
-     * @param options.db - PowerSync database instance
-     * @param options.remoteStorage - Remote storage adapter for upload/download operations
-     * @param options.localStorage - Local storage adapter for file persistence
-     * @param options.watchAttachments - Callback for monitoring attachment changes in your data model
-     * @param options.tableName - Name of the table to store attachment records. Default: 'ps_attachment_queue'
-     * @param options.logger - Logger instance. Defaults to db.logger
-     * @param options.syncIntervalMs - Periodic polling interval in milliseconds for retrying failed uploads/downloads. Default: 30000
-     * @param options.syncThrottleDuration - Throttle duration in milliseconds for the reactive watch query that detects attachment changes. Prevents rapid-fire syncs during bulk changes. Default: 30
-     * @param options.downloadAttachments - Whether to automatically download remote attachments. Default: true
-     * @param options.archivedCacheLimit - Maximum archived attachments before cleanup. Default: 100
-     */
-    constructor({ db, localStorage, remoteStorage, watchAttachments, logger, tableName, syncIntervalMs, syncThrottleDuration, downloadAttachments, archivedCacheLimit, errorHandler }: {
-        db: AbstractPowerSyncDatabase;
-        remoteStorage: RemoteStorageAdapter;
-        localStorage: LocalStorageAdapter;
-        watchAttachments: (onUpdate: (attachment: WatchedAttachmentItem[]) => Promise<void>, signal: AbortSignal) => void;
-        tableName?: string;
-        logger?: ILogger;
-        syncIntervalMs?: number;
-        syncThrottleDuration?: number;
-        downloadAttachments?: boolean;
-        archivedCacheLimit?: number;
-        errorHandler?: AttachmentErrorHandler;
-    });
-    /**
-     * Generates a new attachment ID using a SQLite UUID function.
-     *
-     * @returns Promise resolving to the new attachment ID
-     */
-    generateAttachmentId(): Promise<string>;
-    /**
-     * Starts the attachment synchronization process.
-     *
-     * This method:
-     * - Stops any existing sync operations
-     * - Sets up periodic synchronization based on syncIntervalMs
-     * - Registers listeners for active attachment changes
-     * - Processes watched attachments to queue uploads/downloads
-     * - Handles state transitions for archived and new attachments
-     */
-    startSync(): Promise<void>;
-    /**
-     * Synchronizes all active attachments between local and remote storage.
-     *
-     * This is called automatically at regular intervals when sync is started,
-     * but can also be called manually to trigger an immediate sync.
-     */
-    syncStorage(): Promise<void>;
-    /**
-     * Stops the attachment synchronization process.
-     *
-     * Clears the periodic sync timer and closes all active attachment watchers.
-     */
-    stopSync(): Promise<void>;
-    /**
-     * Saves a file to local storage and queues it for upload to remote storage.
-     *
-     * @param options - File save options
-     * @param options.data - The file data as ArrayBuffer, Blob, or base64 string
-     * @param options.fileExtension - File extension (e.g., 'jpg', 'pdf')
-     * @param options.mediaType - MIME type of the file (e.g., 'image/jpeg')
-     * @param options.metaData - Optional metadata to associate with the attachment
-     * @param options.id - Optional custom ID. If not provided, a UUID will be generated
-     * @param options.updateHook - Optional callback to execute additional database operations
-     *                             within the same transaction as the attachment creation
-     * @returns Promise resolving to the created attachment record
-     */
-    saveFile({ data, fileExtension, mediaType, metaData, id, updateHook }: {
-        data: AttachmentData;
-        fileExtension: string;
-        mediaType?: string;
-        metaData?: string;
-        id?: string;
-        updateHook?: (transaction: Transaction, attachment: AttachmentRecord) => Promise<void>;
-    }): Promise<AttachmentRecord>;
-    deleteFile({ id, updateHook }: {
-        id: string;
-        updateHook?: (transaction: Transaction, attachment: AttachmentRecord) => Promise<void>;
-    }): Promise<void>;
-    expireCache(): Promise<void>;
-    clearQueue(): Promise<void>;
-    /**
-     * Verifies the integrity of all attachment records and repairs inconsistencies.
-     *
-     * This method checks each attachment record against the local filesystem and:
-     * - Updates localUri if the file exists at a different path
-     * - Archives attachments with missing local files that haven't been uploaded
-     * - Requeues synced attachments for download if their local files are missing
-     */
-    verifyAttachments(): Promise<void>;
-}
-
-/**
- * Service for querying and watching attachment records in the database.
- *
- * @internal
- */
-declare class AttachmentService {
-    private db;
-    private logger;
-    private tableName;
-    private mutex;
-    private context;
-    constructor(db: AbstractPowerSyncDatabase, logger: ILogger, tableName?: string, archivedCacheLimit?: number);
-    /**
-     * Creates a differential watch query for active attachments requiring synchronization.
-     * @returns Watch query that emits changes for queued uploads, downloads, and deletes
-     */
-    watchActiveAttachments({ throttleMs }?: {
-        throttleMs?: number;
-    }): DifferentialWatchedQuery<AttachmentRecord>;
-    /**
-     * Executes a callback with exclusive access to the attachment context.
-     */
-    withContext<T>(callback: (context: AttachmentContext) => Promise<T>): Promise<T>;
-}
-
-/**
- * Orchestrates attachment synchronization between local and remote storage.
- * Handles uploads, downloads, deletions, and state transitions.
- *
- * @internal
- */
-declare class SyncingService {
-    private attachmentService;
-    private localStorage;
-    private remoteStorage;
-    private logger;
-    private errorHandler?;
-    constructor(attachmentService: AttachmentService, localStorage: LocalStorageAdapter, remoteStorage: RemoteStorageAdapter, logger: ILogger, errorHandler?: AttachmentErrorHandler);
-    /**
-     * Processes attachments based on their state (upload, download, or delete).
-     * All updates are saved in a single batch after processing.
-     *
-     * @param attachments - Array of attachment records to process
-     * @param context - Attachment context for database operations
-     * @returns Promise that resolves when all attachments have been processed and saved
-     */
-    processAttachments(attachments: AttachmentRecord[], context: AttachmentContext): Promise<void>;
-    /**
-     * Uploads an attachment from local storage to remote storage.
-     * On success, marks as SYNCED. On failure, defers to error handler or archives.
-     *
-     * @param attachment - The attachment record to upload
-     * @returns Updated attachment record with new state
-     * @throws Error if the attachment has no localUri
-     */
-    uploadAttachment(attachment: AttachmentRecord): Promise<AttachmentRecord>;
-    /**
-     * Downloads an attachment from remote storage to local storage.
-     * Retrieves the file, converts to base64, and saves locally.
-     * On success, marks as SYNCED. On failure, defers to error handler or archives.
-     *
-     * @param attachment - The attachment record to download
-     * @returns Updated attachment record with local URI and new state
-     */
-    downloadAttachment(attachment: AttachmentRecord): Promise<AttachmentRecord>;
-    /**
-     * Deletes an attachment from both remote and local storage.
-     * Removes the remote file, local file (if exists), and the attachment record.
-     * On failure, defers to error handler or archives.
-     *
-     * @param attachment - The attachment record to delete
-     * @param context - Attachment context for database operations
-     * @returns Updated attachment record
-     */
-    deleteAttachment(attachment: AttachmentRecord, context: AttachmentContext): Promise<AttachmentRecord>;
-    /**
-     * Performs cleanup of archived attachments by removing their local files and records.
-     * Errors during local file deletion are logged but do not prevent record deletion.
-     */
-    deleteArchivedAttachments(context: AttachmentContext): Promise<boolean>;
-}
-
-interface PowerSyncOpenFactoryOptions extends Partial<PowerSyncDatabaseOptions>, SQLOpenOptions {
-    /** Schema used for the local database. */
-    schema: Schema;
-}
-declare abstract class AbstractPowerSyncDatabaseOpenFactory {
-    protected options: PowerSyncOpenFactoryOptions;
-    constructor(options: PowerSyncOpenFactoryOptions);
-    /**
-     * Schema used for the local database.
-     */
-    get schema(): Schema<{
-        [x: string]: Table<any>;
-    }>;
-    protected abstract openDB(): DBAdapter;
-    generateOptions(): PowerSyncDatabaseOptions;
-    abstract generateInstance(options: PowerSyncDatabaseOptions): AbstractPowerSyncDatabase;
-    getInstance(): AbstractPowerSyncDatabase;
-}
-
-interface CompilableQueryWatchHandler<T> {
-    onResult: (results: T[]) => void;
-    onError?: (error: Error) => void;
-}
-declare function compilableQueryWatch<T>(db: AbstractPowerSyncDatabase, query: CompilableQuery<T>, handler: CompilableQueryWatchHandler<T>, options?: SQLWatchOptions): void;
-
-declare const MAX_OP_ID = "9223372036854775807";
-
-declare function runOnSchemaChange(callback: (signal: AbortSignal) => void, db: AbstractPowerSyncDatabase, options?: SQLWatchOptions): void;
-
-declare class SqliteBucketStorage extends BaseObserver<BucketStorageListener> implements BucketStorageAdapter {
-    private db;
-    private logger;
-    tableNames: Set<string>;
-    private _hasCompletedSync;
-    private updateListener;
-    private _clientId?;
-    constructor(db: DBAdapter, logger?: ILogger);
-    init(): Promise<void>;
-    dispose(): Promise<void>;
-    _getClientId(): Promise<string>;
-    getClientId(): Promise<string>;
-    getMaxOpId(): string;
-    /**
-     * Reset any caches.
-     */
-    startSession(): void;
-    getBucketStates(): Promise<BucketState[]>;
-    getBucketOperationProgress(): Promise<BucketOperationProgress>;
-    saveSyncData(batch: SyncDataBatch, fixedKeyFormat?: boolean): Promise<void>;
-    removeBuckets(buckets: string[]): Promise<void>;
-    /**
-     * Mark a bucket for deletion.
-     */
-    private deleteBucket;
-    hasCompletedSync(): Promise<boolean>;
-    syncLocalDatabase(checkpoint: Checkpoint, priority?: number): Promise<SyncLocalDatabaseResult>;
-    /**
-     * Atomically update the local state to the current checkpoint.
-     *
-     * This includes creating new tables, dropping old tables, and copying data over from the oplog.
-     */
-    private updateObjectsFromBuckets;
-    validateChecksums(checkpoint: Checkpoint, priority: number | undefined): Promise<SyncLocalDatabaseResult>;
-    updateLocalTarget(cb: () => Promise<string>): Promise<boolean>;
-    nextCrudItem(): Promise<CrudEntry | undefined>;
-    hasCrud(): Promise<boolean>;
-    /**
-     * Get a batch of objects to send to the server.
-     * When the objects are successfully sent to the server, call .complete()
-     */
-    getCrudBatch(limit?: number): Promise<CrudBatch | null>;
-    writeTransaction<T>(callback: (tx: Transaction) => Promise<T>, options?: {
-        timeoutMs: number;
-    }): Promise<T>;
-    /**
-     * Set a target checkpoint.
-     */
-    setTargetCheckpoint(checkpoint: Checkpoint): Promise<void>;
-    control(op: PowerSyncControlCommand, payload: string | Uint8Array | ArrayBuffer | null): Promise<string>;
-    hasMigratedSubkeys(): Promise<boolean>;
-    migrateToFixedSubkeys(): Promise<void>;
-    static _subkeyMigrationKey: string;
-}
-
-/**
- * Thrown when an underlying database connection is closed.
- * This is particularly relevant when worker connections are marked as closed while
- * operations are still in progress.
- */
-declare class ConnectionClosedError extends Error {
-    static NAME: string;
-    static MATCHES(input: any): boolean;
-    constructor(message: string);
-}
-
-/**
- * @internal
- * @experimental
- */
-declare const MEMORY_TRIGGER_CLAIM_MANAGER: TriggerClaimManager;
-
-/**
- * Helper function for sanitizing UUID input strings.
- * Typically used with {@link sanitizeSQL}.
- */
-declare function sanitizeUUID(uuid: string): string;
-/**
- * SQL string template function for {@link TrackDiffOptions#when} and {@link CreateDiffTriggerOptions#when}.
- *
- * This function performs basic string interpolation for SQLite WHEN clauses.
- *
- * **String placeholders:**
- * - All string values passed as placeholders are automatically wrapped in single quotes (`'`).
- * - Do not manually wrap placeholders in single quotes in your template string; the function will handle quoting and escaping for you.
- * - Any single quotes within the string value are escaped by doubling them (`''`), as required by SQL syntax.
- *
- * **Other types:**
- * - `null` and `undefined` are converted to SQL `NULL`.
- * - Objects are stringified using `JSON.stringify()` and wrapped in single quotes, with any single quotes inside the stringified value escaped.
- * - Numbers and other primitive types are inserted directly.
- *
- * **Usage example:**
- * ```typescript
- * const myID = "O'Reilly";
- * const clause = sanitizeSQL`New.id = ${myID}`;
- * // Result: "New.id = 'O''Reilly'"
- * ```
- *
- * Avoid manually quoting placeholders:
- * ```typescript
- * // Incorrect:
- * sanitizeSQL`New.id = '${myID}'` // Produces double quotes: New.id = ''O''Reilly''
- * ```
- */
-declare function sanitizeSQL(strings: TemplateStringsArray, ...values: any[]): string;
-
-/**
- * Options for {@link GetAllQuery}.
- */
-type GetAllQueryOptions<RowType = unknown> = {
-    sql: string;
-    parameters?: ReadonlyArray<unknown>;
-    /**
-     * Optional mapper function to convert raw rows into the desired RowType.
-     * @example
-     * ```javascript
-     * (rawRow) => ({
-     *   id: rawRow.id,
-     *   created_at: new Date(rawRow.created_at),
-     * })
-     * ```
-     */
-    mapper?: (rawRow: Record<string, unknown>) => RowType;
-};
-/**
- * Performs a {@link AbstractPowerSyncDatabase.getAll} operation for a watched query.
- */
-declare class GetAllQuery<RowType = unknown> implements WatchCompatibleQuery<RowType[]> {
-    protected options: GetAllQueryOptions<RowType>;
-    constructor(options: GetAllQueryOptions<RowType>);
-    compile(): CompiledQuery;
-    execute(options: {
-        db: AbstractPowerSyncDatabase;
-    }): Promise<RowType[]>;
-}
-
-/**
- * Calls to Abortcontroller.abort(reason: any) will result in the
- * `reason` being thrown. This is not necessarily an error,
- *  but extends error for better logging purposes.
- */
-declare class AbortOperation extends Error {
-    protected reason: string;
-    constructor(reason: string);
-}
-
-interface ControlledExecutorOptions {
-    /**
-     * If throttling is enabled, it ensures only one task runs at a time,
-     * and only one additional task can be scheduled to run after the current task completes. The pending task will be overwritten by the latest task.
-     * Enabled by default.
-     */
-    throttleEnabled?: boolean;
-}
-declare class ControlledExecutor<T> {
-    private task;
-    /**
-     * Represents the currently running task, which could be a Promise or undefined if no task is running.
-     */
-    private runningTask;
-    private pendingTaskParam;
-    /**
-     * Flag to determine if throttling is enabled, which controls whether tasks are queued or run immediately.
-     */
-    private isThrottling;
-    private closed;
-    constructor(task: (param: T) => Promise<void> | void, options?: ControlledExecutorOptions);
-    schedule(param: T): void;
-    dispose(): void;
-    private execute;
-}
-
-interface ParsedQuery {
-    sqlStatement: string;
-    parameters: any[];
-}
-declare const parseQuery: <T>(query: string | CompilableQuery<T>, parameters: any[]) => ParsedQuery;
-
-export { ATTACHMENT_TABLE, AbortOperation, AbstractPowerSyncDatabase, AbstractPowerSyncDatabaseOpenFactory, AbstractQueryProcessor, AbstractRemote, AbstractStreamingSyncImplementation, ArrayComparator, AttachmentContext, AttachmentQueue, AttachmentService, AttachmentState, AttachmentTable, BaseObserver, Column, ColumnType, ConnectionClosedError, ConnectionManager, ControlledExecutor, CrudBatch, CrudEntry, CrudTransaction, DBAdapterDefaultMixin, DBGetUtilsDefaultMixin, DEFAULT_CRUD_BATCH_LIMIT, DEFAULT_CRUD_UPLOAD_THROTTLE_MS, DEFAULT_INDEX_COLUMN_OPTIONS, DEFAULT_INDEX_OPTIONS, DEFAULT_LOCK_TIMEOUT_MS, DEFAULT_POWERSYNC_CLOSE_OPTIONS, DEFAULT_POWERSYNC_DB_OPTIONS, DEFAULT_REMOTE_LOGGER, DEFAULT_REMOTE_OPTIONS, DEFAULT_RETRY_DELAY_MS, DEFAULT_ROW_COMPARATOR, DEFAULT_STREAMING_SYNC_OPTIONS, DEFAULT_STREAM_CONNECTION_OPTIONS, DEFAULT_SYNC_CLIENT_IMPLEMENTATION, DEFAULT_TABLE_OPTIONS, DEFAULT_WATCH_QUERY_OPTIONS, DEFAULT_WATCH_THROTTLE_MS, DiffTriggerOperation, DifferentialQueryProcessor, EMPTY_DIFFERENTIAL, EncodingType, FalsyComparator, FetchImplementationProvider, FetchStrategy, GetAllQuery, Index, IndexedColumn, InvalidSQLCharacters, LockType, LogLevel, MAX_AMOUNT_OF_COLUMNS, MAX_OP_ID, MEMORY_TRIGGER_CLAIM_MANAGER, Mutex, OnChangeQueryProcessor, OpType, OpTypeEnum, OplogEntry, PSInternalTable, PowerSyncControlCommand, RowUpdateType, Schema, Semaphore, SqliteBucketStorage, SyncClientImplementation, SyncDataBatch, SyncDataBucket, SyncProgress, SyncStatus, SyncStreamConnectionMethod, SyncingService, Table, TableV2, TriggerManagerImpl, UpdateType, UploadQueueStats, WatchedQueryListenerEvent, attachmentFromSql, column, compilableQueryWatch, createBaseLogger, createLogger, extractTableUpdates, isBatchedUpdateNotification, isContinueCheckpointRequest, isDBAdapter, isPowerSyncDatabaseOptionsWithSettings, isSQLOpenFactory, isSQLOpenOptions, isStreamingKeepalive, isStreamingSyncCheckpoint, isStreamingSyncCheckpointComplete, isStreamingSyncCheckpointDiff, isStreamingSyncCheckpointPartiallyComplete, isStreamingSyncData, isSyncNewCheckpointRequest, parseQuery, runOnSchemaChange, sanitizeSQL, sanitizeUUID, timeoutSignal };
-export type { AbstractQueryProcessorOptions, AbstractRemoteOptions, AbstractStreamingSyncImplementationOptions, AdditionalConnectionOptions, ArrayComparatorOptions, ArrayQueryDefinition, AttachmentData, AttachmentErrorHandler, AttachmentRecord, AttachmentTableOptions, BSONImplementation, BaseColumnType, BaseConnectionOptions, BaseListener, BaseObserverInterface, BasePowerSyncDatabaseOptions, BaseTriggerDiffRecord, BatchedUpdateNotification, BucketChecksum, BucketDescription, BucketOperationProgress, BucketRequest, BucketState, BucketStorageAdapter, BucketStorageListener, Checkpoint, ChecksumCache, ColumnOptions, ColumnsType, CompilableQuery, CompilableQueryWatchHandler, CompiledQuery, ConnectionManagerListener, ConnectionManagerOptions, ConnectionManagerSyncImplementationResult, ConnectionPool, ContinueCheckpointRequest, ControlledExecutorOptions, CreateDiffTriggerOptions, CreateLoggerOptions, CreateSyncImplementationOptions, CrudRequest, CrudResponse, CrudUploadNotification, DBAdapter, DBAdapterListener, DBGetUtils, DBLockOptions, DifferentialQueryProcessorOptions, DifferentialWatchedQuery, DifferentialWatchedQueryComparator, DifferentialWatchedQueryListener, DifferentialWatchedQueryOptions, DifferentialWatchedQuerySettings, DisconnectAndClearOptions, Disposable, ExtractColumnValueType, ExtractedTriggerDiffRecord, FetchImplementation, GetAllQueryOptions, IndexColumnOptions, IndexOptions, IndexShorthand, InternalConnectionOptions, InternalSubscriptionAdapter, LinkQueryOptions, LocalStorageAdapter, LockContext, LockOptions, MutableWatchedQueryState, OnChangeQueryProcessorOptions, OpId, OpTypeJSON, OplogEntryJSON, ParsedQuery, PendingStatement, PendingStatementParameter, PowerSyncBackendConnector, PowerSyncCloseOptions, PowerSyncConnectionOptions, PowerSyncCredentials, PowerSyncDBListener, PowerSyncDatabaseOptions, PowerSyncDatabaseOptionsWithDBAdapter, PowerSyncDatabaseOptionsWithOpenFactory, PowerSyncDatabaseOptionsWithSettings, PowerSyncOpenFactoryOptions, ProgressWithOperations, Query, QueryParam, QueryResult, RawTableType, RemoteConnector, RemoteStorageAdapter, RequiredAdditionalConnectionOptions, RequiredPowerSyncConnectionOptions, RowType, SQLOnChangeOptions, SQLOpenFactory, SQLOpenOptions, SQLWatchOptions, SavedProgress, SchemaTableType, SimpleAsyncIterator, SocketSyncStreamOptions, SqlExecutor, StandardWatchedQuery, StandardWatchedQueryOptions, StreamingSyncCheckpoint, StreamingSyncCheckpointComplete, StreamingSyncCheckpointDiff, StreamingSyncCheckpointPartiallyComplete, StreamingSyncDataJSON, StreamingSyncImplementation, StreamingSyncImplementationListener, StreamingSyncKeepalive, StreamingSyncLine, StreamingSyncLineOrCrudUploadComplete, StreamingSyncRequest, StreamingSyncRequestParameterType, SubscribedStream, SyncDataBucketJSON, SyncDataFlowStatus, SyncLocalDatabaseResult, SyncNewCheckpointRequest, SyncPriorityStatus, SyncRequest, SyncResponse, SyncStatusOptions, SyncStream, SyncStreamDescription, SyncStreamOptions, SyncStreamStatus, SyncStreamSubscribeOptions, SyncStreamSubscription, SyncSubscriptionDescription, TableOptions, TableOrRawTableOptions, TableUpdateOperation, TableV2Options, TrackDiffOptions, TrackPreviousOptions, Transaction, TriggerClaimManager, TriggerCreationHooks, TriggerDiffDeleteRecord, TriggerDiffHandlerContext, TriggerDiffInsertRecord, TriggerDiffRecord, TriggerDiffUpdateRecord, TriggerManager, TriggerManagerConfig, TriggerRemoveCallback, TriggerRemoveCallbackOptions, UnlockFn, UpdateNotification, WatchCompatibleQuery, WatchExecuteOptions, WatchHandler, WatchOnChangeEvent, WatchOnChangeHandler, WatchedAttachmentItem, WatchedQuery, WatchedQueryComparator, WatchedQueryDifferential, WatchedQueryListener, WatchedQueryOptions, WatchedQueryRowDifferential, WatchedQuerySettings, WatchedQueryState, WithDiffOptions };