drizzle-orm 0.25.2 → 0.25.3-4cc2d87

package/{db.d-66553b9e.d.ts → db.d-bc9a1d6c.d.ts}

@@ -1,7 +1,7 @@
+import { S as SQL, k as ColumnBuilderHKTBase, ax as Assume, i as ColumnBuilderBaseConfig, b as ColumnHKTBase, C as ColumnBaseConfig, o as ColumnBuilder, at as Update, e as Column, f as AnyColumnHKT, ag as TableConfig$1, T as Table, ah as UpdateTableConfig, ak as AnyTableHKT, r as BuildColumns, B as BuildColumn, p as AnyColumnBuilder, aK as ColumnsSelection, V as View, ad as Subquery, ae as WithSubquery, aA as ValueOrArray, a9 as Placeholder, av as Simplify, H as Query, aj as AnyTable, v as SelectedFieldsFlat$1, x as SelectedFields$1, y as SelectedFieldsOrdered$1, J as SQLWrapper, aq as InferModel, ar as UpdateSet, G as GetColumnData, a5 as Param, $ as DriverValueEncoder, Q as QueryTypingsValue, A as AnyColumn, aI as KnownKeysOnly } from './column.d-c31e7ad3.js';
 import { MigrationMeta } from './migrator.js';
-import { S as SQL, d as ColumnHKTBase, C as ColumnBaseConfig, g as Column, ag as Update, j as ColumnBuilderHKTBase, aj as Assume, h as ColumnBuilderBaseConfig, n as ColumnBuilder, a8 as TableConfig$1, T as Table, a9 as UpdateTableConfig, q as BuildColumns, B as BuildColumn, o as AnyColumnBuilder, at as ColumnsSelection, V as View, a5 as Subquery, a6 as WithSubquery, am as ValueOrArray, P as Placeholder, ai as Simplify, y as Query, aa as AnyTable, s as SelectedFieldsFlat$1, u as SelectedFields$1, v as SelectedFieldsOrdered$1, b as SQLWrapper, ad as InferModel, ae as UpdateSet, G as GetColumnData, $ as Param, K as DriverValueEncoder, Q as QueryTypingsValue } from './column.d-8b137277.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-c3e86d45.js';
-import { Q as QueryPromise } from './query-promise.d-a8af8583.js';
+import { Q as QueryPromise, J as TablesRelationalConfig, I as TableRelationalConfig, H as DBQueryConfig, a2 as BuildRelationalQueryResult, U as BuildQueryResult, L as ExtractTablesWithRelations, K as RelationalSchemaConfig } from './query-promise.d-e370e0a9.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-34d7f74e.js';
 
 declare class CheckBuilder {
     name: string;
@@ -90,6 +90,9 @@ declare abstract class PgColumn<THKT extends ColumnHKTBase, T extends ColumnBase
 }> {
 }
 type AnyPgColumn<TPartial extends Partial<ColumnBaseConfig> = {}> = PgColumn<PgColumnHKT, Required<Update<ColumnBaseConfig, TPartial>>>;
+interface AnyPgColumnHKT extends AnyColumnHKT {
+    type: AnyPgColumn<Assume<this['config'], Partial<ColumnBaseConfig>>>;
+}
 
 interface IndexConfig {
     name?: string;
@@ -138,8 +141,8 @@ interface IndexBuilder extends AnyIndexBuilder {
 }
 declare class IndexBuilder implements AnyIndexBuilder {
     constructor(columns: IndexColumn[], unique: boolean, only: boolean, name?: string);
-    concurrently(): Omit<this, 'concurrently'>;
-    using(method: SQL): Omit<this, 'using'>;
+    concurrently(): this;
+    using(method: SQL): this;
     asc(): Omit<this, 'asc' | 'desc'>;
     desc(): Omit<this, 'asc' | 'desc'>;
     nullsFirst(): Omit<this, 'nullsFirst' | 'nullsLast'>;
@@ -174,6 +177,9 @@ type TableConfig = TableConfig$1<AnyPgColumn>;
 declare class PgTable<T extends TableConfig> extends Table<T> {
 }
 type AnyPgTable<TPartial extends Partial<TableConfig> = {}> = PgTable<UpdateTableConfig<TableConfig, TPartial>>;
+interface AnyPgTableHKT extends AnyTableHKT {
+    type: AnyPgTable<Assume<this['config'], Partial<TableConfig>>>;
+}
 type PgTableWithColumns<T extends TableConfig> = PgTable<T> & {
     [Key in keyof T['columns']]: T['columns'][Key];
 };
@@ -363,6 +369,12 @@ declare class PgSelectBuilder<TSelection extends SelectedFields | undefined, TBu
     private dialect;
     private withList;
     constructor(fields: TSelection, session: PgSession | undefined, dialect: PgDialect, withList?: Subquery[]);
+    /**
+     * Specify the table, subquery, or other target that you’re
+     * building a select query against.
+     *
+     * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-FROM|Postgres from documentation}
+     */
     from<TFrom extends AnyPgTable | Subquery | PgViewBase | SQL>(source: TFrom): CreatePgSelectFromBuilderMode<TBuilderMode, GetSelectTableName<TFrom>, TSelection extends undefined ? GetSelectTableSelection<TFrom> : TSelection, TSelection extends undefined ? 'single' : 'partial'>;
 }
 declare abstract class PgSelectQueryBuilder<THKT extends PgSelectHKTBase, TTableName extends string | undefined, TSelection extends ColumnsSelection, TSelectMode extends SelectMode, TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'> : {}> extends TypedQueryBuilder<BuildSubquerySelection<TSelection, TNullabilityMap>, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]> {
@@ -380,18 +392,126 @@ declare abstract class PgSelectQueryBuilder<THKT extends PgSelectHKTBase, TTable
     private tableName;
     constructor(table: PgSelectConfig['table'], fields: PgSelectConfig['fields'], isPartialSelect: boolean, session: PgSession | undefined, dialect: PgDialect, withList: Subquery[]);
     private createJoin;
+    /**
+     * For each row of the table, include
+     * values from a matching row of the joined
+     * table, if there is a matching row. If not,
+     * all of the columns of the joined table
+     * will be set to null.
+     */
     leftJoin: JoinFn<THKT, TTableName, TSelectMode, "left", TSelection, TNullabilityMap>;
+    /**
+     * Includes all of the rows of the joined table.
+     * If there is no matching row in the main table,
+     * all the columns of the main table will be
+     * set to null.
+     */
     rightJoin: JoinFn<THKT, TTableName, TSelectMode, "right", TSelection, TNullabilityMap>;
+    /**
+     * This is the default type of join.
+     *
+     * For each row of the table, the joined table
+     * needs to have a matching row, or it will
+     * be excluded from results.
+     */
     innerJoin: JoinFn<THKT, TTableName, TSelectMode, "inner", TSelection, TNullabilityMap>;
+    /**
+     * Rows from both the main & joined are included,
+     * regardless of whether or not they have matching
+     * rows in the other table.
+     */
     fullJoin: JoinFn<THKT, TTableName, TSelectMode, "full", TSelection, TNullabilityMap>;
+    /**
+     * Specify a condition to narrow the result set. Multiple
+     * conditions can be combined with the `and` and `or`
+     * functions.
+     *
+     * ## Examples
+     *
+     * ```ts
+     * // Find cars made in the year 2000
+     * db.select().from(cars).where(eq(cars.year, 2000));
+     * ```
+     */
     where(where: ((aliases: TSelection) => SQL | undefined) | SQL | undefined): this;
+    /**
+     * Sets the HAVING clause of this query, which often
+     * used with GROUP BY and filters rows after they've been
+     * grouped together and combined.
+     *
+     * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-HAVING|Postgres having clause documentation}
+     */
     having(having: ((aliases: TSelection) => SQL | undefined) | SQL | undefined): this;
+    /**
+     * Specify the GROUP BY of this query: given
+     * a list of columns or SQL expressions, Postgres will
+     * combine all rows with the same values in those columns
+     * into a single row.
+     *
+     * ## Examples
+     *
+     * ```ts
+     * // Group and count people by their last names
+     * db.select({
+     *    lastName: people.lastName,
+     *    count: sql<number>`count(*)::integer`
+     * }).from(people).groupBy(people.lastName);
+     * ```
+     *
+     * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-GROUPBY|Postgres GROUP BY documentation}
+     */
     groupBy(builder: (aliases: TSelection) => ValueOrArray<AnyPgColumn | SQL | SQL.Aliased>): this;
     groupBy(...columns: (AnyPgColumn | SQL | SQL.Aliased)[]): this;
+    /**
+     * Specify the ORDER BY clause of this query: a number of
+     * columns or SQL expressions that will control sorting
+     * of results. You can specify whether results are in ascending
+     * or descending order with the `asc()` and `desc()` operators.
+     *
+     * ## Examples
+     *
+     * ```
+     * // Select cars by year released
+     * db.select().from(cars).orderBy(cars.year);
+     * ```
+     *
+     * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-ORDERBY|Postgres ORDER BY documentation}
+     */
     orderBy(builder: (aliases: TSelection) => ValueOrArray<AnyPgColumn | SQL | SQL.Aliased>): this;
     orderBy(...columns: (AnyPgColumn | SQL | SQL.Aliased)[]): this;
+    /**
+     * Set the maximum number of rows that will be
+     * returned by this query.
+     *
+     * ## Examples
+     *
+     * ```ts
+     * // Get the first 10 people from this query.
+     * db.select().from(people).limit(10);
+     * ```
+     *
+     * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-LIMIT|Postgres LIMIT documentation}
+     */
     limit(limit: number | Placeholder): this;
+    /**
+     * Skip a number of rows when returning results
+     * from this query.
+     *
+     * ## Examples
+     *
+     * ```ts
+     * // Get the 10th-20th people from this query.
+     * db.select().from(people).offset(10).limit(10);
+     * ```
+     */
     offset(offset: number | Placeholder): this;
+    /**
+     * The FOR clause specifies a lock strength for this query
+     * that controls how strictly it acquires exclusive access to
+     * the rows being queried.
+     *
+     * {@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'>>;
     as<TAlias extends string>(alias: TAlias): SubqueryWithSelection<BuildSubquerySelection<TSelection, TNullabilityMap>, TAlias>;
@@ -400,6 +520,13 @@ interface PgSelect<TTableName extends string | undefined, TSelection extends Col
 }
 declare class PgSelect<TTableName extends string | undefined, TSelection, TSelectMode extends SelectMode, TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'> : {}> extends PgSelectQueryBuilder<PgSelectHKT, TTableName, TSelection, TSelectMode, TNullabilityMap> {
     private _prepare;
+    /**
+     * Create a prepared statement for this query. This allows
+     * the database to remember this query for the given session
+     * and call it by name, rather than specifying the full query.
+     *
+     * {@link https://www.postgresql.org/docs/current/sql-prepare.html|Postgres prepare documentation}
+     */
     prepare(name: string): PreparedQuery<PreparedQueryConfig & {
         execute: SelectResult<TSelection, TSelectMode, TNullabilityMap>[];
     }>;
@@ -420,6 +547,7 @@ type BuildAliasTable<TTable extends AnyTable, TAlias extends string> = PgTableWi
 interface PgSelectConfig {
     withList: Subquery[];
     fields: Record<string, unknown>;
+    fieldsFlat?: SelectedFieldsOrdered;
     where?: SQL;
     having?: SQL;
     table: AnyPgTable | Subquery | PgViewBase | SQL;
@@ -483,20 +611,30 @@ interface PgTransactionConfig {
     accessMode?: 'read only' | 'read write';
     deferrable?: boolean;
 }
-declare abstract class PgSession<TQueryResult extends QueryResultHKT = QueryResultHKT> {
+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;
     constructor(dialect: PgDialect);
-    abstract prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(query: Query, fields: SelectedFieldsOrdered | undefined, name: string | undefined): PreparedQuery<T>;
+    abstract prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(query: Query, fields: SelectedFieldsOrdered | undefined, name: string | undefined, customResultMapper?: (rows: 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>) => Promise<T>, config?: PgTransactionConfig): Promise<T>;
+    values<T = unknown>(query: SQL): Promise<T[]>;
+    abstract transaction<T>(transaction: (tx: PgTransaction<TQueryResult, TFullSchema, TSchema>) => Promise<T>, config?: PgTransactionConfig): Promise<T>;
 }
-declare abstract class PgTransaction<TQueryResult extends QueryResultHKT> extends PgDatabase<TQueryResult> {
+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;
-    constructor(dialect: PgDialect, session: PgSession, nestedIndex?: number);
+    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>) => Promise<T>): Promise<T>;
+    abstract transaction<T>(transaction: (tx: PgTransaction<TQueryResult, TFullSchema, TSchema>) => Promise<T>): Promise<T>;
 }
 interface QueryResultHKT {
     readonly $brand: 'QueryRowHKT';
@@ -671,7 +809,7 @@ declare class PgDialect {
      * If `isSingleTable` is true, then columns won't be prefixed with table name
      */
     private buildSelection;
-    buildSelectQuery({ withList, fields, where, having, table, joins, orderBy, groupBy, limit, offset, lockingClauses }: PgSelectConfig): SQL;
+    buildSelectQuery({ withList, fields, fieldsFlat, where, having, table, joins, orderBy, groupBy, limit, offset, lockingClauses }: PgSelectConfig): SQL;
     buildInsertQuery({ table, values, onConflict, returning }: PgInsertConfig): SQL;
     buildRefreshMaterializedViewQuery({ view, concurrently, withNoData }: {
         view: PgMaterializedView;
@@ -680,14 +818,53 @@ declare class PgDialect {
     }): SQL;
     prepareTyping(encoder: DriverValueEncoder<unknown, unknown>): QueryTypingsValue;
     sqlToQuery(sql: SQL): Query;
+    buildRelationalQuery(fullSchema: Record<string, unknown>, schema: TablesRelationalConfig, tableNamesMap: Record<string, string>, table: AnyPgTable, tableConfig: TableRelationalConfig, config: true | DBQueryConfig<'many', true>, tableAlias: string, relationColumns: AnyColumn[], isRoot?: boolean): BuildRelationalQueryResult;
+}
+
+declare class RelationalQueryBuilder<TSchema extends TablesRelationalConfig, TFields extends TableRelationalConfig> {
+    private fullSchema;
+    private schema;
+    private tableNamesMap;
+    private table;
+    private tableConfig;
+    private dialect;
+    private session;
+    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 class PgRelationalQuery<TResult> extends QueryPromise<TResult> {
+    private fullSchema;
+    private schema;
+    private tableNamesMap;
+    private table;
+    private tableConfig;
+    private dialect;
+    private session;
+    private config;
+    private mode;
+    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>;
 }
 
-declare class PgDatabase<TQueryResult extends QueryResultHKT> {
+declare class PgDatabase<TQueryResult extends QueryResultHKT, TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>> {
+    readonly _: {
+        readonly schema: TSchema | undefined;
+        readonly tableNamesMap: Record<string, string>;
+    };
+    query: {
+        [K in keyof TSchema]: RelationalQueryBuilder<TSchema, TSchema[K]>;
+    };
     constructor(
     /** @internal */
     dialect: PgDialect, 
     /** @internal */
-    session: PgSession<any>);
+    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>;
     };
@@ -704,7 +881,7 @@ declare class PgDatabase<TQueryResult extends QueryResultHKT> {
     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>) => Promise<T>, config?: PgTransactionConfig): Promise<T>;
+    transaction<T>(transaction: (tx: PgTransaction<TQueryResult, TFullSchema, TSchema>) => Promise<T>, config?: PgTransactionConfig): Promise<T>;
 }
 
-export { PgSelectBuilder as $, AnyPgTable as A, BuildAliasTable as B, Check as C, IndexBuilderOn as D, AnyIndexBuilder as E, ForeignKey as F, IndexBuilder as G, GetColumnsTableName as H, Index as I, index as J, uniqueIndex as K, primaryKey as L, PrimaryKeyBuilder as M, PgDeleteConfig as N, PgDelete as O, PreparedQueryConfig as P, QueryResultHKT as Q, Reference as R, SelectedFieldsOrdered as S, PgInsertConfig as T, UpdateDeleteAction as U, ViewWithConfig as V, PgInsertValue as W, PgInsertBuilder as X, PgInsert as Y, QueryBuilder as Z, PgRefreshMaterializedView as _, PreparedQuery as a, PgSelectQueryBuilder as a0, PgSelect as a1, JoinsValue as a2, AnyPgSelect as a3, PgSelectConfig as a4, JoinFn as a5, SelectedFieldsFlat as a6, SelectedFields as a7, LockStrength as a8, LockConfig as a9, PgMaterializedViewConfig as aA, PgMaterializedViewWithSelection as aB, PgSelectHKTBase as aa, PgSelectKind as ab, PgSelectQueryBuilderHKT as ac, PgSelectHKT as ad, PgUpdateConfig as ae, PgUpdateSetSource as af, PgUpdateBuilder as ag, PgUpdate as ah, QueryResultKind as ai, SubqueryWithSelection as aj, WithSubqueryWithSelection as ak, PgTableExtraConfig as al, TableConfig as am, PgTable as an, PgTableWithColumns as ao, pgTable as ap, pgTableCreator as aq, DefaultViewBuilderCore as ar, ViewBuilder as as, ManualViewBuilder as at, MaterializedViewBuilderCore as au, MaterializedViewBuilder as av, ManualMaterializedViewBuilder as aw, PgViewBase as ax, PgViewConfig as ay, PgViewWithSelection as az, PgSession as b, PgDialect as c, PgTransactionConfig as d, PgTransaction as e, PgDatabase as f, PgColumnBuilder as g, PgColumn as h, PgTableFn as i, pgMaterializedView as j, AnyPgColumn as k, PrimaryKey as l, PgView as m, PgMaterializedView as n, PgMaterializedViewWithConfig as o, pgView as p, CheckBuilder as q, check as r, PgArrayBuilderHKT as s, PgArrayHKT as t, PgArrayBuilder as u, PgArray as v, ForeignKeyBuilder as w, AnyForeignKeyBuilder as x, foreignKey as y, IndexColumn as z };
+export { PgInsertValue as $, AnyPgTable as A, BuildAliasTable as B, Check as C, Reference as D, ForeignKeyBuilder as E, ForeignKey as F, AnyForeignKeyBuilder as G, foreignKey as H, Index as I, IndexColumn as J, IndexBuilderOn as K, AnyIndexBuilder as L, IndexBuilder as M, GetColumnsTableName as N, index as O, PreparedQueryConfig as P, QueryResultHKT as Q, ReferenceConfig as R, SelectedFieldsOrdered as S, uniqueIndex as T, UpdateDeleteAction as U, ViewWithConfig as V, primaryKey as W, PrimaryKeyBuilder as X, PgDeleteConfig as Y, PgDelete as Z, PgInsertConfig as _, PreparedQuery as a, PgInsertBuilder as a0, PgInsert as a1, QueryBuilder as a2, PgRefreshMaterializedView as a3, PgSelectBuilder as a4, PgSelectQueryBuilder as a5, PgSelect as a6, JoinsValue as a7, AnyPgSelect as a8, PgSelectConfig as a9, MaterializedViewBuilderCore as aA, MaterializedViewBuilder as aB, ManualMaterializedViewBuilder as aC, PgViewBase as aD, PgViewConfig as aE, PgViewWithSelection as aF, PgMaterializedViewConfig as aG, PgMaterializedViewWithSelection as aH, JoinFn as aa, SelectedFieldsFlat as ab, SelectedFields as ac, LockStrength as ad, LockConfig as ae, PgSelectHKTBase as af, PgSelectKind as ag, PgSelectQueryBuilderHKT as ah, PgSelectHKT as ai, PgUpdateConfig as aj, PgUpdateSetSource as ak, PgUpdateBuilder as al, PgUpdate as am, QueryResultKind as an, SubqueryWithSelection as ao, WithSubqueryWithSelection as ap, PgTableExtraConfig as aq, TableConfig as ar, PgTable as as, AnyPgTableHKT as at, PgTableWithColumns as au, pgTable as av, pgTableCreator as aw, DefaultViewBuilderCore as ax, ViewBuilder as ay, ManualViewBuilder as az, PgSession as b, PgDialect as c, PgTransactionConfig as d, PgTransaction as e, PgDatabase as f, PgColumnBuilder as g, PgColumn as h, PgTableFn as i, pgMaterializedView as j, AnyPgColumn as k, PrimaryKey as l, PgView as m, PgMaterializedView as n, PgMaterializedViewWithConfig as o, pgView as p, CheckBuilder as q, check as r, PgArrayBuilderHKT as s, PgArrayHKT as t, PgArrayBuilder as u, PgArray as v, PgColumnBuilderHKT as w, PgColumnHKT as x, AnyPgColumnBuilder as y, AnyPgColumnHKT as z };

package/driver.d-17ca4c15.d.ts

@@ -0,0 +1,8 @@
+import { Database } from 'sql.js';
+import { B as BaseSQLiteDatabase } from './db.d-a2311092.js';
+import { aH as DrizzleConfig } from './column.d-c31e7ad3.js';
+
+type SQLJsDatabase<TSchema extends Record<string, unknown> = Record<string, never>> = BaseSQLiteDatabase<'sync', void, TSchema>;
+declare function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(client: Database, config?: DrizzleConfig<TSchema>): SQLJsDatabase<TSchema>;
+
+export { SQLJsDatabase as S, drizzle as d };

package/driver.d-300ddb0e.d.ts

@@ -0,0 +1,64 @@
+import { Q as QueryTypingsValue, L as Logger, H as Query, S as SQL, aH as DrizzleConfig } from './column.d-c31e7ad3.js';
+import { P as PreparedQueryConfig, a as PreparedQuery, S as SelectedFieldsOrdered, b as PgSession, c as PgDialect, d as PgTransactionConfig, e as PgTransaction, Q as QueryResultHKT, f as PgDatabase } from './db.d-bc9a1d6c.js';
+import { RDSDataClient, ExecuteStatementCommandOutput } from '@aws-sdk/client-rds-data';
+import { J as TablesRelationalConfig, K as RelationalSchemaConfig } from './query-promise.d-e370e0a9.js';
+
+type AwsDataApiClient = RDSDataClient;
+declare class AwsDataApiPreparedQuery<T extends PreparedQueryConfig> extends PreparedQuery<T> {
+    private client;
+    private params;
+    private typings;
+    private options;
+    private fields;
+    private customResultMapper?;
+    private rawQuery;
+    constructor(client: AwsDataApiClient, queryString: string, params: unknown[], typings: QueryTypingsValue[], options: AwsDataApiSessionOptions, fields: SelectedFieldsOrdered | undefined, 
+    /** @internal */
+    transactionId: string | undefined, customResultMapper?: ((rows: unknown[][]) => T['execute']) | undefined);
+    execute(placeholderValues?: Record<string, unknown> | undefined): Promise<T['execute']>;
+    all(placeholderValues?: Record<string, unknown> | undefined): Promise<T['all']>;
+    values(placeholderValues?: Record<string, unknown>): Promise<T['values']>;
+}
+interface AwsDataApiSessionOptions {
+    logger?: Logger;
+    database: string;
+    resourceArn: string;
+    secretArn: string;
+}
+declare class AwsDataApiSession<TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig> extends PgSession<AwsDataApiPgQueryResultHKT, TFullSchema, TSchema> {
+    private schema;
+    private options;
+    constructor(
+    /** @internal */
+    client: AwsDataApiClient, dialect: PgDialect, schema: RelationalSchemaConfig<TSchema> | undefined, options: AwsDataApiSessionOptions, 
+    /** @internal */
+    transactionId: string | undefined);
+    prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(query: Query, fields: SelectedFieldsOrdered | undefined, transactionId?: string, customResultMapper?: (rows: unknown[][]) => T['execute']): PreparedQuery<T>;
+    execute<T>(query: SQL): Promise<T>;
+    transaction<T>(transaction: (tx: AwsDataApiTransaction<TFullSchema, TSchema>) => Promise<T>, config?: PgTransactionConfig | undefined): Promise<T>;
+}
+declare class AwsDataApiTransaction<TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig> extends PgTransaction<AwsDataApiPgQueryResultHKT, TFullSchema, TSchema> {
+    transaction<T>(transaction: (tx: AwsDataApiTransaction<TFullSchema, TSchema>) => Promise<T>): Promise<T>;
+}
+interface AwsDataApiPgQueryResultHKT extends QueryResultHKT {
+    type: ExecuteStatementCommandOutput;
+}
+
+interface PgDriverOptions {
+    logger?: Logger;
+    database: string;
+    resourceArn: string;
+    secretArn: string;
+}
+interface DrizzleAwsDataApiPgConfig<TSchema extends Record<string, unknown> = Record<string, never>> extends DrizzleConfig<TSchema> {
+    database: string;
+    resourceArn: string;
+    secretArn: string;
+}
+type AwsDataApiPgDatabase<TSchema extends Record<string, unknown> = Record<string, never>> = PgDatabase<AwsDataApiPgQueryResultHKT, TSchema>;
+declare class AwsPgDialect extends PgDialect {
+    escapeParam(num: number): string;
+}
+declare function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(client: AwsDataApiClient, config: DrizzleAwsDataApiPgConfig<TSchema>): AwsDataApiPgDatabase<TSchema>;
+
+export { AwsDataApiPgDatabase as A, DrizzleAwsDataApiPgConfig as D, PgDriverOptions as P, AwsPgDialect as a, AwsDataApiClient as b, AwsDataApiPreparedQuery as c, drizzle as d, AwsDataApiSessionOptions as e, AwsDataApiSession as f, AwsDataApiTransaction as g, AwsDataApiPgQueryResultHKT as h };

package/driver.d-45e56643.d.ts

@@ -0,0 +1,60 @@
+import { Connection as Connection$1, Pool as Pool$1 } from 'mysql2';
+import { L as Logger, H as Query, S as SQL, ax as Assume, aH as DrizzleConfig } from './column.d-c31e7ad3.js';
+import { ae as PreparedQueryConfig, ah as PreparedQuery, a1 as SelectedFieldsOrdered, aj as MySqlSession, o as MySqlDialect, ag as PreparedQueryKind, ai as MySqlTransactionConfig, ak as MySqlTransaction, ac as QueryResultHKT, af as PreparedQueryHKT, n as MySqlDatabase } from './select.types.d-ae2f8e44.js';
+import { J as TablesRelationalConfig, K as RelationalSchemaConfig } from './query-promise.d-e370e0a9.js';
+import { Pool, Connection, ResultSetHeader, FieldPacket, RowDataPacket, OkPacket } from 'mysql2/promise';
+
+type MySql2Client = Pool | Connection;
+type MySqlRawQueryResult = [ResultSetHeader, FieldPacket[]];
+type MySqlQueryResultType = RowDataPacket[][] | RowDataPacket[] | OkPacket | OkPacket[] | ResultSetHeader;
+type MySqlQueryResult<T = any> = [T extends ResultSetHeader ? T : T[], FieldPacket[]];
+declare class MySql2PreparedQuery<T extends PreparedQueryConfig> extends PreparedQuery<T> {
+    private client;
+    private params;
+    private logger;
+    private fields;
+    private customResultMapper?;
+    private rawQuery;
+    private query;
+    constructor(client: MySql2Client, queryString: string, params: unknown[], logger: Logger, fields: SelectedFieldsOrdered | undefined, customResultMapper?: ((rows: unknown[][]) => T['execute']) | undefined);
+    execute(placeholderValues?: Record<string, unknown>): Promise<T['execute']>;
+    iterator(placeholderValues?: Record<string, unknown>): AsyncGenerator<T['execute'] extends any[] ? T['execute'][number] : T['execute']>;
+}
+interface MySql2SessionOptions {
+    logger?: Logger;
+}
+declare class MySql2Session<TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig> extends MySqlSession<MySql2QueryResultHKT, MySql2PreparedQueryHKT, TFullSchema, TSchema> {
+    private client;
+    private schema;
+    private options;
+    private logger;
+    constructor(client: MySql2Client, dialect: MySqlDialect, schema: RelationalSchemaConfig<TSchema> | undefined, options?: MySql2SessionOptions);
+    prepareQuery<T extends PreparedQueryConfig>(query: Query, fields: SelectedFieldsOrdered | undefined, customResultMapper?: (rows: unknown[][]) => T['execute']): PreparedQueryKind<MySql2PreparedQueryHKT, T>;
+    all<T = unknown>(query: SQL<unknown>): Promise<T[]>;
+    transaction<T>(transaction: (tx: MySql2Transaction<TFullSchema, TSchema>) => Promise<T>, config?: MySqlTransactionConfig): Promise<T>;
+}
+declare class MySql2Transaction<TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig> extends MySqlTransaction<MySql2QueryResultHKT, MySql2PreparedQueryHKT, TFullSchema, TSchema> {
+    transaction<T>(transaction: (tx: MySql2Transaction<TFullSchema, TSchema>) => Promise<T>): Promise<T>;
+}
+interface MySql2QueryResultHKT extends QueryResultHKT {
+    type: MySqlRawQueryResult;
+}
+interface MySql2PreparedQueryHKT extends PreparedQueryHKT {
+    type: MySql2PreparedQuery<Assume<this['config'], PreparedQueryConfig>>;
+}
+
+interface MySqlDriverOptions {
+    logger?: Logger;
+}
+declare class MySql2Driver {
+    private client;
+    private dialect;
+    private options;
+    constructor(client: MySql2Client, dialect: MySqlDialect, options?: MySqlDriverOptions);
+    createSession(schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined): MySql2Session<Record<string, unknown>, TablesRelationalConfig>;
+}
+
+type MySql2Database<TSchema extends Record<string, unknown> = Record<string, never>> = MySqlDatabase<MySql2QueryResultHKT, MySql2PreparedQueryHKT, TSchema>;
+declare function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(client: MySql2Client | Connection$1 | Pool$1, config?: DrizzleConfig<TSchema>): MySql2Database<TSchema>;
+
+export { MySqlDriverOptions as M, MySql2Driver as a, MySql2Database as b, MySql2Client as c, drizzle as d, MySqlRawQueryResult as e, MySqlQueryResultType as f, MySqlQueryResult as g, MySql2PreparedQuery as h, MySql2SessionOptions as i, MySql2Session as j, MySql2Transaction as k, MySql2QueryResultHKT as l, MySql2PreparedQueryHKT as m };

package/driver.d-64f2125c.d.ts

@@ -0,0 +1,8 @@
+import { ResultSet, Client } from '@libsql/client';
+import { B as BaseSQLiteDatabase } from './db.d-a2311092.js';
+import { aH as DrizzleConfig } from './column.d-c31e7ad3.js';
+
+type LibSQLDatabase<TSchema extends Record<string, unknown> = Record<string, never>> = BaseSQLiteDatabase<'async', ResultSet, TSchema>;
+declare function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(client: Client, config?: DrizzleConfig<TSchema>): LibSQLDatabase<TSchema>;
+
+export { LibSQLDatabase as L, drizzle as d };

package/driver.d-7fde2e9d.d.ts

@@ -0,0 +1,55 @@
+import { L as Logger, H as Query, ax as Assume, aH as DrizzleConfig } from './column.d-c31e7ad3.js';
+import { P as PreparedQueryConfig, a as PreparedQuery, S as SelectedFieldsOrdered, b as PgSession, c as PgDialect, d as PgTransactionConfig, e as PgTransaction, Q as QueryResultHKT, f as PgDatabase } from './db.d-bc9a1d6c.js';
+import { J as TablesRelationalConfig, K as RelationalSchemaConfig } from './query-promise.d-e370e0a9.js';
+import { Pool, PoolClient, Client, QueryResult, QueryResultRow } from '@neondatabase/serverless';
+
+type NeonClient = Pool | PoolClient | Client;
+declare class NeonPreparedQuery<T extends PreparedQueryConfig> extends PreparedQuery<T> {
+    private client;
+    private params;
+    private logger;
+    private fields;
+    private customResultMapper?;
+    private rawQuery;
+    private query;
+    constructor(client: NeonClient, queryString: string, params: unknown[], logger: Logger, fields: SelectedFieldsOrdered | undefined, name: string | undefined, customResultMapper?: ((rows: unknown[][]) => T['execute']) | undefined);
+    execute(placeholderValues?: Record<string, unknown> | undefined): Promise<T['execute']>;
+    all(placeholderValues?: Record<string, unknown> | undefined): Promise<T['all']>;
+    values(placeholderValues?: Record<string, unknown> | undefined): Promise<T['values']>;
+}
+interface NeonSessionOptions {
+    logger?: Logger;
+}
+declare class NeonSession<TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig> extends PgSession<NeonQueryResultHKT, TFullSchema, TSchema> {
+    private client;
+    private schema;
+    private options;
+    private logger;
+    constructor(client: NeonClient, dialect: PgDialect, schema: RelationalSchemaConfig<TSchema> | undefined, options?: NeonSessionOptions);
+    prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(query: Query, fields: SelectedFieldsOrdered | undefined, name: string | undefined, customResultMapper?: (rows: unknown[][]) => T['execute']): PreparedQuery<T>;
+    query(query: string, params: unknown[]): Promise<QueryResult>;
+    queryObjects<T extends QueryResultRow>(query: string, params: unknown[]): Promise<QueryResult<T>>;
+    transaction<T>(transaction: (tx: NeonTransaction<TFullSchema, TSchema>) => Promise<T>, config?: PgTransactionConfig): Promise<T>;
+}
+declare class NeonTransaction<TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig> extends PgTransaction<NeonQueryResultHKT, TFullSchema, TSchema> {
+    transaction<T>(transaction: (tx: NeonTransaction<TFullSchema, TSchema>) => Promise<T>): Promise<T>;
+}
+interface NeonQueryResultHKT extends QueryResultHKT {
+    type: QueryResult<Assume<this['row'], QueryResultRow>>;
+}
+
+interface NeonDriverOptions {
+    logger?: Logger;
+}
+declare class NeonDriver {
+    private client;
+    private dialect;
+    private options;
+    constructor(client: NeonClient, dialect: PgDialect, options?: NeonDriverOptions);
+    createSession(schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined): NeonSession<Record<string, unknown>, TablesRelationalConfig>;
+    initMappers(): void;
+}
+type NeonDatabase<TSchema extends Record<string, unknown> = Record<string, never>> = PgDatabase<NeonQueryResultHKT, TSchema>;
+declare function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(client: NeonClient, config?: DrizzleConfig<TSchema>): NeonDatabase<TSchema>;
+
+export { NeonDriverOptions as N, NeonDriver as a, NeonDatabase as b, NeonClient as c, drizzle as d, NeonPreparedQuery as e, NeonSessionOptions as f, NeonSession as g, NeonTransaction as h, NeonQueryResultHKT as i };

package/driver.d-9d703b84.d.ts

@@ -0,0 +1,8 @@
+import { RunResult, Database } from 'better-sqlite3';
+import { B as BaseSQLiteDatabase } from './db.d-a2311092.js';
+import { aH as DrizzleConfig } from './column.d-c31e7ad3.js';
+
+type BetterSQLite3Database<TSchema extends Record<string, unknown> = Record<string, never>> = BaseSQLiteDatabase<'sync', RunResult, TSchema>;
+declare function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(client: Database, config?: DrizzleConfig<TSchema>): BetterSQLite3Database<TSchema>;
+
+export { BetterSQLite3Database as B, drizzle as d };

package/driver.d-b2b94bf9.d.ts

@@ -0,0 +1,46 @@
+import { Sql, RowList, Row, TransactionSql } from 'postgres';
+import { P as PreparedQueryConfig, a as PreparedQuery, S as SelectedFieldsOrdered, b as PgSession, c as PgDialect, d as PgTransactionConfig, e as PgTransaction, Q as QueryResultHKT, f as PgDatabase } from './db.d-bc9a1d6c.js';
+import { L as Logger, H as Query, ax as Assume, aH as DrizzleConfig } from './column.d-c31e7ad3.js';
+import { J as TablesRelationalConfig, K as RelationalSchemaConfig } from './query-promise.d-e370e0a9.js';
+
+declare class PostgresJsPreparedQuery<T extends PreparedQueryConfig> extends PreparedQuery<T> {
+    private client;
+    private query;
+    private params;
+    private logger;
+    private fields;
+    private customResultMapper?;
+    constructor(client: Sql, query: string, params: unknown[], logger: Logger, fields: SelectedFieldsOrdered | undefined, customResultMapper?: ((rows: unknown[][]) => T['execute']) | undefined);
+    execute(placeholderValues?: Record<string, unknown> | undefined): Promise<T['execute']>;
+    all(placeholderValues?: Record<string, unknown> | undefined): Promise<T['all']>;
+    values(placeholderValues?: Record<string, unknown> | undefined): Promise<T['values']>;
+}
+interface PostgresJsSessionOptions {
+    logger?: Logger;
+}
+declare class PostgresJsSession<TSQL extends Sql, TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig> extends PgSession<PostgresJsQueryResultHKT, TFullSchema, TSchema> {
+    client: TSQL;
+    private schema;
+    logger: Logger;
+    constructor(client: TSQL, dialect: PgDialect, schema: RelationalSchemaConfig<TSchema> | undefined, 
+    /** @internal */
+    options?: PostgresJsSessionOptions);
+    prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(query: Query, fields: SelectedFieldsOrdered | undefined, name: string | undefined, customResultMapper?: (rows: unknown[][]) => T['execute']): PreparedQuery<T>;
+    query(query: string, params: unknown[]): Promise<RowList<Row[]>>;
+    queryObjects<T extends Row>(query: string, params: unknown[]): Promise<RowList<T[]>>;
+    transaction<T>(transaction: (tx: PostgresJsTransaction<TFullSchema, TSchema>) => Promise<T>, config?: PgTransactionConfig): Promise<T>;
+}
+declare class PostgresJsTransaction<TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig> extends PgTransaction<PostgresJsQueryResultHKT, TFullSchema, TSchema> {
+    constructor(dialect: PgDialect, 
+    /** @internal */
+    session: PostgresJsSession<TransactionSql, TFullSchema, TSchema>, schema: RelationalSchemaConfig<TSchema> | undefined, nestedIndex?: number);
+    transaction<T>(transaction: (tx: PostgresJsTransaction<TFullSchema, TSchema>) => Promise<T>): Promise<T>;
+}
+interface PostgresJsQueryResultHKT extends QueryResultHKT {
+    type: RowList<Assume<this['row'], Row>[]>;
+}
+
+type PostgresJsDatabase<TSchema extends Record<string, unknown> = Record<string, never>> = PgDatabase<PostgresJsQueryResultHKT, TSchema>;
+declare function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(client: Sql, config?: DrizzleConfig<TSchema>): PostgresJsDatabase<TSchema>;
+
+export { PostgresJsDatabase as P, PostgresJsPreparedQuery as a, PostgresJsSessionOptions as b, PostgresJsSession as c, drizzle as d, PostgresJsTransaction as e, PostgresJsQueryResultHKT as f };

package/driver.d-b70ee7ee.d.ts

@@ -0,0 +1,55 @@
+import { L as Logger, H as Query, ax as Assume, aH as DrizzleConfig } from './column.d-c31e7ad3.js';
+import { P as PreparedQueryConfig, a as PreparedQuery, S as SelectedFieldsOrdered, b as PgSession, c as PgDialect, d as PgTransactionConfig, e as PgTransaction, Q as QueryResultHKT, f as PgDatabase } from './db.d-bc9a1d6c.js';
+import { J as TablesRelationalConfig, K as RelationalSchemaConfig } from './query-promise.d-e370e0a9.js';
+import pg, { PoolClient, Client, QueryResult, QueryResultRow } from 'pg';
+
+type NodePgClient = pg.Pool | PoolClient | Client;
+declare class NodePgPreparedQuery<T extends PreparedQueryConfig> extends PreparedQuery<T> {
+    private client;
+    private params;
+    private logger;
+    private fields;
+    private customResultMapper?;
+    private rawQuery;
+    private query;
+    constructor(client: NodePgClient, queryString: string, params: unknown[], logger: Logger, fields: SelectedFieldsOrdered | undefined, name: string | undefined, customResultMapper?: ((rows: unknown[][]) => T['execute']) | undefined);
+    execute(placeholderValues?: Record<string, unknown> | undefined): Promise<T['execute']>;
+    all(placeholderValues?: Record<string, unknown> | undefined): Promise<T['all']>;
+    values(placeholderValues?: Record<string, unknown> | undefined): Promise<T['values']>;
+}
+interface NodePgSessionOptions {
+    logger?: Logger;
+}
+declare class NodePgSession<TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig> extends PgSession<NodePgQueryResultHKT, TFullSchema, TSchema> {
+    private client;
+    private schema;
+    private options;
+    private logger;
+    constructor(client: NodePgClient, dialect: PgDialect, schema: RelationalSchemaConfig<TSchema> | undefined, options?: NodePgSessionOptions);
+    prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(query: Query, fields: SelectedFieldsOrdered | undefined, name: string | undefined, customResultMapper?: (rows: unknown[][]) => T['execute']): PreparedQuery<T>;
+    query(query: string, params: unknown[]): Promise<QueryResult>;
+    queryObjects<T extends QueryResultRow>(query: string, params: unknown[]): Promise<QueryResult<T>>;
+    transaction<T>(transaction: (tx: NodePgTransaction<TFullSchema, TSchema>) => Promise<T>, config?: PgTransactionConfig | undefined): Promise<T>;
+}
+declare class NodePgTransaction<TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig> extends PgTransaction<NodePgQueryResultHKT, TFullSchema, TSchema> {
+    transaction<T>(transaction: (tx: NodePgTransaction<TFullSchema, TSchema>) => Promise<T>): Promise<T>;
+}
+interface NodePgQueryResultHKT extends QueryResultHKT {
+    type: QueryResult<Assume<this['row'], QueryResultRow>>;
+}
+
+interface PgDriverOptions {
+    logger?: Logger;
+}
+declare class NodePgDriver {
+    private client;
+    private dialect;
+    private options;
+    constructor(client: NodePgClient, dialect: PgDialect, options?: PgDriverOptions);
+    createSession(schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined): NodePgSession<Record<string, unknown>, TablesRelationalConfig>;
+    initMappers(): void;
+}
+type NodePgDatabase<TSchema extends Record<string, unknown> = Record<string, never>> = PgDatabase<NodePgQueryResultHKT, TSchema>;
+declare function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(client: NodePgClient, config?: DrizzleConfig<TSchema>): NodePgDatabase<TSchema>;
+
+export { NodePgDriver as N, PgDriverOptions as P, NodePgDatabase as a, NodePgClient as b, NodePgPreparedQuery as c, drizzle as d, NodePgSessionOptions as e, NodePgSession as f, NodePgTransaction as g, NodePgQueryResultHKT as h };