import type { DriverSpecs } from './Driver.js';
import { type HasSql, internalData, internalSql } from './Internal.js';
import { type Sql } from './Sql.js';
import type { Field, FieldData } from './expr/Field.js';
import { type Input } from './expr/Input.js';
export interface BaseColumnData {
    type: HasSql;
    name?: string;
    json?: boolean;
    primary?: boolean;
    notNull?: boolean;
    isUnique?: boolean;
    autoIncrement?: boolean;
    defaultValue?: Sql;
    references?(): FieldData;
    mapFromDriverValue?(value: unknown, specs: DriverSpecs): unknown;
    mapToDriverValue?(value: unknown): unknown;
    $default?(): Sql;
    $onUpdate?(): Sql;
}
export interface ColumnData extends BaseColumnData {
    type: ColumnType;
}
export declare class ColumnType implements HasSql {
    kind: string;
    args: Array<Input<unknown>>;
    [internalSql]: Sql;
    constructor(kind: string, args: Array<Input<unknown>>, sql?: Sql);
}
type WithoutNull<Value> = Exclude<Value, null>;
export declare class Column<Value = unknown> {
    readonly [internalData]: ColumnData;
    constructor(data: ColumnData);
    notNull(): RequiredColumn<Value>;
    $defaultFn(value: () => Input<WithoutNull<Value>>): Column<WithoutNull<Value>>;
    $default(value: Input<WithoutNull<Value>> | (() => Input<WithoutNull<Value>>)): Column<WithoutNull<Value>>;
    $onUpdateFn(fn: () => Input<Value>): Column<Value>;
    $onUpdate(fn: () => Input<Value>): Column<Value>;
    default(value: Input<WithoutNull<Value>>): Column<WithoutNull<Value>>;
    defaultNow(): Column<WithoutNull<Value>>;
    primaryKey(options?: {
        autoIncrement: boolean;
    }): Column<WithoutNull<Value>>;
    unique(name?: string): Column<Value>;
    references(foreignField: Field | (() => Field)): Column<Value>;
    $type<T>(): Column<null extends Value ? T | null : T>;
}
export declare class JsonColumn<Value = unknown> extends Column<Value> {
    private brand;
    constructor(data: ColumnData);
}
declare const required: unique symbol;
export interface RequiredColumn<Value = unknown> extends Column<WithoutNull<Value>> {
    [required]: true;
}
export interface Columns {
    <T>(data: ColumnData): Column<T>;
    [key: string]: (...args: Array<Input<any>>) => ColumnType;
}
export declare const column: Columns;
export type ColumnArguments<Options> = [name?: string] | [options: Options] | [name: string, options: Options];
export declare function columnConfig<Options>(args: ColumnArguments<Options>): {
    name: string | undefined;
    options: Options | undefined;
};
export declare function formatColumn(column: BaseColumnData): Sql;
export {};