import { S as Sql } from '../types-YTdPe6Qz.cjs';
import '@dotdo/postgres-shared/errors';

/**
 * Type-safe Query Builder Types
 *
 * Core types for building type-safe SQL queries with full TypeScript inference.
 * These types ensure that queries are validated at compile time.
 */
/**
 * Base column definition with type information
 */
interface ColumnDefinition<TName extends string = string, TType = unknown, TNotNull extends boolean = boolean, TDefault extends boolean = boolean> {
    readonly name: TName;
    readonly dataType: TType;
    readonly notNull: TNotNull;
    readonly hasDefault: TDefault;
    readonly _columnBrand: 'column';
}
/**
 * Table definition with typed columns
 */
interface TableDefinition<TName extends string = string, TColumns extends Record<string, ColumnDefinition> = Record<string, ColumnDefinition>> {
    readonly tableName: TName;
    readonly columns: TColumns;
    readonly _tableBrand: 'table';
}
/**
 * Infer the row type from a table definition
 */
type InferTableRow<T extends TableDefinition> = {
    [K in keyof T['columns']]: InferColumnType<T['columns'][K]>;
};
/**
 * Infer the TypeScript type from a column definition
 */
type InferColumnType<T extends ColumnDefinition> = T['notNull'] extends true ? T['dataType'] : T['dataType'] | null;
/**
 * Infer insert type (required fields only)
 */
type InferInsertRow<T extends TableDefinition> = {
    [K in keyof T['columns'] as RequiredInsertColumn<T['columns'][K]> extends true ? K : never]: T['columns'][K]['dataType'];
} & {
    [K in keyof T['columns'] as RequiredInsertColumn<T['columns'][K]> extends true ? never : K]?: T['columns'][K]['dataType'] | null;
};
type RequiredInsertColumn<T extends ColumnDefinition> = T['notNull'] extends true ? T['hasDefault'] extends true ? false : true : false;
/**
 * SQL expression with type information
 */
interface SQLExpression<TType = unknown> {
    readonly _type: TType;
    readonly _brand: 'sql_expression';
    toSQL(): {
        sql: string;
        params: unknown[];
    };
}
/**
 * Column reference expression
 */
interface ColumnRef<TTable extends string = string, TColumn extends string = string, TType = unknown> extends SQLExpression<TType> {
    readonly table: TTable;
    readonly column: TColumn;
    readonly _brand: 'sql_expression';
}
type ComparisonOperator = '=' | '!=' | '<' | '<=' | '>' | '>=' | 'LIKE' | 'ILIKE' | 'IN' | 'NOT IN' | 'IS NULL' | 'IS NOT NULL';
/**
 * Aggregate function expression
 */
interface AggregateExpr<TType = unknown> extends SQLExpression<TType> {
    readonly fn: 'COUNT' | 'SUM' | 'AVG' | 'MIN' | 'MAX';
    readonly column: SQLExpression | '*';
    readonly distinct?: boolean;
}
/**
 * Selection specification - what columns to select
 */
type SelectionSpec<T extends TableDefinition> = '*' | (keyof T['columns'])[] | Record<string, SQLExpression | keyof T['columns']>;
/**
 * Infer result type from selection spec
 */
type InferSelectResult<T extends TableDefinition, TSelection extends SelectionSpec<T>> = TSelection extends '*' ? InferTableRow<T> : TSelection extends (keyof T['columns'])[] ? Pick<InferTableRow<T>, TSelection[number]> : TSelection extends Record<string, SQLExpression | keyof T['columns']> ? {
    [K in keyof TSelection]: TSelection[K] extends SQLExpression<infer U> ? U : TSelection[K] extends keyof T['columns'] ? InferColumnType<T['columns'][TSelection[K]]> : never;
} : never;
/**
 * WHERE clause type - accepts boolean expressions
 */
type WhereClause<T extends TableDefinition> = SQLExpression<boolean> | ((columns: ColumnRefs<T>) => SQLExpression<boolean>);
/**
 * Column references for a table
 */
type ColumnRefs<T extends TableDefinition> = {
    [K in keyof T['columns']]: ColumnRef<T['tableName'], K & string, T['columns'][K]['dataType']>;
};
/**
 * ORDER BY specification
 */
type OrderBySpec<T extends TableDefinition> = keyof T['columns'] | {
    column: keyof T['columns'];
    direction: 'ASC' | 'DESC';
} | {
    column: keyof T['columns'];
    direction: 'ASC' | 'DESC';
    nulls?: 'FIRST' | 'LAST';
};
/**
 * Join types
 */
type JoinType = 'INNER' | 'LEFT' | 'RIGHT' | 'FULL';
/**
 * Join condition specification
 */
type JoinCondition<TLeft extends TableDefinition, TRight extends TableDefinition> = SQLExpression<boolean> | {
    left: keyof TLeft['columns'];
    right: keyof TRight['columns'];
};
/**
 * Result type for joined tables
 */
type JoinResult<TLeft extends TableDefinition, TRight extends TableDefinition, TJoinType extends JoinType> = TJoinType extends 'LEFT' ? InferTableRow<TLeft> & {
    [K in TRight['tableName']]: InferTableRow<TRight> | null;
} : TJoinType extends 'RIGHT' ? {
    [K in TLeft['tableName']]: InferTableRow<TLeft> | null;
} & InferTableRow<TRight> : TJoinType extends 'FULL' ? {
    [K in TLeft['tableName']]: InferTableRow<TLeft> | null;
} & {
    [K in TRight['tableName']]: InferTableRow<TRight> | null;
} : InferTableRow<TLeft> & InferTableRow<TRight>;
/**
 * Combined table reference after join
 */
interface JoinedTables<TLeft extends TableDefinition, TRight extends TableDefinition, TJoinType extends JoinType = 'INNER'> {
    left: TLeft;
    right: TRight;
    joinType: TJoinType;
    condition: SQLExpression<boolean>;
}
/**
 * Insert values - single or array of rows
 */
type InsertValues<T extends TableDefinition> = InferInsertRow<T> | InferInsertRow<T>[];
/**
 * On conflict action
 */
type OnConflictAction<T extends TableDefinition> = 'DO NOTHING' | {
    doUpdate: Partial<InferInsertRow<T>>;
} | {
    doUpdate: (row: InferTableRow<T>) => Partial<InferInsertRow<T>>;
};
/**
 * Conflict target columns
 */
type ConflictTarget<T extends TableDefinition> = (keyof T['columns'])[] | {
    constraint: string;
};
/**
 * Update set values
 */
type UpdateSet<T extends TableDefinition> = Partial<{
    [K in keyof T['columns']]: T['columns'][K]['dataType'] | SQLExpression<T['columns'][K]['dataType']>;
}>;
/**
 * Base query builder interface
 */
interface QueryBuilder<TResult = unknown> {
    /**
     * Get the generated SQL and parameters
     */
    toSQL(): {
        sql: string;
        params: unknown[];
    };
    /**
     * Execute the query and return results
     */
    execute(): Promise<TResult>;
}
/**
 * SELECT query builder interface
 */
interface SelectQueryBuilder<T extends TableDefinition, TSelection extends SelectionSpec<T> = '*', TResult = InferSelectResult<T, TSelection>[]> extends QueryBuilder<TResult> {
    /**
     * Select specific columns or expressions
     */
    select<TNewSelection extends SelectionSpec<T>>(selection: TNewSelection): SelectQueryBuilder<T, TNewSelection, InferSelectResult<T, TNewSelection>[]>;
    /**
     * Add WHERE clause
     */
    where(condition: WhereClause<T>): SelectQueryBuilder<T, TSelection, TResult>;
    /**
     * Add AND condition to WHERE clause
     */
    andWhere(condition: WhereClause<T>): SelectQueryBuilder<T, TSelection, TResult>;
    /**
     * Add OR condition to WHERE clause
     */
    orWhere(condition: WhereClause<T>): SelectQueryBuilder<T, TSelection, TResult>;
    /**
     * Add ORDER BY clause
     */
    orderBy(...specs: OrderBySpec<T>[]): SelectQueryBuilder<T, TSelection, TResult>;
    /**
     * Add LIMIT clause
     */
    limit(count: number): SelectQueryBuilder<T, TSelection, TResult>;
    /**
     * Add OFFSET clause
     */
    offset(count: number): SelectQueryBuilder<T, TSelection, TResult>;
    /**
     * Add GROUP BY clause
     */
    groupBy(...columns: (keyof T['columns'])[]): SelectQueryBuilder<T, TSelection, TResult>;
    /**
     * Add HAVING clause
     */
    having(condition: SQLExpression<boolean>): SelectQueryBuilder<T, TSelection, TResult>;
    /**
     * Add DISTINCT
     */
    distinct(): SelectQueryBuilder<T, TSelection, TResult>;
    /**
     * Execute and return first result or null
     */
    first(): Promise<TResult extends (infer U)[] ? U | null : TResult | null>;
    /**
     * Execute and return first result or throw
     */
    firstOrThrow(): Promise<TResult extends (infer U)[] ? U : TResult>;
}
/**
 * JOIN query builder interface
 */
interface JoinQueryBuilder<TLeft extends TableDefinition, TRight extends TableDefinition, TJoinType extends JoinType, TResult = JoinResult<TLeft, TRight, TJoinType>[]> extends QueryBuilder<TResult> {
    /**
     * Add WHERE clause
     */
    where(condition: SQLExpression<boolean>): JoinQueryBuilder<TLeft, TRight, TJoinType, TResult>;
    /**
     * Add ORDER BY clause
     */
    orderBy(column: string, direction?: 'ASC' | 'DESC'): JoinQueryBuilder<TLeft, TRight, TJoinType, TResult>;
    /**
     * Add LIMIT clause
     */
    limit(count: number): JoinQueryBuilder<TLeft, TRight, TJoinType, TResult>;
    /**
     * Select specific columns from joined tables
     */
    select<TSelection extends Record<string, SQLExpression>>(selection: TSelection): JoinQueryBuilder<TLeft, TRight, TJoinType, {
        [K in keyof TSelection]: TSelection[K] extends SQLExpression<infer U> ? U : never;
    }[]>;
}
/**
 * INSERT query builder interface
 */
interface InsertQueryBuilder<T extends TableDefinition, TResult = {
    rowCount: number;
}> extends QueryBuilder<TResult> {
    /**
     * Add RETURNING clause
     */
    returning(): InsertQueryBuilder<T, InferTableRow<T>[]>;
    /**
     * Add RETURNING clause with specific columns
     */
    returning<TColumns extends (keyof T['columns'])[]>(...columns: TColumns): InsertQueryBuilder<T, Pick<InferTableRow<T>, TColumns[number]>[]>;
    /**
     * Add ON CONFLICT clause
     */
    onConflict(target: ConflictTarget<T>, action: OnConflictAction<T>): InsertQueryBuilder<T, TResult>;
}
/**
 * UPDATE query builder interface
 */
interface UpdateQueryBuilder<T extends TableDefinition, TResult = {
    rowCount: number;
}> extends QueryBuilder<TResult> {
    /**
     * Add WHERE clause
     */
    where(condition: WhereClause<T>): UpdateQueryBuilder<T, TResult>;
    /**
     * Add RETURNING clause
     */
    returning(): UpdateQueryBuilder<T, InferTableRow<T>[]>;
    /**
     * Add RETURNING clause with specific columns
     */
    returning<TColumns extends (keyof T['columns'])[]>(...columns: TColumns): UpdateQueryBuilder<T, Pick<InferTableRow<T>, TColumns[number]>[]>;
}
/**
 * DELETE query builder interface
 */
interface DeleteQueryBuilder<T extends TableDefinition, TResult = {
    rowCount: number;
}> extends QueryBuilder<TResult> {
    /**
     * Add WHERE clause
     */
    where(condition: WhereClause<T>): DeleteQueryBuilder<T, TResult>;
    /**
     * Add RETURNING clause
     */
    returning(): DeleteQueryBuilder<T, InferTableRow<T>[]>;
    /**
     * Add RETURNING clause with specific columns
     */
    returning<TColumns extends (keyof T['columns'])[]>(...columns: TColumns): DeleteQueryBuilder<T, Pick<InferTableRow<T>, TColumns[number]>[]>;
}
/**
 * Main query builder factory interface
 */
interface QueryBuilderFactory {
    /**
     * Start a SELECT query
     */
    select<T extends TableDefinition>(): {
        from(table: T): SelectQueryBuilder<T, '*'>;
    };
    /**
     * Start a SELECT query with specific columns
     */
    select<T extends TableDefinition, TSelection extends SelectionSpec<T>>(selection: TSelection): {
        from(table: T): SelectQueryBuilder<T, TSelection>;
    };
    /**
     * Start an INSERT query
     */
    insert<T extends TableDefinition>(table: T): {
        values(values: InsertValues<T>): InsertQueryBuilder<T>;
    };
    /**
     * Start an UPDATE query
     */
    update<T extends TableDefinition>(table: T): {
        set(values: UpdateSet<T>): UpdateQueryBuilder<T>;
    };
    /**
     * Start a DELETE query
     */
    delete<T extends TableDefinition>(table: T): DeleteQueryBuilder<T>;
    /**
     * Create a JOIN
     */
    join<TLeft extends TableDefinition, TRight extends TableDefinition>(left: TLeft, right: TRight, condition: JoinCondition<TLeft, TRight>): JoinQueryBuilder<TLeft, TRight, 'INNER'>;
    /**
     * Create a LEFT JOIN
     */
    leftJoin<TLeft extends TableDefinition, TRight extends TableDefinition>(left: TLeft, right: TRight, condition: JoinCondition<TLeft, TRight>): JoinQueryBuilder<TLeft, TRight, 'LEFT'>;
    /**
     * Create a RIGHT JOIN
     */
    rightJoin<TLeft extends TableDefinition, TRight extends TableDefinition>(left: TLeft, right: TRight, condition: JoinCondition<TLeft, TRight>): JoinQueryBuilder<TLeft, TRight, 'RIGHT'>;
    /**
     * Create a FULL OUTER JOIN
     */
    fullJoin<TLeft extends TableDefinition, TRight extends TableDefinition>(left: TLeft, right: TRight, condition: JoinCondition<TLeft, TRight>): JoinQueryBuilder<TLeft, TRight, 'FULL'>;
}

/**
 * Type-safe Query Builder Implementation
 *
 * Full implementation of the query builder with type-safe SQL generation.
 */

declare class InsertQueryBuilderImpl<T extends TableDefinition, TResult = {
    rowCount: number;
}> implements InsertQueryBuilder<T, TResult> {
    private client;
    private table;
    private values;
    private _returning?;
    private _onConflict?;
    constructor(client: Sql, table: T, values: InsertValues<T>);
    returning(): InsertQueryBuilder<T, InferTableRow<T>[]>;
    returning<TColumns extends (keyof T['columns'])[]>(...columns: TColumns): InsertQueryBuilder<T, Pick<InferTableRow<T>, TColumns[number]>[]>;
    onConflict(target: ConflictTarget<T>, action: OnConflictAction<T>): InsertQueryBuilder<T, TResult>;
    toSQL(): {
        sql: string;
        params: unknown[];
    };
    execute(): Promise<TResult>;
}
declare class UpdateQueryBuilderImpl<T extends TableDefinition, TResult = {
    rowCount: number;
}> implements UpdateQueryBuilder<T, TResult> {
    private client;
    private table;
    private setValues;
    private _where?;
    private _returning?;
    constructor(client: Sql, table: T, setValues: UpdateSet<T>);
    where(condition: WhereClause<T>): UpdateQueryBuilder<T, TResult>;
    returning(): UpdateQueryBuilder<T, InferTableRow<T>[]>;
    returning<TColumns extends (keyof T['columns'])[]>(...columns: TColumns): UpdateQueryBuilder<T, Pick<InferTableRow<T>, TColumns[number]>[]>;
    toSQL(): {
        sql: string;
        params: unknown[];
    };
    execute(): Promise<TResult>;
}
/**
 * Create a query builder factory from a postgres.do client
 */
declare function createQueryBuilder(client: Sql): {
    /**
     * Start a SELECT query
     */
    select<T extends TableDefinition, TSelection extends SelectionSpec<T> = "*">(selection?: TSelection): {
        from(table: T): SelectQueryBuilder<T, TSelection extends undefined ? "*" : TSelection>;
    };
    /**
     * Start an INSERT query
     */
    insert<T extends TableDefinition>(table: T): {
        values(values: InsertValues<T>): InsertQueryBuilderImpl<T, {
            rowCount: number;
        }>;
    };
    /**
     * Start an UPDATE query
     */
    update<T extends TableDefinition>(table: T): {
        set(values: UpdateSet<T>): UpdateQueryBuilderImpl<T, {
            rowCount: number;
        }>;
    };
    /**
     * Start a DELETE query
     */
    delete<T extends TableDefinition>(table: T): DeleteQueryBuilder<T>;
    /**
     * Create an INNER JOIN
     */
    join<TLeft extends TableDefinition, TRight extends TableDefinition>(left: TLeft, right: TRight, condition: JoinCondition<TLeft, TRight>): JoinQueryBuilder<TLeft, TRight, "INNER">;
    /**
     * Create a LEFT JOIN
     */
    leftJoin<TLeft extends TableDefinition, TRight extends TableDefinition>(left: TLeft, right: TRight, condition: JoinCondition<TLeft, TRight>): JoinQueryBuilder<TLeft, TRight, "LEFT">;
    /**
     * Create a RIGHT JOIN
     */
    rightJoin<TLeft extends TableDefinition, TRight extends TableDefinition>(left: TLeft, right: TRight, condition: JoinCondition<TLeft, TRight>): JoinQueryBuilder<TLeft, TRight, "RIGHT">;
    /**
     * Create a FULL OUTER JOIN
     */
    fullJoin<TLeft extends TableDefinition, TRight extends TableDefinition>(left: TLeft, right: TRight, condition: JoinCondition<TLeft, TRight>): JoinQueryBuilder<TLeft, TRight, "FULL">;
};

/**
 * Type-safe SQL Expression Builders
 *
 * Provides builder functions for creating type-safe SQL expressions.
 * All comparisons are validated at compile time.
 */

/**
 * Create an equality comparison (=)
 */
declare function eq<TType>(left: SQLExpression<TType>, right: TType | SQLExpression<TType>): SQLExpression<boolean>;
/**
 * Create an inequality comparison (!=)
 */
declare function ne<TType>(left: SQLExpression<TType>, right: TType | SQLExpression<TType>): SQLExpression<boolean>;
/**
 * Create a less than comparison (<)
 */
declare function lt<TType>(left: SQLExpression<TType>, right: TType | SQLExpression<TType>): SQLExpression<boolean>;
/**
 * Create a less than or equal comparison (<=)
 */
declare function lte<TType>(left: SQLExpression<TType>, right: TType | SQLExpression<TType>): SQLExpression<boolean>;
/**
 * Create a greater than comparison (>)
 */
declare function gt<TType>(left: SQLExpression<TType>, right: TType | SQLExpression<TType>): SQLExpression<boolean>;
/**
 * Create a greater than or equal comparison (>=)
 */
declare function gte<TType>(left: SQLExpression<TType>, right: TType | SQLExpression<TType>): SQLExpression<boolean>;
/**
 * Create a LIKE comparison
 */
declare function like(column: SQLExpression<string>, pattern: string): SQLExpression<boolean>;
/**
 * Create a case-insensitive LIKE comparison (ILIKE)
 */
declare function ilike(column: SQLExpression<string>, pattern: string): SQLExpression<boolean>;
/**
 * Create an IN comparison
 */
declare function inArray<TType>(column: SQLExpression<TType>, values: TType[]): SQLExpression<boolean>;
/**
 * Create a NOT IN comparison
 */
declare function notInArray<TType>(column: SQLExpression<TType>, values: TType[]): SQLExpression<boolean>;
/**
 * Create an IS NULL comparison
 */
declare function isNull<TType>(column: SQLExpression<TType | null>): SQLExpression<boolean>;
/**
 * Create an IS NOT NULL comparison
 */
declare function isNotNull<TType>(column: SQLExpression<TType | null>): SQLExpression<boolean>;
/**
 * Create a BETWEEN comparison
 */
declare function between<TType>(column: SQLExpression<TType>, min: TType, max: TType): SQLExpression<boolean>;
/**
 * Create a NOT BETWEEN comparison
 */
declare function notBetween<TType>(column: SQLExpression<TType>, min: TType, max: TType): SQLExpression<boolean>;
/**
 * Create an AND expression
 */
declare function and(...expressions: SQLExpression<boolean>[]): SQLExpression<boolean>;
/**
 * Create an OR expression
 */
declare function or(...expressions: SQLExpression<boolean>[]): SQLExpression<boolean>;
/**
 * Create a NOT expression
 */
declare function not(expression: SQLExpression<boolean>): SQLExpression<boolean>;
/**
 * Create a COUNT aggregate
 */
declare function count(): AggregateExpr<number>;
declare function count<TType>(column: SQLExpression<TType>): AggregateExpr<number>;
/**
 * Create a COUNT DISTINCT aggregate
 */
declare function countDistinct<TType>(column: SQLExpression<TType>): AggregateExpr<number>;
/**
 * Create a SUM aggregate
 */
declare function sum(column: SQLExpression<number>): AggregateExpr<number>;
/**
 * Create an AVG aggregate
 */
declare function avg(column: SQLExpression<number>): AggregateExpr<number>;
/**
 * Create a MIN aggregate
 */
declare function min<TType>(column: SQLExpression<TType>): AggregateExpr<TType>;
/**
 * Create a MAX aggregate
 */
declare function max<TType>(column: SQLExpression<TType>): AggregateExpr<TType>;
/**
 * Create a CONCAT expression
 */
declare function concat(...values: (SQLExpression<string> | string)[]): SQLExpression<string>;
/**
 * Create a LOWER expression
 */
declare function lower(value: SQLExpression<string>): SQLExpression<string>;
/**
 * Create an UPPER expression
 */
declare function upper(value: SQLExpression<string>): SQLExpression<string>;
/**
 * Create a TRIM expression
 */
declare function trim(value: SQLExpression<string>): SQLExpression<string>;
/**
 * Create a COALESCE expression
 */
declare function coalesce<TType>(...values: (SQLExpression<TType | null> | TType)[]): SQLExpression<TType>;
/**
 * Create a column reference
 */
declare function col<TTable extends string, TColumn extends string, TType = unknown>(table: TTable, column: TColumn): ColumnRef<TTable, TColumn, TType>;
/**
 * Create column references for a table definition
 */
declare function columnsOf<T extends TableDefinition>(table: T): ColumnRefs<T>;
/**
 * Create a raw SQL expression (use with caution!)
 */
declare function raw<TType = unknown>(sql: string, params?: unknown[]): SQLExpression<TType>;
/**
 * Create a literal value expression
 */
declare function literal<TType>(value: TType): SQLExpression<TType>;
/**
 * Create a SQL expression from a template literal
 */
declare function sql<TType = unknown>(strings: TemplateStringsArray, ...values: unknown[]): SQLExpression<TType>;

/**
 * Type-safe Schema Definition
 *
 * Provides helpers for defining schemas that work with the query builder.
 * Also includes adapters for Drizzle ORM schemas.
 */

/**
 * Column builder for type-safe column definitions
 */
declare class ColumnBuilder<TName extends string, TType, TNotNull extends boolean = false, TDefault extends boolean = false> {
    private _type;
    private _name;
    private _notNull;
    private _hasDefault;
    constructor(name: TName, _type: TType);
    /**
     * Mark column as NOT NULL
     */
    notNull(): ColumnBuilder<TName, TType, true, TDefault>;
    /**
     * Mark column as having a default value
     */
    default<TValue extends TType>(_value: TValue): ColumnBuilder<TName, TType, TNotNull, true>;
    /**
     * Mark as primary key (implies NOT NULL)
     */
    primaryKey(): ColumnBuilder<TName, TType, true, TDefault>;
    /**
     * Build the column definition
     */
    build(): ColumnDefinition<TName, TType, TNotNull, TDefault>;
}
/**
 * Create a serial (auto-incrementing integer) column
 */
declare function serial<TName extends string>(name: TName): ColumnBuilder<TName, number, true, true>;
/**
 * Create a bigserial (auto-incrementing bigint) column
 */
declare function bigserial<TName extends string>(name: TName): ColumnBuilder<TName, bigint, true, true>;
/**
 * Create an integer column
 */
declare function integer<TName extends string>(name: TName): ColumnBuilder<TName, number, false, false>;
/**
 * Create a bigint column
 */
declare function bigint<TName extends string>(name: TName): ColumnBuilder<TName, bigint, false, false>;
/**
 * Create a text column
 */
declare function text<TName extends string>(name: TName): ColumnBuilder<TName, string, false, false>;
/**
 * Create a varchar column
 */
declare function varchar<TName extends string>(name: TName, _length?: number): ColumnBuilder<TName, string, false, false>;
/**
 * Create a boolean column
 */
declare function boolean<TName extends string>(name: TName): ColumnBuilder<TName, boolean, false, false>;
/**
 * Create a timestamp column
 */
declare function timestamp<TName extends string>(name: TName): ColumnBuilder<TName, Date, false, false>;
/**
 * Create a timestamp with timezone column
 */
declare function timestamptz<TName extends string>(name: TName): ColumnBuilder<TName, Date, false, false>;
/**
 * Create a date column
 */
declare function date<TName extends string>(name: TName): ColumnBuilder<TName, string | Date, false, false>;
/**
 * Create a time column
 */
declare function time<TName extends string>(name: TName): ColumnBuilder<TName, string, false, false>;
/**
 * Create a UUID column
 */
declare function uuid<TName extends string>(name: TName): ColumnBuilder<TName, string, false, false>;
/**
 * Create a JSON column
 */
declare function json<TName extends string, TData = unknown>(name: TName): ColumnBuilder<TName, TData, false, false>;
/**
 * Create a JSONB column
 */
declare function jsonb<TName extends string, TData = unknown>(name: TName): ColumnBuilder<TName, TData, false, false>;
/**
 * Create a numeric/decimal column
 */
declare function numeric<TName extends string>(name: TName, _precision?: number, _scale?: number): ColumnBuilder<TName, number, false, false>;
/**
 * Create a real (float4) column
 */
declare function real<TName extends string>(name: TName): ColumnBuilder<TName, number, false, false>;
/**
 * Create a double precision (float8) column
 */
declare function doublePrecision<TName extends string>(name: TName): ColumnBuilder<TName, number, false, false>;
type ColumnBuilderMap = Record<string, ColumnBuilder<string, unknown, boolean, boolean>>;
type ExtractColumnDefs<T extends ColumnBuilderMap> = {
    [K in keyof T]: T[K] extends ColumnBuilder<infer TName, infer TType, infer TNotNull, infer TDefault> ? ColumnDefinition<TName & string, TType, TNotNull, TDefault> : never;
};
/**
 * Define a table with type-safe columns
 */
declare function defineTable<TName extends string, TColumns extends ColumnBuilderMap>(name: TName, columns: TColumns): TableDefinition<TName, ExtractColumnDefs<TColumns>>;
/**
 * Options for converting Drizzle schema to query builder format
 */
interface DrizzleAdapterOptions {
    /**
     * Transform column names (e.g., from snake_case to camelCase)
     */
    transformColumnNames?: (name: string) => string;
}
/**
 * Convert a Drizzle table to a query builder TableDefinition
 *
 * This enables using Drizzle schemas with the standalone query builder.
 *
 * @example
 * ```typescript
 * import { users } from './drizzle-schema'
 * import { fromDrizzleTable, createQueryBuilder } from 'postgres.do/query-builder'
 *
 * const usersTable = fromDrizzleTable(users)
 * const qb = createQueryBuilder(sql)
 *
 * // Type-safe queries using Drizzle schema
 * const results = await qb.select().from(usersTable).execute()
 * ```
 */
declare function fromDrizzleTable<TDrizzleTable extends object>(drizzleTable: TDrizzleTable, options?: DrizzleAdapterOptions): TableDefinition;
/**
 * Infer the select result type for a table
 */
type SelectResult<T extends TableDefinition> = InferTableRow<T>;
/**
 * Infer the insert type for a table
 */
type InsertType<T extends TableDefinition> = InferInsertRow<T>;
/**
 * Get column keys for a table
 */
type ColumnKeys<T extends TableDefinition> = keyof T['columns'];

export { type AggregateExpr, type ColumnDefinition, type ColumnKeys, type ColumnRef, type ColumnRefs, type ComparisonOperator, type ConflictTarget, type DeleteQueryBuilder, type DrizzleAdapterOptions, type InferColumnType, type InferInsertRow, type InferSelectResult, type InferTableRow, type InsertQueryBuilder, type InsertType, type InsertValues, type JoinCondition, type JoinQueryBuilder, type JoinResult, type JoinType, type JoinedTables, type OnConflictAction, type OrderBySpec, type QueryBuilder, type QueryBuilderFactory, type SQLExpression, type SelectQueryBuilder, type SelectResult, type SelectionSpec, type TableDefinition, type UpdateQueryBuilder, type UpdateSet, type WhereClause, and, avg, between, bigint, bigserial, boolean, coalesce, col, columnsOf, concat, count, countDistinct, createQueryBuilder, date, defineTable, doublePrecision, eq, fromDrizzleTable, gt, gte, ilike, inArray, integer, isNotNull, isNull, json, jsonb, like, literal, lower, lt, lte, max, min, ne, not, notBetween, notInArray, numeric, or, raw, real, serial, sql, sum, text, time, timestamp, timestamptz, trim, upper, uuid, varchar };