drizzle-orm 0.27.3-e080bed → 0.28.0-5dd9190

package/pg-core/index.d.ts

@@ -1,50 +1,41 @@
-import { P as PgColumnBuilder, a as PgColumn, A as AnyPgTable, B as BuildAliasTable, b as PgTableFn, p as pgView, c as pgMaterializedView, d as AnyPgColumn, I as Index, F as ForeignKey, C as Check, e as PrimaryKey, U as UniqueConstraint, f as PgView, V as ViewWithConfig, g as PgMaterializedView, h as PgMaterializedViewWithConfig } from '../db.d-9d586c00.js';
-export { y as AnyForeignKeyBuilder, G as AnyIndexBuilder, r as AnyPgColumnBuilder, s as AnyPgColumnHKT, a6 as AnyPgSelect, ay as AnyPgTableHKT, i as CheckBuilder, aC as DefaultViewBuilderCore, x as ForeignKeyBuilder, J as GetColumnsTableName, H as IndexBuilder, E as IndexBuilderOn, D as IndexColumn, a5 as Join, a8 as JoinFn, ad as LockConfig, ac as LockStrength, aH as ManualMaterializedViewBuilder, aE as ManualViewBuilder, aG as MaterializedViewBuilder, aF as MaterializedViewBuilderCore, n as PgArray, m as PgArrayBuilder, k as PgArrayBuilderHKT, l as PgArrayHKT, o as PgColumnBuilderHKT, q as PgColumnHKT, t as PgDatabase, X as PgDelete, W as PgDeleteConfig, u as PgDialect, $ as PgInsert, _ as PgInsertBuilder, Y as PgInsertConfig, Z as PgInsertValue, aL as PgMaterializedViewConfig, aM as PgMaterializedViewWithSelection, a1 as PgRefreshMaterializedView, a4 as PgSelect, a2 as PgSelectBuilder, a7 as PgSelectConfig, ah as PgSelectHKT, ae as PgSelectHKTBase, af as PgSelectKind, a3 as PgSelectQueryBuilder, ag as PgSelectQueryBuilderHKT, ap as PgSession, ax as PgTable, av as PgTableExtraConfig, az as PgTableWithColumns, aq as PgTransaction, ao as PgTransactionConfig, al as PgUpdate, ak as PgUpdateBuilder, ai as PgUpdateConfig, aj as PgUpdateSetSource, aI as PgViewBase, aJ as PgViewConfig, aK as PgViewWithSelection, an as PreparedQuery, am as PreparedQueryConfig, N as PrimaryKeyBuilder, a0 as QueryBuilder, ar as QueryResultHKT, as as QueryResultKind, w as Reference, R as ReferenceConfig, aa as SelectedFields, a9 as SelectedFieldsFlat, ab as SelectedFieldsOrdered, at as SubqueryWithSelection, aw as TableConfig, S as UniqueConstraintBuilder, T as UniqueOnConstraintBuilder, v as UpdateDeleteAction, aD as ViewBuilder, au as WithSubqueryWithSelection, j as check, z as foreignKey, K as index, aA as pgTable, aB as pgTableCreator, M as primaryKey, O as unique, L as uniqueIndex, Q as uniqueKeyName } from '../db.d-9d586c00.js';
-import { o as ColumnBuilderHKTBase, aD as Assume, l as ColumnBuilderBaseConfig, c as ColumnHKTBase, C as ColumnBaseConfig, e as entityKind, W as WithEnum, aK as Writable, S as Simplify, aE as Equal, a as SQL, p as ColumnBuilderKind, X as SelectedFields, A as AnyColumn, T as Table, ap as TableConfig } from '../column.d-9d74a4f3.js';
+import { P as PgViewBase, B as BuildAliasTable, p as pgView, a as pgMaterializedView, b as PgView, V as ViewWithConfig, c as PgMaterializedView, d as PgMaterializedViewWithConfig } from '../select.types.d-d0a10728.js';
+export { A as AnyPgSelect, T as DefaultViewBuilderCore, J as Join, s as JoinFn, v as LockConfig, L as LockStrength, _ as ManualMaterializedViewBuilder, X as ManualViewBuilder, Z as MaterializedViewBuilder, Y as MaterializedViewBuilderCore, e as PgDatabase, h as PgDelete, g as PgDeleteConfig, f as PgDialect, l as PgInsert, k as PgInsertBuilder, i as PgInsertConfig, j as PgInsertValue, a1 as PgMaterializedViewConfig, a2 as PgMaterializedViewWithSelection, m as PgRefreshMaterializedView, q as PgSelect, n as PgSelectBuilder, r as PgSelectConfig, z as PgSelectHKT, w as PgSelectHKTBase, x as PgSelectKind, o as PgSelectQueryBuilder, y as PgSelectQueryBuilderHKT, K as PgSession, M as PgTransaction, I as PgTransactionConfig, F as PgUpdate, E as PgUpdateBuilder, C as PgUpdateConfig, D as PgUpdateSetSource, $ as PgViewConfig, a0 as PgViewWithSelection, H as PreparedQuery, G as PreparedQueryConfig, Q as QueryBuilder, N as QueryResultHKT, O as QueryResultKind, t as SelectedFields, S as SelectedFieldsFlat, u as SelectedFieldsOrdered, R as SubqueryWithSelection, U as ViewBuilder, W as WithSubqueryWithSelection } from '../select.types.d-d0a10728.js';
+import { i as ColumnBuilderBaseConfig, bq as PgColumnBuilder, e as entityKind, C as ColumnBaseConfig, bo as PgColumn, N as NotNull, H as HasDefault, aC as Writable, bm as AnyPgTable, aw as Equal, a as SQL, g as ColumnDataType, c3 as PgTableFn, c4 as Index, c5 as ForeignKey, c6 as Check, c7 as PrimaryKey, c8 as UniqueConstraint, E as SelectedFields, A as AnyColumn, T as Table, ak as TableConfig, d as Column, bn as AnyPgColumn } from '../column.d-9d2f4045.js';
+export { ch as AnyForeignKeyBuilder, ck as AnyIndexBuilder, br as AnyPgColumnBuilder, c9 as CheckBuilder, cg as ForeignKeyBuilder, cm as GetColumnsTableName, cl as IndexBuilder, cj as IndexBuilderOn, bp as IndexColumn, cc as PgArray, cb as PgArrayBuilder, bs as PgTable, cv as PgTableExtraConfig, bt as PgTableWithColumns, cq as PrimaryKeyBuilder, cf as Reference, cd as ReferenceConfig, cw as TableConfig, ct as UniqueConstraintBuilder, cu as UniqueOnConstraintBuilder, ce as UpdateDeleteAction, ca as check, ci as foreignKey, cn as index, cx as pgTable, cy as pgTableCreator, cp as primaryKey, cr as unique, co as uniqueIndex, cs as uniqueKeyName } from '../column.d-9d2f4045.js';
+import '../select.types.d-a3c4c974.js';
+import '../query-promise.d-bc96befc.js';
 import '../migrator.js';
-import '../query-promise.d-fd15f63a.js';
-import '../select.types.d-1ea8ee3b.js';
 
-interface PgBigInt53BuilderHKT extends ColumnBuilderHKTBase {
-    _type: PgBigInt53Builder<Assume<this['config'], ColumnBuilderBaseConfig>>;
-    _columnHKT: PgBigInt53HKT;
-}
-interface PgBigInt53HKT extends ColumnHKTBase {
-    _type: PgBigInt53<Assume<this['config'], ColumnBaseConfig>>;
-}
 type PgBigInt53BuilderInitial<TName extends string> = PgBigInt53Builder<{
     name: TName;
+    dataType: 'number';
+    columnType: 'PgBigInt53';
     data: number;
     driverParam: number | string;
-    notNull: false;
-    hasDefault: false;
+    enumValues: undefined;
 }>;
-declare class PgBigInt53Builder<T extends ColumnBuilderBaseConfig> extends PgColumnBuilder<PgBigInt53BuilderHKT, T> {
+declare class PgBigInt53Builder<T extends ColumnBuilderBaseConfig<'number', 'PgBigInt53'>> extends PgColumnBuilder<T> {
     static readonly [entityKind]: string;
+    constructor(name: T['name']);
 }
-declare class PgBigInt53<T extends ColumnBaseConfig> extends PgColumn<PgBigInt53HKT, T> {
+declare class PgBigInt53<T extends ColumnBaseConfig<'number', 'PgBigInt53'>> extends PgColumn<T> {
     static readonly [entityKind]: string;
     getSQLType(): string;
     mapFromDriverValue(value: number | string): number;
 }
-interface PgBigInt64BuilderHKT extends ColumnBuilderHKTBase {
-    _type: PgBigInt64Builder<Assume<this['config'], ColumnBuilderBaseConfig>>;
-    _columnHKT: PgBigInt64HKT;
-}
-interface PgBigInt64HKT extends ColumnHKTBase {
-    _type: PgBigInt64<Assume<this['config'], ColumnBaseConfig>>;
-}
 type PgBigInt64BuilderInitial<TName extends string> = PgBigInt64Builder<{
     name: TName;
+    dataType: 'bigint';
+    columnType: 'PgBigInt64';
     data: bigint;
     driverParam: string;
-    notNull: false;
-    hasDefault: false;
+    enumValues: undefined;
 }>;
-declare class PgBigInt64Builder<T extends ColumnBuilderBaseConfig> extends PgColumnBuilder<PgBigInt64BuilderHKT, T> {
+declare class PgBigInt64Builder<T extends ColumnBuilderBaseConfig<'bigint', 'PgBigInt64'>> extends PgColumnBuilder<T> {
     static readonly [entityKind]: string;
+    constructor(name: T['name']);
 }
-declare class PgBigInt64<T extends ColumnBaseConfig> extends PgColumn<PgBigInt64HKT, T> {
+declare class PgBigInt64<T extends ColumnBaseConfig<'bigint', 'PgBigInt64'>> extends PgColumn<T> {
     static readonly [entityKind]: string;
     getSQLType(): string;
     mapFromDriverValue(value: string): bigint;
@@ -54,48 +45,36 @@ interface PgBigIntConfig<T extends 'number' | 'bigint' = 'number' | 'bigint'> {
 }
 declare function bigint<TName extends string, TMode extends PgBigIntConfig['mode']>(name: TName, config: PgBigIntConfig<TMode>): TMode extends 'number' ? PgBigInt53BuilderInitial<TName> : PgBigInt64BuilderInitial<TName>;
 
-interface PgBigSerial53BuilderHKT extends ColumnBuilderHKTBase {
-    _type: PgBigSerial53Builder<Assume<this['config'], ColumnBuilderBaseConfig>>;
-    _columnHKT: PgBigSerial53HKT;
-}
-interface PgBigSerial53HKT extends ColumnHKTBase {
-    _type: PgBigSerial53<Assume<this['config'], ColumnBaseConfig>>;
-}
-type PgBigSerial53BuilderInitial<TName extends string> = PgBigSerial53Builder<{
+type PgBigSerial53BuilderInitial<TName extends string> = NotNull<HasDefault<PgBigSerial53Builder<{
     name: TName;
+    dataType: 'number';
+    columnType: 'PgBigSerial53';
     data: number;
     driverParam: number;
-    notNull: true;
-    hasDefault: true;
-}>;
-declare class PgBigSerial53Builder<T extends ColumnBuilderBaseConfig> extends PgColumnBuilder<PgBigSerial53BuilderHKT, T> {
+    enumValues: undefined;
+}>>>;
+declare class PgBigSerial53Builder<T extends ColumnBuilderBaseConfig<'number', 'PgBigSerial53'>> extends PgColumnBuilder<T> {
     static readonly [entityKind]: string;
     constructor(name: string);
 }
-declare class PgBigSerial53<T extends ColumnBaseConfig> extends PgColumn<PgBigSerial53HKT, T> {
+declare class PgBigSerial53<T extends ColumnBaseConfig<'number', 'PgBigSerial53'>> extends PgColumn<T> {
     static readonly [entityKind]: string;
     getSQLType(): string;
     mapFromDriverValue(value: number): number;
 }
-interface PgBigSerial64BuilderHKT extends ColumnBuilderHKTBase {
-    _type: PgBigSerial64Builder<Assume<this['config'], ColumnBuilderBaseConfig>>;
-    _columnHKT: PgBigSerial64HKT;
-}
-interface PgBigSerial64HKT extends ColumnHKTBase {
-    _type: PgBigSerial64<Assume<this['config'], ColumnBaseConfig>>;
-}
-type PgBigSerial64BuilderInitial<TName extends string> = PgBigSerial64Builder<{
+type PgBigSerial64BuilderInitial<TName extends string> = NotNull<HasDefault<PgBigSerial64Builder<{
     name: TName;
+    dataType: 'bigint';
+    columnType: 'PgBigSerial64';
     data: bigint;
     driverParam: string;
-    notNull: true;
-    hasDefault: true;
-}>;
-declare class PgBigSerial64Builder<T extends ColumnBuilderBaseConfig> extends PgColumnBuilder<PgBigSerial64BuilderHKT, T> {
+    enumValues: undefined;
+}>>>;
+declare class PgBigSerial64Builder<T extends ColumnBuilderBaseConfig<'bigint', 'PgBigSerial64'>> extends PgColumnBuilder<T> {
     static readonly [entityKind]: string;
     constructor(name: string);
 }
-declare class PgBigSerial64<T extends ColumnBaseConfig> extends PgColumn<PgBigSerial64HKT, T> {
+declare class PgBigSerial64<T extends ColumnBaseConfig<'bigint', 'PgBigSerial64'>> extends PgColumn<T> {
     static readonly [entityKind]: string;
     getSQLType(): string;
     mapFromDriverValue(value: string): bigint;
@@ -105,105 +84,88 @@ interface PgBigSerialConfig<T extends 'number' | 'bigint' = 'number' | 'bigint'>
 }
 declare function bigserial<TName extends string, TMode extends PgBigSerialConfig['mode']>(name: TName, config: PgBigSerialConfig<TMode>): TMode extends 'number' ? PgBigSerial53BuilderInitial<TName> : PgBigSerial64BuilderInitial<TName>;
 
-interface PgBooleanBuilderHKT extends ColumnBuilderHKTBase {
-    _type: PgBooleanBuilder<Assume<this['config'], ColumnBuilderBaseConfig>>;
-    _columnHKT: PgBooleanHKT;
-}
-interface PgBooleanHKT extends ColumnHKTBase {
-    _type: PgBoolean<Assume<this['config'], ColumnBaseConfig>>;
-}
 type PgBooleanBuilderInitial<TName extends string> = PgBooleanBuilder<{
     name: TName;
+    dataType: 'boolean';
+    columnType: 'PgBoolean';
     data: boolean;
     driverParam: boolean;
-    notNull: false;
-    hasDefault: false;
+    enumValues: undefined;
 }>;
-declare class PgBooleanBuilder<T extends ColumnBuilderBaseConfig> extends PgColumnBuilder<PgBooleanBuilderHKT, T> {
+declare class PgBooleanBuilder<T extends ColumnBuilderBaseConfig<'boolean', 'PgBoolean'>> extends PgColumnBuilder<T> {
     static readonly [entityKind]: string;
+    constructor(name: T['name']);
 }
-declare class PgBoolean<T extends ColumnBaseConfig> extends PgColumn<PgBooleanHKT, T> {
+declare class PgBoolean<T extends ColumnBaseConfig<'boolean', 'PgBoolean'>> extends PgColumn<T> {
     static readonly [entityKind]: string;
     getSQLType(): string;
 }
 declare function boolean<TName extends string>(name: TName): PgBooleanBuilderInitial<TName>;
 
-interface PgCharBuilderHKT extends ColumnBuilderHKTBase {
-    _type: PgCharBuilder<Assume<this['config'], ColumnBuilderBaseConfig & WithEnum>>;
-    _columnHKT: PgCharHKT;
-}
-interface PgCharHKT extends ColumnHKTBase {
-    _type: PgChar<Assume<this['config'], ColumnBaseConfig & WithEnum>>;
-}
 type PgCharBuilderInitial<TName extends string, TEnum extends [string, ...string[]]> = PgCharBuilder<{
     name: TName;
+    dataType: 'string';
+    columnType: 'PgChar';
     data: TEnum[number];
     enumValues: TEnum;
     driverParam: string;
-    notNull: false;
-    hasDefault: false;
 }>;
-declare class PgCharBuilder<T extends ColumnBuilderBaseConfig & WithEnum> extends PgColumnBuilder<PgCharBuilderHKT, T, {
+declare class PgCharBuilder<T extends ColumnBuilderBaseConfig<'string', 'PgChar'>> extends PgColumnBuilder<T, {
     length: number | undefined;
-} & WithEnum<T['enumValues']>> {
+    enumValues: T['enumValues'];
+}> {
     static readonly [entityKind]: string;
     constructor(name: string, config: PgCharConfig<T['enumValues']>);
 }
-declare class PgChar<T extends ColumnBaseConfig & WithEnum> extends PgColumn<PgCharHKT, T, {
+declare class PgChar<T extends ColumnBaseConfig<'string', 'PgChar'>> extends PgColumn<T, {
     length: number | undefined;
-} & WithEnum<T['enumValues']>> {
+    enumValues: T['enumValues'];
+}> {
     static readonly [entityKind]: string;
     readonly length: number | undefined;
     readonly enumValues: T["enumValues"];
     getSQLType(): string;
 }
-interface PgCharConfig<TEnum extends readonly string[] | string[]> {
+interface PgCharConfig<TEnum extends readonly string[] | string[] | undefined> {
     length?: number;
     enum?: TEnum;
 }
 declare function char<TName extends string, U extends string, T extends Readonly<[U, ...U[]]>>(name: TName, config?: PgCharConfig<T | Writable<T>>): PgCharBuilderInitial<TName, Writable<T>>;
 
-interface PgCidrBuilderHKT extends ColumnBuilderHKTBase {
-    _type: PgCidrBuilder<Assume<this['config'], ColumnBuilderBaseConfig>>;
-    _columnHKT: PgCidrHKT;
-}
-interface PgCidrHKT extends ColumnHKTBase {
-    _type: PgCidr<Assume<this['config'], ColumnBaseConfig>>;
-}
 type PgCidrBuilderInitial<TName extends string> = PgCidrBuilder<{
     name: TName;
+    dataType: 'string';
+    columnType: 'PgCidr';
     data: string;
     driverParam: string;
-    notNull: false;
-    hasDefault: false;
+    enumValues: undefined;
 }>;
-declare class PgCidrBuilder<T extends ColumnBuilderBaseConfig> extends PgColumnBuilder<PgCidrBuilderHKT, T> {
+declare class PgCidrBuilder<T extends ColumnBuilderBaseConfig<'string', 'PgCidr'>> extends PgColumnBuilder<T> {
     static readonly [entityKind]: string;
+    constructor(name: T['name']);
 }
-declare class PgCidr<T extends ColumnBaseConfig> extends PgColumn<PgCidrHKT, T> {
+declare class PgCidr<T extends ColumnBaseConfig<'string', 'PgCidr'>> extends PgColumn<T> {
     static readonly [entityKind]: string;
     getSQLType(): string;
 }
 declare function cidr<TName extends string>(name: TName): PgCidrBuilderInitial<TName>;
 
-type ConvertCustomConfig<TName extends string, T extends Partial<CustomTypeValues>> = Simplify<{
+type ConvertCustomConfig<TName extends string, T extends Partial<CustomTypeValues>> = {
     name: TName;
+    dataType: 'custom';
+    columnType: 'PgCustomColumn';
     data: T['data'];
     driverParam: T['driverData'];
-    notNull: T['notNull'] extends true ? true : false;
-    hasDefault: T['default'] extends true ? true : false;
-}>;
+    enumValues: undefined;
+} & (T['notNull'] extends true ? {
+    notNull: true;
+} : {}) & (T['default'] extends true ? {
+    hasDefault: true;
+} : {});
 interface PgCustomColumnInnerConfig {
     customTypeValues: CustomTypeValues;
 }
-interface PgCustomColumnBuilderHKT extends ColumnBuilderHKTBase {
-    _type: PgCustomColumnBuilder<Assume<this['config'], ColumnBuilderBaseConfig>>;
-    _columnHKT: PgCustomColumnHKT;
-}
-interface PgCustomColumnHKT extends ColumnHKTBase {
-    _type: PgCustomColumn<Assume<this['config'], ColumnBaseConfig>>;
-}
-declare class PgCustomColumnBuilder<T extends ColumnBuilderBaseConfig> extends PgColumnBuilder<PgCustomColumnBuilderHKT, T, {
+declare class PgCustomColumnBuilder<T extends ColumnBuilderBaseConfig<'custom', 'PgCustomColumn'>> extends PgColumnBuilder<T, {
     fieldConfig: CustomTypeValues['config'];
     customTypeParams: CustomTypeParams<any>;
 }, {
@@ -212,9 +174,8 @@ declare class PgCustomColumnBuilder<T extends ColumnBuilderBaseConfig> extends P
     static readonly [entityKind]: string;
     constructor(name: T['name'], fieldConfig: CustomTypeValues['config'], customTypeParams: CustomTypeParams<any>);
 }
-declare class PgCustomColumn<T extends ColumnBaseConfig> extends PgColumn<PgCustomColumnHKT, T> {
+declare class PgCustomColumn<T extends ColumnBaseConfig<'custom', 'PgCustomColumn'>> extends PgColumn<T> {
     static readonly [entityKind]: string;
-    protected $pgColumnBrand: 'PgCustomColumn';
     private sqlName;
     private mapTo?;
     private mapFrom?;
@@ -331,56 +292,42 @@ interface CustomTypeParams<T extends CustomTypeValues> {
  */
 declare function customType<T extends CustomTypeValues = CustomTypeValues>(customTypeParams: CustomTypeParams<T>): Equal<T['configRequired'], true> extends true ? <TName extends string>(dbName: TName, fieldConfig: T['config']) => PgCustomColumnBuilder<ConvertCustomConfig<TName, T>> : <TName extends string>(dbName: TName, fieldConfig?: T['config']) => PgCustomColumnBuilder<ConvertCustomConfig<TName, T>>;
 
-declare abstract class PgDateColumnBaseBuilder<THKT extends ColumnBuilderHKTBase, T extends ColumnBuilderBaseConfig, TRuntimeConfig extends object = {}> extends PgColumnBuilder<THKT, T, TRuntimeConfig> {
+declare abstract class PgDateColumnBaseBuilder<T extends ColumnBuilderBaseConfig<ColumnDataType, string>, TRuntimeConfig extends object = object> extends PgColumnBuilder<T, TRuntimeConfig> {
     static readonly [entityKind]: string;
-    defaultNow(): ColumnBuilderKind<THKT, Omit<T, "hasDefault"> & {
-        hasDefault: true;
-    } extends infer T_1 ? { [K in keyof T_1]: (Omit<T, "hasDefault"> & {
-        hasDefault: true;
-    })[K]; } : never>;
+    defaultNow(): HasDefault<this>;
 }
 
-interface PgDateBuilderHKT extends ColumnBuilderHKTBase {
-    _type: PgDateBuilder<Assume<this['config'], ColumnBuilderBaseConfig>>;
-    _columnHKT: PgDateHKT;
-}
-interface PgDateHKT extends ColumnHKTBase {
-    _type: PgDate<Assume<this['config'], ColumnBaseConfig>>;
-}
 type PgDateBuilderInitial<TName extends string> = PgDateBuilder<{
     name: TName;
+    dataType: 'date';
+    columnType: 'PgDate';
     data: Date;
     driverParam: string;
-    notNull: false;
-    hasDefault: false;
+    enumValues: undefined;
 }>;
-declare class PgDateBuilder<T extends ColumnBuilderBaseConfig> extends PgDateColumnBaseBuilder<PgDateBuilderHKT, T> {
+declare class PgDateBuilder<T extends ColumnBuilderBaseConfig<'date', 'PgDate'>> extends PgDateColumnBaseBuilder<T> {
     static readonly [entityKind]: string;
+    constructor(name: T['name']);
 }
-declare class PgDate<T extends ColumnBaseConfig> extends PgColumn<PgDateHKT, T> {
+declare class PgDate<T extends ColumnBaseConfig<'date', 'PgDate'>> extends PgColumn<T> {
     static readonly [entityKind]: string;
     getSQLType(): string;
     mapFromDriverValue(value: string): Date;
     mapToDriverValue(value: Date): string;
 }
-interface PgDateStringBuilderHKT extends ColumnBuilderHKTBase {
-    _type: PgDateStringBuilder<Assume<this['config'], ColumnBuilderBaseConfig>>;
-    _columnHKT: PgDateStringHKT;
-}
-interface PgDateStringHKT extends ColumnHKTBase {
-    _type: PgDateString<Assume<this['config'], ColumnBaseConfig>>;
-}
 type PgDateStringBuilderInitial<TName extends string> = PgDateStringBuilder<{
     name: TName;
+    dataType: 'string';
+    columnType: 'PgDateString';
     data: string;
     driverParam: string;
-    notNull: false;
-    hasDefault: false;
+    enumValues: undefined;
 }>;
-declare class PgDateStringBuilder<T extends ColumnBuilderBaseConfig> extends PgDateColumnBaseBuilder<PgDateStringBuilderHKT, T> {
+declare class PgDateStringBuilder<T extends ColumnBuilderBaseConfig<'string', 'PgDateString'>> extends PgDateColumnBaseBuilder<T> {
     static readonly [entityKind]: string;
+    constructor(name: T['name']);
 }
-declare class PgDateString<T extends ColumnBaseConfig> extends PgColumn<PgDateStringHKT, T> {
+declare class PgDateString<T extends ColumnBaseConfig<'string', 'PgDateString'>> extends PgColumn<T> {
     static readonly [entityKind]: string;
     getSQLType(): string;
 }
@@ -391,60 +338,52 @@ declare function date<TName extends string>(TName: TName, config?: {
     mode: 'date';
 }): PgDateBuilderInitial<TName>;
 
-interface PgDoublePrecisionBuilderHKT extends ColumnBuilderHKTBase {
-    _type: PgDoublePrecisionBuilder<Assume<this['config'], ColumnBuilderBaseConfig>>;
-    _columnHKT: PgDoublePrecisionHKT;
-}
-interface PgDoublePrecisionHKT extends ColumnHKTBase {
-    _type: PgDoublePrecision<Assume<this['config'], ColumnBaseConfig>>;
-}
 type PgDoublePrecisionBuilderInitial<TName extends string> = PgDoublePrecisionBuilder<{
     name: TName;
+    dataType: 'number';
+    columnType: 'PgDoublePrecision';
     data: number;
     driverParam: string | number;
-    notNull: false;
-    hasDefault: false;
+    enumValues: undefined;
 }>;
-declare class PgDoublePrecisionBuilder<T extends ColumnBuilderBaseConfig> extends PgColumnBuilder<PgDoublePrecisionBuilderHKT, T> {
+declare class PgDoublePrecisionBuilder<T extends ColumnBuilderBaseConfig<'number', 'PgDoublePrecision'>> extends PgColumnBuilder<T> {
     static readonly [entityKind]: string;
+    constructor(name: T['name']);
 }
-declare class PgDoublePrecision<T extends ColumnBaseConfig> extends PgColumn<PgDoublePrecisionHKT, T> {
+declare class PgDoublePrecision<T extends ColumnBaseConfig<'number', 'PgDoublePrecision'>> extends PgColumn<T> {
     static readonly [entityKind]: string;
     getSQLType(): string;
     mapFromDriverValue(value: string | number): number;
 }
 declare function doublePrecision<TName extends string>(name: TName): PgDoublePrecisionBuilderInitial<TName>;
 
-interface PgEnumColumnBuilderHKT extends ColumnBuilderHKTBase {
-    _type: PgEnumColumnBuilder<Assume<this['config'], ColumnBuilderBaseConfig & WithEnum>>;
-    _columnHKT: PgEnumColumnHKT;
-}
-interface PgEnumColumnHKT extends ColumnHKTBase {
-    _type: PgEnumColumn<Assume<this['config'], ColumnBaseConfig & WithEnum>>;
-}
 type PgEnumColumnBuilderInitial<TName extends string, TValues extends [string, ...string[]]> = PgEnumColumnBuilder<{
     name: TName;
+    dataType: 'string';
+    columnType: 'PgEnumColumn';
     data: TValues[number];
     enumValues: TValues;
     driverParam: string;
-    notNull: false;
-    hasDefault: false;
 }>;
-interface PgEnum<TValues extends [string, ...string[]]> extends WithEnum<TValues> {
+interface PgEnum<TValues extends [string, ...string[]]> {
     <TName extends string>(name: TName): PgEnumColumnBuilderInitial<TName, TValues>;
     readonly enumName: string;
     readonly enumValues: TValues;
 }
 declare function isPgEnum(obj: unknown): obj is PgEnum<[string, ...string[]]>;
-declare class PgEnumColumnBuilder<T extends ColumnBuilderBaseConfig & WithEnum> extends PgColumnBuilder<PgEnumColumnBuilderHKT, T, {
+declare class PgEnumColumnBuilder<T extends ColumnBuilderBaseConfig<'string', 'PgEnumColumn'> & {
+    enumValues: [string, ...string[]];
+}> extends PgColumnBuilder<T, {
     enum: PgEnum<T['enumValues']>;
 }> {
     static readonly [entityKind]: string;
     constructor(name: string, enumInstance: PgEnum<T['enumValues']>);
 }
-declare class PgEnumColumn<T extends ColumnBaseConfig & WithEnum> extends PgColumn<PgEnumColumnHKT, T, {
+declare class PgEnumColumn<T extends ColumnBaseConfig<'string', 'PgEnumColumn'> & {
+    enumValues: [string, ...string[]];
+}> extends PgColumn<T, {
     enum: PgEnum<T['enumValues']>;
-}> implements WithEnum<T['enumValues']> {
+}> {
     static readonly [entityKind]: string;
     readonly enum: PgEnum<T["enumValues"]>;
     readonly enumValues: T["enumValues"];
@@ -455,75 +394,59 @@ declare class PgEnumColumn<T extends ColumnBaseConfig & WithEnum> extends PgColu
 }
 declare function pgEnum<U extends string, T extends Readonly<[U, ...U[]]>>(enumName: string, values: T | Writable<T>): PgEnum<Writable<T>>;
 
-interface PgInetBuilderHKT extends ColumnBuilderHKTBase {
-    _type: PgInetBuilder<Assume<this['config'], ColumnBuilderBaseConfig>>;
-    _columnHKT: PgInetHKT;
-}
-interface PgInetHKT extends ColumnHKTBase {
-    _type: PgInet<Assume<this['config'], ColumnBaseConfig>>;
-}
 type PgInetBuilderInitial<TName extends string> = PgInetBuilder<{
     name: TName;
+    dataType: 'string';
+    columnType: 'PgInet';
     data: string;
     driverParam: string;
-    notNull: false;
-    hasDefault: false;
+    enumValues: undefined;
 }>;
-declare class PgInetBuilder<T extends ColumnBuilderBaseConfig> extends PgColumnBuilder<PgInetBuilderHKT, T> {
+declare class PgInetBuilder<T extends ColumnBuilderBaseConfig<'string', 'PgInet'>> extends PgColumnBuilder<T> {
     static readonly [entityKind]: string;
+    constructor(name: T['name']);
 }
-declare class PgInet<T extends ColumnBaseConfig> extends PgColumn<PgInetHKT, T> {
+declare class PgInet<T extends ColumnBaseConfig<'string', 'PgInet'>> extends PgColumn<T> {
     static readonly [entityKind]: string;
     getSQLType(): string;
 }
 declare function inet<TName extends string>(name: TName): PgInetBuilderInitial<TName>;
 
-interface PgIntegerBuilderHKT extends ColumnBuilderHKTBase {
-    _type: PgIntegerBuilder<Assume<this['config'], ColumnBuilderBaseConfig>>;
-    _columnHKT: PgIntegerHKT;
-}
-interface PgIntegerHKT extends ColumnHKTBase {
-    _type: PgInteger<Assume<this['config'], ColumnBaseConfig>>;
-}
 type PgIntegerBuilderInitial<TName extends string> = PgIntegerBuilder<{
     name: TName;
+    dataType: 'number';
+    columnType: 'PgInteger';
     data: number;
     driverParam: number | string;
-    hasDefault: false;
-    notNull: false;
+    enumValues: undefined;
 }>;
-declare class PgIntegerBuilder<T extends ColumnBuilderBaseConfig> extends PgColumnBuilder<PgIntegerBuilderHKT, T> {
+declare class PgIntegerBuilder<T extends ColumnBuilderBaseConfig<'number', 'PgInteger'>> extends PgColumnBuilder<T> {
     static readonly [entityKind]: string;
+    constructor(name: T['name']);
 }
-declare class PgInteger<T extends ColumnBaseConfig> extends PgColumn<PgIntegerHKT, T> {
+declare class PgInteger<T extends ColumnBaseConfig<'number', 'PgInteger'>> extends PgColumn<T> {
     static readonly [entityKind]: string;
     getSQLType(): string;
     mapFromDriverValue(value: number | string): number;
 }
 declare function integer<TName extends string>(name: TName): PgIntegerBuilderInitial<TName>;
 
-interface PgTimestampBuilderHKT extends ColumnBuilderHKTBase {
-    _type: PgTimestampBuilder<Assume<this['config'], ColumnBuilderBaseConfig>>;
-    _columnHKT: PgTimestampHKT;
-}
-interface PgTimestampHKT extends ColumnHKTBase {
-    _type: PgTimestamp<Assume<this['config'], ColumnBaseConfig>>;
-}
 type PgTimestampBuilderInitial<TName extends string> = PgTimestampBuilder<{
     name: TName;
+    dataType: 'date';
+    columnType: 'PgTimestamp';
     data: Date;
     driverParam: string;
-    notNull: false;
-    hasDefault: false;
+    enumValues: undefined;
 }>;
-declare class PgTimestampBuilder<T extends ColumnBuilderBaseConfig> extends PgDateColumnBaseBuilder<PgTimestampBuilderHKT, T, {
+declare class PgTimestampBuilder<T extends ColumnBuilderBaseConfig<'date', 'PgTimestamp'>> extends PgDateColumnBaseBuilder<T, {
     withTimezone: boolean;
     precision: number | undefined;
 }> {
     static readonly [entityKind]: string;
     constructor(name: string, withTimezone: boolean, precision: number | undefined);
 }
-declare class PgTimestamp<T extends ColumnBaseConfig> extends PgColumn<PgTimestampHKT, T> {
+declare class PgTimestamp<T extends ColumnBaseConfig<'date', 'PgTimestamp'>> extends PgColumn<T> {
     static readonly [entityKind]: string;
     readonly withTimezone: boolean;
     readonly precision: number | undefined;
@@ -534,28 +457,22 @@ declare class PgTimestamp<T extends ColumnBaseConfig> extends PgColumn<PgTimesta
     mapFromDriverValue: (value: string) => Date;
     mapToDriverValue: (value: Date) => string;
 }
-interface PgTimestampStringBuilderHKT extends ColumnBuilderHKTBase {
-    _type: PgTimestampStringBuilder<Assume<this['config'], ColumnBuilderBaseConfig>>;
-    _columnHKT: PgTimestampStringHKT;
-}
-interface PgTimestampStringHKT extends ColumnHKTBase {
-    _type: PgTimestampString<Assume<this['config'], ColumnBaseConfig>>;
-}
 type PgTimestampStringBuilderInitial<TName extends string> = PgTimestampStringBuilder<{
     name: TName;
+    dataType: 'string';
+    columnType: 'PgTimestampString';
     data: string;
     driverParam: string;
-    notNull: false;
-    hasDefault: false;
+    enumValues: undefined;
 }>;
-declare class PgTimestampStringBuilder<T extends ColumnBuilderBaseConfig> extends PgDateColumnBaseBuilder<PgTimestampStringBuilderHKT, T, {
+declare class PgTimestampStringBuilder<T extends ColumnBuilderBaseConfig<'string', 'PgTimestampString'>> extends PgDateColumnBaseBuilder<T, {
     withTimezone: boolean;
     precision: number | undefined;
 }> {
     static readonly [entityKind]: string;
     constructor(name: string, withTimezone: boolean, precision: number | undefined);
 }
-declare class PgTimestampString<T extends ColumnBaseConfig> extends PgColumn<PgTimestampStringHKT, T> {
+declare class PgTimestampString<T extends ColumnBaseConfig<'string', 'PgTimestampString'>> extends PgColumn<T> {
     static readonly [entityKind]: string;
     readonly withTimezone: boolean;
     readonly precision: number | undefined;
@@ -572,27 +489,21 @@ interface PgTimestampConfig<TMode extends 'date' | 'string' = 'date' | 'string'>
 }
 declare function timestamp<TName extends string, TMode extends PgTimestampConfig['mode'] & {}>(name: TName, config?: PgTimestampConfig<TMode>): Equal<TMode, 'string'> extends true ? PgTimestampStringBuilderInitial<TName> : PgTimestampBuilderInitial<TName>;
 
-interface PgIntervalBuilderHKT extends ColumnBuilderHKTBase {
-    _type: PgIntervalBuilder<Assume<this['config'], ColumnBuilderBaseConfig>>;
-    _columnHKT: PgIntervalHKT;
-}
-interface PgIntervalHKT extends ColumnHKTBase {
-    _type: PgInterval<Assume<this['config'], ColumnBaseConfig>>;
-}
 type PgIntervalBuilderInitial<TName extends string> = PgIntervalBuilder<{
     name: TName;
+    dataType: 'string';
+    columnType: 'PgInterval';
     data: string;
     driverParam: string;
-    notNull: false;
-    hasDefault: false;
+    enumValues: undefined;
 }>;
-declare class PgIntervalBuilder<T extends ColumnBuilderBaseConfig> extends PgColumnBuilder<PgIntervalBuilderHKT, T, {
+declare class PgIntervalBuilder<T extends ColumnBuilderBaseConfig<'string', 'PgInterval'>> extends PgColumnBuilder<T, {
     intervalConfig: IntervalConfig;
 }> {
     static readonly [entityKind]: string;
     constructor(name: T['name'], intervalConfig: IntervalConfig);
 }
-declare class PgInterval<T extends ColumnBaseConfig> extends PgColumn<PgIntervalHKT, T, {
+declare class PgInterval<T extends ColumnBaseConfig<'string', 'PgInterval'>> extends PgColumn<T, {
     intervalConfig: IntervalConfig;
 }> {
     static readonly [entityKind]: string;
@@ -606,26 +517,20 @@ interface IntervalConfig {
 }
 declare function interval<TName extends string>(name: TName, config?: IntervalConfig): PgIntervalBuilderInitial<TName>;
 
-interface PgJsonBuilderHKT extends ColumnBuilderHKTBase {
-    _type: PgJsonBuilder<Assume<this['config'], ColumnBuilderBaseConfig>>;
-    _columnHKT: PgJsonHKT;
-}
-interface PgJsonHKT extends ColumnHKTBase {
-    _type: PgJson<Assume<this['config'], ColumnBaseConfig>>;
-}
 type PgJsonBuilderInitial<TName extends string> = PgJsonBuilder<{
     name: TName;
+    dataType: 'json';
+    columnType: 'PgJson';
     data: unknown;
     driverParam: unknown;
-    notNull: false;
-    hasDefault: false;
+    enumValues: undefined;
 }>;
-declare class PgJsonBuilder<T extends ColumnBuilderBaseConfig> extends PgColumnBuilder<PgJsonBuilderHKT, T> {
+declare class PgJsonBuilder<T extends ColumnBuilderBaseConfig<'json', 'PgJson'>> extends PgColumnBuilder<T> {
     static readonly [entityKind]: string;
+    constructor(name: T['name']);
 }
-declare class PgJson<T extends ColumnBaseConfig> extends PgColumn<PgJsonHKT, T> {
+declare class PgJson<T extends ColumnBaseConfig<'json', 'PgJson'>> extends PgColumn<T> {
     static readonly [entityKind]: string;
-    protected $pgColumnBrand: 'PgJson';
     constructor(table: AnyPgTable<{
         name: T['tableName'];
     }>, config: PgJsonBuilder<T>['config']);
@@ -635,26 +540,20 @@ declare class PgJson<T extends ColumnBaseConfig> extends PgColumn<PgJsonHKT, T>
 }
 declare function json<TName extends string>(name: TName): PgJsonBuilderInitial<TName>;
 
-interface PgJsonbBuilderHKT extends ColumnBuilderHKTBase {
-    _type: PgJsonbBuilder<Assume<this['config'], ColumnBuilderBaseConfig>>;
-    _columnHKT: PgJsonbHKT;
-}
-interface PgJsonbHKT extends ColumnHKTBase {
-    _type: PgJsonb<Assume<this['config'], ColumnBaseConfig>>;
-}
 type PgJsonbBuilderInitial<TName extends string> = PgJsonbBuilder<{
     name: TName;
+    dataType: 'json';
+    columnType: 'PgJsonb';
     data: unknown;
     driverParam: unknown;
-    notNull: false;
-    hasDefault: false;
+    enumValues: undefined;
 }>;
-declare class PgJsonbBuilder<T extends ColumnBuilderBaseConfig> extends PgColumnBuilder<PgJsonbBuilderHKT, T> {
+declare class PgJsonbBuilder<T extends ColumnBuilderBaseConfig<'json', 'PgJsonb'>> extends PgColumnBuilder<T> {
     static readonly [entityKind]: string;
+    constructor(name: T['name']);
 }
-declare class PgJsonb<T extends ColumnBaseConfig> extends PgColumn<PgJsonbHKT, T> {
+declare class PgJsonb<T extends ColumnBaseConfig<'json', 'PgJsonb'>> extends PgColumn<T> {
     static readonly [entityKind]: string;
-    protected $pgColumnBrand: 'PgJsonb';
     constructor(table: AnyPgTable<{
         name: T['tableName'];
     }>, config: PgJsonbBuilder<T>['config']);
@@ -664,74 +563,58 @@ declare class PgJsonb<T extends ColumnBaseConfig> extends PgColumn<PgJsonbHKT, T
 }
 declare function jsonb<TName extends string>(name: TName): PgJsonbBuilderInitial<TName>;
 
-interface PgMacaddrBuilderHKT extends ColumnBuilderHKTBase {
-    _type: PgMacaddrBuilder<Assume<this['config'], ColumnBuilderBaseConfig>>;
-    _columnHKT: PgMacaddrHKT;
-}
-interface PgMacaddrHKT extends ColumnHKTBase {
-    _type: PgMacaddr<Assume<this['config'], ColumnBaseConfig>>;
-}
 type PgMacaddrBuilderInitial<TName extends string> = PgMacaddrBuilder<{
     name: TName;
+    dataType: 'string';
+    columnType: 'PgMacaddr';
     data: string;
     driverParam: string;
-    notNull: false;
-    hasDefault: false;
+    enumValues: undefined;
 }>;
-declare class PgMacaddrBuilder<T extends ColumnBuilderBaseConfig> extends PgColumnBuilder<PgMacaddrBuilderHKT, T> {
+declare class PgMacaddrBuilder<T extends ColumnBuilderBaseConfig<'string', 'PgMacaddr'>> extends PgColumnBuilder<T> {
     static readonly [entityKind]: string;
+    constructor(name: T['name']);
 }
-declare class PgMacaddr<T extends ColumnBaseConfig> extends PgColumn<PgMacaddrHKT, T> {
+declare class PgMacaddr<T extends ColumnBaseConfig<'string', 'PgMacaddr'>> extends PgColumn<T> {
     static readonly [entityKind]: string;
     getSQLType(): string;
 }
 declare function macaddr<TName extends string>(name: TName): PgMacaddrBuilderInitial<TName>;
 
-interface PgMacaddr8BuilderHKT extends ColumnBuilderHKTBase {
-    _type: PgMacaddr8Builder<Assume<this['config'], ColumnBuilderBaseConfig>>;
-    _columnHKT: PgMacaddr8HKT;
-}
-interface PgMacaddr8HKT extends ColumnHKTBase {
-    _type: PgMacaddr8<Assume<this['config'], ColumnBaseConfig>>;
-}
 type PgMacaddr8BuilderInitial<TName extends string> = PgMacaddr8Builder<{
     name: TName;
+    dataType: 'string';
+    columnType: 'PgMacaddr8';
     data: string;
     driverParam: string;
-    notNull: false;
-    hasDefault: false;
+    enumValues: undefined;
 }>;
-declare class PgMacaddr8Builder<T extends ColumnBuilderBaseConfig> extends PgColumnBuilder<PgMacaddr8BuilderHKT, T> {
+declare class PgMacaddr8Builder<T extends ColumnBuilderBaseConfig<'string', 'PgMacaddr8'>> extends PgColumnBuilder<T> {
     static readonly [entityKind]: string;
+    constructor(name: T['name']);
 }
-declare class PgMacaddr8<T extends ColumnBaseConfig> extends PgColumn<PgMacaddr8HKT, T> {
+declare class PgMacaddr8<T extends ColumnBaseConfig<'string', 'PgMacaddr8'>> extends PgColumn<T> {
     static readonly [entityKind]: string;
     getSQLType(): string;
 }
 declare function macaddr8<TName extends string>(name: TName): PgMacaddr8BuilderInitial<TName>;
 
-interface PgNumericBuilderHKT extends ColumnBuilderHKTBase {
-    _type: PgNumericBuilder<Assume<this['config'], ColumnBuilderBaseConfig>>;
-    _columnHKT: PgNumericHKT;
-}
-interface PgNumericHKT extends ColumnHKTBase {
-    _type: PgNumeric<Assume<this['config'], ColumnBaseConfig>>;
-}
 type PgNumericBuilderInitial<TName extends string> = PgNumericBuilder<{
     name: TName;
+    dataType: 'string';
+    columnType: 'PgNumeric';
     data: string;
     driverParam: string;
-    notNull: false;
-    hasDefault: false;
+    enumValues: undefined;
 }>;
-declare class PgNumericBuilder<T extends ColumnBuilderBaseConfig> extends PgColumnBuilder<PgNumericBuilderHKT, T, {
+declare class PgNumericBuilder<T extends ColumnBuilderBaseConfig<'string', 'PgNumeric'>> extends PgColumnBuilder<T, {
     precision: number | undefined;
     scale: number | undefined;
 }> {
     static readonly [entityKind]: string;
     constructor(name: string, precision?: number, scale?: number);
 }
-declare class PgNumeric<T extends ColumnBaseConfig> extends PgColumn<PgNumericHKT, T> {
+declare class PgNumeric<T extends ColumnBaseConfig<'string', 'PgNumeric'>> extends PgColumn<T> {
     static readonly [entityKind]: string;
     readonly precision: number | undefined;
     readonly scale: number | undefined;
@@ -752,27 +635,21 @@ declare function numeric<TName extends string>(name: TName, config?: {
 }): PgNumericBuilderInitial<TName>;
 declare const decimal: typeof numeric;
 
-interface PgRealBuilderHKT extends ColumnBuilderHKTBase {
-    _type: PgRealBuilder<Assume<this['config'], ColumnBuilderBaseConfig>>;
-    _columnHKT: PgRealHKT;
-}
-interface PgRealHKT extends ColumnHKTBase {
-    _type: PgReal<Assume<this['config'], ColumnBaseConfig>>;
-}
 type PgRealBuilderInitial<TName extends string> = PgRealBuilder<{
     name: TName;
+    dataType: 'number';
+    columnType: 'PgReal';
     data: number;
     driverParam: string | number;
-    notNull: false;
-    hasDefault: false;
+    enumValues: undefined;
 }>;
-declare class PgRealBuilder<T extends ColumnBuilderBaseConfig> extends PgColumnBuilder<PgRealBuilderHKT, T, {
+declare class PgRealBuilder<T extends ColumnBuilderBaseConfig<'number', 'PgReal'>> extends PgColumnBuilder<T, {
     length: number | undefined;
 }> {
     static readonly [entityKind]: string;
     constructor(name: string, length?: number);
 }
-declare class PgReal<T extends ColumnBaseConfig> extends PgColumn<PgRealHKT, T> {
+declare class PgReal<T extends ColumnBaseConfig<'number', 'PgReal'>> extends PgColumn<T> {
     static readonly [entityKind]: string;
     constructor(table: AnyPgTable<{
         name: T['tableName'];
@@ -782,129 +659,96 @@ declare class PgReal<T extends ColumnBaseConfig> extends PgColumn<PgRealHKT, T>
 }
 declare function real<TName extends string>(name: TName): PgRealBuilderInitial<TName>;
 
-type PgSerialBuilderInitial<TName extends string> = PgSerialBuilder<{
+type PgSerialBuilderInitial<TName extends string> = NotNull<HasDefault<PgSerialBuilder<{
     name: TName;
+    dataType: 'number';
+    columnType: 'PgSerial';
     data: number;
     driverParam: number;
-    notNull: true;
-    hasDefault: true;
-}>;
-interface PgSerialBuilderHKT extends ColumnBuilderHKTBase {
-    _type: PgSerialBuilder<Assume<this['config'], ColumnBuilderBaseConfig>>;
-    _columnHKT: PgSerialHKT;
-}
-interface PgSerialBuilderHKT extends ColumnBuilderHKTBase {
-    _type: PgSerialBuilder<Assume<this['config'], ColumnBuilderBaseConfig>>;
-    _columnHKT: PgSerialHKT;
-}
-interface PgSerialHKT extends ColumnHKTBase {
-    _type: PgSerial<Assume<this['config'], ColumnBaseConfig>>;
-}
-interface PgSerialHKT extends ColumnHKTBase {
-    _type: PgSerial<Assume<this['config'], ColumnBaseConfig>>;
-}
-declare class PgSerialBuilder<T extends ColumnBuilderBaseConfig> extends PgColumnBuilder<PgSerialBuilderHKT, T> {
+    enumValues: undefined;
+}>>>;
+declare class PgSerialBuilder<T extends ColumnBuilderBaseConfig<'number', 'PgSerial'>> extends PgColumnBuilder<T> {
     static readonly [entityKind]: string;
     constructor(name: string);
 }
-declare class PgSerial<T extends ColumnBaseConfig> extends PgColumn<PgSerialHKT, T> {
+declare class PgSerial<T extends ColumnBaseConfig<'number', 'PgSerial'>> extends PgColumn<T> {
     static readonly [entityKind]: string;
     getSQLType(): string;
 }
 declare function serial<TName extends string>(name: TName): PgSerialBuilderInitial<TName>;
 
-interface PgSmallIntBuilderHKT extends ColumnBuilderHKTBase {
-    _type: PgSmallIntBuilder<Assume<this['config'], ColumnBuilderBaseConfig>>;
-    _columnHKT: PgSmallIntHKT;
-}
-interface PgSmallIntHKT extends ColumnHKTBase {
-    _type: PgSmallInt<Assume<this['config'], ColumnBaseConfig>>;
-}
 type PgSmallIntBuilderInitial<TName extends string> = PgSmallIntBuilder<{
     name: TName;
+    dataType: 'number';
+    columnType: 'PgSmallInt';
     data: number;
     driverParam: number | string;
-    notNull: false;
-    hasDefault: false;
+    enumValues: undefined;
 }>;
-declare class PgSmallIntBuilder<T extends ColumnBuilderBaseConfig> extends PgColumnBuilder<PgSmallIntBuilderHKT, T> {
+declare class PgSmallIntBuilder<T extends ColumnBuilderBaseConfig<'number', 'PgSmallInt'>> extends PgColumnBuilder<T> {
     static readonly [entityKind]: string;
+    constructor(name: T['name']);
 }
-declare class PgSmallInt<T extends ColumnBaseConfig> extends PgColumn<PgSmallIntHKT, T> {
+declare class PgSmallInt<T extends ColumnBaseConfig<'number', 'PgSmallInt'>> extends PgColumn<T> {
     static readonly [entityKind]: string;
     getSQLType(): string;
     mapFromDriverValue: (value: number | string) => number;
 }
 declare function smallint<TName extends string>(name: TName): PgSmallIntBuilderInitial<TName>;
 
-interface PgSmallSerialBuilderHKT extends ColumnBuilderHKTBase {
-    _type: PgSmallSerialBuilder<Assume<this['config'], ColumnBuilderBaseConfig>>;
-    _columnHKT: PgSmallSerialHKT;
-}
-interface PgSmallSerialHKT extends ColumnHKTBase {
-    _type: PgSmallSerial<Assume<this['config'], ColumnBaseConfig>>;
-}
 type PgSmallSerialBuilderInitial<TName extends string> = PgSmallSerialBuilder<{
     name: TName;
+    dataType: 'number';
+    columnType: 'PgSmallSerial';
     data: number;
     driverParam: number;
-    notNull: false;
-    hasDefault: false;
+    enumValues: undefined;
 }>;
-declare class PgSmallSerialBuilder<T extends ColumnBuilderBaseConfig> extends PgColumnBuilder<PgSmallSerialBuilderHKT, T> {
+declare class PgSmallSerialBuilder<T extends ColumnBuilderBaseConfig<'number', 'PgSmallSerial'>> extends PgColumnBuilder<T> {
     static readonly [entityKind]: string;
     constructor(name: string);
 }
-declare class PgSmallSerial<T extends ColumnBaseConfig> extends PgColumn<PgSmallSerialHKT, T> {
+declare class PgSmallSerial<T extends ColumnBaseConfig<'number', 'PgSmallSerial'>> extends PgColumn<T> {
     static readonly [entityKind]: string;
     getSQLType(): string;
 }
 declare function smallserial<TName extends string>(name: TName): PgSmallSerialBuilderInitial<TName>;
 
-interface PgTextBuilderHKT extends ColumnBuilderHKTBase {
-    _type: PgTextBuilder<Assume<this['config'], ColumnBuilderBaseConfig & WithEnum>>;
-    _columnHKT: PgTextHKT;
-}
-interface PgTextHKT extends ColumnHKTBase {
-    _type: PgText<Assume<this['config'], ColumnBaseConfig & WithEnum>>;
-}
 type PgTextBuilderInitial<TName extends string, TEnum extends [string, ...string[]]> = PgTextBuilder<{
     name: TName;
+    dataType: 'string';
+    columnType: 'PgText';
     data: TEnum[number];
     enumValues: TEnum;
     driverParam: string;
-    notNull: false;
-    hasDefault: false;
 }>;
-declare class PgTextBuilder<T extends ColumnBuilderBaseConfig & WithEnum> extends PgColumnBuilder<PgTextBuilderHKT, T, WithEnum<T['enumValues']>> {
+declare class PgTextBuilder<T extends ColumnBuilderBaseConfig<'string', 'PgText'>> extends PgColumnBuilder<T, {
+    enumValues: T['enumValues'];
+}> {
     static readonly [entityKind]: string;
     constructor(name: T['name'], config: PgTextConfig<T['enumValues']>);
 }
-declare class PgText<T extends ColumnBaseConfig & WithEnum> extends PgColumn<PgTextHKT, T, WithEnum<T['enumValues']>> implements WithEnum<T['enumValues']> {
+declare class PgText<T extends ColumnBaseConfig<'string', 'PgText'>> extends PgColumn<T, {
+    enumValues: T['enumValues'];
+}> {
     static readonly [entityKind]: string;
     readonly enumValues: T["enumValues"];
     getSQLType(): string;
 }
-interface PgTextConfig<TEnum extends readonly string[] | string[]> {
+interface PgTextConfig<TEnum extends readonly string[] | string[] | undefined> {
     enum?: TEnum;
 }
 declare function text<TName extends string, U extends string, T extends Readonly<[U, ...U[]]>>(name: TName, config?: PgTextConfig<T | Writable<T>>): PgTextBuilderInitial<TName, Writable<T>>;
 
-interface PgTimeBuilderHKT extends ColumnBuilderHKTBase {
-    _type: PgTimeBuilder<Assume<this['config'], ColumnBuilderBaseConfig>>;
-    _columnHKT: PgTimeHKT;
-}
-interface PgTimeHKT extends ColumnHKTBase {
-    _type: PgTime<Assume<this['config'], ColumnBaseConfig>>;
-}
 type PgTimeBuilderInitial<TName extends string> = PgTimeBuilder<{
     name: TName;
+    dataType: 'string';
+    columnType: 'PgTime';
     data: string;
     driverParam: string;
-    notNull: false;
-    hasDefault: false;
+    enumValues: undefined;
 }>;
-declare class PgTimeBuilder<T extends ColumnBuilderBaseConfig> extends PgDateColumnBaseBuilder<PgTimeBuilderHKT, T, {
+declare class PgTimeBuilder<T extends ColumnBuilderBaseConfig<'string', 'PgTime'>> extends PgDateColumnBaseBuilder<T, {
     withTimezone: boolean;
     precision: number | undefined;
 }> {
@@ -913,7 +757,7 @@ declare class PgTimeBuilder<T extends ColumnBuilderBaseConfig> extends PgDateCol
     static readonly [entityKind]: string;
     constructor(name: T['name'], withTimezone: boolean, precision: number | undefined);
 }
-declare class PgTime<T extends ColumnBaseConfig> extends PgColumn<PgTimeHKT, T> {
+declare class PgTime<T extends ColumnBaseConfig<'string', 'PgTime'>> extends PgColumn<T> {
     static readonly [entityKind]: string;
     readonly withTimezone: boolean;
     readonly precision: number | undefined;
@@ -928,69 +772,59 @@ interface TimeConfig {
 }
 declare function time<TName extends string>(name: TName, config?: TimeConfig): PgTimeBuilderInitial<TName>;
 
-interface PgUUIDBuilderHKT extends ColumnBuilderHKTBase {
-    _type: PgUUIDBuilder<Assume<this['config'], ColumnBuilderBaseConfig>>;
-    _columnHKT: PgUUIDHKT;
-}
-interface PgUUIDHKT extends ColumnHKTBase {
-    _type: PgUUID<Assume<this['config'], ColumnBaseConfig>>;
-}
 type PgUUIDBuilderInitial<TName extends string> = PgUUIDBuilder<{
     name: TName;
+    dataType: 'string';
+    columnType: 'PgUUID';
     data: string;
     driverParam: string;
-    notNull: false;
-    hasDefault: false;
+    enumValues: undefined;
 }>;
-declare class PgUUIDBuilder<T extends ColumnBuilderBaseConfig> extends PgColumnBuilder<PgUUIDBuilderHKT, T> {
+declare class PgUUIDBuilder<T extends ColumnBuilderBaseConfig<'string', 'PgUUID'>> extends PgColumnBuilder<T> {
     static readonly [entityKind]: string;
+    constructor(name: T['name']);
     /**
      * Adds `default gen_random_uuid()` to the column definition.
      */
     defaultRandom(): ReturnType<this['default']>;
 }
-declare class PgUUID<T extends ColumnBaseConfig> extends PgColumn<PgUUIDHKT, T> {
+declare class PgUUID<T extends ColumnBaseConfig<'string', 'PgUUID'>> extends PgColumn<T> {
     static readonly [entityKind]: string;
     getSQLType(): string;
 }
 declare function uuid<TName extends string>(name: TName): PgUUIDBuilderInitial<TName>;
 
-interface PgVarcharBuilderHKT extends ColumnBuilderHKTBase {
-    _type: PgVarcharBuilder<Assume<this['config'], ColumnBuilderBaseConfig & WithEnum>>;
-    _columnHKT: PgVarcharHKT;
-}
-interface PgVarcharHKT extends ColumnHKTBase {
-    _type: PgVarchar<Assume<this['config'], ColumnBaseConfig & WithEnum>>;
-}
 type PgVarcharBuilderInitial<TName extends string, TEnum extends [string, ...string[]]> = PgVarcharBuilder<{
     name: TName;
+    dataType: 'string';
+    columnType: 'PgVarchar';
     data: TEnum[number];
     driverParam: string;
     enumValues: TEnum;
-    notNull: false;
-    hasDefault: false;
 }>;
-declare class PgVarcharBuilder<T extends ColumnBuilderBaseConfig & WithEnum> extends PgColumnBuilder<PgVarcharBuilderHKT, T, {
+declare class PgVarcharBuilder<T extends ColumnBuilderBaseConfig<'string', 'PgVarchar'>> extends PgColumnBuilder<T, {
     length: number | undefined;
-} & WithEnum<T['enumValues']>> {
+    enumValues: T['enumValues'];
+}> {
     static readonly [entityKind]: string;
     constructor(name: string, config: PgVarcharConfig<T['enumValues']>);
 }
-declare class PgVarchar<T extends ColumnBaseConfig & WithEnum> extends PgColumn<PgVarcharHKT, T, {
+declare class PgVarchar<T extends ColumnBaseConfig<'string', 'PgVarchar'>> extends PgColumn<T, {
     length: number | undefined;
-} & WithEnum<T['enumValues']>> implements WithEnum<T['enumValues']> {
+    enumValues: T['enumValues'];
+}> {
     static readonly [entityKind]: string;
     readonly length: number | undefined;
     readonly enumValues: T["enumValues"];
     getSQLType(): string;
 }
-interface PgVarcharConfig<TEnum extends readonly string[] | string[]> {
+interface PgVarcharConfig<TEnum extends readonly string[] | string[] | undefined> {
     length?: number;
     enum?: TEnum;
 }
 declare function varchar<TName extends string, U extends string, T extends Readonly<[U, ...U[]]>>(name: TName, config?: PgVarcharConfig<T | Writable<T>>): PgVarcharBuilderInitial<TName, Writable<T>>;
 
-declare function alias<TTable extends AnyPgTable, TAlias extends string>(table: TTable, alias: TAlias): BuildAliasTable<TTable, TAlias>;
+declare function alias<TTable extends AnyPgTable | PgViewBase, TAlias extends string>(table: TTable, alias: TAlias): BuildAliasTable<TTable, TAlias>;
 
 declare class PgSchema<TName extends string = string> {
     readonly schemaName: TName;
@@ -1004,7 +838,7 @@ declare function isPgSchema(obj: unknown): obj is PgSchema;
 declare function pgSchema<T extends string>(name: T): PgSchema<T>;
 
 declare function getTableConfig<TTable extends AnyPgTable>(table: TTable): {
-    columns: AnyPgColumn[];
+    columns: PgColumn<ColumnBaseConfig<ColumnDataType, string>, {}, {}>[];
     indexes: Index[];
     foreignKeys: ForeignKey[];
     checks: Check[];
@@ -1018,7 +852,7 @@ declare function getViewConfig<TName extends string = string, TExisting extends
     name: TName;
     originalName: TName;
     schema: string | undefined;
-    selectedFields: SelectedFields<AnyColumn, Table<TableConfig<AnyColumn>>>;
+    selectedFields: SelectedFields<AnyColumn, Table<TableConfig<Column<any, object, object>>>>;
     isExisting: TExisting;
     query: TExisting extends true ? undefined : SQL<unknown>;
     isAlias: boolean;
@@ -1031,7 +865,7 @@ declare function getMaterializedViewConfig<TName extends string = string, TExist
     name: TName;
     originalName: TName;
     schema: string | undefined;
-    selectedFields: SelectedFields<AnyColumn, Table<TableConfig<AnyColumn>>>;
+    selectedFields: SelectedFields<AnyColumn, Table<TableConfig<Column<any, object, object>>>>;
     isExisting: TExisting;
     query: TExisting extends true ? undefined : SQL<unknown>;
     isAlias: boolean;
@@ -1047,4 +881,4 @@ type ColumnsWithTable<TTableName extends string, TForeignTableName extends strin
     }>;
 };
 
-export { AnyPgColumn, AnyPgTable, BuildAliasTable, Check, ColumnsWithTable, ConvertCustomConfig, CustomTypeParams, CustomTypeValues, ForeignKey, Index, IntervalConfig, PgBigInt53, PgBigInt53Builder, PgBigInt53BuilderHKT, PgBigInt53BuilderInitial, PgBigInt53HKT, PgBigInt64, PgBigInt64Builder, PgBigInt64BuilderHKT, PgBigInt64BuilderInitial, PgBigInt64HKT, PgBigSerial53, PgBigSerial53Builder, PgBigSerial53BuilderHKT, PgBigSerial53BuilderInitial, PgBigSerial53HKT, PgBigSerial64, PgBigSerial64Builder, PgBigSerial64BuilderHKT, PgBigSerial64BuilderInitial, PgBigSerial64HKT, PgBoolean, PgBooleanBuilder, PgBooleanBuilderHKT, PgBooleanBuilderInitial, PgBooleanHKT, PgChar, PgCharBuilder, PgCharBuilderHKT, PgCharBuilderInitial, PgCharConfig, PgCharHKT, PgCidr, PgCidrBuilder, PgCidrBuilderHKT, PgCidrBuilderInitial, PgCidrHKT, PgColumn, PgColumnBuilder, PgCustomColumn, PgCustomColumnBuilder, PgCustomColumnBuilderHKT, PgCustomColumnHKT, PgCustomColumnInnerConfig, PgDate, PgDateBuilder, PgDateBuilderHKT, PgDateBuilderInitial, PgDateHKT, PgDateString, PgDateStringBuilder, PgDateStringBuilderHKT, PgDateStringBuilderInitial, PgDateStringHKT, PgDoublePrecision, PgDoublePrecisionBuilder, PgDoublePrecisionBuilderHKT, PgDoublePrecisionBuilderInitial, PgDoublePrecisionHKT, PgEnum, PgEnumColumn, PgEnumColumnBuilder, PgEnumColumnBuilderHKT, PgEnumColumnBuilderInitial, PgEnumColumnHKT, PgInet, PgInetBuilder, PgInetBuilderHKT, PgInetBuilderInitial, PgInetHKT, PgInteger, PgIntegerBuilder, PgIntegerBuilderHKT, PgIntegerHKT, PgInterval, PgIntervalBuilder, PgIntervalBuilderHKT, PgIntervalBuilderInitial, PgIntervalHKT, PgJson, PgJsonBuilder, PgJsonBuilderHKT, PgJsonBuilderInitial, PgJsonHKT, PgJsonb, PgJsonbBuilder, PgJsonbBuilderHKT, PgJsonbBuilderInitial, PgJsonbHKT, PgMacaddr, PgMacaddr8, PgMacaddr8Builder, PgMacaddr8BuilderHKT, PgMacaddr8BuilderInitial, PgMacaddr8HKT, PgMacaddrBuilder, PgMacaddrBuilderHKT, PgMacaddrBuilderInitial, PgMacaddrHKT, PgMaterializedView, PgMaterializedViewWithConfig, PgNumeric, PgNumericBuilder, PgNumericBuilderHKT, PgNumericBuilderInitial, PgNumericHKT, PgReal, PgRealBuilder, PgRealBuilderHKT, PgRealBuilderInitial, PgRealHKT, PgSchema, PgSerial, PgSerialBuilder, PgSerialBuilderHKT, PgSerialBuilderInitial, PgSerialHKT, PgSmallInt, PgSmallIntBuilder, PgSmallIntBuilderHKT, PgSmallIntBuilderInitial, PgSmallIntHKT, PgSmallSerial, PgSmallSerialBuilder, PgSmallSerialBuilderHKT, PgSmallSerialBuilderInitial, PgSmallSerialHKT, PgTableFn, PgText, PgTextBuilder, PgTextBuilderHKT, PgTextConfig, PgTextHKT, PgTime, PgTimeBuilder, PgTimeBuilderHKT, PgTimeBuilderInitial, PgTimeHKT, PgTimestamp, PgTimestampBuilder, PgTimestampBuilderHKT, PgTimestampBuilderInitial, PgTimestampConfig, PgTimestampHKT, PgTimestampString, PgTimestampStringBuilder, PgTimestampStringBuilderHKT, PgTimestampStringBuilderInitial, PgTimestampStringHKT, PgUUID, PgUUIDBuilder, PgUUIDBuilderHKT, PgUUIDBuilderInitial, PgUUIDHKT, PgVarchar, PgVarcharBuilder, PgVarcharBuilderHKT, PgVarcharBuilderInitial, PgVarcharConfig, PgVarcharHKT, PgView, Precision, PrimaryKey, TimeConfig, UniqueConstraint, ViewWithConfig, alias, bigint, bigserial, boolean, char, cidr, customType, date, decimal, doublePrecision, getMaterializedViewConfig, getTableConfig, getViewConfig, inet, integer, interval, isPgEnum, isPgSchema, json, jsonb, macaddr, macaddr8, makePgArray, numeric, parsePgArray, parsePgNestedArray, pgEnum, pgMaterializedView, pgSchema, pgView, real, serial, smallint, smallserial, text, time, timestamp, uuid, varchar };
+export { AnyPgColumn, AnyPgTable, BuildAliasTable, Check, ColumnsWithTable, ConvertCustomConfig, CustomTypeParams, CustomTypeValues, ForeignKey, Index, IntervalConfig, PgBigInt53, PgBigInt53Builder, PgBigInt53BuilderInitial, PgBigInt64, PgBigInt64Builder, PgBigInt64BuilderInitial, PgBigSerial53, PgBigSerial53Builder, PgBigSerial53BuilderInitial, PgBigSerial64, PgBigSerial64Builder, PgBigSerial64BuilderInitial, PgBoolean, PgBooleanBuilder, PgBooleanBuilderInitial, PgChar, PgCharBuilder, PgCharBuilderInitial, PgCharConfig, PgCidr, PgCidrBuilder, PgCidrBuilderInitial, PgColumn, PgColumnBuilder, PgCustomColumn, PgCustomColumnBuilder, PgCustomColumnInnerConfig, PgDate, PgDateBuilder, PgDateBuilderInitial, PgDateString, PgDateStringBuilder, PgDateStringBuilderInitial, PgDoublePrecision, PgDoublePrecisionBuilder, PgDoublePrecisionBuilderInitial, PgEnum, PgEnumColumn, PgEnumColumnBuilder, PgEnumColumnBuilderInitial, PgInet, PgInetBuilder, PgInetBuilderInitial, PgInteger, PgIntegerBuilder, PgInterval, PgIntervalBuilder, PgIntervalBuilderInitial, PgJson, PgJsonBuilder, PgJsonBuilderInitial, PgJsonb, PgJsonbBuilder, PgJsonbBuilderInitial, PgMacaddr, PgMacaddr8, PgMacaddr8Builder, PgMacaddr8BuilderInitial, PgMacaddrBuilder, PgMacaddrBuilderInitial, PgMaterializedView, PgMaterializedViewWithConfig, PgNumeric, PgNumericBuilder, PgNumericBuilderInitial, PgReal, PgRealBuilder, PgRealBuilderInitial, PgSchema, PgSerial, PgSerialBuilder, PgSerialBuilderInitial, PgSmallInt, PgSmallIntBuilder, PgSmallIntBuilderInitial, PgSmallSerial, PgSmallSerialBuilder, PgSmallSerialBuilderInitial, PgTableFn, PgText, PgTextBuilder, PgTextConfig, PgTime, PgTimeBuilder, PgTimeBuilderInitial, PgTimestamp, PgTimestampBuilder, PgTimestampBuilderInitial, PgTimestampConfig, PgTimestampString, PgTimestampStringBuilder, PgTimestampStringBuilderInitial, PgUUID, PgUUIDBuilder, PgUUIDBuilderInitial, PgVarchar, PgVarcharBuilder, PgVarcharBuilderInitial, PgVarcharConfig, PgView, PgViewBase, Precision, PrimaryKey, TimeConfig, UniqueConstraint, ViewWithConfig, alias, bigint, bigserial, boolean, char, cidr, customType, date, decimal, doublePrecision, getMaterializedViewConfig, getTableConfig, getViewConfig, inet, integer, interval, isPgEnum, isPgSchema, json, jsonb, macaddr, macaddr8, makePgArray, numeric, parsePgArray, parsePgNestedArray, pgEnum, pgMaterializedView, pgSchema, pgView, real, serial, smallint, smallserial, text, time, timestamp, uuid, varchar };