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

package/dist/index.d.cts

@@ -357,7 +357,6 @@ interface Checkpoint {
     last_op_id: OpId;
     buckets: BucketChecksum[];
     write_checkpoint?: string;
-    streams?: any[];
 }
 interface BucketState {
     bucket: string;
@@ -391,12 +390,6 @@ interface BucketChecksum {
      * Count of operations - informational only.
      */
     count?: number;
-    /**
-     * The JavaScript client does not use this field, which is why it's defined to be `any`. We rely on the structure of
-     * this interface to pass custom `BucketChecksum`s to the Rust client in unit tests, which so all fields need to be
-     * present.
-     */
-    subscriptions?: any;
 }
 declare enum PSInternalTable {
     DATA = "ps_data",
@@ -411,8 +404,7 @@ declare enum PowerSyncControlCommand {
     STOP = "stop",
     START = "start",
     NOTIFY_TOKEN_REFRESHED = "refreshed_token",
-    NOTIFY_CRUD_UPLOAD_COMPLETED = "completed_upload",
-    UPDATE_SUBSCRIPTIONS = "update_subscriptions"
+    NOTIFY_CRUD_UPLOAD_COMPLETED = "completed_upload"
 }
 interface BucketStorageListener extends BaseListener {
     crudUpdate: () => void;
@@ -584,20 +576,6 @@ interface CrudResponse {
     checkpoint?: OpId;
 }
 
-interface CoreStreamSubscription {
-    progress: {
-        total: number;
-        downloaded: number;
-    };
-    name: string;
-    parameters: any;
-    priority: number | null;
-    active: boolean;
-    is_default: boolean;
-    has_explicit_subscription: boolean;
-    expires_at: number | null;
-    last_synced_at: number | null;
-}
 interface BucketProgress {
     priority: number;
     at_last: number;
@@ -605,1172 +583,1020 @@ interface BucketProgress {
     target_count: number;
 }
 
-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;
-};
+/** @internal */
+type InternalProgressInformation = Record<string, BucketProgress>;
 /**
- * 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.
+ * Information about a progressing download made by the PowerSync SDK.
+ *
+ * To obtain these values, use {@link SyncProgress}, available through
+ * {@link SyncStatus#downloadProgress}.
  */
-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>;
+interface ProgressWithOperations {
     /**
-     * Executes a callback for each data item in the stream
+     * The total amount of operations to download for the current sync iteration
+     * to complete.
      */
-    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;
-}
-
-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 {
+    totalOperations: number;
     /**
-     * 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 amount of operations that have already been downloaded.
      */
-    Buffered = "buffered",
+    downloadedOperations: number;
     /**
-     * Processes each sync event immediately before requesting the next.
-     * This reduces processing overhead and improves real-time responsiveness.
+     * 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.
      */
-    Sequential = "sequential"
+    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;
-}
-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;
+declare class SyncProgress implements ProgressWithOperations {
+    protected internal: InternalProgressInformation;
+    totalOperations: number;
+    downloadedOperations: number;
+    downloadedFraction: number;
+    constructor(internal: InternalProgressInformation);
     /**
-     * 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.
+     * 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.
      */
-    fetchImplementation: FetchImplementation | FetchImplementationProvider;
+    untilPriority(priority: number): ProgressWithOperations;
+}
+
+type SyncDataFlowStatus = Partial<{
+    downloading: boolean;
+    uploading: boolean;
     /**
-     * Optional options to pass directly to all `fetch` calls.
+     * Error during downloading (including connecting).
      *
-     * This can include fields such as `dispatcher` (e.g. for proxy support),
-     * `cache`, or any other fetch-compatible options.
+     * Cleared on the next successful data download.
      */
-    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>);
+    downloadError?: Error;
     /**
-     * @returns a fetch implementation (function)
-     * which can be called to perform fetch requests
+     * Error during uploading.
+     * Cleared on the next successful upload.
      */
-    get fetch(): FetchImplementation;
+    uploadError?: Error;
     /**
-     * Get credentials currently cached, or fetch new credentials if none are
-     * available.
+     * Internal information about how far we are downloading operations in buckets.
      *
-     * These credentials may have expired already.
+     * Please use the {@link SyncStatus#downloadProgress} property to track sync progress.
      */
-    getCredentials(): Promise<PowerSyncCredentials | null>;
+    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);
     /**
-     * Fetch a new set of credentials and cache it.
-     *
-     * Until this call succeeds, `getCredentials` will still return the
-     * old credentials.
+     * Indicates if the client is currently connected to the PowerSync service.
      *
-     * This may be called before the current credentials have expired.
+     * @returns {boolean} True if connected, false otherwise. Defaults to false if not specified.
      */
-    prefetchCredentials(): Promise<PowerSyncCredentials | null>;
+    get connected(): boolean;
     /**
-     * Get credentials for PowerSync.
+     * Indicates if the client is in the process of establishing a connection to the PowerSync service.
      *
-     * This should always fetch a fresh set of credentials - don't use cached
-     * values.
+     * @returns {boolean} True if connecting, false otherwise. Defaults to false if not specified.
      */
-    fetchCredentials(): Promise<PowerSyncCredentials | null>;
-    /***
-     * Immediately invalidate credentials.
+    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.
      *
-     * This may be called when the current credentials have expired.
+     * @returns {Date | undefined} The timestamp of the last successful sync, or undefined if no sync has completed.
      */
-    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>;
+    get lastSyncedAt(): Date | undefined;
     /**
-     * Provides a BSON implementation. The import nature of this varies depending on the platform
+     * 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.
      */
-    abstract getBSON(): Promise<BSONImplementation>;
-    protected createSocket(url: string): WebSocket;
+    get hasSynced(): boolean | undefined;
     /**
-     * Returns a data stream of sync line data.
+     * Provides the current data flow status regarding uploads and downloads.
      *
-     * @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).
+     * @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.
      */
-    socketStreamRaw<T>(options: SocketSyncStreamOptions, map: (buffer: Uint8Array) => T, bson?: typeof BSON): Promise<DataStream<T>>;
+    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;
+    }>;
     /**
-     * Connects to the sync/stream http endpoint, mapping and emitting each received string line.
+     * 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.
      */
-    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 RequiredAdditionalConnectionOptions {
-    adapter: BucketStorageAdapter;
-    subscriptions: SubscribedStream[];
-    uploadCrud: () => Promise<void>;
-    /**
-     * An identifier for which PowerSync DB this sync implementation is
-     * linked to. Most commonly DB name, but not restricted to DB name.
-     */
-    identifier?: string;
-    logger?: ILogger;
-    remote: AbstractRemote;
-}
-interface StreamingSyncImplementationListener extends BaseListener {
-    /**
-     * Triggered whenever a status update has been attempted to be made or
-     * refreshed.
+     * @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
      */
-    statusUpdated?: ((statusUpdate: SyncStatusOptions) => void) | undefined;
+    statusForPriority(priority: number): SyncPriorityStatus;
     /**
-     * Triggers whenever the status' members have changed in value
+     * 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
      */
-    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 {
+    isEqual(status: SyncStatus): boolean;
     /**
-     * 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.
+     * Creates a human-readable string representation of the current sync status.
+     * Includes information about connection state, sync completion, and data flow.
      *
-     * This defaults to the JavaScript implementation ({@link SyncClientImplementation.JAVASCRIPT})
-     * since the ({@link SyncClientImplementation.RUST}) implementation is experimental at the moment.
+     * @returns {string} A string representation of the sync status
      */
-    clientImplementation?: SyncClientImplementation;
+    getMessage(): string;
     /**
-     * The connection method to use when streaming updates from
-     * the PowerSync backend instance.
-     * Defaults to a HTTP streaming connection.
+     * Serializes the SyncStatus instance to a plain object.
+     *
+     * @returns {SyncStatusOptions} A plain object representation of the sync status
      */
-    connectionMethod?: SyncStreamConnectionMethod;
+    toJSON(): SyncStatusOptions;
+    private static comparePriorities;
+}
+
+declare class UploadQueueStats {
     /**
-     * The fetch strategy to use when streaming updates from the PowerSync backend instance.
+     * Number of records in the upload queue.
      */
-    fetchStrategy?: FetchStrategy;
+    count: number;
     /**
-     * These parameters are passed to the sync rules, and will be available under the`user_parameters` object.
+     * Size of the upload queue in bytes.
      */
-    params?: Record<string, StreamingSyncRequestParameterType>;
+    size: number | null;
+    constructor(
     /**
-     * Whether to include streams that have `auto_subscribe: true` in their definition.
-     *
-     * This defaults to `true`.
+     * Number of records in the upload queue.
      */
-    includeDefaultStreams?: boolean;
+    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 */
-interface RequiredAdditionalConnectionOptions extends Required<AdditionalConnectionOptions> {
-    subscriptions: SubscribedStream[];
+interface ColumnOptions {
+    name: string;
+    type?: ColumnType;
 }
-interface StreamingSyncImplementation extends BaseObserverInterface<StreamingSyncImplementationListener>, Disposable {
+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>;
-    updateSubscriptions(subscriptions: SubscribedStream[]): void;
-}
-declare const DEFAULT_CRUD_UPLOAD_THROTTLE_MS = 1000;
-declare const DEFAULT_RETRY_DELAY_MS = 5000;
-declare const DEFAULT_STREAMING_SYNC_OPTIONS: {
-    retryDelayMs: number;
-    crudUploadThrottleMs: number;
-};
-type RequiredPowerSyncConnectionOptions = Required<BaseConnectionOptions>;
-declare const DEFAULT_STREAM_CONNECTION_OPTIONS: RequiredPowerSyncConnectionOptions;
-type SubscribedStream = {
-    name: string;
-    params: Record<string, any> | null;
+    delete: PendingStatement;
 };
-declare abstract class AbstractStreamingSyncImplementation extends BaseObserver<StreamingSyncImplementationListener> implements StreamingSyncImplementation {
-    protected _lastSyncedAt: Date | null;
-    protected options: AbstractStreamingSyncImplementationOptions;
-    protected abortController: AbortController | null;
-    protected uploadAbortController: AbortController | null;
-    protected crudUpdateListener?: () => void;
-    protected streamingSyncPromise?: Promise<void>;
-    protected logger: ILogger;
-    private activeStreams;
-    private isUploadingCrud;
-    private notifyCompletedUploads?;
-    private handleActiveStreamsChange?;
-    syncStatus: SyncStatus;
-    triggerCrudUpload: () => void;
-    constructor(options: AbstractStreamingSyncImplementationOptions);
-    waitForReady(): Promise<void>;
-    waitForStatus(status: SyncStatusOptions): Promise<void>;
-    waitUntilStatusMatches(predicate: (status: SyncStatus) => boolean): Promise<void>;
-    get lastSyncedAt(): Date | undefined;
-    get isConnected(): boolean;
-    dispose(): Promise<void>;
-    abstract obtainLock<T>(lockOptions: LockOptions<T>): Promise<T>;
-    hasCompletedSync(): Promise<boolean>;
-    getWriteCheckpoint(): Promise<string>;
-    protected _uploadAllCrud(): Promise<void>;
-    connect(options?: PowerSyncConnectionOptions): Promise<void>;
-    disconnect(): Promise<void>;
-    /**
-     * @deprecated use [connect instead]
-     */
-    streamingSync(signal?: AbortSignal, options?: PowerSyncConnectionOptions): Promise<void>;
-    private collectLocalBucketState;
-    /**
-     * Older versions of the JS SDK used to encode subkeys as JSON in {@link OplogEntry.toJSON}.
-     * Because subkeys are always strings, this leads to quotes being added around them in `ps_oplog`.
-     * While this is not a problem as long as it's done consistently, it causes issues when a database
-     * created by the JS SDK is used with other SDKs, or (more likely) when the new Rust sync client
-     * is enabled.
-     *
-     * So, we add a migration from the old key format (with quotes) to the new one (no quotes). The
-     * migration is only triggered when necessary (for now). The function returns whether the new format
-     * should be used, so that the JS SDK is able to write to updated databases.
-     *
-     * @param requireFixedKeyFormat Whether we require the new format or also support the old one.
-     *        The Rust client requires the new subkey format.
-     * @returns Whether the database is now using the new, fixed subkey format.
-     */
-    private requireKeyFormat;
-    protected streamingSyncIteration(signal: AbortSignal, options?: PowerSyncConnectionOptions): Promise<RustIterationResult | null>;
-    private legacyStreamingSyncIteration;
-    private rustSyncIteration;
-    private updateSyncStatusForStartingCheckpoint;
-    private applyCheckpoint;
-    protected updateSyncStatus(options: SyncStatusOptions): void;
-    private delayRetry;
-    updateSubscriptions(subscriptions: SubscribedStream[]): void;
-}
-interface RustIterationResult {
-    immediateRestart: boolean;
-}
-
-/** @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);
 }
 
-/**
- * A description of a sync stream, consisting of its {@link name} and the {@link parameters} used when subscribing.
- */
-interface SyncStreamDescription {
-    /**
-     * The name of the stream as it appears in the stream definition for the PowerSync service.
-     */
+interface IndexColumnOptions {
     name: string;
-    /**
-     * The parameters used to subscribe to the stream, if any.
-     *
-     * The same stream can be subscribed to multiple times with different parameters.
-     */
-    parameters: Record<string, any> | null;
+    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;
+        }[];
+    };
 }
+
 /**
- * Information about a subscribed sync stream.
+  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.
  *
- * This includes the {@link SyncStreamDescription}, along with information about the current sync status.
+ * 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 SyncSubscriptionDescription extends SyncStreamDescription {
-    active: boolean;
-    /**
-     * Whether this stream subscription is included by default, regardless of whether the stream has explicitly been
-     * subscribed to or not.
-     *
-     * It's possible for both {@link isDefault} and {@link hasExplicitSubscription} to be true at the same time - this
-     * happens when a default stream was subscribed explicitly.
-     */
-    isDefault: boolean;
-    /**
-     * Whether this stream has been subscribed to explicitly.
-     *
-     * It's possible for both {@link isDefault} and {@link hasExplicitSubscription} to be true at the same time - this
-     * happens when a default stream was subscribed explicitly.
-     */
-    hasExplicitSubscription: boolean;
-    /**
-     * For sync streams that have a time-to-live, the current time at which the stream would expire if not subscribed to
-     * again.
-     */
-    expiresAt: Date | null;
-    /**
-     * Whether this stream subscription has been synced at least once.
-     */
-    hasSynced: boolean;
-    /**
-     * If {@link hasSynced} is true, the last time data from this stream has been synced.
-     */
-    lastSyncedAt: Date | null;
+interface 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 SyncStreamSubscribeOptions {
-    /**
-     * A "time to live" for this stream subscription, in seconds.
-     *
-     * The TTL control when a stream gets evicted after not having an active {@link SyncStreamSubscription} object
-     * attached to it.
-     */
-    ttl?: number;
+interface TableOptions extends SharedTableOptions {
     /**
-     * A priority to assign to this subscription. This overrides the default priority that may have been set on streams.
-     *
-     * For details on priorities, see [priotized sync](https://docs.powersync.com/usage/use-case-examples/prioritized-sync).
+     * The synced table name, matching sync rules
      */
-    priority?: 0 | 1 | 2 | 3;
+    name: string;
+    columns: Column[];
+    indexes?: Index[];
 }
-/**
- * A handle to a {@link SyncStreamDescription} that allows subscribing to the stream.
- *
- * To obtain an instance of {@link SyncStream}, call {@link AbstractPowerSyncDatabase.syncStream}.
- */
-interface SyncStream extends SyncStreamDescription {
+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>;
     /**
-     * Adds a subscription to this stream, requesting it to be included when connecting to the sync service.
+     * Create a table.
+     * @deprecated This was only only included for TableV2 and is no longer necessary.
+     * Prefer to use new Table() directly.
      *
-     * You should keep a reference to the returned {@link SyncStreamSubscription} object along as you need data for that
-     * stream. As soon as {@link SyncStreamSubscription.unsubscribe} is called for all subscriptions on this stream
-     * (including subscriptions created on other tabs), the {@link SyncStreamSubscribeOptions.ttl} starts ticking and will
-     * eventually evict the stream (unless {@link subscribe} is called again).
+     * TODO remove in the next major release.
      */
-    subscribe(options?: SyncStreamSubscribeOptions): Promise<SyncStreamSubscription>;
+    static createTable(name: string, table: Table): Table<ColumnsType>;
     /**
-     * Clears all subscriptions attached to this stream and resets the TTL for the stream.
+     * Creates a new Table instance.
      *
-     * This is a potentially dangerous operations, as it interferes with other stream subscriptions.
-     */
-    unsubscribeAll(): Promise<void>;
-}
-interface SyncStreamSubscription extends SyncStreamDescription {
-    /**
-     * A promise that resolves once data from in this sync stream has been synced and applied.
+     * 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 })
+     *   ]
+     * });
+     *```
      */
-    waitForFirstSync(abort?: AbortSignal): Promise<void>;
+    constructor(columns: Columns, options?: TableV2Options);
     /**
-     * Removes this stream subscription.
+     * @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'] } }
+     *   );
+     *```
      */
-    unsubscribe(): void;
+    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 SyncDataFlowStatus = Partial<{
-    downloading: boolean;
-    uploading: boolean;
+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);
     /**
-     * Error during downloading (including connecting).
+     * 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.
      *
-     * Cleared on the next successful data download.
+     * @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.
      */
-    downloadError?: Error;
-    /**
-     * Error during uploading.
-     * Cleared on the next successful upload.
+    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.
      */
-    uploadError?: Error;
-    /**
-     * Internal information about how far we are downloading operations in buckets.
+    fetchCredentials: () => Promise<PowerSyncCredentials | null>;
+    /** Upload local changes to the app backend.
      *
-     * Please use the {@link SyncStatus#downloadProgress} property to track sync progress.
+     * 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).
      */
-    downloadProgress: InternalProgressInformation | null;
-    internalStreamSubscriptions: CoreStreamSubscription[] | null;
-}>;
-interface SyncPriorityStatus {
-    priority: number;
-    lastSyncedAt?: Date;
-    hasSynced?: boolean;
+    uploadData: (database: AbstractPowerSyncDatabase) => Promise<void>;
 }
-type SyncStatusOptions = {
-    connected?: boolean;
-    connecting?: boolean;
-    dataFlow?: SyncDataFlowStatus;
-    lastSyncedAt?: Date;
-    hasSynced?: boolean;
-    priorityStatusEntries?: SyncPriorityStatus[];
-    clientImplementation?: SyncClientImplementation;
-};
-declare class SyncStatus {
-    protected options: SyncStatusOptions;
-    constructor(options: SyncStatusOptions);
+
+type DataStreamOptions<ParsedData, SourceData> = {
+    mapLine?: (line: SourceData) => ParsedData;
     /**
-     * Returns the used sync client implementation (either the one implemented in JavaScript or the newer Rust-based
-     * implementation).
-     *
-     * This information is only available after a connection has been requested.
+     * Close the stream if any consumer throws an error
      */
-    get clientImplementation(): SyncClientImplementation | undefined;
+    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>;
     /**
-     * Indicates if the client is currently connected to the PowerSync service.
-     *
-     * @returns {boolean} True if connected, false otherwise. Defaults to false if not specified.
+     * Enqueues data for the consumers to read
      */
-    get connected(): boolean;
+    enqueueData(data: SourceData): void;
     /**
-     * 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.
+     * Reads data once from the data stream
+     * @returns a Data payload or Null if the stream closed.
      */
-    get connecting(): boolean;
+    read(): Promise<ParsedData | null>;
     /**
-     * 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.
+     * Executes a callback for each data item in the stream
      */
-    get lastSyncedAt(): Date | undefined;
+    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 {
     /**
-     * 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.
+     * 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.
      */
-    get hasSynced(): boolean | undefined;
+    Buffered = "buffered",
     /**
-     * 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.
+     * Processes each sync event immediately before requesting the next.
+     * This reduces processing overhead and improves real-time responsiveness.
      */
-    get dataFlowStatus(): Partial<{
-        downloading: boolean;
-        uploading: boolean;
-        /**
-         * Error during downloading (including connecting).
-         *
-         * Cleared on the next successful data download.
-         */
-        downloadError?: Error;
-        /**
-         * Error during uploading.
-         * Cleared on the next successful upload.
-         */
-        uploadError?: Error;
-        /**
-         * Internal information about how far we are downloading operations in buckets.
-         *
-         * Please use the {@link SyncStatus#downloadProgress} property to track sync progress.
-         */
-        downloadProgress: InternalProgressInformation | null;
-        internalStreamSubscriptions: CoreStreamSubscription[] | null;
-    }>;
+    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 = {
     /**
-     * All sync streams currently being tracked in teh database.
-     *
-     * This returns null when the database is currently being opened and we don't have reliable information about all
-     * included streams yet.
-     *
-     * @experimental Sync streams are currently in alpha.
+     * Transforms the PowerSync base URL which might contain
+     * `http(s)://` to the corresponding WebSocket variant
+     * e.g. `ws(s)://`
      */
-    get syncStreams(): SyncStreamStatus[] | undefined;
+    socketUrlTransformer: (url: string) => string;
     /**
-     * If the `stream` appears in {@link syncStreams}, returns the current status for that stream.
-     *
-     * @experimental Sync streams are currently in alpha.
+     * 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.
      */
-    forStream(stream: SyncStreamDescription): SyncStreamStatus | undefined;
+    fetchImplementation: FetchImplementation | FetchImplementationProvider;
     /**
-     * Provides sync status information for all bucket priorities, sorted by priority (highest first).
+     * Optional options to pass directly to all `fetch` calls.
      *
-     * @returns {SyncPriorityStatus[]} An array of status entries for different sync priority levels,
-     * sorted with highest priorities (lower numbers) first.
+     * This can include fields such as `dispatcher` (e.g. for proxy support),
+     * `cache`, or any other fetch-compatible options.
      */
-    get priorityStatusEntries(): SyncPriorityStatus[];
+    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>);
     /**
-     * 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.
+     * @returns a fetch implementation (function)
+     * which can be called to perform fetch requests
      */
-    get downloadProgress(): SyncProgress | null;
+    get fetch(): FetchImplementation;
     /**
-     * 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.
+     * Get credentials currently cached, or fetch new credentials if none are
+     * available.
      *
-     * @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
+     * These credentials may have expired already.
      */
-    statusForPriority(priority: number): SyncPriorityStatus;
+    getCredentials(): Promise<PowerSyncCredentials | null>;
     /**
-     * Compares this SyncStatus instance with another to determine if they are equal.
-     * Equality is determined by comparing the serialized JSON representation of both instances.
+     * Fetch a new set of credentials and cache it.
      *
-     * @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.
+     * Until this call succeeds, `getCredentials` will still return the
+     * old credentials.
      *
-     * @returns {string} A string representation of the sync status
+     * This may be called before the current credentials have expired.
      */
-    getMessage(): string;
+    prefetchCredentials(): Promise<PowerSyncCredentials | null>;
     /**
-     * Serializes the SyncStatus instance to a plain object.
+     * Get credentials for PowerSync.
      *
-     * @returns {SyncStatusOptions} A plain object representation of the sync status
+     * This should always fetch a fresh set of credentials - don't use cached
+     * values.
      */
-    toJSON(): SyncStatusOptions;
-    private static comparePriorities;
-}
-/**
- * Information about a sync stream subscription.
- */
-interface SyncStreamStatus {
-    progress: ProgressWithOperations | null;
-    subscription: SyncSubscriptionDescription;
-    priority: number | null;
-}
-
-declare class UploadQueueStats {
-    /**
-     * Number of records in the upload queue.
+    fetchCredentials(): Promise<PowerSyncCredentials | null>;
+    /***
+     * Immediately invalidate credentials.
+     *
+     * This may be called when the current credentials have expired.
      */
-    count: number;
+    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>;
     /**
-     * Size of the upload queue in bytes.
+     * Provides a BSON implementation. The import nature of this varies depending on the platform
      */
-    size: number | null;
-    constructor(
+    abstract getBSON(): Promise<BSONImplementation>;
+    protected createSocket(url: string): WebSocket;
     /**
-     * Number of records in the upload queue.
+     * 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).
      */
-    count: number, 
+    socketStreamRaw<T>(options: SocketSyncStreamOptions, map: (buffer: Uint8Array) => T, bson?: typeof BSON): Promise<DataStream<T>>;
     /**
-     * Size of the upload queue in bytes.
+     * Connects to the sync/stream http endpoint, mapping and emitting each received string line.
      */
-    size?: number | null);
-    toString(): string;
+    postStreamRaw<T>(options: SyncStreamOptions, mapLine: (line: string) => T): Promise<DataStream<T>>;
 }
 
-declare enum ColumnType {
-    TEXT = "TEXT",
-    INTEGER = "INTEGER",
-    REAL = "REAL"
-}
-interface ColumnOptions {
-    name: string;
-    type?: ColumnType;
+declare enum LockType {
+    CRUD = "crud",
+    SYNC = "sync"
 }
-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;
-    };
+declare enum SyncStreamConnectionMethod {
+    HTTP = "http",
+    WEB_SOCKET = "web-socket"
 }
-
-/**
- * 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;
+declare enum SyncClientImplementation {
     /**
-     * The statement to run when PowerSync detects that a row needs to be deleted.
+     * 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.
      */
-    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 {
+    JAVASCRIPT = "js",
     /**
-     * The name of the table.
+     * This implementation offloads the sync line decoding and handling into the PowerSync
+     * core extension.
      *
-     * 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.
+     * @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.
      */
-    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;
-        }[];
-    };
+    RUST = "rust"
 }
-
 /**
-  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.
+ * The default {@link SyncClientImplementation} to use.
  *
- * 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.
+ * 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.
  */
-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;
+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 TableOptions extends SharedTableOptions {
+interface AbstractStreamingSyncImplementationOptions extends AdditionalConnectionOptions {
+    adapter: BucketStorageAdapter;
+    uploadCrud: () => Promise<void>;
     /**
-     * The synced table name, matching sync rules
+     * An identifier for which PowerSync DB this sync implementation is
+     * linked to. Most commonly DB name, but not restricted to DB name.
      */
-    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;
+    identifier?: string;
+    logger?: ILogger;
+    remote: AbstractRemote;
 }
-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>;
+interface StreamingSyncImplementationListener extends BaseListener {
     /**
-     * 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 })
-     *   ]
-     * });
-     *```
+     * Triggered whenever a status update has been attempted to be made or
+     * refreshed.
      */
-    constructor(columns: Columns, options?: TableV2Options);
+    statusUpdated?: ((statusUpdate: SyncStatusOptions) => void) | undefined;
     /**
-     * @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'] } }
-     *   );
-     *```
+     * Triggers whenever the status' members have changed in value
      */
-    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;
-            }[];
-        }[];
-    };
+    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;
 }
 
 /**
@@ -1784,24 +1610,11 @@ interface ConnectionManagerSyncImplementationResult {
      */
     onDispose: () => Promise<void> | void;
 }
-/**
- * The subset of {@link AbstractStreamingSyncImplementationOptions} managed by the connection manager.
- *
- * @internal
- */
-interface CreateSyncImplementationOptions extends AdditionalConnectionOptions {
-    subscriptions: SubscribedStream[];
-}
-interface InternalSubscriptionAdapter {
-    firstStatusMatching(predicate: (status: SyncStatus) => any, abort?: AbortSignal): Promise<void>;
-    resolveOfflineSyncStatus(): Promise<void>;
-    rustSubscriptionsCommand(payload: any): Promise<void>;
-}
 /**
  * @internal
  */
 interface ConnectionManagerOptions {
-    createSyncImplementation(connector: PowerSyncBackendConnector, options: CreateSyncImplementationOptions): Promise<ConnectionManagerSyncImplementationResult>;
+    createSyncImplementation(connector: PowerSyncBackendConnector, options: InternalConnectionOptions): Promise<ConnectionManagerSyncImplementationResult>;
     logger: ILogger;
 }
 type StoredConnectionOptions = {
@@ -1847,12 +1660,6 @@ declare class ConnectionManager extends BaseObserver<ConnectionManagerListener>
      * is disposed.
      */
     protected syncDisposer: (() => Promise<void> | void) | null;
-    /**
-     * Subscriptions managed in this connection manager.
-     *
-     * On the web, these local subscriptions are merged across tabs by a shared worker.
-     */
-    private locallyActiveSubscriptions;
     constructor(options: ConnectionManagerOptions);
     get logger(): ILogger;
     close(): Promise<void>;
@@ -1866,9 +1673,6 @@ declare class ConnectionManager extends BaseObserver<ConnectionManagerListener>
     disconnect(): Promise<void>;
     protected disconnectInternal(): Promise<void>;
     protected performDisconnect(): Promise<void>;
-    stream(adapter: InternalSubscriptionAdapter, name: string, parameters: Record<string, any> | null): SyncStream;
-    private get activeStreams();
-    private subscriptionsMayHaveChanged;
 }
 
 /**
@@ -2003,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;
@@ -2076,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.
      */
@@ -2090,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.
@@ -2368,6 +2169,7 @@ interface SQLOpenOptions {
      *    debugMode: process.env.NODE_ENV !== 'production'
      */
     debugMode?: boolean;
+    logger?: ILogger;
 }
 interface SQLOpenFactory {
     /**
@@ -2740,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
@@ -2891,7 +2693,6 @@ declare abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncD
     protected bucketStorageAdapter: BucketStorageAdapter;
     protected _isReadyPromise: Promise<void>;
     protected connectionManager: ConnectionManager;
-    private subscriptions;
     get syncStreamImplementation(): StreamingSyncImplementation | null;
     protected _schema: Schema;
     private _database;
@@ -2927,7 +2728,7 @@ declare abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncD
      * Opens the DBAdapter given open options using a default open factory
      */
     protected abstract openDBAdapter(options: PowerSyncDatabaseOptionsWithSettings): DBAdapter;
-    protected abstract generateSyncStreamImplementation(connector: PowerSyncBackendConnector, options: CreateSyncImplementationOptions & RequiredAdditionalConnectionOptions): StreamingSyncImplementation;
+    protected abstract generateSyncStreamImplementation(connector: PowerSyncBackendConnector, options: RequiredAdditionalConnectionOptions): StreamingSyncImplementation;
     protected abstract generateBucketStorageAdapter(): BucketStorageAdapter;
     /**
      * @returns A promise which will resolve once initialization is completed.
@@ -2946,7 +2747,6 @@ declare abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncD
         signal?: AbortSignal;
         priority?: number;
     }): Promise<void>;
-    private waitForStatus;
     /**
      * Allows for extended implementations to execute custom initialization
      * logic as part of the total init process
@@ -2958,7 +2758,7 @@ declare abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncD
      */
     protected initialize(): Promise<void>;
     private _loadVersion;
-    protected resolveOfflineSyncStatus(): Promise<void>;
+    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.
      *
@@ -2970,7 +2770,7 @@ declare abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncD
      * While initializing is automatic, this helps to catch and report initialization errors.
      */
     init(): Promise<void>;
-    protected resolvedConnectionOptions(options: CreateSyncImplementationOptions): CreateSyncImplementationOptions & RequiredAdditionalConnectionOptions;
+    resolvedConnectionOptions(options?: PowerSyncConnectionOptions): RequiredAdditionalConnectionOptions;
     /**
      * @deprecated Use {@link AbstractPowerSyncDatabase#close} instead.
      * Clears all listeners registered by {@link AbstractPowerSyncDatabase#registerListener}.
@@ -3000,15 +2800,6 @@ declare abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncD
      * To preserve data in local-only tables, set clearLocal to false.
      */
     disconnectAndClear(options?: DisconnectAndClearOptions): Promise<void>;
-    /**
-     * Create a sync stream to query its status or to subscribe to it.
-     *
-     * @param name The name of the stream to subscribe to.
-     * @param params Optional parameters for the stream subscription.
-     * @returns A {@link SyncStream} instance that can be subscribed to.
-     * @experimental Sync streams are currently in alpha.
-     */
-    syncStream(name: string, params?: Record<string, any>): SyncStream;
     /**
      * Close the database, releasing resources.
      *
@@ -3575,4 +3366,4 @@ interface ParsedQuery {
 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, DiffTriggerOperation, 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, sanitizeSQL, sanitizeUUID };
-export type { AbstractQueryProcessorOptions, AbstractRemoteOptions, AbstractStreamingSyncImplementationOptions, AdditionalConnectionOptions, ArrayComparatorOptions, ArrayQueryDefinition, BSONImplementation, BaseColumnType, BaseConnectionOptions, BaseListener, BaseObserverInterface, BasePowerSyncDatabaseOptions, BaseTriggerDiffRecord, BatchedUpdateNotification, BucketChecksum, BucketDescription, BucketOperationProgress, BucketRequest, BucketState, BucketStorageAdapter, BucketStorageListener, Checkpoint, ChecksumCache, ColumnOptions, ColumnsType, CompilableQuery, CompilableQueryWatchHandler, CompiledQuery, ConnectionManagerListener, ConnectionManagerOptions, ConnectionManagerSyncImplementationResult, ContinueCheckpointRequest, ControlledExecutorOptions, CreateDiffTriggerOptions, CreateLoggerOptions, CreateSyncImplementationOptions, CrudRequest, CrudResponse, CrudUploadNotification, DBAdapter, DBAdapterListener, DBGetUtils, DBLockOptions, DataStreamCallback, DataStreamListener, DataStreamOptions, DifferentialQueryProcessorOptions, DifferentialWatchedQuery, DifferentialWatchedQueryComparator, DifferentialWatchedQueryListener, DifferentialWatchedQueryOptions, DifferentialWatchedQuerySettings, DisconnectAndClearOptions, Disposable, ExtractColumnValueType, ExtractedTriggerDiffRecord, FetchImplementation, GetAllQueryOptions, IndexColumnOptions, IndexOptions, IndexShorthand, InternalConnectionOptions, InternalSubscriptionAdapter, 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, SubscribedStream, SyncDataBucketJSON, SyncDataFlowStatus, SyncLocalDatabaseResult, SyncNewCheckpointRequest, SyncPriorityStatus, SyncRequest, SyncResponse, SyncStatusOptions, SyncStream, SyncStreamDescription, SyncStreamOptions, SyncStreamStatus, SyncStreamSubscribeOptions, SyncStreamSubscription, SyncSubscriptionDescription, TableOptions, TableUpdateOperation, TableV2Options, TrackDiffOptions, TrackPreviousOptions, Transaction, TriggerCreationHooks, TriggerDiffDeleteRecord, TriggerDiffHandlerContext, TriggerDiffInsertRecord, TriggerDiffRecord, TriggerDiffUpdateRecord, TriggerManager, TriggerRemoveCallback, UpdateNotification, WatchCompatibleQuery, WatchExecuteOptions, WatchHandler, WatchOnChangeEvent, WatchOnChangeHandler, WatchedQuery, WatchedQueryComparator, WatchedQueryDifferential, WatchedQueryListener, WatchedQueryOptions, WatchedQueryRowDifferential, WatchedQuerySettings, WatchedQueryState };
+export type { AbstractQueryProcessorOptions, AbstractRemoteOptions, AbstractStreamingSyncImplementationOptions, AdditionalConnectionOptions, ArrayComparatorOptions, ArrayQueryDefinition, BSONImplementation, BaseColumnType, BaseConnectionOptions, BaseListener, BaseObserverInterface, BasePowerSyncDatabaseOptions, BaseTriggerDiffRecord, BatchedUpdateNotification, BucketChecksum, BucketDescription, BucketOperationProgress, BucketRequest, BucketState, BucketStorageAdapter, BucketStorageListener, Checkpoint, ChecksumCache, ColumnOptions, ColumnsType, CompilableQuery, CompilableQueryWatchHandler, CompiledQuery, ConnectionManagerListener, ConnectionManagerOptions, ConnectionManagerSyncImplementationResult, ContinueCheckpointRequest, ControlledExecutorOptions, CreateDiffTriggerOptions, CreateLoggerOptions, CrudRequest, CrudResponse, CrudUploadNotification, DBAdapter, DBAdapterListener, DBGetUtils, DBLockOptions, DataStreamCallback, DataStreamListener, DataStreamOptions, DifferentialQueryProcessorOptions, DifferentialWatchedQuery, DifferentialWatchedQueryComparator, DifferentialWatchedQueryListener, DifferentialWatchedQueryOptions, DifferentialWatchedQuerySettings, DisconnectAndClearOptions, Disposable, ExtractColumnValueType, ExtractedTriggerDiffRecord, 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, TrackDiffOptions, TrackPreviousOptions, Transaction, TriggerCreationHooks, TriggerDiffDeleteRecord, TriggerDiffHandlerContext, TriggerDiffInsertRecord, TriggerDiffRecord, TriggerDiffUpdateRecord, TriggerManager, TriggerRemoveCallback, UpdateNotification, WatchCompatibleQuery, WatchExecuteOptions, WatchHandler, WatchOnChangeEvent, WatchOnChangeHandler, WatchedQuery, WatchedQueryComparator, WatchedQueryDifferential, WatchedQueryListener, WatchedQueryOptions, WatchedQueryRowDifferential, WatchedQuerySettings, WatchedQueryState };