type ResultCollection = "last_statement_all_rows" | "last_statement_first_row" | "last_statement_all_rows_scalar" | "last_statement_first_row_scalar" | "all_statements_all_rows" | "all_statements_first_row" | "all_statements_all_rows_scalar" | "all_statements_first_row_scalar" | "legacy";
type FetchParams<ResultCollectionT extends ResultCollection> = {
    resultCollection?: ResultCollectionT;
};
type SqlResult<T, ResultCollectionT extends ResultCollection> = ResultCollectionT extends "last_statement_first_row" ? T | null : ResultCollectionT extends "all_statements_first_row" ? T[] : ResultCollectionT extends "last_statement_all_rows" ? T[] : ResultCollectionT extends "all_statements_all_rows" ? T[][] : ResultCollectionT extends "last_statement_all_rows_scalar" ? T[keyof T][] : ResultCollectionT extends "all_statements_all_rows_scalar" ? T[keyof T][][] : ResultCollectionT extends "last_statement_first_row_scalar" ? T[keyof T] | null : ResultCollectionT extends "all_statements_first_row_scalar" ? T[keyof T][] : unknown;
/**
 * SQL statement object with query content, arguments, and execution methods
 */
export type SqlStatement<T> = {
    /** Raw SQL content with formatted arguments */
    content: string;
    /** Argument values keyed by parameter name */
    args: Record<string, any>;
    /**
     * Execute the SQL query and return results
     * @param params - Optional parameters including result collection mode
     * @returns Query results based on the result collection mode
     */
    fetch<ResultCollectionT extends ResultCollection = "last_statement_all_rows">(params?: FetchParams<ResultCollectionT | ResultCollection>): Promise<SqlResult<T, ResultCollectionT>>;
    /**
     * Execute the SQL query and return only the first row
     * @param params - Optional parameters
     * @returns First row of the query result
     */
    fetchOne(params?: Omit<FetchParams<"last_statement_first_row">, "resultCollection">): Promise<SqlResult<T, "last_statement_first_row">>;
    /**
     * Execute the SQL query and return only the first row as a scalar value
     * @param params - Optional parameters
     * @returns First row of the query result
     */
    fetchOneScalar(params?: Omit<FetchParams<"last_statement_first_row_scalar">, "resultCollection">): Promise<SqlResult<T, "last_statement_first_row_scalar">>;
    /**
     * Execute the SQL query without fetching rows
     * @param params - Optional parameters
     */
    execute(params?: Omit<FetchParams<"last_statement_first_row">, "resultCollection">): Promise<void>;
};
/**
 * Wrapper for raw SQL fragments that should be inlined without parameterization.
 * Created via `sql.raw(value)`.
 */
export declare class RawSql {
    readonly value: string;
    readonly __brand: "RawSql";
    constructor(value: string);
}
/**
 * Template tag function for creating SQL statements with parameterized values
 */
export interface SqlTemplateFunction {
    <T = any>(strings: TemplateStringsArray, ...values: any[]): SqlStatement<T>;
    /** Create a raw SQL fragment that will be inlined without parameterization */
    raw(value: string): RawSql;
}
export interface DatatableSqlTemplateFunction extends SqlTemplateFunction {
    query<T = any>(sql: string, ...params: any[]): SqlStatement<T>;
}
export interface DatatableOptions {
    /** The data table role to connect as. Omit to get the data table's default role. */
    role?: string;
}
/**
 * Create a SQL template function for PostgreSQL/datatable queries
 * @param name - Database/datatable name (default: "main")
 * @param opts.role - Connect as this data table role instead of the data table's default one.
 *   Only meaningful on a data table under roles, and only for a role you are a tenant of.
 * @returns SQL template function for building parameterized queries
 * @example
 * let sql = wmill.datatable()
 * let name = 'Robin'
 * let age = 21
 * await sql`
 *   SELECT * FROM friends
 *     WHERE name = ${name} AND age = ${age}::int
 * `.fetch()
 * @example
 * // Read through a restricted role
 * let sql = wmill.datatable("main", { role: "analytics" })
 */
export declare function datatable(name?: string, opts?: DatatableOptions): DatatableSqlTemplateFunction;
/**
 * Create a SQL template function for DuckDB/ducklake queries
 * @param name - DuckDB database name, optionally with a schema as `name:schema` (default: "main")
 * @returns SQL template function for building parameterized queries
 * @example
 * let sql = wmill.ducklake()
 * let name = 'Robin'
 * let age = 21
 * await sql`
 *   SELECT * FROM friends
 *     WHERE name = ${name} AND age = ${age}
 * `.fetch()
 * @example
 * // Target a specific schema within the ducklake
 * let sql = wmill.ducklake("my_lake:analytics")
 */
export declare function ducklake(name?: string): SqlTemplateFunction;
/** Options for the ducklake materialization helpers. `partition` is bound as a
 * DuckDB arg (never interpolated); `selectSql`, `table`, `schema`, `uniqueKey`
 * are trusted structural SQL inlined via `raw`. */
export interface DucklakeMaterializeOptions {
    /** ducklake name (default "main"), optionally "name:schema". */
    ducklake?: string;
    /** target table within the ducklake. */
    table: string;
    /** the SELECT producing the rows for this slice. */
    selectSql: string;
    /** the partition value (bound). Omit for a whole-table materialization — no
     * partition column, and replace becomes a `CREATE OR REPLACE TABLE`. */
    partition?: string;
    /** dedup key → upsert in slice (delete-by-key + insert); omit → replace (delete partition + insert). */
    uniqueKey?: string;
    /** physical partition column (default "_wm_partition"). */
    partitionCol?: string;
}
/** Idempotently materialize `selectSql` into a ducklake table for one
 * partition (or the whole table when `partition` is omitted) — the client-side
 * equivalent of the `// materialize` engine.
 * With `uniqueKey` it upserts the slice (delete-by-key + insert); otherwise it
 * replaces it (whole table → `CREATE OR REPLACE`; partition → delete + insert).
 * Safe to re-run for the same partition (backfill / failure-recovery).
 *
 * Returns a lazy statement — call `.execute()` to run it:
 * `await wmill.upsertPartition({ table, selectSql, partition }).execute()`. */
export declare function upsertPartition(opts: DucklakeMaterializeOptions): SqlStatement<any>;
/** INSERT-only materialization (no dedup/replace) for append-only tables.
 * Re-running the same partition duplicates rows — use only for immutable
 * event-log sources.
 *
 * Returns a lazy statement — call `.execute()` to run it:
 * `await wmill.appendPartition({ table, selectSql, partition }).execute()`. */
export declare function appendPartition(opts: Omit<DucklakeMaterializeOptions, "uniqueKey">): SqlStatement<any>;
export {};