import { ArrayQueryDefinition, BasePowerSyncDatabaseOptions, CommonPowerSyncDatabase, CrudBatch, CrudTransaction, DBAdapter, DisconnectAndClearOptions, LockContext, PowerSyncBackendConnector, PowerSyncCloseOptions, PowerSyncDBListener, PowerSyncLogger, Query, QueryResult, Schema, SQLOnChangeOptions, SQLWatchOptions, SyncOptions, SyncStatus, SyncStream, Transaction, TriggerManager, UploadQueueStats, WatchCompatibleQuery, WatchHandler, WatchOnChangeEvent, WatchOnChangeHandler, BaseObserver, SqliteRecord, SyncStreamConnectionMethod } from '@powersync/common';
import { BucketStorageAdapter } from './sync/bucket/BucketStorageAdapter.js';
import { SyncStatusSnapshot } from '../db/crud/SyncStatus.js';
import { ConnectionManager, CreateSyncImplementationOptions } from './ConnectionManager.js';
import { Mutex } from '../utils/mutex.js';
import { TriggerManagerConfig, TriggerManagerImpl } from './triggers/TriggerManagerImpl.js';
import { StreamingSyncImplementation } from './sync/stream/AbstractStreamingSyncImplementation.js';
/**
 * @internal
 */
export declare const DEFAULT_POWERSYNC_CLOSE_OPTIONS: PowerSyncCloseOptions;
/**
 * Requesting nested or recursive locks can block the application in some circumstances.
 * This default lock timeout will act as a failsafe to throw an error if a lock cannot
 * be obtained.
 *
 * @internal
 */
export declare const DEFAULT_LOCK_TIMEOUT_MS = 120000;
export declare abstract class BasePowerSyncDatabase<Options extends BasePowerSyncDatabaseOptions = BasePowerSyncDatabaseOptions> extends BaseObserver<PowerSyncDBListener> implements CommonPowerSyncDatabase {
    protected options: Options;
    closed: boolean;
    ready: boolean;
    currentStatus: SyncStatusSnapshot;
    sdkVersion: string;
    protected bucketStorageAdapter: BucketStorageAdapter;
    protected _isReadyPromise: Promise<void>;
    protected connectionManager: ConnectionManager;
    private subscriptions;
    get syncStreamImplementation(): StreamingSyncImplementation | null;
    /**
     * The connector used to connect to the PowerSync service.
     *
     * @returns The connector used to connect to the PowerSync service or null if `connect()` has not been called.
     */
    get connector(): PowerSyncBackendConnector | null;
    /**
     * The resolved connection options used to connect to the PowerSync service.
     *
     * @returns The resolved connection options used to connect to the PowerSync service or null if `connect()` has not been called.
     */
    get connectionOptions(): Required<SyncOptions> | null;
    protected _schema: Schema;
    private _database;
    protected runExclusiveMutex: Mutex;
    /**
     * @experimental
     * Allows creating SQLite triggers which can be used to track various operations on SQLite tables.
     */
    readonly triggers: TriggerManager;
    protected triggersImpl: TriggerManagerImpl;
    logger: PowerSyncLogger;
    constructor(options: Options);
    /**
     * The default connection method to use on this platform.
     *
     * This defaults to `HTTP` on most SDKs. On React Native, it defaults to RSocket if a streaming HTTP client is
     * unavailable.
     */
    protected get defaultConnectionMethod(): SyncStreamConnectionMethod;
    get schema(): Schema<{
        [x: string]: import("@powersync/common").Table<any>;
    }>;
    /**
     * The underlying database.
     *
     * For the most part, behavior is the same whether querying on the underlying database, or on {@link AbstractPowerSyncDatabase}.
     */
    get database(): DBAdapter;
    /**
     * Whether a connection to the PowerSync service is currently open.
     */
    get connected(): boolean;
    get connecting(): boolean;
    /**
     * Opens the DBAdapter given open options using a default open factory
     */
    protected abstract openDBAdapter(): DBAdapter;
    /**
     * Generates a base configuration for {@link TriggerManagerImpl}.
     * Implementations should override this if necessary.
     */
    protected generateTriggerManagerConfig(): TriggerManagerConfig;
    protected abstract generateSyncStreamImplementation(connector: PowerSyncBackendConnector, options: CreateSyncImplementationOptions): StreamingSyncImplementation;
    protected abstract generateBucketStorageAdapter(): BucketStorageAdapter;
    waitForReady(): Promise<void>;
    waitForFirstSync(request?: AbortSignal | {
        signal?: AbortSignal;
        priority?: number;
    }): Promise<void>;
    waitForStatus(predicate: (status: SyncStatus) => any, signal?: AbortSignal): Promise<void>;
    /**
     * Allows for extended implementations to execute custom initialization
     * logic as part of the total init process
     */
    protected abstract _initialize(): Promise<void>;
    /**
     * Entry point for executing initialization logic.
     * This is to be automatically executed in the constructor.
     */
    protected initialize(): Promise<void>;
    protected loadVersion(): Promise<void>;
    protected resolveOfflineSyncStatus(): Promise<void>;
    updateSchema(schema: Schema): Promise<void>;
    init(): Promise<void>;
    /**
     * Locking mechanism for exclusively running critical portions of connect/disconnect operations.
     * Locking here is mostly only important on web for multiple tab scenarios.
     */
    protected runExclusive<T>(callback: () => Promise<T>): Promise<T>;
    connect(connector: PowerSyncBackendConnector, options?: SyncOptions): Promise<void>;
    disconnect(): Promise<void>;
    disconnectAndClear(options?: DisconnectAndClearOptions): Promise<void>;
    syncStream(name: string, params?: Record<string, any>): SyncStream;
    close(options?: PowerSyncCloseOptions): Promise<void>;
    getUploadQueueStats(includeSize?: boolean): Promise<UploadQueueStats>;
    getCrudBatch(limit?: number): Promise<CrudBatch | null>;
    getNextCrudTransaction(): Promise<CrudTransaction | null>;
    getCrudTransactions(): AsyncIterable<CrudTransaction, null>;
    getClientId(): Promise<string>;
    execute<T = SqliteRecord>(sql: string, parameters?: any[]): Promise<QueryResult<T>>;
    executeRaw(sql: string, parameters?: any[]): Promise<import("@powersync/common").RawQueryResult>;
    executeBatch(sql: string, parameters?: any[][]): Promise<QueryResult<never>>;
    getAll<T>(sql: string, parameters?: any[]): Promise<T[]>;
    getOptional<T>(sql: string, parameters?: any[]): Promise<T | null>;
    get<T>(sql: string, parameters?: any[]): Promise<T>;
    readLock<T>(callback: (db: LockContext) => Promise<T>): Promise<T>;
    writeLock<T>(callback: (db: LockContext) => Promise<T>): Promise<T>;
    readTransaction<T>(callback: (tx: Transaction) => Promise<T>, lockTimeout?: number): Promise<T>;
    writeTransaction<T>(callback: (tx: Transaction) => Promise<T>, lockTimeout?: number): Promise<T>;
    watch(sql: string, parameters?: any[], options?: SQLWatchOptions): AsyncIterable<QueryResult>;
    watch(sql: string, parameters?: any[], handler?: WatchHandler, options?: SQLWatchOptions): void;
    query<RowType>(query: ArrayQueryDefinition<RowType>): Query<RowType>;
    customQuery<RowType>(query: WatchCompatibleQuery<RowType[]>): Query<RowType>;
    watchWithCallback(sql: string, parameters?: any[], handler?: WatchHandler, options?: SQLWatchOptions): void;
    watchWithAsyncGenerator(sql: string, parameters?: any[], options?: SQLWatchOptions): AsyncIterable<QueryResult>;
    resolveTables(sql: string, parameters?: any[], options?: SQLWatchOptions): Promise<string[]>;
    onChange(options?: SQLOnChangeOptions): AsyncIterable<WatchOnChangeEvent>;
    onChange(handler?: WatchOnChangeHandler, options?: SQLOnChangeOptions): () => void;
    onChangeWithCallback(handler?: WatchOnChangeHandler, options?: SQLOnChangeOptions): () => void;
    onChangeWithAsyncGenerator(options?: SQLWatchOptions): AsyncIterable<WatchOnChangeEvent>;
    createMutex(): Mutex;
    private handleTableChanges;
    private processTableUpdates;
    private executeReadOnly;
}