drizzle-orm 0.28.3 → 0.28.4

package/pg-core/columns/uuid.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 PgUUIDBuilderInitial<TName extends string> = PgUUIDBuilder<{
     name: TName;
     dataType: 'string';

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

@@ -0,0 +1,34 @@
+import type { ColumnBuilderBaseConfig } from '../../column-builder.js';
+import type { ColumnBaseConfig } from '../../column.js';
+import { entityKind } from '../../entity.js';
+import { type Writable } from '../../utils.js';
+import { PgColumn, PgColumnBuilder } from './common.js';
+export type PgVarcharBuilderInitial<TName extends string, TEnum extends [string, ...string[]]> = PgVarcharBuilder<{
+    name: TName;
+    dataType: 'string';
+    columnType: 'PgVarchar';
+    data: TEnum[number];
+    driverParam: string;
+    enumValues: TEnum;
+}>;
+export declare class PgVarcharBuilder<T extends ColumnBuilderBaseConfig<'string', 'PgVarchar'>> extends PgColumnBuilder<T, {
+    length: number | undefined;
+    enumValues: T['enumValues'];
+}> {
+    static readonly [entityKind]: string;
+    constructor(name: string, config: PgVarcharConfig<T['enumValues']>);
+}
+export declare class PgVarchar<T extends ColumnBaseConfig<'string', 'PgVarchar'>> extends PgColumn<T, {
+    length: number | undefined;
+    enumValues: T['enumValues'];
+}> {
+    static readonly [entityKind]: string;
+    readonly length: number | undefined;
+    readonly enumValues: T["enumValues"];
+    getSQLType(): string;
+}
+export interface PgVarcharConfig<TEnum extends readonly string[] | string[] | undefined> {
+    length?: number;
+    enum?: TEnum;
+}
+export 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>>;

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

@@ -0,0 +1,34 @@
+import type { ColumnBuilderBaseConfig } from '../../column-builder.js';
+import type { ColumnBaseConfig } from '../../column.js';
+import { entityKind } from '../../entity.js';
+import { type Writable } from '../../utils.js';
+import { PgColumn, PgColumnBuilder } from './common.js';
+export type PgVarcharBuilderInitial<TName extends string, TEnum extends [string, ...string[]]> = PgVarcharBuilder<{
+    name: TName;
+    dataType: 'string';
+    columnType: 'PgVarchar';
+    data: TEnum[number];
+    driverParam: string;
+    enumValues: TEnum;
+}>;
+export declare class PgVarcharBuilder<T extends ColumnBuilderBaseConfig<'string', 'PgVarchar'>> extends PgColumnBuilder<T, {
+    length: number | undefined;
+    enumValues: T['enumValues'];
+}> {
+    static readonly [entityKind]: string;
+    constructor(name: string, config: PgVarcharConfig<T['enumValues']>);
+}
+export declare class PgVarchar<T extends ColumnBaseConfig<'string', 'PgVarchar'>> extends PgColumn<T, {
+    length: number | undefined;
+    enumValues: T['enumValues'];
+}> {
+    static readonly [entityKind]: string;
+    readonly length: number | undefined;
+    readonly enumValues: T["enumValues"];
+    getSQLType(): string;
+}
+export interface PgVarcharConfig<TEnum extends readonly string[] | string[] | undefined> {
+    length?: number;
+    enum?: TEnum;
+}
+export 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>>;

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

@@ -1,8 +1,8 @@
-import type { ColumnBaseConfig } from '../../column';
-import type { ColumnBuilderBaseConfig } from '../../column-builder';
-import { entityKind } from '../../entity';
-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 Writable } from '../../utils.js';
+import { PgColumn, PgColumnBuilder } from './common.js';
 export type PgVarcharBuilderInitial<TName extends string, TEnum extends [string, ...string[]]> = PgVarcharBuilder<{
     name: TName;
     dataType: 'string';

package/pg-core/db.d.cts

@@ -0,0 +1,53 @@
+import { entityKind } from '../entity.js';
+import type { PgDialect } from './dialect.js';
+import { PgDelete, PgInsertBuilder, PgSelectBuilder, PgUpdateBuilder, QueryBuilder } from './query-builders/index.js';
+import type { PgSession, PgTransaction, PgTransactionConfig, QueryResultHKT, QueryResultKind } from './session.js';
+import { type PgTable } from './table.js';
+import type { TypedQueryBuilder } from '../query-builders/query-builder.js';
+import { type ExtractTablesWithRelations, type RelationalSchemaConfig, type TablesRelationalConfig } from '../relations.js';
+import { type SQLWrapper } from '../sql/index.js';
+import { WithSubquery } from '../subquery.js';
+import { type DrizzleTypeError } from '../utils.js';
+import { type ColumnsSelection } from '../view.js';
+import { type PgColumn } from './columns/index.js';
+import { RelationalQueryBuilder } from './query-builders/query.js';
+import { PgRefreshMaterializedView } from './query-builders/refresh-materialized-view.js';
+import type { SelectedFields } from './query-builders/select.types.js';
+import type { WithSubqueryWithSelection } from './subquery.js';
+import type { PgMaterializedView } from './view.js';
+export declare class PgDatabase<TQueryResult extends QueryResultHKT, TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>> {
+    static readonly [entityKind]: string;
+    readonly _: {
+        readonly schema: TSchema | undefined;
+        readonly tableNamesMap: Record<string, string>;
+    };
+    query: TFullSchema extends Record<string, never> ? DrizzleTypeError<'Seems like the schema generic is missing - did you forget to add it to your DB type?'> : {
+        [K in keyof TSchema]: RelationalQueryBuilder<TSchema, TSchema[K]>;
+    };
+    constructor(
+    /** @internal */
+    dialect: PgDialect, 
+    /** @internal */
+    session: PgSession<any, any, any>, schema: RelationalSchemaConfig<TSchema> | undefined);
+    $with<TAlias extends string>(alias: TAlias): {
+        as<TSelection extends ColumnsSelection>(qb: TypedQueryBuilder<TSelection, unknown> | ((qb: QueryBuilder) => TypedQueryBuilder<TSelection, unknown>)): WithSubqueryWithSelection<TSelection, TAlias>;
+    };
+    with(...queries: WithSubquery[]): {
+        select: {
+            (): PgSelectBuilder<undefined>;
+            <TSelection extends SelectedFields>(fields: TSelection): PgSelectBuilder<TSelection, "db">;
+        };
+    };
+    select(): PgSelectBuilder<undefined>;
+    select<TSelection extends SelectedFields>(fields: TSelection): PgSelectBuilder<TSelection>;
+    selectDistinct(): PgSelectBuilder<undefined>;
+    selectDistinct<TSelection extends SelectedFields>(fields: TSelection): PgSelectBuilder<TSelection>;
+    selectDistinctOn(on: (PgColumn | SQLWrapper)[]): PgSelectBuilder<undefined>;
+    selectDistinctOn<TSelection extends SelectedFields>(on: (PgColumn | SQLWrapper)[], fields: TSelection): PgSelectBuilder<TSelection>;
+    update<TTable extends PgTable>(table: TTable): PgUpdateBuilder<TTable, TQueryResult>;
+    insert<TTable extends PgTable>(table: TTable): PgInsertBuilder<TTable, TQueryResult>;
+    delete<TTable extends PgTable>(table: TTable): PgDelete<TTable, TQueryResult>;
+    refreshMaterializedView<TView extends PgMaterializedView>(view: TView): PgRefreshMaterializedView<TQueryResult>;
+    execute<TRow extends Record<string, unknown> = Record<string, unknown>>(query: SQLWrapper): Promise<QueryResultKind<TQueryResult, TRow>>;
+    transaction<T>(transaction: (tx: PgTransaction<TQueryResult, TFullSchema, TSchema>) => Promise<T>, config?: PgTransactionConfig): Promise<T>;
+}

package/pg-core/db.d.mts

@@ -0,0 +1,53 @@
+import { entityKind } from '../entity.js';
+import type { PgDialect } from './dialect.js';
+import { PgDelete, PgInsertBuilder, PgSelectBuilder, PgUpdateBuilder, QueryBuilder } from './query-builders/index.js';
+import type { PgSession, PgTransaction, PgTransactionConfig, QueryResultHKT, QueryResultKind } from './session.js';
+import { type PgTable } from './table.js';
+import type { TypedQueryBuilder } from '../query-builders/query-builder.js';
+import { type ExtractTablesWithRelations, type RelationalSchemaConfig, type TablesRelationalConfig } from '../relations.js';
+import { type SQLWrapper } from '../sql/index.js';
+import { WithSubquery } from '../subquery.js';
+import { type DrizzleTypeError } from '../utils.js';
+import { type ColumnsSelection } from '../view.js';
+import { type PgColumn } from './columns/index.js';
+import { RelationalQueryBuilder } from './query-builders/query.js';
+import { PgRefreshMaterializedView } from './query-builders/refresh-materialized-view.js';
+import type { SelectedFields } from './query-builders/select.types.js';
+import type { WithSubqueryWithSelection } from './subquery.js';
+import type { PgMaterializedView } from './view.js';
+export declare class PgDatabase<TQueryResult extends QueryResultHKT, TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>> {
+    static readonly [entityKind]: string;
+    readonly _: {
+        readonly schema: TSchema | undefined;
+        readonly tableNamesMap: Record<string, string>;
+    };
+    query: TFullSchema extends Record<string, never> ? DrizzleTypeError<'Seems like the schema generic is missing - did you forget to add it to your DB type?'> : {
+        [K in keyof TSchema]: RelationalQueryBuilder<TSchema, TSchema[K]>;
+    };
+    constructor(
+    /** @internal */
+    dialect: PgDialect, 
+    /** @internal */
+    session: PgSession<any, any, any>, schema: RelationalSchemaConfig<TSchema> | undefined);
+    $with<TAlias extends string>(alias: TAlias): {
+        as<TSelection extends ColumnsSelection>(qb: TypedQueryBuilder<TSelection, unknown> | ((qb: QueryBuilder) => TypedQueryBuilder<TSelection, unknown>)): WithSubqueryWithSelection<TSelection, TAlias>;
+    };
+    with(...queries: WithSubquery[]): {
+        select: {
+            (): PgSelectBuilder<undefined>;
+            <TSelection extends SelectedFields>(fields: TSelection): PgSelectBuilder<TSelection, "db">;
+        };
+    };
+    select(): PgSelectBuilder<undefined>;
+    select<TSelection extends SelectedFields>(fields: TSelection): PgSelectBuilder<TSelection>;
+    selectDistinct(): PgSelectBuilder<undefined>;
+    selectDistinct<TSelection extends SelectedFields>(fields: TSelection): PgSelectBuilder<TSelection>;
+    selectDistinctOn(on: (PgColumn | SQLWrapper)[]): PgSelectBuilder<undefined>;
+    selectDistinctOn<TSelection extends SelectedFields>(on: (PgColumn | SQLWrapper)[], fields: TSelection): PgSelectBuilder<TSelection>;
+    update<TTable extends PgTable>(table: TTable): PgUpdateBuilder<TTable, TQueryResult>;
+    insert<TTable extends PgTable>(table: TTable): PgInsertBuilder<TTable, TQueryResult>;
+    delete<TTable extends PgTable>(table: TTable): PgDelete<TTable, TQueryResult>;
+    refreshMaterializedView<TView extends PgMaterializedView>(view: TView): PgRefreshMaterializedView<TQueryResult>;
+    execute<TRow extends Record<string, unknown> = Record<string, unknown>>(query: SQLWrapper): Promise<QueryResultKind<TQueryResult, TRow>>;
+    transaction<T>(transaction: (tx: PgTransaction<TQueryResult, TFullSchema, TSchema>) => Promise<T>, config?: PgTransactionConfig): Promise<T>;
+}

package/pg-core/db.d.ts

@@ -1,20 +1,20 @@
-import { entityKind } from '../entity';
-import type { PgDialect } from './dialect';
-import { PgDelete, PgInsertBuilder, PgSelectBuilder, PgUpdateBuilder, QueryBuilder } from './query-builders';
-import type { PgSession, PgTransaction, PgTransactionConfig, QueryResultHKT, QueryResultKind } from './session';
-import { type PgTable } from './table';
-import type { TypedQueryBuilder } from '../query-builders/query-builder';
-import { type ExtractTablesWithRelations, type RelationalSchemaConfig, type TablesRelationalConfig } from '../relations';
-import { type SQLWrapper } from '../sql';
-import { WithSubquery } from '../subquery';
-import { type DrizzleTypeError } from '../utils';
-import { type ColumnsSelection } from '../view';
-import { type PgColumn } from './columns';
-import { RelationalQueryBuilder } from './query-builders/query';
-import { PgRefreshMaterializedView } from './query-builders/refresh-materialized-view';
-import type { SelectedFields } from './query-builders/select.types';
-import type { WithSubqueryWithSelection } from './subquery';
-import type { PgMaterializedView } from './view';
+import { entityKind } from '../entity.js';
+import type { PgDialect } from './dialect.js';
+import { PgDelete, PgInsertBuilder, PgSelectBuilder, PgUpdateBuilder, QueryBuilder } from './query-builders/index.js';
+import type { PgSession, PgTransaction, PgTransactionConfig, QueryResultHKT, QueryResultKind } from './session.js';
+import { type PgTable } from './table.js';
+import type { TypedQueryBuilder } from '../query-builders/query-builder.js';
+import { type ExtractTablesWithRelations, type RelationalSchemaConfig, type TablesRelationalConfig } from '../relations.js';
+import { type SQLWrapper } from '../sql/index.js';
+import { WithSubquery } from '../subquery.js';
+import { type DrizzleTypeError } from '../utils.js';
+import { type ColumnsSelection } from '../view.js';
+import { type PgColumn } from './columns/index.js';
+import { RelationalQueryBuilder } from './query-builders/query.js';
+import { PgRefreshMaterializedView } from './query-builders/refresh-materialized-view.js';
+import type { SelectedFields } from './query-builders/select.types.js';
+import type { WithSubqueryWithSelection } from './subquery.js';
+import type { PgMaterializedView } from './view.js';
 export declare class PgDatabase<TQueryResult extends QueryResultHKT, TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>> {
     static readonly [entityKind]: string;
     readonly _: {

package/pg-core/dialect.d.cts

@@ -0,0 +1,53 @@
+import { entityKind } from '../entity.js';
+import type { MigrationMeta } from '../migrator.js';
+import { PgColumn } from './columns/index.js';
+import type { PgDeleteConfig, PgInsertConfig, PgUpdateConfig } from './query-builders/index.js';
+import type { PgSelectConfig } from './query-builders/select.types.js';
+import { PgTable } from './table.js';
+import { type BuildRelationalQueryResult, type DBQueryConfig, type Relation, type TableRelationalConfig, type TablesRelationalConfig } from '../relations.js';
+import { type DriverValueEncoder, type Query, type QueryTypingsValue, SQL } from '../sql/index.js';
+import { type UpdateSet } from '../utils.js';
+import type { PgSession } from './session.js';
+import { type PgMaterializedView } from './view.js';
+export declare class PgDialect {
+    static readonly [entityKind]: string;
+    migrate(migrations: MigrationMeta[], session: PgSession): Promise<void>;
+    escapeName(name: string): string;
+    escapeParam(num: number): string;
+    escapeString(str: string): string;
+    buildDeleteQuery({ table, where, returning }: PgDeleteConfig): SQL;
+    buildUpdateSet(table: PgTable, set: UpdateSet): SQL;
+    buildUpdateQuery({ table, set, where, returning }: PgUpdateConfig): SQL;
+    /**
+     * Builds selection SQL with provided fields/expressions
+     *
+     * Examples:
+     *
+     * `select <selection> from`
+     *
+     * `insert ... returning <selection>`
+     *
+     * If `isSingleTable` is true, then columns won't be prefixed with table name
+     */
+    private buildSelection;
+    buildSelectQuery({ withList, fields, fieldsFlat, where, having, table, joins, orderBy, groupBy, limit, offset, lockingClauses, distinct, }: PgSelectConfig): SQL;
+    buildInsertQuery({ table, values, onConflict, returning }: PgInsertConfig): SQL;
+    buildRefreshMaterializedViewQuery({ view, concurrently, withNoData }: {
+        view: PgMaterializedView;
+        concurrently?: boolean;
+        withNoData?: boolean;
+    }): SQL;
+    prepareTyping(encoder: DriverValueEncoder<unknown, unknown>): QueryTypingsValue;
+    sqlToQuery(sql: SQL): Query;
+    buildRelationalQueryWithoutPK({ fullSchema, schema, tableNamesMap, table, tableConfig, queryConfig: config, tableAlias, nestedQueryRelation, joinOn, }: {
+        fullSchema: Record<string, unknown>;
+        schema: TablesRelationalConfig;
+        tableNamesMap: Record<string, string>;
+        table: PgTable;
+        tableConfig: TableRelationalConfig;
+        queryConfig: true | DBQueryConfig<'many', true>;
+        tableAlias: string;
+        nestedQueryRelation?: Relation;
+        joinOn?: SQL;
+    }): BuildRelationalQueryResult<PgTable, PgColumn>;
+}

package/pg-core/dialect.d.mts

@@ -0,0 +1,53 @@
+import { entityKind } from '../entity.js';
+import type { MigrationMeta } from '../migrator.js';
+import { PgColumn } from './columns/index.js';
+import type { PgDeleteConfig, PgInsertConfig, PgUpdateConfig } from './query-builders/index.js';
+import type { PgSelectConfig } from './query-builders/select.types.js';
+import { PgTable } from './table.js';
+import { type BuildRelationalQueryResult, type DBQueryConfig, type Relation, type TableRelationalConfig, type TablesRelationalConfig } from '../relations.js';
+import { type DriverValueEncoder, type Query, type QueryTypingsValue, SQL } from '../sql/index.js';
+import { type UpdateSet } from '../utils.js';
+import type { PgSession } from './session.js';
+import { type PgMaterializedView } from './view.js';
+export declare class PgDialect {
+    static readonly [entityKind]: string;
+    migrate(migrations: MigrationMeta[], session: PgSession): Promise<void>;
+    escapeName(name: string): string;
+    escapeParam(num: number): string;
+    escapeString(str: string): string;
+    buildDeleteQuery({ table, where, returning }: PgDeleteConfig): SQL;
+    buildUpdateSet(table: PgTable, set: UpdateSet): SQL;
+    buildUpdateQuery({ table, set, where, returning }: PgUpdateConfig): SQL;
+    /**
+     * Builds selection SQL with provided fields/expressions
+     *
+     * Examples:
+     *
+     * `select <selection> from`
+     *
+     * `insert ... returning <selection>`
+     *
+     * If `isSingleTable` is true, then columns won't be prefixed with table name
+     */
+    private buildSelection;
+    buildSelectQuery({ withList, fields, fieldsFlat, where, having, table, joins, orderBy, groupBy, limit, offset, lockingClauses, distinct, }: PgSelectConfig): SQL;
+    buildInsertQuery({ table, values, onConflict, returning }: PgInsertConfig): SQL;
+    buildRefreshMaterializedViewQuery({ view, concurrently, withNoData }: {
+        view: PgMaterializedView;
+        concurrently?: boolean;
+        withNoData?: boolean;
+    }): SQL;
+    prepareTyping(encoder: DriverValueEncoder<unknown, unknown>): QueryTypingsValue;
+    sqlToQuery(sql: SQL): Query;
+    buildRelationalQueryWithoutPK({ fullSchema, schema, tableNamesMap, table, tableConfig, queryConfig: config, tableAlias, nestedQueryRelation, joinOn, }: {
+        fullSchema: Record<string, unknown>;
+        schema: TablesRelationalConfig;
+        tableNamesMap: Record<string, string>;
+        table: PgTable;
+        tableConfig: TableRelationalConfig;
+        queryConfig: true | DBQueryConfig<'many', true>;
+        tableAlias: string;
+        nestedQueryRelation?: Relation;
+        joinOn?: SQL;
+    }): BuildRelationalQueryResult<PgTable, PgColumn>;
+}

package/pg-core/dialect.d.ts

@@ -1,14 +1,14 @@
-import { entityKind } from '../entity';
-import type { MigrationMeta } from '../migrator';
-import { PgColumn } from './columns';
-import type { PgDeleteConfig, PgInsertConfig, PgUpdateConfig } from './query-builders';
-import type { PgSelectConfig } from './query-builders/select.types';
-import { PgTable } from './table';
-import { type BuildRelationalQueryResult, type DBQueryConfig, type Relation, type TableRelationalConfig, type TablesRelationalConfig } from '../relations';
-import { type DriverValueEncoder, type Query, type QueryTypingsValue, SQL } from '../sql';
-import { type UpdateSet } from '../utils';
-import type { PgSession } from './session';
-import { type PgMaterializedView } from './view';
+import { entityKind } from '../entity.js';
+import type { MigrationMeta } from '../migrator.js';
+import { PgColumn } from './columns/index.js';
+import type { PgDeleteConfig, PgInsertConfig, PgUpdateConfig } from './query-builders/index.js';
+import type { PgSelectConfig } from './query-builders/select.types.js';
+import { PgTable } from './table.js';
+import { type BuildRelationalQueryResult, type DBQueryConfig, type Relation, type TableRelationalConfig, type TablesRelationalConfig } from '../relations.js';
+import { type DriverValueEncoder, type Query, type QueryTypingsValue, SQL } from '../sql/index.js';
+import { type UpdateSet } from '../utils.js';
+import type { PgSession } from './session.js';
+import { type PgMaterializedView } from './view.js';
 export declare class PgDialect {
     static readonly [entityKind]: string;
     migrate(migrations: MigrationMeta[], session: PgSession): Promise<void>;

package/pg-core/expressions.d.cts

@@ -0,0 +1,8 @@
+import type { PgColumn } from './columns/index.js';
+import type { Placeholder, SQL, SQLWrapper } from '../sql/index.js';
+export * from '../expressions.js';
+export declare function concat(column: PgColumn | SQL.Aliased, value: string | Placeholder | SQLWrapper): SQL;
+export declare function substring(column: PgColumn | SQL.Aliased, { from, for: _for }: {
+    from?: number | Placeholder | SQLWrapper;
+    for?: number | Placeholder | SQLWrapper;
+}): SQL;

package/pg-core/expressions.d.mts

@@ -0,0 +1,8 @@
+import type { PgColumn } from './columns/index.js';
+import type { Placeholder, SQL, SQLWrapper } from '../sql/index.js';
+export * from '../expressions.js';
+export declare function concat(column: PgColumn | SQL.Aliased, value: string | Placeholder | SQLWrapper): SQL;
+export declare function substring(column: PgColumn | SQL.Aliased, { from, for: _for }: {
+    from?: number | Placeholder | SQLWrapper;
+    for?: number | Placeholder | SQLWrapper;
+}): SQL;

package/pg-core/expressions.d.ts

@@ -1,6 +1,6 @@
-import type { PgColumn } from './columns';
-import type { Placeholder, SQL, SQLWrapper } from '../sql';
-export * from '../expressions';
+import type { PgColumn } from './columns/index.js';
+import type { Placeholder, SQL, SQLWrapper } from '../sql/index.js';
+export * from '../expressions.js';
 export declare function concat(column: PgColumn | SQL.Aliased, value: string | Placeholder | SQLWrapper): SQL;
 export declare function substring(column: PgColumn | SQL.Aliased, { from, for: _for }: {
     from?: number | Placeholder | SQLWrapper;

package/pg-core/foreign-keys.d.cts

@@ -0,0 +1,45 @@
+import { entityKind } from '../entity.js';
+import type { AnyPgColumn, PgColumn } from './columns/index.js';
+import { PgTable } from './table.js';
+export type UpdateDeleteAction = 'cascade' | 'restrict' | 'no action' | 'set null' | 'set default';
+export type Reference = () => {
+    readonly columns: PgColumn[];
+    readonly foreignTable: PgTable;
+    readonly foreignColumns: PgColumn[];
+};
+export declare class ForeignKeyBuilder {
+    static readonly [entityKind]: string;
+    constructor(config: () => {
+        columns: PgColumn[];
+        foreignColumns: PgColumn[];
+    }, actions?: {
+        onUpdate?: UpdateDeleteAction;
+        onDelete?: UpdateDeleteAction;
+    } | undefined);
+    onUpdate(action: UpdateDeleteAction): this;
+    onDelete(action: UpdateDeleteAction): this;
+}
+export type AnyForeignKeyBuilder = ForeignKeyBuilder;
+export declare class ForeignKey {
+    readonly table: PgTable;
+    static readonly [entityKind]: string;
+    readonly reference: Reference;
+    readonly onUpdate: UpdateDeleteAction | undefined;
+    readonly onDelete: UpdateDeleteAction | undefined;
+    constructor(table: PgTable, builder: ForeignKeyBuilder);
+    getName(): string;
+}
+type ColumnsWithTable<TTableName extends string, TColumns extends PgColumn[]> = {
+    [Key in keyof TColumns]: AnyPgColumn<{
+        tableName: TTableName;
+    }>;
+};
+export declare function foreignKey<TTableName extends string, TForeignTableName extends string, TColumns extends [AnyPgColumn<{
+    tableName: TTableName;
+}>, ...AnyPgColumn<{
+    tableName: TTableName;
+}>[]]>(config: {
+    columns: TColumns;
+    foreignColumns: ColumnsWithTable<TForeignTableName, TColumns>;
+}): ForeignKeyBuilder;
+export {};

package/pg-core/foreign-keys.d.mts

@@ -0,0 +1,45 @@
+import { entityKind } from '../entity.js';
+import type { AnyPgColumn, PgColumn } from './columns/index.js';
+import { PgTable } from './table.js';
+export type UpdateDeleteAction = 'cascade' | 'restrict' | 'no action' | 'set null' | 'set default';
+export type Reference = () => {
+    readonly columns: PgColumn[];
+    readonly foreignTable: PgTable;
+    readonly foreignColumns: PgColumn[];
+};
+export declare class ForeignKeyBuilder {
+    static readonly [entityKind]: string;
+    constructor(config: () => {
+        columns: PgColumn[];
+        foreignColumns: PgColumn[];
+    }, actions?: {
+        onUpdate?: UpdateDeleteAction;
+        onDelete?: UpdateDeleteAction;
+    } | undefined);
+    onUpdate(action: UpdateDeleteAction): this;
+    onDelete(action: UpdateDeleteAction): this;
+}
+export type AnyForeignKeyBuilder = ForeignKeyBuilder;
+export declare class ForeignKey {
+    readonly table: PgTable;
+    static readonly [entityKind]: string;
+    readonly reference: Reference;
+    readonly onUpdate: UpdateDeleteAction | undefined;
+    readonly onDelete: UpdateDeleteAction | undefined;
+    constructor(table: PgTable, builder: ForeignKeyBuilder);
+    getName(): string;
+}
+type ColumnsWithTable<TTableName extends string, TColumns extends PgColumn[]> = {
+    [Key in keyof TColumns]: AnyPgColumn<{
+        tableName: TTableName;
+    }>;
+};
+export declare function foreignKey<TTableName extends string, TForeignTableName extends string, TColumns extends [AnyPgColumn<{
+    tableName: TTableName;
+}>, ...AnyPgColumn<{
+    tableName: TTableName;
+}>[]]>(config: {
+    columns: TColumns;
+    foreignColumns: ColumnsWithTable<TForeignTableName, TColumns>;
+}): ForeignKeyBuilder;
+export {};

package/pg-core/foreign-keys.d.ts

@@ -1,6 +1,6 @@
-import { entityKind } from '../entity';
-import type { AnyPgColumn, PgColumn } from './columns';
-import { PgTable } from './table';
+import { entityKind } from '../entity.js';
+import type { AnyPgColumn, PgColumn } from './columns/index.js';
+import { PgTable } from './table.js';
 export type UpdateDeleteAction = 'cascade' | 'restrict' | 'no action' | 'set null' | 'set default';
 export type Reference = () => {
     readonly columns: PgColumn[];