import type { Column, GetColumnData } from './column.js';
import { entityKind } from './entity.js';
import type { OptionalKeyOnly, RequiredKeyOnly } from './operations.js';
import type { SQLWrapper } from './sql/sql.js';
import { TableName } from './table.utils.js';
import type { Simplify, Update } from './utils.js';
export interface TableConfig<TColumn extends Column = Column<any>> {
    name: string;
    schema: string | undefined;
    columns: Record<string, TColumn>;
    dialect: string;
}
export type UpdateTableConfig<T extends TableConfig, TUpdate extends Partial<TableConfig>> = Required<Update<T, TUpdate>>;
/** @internal */
export declare const Schema: unique symbol;
/** @internal */
export declare const Columns: unique symbol;
/** @internal */
export declare const ExtraConfigColumns: unique symbol;
/** @internal */
export declare const OriginalName: unique symbol;
/** @internal */
export declare const BaseName: unique symbol;
/** @internal */
export declare const IsAlias: unique symbol;
/** @internal */
export declare const ExtraConfigBuilder: unique symbol;
declare const IsDrizzleTable: unique symbol;
export interface Table<T extends TableConfig = TableConfig> extends SQLWrapper {
}
export declare class Table<T extends TableConfig = TableConfig> implements SQLWrapper {
    static readonly [entityKind]: string;
    readonly _: {
        readonly brand: 'Table';
        readonly config: T;
        readonly name: T['name'];
        readonly schema: T['schema'];
        readonly columns: T['columns'];
        readonly inferSelect: InferSelectModel<Table<T>>;
        readonly inferInsert: InferInsertModel<Table<T>>;
    };
    readonly $inferSelect: InferSelectModel<Table<T>>;
    readonly $inferInsert: InferInsertModel<Table<T>>;
    /** @internal */
    static readonly Symbol: {
        Name: typeof TableName;
        Schema: typeof Schema;
        OriginalName: typeof OriginalName;
        Columns: typeof Columns;
        ExtraConfigColumns: typeof ExtraConfigColumns;
        BaseName: typeof BaseName;
        IsAlias: typeof IsAlias;
        ExtraConfigBuilder: typeof ExtraConfigBuilder;
    };
    /**
     * @internal
     * Can be changed if the table is aliased.
     */
    [TableName]: string;
    /**
     * @internal
     * Used to store the original name of the table, before any aliasing.
     */
    [OriginalName]: string;
    /** @internal */
    [Schema]: string | undefined;
    /** @internal */
    [Columns]: T['columns'];
    /** @internal */
    [ExtraConfigColumns]: Record<string, unknown>;
    /**
     *  @internal
     * Used to store the table name before the transformation via the `tableCreator` functions.
     */
    [BaseName]: string;
    /** @internal */
    [IsAlias]: boolean;
    /** @internal */
    [IsDrizzleTable]: boolean;
    /** @internal */
    [ExtraConfigBuilder]: ((self: any) => Record<string, unknown> | unknown[]) | undefined;
    constructor(name: string, schema: string | undefined, baseName: string);
}
export declare function isTable(table: unknown): table is Table;
/**
 * Any table with a specified boundary.
 *
 * @example
    ```ts
    // Any table with a specific name
    type AnyUsersTable = AnyTable<{ name: 'users' }>;
    ```
 *
 * To describe any table with any config, simply use `Table` without any type arguments, like this:
 *
    ```ts
    function needsTable(table: Table) {
        ...
    }
    ```
 */
export type AnyTable<TPartial extends Partial<TableConfig>> = Table<UpdateTableConfig<TableConfig, TPartial>>;
export declare function getTableName<T extends Table>(table: T): T['_']['name'];
export declare function getTableUniqueName<T extends Table>(table: T): `${T['_']['schema']}.${T['_']['name']}`;
export type MapColumnName<TName extends string, TColumn extends Column, TDBColumNames extends boolean> = TDBColumNames extends true ? TColumn['_']['name'] : TName;
export type InferModelFromColumns<TColumns extends Record<string, Column>, TInferMode extends 'select' | 'insert' = 'select', TConfig extends {
    dbColumnNames: boolean;
    override?: boolean;
} = {
    dbColumnNames: false;
    override: false;
}> = Simplify<TInferMode extends 'insert' ? {
    [Key in keyof TColumns & string as RequiredKeyOnly<MapColumnName<Key, TColumns[Key], TConfig['dbColumnNames']>, TColumns[Key]>]: GetColumnData<TColumns[Key], 'query'>;
} & {
    [Key in keyof TColumns & string as OptionalKeyOnly<MapColumnName<Key, TColumns[Key], TConfig['dbColumnNames']>, TColumns[Key], TConfig['override']>]?: GetColumnData<TColumns[Key], 'query'> | undefined;
} : {
    [Key in keyof TColumns & string as MapColumnName<Key, TColumns[Key], TConfig['dbColumnNames']>]: GetColumnData<TColumns[Key], 'query'>;
}>;
/** @deprecated Use one of the alternatives: {@link InferSelectModel} / {@link InferInsertModel}, or `table.$inferSelect` / `table.$inferInsert`
 */
export type InferModel<TTable extends Table, TInferMode extends 'select' | 'insert' = 'select', TConfig extends {
    dbColumnNames: boolean;
} = {
    dbColumnNames: false;
}> = InferModelFromColumns<TTable['_']['columns'], TInferMode, TConfig>;
export type InferSelectModel<TTable extends Table, TConfig extends {
    dbColumnNames: boolean;
} = {
    dbColumnNames: false;
}> = InferModelFromColumns<TTable['_']['columns'], 'select', TConfig>;
export type InferInsertModel<TTable extends Table, TConfig extends {
    dbColumnNames: boolean;
    override?: boolean;
} = {
    dbColumnNames: false;
    override: false;
}> = InferModelFromColumns<TTable['_']['columns'], 'insert', TConfig>;
export type InferEnum<T> = T extends {
    enumValues: readonly (infer U)[];
} ? U : never;
export {};
//# sourceMappingURL=table.d.ts.map