drizzle-orm 0.28.3 → 0.28.4

package/pg-core/columns/custom.d.cts

@@ -0,0 +1,148 @@
+import type { ColumnBuilderBaseConfig } from '../../column-builder.js';
+import type { ColumnBaseConfig } from '../../column.js';
+import { entityKind } from '../../entity.js';
+import type { AnyPgTable } from '../table.js';
+import type { SQL } from '../../sql/index.js';
+import { type Equal } from '../../utils.js';
+import { PgColumn, PgColumnBuilder } from './common.js';
+export type ConvertCustomConfig<TName extends string, T extends Partial<CustomTypeValues>> = {
+    name: TName;
+    dataType: 'custom';
+    columnType: 'PgCustomColumn';
+    data: T['data'];
+    driverParam: T['driverData'];
+    enumValues: undefined;
+} & (T['notNull'] extends true ? {
+    notNull: true;
+} : {}) & (T['default'] extends true ? {
+    hasDefault: true;
+} : {});
+export interface PgCustomColumnInnerConfig {
+    customTypeValues: CustomTypeValues;
+}
+export declare class PgCustomColumnBuilder<T extends ColumnBuilderBaseConfig<'custom', 'PgCustomColumn'>> extends PgColumnBuilder<T, {
+    fieldConfig: CustomTypeValues['config'];
+    customTypeParams: CustomTypeParams<any>;
+}, {
+    pgColumnBuilderBrand: 'PgCustomColumnBuilderBrand';
+}> {
+    static readonly [entityKind]: string;
+    constructor(name: T['name'], fieldConfig: CustomTypeValues['config'], customTypeParams: CustomTypeParams<any>);
+}
+export declare class PgCustomColumn<T extends ColumnBaseConfig<'custom', 'PgCustomColumn'>> extends PgColumn<T> {
+    static readonly [entityKind]: string;
+    private sqlName;
+    private mapTo?;
+    private mapFrom?;
+    constructor(table: AnyPgTable<{
+        name: T['tableName'];
+    }>, config: PgCustomColumnBuilder<T>['config']);
+    getSQLType(): string;
+    mapFromDriverValue(value: T['driverParam']): T['data'];
+    mapToDriverValue(value: T['data']): T['driverParam'];
+}
+export type CustomTypeValues = {
+    /**
+     * Required type for custom column, that will infer proper type model
+     *
+     * Examples:
+     *
+     * If you want your column to be `string` type after selecting/or on inserting - use `data: string`. Like `text`, `varchar`
+     *
+     * If you want your column to be `number` type after selecting/or on inserting - use `data: number`. Like `integer`
+     */
+    data: unknown;
+    /**
+     * Type helper, that represents what type database driver is accepting for specific database data type
+     */
+    driverData?: unknown;
+    /**
+     * What config type should be used for {@link CustomTypeParams} `dataType` generation
+     */
+    config?: unknown;
+    /**
+     * Whether the config argument should be required or not
+     * @default false
+     */
+    configRequired?: boolean;
+    /**
+     * If your custom data type should be notNull by default you can use `notNull: true`
+     *
+     * @example
+     * const customSerial = customType<{ data: number, notNull: true, default: true }>({
+     * 	  dataType() {
+     * 	    return 'serial';
+     *    },
+     * });
+     */
+    notNull?: boolean;
+    /**
+     * If your custom data type has default you can use `default: true`
+     *
+     * @example
+     * const customSerial = customType<{ data: number, notNull: true, default: true }>({
+     * 	  dataType() {
+     * 	    return 'serial';
+     *    },
+     * });
+     */
+    default?: boolean;
+};
+export interface CustomTypeParams<T extends CustomTypeValues> {
+    /**
+     * Database data type string representation, that is used for migrations
+     * @example
+     * ```
+     * `jsonb`, `text`
+     * ```
+     *
+     * If database data type needs additional params you can use them from `config` param
+     * @example
+     * ```
+     * `varchar(256)`, `numeric(2,3)`
+     * ```
+     *
+     * To make `config` be of specific type please use config generic in {@link CustomTypeValues}
+     *
+     * @example
+     * Usage example
+     * ```
+     *   dataType() {
+     *     return 'boolean';
+     *   },
+     * ```
+     * Or
+     * ```
+     *   dataType(config) {
+     * 	   return typeof config.length !== 'undefined' ? `varchar(${config.length})` : `varchar`;
+     * 	 }
+     * ```
+     */
+    dataType: (config: T['config'] | (Equal<T['configRequired'], true> extends true ? never : undefined)) => string;
+    /**
+     * Optional mapping function, between user input and driver
+     * @example
+     * For example, when using jsonb we need to map JS/TS object to string before writing to database
+     * ```
+     * toDriver(value: TData): string {
+     * 	 return JSON.stringify(value);
+     * }
+     * ```
+     */
+    toDriver?: (value: T['data']) => T['driverData'] | SQL;
+    /**
+     * Optional mapping function, that is responsible for data mapping from database to JS/TS code
+     * @example
+     * For example, when using timestamp we need to map string Date representation to JS Date
+     * ```
+     * fromDriver(value: string): Date {
+     * 	return new Date(value);
+     * },
+     * ```
+     */
+    fromDriver?: (value: T['driverData']) => T['data'];
+}
+/**
+ * Custom pg database data type generator
+ */
+export 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>>;

package/pg-core/columns/custom.d.mts

@@ -0,0 +1,148 @@
+import type { ColumnBuilderBaseConfig } from '../../column-builder.js';
+import type { ColumnBaseConfig } from '../../column.js';
+import { entityKind } from '../../entity.js';
+import type { AnyPgTable } from '../table.js';
+import type { SQL } from '../../sql/index.js';
+import { type Equal } from '../../utils.js';
+import { PgColumn, PgColumnBuilder } from './common.js';
+export type ConvertCustomConfig<TName extends string, T extends Partial<CustomTypeValues>> = {
+    name: TName;
+    dataType: 'custom';
+    columnType: 'PgCustomColumn';
+    data: T['data'];
+    driverParam: T['driverData'];
+    enumValues: undefined;
+} & (T['notNull'] extends true ? {
+    notNull: true;
+} : {}) & (T['default'] extends true ? {
+    hasDefault: true;
+} : {});
+export interface PgCustomColumnInnerConfig {
+    customTypeValues: CustomTypeValues;
+}
+export declare class PgCustomColumnBuilder<T extends ColumnBuilderBaseConfig<'custom', 'PgCustomColumn'>> extends PgColumnBuilder<T, {
+    fieldConfig: CustomTypeValues['config'];
+    customTypeParams: CustomTypeParams<any>;
+}, {
+    pgColumnBuilderBrand: 'PgCustomColumnBuilderBrand';
+}> {
+    static readonly [entityKind]: string;
+    constructor(name: T['name'], fieldConfig: CustomTypeValues['config'], customTypeParams: CustomTypeParams<any>);
+}
+export declare class PgCustomColumn<T extends ColumnBaseConfig<'custom', 'PgCustomColumn'>> extends PgColumn<T> {
+    static readonly [entityKind]: string;
+    private sqlName;
+    private mapTo?;
+    private mapFrom?;
+    constructor(table: AnyPgTable<{
+        name: T['tableName'];
+    }>, config: PgCustomColumnBuilder<T>['config']);
+    getSQLType(): string;
+    mapFromDriverValue(value: T['driverParam']): T['data'];
+    mapToDriverValue(value: T['data']): T['driverParam'];
+}
+export type CustomTypeValues = {
+    /**
+     * Required type for custom column, that will infer proper type model
+     *
+     * Examples:
+     *
+     * If you want your column to be `string` type after selecting/or on inserting - use `data: string`. Like `text`, `varchar`
+     *
+     * If you want your column to be `number` type after selecting/or on inserting - use `data: number`. Like `integer`
+     */
+    data: unknown;
+    /**
+     * Type helper, that represents what type database driver is accepting for specific database data type
+     */
+    driverData?: unknown;
+    /**
+     * What config type should be used for {@link CustomTypeParams} `dataType` generation
+     */
+    config?: unknown;
+    /**
+     * Whether the config argument should be required or not
+     * @default false
+     */
+    configRequired?: boolean;
+    /**
+     * If your custom data type should be notNull by default you can use `notNull: true`
+     *
+     * @example
+     * const customSerial = customType<{ data: number, notNull: true, default: true }>({
+     * 	  dataType() {
+     * 	    return 'serial';
+     *    },
+     * });
+     */
+    notNull?: boolean;
+    /**
+     * If your custom data type has default you can use `default: true`
+     *
+     * @example
+     * const customSerial = customType<{ data: number, notNull: true, default: true }>({
+     * 	  dataType() {
+     * 	    return 'serial';
+     *    },
+     * });
+     */
+    default?: boolean;
+};
+export interface CustomTypeParams<T extends CustomTypeValues> {
+    /**
+     * Database data type string representation, that is used for migrations
+     * @example
+     * ```
+     * `jsonb`, `text`
+     * ```
+     *
+     * If database data type needs additional params you can use them from `config` param
+     * @example
+     * ```
+     * `varchar(256)`, `numeric(2,3)`
+     * ```
+     *
+     * To make `config` be of specific type please use config generic in {@link CustomTypeValues}
+     *
+     * @example
+     * Usage example
+     * ```
+     *   dataType() {
+     *     return 'boolean';
+     *   },
+     * ```
+     * Or
+     * ```
+     *   dataType(config) {
+     * 	   return typeof config.length !== 'undefined' ? `varchar(${config.length})` : `varchar`;
+     * 	 }
+     * ```
+     */
+    dataType: (config: T['config'] | (Equal<T['configRequired'], true> extends true ? never : undefined)) => string;
+    /**
+     * Optional mapping function, between user input and driver
+     * @example
+     * For example, when using jsonb we need to map JS/TS object to string before writing to database
+     * ```
+     * toDriver(value: TData): string {
+     * 	 return JSON.stringify(value);
+     * }
+     * ```
+     */
+    toDriver?: (value: T['data']) => T['driverData'] | SQL;
+    /**
+     * Optional mapping function, that is responsible for data mapping from database to JS/TS code
+     * @example
+     * For example, when using timestamp we need to map string Date representation to JS Date
+     * ```
+     * fromDriver(value: string): Date {
+     * 	return new Date(value);
+     * },
+     * ```
+     */
+    fromDriver?: (value: T['driverData']) => T['data'];
+}
+/**
+ * Custom pg database data type generator
+ */
+export 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>>;

package/pg-core/columns/custom.d.ts

@@ -1,10 +1,10 @@
-import type { ColumnBaseConfig } from '../../column';
-import type { ColumnBuilderBaseConfig } from '../../column-builder';
-import { entityKind } from '../../entity';
-import type { AnyPgTable } from '../table';
-import type { SQL } from '../../sql';
-import { type Equal } from '../../utils';
-import { PgColumn, PgColumnBuilder } from './common';
+import type { ColumnBuilderBaseConfig } from '../../column-builder.js';
+import type { ColumnBaseConfig } from '../../column.js';
+import { entityKind } from '../../entity.js';
+import type { AnyPgTable } from '../table.js';
+import type { SQL } from '../../sql/index.js';
+import { type Equal } from '../../utils.js';
+import { PgColumn, PgColumnBuilder } from './common.js';
 export type ConvertCustomConfig<TName extends string, T extends Partial<CustomTypeValues>> = {
     name: TName;
     dataType: 'custom';

package/pg-core/columns/date.common.d.cts

@@ -0,0 +1,7 @@
+import type { ColumnBuilderBaseConfig, ColumnDataType } from '../../column-builder.js';
+import { entityKind } from '../../entity.js';
+import { PgColumnBuilder } from './common.js';
+export declare abstract class PgDateColumnBaseBuilder<T extends ColumnBuilderBaseConfig<ColumnDataType, string>, TRuntimeConfig extends object = object> extends PgColumnBuilder<T, TRuntimeConfig> {
+    static readonly [entityKind]: string;
+    defaultNow(): import("../../column-builder.js").HasDefault<this>;
+}

package/pg-core/columns/date.common.d.mts

@@ -0,0 +1,7 @@
+import type { ColumnBuilderBaseConfig, ColumnDataType } from '../../column-builder.js';
+import { entityKind } from '../../entity.js';
+import { PgColumnBuilder } from './common.js';
+export declare abstract class PgDateColumnBaseBuilder<T extends ColumnBuilderBaseConfig<ColumnDataType, string>, TRuntimeConfig extends object = object> extends PgColumnBuilder<T, TRuntimeConfig> {
+    static readonly [entityKind]: string;
+    defaultNow(): import("../../column-builder.js").HasDefault<this>;
+}

package/pg-core/columns/date.common.d.ts

@@ -1,7 +1,7 @@
-import type { ColumnBuilderBaseConfig, ColumnDataType } from '../../column-builder';
-import { entityKind } from '../../entity';
-import { PgColumnBuilder } from './common';
+import type { ColumnBuilderBaseConfig, ColumnDataType } from '../../column-builder.js';
+import { entityKind } from '../../entity.js';
+import { PgColumnBuilder } from './common.js';
 export declare abstract class PgDateColumnBaseBuilder<T extends ColumnBuilderBaseConfig<ColumnDataType, string>, TRuntimeConfig extends object = object> extends PgColumnBuilder<T, TRuntimeConfig> {
     static readonly [entityKind]: string;
-    defaultNow(): import("../../column-builder").HasDefault<this>;
+    defaultNow(): import("../../column-builder.js").HasDefault<this>;
 }

package/pg-core/columns/date.d.cts

@@ -0,0 +1,45 @@
+import type { ColumnBuilderBaseConfig } from '../../column-builder.js';
+import type { ColumnBaseConfig } from '../../column.js';
+import { entityKind } from '../../entity.js';
+import { PgColumn } from './common.js';
+import { PgDateColumnBaseBuilder } from './date.common.js';
+export type PgDateBuilderInitial<TName extends string> = PgDateBuilder<{
+    name: TName;
+    dataType: 'date';
+    columnType: 'PgDate';
+    data: Date;
+    driverParam: string;
+    enumValues: undefined;
+}>;
+export declare class PgDateBuilder<T extends ColumnBuilderBaseConfig<'date', 'PgDate'>> extends PgDateColumnBaseBuilder<T> {
+    static readonly [entityKind]: string;
+    constructor(name: T['name']);
+}
+export 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;
+}
+export type PgDateStringBuilderInitial<TName extends string> = PgDateStringBuilder<{
+    name: TName;
+    dataType: 'string';
+    columnType: 'PgDateString';
+    data: string;
+    driverParam: string;
+    enumValues: undefined;
+}>;
+export declare class PgDateStringBuilder<T extends ColumnBuilderBaseConfig<'string', 'PgDateString'>> extends PgDateColumnBaseBuilder<T> {
+    static readonly [entityKind]: string;
+    constructor(name: T['name']);
+}
+export declare class PgDateString<T extends ColumnBaseConfig<'string', 'PgDateString'>> extends PgColumn<T> {
+    static readonly [entityKind]: string;
+    getSQLType(): string;
+}
+export declare function date<TName extends string>(name: TName, config?: {
+    mode: 'string';
+}): PgDateStringBuilderInitial<TName>;
+export declare function date<TName extends string>(TName: TName, config?: {
+    mode: 'date';
+}): PgDateBuilderInitial<TName>;

package/pg-core/columns/date.d.mts

@@ -0,0 +1,45 @@
+import type { ColumnBuilderBaseConfig } from '../../column-builder.js';
+import type { ColumnBaseConfig } from '../../column.js';
+import { entityKind } from '../../entity.js';
+import { PgColumn } from './common.js';
+import { PgDateColumnBaseBuilder } from './date.common.js';
+export type PgDateBuilderInitial<TName extends string> = PgDateBuilder<{
+    name: TName;
+    dataType: 'date';
+    columnType: 'PgDate';
+    data: Date;
+    driverParam: string;
+    enumValues: undefined;
+}>;
+export declare class PgDateBuilder<T extends ColumnBuilderBaseConfig<'date', 'PgDate'>> extends PgDateColumnBaseBuilder<T> {
+    static readonly [entityKind]: string;
+    constructor(name: T['name']);
+}
+export 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;
+}
+export type PgDateStringBuilderInitial<TName extends string> = PgDateStringBuilder<{
+    name: TName;
+    dataType: 'string';
+    columnType: 'PgDateString';
+    data: string;
+    driverParam: string;
+    enumValues: undefined;
+}>;
+export declare class PgDateStringBuilder<T extends ColumnBuilderBaseConfig<'string', 'PgDateString'>> extends PgDateColumnBaseBuilder<T> {
+    static readonly [entityKind]: string;
+    constructor(name: T['name']);
+}
+export declare class PgDateString<T extends ColumnBaseConfig<'string', 'PgDateString'>> extends PgColumn<T> {
+    static readonly [entityKind]: string;
+    getSQLType(): string;
+}
+export declare function date<TName extends string>(name: TName, config?: {
+    mode: 'string';
+}): PgDateStringBuilderInitial<TName>;
+export declare function date<TName extends string>(TName: TName, config?: {
+    mode: 'date';
+}): PgDateBuilderInitial<TName>;

package/pg-core/columns/date.d.ts

@@ -1,8 +1,8 @@
-import type { ColumnBaseConfig } from '../../column';
-import type { ColumnBuilderBaseConfig } from '../../column-builder';
-import { entityKind } from '../../entity';
-import { PgColumn } from './common';
-import { PgDateColumnBaseBuilder } from './date.common';
+import type { ColumnBuilderBaseConfig } from '../../column-builder.js';
+import type { ColumnBaseConfig } from '../../column.js';
+import { entityKind } from '../../entity.js';
+import { PgColumn } from './common.js';
+import { PgDateColumnBaseBuilder } from './date.common.js';
 export type PgDateBuilderInitial<TName extends string> = PgDateBuilder<{
     name: TName;
     dataType: 'date';

package/pg-core/columns/double-precision.d.cts

@@ -0,0 +1,22 @@
+import type { ColumnBuilderBaseConfig } from '../../column-builder.js';
+import type { ColumnBaseConfig } from '../../column.js';
+import { entityKind } from '../../entity.js';
+import { PgColumn, PgColumnBuilder } from './common.js';
+export type PgDoublePrecisionBuilderInitial<TName extends string> = PgDoublePrecisionBuilder<{
+    name: TName;
+    dataType: 'number';
+    columnType: 'PgDoublePrecision';
+    data: number;
+    driverParam: string | number;
+    enumValues: undefined;
+}>;
+export declare class PgDoublePrecisionBuilder<T extends ColumnBuilderBaseConfig<'number', 'PgDoublePrecision'>> extends PgColumnBuilder<T> {
+    static readonly [entityKind]: string;
+    constructor(name: T['name']);
+}
+export declare class PgDoublePrecision<T extends ColumnBaseConfig<'number', 'PgDoublePrecision'>> extends PgColumn<T> {
+    static readonly [entityKind]: string;
+    getSQLType(): string;
+    mapFromDriverValue(value: string | number): number;
+}
+export declare function doublePrecision<TName extends string>(name: TName): PgDoublePrecisionBuilderInitial<TName>;

package/pg-core/columns/double-precision.d.mts

@@ -0,0 +1,22 @@
+import type { ColumnBuilderBaseConfig } from '../../column-builder.js';
+import type { ColumnBaseConfig } from '../../column.js';
+import { entityKind } from '../../entity.js';
+import { PgColumn, PgColumnBuilder } from './common.js';
+export type PgDoublePrecisionBuilderInitial<TName extends string> = PgDoublePrecisionBuilder<{
+    name: TName;
+    dataType: 'number';
+    columnType: 'PgDoublePrecision';
+    data: number;
+    driverParam: string | number;
+    enumValues: undefined;
+}>;
+export declare class PgDoublePrecisionBuilder<T extends ColumnBuilderBaseConfig<'number', 'PgDoublePrecision'>> extends PgColumnBuilder<T> {
+    static readonly [entityKind]: string;
+    constructor(name: T['name']);
+}
+export declare class PgDoublePrecision<T extends ColumnBaseConfig<'number', 'PgDoublePrecision'>> extends PgColumn<T> {
+    static readonly [entityKind]: string;
+    getSQLType(): string;
+    mapFromDriverValue(value: string | number): number;
+}
+export declare function doublePrecision<TName extends string>(name: TName): PgDoublePrecisionBuilderInitial<TName>;

package/pg-core/columns/double-precision.d.ts

@@ -1,7 +1,7 @@
-import type { ColumnBaseConfig } from '../../column';
-import type { ColumnBuilderBaseConfig } from '../../column-builder';
-import { entityKind } from '../../entity';
-import { PgColumn, PgColumnBuilder } from './common';
+import type { ColumnBuilderBaseConfig } from '../../column-builder.js';
+import type { ColumnBaseConfig } from '../../column.js';
+import { entityKind } from '../../entity.js';
+import { PgColumn, PgColumnBuilder } from './common.js';
 export type PgDoublePrecisionBuilderInitial<TName extends string> = PgDoublePrecisionBuilder<{
     name: TName;
     dataType: 'number';

package/pg-core/columns/enum.d.cts

@@ -0,0 +1,42 @@
+import type { ColumnBuilderBaseConfig } from '../../column-builder.js';
+import type { ColumnBaseConfig } from '../../column.js';
+import { entityKind } from '../../entity.js';
+import type { AnyPgTable } from '../table.js';
+import { type Writable } from '../../utils.js';
+import { PgColumn, PgColumnBuilder } from './common.js';
+export type PgEnumColumnBuilderInitial<TName extends string, TValues extends [string, ...string[]]> = PgEnumColumnBuilder<{
+    name: TName;
+    dataType: 'string';
+    columnType: 'PgEnumColumn';
+    data: TValues[number];
+    enumValues: TValues;
+    driverParam: string;
+}>;
+export interface PgEnum<TValues extends [string, ...string[]]> {
+    <TName extends string>(name: TName): PgEnumColumnBuilderInitial<TName, TValues>;
+    readonly enumName: string;
+    readonly enumValues: TValues;
+}
+export declare function isPgEnum(obj: unknown): obj is PgEnum<[string, ...string[]]>;
+export 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']>);
+}
+export declare class PgEnumColumn<T extends ColumnBaseConfig<'string', 'PgEnumColumn'> & {
+    enumValues: [string, ...string[]];
+}> extends PgColumn<T, {
+    enum: PgEnum<T['enumValues']>;
+}> {
+    static readonly [entityKind]: string;
+    readonly enum: PgEnum<T["enumValues"]>;
+    readonly enumValues: T["enumValues"];
+    constructor(table: AnyPgTable<{
+        name: T['tableName'];
+    }>, config: PgEnumColumnBuilder<T>['config']);
+    getSQLType(): string;
+}
+export declare function pgEnum<U extends string, T extends Readonly<[U, ...U[]]>>(enumName: string, values: T | Writable<T>): PgEnum<Writable<T>>;

package/pg-core/columns/enum.d.mts

@@ -0,0 +1,42 @@
+import type { ColumnBuilderBaseConfig } from '../../column-builder.js';
+import type { ColumnBaseConfig } from '../../column.js';
+import { entityKind } from '../../entity.js';
+import type { AnyPgTable } from '../table.js';
+import { type Writable } from '../../utils.js';
+import { PgColumn, PgColumnBuilder } from './common.js';
+export type PgEnumColumnBuilderInitial<TName extends string, TValues extends [string, ...string[]]> = PgEnumColumnBuilder<{
+    name: TName;
+    dataType: 'string';
+    columnType: 'PgEnumColumn';
+    data: TValues[number];
+    enumValues: TValues;
+    driverParam: string;
+}>;
+export interface PgEnum<TValues extends [string, ...string[]]> {
+    <TName extends string>(name: TName): PgEnumColumnBuilderInitial<TName, TValues>;
+    readonly enumName: string;
+    readonly enumValues: TValues;
+}
+export declare function isPgEnum(obj: unknown): obj is PgEnum<[string, ...string[]]>;
+export 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']>);
+}
+export declare class PgEnumColumn<T extends ColumnBaseConfig<'string', 'PgEnumColumn'> & {
+    enumValues: [string, ...string[]];
+}> extends PgColumn<T, {
+    enum: PgEnum<T['enumValues']>;
+}> {
+    static readonly [entityKind]: string;
+    readonly enum: PgEnum<T["enumValues"]>;
+    readonly enumValues: T["enumValues"];
+    constructor(table: AnyPgTable<{
+        name: T['tableName'];
+    }>, config: PgEnumColumnBuilder<T>['config']);
+    getSQLType(): string;
+}
+export declare function pgEnum<U extends string, T extends Readonly<[U, ...U[]]>>(enumName: string, values: T | Writable<T>): PgEnum<Writable<T>>;

package/pg-core/columns/enum.d.ts

@@ -1,9 +1,9 @@
-import type { ColumnBaseConfig } from '../../column';
-import type { ColumnBuilderBaseConfig } from '../../column-builder';
-import { entityKind } from '../../entity';
-import type { AnyPgTable } from '../table';
-import { type Writable } from '../../utils';
-import { PgColumn, PgColumnBuilder } from './common';
+import type { ColumnBuilderBaseConfig } from '../../column-builder.js';
+import type { ColumnBaseConfig } from '../../column.js';
+import { entityKind } from '../../entity.js';
+import type { AnyPgTable } from '../table.js';
+import { type Writable } from '../../utils.js';
+import { PgColumn, PgColumnBuilder } from './common.js';
 export type PgEnumColumnBuilderInitial<TName extends string, TValues extends [string, ...string[]]> = PgEnumColumnBuilder<{
     name: TName;
     dataType: 'string';

package/pg-core/columns/index.d.cts

@@ -0,0 +1,28 @@
+export * from './array.js';
+export * from './bigint.js';
+export * from './bigserial.js';
+export * from './boolean.js';
+export * from './char.js';
+export * from './cidr.js';
+export * from './common.js';
+export * from './custom.js';
+export * from './date.js';
+export * from './double-precision.js';
+export * from './enum.js';
+export * from './inet.js';
+export * from './integer.js';
+export * from './interval.js';
+export * from './json.js';
+export * from './jsonb.js';
+export * from './macaddr.js';
+export * from './macaddr8.js';
+export * from './numeric.js';
+export * from './real.js';
+export * from './serial.js';
+export * from './smallint.js';
+export * from './smallserial.js';
+export * from './text.js';
+export * from './time.js';
+export * from './timestamp.js';
+export * from './uuid.js';
+export * from './varchar.js';