import type { LockContext, QueryResult } from '@powersync/common';
import type { Cache } from 'drizzle-orm/cache/core';
import type { WithCacheConfig } from 'drizzle-orm/cache/core/types';
import { entityKind } from 'drizzle-orm/entity';
import type { Logger } from 'drizzle-orm/logger';
import { type Query } from 'drizzle-orm/sql/sql';
import type { SelectedFieldsOrdered } from 'drizzle-orm/sqlite-core/query-builders/select.types';
import { SQLitePreparedQuery, type PreparedQueryConfig as PreparedQueryConfigBase, type SQLiteExecuteMethod } from 'drizzle-orm/sqlite-core/session';
type PreparedQueryConfig = Omit<PreparedQueryConfigBase, 'statement' | 'run'>;
/**
 * Callback which uses a LockContext for database operations.
 */
export type LockCallback<T> = (ctx: LockContext) => Promise<T>;
/**
 * Provider for specific database contexts.
 * Handlers are provided a context to the provided callback.
 * This does not necessarily need to acquire a database lock for each call.
 * Calls might use the same lock context for multiple operations.
 * The read/write context may relate to a single read OR write context.
 */
export type ContextProvider = {
    useReadContext: <T>(fn: LockCallback<T>) => Promise<T>;
    useWriteContext: <T>(fn: LockCallback<T>) => Promise<T>;
};
export declare class PowerSyncSQLitePreparedQuery<T extends PreparedQueryConfig = PreparedQueryConfig> extends SQLitePreparedQuery<{
    type: 'async';
    run: QueryResult;
    all: T['all'];
    get: T['get'];
    values: T['values'];
    execute: T['execute'];
}> {
    private contextProvider;
    private logger;
    private fields;
    private _isResponseInArrayMode;
    private customResultMapper?;
    static readonly [entityKind]: string;
    private readOnly;
    constructor(contextProvider: ContextProvider, query: Query, logger: Logger, fields: SelectedFieldsOrdered | undefined, executeMethod: SQLiteExecuteMethod, _isResponseInArrayMode: boolean, customResultMapper?: ((rows: unknown[][]) => unknown) | undefined, cache?: Cache | undefined, queryMetadata?: {
        type: 'select' | 'update' | 'delete' | 'insert';
        tables: string[];
    } | undefined, cacheConfig?: WithCacheConfig | undefined);
    run(placeholderValues?: Record<string, unknown>): Promise<QueryResult>;
    all(placeholderValues?: Record<string, unknown>): Promise<T['all']>;
    get(placeholderValues?: Record<string, unknown>): Promise<T['get']>;
    values(placeholderValues?: Record<string, unknown>): Promise<T['values']>;
    isResponseInArrayMode(): boolean;
    protected useContext<T>(callback: LockCallback<T>): Promise<T>;
}
/**
 * Maps a flat array of database row values to a result object based on the provided column definitions.
 * It reconstructs the hierarchical structure of the result by following the specified paths for each field.
 * It also handles nullification of nested objects when joined tables are nullable.
 */
export declare function mapResultRow<TResult>(columns: SelectedFieldsOrdered, row: unknown[], joinsNotNullableMap: Record<string, boolean> | undefined): TResult;
export {};