@powersync/common 0.0.0-dev-20250916075127 → 0.0.0-dev-20250922105207

package/dist/index.d.cts

@@ -440,73 +440,6 @@ interface BucketStorageAdapter extends BaseObserverInterface<BucketStorageListen
     control(op: PowerSyncControlCommand, payload: string | Uint8Array | null): Promise<string>;
 }
 
-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>;
-}
-
-interface PowerSyncCredentials {
-    endpoint: string;
-    token: string;
-    expiresAt?: Date;
-}
-
 /**
  * For sync2.json
  */
@@ -643,968 +576,1027 @@ interface CrudResponse {
     checkpoint?: OpId;
 }
 
-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 {
+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 {
     /**
-     * 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.
+     * The total amount of operations to download for the current sync iteration
+     * to complete.
      */
-    Buffered = "buffered",
+    totalOperations: number;
     /**
-     * Processes each sync event immediately before requesting the next.
-     * This reduces processing overhead and improves real-time responsiveness.
+     * The amount of operations that have already been downloaded.
      */
-    Sequential = "sequential"
+    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;
 }
-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"
+ * 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 FetchImplementationProvider {
-    getFetch(): FetchImplementation;
+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 AbstractRemoteOptions = {
+
+type SyncDataFlowStatus = Partial<{
+    downloading: boolean;
+    uploading: boolean;
     /**
-     * Transforms the PowerSync base URL which might contain
-     * `http(s)://` to the corresponding WebSocket variant
-     * e.g. `ws(s)://`
+     * Error during downloading (including connecting).
+     *
+     * Cleared on the next successful data download.
      */
-    socketUrlTransformer: (url: string) => string;
+    downloadError?: Error;
     /**
-     * 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.
+     * Error during uploading.
+     * Cleared on the next successful upload.
      */
-    fetchImplementation: FetchImplementation | FetchImplementationProvider;
+    uploadError?: Error;
     /**
-     * Optional options to pass directly to all `fetch` calls.
+     * Internal information about how far we are downloading operations in buckets.
      *
-     * This can include fields such as `dispatcher` (e.g. for proxy support),
-     * `cache`, or any other fetch-compatible options.
+     * Please use the {@link SyncStatus#downloadProgress} property to track sync progress.
      */
-    fetchOptions?: {};
+    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 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>);
+declare class SyncStatus {
+    protected options: SyncStatusOptions;
+    constructor(options: SyncStatusOptions);
     /**
-     * @returns a fetch implementation (function)
-     * which can be called to perform fetch requests
+     * 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 fetch(): FetchImplementation;
+    get connected(): boolean;
     /**
-     * Get credentials currently cached, or fetch new credentials if none are
-     * available.
+     * Indicates if the client is in the process of establishing a connection to the PowerSync service.
      *
-     * These credentials may have expired already.
+     * @returns {boolean} True if connecting, false otherwise. Defaults to false if not specified.
      */
-    getCredentials(): Promise<PowerSyncCredentials | null>;
+    get connecting(): boolean;
     /**
-     * Fetch a new set of credentials and cache it.
-     *
-     * Until this call succeeds, `getCredentials` will still return the
-     * old credentials.
+     * Time that a last sync has fully completed, if any.
+     * This timestamp is reset to null after a restart of the PowerSync service.
      *
-     * This may be called before the current credentials have expired.
+     * @returns {Date | undefined} The timestamp of the last successful sync, or undefined if no sync has completed.
      */
-    prefetchCredentials(): Promise<PowerSyncCredentials | null>;
+    get lastSyncedAt(): Date | undefined;
     /**
-     * Get credentials for PowerSync.
+     * Indicates whether there has been at least one full sync completed since initialization.
      *
-     * This should always fetch a fresh set of credentials - don't use cached
-     * values.
+     * @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.
      */
-    fetchCredentials(): Promise<PowerSyncCredentials | null>;
-    /***
-     * Immediately invalidate credentials.
+    get hasSynced(): boolean | undefined;
+    /**
+     * Provides the current data flow status regarding uploads and downloads.
      *
-     * This may be called when the current credentials have expired.
+     * @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.
      */
-    invalidateCredentials(): void;
-    getUserAgent(): string;
-    protected buildRequest(path: string): Promise<{
-        url: string;
-        headers: {
-            'content-type': string;
-            Authorization: string;
-            'x-user-agent': string;
-        };
+    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;
     }>;
-    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.
+     * Provides sync status information for all bucket priorities, sorted by priority (highest first).
      *
-     * @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.
+     * @returns {SyncPriorityStatus[]} An array of status entries for different sync priority levels,
+     * sorted with highest priorities (lower numbers) first.
      */
-    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 {
+    get priorityStatusEntries(): SyncPriorityStatus[];
     /**
-     * Decodes and handles sync lines received from the sync service in JavaScript.
-     *
-     * This is the default option.
+     * A realtime progress report on how many operations have been downloaded and
+     * how many are necessary in total to complete the next sync iteration.
      *
-     * @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.
+     * This field is only set when {@link SyncDataFlowStatus#downloading} is also true.
      */
-    JAVASCRIPT = "js",
+    get downloadProgress(): SyncProgress | null;
     /**
-     * This implementation offloads the sync line decoding and handling into the PowerSync
-     * core extension.
+     * Reports the sync status (a pair of {@link SyncStatus#hasSynced} and {@link SyncStatus#lastSyncedAt} fields)
+     * for a specific bucket priority level.
      *
-     * @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.
+     * 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.
      *
-     * ## Compatibility warning
+     * 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.
      *
-     * 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.
+     * 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.
      *
-     * __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.
+     * @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
      */
-    identifier?: string;
-    logger?: ILogger;
-    remote: AbstractRemote;
-}
-interface StreamingSyncImplementationListener extends BaseListener {
+    statusForPriority(priority: number): SyncPriorityStatus;
     /**
-     * Triggered whenever a status update has been attempted to be made or
-     * refreshed.
+     * 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
      */
-    statusUpdated?: ((statusUpdate: SyncStatusOptions) => void) | undefined;
+    isEqual(status: SyncStatus): boolean;
     /**
-     * Triggers whenever the status' members have changed in value
+     * 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
      */
-    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 {
+    getMessage(): string;
     /**
-     * Whether to use a JavaScript implementation to handle received sync lines from the sync
-     * service, or whether this work should be offloaded to the PowerSync core extension.
+     * Serializes the SyncStatus instance to a plain object.
      *
-     * This defaults to the JavaScript implementation ({@link SyncClientImplementation.JAVASCRIPT})
-     * since the ({@link SyncClientImplementation.RUST}) implementation is experimental at the moment.
+     * @returns {SyncStatusOptions} A plain object representation of the sync status
      */
-    clientImplementation?: SyncClientImplementation;
+    toJSON(): SyncStatusOptions;
+    private static comparePriorities;
+}
+
+declare class UploadQueueStats {
     /**
-     * The connection method to use when streaming updates from
-     * the PowerSync backend instance.
-     * Defaults to a HTTP streaming connection.
+     * Number of records in the upload queue.
      */
-    connectionMethod?: SyncStreamConnectionMethod;
+    count: number;
     /**
-     * The fetch strategy to use when streaming updates from the PowerSync backend instance.
+     * Size of the upload queue in bytes.
      */
-    fetchStrategy?: FetchStrategy;
+    size: number | null;
+    constructor(
     /**
-     * These parameters are passed to the sync rules, and will be available under the`user_parameters` object.
+     * Number of records in the upload queue.
      */
-    params?: Record<string, StreamingSyncRequestParameterType>;
+    count: number, 
     /**
-     * The serialized schema - mainly used to forward information about raw tables to the sync client.
+     * Size of the upload queue in bytes.
      */
-    serializedSchema?: any;
+    size?: number | null);
+    toString(): string;
 }
-/** @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;
+
+declare enum ColumnType {
+    TEXT = "TEXT",
+    INTEGER = "INTEGER",
+    REAL = "REAL"
 }
-/** @internal */
-type RequiredAdditionalConnectionOptions = Required<AdditionalConnectionOptions>;
-interface StreamingSyncImplementation extends BaseObserverInterface<StreamingSyncImplementationListener>, Disposable {
+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 = {
     /**
-     * Connects to the sync service
+     * The statement to run when PowerSync detects that a row needs to be inserted or updated.
      */
-    connect(options?: InternalConnectionOptions): Promise<void>;
+    put: PendingStatement;
     /**
-     * Disconnects from the sync services.
-     * @throws if not connected or if abort is not controlled internally
+     * The statement to run when PowerSync detects that a row needs to be deleted.
      */
-    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;
+    delete: PendingStatement;
 };
-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;
-}
-
-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.
+ * A parameter to use as part of {@link PendingStatement}.
  *
- * To obtain these values, use {@link SyncProgress}, available through
- * {@link SyncStatus#downloadProgress}.
+ * 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'}`.
  */
-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;
-}
+type PendingStatementParameter = 'Id' | {
+    Column: string;
+};
 /**
- * Provides realtime progress on how PowerSync is downloading rows.
+ * 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.
  *
- * 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).
+ * 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.
  *
- * 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).
+ * 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.
  *
- * 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.
+ * Note that raw tables are only supported when using the new `SyncClientImplementation.rust` sync client.
  *
- * Also note that data is downloaded in bulk, which means that individual counters are unlikely
- * to be updated one-by-one.
+ * @experimental Please note that this feature is experimental at the moment, and not covered by PowerSync semver or
+ * stability guarantees.
  */
-declare class SyncProgress implements ProgressWithOperations {
-    protected internal: InternalProgressInformation;
-    totalOperations: number;
-    downloadedOperations: number;
-    downloadedFraction: number;
-    constructor(internal: InternalProgressInformation);
+declare class RawTable implements RawTableType {
     /**
-     * Returns download progress towards all data up until the specified priority being received.
+     * The name of the table.
      *
-     * 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.
+     * 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.
      */
-    untilPriority(priority: number): ProgressWithOperations;
+    name: string;
+    put: PendingStatement;
+    delete: PendingStatement;
+    constructor(name: string, type: RawTableType);
 }
 
-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;
+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 {
     /**
-     * Internal information about how far we are downloading operations in buckets.
-     *
-     * Please use the {@link SyncStatus#downloadProgress} property to track sync progress.
+     * The synced table name, matching sync rules
      */
-    downloadProgress: InternalProgressInformation | null;
-}>;
-interface SyncPriorityStatus {
-    priority: number;
-    lastSyncedAt?: Date;
-    hasSynced?: boolean;
+    name: string;
+    columns: Column[];
+    indexes?: Index[];
 }
-type SyncStatusOptions = {
-    connected?: boolean;
-    connecting?: boolean;
-    dataFlow?: SyncDataFlowStatus;
-    lastSyncedAt?: Date;
-    hasSynced?: boolean;
-    priorityStatusEntries?: SyncPriorityStatus[];
-    clientImplementation?: SyncClientImplementation;
+type RowType<T extends TableV2<any>> = {
+    [K in keyof T['columnMap']]: ExtractColumnValueType<T['columnMap'][K]>;
+} & {
+    id: string;
 };
-declare class SyncStatus {
-    protected options: SyncStatusOptions;
-    constructor(options: SyncStatusOptions);
+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>;
     /**
-     * Returns the used sync client implementation (either the one implemented in JavaScript or the newer Rust-based
-     * implementation).
+     * Create a table.
+     * @deprecated This was only only included for TableV2 and is no longer necessary.
+     * Prefer to use new Table() directly.
      *
-     * This information is only available after a connection has been requested.
+     * TODO remove in the next major release.
      */
-    get clientImplementation(): SyncClientImplementation | undefined;
+    static createTable(name: string, table: Table): Table<ColumnsType>;
     /**
-     * Indicates if the client is currently connected to the PowerSync service.
+     * Creates a new Table instance.
      *
-     * @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.
+     * 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)
      *
-     * @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.
+     * @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
      *
-     * @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.
+     * @example
+     * ```javascript
+     * // New Constructor
+     * const table = new Table(
+     *   {
+     *     name: column.text,
+     *     age: column.integer
+     *   },
+     *   { indexes: { nameIndex: ['name'] } }
+     * );
+     *```
      *
-     * @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.
+     * @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 })
+     *   ]
+     * });
+     *```
      */
-    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;
-    }>;
+    constructor(columns: Columns, options?: TableV2Options);
     /**
-     * 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.
+     * @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'] } }
+     *   );
+     *```
      */
-    get priorityStatusEntries(): SyncPriorityStatus[];
+    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);
     /**
-     * A realtime progress report on how many operations have been downloaded and
-     * how many are necessary in total to complete the next sync iteration.
+     * 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.
      *
-     * This field is only set when {@link SyncDataFlowStatus#downloading} is also true.
+     * @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.
      */
-    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.
+    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 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.
+     * This should always fetch a fresh set of credentials - don't use cached
+     * values.
      *
-     * 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.
+     * 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.
      *
-     * @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
+     * This token is kept for the duration of a sync connection.
      */
-    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.
+    fetchCredentials: () => Promise<PowerSyncCredentials | null>;
+    /** Upload local changes to the app backend.
      *
-     * @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.
+     * Use {@link AbstractPowerSyncDatabase.getCrudBatch} to get a batch of changes to upload.
      *
-     * @returns {SyncStatusOptions} A plain object representation of the sync status
+     * Any thrown errors will result in a retry after the configured wait period (default: 5 seconds).
      */
-    toJSON(): SyncStatusOptions;
-    private static comparePriorities;
+    uploadData: (database: AbstractPowerSyncDatabase) => Promise<void>;
 }
 
-declare class UploadQueueStats {
+type DataStreamOptions<ParsedData, SourceData> = {
+    mapLine?: (line: SourceData) => ParsedData;
     /**
-     * Number of records in the upload queue.
+     * Close the stream if any consumer throws an error
      */
-    count: number;
+    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>;
     /**
-     * Size of the upload queue in bytes.
+     * Enqueues data for the consumers to read
      */
-    size: number | null;
-    constructor(
+    enqueueData(data: SourceData): void;
     /**
-     * Number of records in the upload queue.
+     * Reads data once from the data stream
+     * @returns a Data payload or Null if the stream closed.
      */
-    count: number, 
+    read(): Promise<ParsedData | null>;
     /**
-     * Size of the upload queue in bytes.
+     * Executes a callback for each data item in the stream
      */
-    size?: number | null);
-    toString(): string;
+    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>;
 }
 
-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 BSONImplementation = typeof BSON;
+type RemoteConnector = {
+    fetchCredentials: () => Promise<PowerSyncCredentials | null>;
+    invalidateCredentials?: () => void;
 };
-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 const DEFAULT_REMOTE_LOGGER: Logger.ILogger;
+type SyncStreamOptions = {
+    path: string;
+    data: StreamingSyncRequest;
+    headers?: Record<string, string>;
+    abortSignal?: AbortSignal;
+    fetchOptions?: Request;
 };
-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 = {
+declare enum FetchStrategy {
     /**
-     * The statement to run when PowerSync detects that a row needs to be inserted or updated.
+     * 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.
      */
-    put: PendingStatement;
+    Buffered = "buffered",
     /**
-     * The statement to run when PowerSync detects that a row needs to be deleted.
+     * Processes each sync event immediately before requesting the next.
+     * This reduces processing overhead and improves real-time responsiveness.
      */
-    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;
+    Sequential = "sequential"
+}
+type SocketSyncStreamOptions = SyncStreamOptions & {
+    fetchStrategy: FetchStrategy;
 };
+type FetchImplementation = typeof fetch;
 /**
- * A statement that the PowerSync client should use to insert or delete data into a table managed by the user.
+ * 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"
  */
-type PendingStatement = {
-    sql: string;
-    params: PendingStatementParameter[];
+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?: {};
 };
-/**
- * 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 {
+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>);
     /**
-     * The name of the table.
+     * @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.
      *
-     * 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.
+     * These credentials may have expired already.
      */
-    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 {
+    getCredentials(): Promise<PowerSyncCredentials | null>;
     /**
-     * The synced table name, matching sync rules
+     * 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.
      */
-    name: string;
-    columns: Column[];
-    indexes?: Index[];
+    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>>;
 }
-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 enum LockType {
+    CRUD = "crud",
+    SYNC = "sync"
 }
-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>;
+declare enum SyncStreamConnectionMethod {
+    HTTP = "http",
+    WEB_SOCKET = "web-socket"
+}
+declare enum SyncClientImplementation {
     /**
-     * Create a table.
-     * @deprecated This was only only included for TableV2 and is no longer necessary.
-     * Prefer to use new Table() directly.
+     * Decodes and handles sync lines received from the sync service in JavaScript.
      *
-     * TODO remove in the next major release.
+     * 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.
      */
-    static createTable(name: string, table: Table): Table<ColumnsType>;
+    JAVASCRIPT = "js",
     /**
-     * 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)
+     * This implementation offloads the sync line decoding and handling into the PowerSync
+     * core extension.
      *
-     * @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
+     * @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.
      *
-     * @example
-     * ```javascript
-     * // New Constructor
-     * const table = new Table(
-     *   {
-     *     name: column.text,
-     *     age: column.integer
-     *   },
-     *   { indexes: { nameIndex: ['name'] } }
-     * );
-     *```
+     * ## 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.
      *
-     * @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 })
-     *   ]
-     * });
-     *```
+     * __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.
      */
-    constructor(columns: Columns, options?: TableV2Options);
+    identifier?: string;
+    logger?: ILogger;
+    remote: AbstractRemote;
+}
+interface StreamingSyncImplementationListener extends BaseListener {
     /**
-     * @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'] } }
-     *   );
-     *```
+     * Triggered whenever a status update has been attempted to be made or
+     * refreshed.
      */
-    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;
-            }[];
-        }[];
-    };
+    statusUpdated?: ((statusUpdate: SyncStatusOptions) => void) | undefined;
+    /**
+     * Triggers whenever the status' members have changed in value
+     */
+    statusChanged?: ((status: SyncStatus) => void) | undefined;
 }
-
-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.
+ * Configurable options to be used when connecting to the PowerSync
+ * backend instance.
  */
-declare class Schema<S extends SchemaType = SchemaType> {
-    readonly types: SchemaTableType<S>;
-    readonly props: S;
-    readonly tables: Table[];
-    readonly rawTables: RawTable[];
-    constructor(tables: Table[] | S);
+type PowerSyncConnectionOptions = Omit<InternalConnectionOptions, 'serializedSchema'>;
+interface InternalConnectionOptions extends BaseConnectionOptions, AdditionalConnectionOptions {
+}
+/** @internal */
+interface BaseConnectionOptions {
     /**
-     * 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.
+     * 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.
      *
-     * @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.
+     * This defaults to the JavaScript implementation ({@link SyncClientImplementation.JAVASCRIPT})
+     * since the ({@link SyncClientImplementation.RUST}) implementation is experimental at the moment.
      */
-    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;
+    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;
 }
-
-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.
+/** @internal */
+interface AdditionalConnectionOptions {
+    /**
+     * Delay for retrying sync streaming operations
+     * from the PowerSync backend after an error occurs.
      */
-    fetchCredentials: () => Promise<PowerSyncCredentials | null>;
-    /** Upload local changes to the app backend.
+    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.
      *
-     * Use {@link AbstractPowerSyncDatabase.getCrudBatch} to get a batch of changes to upload.
+     * 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.
      *
-     * Any thrown errors will result in a retry after the configured wait period (default: 5 seconds).
+     * @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.
      */
-    uploadData: (database: AbstractPowerSyncDatabase) => Promise<void>;
+    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;
 }
 
 /**
@@ -1815,14 +1807,12 @@ declare enum WatchedQueryListenerEvent {
     ON_DATA = "onData",
     ON_ERROR = "onError",
     ON_STATE_CHANGE = "onStateChange",
-    SETTINGS_WILL_UPDATE = "settingsWillUpdate",
     CLOSED = "closed"
 }
 interface WatchedQueryListener<Data> extends BaseListener {
     [WatchedQueryListenerEvent.ON_DATA]?: (data: Data) => void | Promise<void>;
     [WatchedQueryListenerEvent.ON_ERROR]?: (error: Error) => void | Promise<void>;
     [WatchedQueryListenerEvent.ON_STATE_CHANGE]?: (state: WatchedQueryState<Data>) => void | Promise<void>;
-    [WatchedQueryListenerEvent.SETTINGS_WILL_UPDATE]?: () => void;
     [WatchedQueryListenerEvent.CLOSED]?: () => void | Promise<void>;
 }
 declare const DEFAULT_WATCH_THROTTLE_MS = 30;
@@ -1888,7 +1878,6 @@ declare abstract class AbstractQueryProcessor<Data = unknown[], Settings extends
     constructor(options: AbstractQueryProcessorOptions<Data, Settings>);
     protected constructInitialState(): WatchedQueryState<Data>;
     protected get reportFetching(): boolean;
-    protected updateSettingsInternal(settings: Settings, signal: AbortSignal): Promise<void>;
     /**
      * Updates the underlying query.
      */
@@ -1902,7 +1891,7 @@ declare abstract class AbstractQueryProcessor<Data = unknown[], Settings extends
     /**
      * Configures base DB listeners and links the query to listeners.
      */
-    protected init(signal: AbortSignal): Promise<void>;
+    protected init(): Promise<void>;
     close(): Promise<void>;
     /**
      * Runs a callback and reports errors to the error listeners.
@@ -2180,6 +2169,7 @@ interface SQLOpenOptions {
      *    debugMode: process.env.NODE_ENV !== 'production'
      */
     debugMode?: boolean;
+    logger?: ILogger;
 }
 interface SQLOpenFactory {
     /**
@@ -2552,7 +2542,7 @@ interface TriggerManager {
      *        },
      *        onChange: async (context) => {
      *          // Fetches the todo records that were inserted during this diff
-     *          const newTodos = await context.withDiff<Database['todos']>(`
+     *          const newTodos = await context.getAll<Database['todos']>(`
      *            SELECT
      *              todos.*
      *            FROM