drizzle-orm 0.27.3-e080bed → 0.28.0-5dd9190

package/{db.d-9d586c00.d.ts → select.types.d-d0a10728.d.ts}

@@ -1,417 +1,315 @@
-import { a as SQL, e as entityKind, o as ColumnBuilderHKTBase, aD as Assume, l as ColumnBuilderBaseConfig, c as ColumnHKTBase, C as ColumnBaseConfig, s as ColumnBuilder, aA as Update, f as ColumnHKT, g as Column, r as ColumnBuilderRuntimeConfig, h as AnyColumnHKT, ap as TableConfig$1, T as Table, aq as UpdateTableConfig, at as AnyTableHKT, v as BuildColumns, B as BuildColumn, t as AnyColumnBuilder, aQ as ColumnsSelection, V as View, am as Subquery, an as WithSubquery, a1 as SQLWrapper, aG as ValueOrArray, ai as Placeholder, S as Simplify, Q as Query, as as AnyTable, K as SelectedFieldsFlat$1, X as SelectedFields$1, Y as SelectedFieldsOrdered$1, I as InferModel, ay as UpdateSet, G as GetColumnData, ae as Param, a8 as DriverValueEncoder, a0 as QueryTypingsValue, aN as KnownKeysOnly, aF as DrizzleTypeError } from './column.d-9d74a4f3.js';
+import { e as entityKind, bm as AnyPgTable, aF as KnownKeysOnly, Q as Query, aJ as ColumnsSelection, ah as Subquery, ai as WithSubquery, ax as DrizzleTypeError, bn as AnyPgColumn, X as SQLWrapper, a as SQL, aq as UpdateSet, a3 as DriverValueEncoder, W as QueryTypingsValue, bo as PgColumn, I as InferModel, G as GetColumnData, a9 as Param, ad as Placeholder, bp as IndexColumn, ay as ValueOrArray, bq as PgColumnBuilder, o as BuildColumns, br as AnyPgColumnBuilder, V as View, bs as PgTable, T as Table, bt as PgTableWithColumns, al as UpdateTableConfig, av as Assume, y as SelectedFieldsFlat$1, E as SelectedFields$1, F as SelectedFieldsOrdered$1 } from './column.d-9d2f4045.js';
+import { A as AddAliasToSelection, T as TypedQueryBuilder, f as SelectResultFields, G as GetSelectTableName, a as GetSelectTableSelection, S as SelectMode, J as JoinNullability, B as BuildSubquerySelection, b as SelectResult, c as JoinType, M as MapColumnsToTableAlias, d as AppendToResult, e as AppendToNullabilityMap } from './select.types.d-a3c4c974.js';
+import { T as TablesRelationalConfig, L as TableRelationalConfig, K as DBQueryConfig, V as BuildQueryResult, Q as QueryPromise, N as ExtractTablesWithRelations, R as RelationalSchemaConfig, a as Relation, a3 as BuildRelationalQueryResult } from './query-promise.d-bc96befc.js';
 import { MigrationMeta } from './migrator.js';
-import { Q as QueryPromise, T as TablesRelationalConfig, K as TableRelationalConfig, J as DBQueryConfig, a as Relation, a2 as BuildRelationalQueryResult, U as BuildQueryResult, L as ExtractTablesWithRelations, R as RelationalSchemaConfig } from './query-promise.d-fd15f63a.js';
-import { T as TypedQueryBuilder, A as AddAliasToSelection, G as GetSelectTableName, a as GetSelectTableSelection, S as SelectMode, J as JoinNullability, B as BuildSubquerySelection, b as SelectResult, c as JoinType, M as MapColumnsToTableAlias, d as AppendToResult, e as AppendToNullabilityMap, f as SelectResultFields } from './select.types.d-1ea8ee3b.js';
 
-declare class CheckBuilder {
-    name: string;
-    value: SQL;
-    static readonly [entityKind]: string;
-    protected brand: 'PgConstraintBuilder';
-    constructor(name: string, value: SQL);
-}
-declare class Check {
-    table: AnyPgTable;
+declare class RelationalQueryBuilder<TSchema extends TablesRelationalConfig, TFields extends TableRelationalConfig> {
+    private fullSchema;
+    private schema;
+    private tableNamesMap;
+    private table;
+    private tableConfig;
+    private dialect;
+    private session;
     static readonly [entityKind]: string;
-    readonly name: string;
-    readonly value: SQL;
-    constructor(table: AnyPgTable, builder: CheckBuilder);
+    constructor(fullSchema: Record<string, unknown>, schema: TSchema, tableNamesMap: Record<string, string>, table: AnyPgTable, tableConfig: TableRelationalConfig, dialect: PgDialect, session: PgSession);
+    findMany<TConfig extends DBQueryConfig<'many', true, TSchema, TFields>>(config?: KnownKeysOnly<TConfig, DBQueryConfig<'many', true, TSchema, TFields>>): PgRelationalQuery<BuildQueryResult<TSchema, TFields, TConfig>[]>;
+    findFirst<TSelection extends Omit<DBQueryConfig<'many', true, TSchema, TFields>, 'limit'>>(config?: KnownKeysOnly<TSelection, Omit<DBQueryConfig<'many', true, TSchema, TFields>, 'limit'>>): PgRelationalQuery<BuildQueryResult<TSchema, TFields, TSelection> | undefined>;
 }
-declare function check(name: string, value: SQL): CheckBuilder;
-
-type UpdateDeleteAction = 'cascade' | 'restrict' | 'no action' | 'set null' | 'set default';
-type Reference = () => {
-    readonly columns: AnyPgColumn[];
-    readonly foreignTable: AnyPgTable;
-    readonly foreignColumns: AnyPgColumn[];
-};
-declare class ForeignKeyBuilder {
-    static readonly [entityKind]: string;
-    constructor(config: () => {
-        columns: AnyPgColumn[];
-        foreignColumns: AnyPgColumn[];
-    }, actions?: {
-        onUpdate?: UpdateDeleteAction;
-        onDelete?: UpdateDeleteAction;
-    } | undefined);
-    onUpdate(action: UpdateDeleteAction): this;
-    onDelete(action: UpdateDeleteAction): this;
-}
-type AnyForeignKeyBuilder = ForeignKeyBuilder;
-declare class ForeignKey {
-    readonly table: AnyPgTable;
+declare class PgRelationalQuery<TResult> extends QueryPromise<TResult> {
+    private fullSchema;
+    private schema;
+    private tableNamesMap;
+    private table;
+    private tableConfig;
+    private dialect;
+    private session;
+    private config;
+    private mode;
     static readonly [entityKind]: string;
-    readonly reference: Reference;
-    readonly onUpdate: UpdateDeleteAction | undefined;
-    readonly onDelete: UpdateDeleteAction | undefined;
-    constructor(table: AnyPgTable, builder: ForeignKeyBuilder);
-    getName(): string;
-}
-type ColumnsWithTable<TTableName extends string, TColumns extends AnyPgColumn[]> = {
-    [Key in keyof TColumns]: AnyPgColumn<{
-        tableName: TTableName;
+    protected $brand: 'PgRelationalQuery';
+    constructor(fullSchema: Record<string, unknown>, schema: TablesRelationalConfig, tableNamesMap: Record<string, string>, table: AnyPgTable, tableConfig: TableRelationalConfig, dialect: PgDialect, session: PgSession, config: DBQueryConfig<'many', true> | true, mode: 'many' | 'first');
+    private _prepare;
+    prepare(name: string): PreparedQuery<PreparedQueryConfig & {
+        execute: TResult;
     }>;
-};
-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;
-
-interface ReferenceConfig {
-    ref: () => AnyPgColumn;
-    actions: {
-        onUpdate?: UpdateDeleteAction;
-        onDelete?: UpdateDeleteAction;
-    };
-}
-interface PgColumnBuilderHKT extends ColumnBuilderHKTBase {
-    _type: PgColumnBuilder<PgColumnBuilderHKT, Assume<this['config'], ColumnBuilderBaseConfig>>;
-    _columnHKT: PgColumnHKT;
+    execute(): Promise<TResult>;
 }
-interface PgColumnHKT extends ColumnHKTBase {
-    _type: PgColumn<PgColumnHKT, Assume<this['config'], ColumnBaseConfig>>;
+
+interface PgRefreshMaterializedView<TQueryResult extends QueryResultHKT> extends QueryPromise<QueryResultKind<TQueryResult, never>> {
 }
-declare abstract class PgColumnBuilder<THKT extends ColumnBuilderHKTBase, T extends ColumnBuilderBaseConfig, TRuntimeConfig extends object = {}, TTypeConfig extends object = {}> extends ColumnBuilder<THKT, T, TRuntimeConfig, TTypeConfig & {
-    pgBrand: 'PgColumnBuilder';
-}> {
-    private foreignKeyConfigs;
+declare class PgRefreshMaterializedView<TQueryResult extends QueryResultHKT> extends QueryPromise<QueryResultKind<TQueryResult, never>> {
+    private session;
+    private dialect;
     static readonly [entityKind]: string;
-    array(size?: number): PgArrayBuilder<{
-        name: NonNullable<T['name']>;
-        notNull: NonNullable<T['notNull']>;
-        hasDefault: NonNullable<T['hasDefault']>;
-        data: T['data'][];
-        driverParam: T['driverParam'][] | string;
+    private config;
+    constructor(view: PgMaterializedView, session: PgSession, dialect: PgDialect);
+    concurrently(): this;
+    withNoData(): this;
+    toSQL(): {
+        sql: Query['sql'];
+        params: Query['params'];
+    };
+    private _prepare;
+    prepare(name: string): PreparedQuery<PreparedQueryConfig & {
+        execute: QueryResultKind<TQueryResult, never>;
     }>;
-    references(ref: ReferenceConfig['ref'], actions?: ReferenceConfig['actions']): this;
-    unique(name?: string, config?: {
-        nulls: 'distinct' | 'not distinct';
-    }): this;
-}
-type AnyPgColumnBuilder<TPartial extends Partial<ColumnBuilderBaseConfig> = {}> = PgColumnBuilder<PgColumnBuilderHKT, Required<Update<ColumnBuilderBaseConfig, TPartial>>>;
-declare abstract class PgColumn<THKT extends ColumnHKT, T extends ColumnBaseConfig, TRuntimeConfig extends object = {}, TTypeConfig extends object = {}> extends Column<THKT, T, TRuntimeConfig, TTypeConfig & {
-    pgBrand: 'PgColumn';
-}> {
-    readonly table: AnyPgTable;
-    static readonly [entityKind]: string;
-    constructor(table: AnyPgTable, config: ColumnBuilderRuntimeConfig<T['data']> & TRuntimeConfig);
-}
-type AnyPgColumn<TPartial extends Partial<ColumnBaseConfig> = {}> = PgColumn<PgColumnHKT, Required<Update<ColumnBaseConfig, TPartial>>>;
-interface AnyPgColumnHKT extends AnyColumnHKT {
-    type: AnyPgColumn<Assume<this['config'], Partial<ColumnBaseConfig>>>;
+    execute: ReturnType<this['prepare']>['execute'];
 }
 
-interface IndexConfig {
-    name?: string;
-    columns: IndexColumn[];
-    /**
-     * If true, the index will be created as `create unique index` instead of `create index`.
-     */
-    unique: boolean;
-    /**
-     * If true, the index will be created as `create index concurrently` instead of `create index`.
-     */
-    concurrently?: boolean;
-    /**
-     * If true, the index will be created as `create index ... on only <table>` instead of `create index ... on <table>`.
-     */
-    only: boolean;
-    /**
-     * If set, the index will be created as `create index ... using <method>`.
-     */
-    using?: SQL;
-    /**
-     * If set, the index will be created as `create index ... asc | desc`.
-     */
-    order?: 'asc' | 'desc';
-    /**
-     * If set, adds `nulls first` or `nulls last` to the index.
-     */
-    nulls?: 'first' | 'last';
-    /**
-     * Condition for partial index.
-     */
-    where?: SQL;
-}
-type IndexColumn = AnyPgColumn;
-declare class IndexBuilderOn {
-    private unique;
-    private name?;
-    static readonly [entityKind]: string;
-    constructor(unique: boolean, name?: string | undefined);
-    on(...columns: [IndexColumn, ...IndexColumn[]]): IndexBuilder;
-    onOnly(...columns: [IndexColumn, ...IndexColumn[]]): IndexBuilder;
-}
-interface AnyIndexBuilder {
-    build(table: AnyPgTable): Index;
-}
-interface IndexBuilder extends AnyIndexBuilder {
-}
-declare class IndexBuilder implements AnyIndexBuilder {
-    static readonly [entityKind]: string;
-    constructor(columns: IndexColumn[], unique: boolean, only: boolean, name?: string);
-    concurrently(): this;
-    using(method: SQL): this;
-    asc(): Omit<this, 'asc' | 'desc'>;
-    desc(): Omit<this, 'asc' | 'desc'>;
-    nullsFirst(): Omit<this, 'nullsFirst' | 'nullsLast'>;
-    nullsLast(): Omit<this, 'nullsFirst' | 'nullsLast'>;
-    where(condition: SQL): Omit<this, 'where'>;
-}
-declare class Index {
+type SubqueryWithSelection<TSelection extends ColumnsSelection, TAlias extends string> = Subquery<TAlias, AddAliasToSelection<TSelection, TAlias, 'pg'>> & AddAliasToSelection<TSelection, TAlias, 'pg'>;
+type WithSubqueryWithSelection<TSelection extends ColumnsSelection, TAlias extends string> = WithSubquery<TAlias, AddAliasToSelection<TSelection, TAlias, 'pg'>> & AddAliasToSelection<TSelection, TAlias, 'pg'>;
+
+declare class PgDatabase<TQueryResult extends QueryResultHKT, TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>> {
     static readonly [entityKind]: string;
-    readonly config: IndexConfig & {
-        table: AnyPgTable;
+    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">;
+        };
     };
-    constructor(config: IndexConfig, table: AnyPgTable);
+    select(): PgSelectBuilder<undefined>;
+    select<TSelection extends SelectedFields>(fields: TSelection): PgSelectBuilder<TSelection>;
+    selectDistinct(): PgSelectBuilder<undefined>;
+    selectDistinct<TSelection extends SelectedFields>(fields: TSelection): PgSelectBuilder<TSelection>;
+    selectDistinctOn(on: (AnyPgColumn | SQLWrapper)[]): PgSelectBuilder<undefined>;
+    selectDistinctOn<TSelection extends SelectedFields>(on: (AnyPgColumn | SQLWrapper)[], fields: TSelection): PgSelectBuilder<TSelection>;
+    update<TTable extends AnyPgTable>(table: TTable): PgUpdateBuilder<TTable, TQueryResult>;
+    insert<TTable extends AnyPgTable>(table: TTable): PgInsertBuilder<TTable, TQueryResult>;
+    delete<TTable extends AnyPgTable>(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>;
 }
-type GetColumnsTableName<TColumns> = TColumns extends AnyPgColumn ? TColumns['_']['name'] : TColumns extends AnyPgColumn[] ? TColumns[number]['_']['name'] : never;
-declare function index(name?: string): IndexBuilderOn;
-declare function uniqueIndex(name?: string): IndexBuilderOn;
 
-declare function primaryKey<TTableName extends string, TColumns extends AnyPgColumn<{
-    tableName: TTableName;
-}>[]>(...columns: TColumns): PrimaryKeyBuilder;
-declare class PrimaryKeyBuilder {
-    static readonly [entityKind]: string;
-    constructor(columns: AnyPgColumn[]);
+interface PreparedQueryConfig {
+    execute: unknown;
+    all: unknown;
+    values: unknown;
 }
-declare class PrimaryKey {
-    readonly table: AnyPgTable;
+declare abstract class PreparedQuery<T extends PreparedQueryConfig> {
     static readonly [entityKind]: string;
-    readonly columns: AnyPgColumn<{}>[];
-    constructor(table: AnyPgTable, columns: AnyPgColumn<{}>[]);
-    getName(): string;
+    abstract execute(placeholderValues?: Record<string, unknown>): Promise<T['execute']>;
 }
-
-declare function unique(name?: string): UniqueOnConstraintBuilder;
-declare function uniqueKeyName(table: AnyPgTable, columns: string[]): string;
-declare class UniqueConstraintBuilder {
-    private name?;
-    static readonly [entityKind]: string;
-    constructor(columns: AnyPgColumn[], name?: string | undefined);
-    nullsNotDistinct(): this;
+interface PgTransactionConfig {
+    isolationLevel?: 'read uncommitted' | 'read committed' | 'repeatable read' | 'serializable';
+    accessMode?: 'read only' | 'read write';
+    deferrable?: boolean;
 }
-declare class UniqueOnConstraintBuilder {
+declare abstract class PgSession<TQueryResult extends QueryResultHKT = QueryResultHKT, TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = Record<string, never>> {
+    protected dialect: PgDialect;
     static readonly [entityKind]: string;
-    constructor(name?: string);
-    on(...columns: [AnyPgColumn, ...AnyPgColumn[]]): UniqueConstraintBuilder;
+    constructor(dialect: PgDialect);
+    abstract prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(query: Query, fields: SelectedFieldsOrdered | undefined, name: string | undefined, customResultMapper?: (rows: unknown[][], mapColumnValue?: (value: unknown) => unknown) => T['execute']): PreparedQuery<T>;
+    execute<T>(query: SQL): Promise<T>;
+    all<T = unknown>(query: SQL): Promise<T[]>;
+    abstract transaction<T>(transaction: (tx: PgTransaction<TQueryResult, TFullSchema, TSchema>) => Promise<T>, config?: PgTransactionConfig): Promise<T>;
 }
-declare class UniqueConstraint {
-    readonly table: AnyPgTable;
+declare abstract class PgTransaction<TQueryResult extends QueryResultHKT, TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = Record<string, never>> extends PgDatabase<TQueryResult, TFullSchema, TSchema> {
+    protected schema: {
+        fullSchema: Record<string, unknown>;
+        schema: TSchema;
+        tableNamesMap: Record<string, string>;
+    } | undefined;
+    protected readonly nestedIndex: number;
     static readonly [entityKind]: string;
-    readonly columns: AnyPgColumn<{}>[];
-    readonly name?: string;
-    readonly nullsNotDistinct: boolean;
-    constructor(table: AnyPgTable, columns: AnyPgColumn<{}>[], nullsNotDistinct: boolean, name?: string);
-    getName(): string | undefined;
+    constructor(dialect: PgDialect, session: PgSession<any, any, any>, schema: {
+        fullSchema: Record<string, unknown>;
+        schema: TSchema;
+        tableNamesMap: Record<string, string>;
+    } | undefined, nestedIndex?: number);
+    rollback(): never;
+    setTransaction(config: PgTransactionConfig): Promise<void>;
+    abstract transaction<T>(transaction: (tx: PgTransaction<TQueryResult, TFullSchema, TSchema>) => Promise<T>): Promise<T>;
 }
+interface QueryResultHKT {
+    readonly $brand: 'QueryRowHKT';
+    readonly row: unknown;
+    readonly type: unknown;
+}
+type QueryResultKind<TKind extends QueryResultHKT, TRow> = (TKind & {
+    readonly row: TRow;
+})['type'];
 
-type PgTableExtraConfig = Record<string, AnyIndexBuilder | CheckBuilder | ForeignKeyBuilder | PrimaryKeyBuilder | UniqueConstraintBuilder>;
-type TableConfig = TableConfig$1<AnyPgColumn>;
-declare class PgTable<T extends TableConfig> extends Table<T> {
+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: AnyPgTable, 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: AnyPgTable;
+        tableConfig: TableRelationalConfig;
+        queryConfig: true | DBQueryConfig<'many', true>;
+        tableAlias: string;
+        nestedQueryRelation?: Relation;
+        joinOn?: SQL;
+    }): BuildRelationalQueryResult<AnyPgTable, PgColumn>;
 }
-type AnyPgTable<TPartial extends Partial<TableConfig> = {}> = PgTable<UpdateTableConfig<TableConfig, TPartial>>;
-interface AnyPgTableHKT extends AnyTableHKT {
-    type: AnyPgTable<Assume<this['config'], Partial<TableConfig>>>;
+
+interface PgDeleteConfig {
+    where?: SQL | undefined;
+    table: AnyPgTable;
+    returning?: SelectedFieldsOrdered;
 }
-type PgTableWithColumns<T extends TableConfig> = PgTable<T> & {
-    [Key in keyof T['columns']]: T['columns'][Key];
-};
-interface PgTableFn<TSchema extends string | undefined = undefined> {
-    <TTableName extends string, TColumnsMap extends Record<string, AnyPgColumnBuilder>>(name: TTableName, columns: TColumnsMap, extraConfig?: (self: BuildColumns<TTableName, TColumnsMap>) => PgTableExtraConfig): PgTableWithColumns<{
-        name: TTableName;
-        schema: TSchema;
-        columns: BuildColumns<TTableName, TColumnsMap>;
-    }>;
+interface PgDelete<TTable extends AnyPgTable, TQueryResult extends QueryResultHKT, TReturning extends Record<string, unknown> | undefined = undefined> extends QueryPromise<TReturning extends undefined ? QueryResultKind<TQueryResult, never> : TReturning[]> {
 }
-declare const pgTable: PgTableFn;
-declare function pgTableCreator(customizeTableName: (name: string) => string): PgTableFn;
-
-interface PgArrayBuilderHKT extends ColumnBuilderHKTBase {
-    _type: PgArrayBuilder<Assume<this['config'], ColumnBuilderBaseConfig>>;
-    _columnHKT: PgArrayHKT;
-}
-interface PgArrayHKT extends ColumnHKTBase {
-    _type: PgArray<Assume<this['config'], ColumnBaseConfig>>;
-}
-declare class PgArrayBuilder<T extends ColumnBuilderBaseConfig> extends PgColumnBuilder<PgArrayBuilderHKT, T, {
-    baseBuilder: PgColumnBuilder<PgColumnBuilderHKT, {
-        name: T['name'];
-        notNull: T['notNull'];
-        hasDefault: T['hasDefault'];
-        data: Assume<T['data'], unknown[]>[number];
-        driverParam: string | Assume<T['driverParam'], unknown[]>[number];
-    }>;
-    size: number | undefined;
-}> {
-    static readonly [entityKind] = "PgArrayBuilder";
-    constructor(name: string, baseBuilder: PgArrayBuilder<T>['config']['baseBuilder'], size: number | undefined);
-}
-declare class PgArray<T extends ColumnBaseConfig> extends PgColumn<PgArrayHKT, T, {}, {
-    baseColumn: BuildColumn<string, Assume<PgColumnBuilder<PgColumnBuilderHKT, {
-        name: T['name'];
-        notNull: T['notNull'];
-        hasDefault: T['hasDefault'];
-        data: Assume<T['data'], unknown[]>[number];
-        driverParam: string | Assume<T['driverParam'], unknown[]>[number];
-    }>, AnyColumnBuilder>>;
-}> {
-    readonly baseColumn: AnyPgColumn;
-    readonly range?: [number | undefined, number | undefined] | undefined;
-    protected $pgColumnBrand: 'PgArray';
-    readonly size: number | undefined;
+declare class PgDelete<TTable extends AnyPgTable, TQueryResult extends QueryResultHKT, TReturning extends Record<string, unknown> | undefined = undefined> extends QueryPromise<TReturning extends undefined ? QueryResultKind<TQueryResult, never> : TReturning[]> implements SQLWrapper {
+    private session;
+    private dialect;
     static readonly [entityKind]: string;
-    constructor(table: AnyPgTable<{
-        name: T['tableName'];
-    }>, config: PgArrayBuilder<T>['config'], baseColumn: AnyPgColumn, range?: [number | undefined, number | undefined] | undefined);
-    getSQLType(): string;
-    mapFromDriverValue(value: unknown[] | string): T['data'];
-    mapToDriverValue(value: unknown[], isNestedArray?: boolean): unknown[] | string;
+    private config;
+    constructor(table: TTable, session: PgSession, dialect: PgDialect);
+    where(where: SQL | undefined): Omit<this, 'where'>;
+    returning(): PgDelete<TTable, TQueryResult, InferModel<TTable>>;
+    returning<TSelectedFields extends SelectedFieldsFlat>(fields: TSelectedFields): PgDelete<TTable, TQueryResult, SelectResultFields<TSelectedFields>>;
+    toSQL(): {
+        sql: Query['sql'];
+        params: Query['params'];
+    };
+    private _prepare;
+    prepare(name: string): PreparedQuery<PreparedQueryConfig & {
+        execute: TReturning extends undefined ? QueryResultKind<TQueryResult, never> : TReturning[];
+    }>;
+    execute: ReturnType<this['prepare']>['execute'];
 }
 
-interface ViewWithConfig {
-    checkOption: 'local' | 'cascaded';
-    securityBarrier: boolean;
-    securityInvoker: boolean;
+interface PgUpdateConfig {
+    where?: SQL | undefined;
+    set: UpdateSet;
+    table: AnyPgTable;
+    returning?: SelectedFieldsOrdered;
 }
-declare class DefaultViewBuilderCore<TConfig extends {
-    name: string;
-    columns?: unknown;
-}> {
-    protected name: TConfig['name'];
-    protected schema: string | undefined;
+type PgUpdateSetSource<TTable extends AnyPgTable> = {
+    [Key in keyof TTable['_']['columns']]?: GetColumnData<TTable['_']['columns'][Key]> | SQL;
+} & {};
+declare class PgUpdateBuilder<TTable extends AnyPgTable, TQueryResult extends QueryResultHKT> {
+    private table;
+    private session;
+    private dialect;
     static readonly [entityKind]: string;
     readonly _: {
-        readonly name: TConfig['name'];
-        readonly columns: TConfig['columns'];
-    };
-    constructor(name: TConfig['name'], schema: string | undefined);
-    protected config: {
-        with?: ViewWithConfig;
+        readonly table: TTable;
     };
-    with(config: ViewWithConfig): this;
+    constructor(table: TTable, session: PgSession, dialect: PgDialect);
+    set(values: PgUpdateSetSource<TTable>): PgUpdate<TTable, TQueryResult>;
 }
-declare class ViewBuilder<TName extends string = string> extends DefaultViewBuilderCore<{
-    name: TName;
-}> {
-    static readonly [entityKind]: string;
-    as<TSelectedFields extends SelectedFields>(qb: TypedQueryBuilder<TSelectedFields> | ((qb: QueryBuilder) => TypedQueryBuilder<TSelectedFields>)): PgViewWithSelection<TName, false, AddAliasToSelection<TSelectedFields, TName>>;
-}
-declare class ManualViewBuilder<TName extends string = string, TColumns extends Record<string, AnyPgColumnBuilder> = Record<string, AnyPgColumnBuilder>> extends DefaultViewBuilderCore<{
-    name: TName;
-    columns: TColumns;
-}> {
-    static readonly [entityKind]: string;
-    private columns;
-    constructor(name: TName, columns: TColumns, schema: string | undefined);
-    existing(): PgViewWithSelection<TName, true, BuildColumns<TName, TColumns>>;
-    as(query: SQL): PgViewWithSelection<TName, false, BuildColumns<TName, TColumns>>;
-}
-interface PgMaterializedViewWithConfig {
-    [Key: string]: string | number | boolean | SQL;
+interface PgUpdate<TTable extends AnyPgTable, TQueryResult extends QueryResultHKT, TReturning extends Record<string, unknown> | undefined = undefined> extends QueryPromise<TReturning extends undefined ? QueryResultKind<TQueryResult, never> : TReturning[]>, SQLWrapper {
 }
-declare class MaterializedViewBuilderCore<TConfig extends {
-    name: string;
-    columns?: unknown;
-}> {
-    protected name: TConfig['name'];
-    protected schema: string | undefined;
+declare class PgUpdate<TTable extends AnyPgTable, TQueryResult extends QueryResultHKT, TReturning extends Record<string, unknown> | undefined = undefined> extends QueryPromise<TReturning extends undefined ? QueryResultKind<TQueryResult, never> : TReturning[]> implements SQLWrapper {
+    private session;
+    private dialect;
     static readonly [entityKind]: string;
-    _: {
-        readonly name: TConfig['name'];
-        readonly columns: TConfig['columns'];
-    };
-    constructor(name: TConfig['name'], schema: string | undefined);
-    protected config: {
-        with?: PgMaterializedViewWithConfig;
-        using?: string;
-        tablespace?: string;
-        withNoData?: boolean;
+    readonly _: {
+        readonly table: TTable;
+        readonly return: TReturning;
     };
-    using(using: string): this;
-    with(config: PgMaterializedViewWithConfig): this;
-    tablespace(tablespace: string): this;
-    withNoData(): this;
-}
-declare class MaterializedViewBuilder<TName extends string = string> extends MaterializedViewBuilderCore<{
-    name: TName;
-}> {
-    static readonly [entityKind]: string;
-    as<TSelectedFields extends SelectedFields>(qb: TypedQueryBuilder<TSelectedFields> | ((qb: QueryBuilder) => TypedQueryBuilder<TSelectedFields>)): PgMaterializedViewWithSelection<TName, false, AddAliasToSelection<TSelectedFields, TName>>;
+    private config;
+    constructor(table: TTable, set: UpdateSet, session: PgSession, dialect: PgDialect);
+    where(where: SQL | undefined): this;
+    returning(): PgUpdate<TTable, TQueryResult, InferModel<TTable>>;
+    returning<TSelectedFields extends SelectedFields>(fields: TSelectedFields): PgUpdate<TTable, TQueryResult, SelectResultFields<TSelectedFields>>;
+    toSQL(): Omit<Query, 'typings'>;
+    private _prepare;
+    prepare(name: string): PreparedQuery<PreparedQueryConfig & {
+        execute: TReturning extends undefined ? QueryResultKind<TQueryResult, never> : TReturning[];
+    }>;
+    execute: ReturnType<this['prepare']>['execute'];
 }
-declare class ManualMaterializedViewBuilder<TName extends string = string, TColumns extends Record<string, AnyPgColumnBuilder> = Record<string, AnyPgColumnBuilder>> extends MaterializedViewBuilderCore<{
-    name: TName;
-    columns: TColumns;
-}> {
-    static readonly [entityKind]: string;
-    private columns;
-    constructor(name: TName, columns: TColumns, schema: string | undefined);
-    existing(): PgMaterializedViewWithSelection<TName, true, BuildColumns<TName, TColumns>>;
-    as(query: SQL): PgMaterializedViewWithSelection<TName, false, BuildColumns<TName, TColumns>>;
+
+interface PgInsertConfig<TTable extends AnyPgTable = AnyPgTable> {
+    table: TTable;
+    values: Record<string, Param | SQL>[];
+    onConflict?: SQL;
+    returning?: SelectedFieldsOrdered;
 }
-declare abstract class PgViewBase<TName extends string = string, TExisting extends boolean = boolean, TSelectedFields extends ColumnsSelection = ColumnsSelection> extends View<TName, TExisting, TSelectedFields> {
+type PgInsertValue<TTable extends AnyPgTable> = {
+    [Key in keyof InferModel<TTable, 'insert'>]: InferModel<TTable, 'insert'>[Key] | SQL | Placeholder;
+} & {};
+declare class PgInsertBuilder<TTable extends AnyPgTable, TQueryResult extends QueryResultHKT> {
+    private table;
+    private session;
+    private dialect;
     static readonly [entityKind]: string;
-    readonly _: View<TName, TExisting, TSelectedFields>['_'] & {
-        readonly viewBrand: 'PgViewBase';
-    };
+    constructor(table: TTable, session: PgSession, dialect: PgDialect);
+    values(value: PgInsertValue<TTable>): PgInsert<TTable, TQueryResult>;
+    values(values: PgInsertValue<TTable>[]): PgInsert<TTable, TQueryResult>;
 }
-declare const PgViewConfig: unique symbol;
-declare class PgView<TName extends string = string, TExisting extends boolean = boolean, TSelectedFields extends ColumnsSelection = ColumnsSelection> extends PgViewBase<TName, TExisting, TSelectedFields> {
-    static readonly [entityKind]: string;
-    [PgViewConfig]: {
-        with?: ViewWithConfig;
-    } | undefined;
-    constructor({ pgConfig, config }: {
-        pgConfig: {
-            with?: ViewWithConfig;
-        } | undefined;
-        config: {
-            name: TName;
-            schema: string | undefined;
-            selectedFields: SelectedFields;
-            query: SQL | undefined;
-        };
-    });
+interface PgInsert<TTable extends AnyPgTable, TQueryResult extends QueryResultHKT, TReturning extends Record<string, unknown> | undefined = undefined> extends QueryPromise<TReturning extends undefined ? QueryResultKind<TQueryResult, never> : TReturning[]>, SQLWrapper {
 }
-type PgViewWithSelection<TName extends string = string, TExisting extends boolean = boolean, TSelectedFields extends ColumnsSelection = ColumnsSelection> = PgView<TName, TExisting, TSelectedFields> & TSelectedFields;
-declare const PgMaterializedViewConfig: unique symbol;
-declare class PgMaterializedView<TName extends string = string, TExisting extends boolean = boolean, TSelectedFields extends ColumnsSelection = ColumnsSelection> extends PgViewBase<TName, TExisting, TSelectedFields> {
+declare class PgInsert<TTable extends AnyPgTable, TQueryResult extends QueryResultHKT, TReturning extends Record<string, unknown> | undefined = undefined> extends QueryPromise<TReturning extends undefined ? QueryResultKind<TQueryResult, never> : TReturning[]> implements SQLWrapper {
+    private session;
+    private dialect;
     static readonly [entityKind]: string;
-    readonly [PgMaterializedViewConfig]: {
-        readonly with?: PgMaterializedViewWithConfig;
-        readonly using?: string;
-        readonly tablespace?: string;
-        readonly withNoData?: boolean;
-    } | undefined;
-    constructor({ pgConfig, config }: {
-        pgConfig: {
-            with: PgMaterializedViewWithConfig | undefined;
-            using: string | undefined;
-            tablespace: string | undefined;
-            withNoData: boolean | undefined;
-        } | undefined;
-        config: {
-            name: TName;
-            schema: string | undefined;
-            selectedFields: SelectedFields;
-            query: SQL | undefined;
-        };
-    });
+    _: {
+        table: TTable;
+        return: TReturning;
+    };
+    private config;
+    constructor(table: TTable, values: PgInsertConfig['values'], session: PgSession, dialect: PgDialect);
+    returning(): PgInsert<TTable, TQueryResult, InferModel<TTable>>;
+    returning<TSelectedFields extends SelectedFieldsFlat>(fields: TSelectedFields): PgInsert<TTable, TQueryResult, SelectResultFields<TSelectedFields>>;
+    onConflictDoNothing(config?: {
+        target?: IndexColumn | IndexColumn[];
+        where?: SQL;
+    }): this;
+    onConflictDoUpdate(config: {
+        target: IndexColumn | IndexColumn[];
+        where?: SQL;
+        set: PgUpdateSetSource<TTable>;
+    }): this;
+    toSQL(): {
+        sql: Query['sql'];
+        params: Query['params'];
+    };
+    private _prepare;
+    prepare(name: string): PreparedQuery<PreparedQueryConfig & {
+        execute: TReturning extends undefined ? QueryResultKind<TQueryResult, never> : TReturning[];
+    }>;
+    execute: ReturnType<this['prepare']>['execute'];
 }
-type PgMaterializedViewWithSelection<TName extends string = string, TExisting extends boolean = boolean, TSelectedFields extends ColumnsSelection = ColumnsSelection> = PgMaterializedView<TName, TExisting, TSelectedFields> & TSelectedFields;
-declare function pgView<TName extends string>(name: TName): ViewBuilder<TName>;
-declare function pgView<TName extends string, TColumns extends Record<string, AnyPgColumnBuilder>>(name: TName, columns: TColumns): ManualViewBuilder<TName, TColumns>;
-declare function pgMaterializedView<TName extends string>(name: TName): MaterializedViewBuilder<TName>;
-declare function pgMaterializedView<TName extends string, TColumns extends Record<string, AnyPgColumnBuilder>>(name: TName, columns: TColumns): ManualMaterializedViewBuilder<TName, TColumns>;
-
-type SubqueryWithSelection<TSelection extends ColumnsSelection, TAlias extends string> = Subquery<TAlias, AddAliasToSelection<TSelection, TAlias>> & AddAliasToSelection<TSelection, TAlias>;
-type WithSubqueryWithSelection<TSelection extends ColumnsSelection, TAlias extends string> = WithSubquery<TAlias, AddAliasToSelection<TSelection, TAlias>> & AddAliasToSelection<TSelection, TAlias>;
 
 type CreatePgSelectFromBuilderMode<TBuilderMode extends 'db' | 'qb', TTableName extends string | undefined, TSelection extends ColumnsSelection, TSelectMode extends SelectMode> = TBuilderMode extends 'db' ? PgSelect<TTableName, TSelection, TSelectMode> : PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>;
 declare class PgSelectBuilder<TSelection extends SelectedFields | undefined, TBuilderMode extends 'db' | 'qb' = 'db'> {
@@ -585,7 +483,10 @@ declare abstract class PgSelectQueryBuilder<THKT extends PgSelectHKTBase, TTable
      * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-FOR-UPDATE-SHARE|Postgres locking clause documentation}
      */
     for(strength: LockStrength, config?: LockConfig): this;
-    toSQL(): Simplify<Omit<Query, 'typings'>>;
+    toSQL(): {
+        sql: Query['sql'];
+        params: Query['params'];
+    };
     as<TAlias extends string>(alias: TAlias): SubqueryWithSelection<BuildSubquerySelection<TSelection, TNullabilityMap>, TAlias>;
 }
 interface PgSelect<TTableName extends string | undefined, TSelection extends ColumnsSelection, TSelectMode extends SelectMode, TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'> : {}> extends PgSelectQueryBuilder<PgSelectHKT, TTableName, TSelection, TSelectMode, TNullabilityMap>, QueryPromise<SelectResult<TSelection, TSelectMode, TNullabilityMap>[]> {
@@ -606,398 +507,237 @@ declare class PgSelect<TTableName extends string | undefined, TSelection, TSelec
     execute: ReturnType<this['prepare']>['execute'];
 }
 
-interface Join {
-    on: SQL | undefined;
-    table: AnyPgTable | Subquery | PgViewBase | SQL;
-    alias: string | undefined;
-    joinType: JoinType;
-    lateral?: boolean;
-}
-type AnyPgSelect = PgSelect<any, any, any, any>;
-type BuildAliasTable<TTable extends AnyTable, TAlias extends string> = PgTableWithColumns<Assume<UpdateTableConfig<TTable['_']['config'], {
-    name: TAlias;
-    columns: MapColumnsToTableAlias<TTable['_']['columns'], TAlias>;
-}>, TableConfig>>;
-interface PgSelectConfig {
-    withList?: Subquery[];
-    fields: Record<string, unknown>;
-    fieldsFlat?: SelectedFieldsOrdered;
-    where?: SQL;
-    having?: SQL;
-    table: AnyPgTable | Subquery | PgViewBase | SQL;
-    limit?: number | Placeholder;
-    offset?: number | Placeholder;
-    joins?: Join[];
-    orderBy?: (AnyPgColumn | SQL | SQL.Aliased)[];
-    groupBy?: (AnyPgColumn | SQL | SQL.Aliased)[];
-    lockingClauses?: {
-        strength: LockStrength;
-        config: LockConfig;
-    }[];
-    distinct?: boolean | {
-        on: (AnyPgColumn | SQLWrapper)[];
+declare class QueryBuilder {
+    static readonly [entityKind]: string;
+    private dialect;
+    $with<TAlias extends string>(alias: TAlias): {
+        as<TSelection extends ColumnsSelection>(qb: TypedQueryBuilder<TSelection, unknown> | ((qb: QueryBuilder) => TypedQueryBuilder<TSelection, unknown>)): WithSubqueryWithSelection<TSelection, TAlias>;
     };
-}
-type JoinFn<THKT extends PgSelectHKTBase, TTableName extends string | undefined, TSelectMode extends SelectMode, TJoinType extends JoinType, TSelection, TNullabilityMap extends Record<string, JoinNullability>> = <TJoinedTable extends AnyPgTable | Subquery | PgViewBase | SQL, TJoinedName extends GetSelectTableName<TJoinedTable> = GetSelectTableName<TJoinedTable>>(table: TJoinedTable, on: ((aliases: TSelection) => SQL | undefined) | SQL | undefined) => PgSelectKind<THKT, TTableName, AppendToResult<TTableName, TSelection, TJoinedName, TJoinedTable extends Table ? TJoinedTable['_']['columns'] : TJoinedTable extends Subquery ? Assume<TJoinedTable['_']['selectedFields'], SelectedFields> : never, TSelectMode>, TSelectMode extends 'partial' ? TSelectMode : 'multiple', AppendToNullabilityMap<TNullabilityMap, TJoinedName, TJoinType>>;
-type SelectedFieldsFlat = SelectedFieldsFlat$1<AnyPgColumn>;
-type SelectedFields = SelectedFields$1<AnyPgColumn, AnyPgTable>;
-type SelectedFieldsOrdered = SelectedFieldsOrdered$1<AnyPgColumn>;
-type LockStrength = 'update' | 'no key update' | 'share' | 'key share';
-type LockConfig = {
-    of?: AnyPgTable;
-} & ({
-    noWait: true;
-    skipLocked?: undefined;
-} | {
-    noWait?: undefined;
-    skipLocked: true;
-} | {
-    noWait?: undefined;
-    skipLocked?: undefined;
-});
-interface PgSelectHKTBase {
-    tableName: string | undefined;
-    selection: unknown;
-    selectMode: SelectMode;
-    nullabilityMap: unknown;
-    _type: unknown;
-}
-type PgSelectKind<T extends PgSelectHKTBase, TTableName extends string | undefined, TSelection, TSelectMode extends SelectMode, TNullabilityMap extends Record<string, JoinNullability>> = (T & {
-    tableName: TTableName;
-    selection: TSelection;
-    selectMode: TSelectMode;
-    nullabilityMap: TNullabilityMap;
-})['_type'];
-interface PgSelectQueryBuilderHKT extends PgSelectHKTBase {
-    _type: PgSelectQueryBuilder<this, this['tableName'], Assume<this['selection'], ColumnsSelection>, this['selectMode'], Assume<this['nullabilityMap'], Record<string, JoinNullability>>>;
-}
-interface PgSelectHKT extends PgSelectHKTBase {
-    _type: PgSelect<this['tableName'], Assume<this['selection'], ColumnsSelection>, this['selectMode'], Assume<this['nullabilityMap'], Record<string, JoinNullability>>>;
+    with(...queries: WithSubquery[]): {
+        select: {
+            (): PgSelectBuilder<undefined, 'qb'>;
+            <TSelection extends SelectedFields>(fields: TSelection): PgSelectBuilder<TSelection, "qb">;
+        };
+        selectDistinct: {
+            (): PgSelectBuilder<undefined, 'qb'>;
+            <TSelection_1 extends SelectedFields>(fields: TSelection_1): PgSelectBuilder<TSelection_1, "qb">;
+        };
+        selectDistinctOn: {
+            (on: (AnyPgColumn | SQLWrapper)[]): PgSelectBuilder<undefined, 'qb'>;
+            <TSelection_2 extends SelectedFields>(on: (AnyPgColumn | SQLWrapper)[], fields: TSelection_2): PgSelectBuilder<TSelection_2, "qb">;
+        };
+    };
+    select(): PgSelectBuilder<undefined, 'qb'>;
+    select<TSelection extends SelectedFields>(fields: TSelection): PgSelectBuilder<TSelection, 'qb'>;
+    selectDistinct(): PgSelectBuilder<undefined>;
+    selectDistinct<TSelection extends SelectedFields>(fields: TSelection): PgSelectBuilder<TSelection>;
+    selectDistinctOn(on: (AnyPgColumn | SQLWrapper)[]): PgSelectBuilder<undefined>;
+    selectDistinctOn<TSelection extends SelectedFields>(on: (AnyPgColumn | SQLWrapper)[], fields: TSelection): PgSelectBuilder<TSelection>;
+    private getDialect;
 }
 
-interface PreparedQueryConfig {
-    execute: unknown;
-    all: unknown;
-    values: unknown;
+interface ViewWithConfig {
+    checkOption: 'local' | 'cascaded';
+    securityBarrier: boolean;
+    securityInvoker: boolean;
 }
-declare abstract class PreparedQuery<T extends PreparedQueryConfig> {
+declare class DefaultViewBuilderCore<TConfig extends {
+    name: string;
+    columns?: unknown;
+}> {
+    protected name: TConfig['name'];
+    protected schema: string | undefined;
     static readonly [entityKind]: string;
-    abstract execute(placeholderValues?: Record<string, unknown>): Promise<T['execute']>;
-}
-interface PgTransactionConfig {
-    isolationLevel?: 'read uncommitted' | 'read committed' | 'repeatable read' | 'serializable';
-    accessMode?: 'read only' | 'read write';
-    deferrable?: boolean;
-}
-declare abstract class PgSession<TQueryResult extends QueryResultHKT = QueryResultHKT, TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = Record<string, never>> {
-    protected dialect: PgDialect;
-    static readonly [entityKind]: string;
-    constructor(dialect: PgDialect);
-    abstract prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(query: Query, fields: SelectedFieldsOrdered | undefined, name: string | undefined, customResultMapper?: (rows: unknown[][], mapColumnValue?: (value: unknown) => unknown) => T['execute']): PreparedQuery<T>;
-    execute<T>(query: SQL): Promise<T>;
-    all<T = unknown>(query: SQL): Promise<T[]>;
-    abstract transaction<T>(transaction: (tx: PgTransaction<TQueryResult, TFullSchema, TSchema>) => Promise<T>, config?: PgTransactionConfig): Promise<T>;
+    readonly _: {
+        readonly name: TConfig['name'];
+        readonly columns: TConfig['columns'];
+    };
+    constructor(name: TConfig['name'], schema: string | undefined);
+    protected config: {
+        with?: ViewWithConfig;
+    };
+    with(config: ViewWithConfig): this;
 }
-declare abstract class PgTransaction<TQueryResult extends QueryResultHKT, TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = Record<string, never>> extends PgDatabase<TQueryResult, TFullSchema, TSchema> {
-    protected schema: {
-        fullSchema: Record<string, unknown>;
-        schema: TSchema;
-        tableNamesMap: Record<string, string>;
-    } | undefined;
-    protected readonly nestedIndex: number;
+declare class ViewBuilder<TName extends string = string> extends DefaultViewBuilderCore<{
+    name: TName;
+}> {
     static readonly [entityKind]: string;
-    constructor(dialect: PgDialect, session: PgSession<any, any, any>, schema: {
-        fullSchema: Record<string, unknown>;
-        schema: TSchema;
-        tableNamesMap: Record<string, string>;
-    } | undefined, nestedIndex?: number);
-    rollback(): never;
-    setTransaction(config: PgTransactionConfig): Promise<void>;
-    abstract transaction<T>(transaction: (tx: PgTransaction<TQueryResult, TFullSchema, TSchema>) => Promise<T>): Promise<T>;
-}
-interface QueryResultHKT {
-    readonly $brand: 'QueryRowHKT';
-    readonly row: unknown;
-    readonly type: unknown;
+    as<TSelectedFields extends SelectedFields>(qb: TypedQueryBuilder<TSelectedFields> | ((qb: QueryBuilder) => TypedQueryBuilder<TSelectedFields>)): PgViewWithSelection<TName, false, AddAliasToSelection<TSelectedFields, TName, 'pg'>>;
 }
-type QueryResultKind<TKind extends QueryResultHKT, TRow> = (TKind & {
-    readonly row: TRow;
-})['type'];
-
-interface PgDeleteConfig {
-    where?: SQL | undefined;
-    table: AnyPgTable;
-    returning?: SelectedFieldsOrdered;
-}
-interface PgDelete<TTable extends AnyPgTable, TQueryResult extends QueryResultHKT, TReturning extends Record<string, unknown> | undefined = undefined> extends QueryPromise<TReturning extends undefined ? QueryResultKind<TQueryResult, never> : TReturning[]> {
-}
-declare class PgDelete<TTable extends AnyPgTable, TQueryResult extends QueryResultHKT, TReturning extends Record<string, unknown> | undefined = undefined> extends QueryPromise<TReturning extends undefined ? QueryResultKind<TQueryResult, never> : TReturning[]> implements SQLWrapper {
-    private session;
-    private dialect;
+declare class ManualViewBuilder<TName extends string = string, TColumns extends Record<string, PgColumnBuilder> = Record<string, PgColumnBuilder>> extends DefaultViewBuilderCore<{
+    name: TName;
+    columns: TColumns;
+}> {
     static readonly [entityKind]: string;
-    private config;
-    constructor(table: TTable, session: PgSession, dialect: PgDialect);
-    where(where: SQL | undefined): Omit<this, 'where'>;
-    returning(): PgDelete<TTable, TQueryResult, InferModel<TTable>>;
-    returning<TSelectedFields extends SelectedFieldsFlat>(fields: TSelectedFields): PgDelete<TTable, TQueryResult, SelectResultFields<TSelectedFields>>;
-    toSQL(): Simplify<Omit<Query, 'typings'>>;
-    private _prepare;
-    prepare(name: string): PreparedQuery<PreparedQueryConfig & {
-        execute: TReturning extends undefined ? QueryResultKind<TQueryResult, never> : TReturning[];
-    }>;
-    execute: ReturnType<this['prepare']>['execute'];
+    private columns;
+    constructor(name: TName, columns: TColumns, schema: string | undefined);
+    existing(): PgViewWithSelection<TName, true, BuildColumns<TName, TColumns, 'pg'>>;
+    as(query: SQL): PgViewWithSelection<TName, false, BuildColumns<TName, TColumns, 'pg'>>;
 }
-
-interface PgUpdateConfig {
-    where?: SQL | undefined;
-    set: UpdateSet;
-    table: AnyPgTable;
-    returning?: SelectedFieldsOrdered;
+interface PgMaterializedViewWithConfig {
+    [Key: string]: string | number | boolean | SQL;
 }
-type PgUpdateSetSource<TTable extends AnyPgTable> = Simplify<{
-    [Key in keyof TTable['_']['columns']]?: GetColumnData<TTable['_']['columns'][Key]> | SQL;
-}>;
-declare class PgUpdateBuilder<TTable extends AnyPgTable, TQueryResult extends QueryResultHKT> {
-    private table;
-    private session;
-    private dialect;
+declare class MaterializedViewBuilderCore<TConfig extends {
+    name: string;
+    columns?: unknown;
+}> {
+    protected name: TConfig['name'];
+    protected schema: string | undefined;
     static readonly [entityKind]: string;
-    readonly _: {
-        readonly table: TTable;
+    _: {
+        readonly name: TConfig['name'];
+        readonly columns: TConfig['columns'];
     };
-    constructor(table: TTable, session: PgSession, dialect: PgDialect);
-    set(values: PgUpdateSetSource<TTable>): PgUpdate<TTable, TQueryResult>;
-}
-interface PgUpdate<TTable extends AnyPgTable, TQueryResult extends QueryResultHKT, TReturning extends Record<string, unknown> | undefined = undefined> extends QueryPromise<TReturning extends undefined ? QueryResultKind<TQueryResult, never> : TReturning[]>, SQLWrapper {
-}
-declare class PgUpdate<TTable extends AnyPgTable, TQueryResult extends QueryResultHKT, TReturning extends Record<string, unknown> | undefined = undefined> extends QueryPromise<TReturning extends undefined ? QueryResultKind<TQueryResult, never> : TReturning[]> implements SQLWrapper {
-    private session;
-    private dialect;
-    static readonly [entityKind]: string;
-    readonly _: {
-        readonly table: TTable;
-        readonly return: TReturning;
+    constructor(name: TConfig['name'], schema: string | undefined);
+    protected config: {
+        with?: PgMaterializedViewWithConfig;
+        using?: string;
+        tablespace?: string;
+        withNoData?: boolean;
     };
-    private config;
-    constructor(table: TTable, set: UpdateSet, session: PgSession, dialect: PgDialect);
-    where(where: SQL | undefined): this;
-    returning(): PgUpdate<TTable, TQueryResult, InferModel<TTable>>;
-    returning<TSelectedFields extends SelectedFields>(fields: TSelectedFields): PgUpdate<TTable, TQueryResult, SelectResultFields<TSelectedFields>>;
-    toSQL(): Omit<Query, 'typings'>;
-    private _prepare;
-    prepare(name: string): PreparedQuery<PreparedQueryConfig & {
-        execute: TReturning extends undefined ? QueryResultKind<TQueryResult, never> : TReturning[];
-    }>;
-    execute: ReturnType<this['prepare']>['execute'];
-}
-
-interface PgInsertConfig<TTable extends AnyPgTable = AnyPgTable> {
-    table: TTable;
-    values: Record<string, Param | SQL>[];
-    onConflict?: SQL;
-    returning?: SelectedFieldsOrdered;
+    using(using: string): this;
+    with(config: PgMaterializedViewWithConfig): this;
+    tablespace(tablespace: string): this;
+    withNoData(): this;
 }
-type PgInsertValue<TTable extends AnyPgTable> = Simplify<{
-    [Key in keyof InferModel<TTable, 'insert'>]: InferModel<TTable, 'insert'>[Key] | SQL | Placeholder;
-}>;
-declare class PgInsertBuilder<TTable extends AnyPgTable, TQueryResult extends QueryResultHKT> {
-    private table;
-    private session;
-    private dialect;
+declare class MaterializedViewBuilder<TName extends string = string> extends MaterializedViewBuilderCore<{
+    name: TName;
+}> {
     static readonly [entityKind]: string;
-    constructor(table: TTable, session: PgSession, dialect: PgDialect);
-    values(value: PgInsertValue<TTable>): PgInsert<TTable, TQueryResult>;
-    values(values: PgInsertValue<TTable>[]): PgInsert<TTable, TQueryResult>;
+    as<TSelectedFields extends SelectedFields>(qb: TypedQueryBuilder<TSelectedFields> | ((qb: QueryBuilder) => TypedQueryBuilder<TSelectedFields>)): PgMaterializedViewWithSelection<TName, false, AddAliasToSelection<TSelectedFields, TName, 'pg'>>;
 }
-interface PgInsert<TTable extends AnyPgTable, TQueryResult extends QueryResultHKT, TReturning extends Record<string, unknown> | undefined = undefined> extends QueryPromise<TReturning extends undefined ? QueryResultKind<TQueryResult, never> : TReturning[]>, SQLWrapper {
+declare class ManualMaterializedViewBuilder<TName extends string = string, TColumns extends Record<string, AnyPgColumnBuilder> = Record<string, AnyPgColumnBuilder>> extends MaterializedViewBuilderCore<{
+    name: TName;
+    columns: TColumns;
+}> {
+    static readonly [entityKind]: string;
+    private columns;
+    constructor(name: TName, columns: TColumns, schema: string | undefined);
+    existing(): PgMaterializedViewWithSelection<TName, true, BuildColumns<TName, TColumns, 'pg'>>;
+    as(query: SQL): PgMaterializedViewWithSelection<TName, false, BuildColumns<TName, TColumns, 'pg'>>;
 }
-declare class PgInsert<TTable extends AnyPgTable, TQueryResult extends QueryResultHKT, TReturning extends Record<string, unknown> | undefined = undefined> extends QueryPromise<TReturning extends undefined ? QueryResultKind<TQueryResult, never> : TReturning[]> implements SQLWrapper {
-    private session;
-    private dialect;
+declare abstract class PgViewBase<TName extends string = string, TExisting extends boolean = boolean, TSelectedFields extends ColumnsSelection = ColumnsSelection> extends View<TName, TExisting, TSelectedFields> {
     static readonly [entityKind]: string;
-    _: {
-        table: TTable;
-        return: TReturning;
+    readonly _: View<TName, TExisting, TSelectedFields>['_'] & {
+        readonly viewBrand: 'PgViewBase';
     };
-    private config;
-    constructor(table: TTable, values: PgInsertConfig['values'], session: PgSession, dialect: PgDialect);
-    returning(): PgInsert<TTable, TQueryResult, InferModel<TTable>>;
-    returning<TSelectedFields extends SelectedFieldsFlat>(fields: TSelectedFields): PgInsert<TTable, TQueryResult, SelectResultFields<TSelectedFields>>;
-    onConflictDoNothing(config?: {
-        target?: IndexColumn | IndexColumn[];
-        where?: SQL;
-    }): this;
-    onConflictDoUpdate(config: {
-        target: IndexColumn | IndexColumn[];
-        where?: SQL;
-        set: PgUpdateSetSource<TTable>;
-    }): this;
-    toSQL(): Simplify<Omit<Query, 'typings'>>;
-    private _prepare;
-    prepare(name: string): PreparedQuery<PreparedQueryConfig & {
-        execute: TReturning extends undefined ? QueryResultKind<TQueryResult, never> : TReturning[];
-    }>;
-    execute: ReturnType<this['prepare']>['execute'];
 }
-
-declare class QueryBuilder {
+declare const PgViewConfig: unique symbol;
+declare class PgView<TName extends string = string, TExisting extends boolean = boolean, TSelectedFields extends ColumnsSelection = ColumnsSelection> extends PgViewBase<TName, TExisting, TSelectedFields> {
     static readonly [entityKind]: string;
-    private dialect;
-    $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, 'qb'>;
-            <TSelection extends SelectedFields>(fields: TSelection): PgSelectBuilder<TSelection, "qb">;
-        };
-        selectDistinct: {
-            (): PgSelectBuilder<undefined, 'qb'>;
-            <TSelection_1 extends SelectedFields>(fields: TSelection_1): PgSelectBuilder<TSelection_1, "qb">;
-        };
-        selectDistinctOn: {
-            (on: (AnyPgColumn | SQLWrapper)[]): PgSelectBuilder<undefined, 'qb'>;
-            <TSelection_2 extends SelectedFields>(on: (AnyPgColumn | SQLWrapper)[], fields: TSelection_2): PgSelectBuilder<TSelection_2, "qb">;
+    [PgViewConfig]: {
+        with?: ViewWithConfig;
+    } | undefined;
+    constructor({ pgConfig, config }: {
+        pgConfig: {
+            with?: ViewWithConfig;
+        } | undefined;
+        config: {
+            name: TName;
+            schema: string | undefined;
+            selectedFields: SelectedFields;
+            query: SQL | undefined;
         };
-    };
-    select(): PgSelectBuilder<undefined, 'qb'>;
-    select<TSelection extends SelectedFields>(fields: TSelection): PgSelectBuilder<TSelection, 'qb'>;
-    selectDistinct(): PgSelectBuilder<undefined>;
-    selectDistinct<TSelection extends SelectedFields>(fields: TSelection): PgSelectBuilder<TSelection>;
-    selectDistinctOn(on: (AnyPgColumn | SQLWrapper)[]): PgSelectBuilder<undefined>;
-    selectDistinctOn<TSelection extends SelectedFields>(on: (AnyPgColumn | SQLWrapper)[], fields: TSelection): PgSelectBuilder<TSelection>;
-    private getDialect;
-}
-
-interface PgRefreshMaterializedView<TQueryResult extends QueryResultHKT> extends QueryPromise<QueryResultKind<TQueryResult, never>> {
+    });
 }
-declare class PgRefreshMaterializedView<TQueryResult extends QueryResultHKT> extends QueryPromise<QueryResultKind<TQueryResult, never>> {
-    private session;
-    private dialect;
+type PgViewWithSelection<TName extends string = string, TExisting extends boolean = boolean, TSelectedFields extends ColumnsSelection = ColumnsSelection> = PgView<TName, TExisting, TSelectedFields> & TSelectedFields;
+declare const PgMaterializedViewConfig: unique symbol;
+declare class PgMaterializedView<TName extends string = string, TExisting extends boolean = boolean, TSelectedFields extends ColumnsSelection = ColumnsSelection> extends PgViewBase<TName, TExisting, TSelectedFields> {
     static readonly [entityKind]: string;
-    private config;
-    constructor(view: PgMaterializedView, session: PgSession, dialect: PgDialect);
-    concurrently(): this;
-    withNoData(): this;
-    toSQL(): Simplify<Omit<Query, 'typings'>>;
-    private _prepare;
-    prepare(name: string): PreparedQuery<PreparedQueryConfig & {
-        execute: QueryResultKind<TQueryResult, never>;
-    }>;
-    execute: ReturnType<this['prepare']>['execute'];
+    readonly [PgMaterializedViewConfig]: {
+        readonly with?: PgMaterializedViewWithConfig;
+        readonly using?: string;
+        readonly tablespace?: string;
+        readonly withNoData?: boolean;
+    } | undefined;
+    constructor({ pgConfig, config }: {
+        pgConfig: {
+            with: PgMaterializedViewWithConfig | undefined;
+            using: string | undefined;
+            tablespace: string | undefined;
+            withNoData: boolean | undefined;
+        } | undefined;
+        config: {
+            name: TName;
+            schema: string | undefined;
+            selectedFields: SelectedFields;
+            query: SQL | undefined;
+        };
+    });
 }
+type PgMaterializedViewWithSelection<TName extends string = string, TExisting extends boolean = boolean, TSelectedFields extends ColumnsSelection = ColumnsSelection> = PgMaterializedView<TName, TExisting, TSelectedFields> & TSelectedFields;
+declare function pgView<TName extends string>(name: TName): ViewBuilder<TName>;
+declare function pgView<TName extends string, TColumns extends Record<string, AnyPgColumnBuilder>>(name: TName, columns: TColumns): ManualViewBuilder<TName, TColumns>;
+declare function pgMaterializedView<TName extends string>(name: TName): MaterializedViewBuilder<TName>;
+declare function pgMaterializedView<TName extends string, TColumns extends Record<string, AnyPgColumnBuilder>>(name: TName, columns: TColumns): ManualMaterializedViewBuilder<TName, TColumns>;
 
-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: AnyPgTable, 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: AnyPgTable;
-        tableConfig: TableRelationalConfig;
-        queryConfig: true | DBQueryConfig<'many', true>;
-        tableAlias: string;
-        nestedQueryRelation?: Relation;
-        joinOn?: SQL;
-    }): BuildRelationalQueryResult<AnyPgTable, AnyPgColumn>;
+interface Join {
+    on: SQL | undefined;
+    table: PgTable | Subquery | PgViewBase | SQL;
+    alias: string | undefined;
+    joinType: JoinType;
+    lateral?: boolean;
 }
-
-declare class RelationalQueryBuilder<TSchema extends TablesRelationalConfig, TFields extends TableRelationalConfig> {
-    private fullSchema;
-    private schema;
-    private tableNamesMap;
-    private table;
-    private tableConfig;
-    private dialect;
-    private session;
-    static readonly [entityKind]: string;
-    constructor(fullSchema: Record<string, unknown>, schema: TSchema, tableNamesMap: Record<string, string>, table: AnyPgTable, tableConfig: TableRelationalConfig, dialect: PgDialect, session: PgSession);
-    findMany<TConfig extends DBQueryConfig<'many', true, TSchema, TFields>>(config?: KnownKeysOnly<TConfig, DBQueryConfig<'many', true, TSchema, TFields>>): PgRelationalQuery<BuildQueryResult<TSchema, TFields, TConfig>[]>;
-    findFirst<TSelection extends Omit<DBQueryConfig<'many', true, TSchema, TFields>, 'limit'>>(config?: KnownKeysOnly<TSelection, Omit<DBQueryConfig<'many', true, TSchema, TFields>, 'limit'>>): PgRelationalQuery<BuildQueryResult<TSchema, TFields, TSelection> | undefined>;
+type AnyPgSelect = PgSelect<any, any, any, any>;
+type BuildAliasTable<TTable extends PgTable | View, TAlias extends string> = TTable extends Table ? PgTableWithColumns<UpdateTableConfig<TTable['_']['config'], {
+    name: TAlias;
+    columns: MapColumnsToTableAlias<TTable['_']['columns'], TAlias, 'pg'>;
+}>> : TTable extends View ? PgViewWithSelection<TAlias, TTable['_']['existing'], MapColumnsToTableAlias<TTable['_']['selectedFields'], TAlias, 'pg'>> : never;
+interface PgSelectConfig {
+    withList?: Subquery[];
+    fields: Record<string, unknown>;
+    fieldsFlat?: SelectedFieldsOrdered;
+    where?: SQL;
+    having?: SQL;
+    table: PgTable | Subquery | PgViewBase | SQL;
+    limit?: number | Placeholder;
+    offset?: number | Placeholder;
+    joins?: Join[];
+    orderBy?: (PgColumn | SQL | SQL.Aliased)[];
+    groupBy?: (PgColumn | SQL | SQL.Aliased)[];
+    lockingClauses?: {
+        strength: LockStrength;
+        config: LockConfig;
+    }[];
+    distinct?: boolean | {
+        on: (PgColumn | SQLWrapper)[];
+    };
 }
-declare class PgRelationalQuery<TResult> extends QueryPromise<TResult> {
-    private fullSchema;
-    private schema;
-    private tableNamesMap;
-    private table;
-    private tableConfig;
-    private dialect;
-    private session;
-    private config;
-    private mode;
-    static readonly [entityKind]: string;
-    protected $brand: 'PgRelationalQuery';
-    constructor(fullSchema: Record<string, unknown>, schema: TablesRelationalConfig, tableNamesMap: Record<string, string>, table: AnyPgTable, tableConfig: TableRelationalConfig, dialect: PgDialect, session: PgSession, config: DBQueryConfig<'many', true> | true, mode: 'many' | 'first');
-    private _prepare;
-    prepare(name: string): PreparedQuery<PreparedQueryConfig & {
-        execute: TResult;
-    }>;
-    execute(): Promise<TResult>;
+type JoinFn<THKT extends PgSelectHKTBase, TTableName extends string | undefined, TSelectMode extends SelectMode, TJoinType extends JoinType, TSelection, TNullabilityMap extends Record<string, JoinNullability>> = <TJoinedTable extends PgTable | Subquery | PgViewBase | SQL, TJoinedName extends GetSelectTableName<TJoinedTable> = GetSelectTableName<TJoinedTable>>(table: TJoinedTable, on: ((aliases: TSelection) => SQL | undefined) | SQL | undefined) => PgSelectKind<THKT, TTableName, AppendToResult<TTableName, TSelection, TJoinedName, TJoinedTable extends Table ? TJoinedTable['_']['columns'] : TJoinedTable extends Subquery ? Assume<TJoinedTable['_']['selectedFields'], SelectedFields> : never, TSelectMode>, TSelectMode extends 'partial' ? TSelectMode : 'multiple', AppendToNullabilityMap<TNullabilityMap, TJoinedName, TJoinType>>;
+type SelectedFieldsFlat = SelectedFieldsFlat$1<PgColumn>;
+type SelectedFields = SelectedFields$1<PgColumn, PgTable>;
+type SelectedFieldsOrdered = SelectedFieldsOrdered$1<PgColumn>;
+type LockStrength = 'update' | 'no key update' | 'share' | 'key share';
+type LockConfig = {
+    of?: PgTable;
+} & ({
+    noWait: true;
+    skipLocked?: undefined;
+} | {
+    noWait?: undefined;
+    skipLocked: true;
+} | {
+    noWait?: undefined;
+    skipLocked?: undefined;
+});
+interface PgSelectHKTBase {
+    tableName: string | undefined;
+    selection: unknown;
+    selectMode: SelectMode;
+    nullabilityMap: unknown;
+    _type: unknown;
 }
-
-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: (AnyPgColumn | SQLWrapper)[]): PgSelectBuilder<undefined>;
-    selectDistinctOn<TSelection extends SelectedFields>(on: (AnyPgColumn | SQLWrapper)[], fields: TSelection): PgSelectBuilder<TSelection>;
-    update<TTable extends AnyPgTable>(table: TTable): PgUpdateBuilder<TTable, TQueryResult>;
-    insert<TTable extends AnyPgTable>(table: TTable): PgInsertBuilder<TTable, TQueryResult>;
-    delete<TTable extends AnyPgTable>(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>;
+type PgSelectKind<T extends PgSelectHKTBase, TTableName extends string | undefined, TSelection, TSelectMode extends SelectMode, TNullabilityMap extends Record<string, JoinNullability>> = (T & {
+    tableName: TTableName;
+    selection: TSelection;
+    selectMode: TSelectMode;
+    nullabilityMap: TNullabilityMap;
+})['_type'];
+interface PgSelectQueryBuilderHKT extends PgSelectHKTBase {
+    _type: PgSelectQueryBuilder<this, this['tableName'], Assume<this['selection'], ColumnsSelection>, this['selectMode'], Assume<this['nullabilityMap'], Record<string, JoinNullability>>>;
+}
+interface PgSelectHKT extends PgSelectHKTBase {
+    _type: PgSelect<this['tableName'], Assume<this['selection'], ColumnsSelection>, this['selectMode'], Assume<this['nullabilityMap'], Record<string, JoinNullability>>>;
 }
 
-export { PgInsert as $, AnyPgTable as A, BuildAliasTable as B, Check as C, IndexColumn as D, IndexBuilderOn as E, ForeignKey as F, AnyIndexBuilder as G, IndexBuilder as H, Index as I, GetColumnsTableName as J, index as K, uniqueIndex as L, primaryKey as M, PrimaryKeyBuilder as N, unique as O, PgColumnBuilder as P, uniqueKeyName as Q, ReferenceConfig as R, UniqueConstraintBuilder as S, UniqueOnConstraintBuilder as T, UniqueConstraint as U, ViewWithConfig as V, PgDeleteConfig as W, PgDelete as X, PgInsertConfig as Y, PgInsertValue as Z, PgInsertBuilder as _, PgColumn as a, QueryBuilder as a0, PgRefreshMaterializedView as a1, PgSelectBuilder as a2, PgSelectQueryBuilder as a3, PgSelect as a4, Join as a5, AnyPgSelect as a6, PgSelectConfig as a7, JoinFn as a8, SelectedFieldsFlat as a9, pgTable as aA, pgTableCreator as aB, DefaultViewBuilderCore as aC, ViewBuilder as aD, ManualViewBuilder as aE, MaterializedViewBuilderCore as aF, MaterializedViewBuilder as aG, ManualMaterializedViewBuilder as aH, PgViewBase as aI, PgViewConfig as aJ, PgViewWithSelection as aK, PgMaterializedViewConfig as aL, PgMaterializedViewWithSelection as aM, SelectedFields as aa, SelectedFieldsOrdered as ab, LockStrength as ac, LockConfig as ad, PgSelectHKTBase as ae, PgSelectKind as af, PgSelectQueryBuilderHKT as ag, PgSelectHKT as ah, PgUpdateConfig as ai, PgUpdateSetSource as aj, PgUpdateBuilder as ak, PgUpdate as al, PreparedQueryConfig as am, PreparedQuery as an, PgTransactionConfig as ao, PgSession as ap, PgTransaction as aq, QueryResultHKT as ar, QueryResultKind as as, SubqueryWithSelection as at, WithSubqueryWithSelection as au, PgTableExtraConfig as av, TableConfig as aw, PgTable as ax, AnyPgTableHKT as ay, PgTableWithColumns as az, PgTableFn as b, pgMaterializedView as c, AnyPgColumn as d, PrimaryKey as e, PgView as f, PgMaterializedView as g, PgMaterializedViewWithConfig as h, CheckBuilder as i, check as j, PgArrayBuilderHKT as k, PgArrayHKT as l, PgArrayBuilder as m, PgArray as n, PgColumnBuilderHKT as o, pgView as p, PgColumnHKT as q, AnyPgColumnBuilder as r, AnyPgColumnHKT as s, PgDatabase as t, PgDialect as u, UpdateDeleteAction as v, Reference as w, ForeignKeyBuilder as x, AnyForeignKeyBuilder as y, foreignKey as z };
+export { PgViewConfig as $, AnyPgSelect as A, BuildAliasTable as B, PgUpdateConfig as C, PgUpdateSetSource as D, PgUpdateBuilder as E, PgUpdate as F, PreparedQueryConfig as G, PreparedQuery as H, PgTransactionConfig as I, Join as J, PgSession as K, LockStrength as L, PgTransaction as M, QueryResultHKT as N, QueryResultKind as O, PgViewBase as P, QueryBuilder as Q, SubqueryWithSelection as R, SelectedFieldsFlat as S, DefaultViewBuilderCore as T, ViewBuilder as U, ViewWithConfig as V, WithSubqueryWithSelection as W, ManualViewBuilder as X, MaterializedViewBuilderCore as Y, MaterializedViewBuilder as Z, ManualMaterializedViewBuilder as _, pgMaterializedView as a, PgViewWithSelection as a0, PgMaterializedViewConfig as a1, PgMaterializedViewWithSelection as a2, PgView as b, PgMaterializedView as c, PgMaterializedViewWithConfig as d, PgDatabase as e, PgDialect as f, PgDeleteConfig as g, PgDelete as h, PgInsertConfig as i, PgInsertValue as j, PgInsertBuilder as k, PgInsert as l, PgRefreshMaterializedView as m, PgSelectBuilder as n, PgSelectQueryBuilder as o, pgView as p, PgSelect as q, PgSelectConfig as r, JoinFn as s, SelectedFields as t, SelectedFieldsOrdered as u, LockConfig as v, PgSelectHKTBase as w, PgSelectKind as x, PgSelectQueryBuilderHKT as y, PgSelectHKT as z };