@powersync/common 1.34.0 → 1.36.0

package/dist/index.d.cts

@@ -0,0 +1,2934 @@
+import { Mutex } from 'async-mutex';
+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 if result of a update query. */
+    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 LockContext extends DBGetUtils {
+    /** 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[][]>;
+}
+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 DBAdapter extends BaseObserverInterface<DBAdapterListener>, DBGetUtils {
+    close: () => void | Promise<void>;
+    execute: (query: string, params?: any[]) => Promise<QueryResult>;
+    executeRaw: (query: string, params?: any[]) => Promise<any[][]>;
+    executeBatch: (query: string, params?: any[][]) => Promise<QueryResult>;
+    name: string;
+    readLock: <T>(fn: (tx: LockContext) => Promise<T>, options?: DBLockOptions) => Promise<T>;
+    readTransaction: <T>(fn: (tx: Transaction) => Promise<T>, options?: DBLockOptions) => Promise<T>;
+    writeLock: <T>(fn: (tx: LockContext) => Promise<T>, options?: DBLockOptions) => Promise<T>;
+    writeTransaction: <T>(fn: (tx: Transaction) => 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>;
+}
+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;
+}
+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;
+}
+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"
+}
+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>;
+}
+
+/**
+ * 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>;
+    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;
+}
+
+interface BucketProgress {
+    priority: number;
+    at_last: number;
+    since_last: number;
+    target_count: number;
+}
+
+/** @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;
+}>;
+interface SyncPriorityStatus {
+    priority: number;
+    lastSyncedAt?: Date;
+    hasSynced?: boolean;
+}
+type SyncStatusOptions = {
+    connected?: boolean;
+    connecting?: boolean;
+    dataFlow?: SyncDataFlowStatus;
+    lastSyncedAt?: Date;
+    hasSynced?: boolean;
+    priorityStatusEntries?: SyncPriorityStatus[];
+};
+declare class SyncStatus {
+    protected options: SyncStatusOptions;
+    constructor(options: SyncStatusOptions);
+    /**
+     * 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;
+    }>;
+    /**
+     * 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;
+    private static comparePriorities;
+}
+
+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;
+    };
+}
+
+/**
+ * A pending variant of a {@link RawTable} that doesn't have a name (because it would be inferred when creating the
+ * schema).
+ */
+type RawTableType = {
+    /**
+     * 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;
+};
+/**
+ * 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'}`.
+ */
+type PendingStatementParameter = 'Id' | {
+    Column: string;
+};
+/**
+ * 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[];
+};
+/**
+ * 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.
+ *
+ * Note that raw tables are only supported when using the new `SyncClientImplementation.rust` sync client.
+ *
+ * @experimental Please note that this feature is experimental at the moment, and not covered by PowerSync semver or
+ * stability guarantees.
+ */
+declare class RawTable implements RawTableType {
+    /**
+     * The name of the table.
+     *
+     * This does not have to match the actual table name in the schema - {@link put} and {@link 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;
+    put: PendingStatement;
+    delete: PendingStatement;
+    constructor(name: string, type: RawTableType);
+}
+
+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> {
+}
+
+interface SharedTableOptions {
+    localOnly?: boolean;
+    insertOnly?: boolean;
+    viewName?: string;
+    trackPrevious?: boolean | TrackPreviousOptions;
+    trackMetadata?: boolean;
+    ignoreEmptyUpdates?: boolean;
+}
+/** 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(): {
+        name: string;
+        view_name: string;
+        local_only: boolean;
+        insert_only: boolean;
+        include_old: any;
+        include_old_only_when_changed: boolean;
+        include_metadata: boolean;
+        ignore_empty_update: boolean;
+        columns: {
+            name: string;
+            type: ColumnType | undefined;
+        }[];
+        indexes: {
+            name: string;
+            columns: {
+                name: string;
+                ascending: boolean | undefined;
+                type: ColumnType;
+            }[];
+        }[];
+    };
+}
+
+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.
+     * Note that raw tables are only supported when using the new `SyncClientImplementation.rust` sync client.
+     *
+     * @param tables An object of (table name, raw table definition) entries.
+     * @experimental Note that the raw tables API is still experimental and may change in the future.
+     */
+    withRawTables(tables: Record<string, RawTableType>): void;
+    validate(): void;
+    toJSON(): {
+        tables: {
+            name: string;
+            view_name: string;
+            local_only: boolean;
+            insert_only: boolean;
+            include_old: any;
+            include_old_only_when_changed: boolean;
+            include_metadata: boolean;
+            ignore_empty_update: boolean;
+            columns: {
+                name: string;
+                type: ColumnType | undefined;
+            }[];
+            indexes: {
+                name: string;
+                columns: {
+                    name: string;
+                    ascending: boolean | undefined;
+                    type: ColumnType;
+                }[];
+            }[];
+        }[];
+        raw_tables: RawTable[];
+    };
+    private convertToClassicTables;
+}
+
+interface PowerSyncCredentials {
+    endpoint: string;
+    token: string;
+    expiresAt?: Date;
+}
+
+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>;
+}
+
+type DataStreamOptions<ParsedData, SourceData> = {
+    mapLine?: (line: SourceData) => ParsedData;
+    /**
+     * Close the stream if any consumer throws an error
+     */
+    closeOnError?: boolean;
+    pressure?: {
+        highWaterMark?: number;
+        lowWaterMark?: number;
+    };
+    logger?: ILogger;
+};
+type DataStreamCallback<Data extends any = any> = (data: Data) => Promise<void>;
+interface DataStreamListener<Data extends any = any> extends BaseListener {
+    data: (data: Data) => Promise<void>;
+    closed: () => void;
+    error: (error: Error) => void;
+    highWater: () => Promise<void>;
+    lowWater: () => Promise<void>;
+}
+declare const DEFAULT_PRESSURE_LIMITS: {
+    highWater: number;
+    lowWater: number;
+};
+/**
+ * A very basic implementation of a data stream with backpressure support which does not use
+ * native JS streams or async iterators.
+ * This is handy for environments such as React Native which need polyfills for the above.
+ */
+declare class DataStream<ParsedData, SourceData = any> extends BaseObserver<DataStreamListener<ParsedData>> {
+    protected options?: DataStreamOptions<ParsedData, SourceData> | undefined;
+    dataQueue: SourceData[];
+    protected isClosed: boolean;
+    protected processingPromise: Promise<void> | null;
+    protected notifyDataAdded: (() => void) | null;
+    protected logger: ILogger;
+    protected mapLine: (line: SourceData) => ParsedData;
+    constructor(options?: DataStreamOptions<ParsedData, SourceData> | undefined);
+    get highWatermark(): number;
+    get lowWatermark(): number;
+    get closed(): boolean;
+    close(): Promise<void>;
+    /**
+     * Enqueues data for the consumers to read
+     */
+    enqueueData(data: SourceData): void;
+    /**
+     * Reads data once from the data stream
+     * @returns a Data payload or Null if the stream closed.
+     */
+    read(): Promise<ParsedData | null>;
+    /**
+     * Executes a callback for each data item in the stream
+     */
+    forEach(callback: DataStreamCallback<ParsedData>): () => void;
+    protected processQueue(): Promise<void> | undefined;
+    protected hasDataReader(): boolean;
+    protected _processQueue(): Promise<void>;
+    protected iterateAsyncErrored(cb: (l: Partial<DataStreamListener<ParsedData>>) => Promise<void>): Promise<void>;
+}
+
+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>;
+    protected createSocket(url: string): WebSocket;
+    /**
+     * Returns a data stream of sync line data.
+     *
+     * @param map Maps received payload frames to the typed event value.
+     * @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<T>(options: SocketSyncStreamOptions, map: (buffer: Uint8Array) => T, bson?: typeof BSON): Promise<DataStream<T>>;
+    /**
+     * Connects to the sync/stream http endpoint, mapping and emitting each received string line.
+     */
+    postStreamRaw<T>(options: SyncStreamOptions, mapLine: (line: string) => T): Promise<DataStream<T>>;
+}
+
+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 Don't use {@link SyncClientImplementation.JAVASCRIPT} directly. Instead, use
+     * {@link DEFAULT_SYNC_CLIENT_IMPLEMENTATION} or omit the option. The explicit choice to use
+     * the JavaScript-based sync implementation will be removed from a future version of the SDK.
+     */
+    JAVASCRIPT = "js",
+    /**
+     * This implementation offloads the sync line decoding and handling into the PowerSync
+     * core extension.
+     *
+     * @experimental
+     * While this implementation is more performant than {@link SyncClientImplementation.JAVASCRIPT},
+     * it has seen less real-world testing and is marked as __experimental__ at the moment.
+     *
+     * ## 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.
+ *
+ * Please use this field instead of {@link SyncClientImplementation.JAVASCRIPT} directly. A future version
+ * of the PowerSync SDK will enable {@link SyncClientImplementation.RUST} by default and remove the JavaScript
+ * option.
+ */
+declare const DEFAULT_SYNC_CLIENT_IMPLEMENTATION = SyncClientImplementation.JAVASCRIPT;
+/**
+ * Abstract Lock to be implemented by various JS environments
+ */
+interface LockOptions<T> {
+    callback: () => Promise<T>;
+    type: LockType;
+    signal?: AbortSignal;
+}
+interface AbstractStreamingSyncImplementationOptions extends AdditionalConnectionOptions {
+    adapter: BucketStorageAdapter;
+    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 {
+    /**
+     * 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>;
+    /**
+     * 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 */
+type RequiredAdditionalConnectionOptions = Required<AdditionalConnectionOptions>;
+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>;
+}
+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;
+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 isUploadingCrud;
+    private notifyCompletedUploads?;
+    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>;
+    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<void>;
+    private legacyStreamingSyncIteration;
+    private rustSyncIteration;
+    private updateSyncStatusForStartingCheckpoint;
+    private applyCheckpoint;
+    protected updateSyncStatus(options: SyncStatusOptions): void;
+    private delayRetry;
+}
+
+/**
+ * @internal
+ */
+interface ConnectionManagerSyncImplementationResult {
+    sync: StreamingSyncImplementation;
+    /**
+     * Additional cleanup function which is called after the sync stream implementation
+     * is disposed.
+     */
+    onDispose: () => Promise<void> | void;
+}
+/**
+ * @internal
+ */
+interface ConnectionManagerOptions {
+    createSyncImplementation(connector: PowerSyncBackendConnector, options: InternalConnectionOptions): 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;
+    constructor(options: ConnectionManagerOptions);
+    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>;
+}
+
+/**
+ * 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",
+    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.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;
+    /**
+     * 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(): 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);
+}
+
+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;
+    get syncStreamImplementation(): StreamingSyncImplementation | null;
+    protected _schema: Schema;
+    private _database;
+    protected runExclusiveMutex: Mutex;
+    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;
+    protected abstract generateSyncStreamImplementation(connector: PowerSyncBackendConnector, options: 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>;
+    /**
+     * 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>;
+    private _loadVersion;
+    protected updateHasSynced(): 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>;
+    resolvedConnectionOptions(options?: PowerSyncConnectionOptions): 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>;
+    /**
+     * 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>;
+    /**
+     * 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.
+     *
+     * @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;
+}
+
+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;
+}
+
+/**
+ * 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;
+}
+
+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;
+
+interface ParsedQuery {
+    sqlStatement: string;
+    parameters: any[];
+}
+declare const parseQuery: <T>(query: string | CompilableQuery<T>, parameters: any[]) => ParsedQuery;
+
+export { AbortOperation, AbstractPowerSyncDatabase, AbstractPowerSyncDatabaseOpenFactory, AbstractQueryProcessor, AbstractRemote, AbstractStreamingSyncImplementation, ArrayComparator, BaseObserver, Column, ColumnType, ConnectionManager, ControlledExecutor, CrudBatch, CrudEntry, CrudTransaction, 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_PRESSURE_LIMITS, 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, DataStream, DifferentialQueryProcessor, EMPTY_DIFFERENTIAL, FalsyComparator, FetchImplementationProvider, FetchStrategy, GetAllQuery, Index, IndexedColumn, InvalidSQLCharacters, LockType, LogLevel, MAX_AMOUNT_OF_COLUMNS, MAX_OP_ID, OnChangeQueryProcessor, OpType, OpTypeEnum, OplogEntry, PSInternalTable, PowerSyncControlCommand, RowUpdateType, Schema, SqliteBucketStorage, SyncClientImplementation, SyncDataBatch, SyncDataBucket, SyncProgress, SyncStatus, SyncStreamConnectionMethod, Table, TableV2, UpdateType, UploadQueueStats, WatchedQueryListenerEvent, column, compilableQueryWatch, createBaseLogger, createLogger, extractTableUpdates, isBatchedUpdateNotification, isContinueCheckpointRequest, isDBAdapter, isPowerSyncDatabaseOptionsWithSettings, isSQLOpenFactory, isSQLOpenOptions, isStreamingKeepalive, isStreamingSyncCheckpoint, isStreamingSyncCheckpointComplete, isStreamingSyncCheckpointDiff, isStreamingSyncCheckpointPartiallyComplete, isStreamingSyncData, isSyncNewCheckpointRequest, parseQuery, runOnSchemaChange };
+export type { AbstractQueryProcessorOptions, AbstractRemoteOptions, AbstractStreamingSyncImplementationOptions, AdditionalConnectionOptions, ArrayComparatorOptions, ArrayQueryDefinition, BSONImplementation, BaseColumnType, BaseConnectionOptions, BaseListener, BaseObserverInterface, BasePowerSyncDatabaseOptions, BatchedUpdateNotification, BucketChecksum, BucketDescription, BucketOperationProgress, BucketRequest, BucketState, BucketStorageAdapter, BucketStorageListener, Checkpoint, ChecksumCache, ColumnOptions, ColumnsType, CompilableQuery, CompilableQueryWatchHandler, CompiledQuery, ConnectionManagerListener, ConnectionManagerOptions, ConnectionManagerSyncImplementationResult, ContinueCheckpointRequest, ControlledExecutorOptions, CreateLoggerOptions, CrudRequest, CrudResponse, CrudUploadNotification, DBAdapter, DBAdapterListener, DBGetUtils, DBLockOptions, DataStreamCallback, DataStreamListener, DataStreamOptions, DifferentialQueryProcessorOptions, DifferentialWatchedQuery, DifferentialWatchedQueryComparator, DifferentialWatchedQueryListener, DifferentialWatchedQueryOptions, DifferentialWatchedQuerySettings, DisconnectAndClearOptions, Disposable, ExtractColumnValueType, FetchImplementation, GetAllQueryOptions, IndexColumnOptions, IndexOptions, IndexShorthand, InternalConnectionOptions, LinkQueryOptions, LockContext, LockOptions, MutableWatchedQueryState, OnChangeQueryProcessorOptions, OpId, OpTypeJSON, OplogEntryJSON, ParsedQuery, PowerSyncBackendConnector, PowerSyncCloseOptions, PowerSyncConnectionOptions, PowerSyncCredentials, PowerSyncDBListener, PowerSyncDatabaseOptions, PowerSyncDatabaseOptionsWithDBAdapter, PowerSyncDatabaseOptionsWithOpenFactory, PowerSyncDatabaseOptionsWithSettings, PowerSyncOpenFactoryOptions, ProgressWithOperations, Query, QueryParam, QueryResult, RemoteConnector, RequiredAdditionalConnectionOptions, RequiredPowerSyncConnectionOptions, RowType, SQLOnChangeOptions, SQLOpenFactory, SQLOpenOptions, SQLWatchOptions, SavedProgress, SchemaTableType, SocketSyncStreamOptions, StandardWatchedQuery, StandardWatchedQueryOptions, StreamingSyncCheckpoint, StreamingSyncCheckpointComplete, StreamingSyncCheckpointDiff, StreamingSyncCheckpointPartiallyComplete, StreamingSyncDataJSON, StreamingSyncImplementation, StreamingSyncImplementationListener, StreamingSyncKeepalive, StreamingSyncLine, StreamingSyncLineOrCrudUploadComplete, StreamingSyncRequest, StreamingSyncRequestParameterType, SyncDataBucketJSON, SyncDataFlowStatus, SyncLocalDatabaseResult, SyncNewCheckpointRequest, SyncPriorityStatus, SyncRequest, SyncResponse, SyncStatusOptions, SyncStreamOptions, TableOptions, TableUpdateOperation, TableV2Options, TrackPreviousOptions, Transaction, UpdateNotification, WatchCompatibleQuery, WatchExecuteOptions, WatchHandler, WatchOnChangeEvent, WatchOnChangeHandler, WatchedQuery, WatchedQueryComparator, WatchedQueryDifferential, WatchedQueryListener, WatchedQueryOptions, WatchedQueryRowDifferential, WatchedQuerySettings, WatchedQueryState };