import { type Column, type JsonColumn, type RequiredColumn } from './Column.js';
import type { ForeignKeyConstraint, PrimaryKeyConstraint, UniqueConstraint } from './Constraint.js';
import { Index } from './Index.js';
import { type HasSelection, type HasSql, type HasTable } from './Internal.js';
import { type Sql } from './Sql.js';
import { Field } from './expr/Field.js';
import type { Input } from './expr/Input.js';
import { type JsonExpr } from './expr/Json.js';
export type TableDefinition = {
    [name: string]: Column;
};
declare class TableData {
    name: string;
    alias?: string;
    schemaName?: string;
    columns: TableDefinition;
    config?: TableConfig;
}
export declare class TableApi<Definition extends TableDefinition = TableDefinition, Name extends string = string> extends TableData {
    private brand;
    get aliased(): string;
    identifier(altName?: string): Sql;
    target(): Sql;
    columnDefinition(name: string): Sql;
    createDefinition(): Sql;
    listColumns(): Sql;
    fields(): Record<string, HasSql>;
    createTable(altName?: string, ifNotExists?: boolean): Sql;
    createIndexes(): Array<Sql>;
    create(): Array<Sql>;
    drop(): Sql;
    indexes(): Record<string, Index>;
}
export type Table<Definition extends TableDefinition = Record<never, Column>, Name extends string = string> = TableFields<Definition, Name> & HasTable<Definition, Name> & HasSelection;
export type TableFields<Definition extends TableDefinition, TableName extends string = string> = {
    [K in keyof Definition]: Definition[K] extends JsonColumn<infer T> ? JsonExpr<T> : Definition[K] extends Column<infer T> ? Field<T, TableName> : never;
};
export type TableRow<Definition extends TableDefinition> = {
    [K in keyof Definition]: Definition[K] extends Column<infer T> ? T : never;
} & {};
type IsReq<Col> = Col extends RequiredColumn<infer Value> ? null extends Value ? true : false : false;
type RequiredInput<D> = {
    readonly [K in keyof D as true extends IsReq<D[K]> ? K : never]: D[K] extends Column<infer V> ? Input<V> : never;
};
type OptionalInput<D> = {
    readonly [K in keyof D as false extends IsReq<D[K]> ? K : never]?: D[K] extends Column<infer V> ? Input<V> : never;
};
export type TableInsert<Definition extends TableDefinition> = RequiredInput<Definition> & OptionalInput<Definition>;
export type TableUpdate<Definition extends TableDefinition> = {
    readonly [K in keyof Definition]?: Definition[K] extends Column<infer T> ? Input<T> : never;
};
export type TableConfigSetting<Name extends string> = UniqueConstraint<Name> | PrimaryKeyConstraint<Name> | ForeignKeyConstraint<Name> | Index<Name>;
export interface TableConfig<Name extends string = string> extends Record<string, TableConfigSetting<Name>> {
}
export declare function table<Definition extends TableDefinition, Name extends string>(name: Name, columns: Definition, config?: (self: Table<Definition, Name>) => TableConfig<Name>, schemaName?: string): Table<Definition, Name>;
export declare function alias<Definition extends TableDefinition, Alias extends string>(table: Table<Definition>, alias: Alias): Table<Definition, Alias>;
export declare function tableCreator(nameTable: (name: string) => string): typeof table;
export type InsertRow<T> = T extends Table<infer Definition> ? TableInsert<Definition> : never;
export type SelectRow<T> = T extends Table<infer Definition> ? TableRow<Definition> : never;
export type UpdateRow<T> = T extends Table<infer Definition> ? TableUpdate<Definition> : never;
export {};