alepha 0.11.4 → 0.11.5

package/postgres.d.ts

@@ -1 +1,1861 @@
-export * from '@alepha/postgres';
+import * as _alepha_core10 from "alepha";
+import { Alepha, AlephaError, Descriptor, DescriptorArgs, KIND, Page, Static, StaticEncode, TBigInt, TInteger, TNull, TNumber, TNumberOptions, TObject, TObjectOptions, TOptional, TPage, TSchema, TString, TStringOptions, TUnion, TUnsafe, pageSchema } from "alepha";
+import { DateTime, DateTimeProvider } from "alepha/datetime";
+import * as drizzle_orm0 from "drizzle-orm";
+import { BuildExtraConfigColumns, SQL, SQLWrapper, sql } from "drizzle-orm";
+import * as drizzle_orm_pg_core0 from "drizzle-orm/pg-core";
+import { LockConfig, LockStrength, PgColumn, PgColumnBuilderBase, PgDatabase, PgInsertValue, PgSchema, PgSelectBase, PgSequenceOptions, PgTableExtraConfigValue, PgTableWithColumns, PgTransaction, PgTransactionConfig, UpdateDeleteAction } from "drizzle-orm/pg-core";
+import * as _alepha_logger0 from "alepha/logger";
+import * as _alepha_lock0 from "alepha/lock";
+import { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import postgres from "postgres";
+import * as _alepha_retry0 from "alepha/retry";
+import * as typebox11 from "typebox";
+import { PgTransactionConfig as PgTransactionConfig$1 } from "drizzle-orm/pg-core/session";
+import * as DrizzleKit from "drizzle-kit/api";
+import { MigrationConfig } from "drizzle-orm/migrator";
+import * as dayjs0 from "dayjs";
+import { UpdateDeleteAction as UpdateDeleteAction$1 } from "drizzle-orm/pg-core/foreign-keys";
+export * from "drizzle-orm/pg-core";
+
+//#region src/schemas/insertSchema.d.ts
+/**
+ * Transforms a TObject schema for insert operations.
+ * All default properties at the root level are made optional.
+ *
+ * @example
+ * Before: { name: string; age: number(default=0); }
+ * After:  { name: string; age?: number; }
+ */
+type TObjectInsert<T extends TObject> = TObject<{ [K in keyof T["properties"]]: T["properties"][K] extends {
+  [PG_DEFAULT]: any;
+} | {
+  "~optional": true;
+} ? TOptional<T["properties"][K]> : T["properties"][K] }>;
+declare const insertSchema: <T extends TObject>(obj: T) => TObjectInsert<T>;
+//#endregion
+//#region src/schemas/updateSchema.d.ts
+/**
+ * Transforms a TObject schema for update operations.
+ * All optional properties at the root level are made nullable (i.e., `T | null`).
+ * This allows an API endpoint to explicitly accept `null` to clear an optional field in the database.
+ *
+ * @example
+ * Before: { name?: string; age: number; }
+ * After:  { name?: string | null; age: number; }
+ */
+type TObjectUpdate<T extends TObject> = TObject<{ [K in keyof T["properties"]]: T["properties"][K] extends TOptional<infer U> ? TOptional<TUnion<[U, TNull]>> : T["properties"][K] }>;
+declare const updateSchema: <T extends TObject>(schema: T) => TObjectUpdate<T>;
+//#endregion
+//#region src/descriptors/$entity.d.ts
+/**
+ * Creates a database entity descriptor that defines table structure using TypeBox schemas.
+ *
+ * @example
+ * ```ts
+ * import { t } from "alepha";
+ * import { $entity } from "alepha/postgres";
+ *
+ * const userEntity = $entity({
+ *   name: "users",
+ *   schema: t.object({
+ *     id: pg.primaryKey(),
+ *     name: t.text(),
+ *     email: t.email(),
+ *   }),
+ * });
+ * ```
+ */
+declare const $entity: {
+  <TSchema$1 extends TObject>(options: EntityDescriptorOptions<TSchema$1>): EntityDescriptor<TSchema$1>;
+  [KIND]: typeof EntityDescriptor;
+};
+interface EntityDescriptorOptions<T extends TObject, Keys = keyof Static<T>> {
+  /**
+   * The database table name that will be created for this entity.
+   * If not provided, name will be inferred from the $repository variable name.
+   */
+  name: string;
+  /**
+   * TypeBox schema defining the table structure and column types.
+   */
+  schema: T;
+  /**
+   * Database indexes to create for query optimization.
+   */
+  indexes?: (Keys | {
+    /**
+     * Single column to index.
+     */
+    column: Keys;
+    /**
+     * Whether this should be a unique index (enforces uniqueness constraint).
+     */
+    unique?: boolean;
+    /**
+     * Custom name for the index. If not provided, generates name automatically.
+     */
+    name?: string;
+  } | {
+    /**
+     * Multiple columns for composite index (order matters for query optimization).
+     */
+    columns: Keys[];
+    /**
+     * Whether this should be a unique index (enforces uniqueness constraint).
+     */
+    unique?: boolean;
+    /**
+     * Custom name for the index. If not provided, generates name automatically.
+     */
+    name?: string;
+  })[];
+  /**
+   * Foreign key constraints to maintain referential integrity.
+   */
+  foreignKeys?: Array<{
+    /**
+     * Optional name for the foreign key constraint.
+     */
+    name?: string;
+    /**
+     * Local columns that reference the foreign table.
+     */
+    columns: Array<keyof Static<T>>;
+    /**
+     * Referenced columns in the foreign table.
+     * Must be EntityColumn references from other entities.
+     */
+    foreignColumns: Array<() => EntityColumn<any>>;
+  }>;
+  /**
+   * Additional table constraints for data validation.
+   *
+   * Constraints enforce business rules at the database level, providing
+   * an additional layer of data integrity beyond application validation.
+   *
+   * **Constraint Types**:
+   * - **Unique constraints**: Prevent duplicate values across columns
+   * - **Check constraints**: Enforce custom validation rules with SQL expressions
+   *
+   * @example
+   * ```ts
+   * constraints: [
+   *   {
+   *     name: "unique_user_email",
+   *     columns: ["email"],
+   *     unique: true
+   *   },
+   *   {
+   *     name: "valid_age_range",
+   *     columns: ["age"],
+   *     check: sql`age >= 0 AND age <= 150`
+   *   },
+   *   {
+   *     name: "unique_user_username_per_tenant",
+   *     columns: ["tenantId", "username"],
+   *     unique: true
+   *   }
+   * ]
+   * ```
+   */
+  constraints?: Array<{
+    /**
+     * Columns involved in this constraint.
+     */
+    columns: Array<keyof Static<T>>;
+    /**
+     * Optional name for the constraint.
+     */
+    name?: string;
+    /**
+     * Whether this is a unique constraint.
+     */
+    unique?: boolean | {};
+    /**
+     * SQL expression for check constraint validation.
+     */
+    check?: SQL;
+  }>;
+  /**
+   * Advanced Drizzle ORM configuration for complex table setups.
+   */
+  config?: (self: BuildExtraConfigColumns<string, FromSchema<T>, "pg">) => PgTableExtraConfigValue[];
+}
+declare class EntityDescriptor<T extends TObject = TObject> {
+  readonly options: EntityDescriptorOptions<T>;
+  constructor(options: EntityDescriptorOptions<T>);
+  alias(alias: string): this;
+  get cols(): EntityColumns<T>;
+  get name(): string;
+  get schema(): T;
+  get insertSchema(): TObjectInsert<T>;
+  get updateSchema(): TObjectUpdate<T>;
+}
+/**
+ * Convert a schema to columns.
+ */
+type FromSchema<T extends TObject> = { [key in keyof T["properties"]]: PgColumnBuilderBase };
+type SchemaToTableConfig<T extends TObject> = {
+  name: string;
+  schema: string | undefined;
+  columns: { [key in keyof T["properties"]]: PgColumn };
+  dialect: string;
+};
+type EntityColumn<T extends TObject> = {
+  name: string;
+  entity: EntityDescriptor<T>;
+};
+type EntityColumns<T extends TObject> = { [key in keyof T["properties"]]: EntityColumn<T> };
+//#endregion
+//#region src/constants/PG_SYMBOLS.d.ts
+declare const PG_DEFAULT: unique symbol;
+declare const PG_PRIMARY_KEY: unique symbol;
+declare const PG_CREATED_AT: unique symbol;
+declare const PG_UPDATED_AT: unique symbol;
+declare const PG_DELETED_AT: unique symbol;
+declare const PG_VERSION: unique symbol;
+declare const PG_IDENTITY: unique symbol;
+declare const PG_ENUM: unique symbol;
+declare const PG_REF: unique symbol;
+/**
+ * @deprecated Use `PG_IDENTITY` instead.
+ */
+declare const PG_SERIAL: unique symbol;
+type PgDefault = typeof PG_DEFAULT;
+type PgRef = typeof PG_REF;
+type PgPrimaryKey = typeof PG_PRIMARY_KEY;
+type PgSymbols = {
+  [PG_DEFAULT]: {};
+  [PG_PRIMARY_KEY]: {};
+  [PG_CREATED_AT]: {};
+  [PG_UPDATED_AT]: {};
+  [PG_DELETED_AT]: {};
+  [PG_VERSION]: {};
+  [PG_IDENTITY]: PgIdentityOptions;
+  [PG_REF]: PgRefOptions;
+  [PG_ENUM]: PgEnumOptions;
+  /**
+   * @deprecated Use `PG_IDENTITY` instead.
+   */
+  [PG_SERIAL]: {};
+};
+type PgSymbolKeys = keyof PgSymbols;
+type PgIdentityOptions = {
+  mode: "always" | "byDefault";
+} & PgSequenceOptions & {
+  name?: string;
+};
+interface PgEnumOptions {
+  name?: string;
+}
+interface PgRefOptions {
+  ref: () => {
+    name: string;
+    entity: EntityDescriptor;
+  };
+  actions?: {
+    onUpdate?: UpdateDeleteAction;
+    onDelete?: UpdateDeleteAction;
+  };
+}
+//#endregion
+//#region src/errors/PgError.d.ts
+declare class PgError extends AlephaError {
+  name: string;
+  constructor(message: string, cause?: unknown);
+}
+//#endregion
+//#region src/helpers/pgAttr.d.ts
+/**
+ * Decorates a typebox schema with a Postgres attribute.
+ *
+ * > It's just a fancy way to add Symbols to a field.
+ *
+ * @example
+ * ```ts
+ * import { t } from "alepha";
+ * import { PG_UPDATED_AT } from "../constants/PG_SYMBOLS";
+ *
+ * export const updatedAtSchema = pgAttr(
+ *   t.datetime(), PG_UPDATED_AT,
+ * );
+ * ```
+ */
+declare const pgAttr: <T extends TSchema, Attr extends PgSymbolKeys>(type: T, attr: Attr, value?: PgSymbols[Attr]) => PgAttr<T, Attr>;
+/**
+ * Retrieves the fields of a schema that have a specific attribute.
+ */
+declare const getAttrFields: (schema: TObject, name: PgSymbolKeys) => PgAttrField[];
+/**
+ * Type representation.
+ */
+type PgAttr<T extends TSchema, TAttr extends PgSymbolKeys> = T & { [K in TAttr]: PgSymbols[K] };
+interface PgAttrField {
+  key: string;
+  type: TSchema;
+  data: any;
+  nested?: any[];
+  one?: boolean;
+}
+//#endregion
+//#region src/interfaces/FilterOperators.d.ts
+interface FilterOperators<TValue> {
+  /**
+   * Test that two values are equal.
+   *
+   * Remember that the SQL standard dictates that
+   * two NULL values are not equal, so if you want to test
+   * whether a value is null, you may want to use
+   * `isNull` instead.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Select cars made by Ford
+   * db.select().from(cars)
+   *   .where(eq(cars.make, 'Ford'))
+   * ```
+   *
+   * @see isNull for a way to test equality to NULL.
+   */
+  eq?: TValue;
+  /**
+   * Test that two values are not equal.
+   *
+   * Remember that the SQL standard dictates that
+   * two NULL values are not equal, so if you want to test
+   * whether a value is not null, you may want to use
+   * `isNotNull` instead.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Select cars not made by Ford
+   * db.select().from(cars)
+   *   .where(ne(cars.make, 'Ford'))
+   * ```
+   *
+   * @see isNotNull for a way to test whether a value is not null.
+   */
+  ne?: TValue;
+  /**
+   * Test that the first expression passed is greater than
+   * the second expression.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Select cars made after 2000.
+   * db.select().from(cars)
+   *   .where(gt(cars.year, 2000))
+   * ```
+   *
+   * @see gte for greater-than-or-equal
+   */
+  gt?: TValue;
+  /**
+   * Test that the first expression passed is greater than
+   * or equal to the second expression. Use `gt` to
+   * test whether an expression is strictly greater
+   * than another.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Select cars made on or after 2000.
+   * db.select().from(cars)
+   *   .where(gte(cars.year, 2000))
+   * ```
+   *
+   * @see gt for a strictly greater-than condition
+   */
+  gte?: TValue;
+  /**
+   * Test that the first expression passed is less than
+   * the second expression.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Select cars made before 2000.
+   * db.select().from(cars)
+   *   .where(lt(cars.year, 2000))
+   * ```
+   *
+   * @see lte for greater-than-or-equal
+   */
+  lt?: TValue;
+  /**
+   * Test that the first expression passed is less than
+   * or equal to the second expression.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Select cars made before 2000.
+   * db.select().from(cars)
+   *   .where(lte(cars.year, 2000))
+   * ```
+   *
+   * @see lt for a strictly less-than condition
+   */
+  lte?: TValue;
+  /**
+   * Test whether the first parameter, a column or expression,
+   * has a value from a list passed as the second argument.
+   *
+   * ## Throws
+   *
+   * The argument passed in the second array can't be empty:
+   * if an empty is provided, this method will throw.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Select cars made by Ford or GM.
+   * db.select().from(cars)
+   *   .where(inArray(cars.make, ['Ford', 'GM']))
+   * ```
+   *
+   * @see notInArray for the inverse of this test
+   */
+  inArray?: TValue[];
+  /**
+   * Test whether the first parameter, a column or expression,
+   * has a value that is not present in a list passed as the
+   * second argument.
+   *
+   * ## Throws
+   *
+   * The argument passed in the second array can't be empty:
+   * if an empty is provided, this method will throw.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Select cars made by any company except Ford or GM.
+   * db.select().from(cars)
+   *   .where(notInArray(cars.make, ['Ford', 'GM']))
+   * ```
+   *
+   * @see inArray for the inverse of this test
+   */
+  notInArray?: TValue[];
+  /**
+   * Test whether an expression is not NULL. By the SQL standard,
+   * NULL is neither equal nor not equal to itself, so
+   * it's recommended to use `isNull` and `notIsNull` for
+   * comparisons to NULL.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Select cars that have been discontinued.
+   * db.select().from(cars)
+   *   .where(isNotNull(cars.discontinuedAt))
+   * ```
+   *
+   * @see isNull for the inverse of this test
+   */
+  isNotNull?: true;
+  /**
+   * Test whether an expression is NULL. By the SQL standard,
+   * NULL is neither equal nor not equal to itself, so
+   * it's recommended to use `isNull` and `notIsNull` for
+   * comparisons to NULL.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Select cars that have no discontinuedAt date.
+   * db.select().from(cars)
+   *   .where(isNull(cars.discontinuedAt))
+   * ```
+   *
+   * @see isNotNull for the inverse of this test
+   */
+  isNull?: true;
+  /**
+   * Test whether an expression is between two values. This
+   * is an easier way to express range tests, which would be
+   * expressed mathematically as `x <= a <= y` but in SQL
+   * would have to be like `a >= x AND a <= y`.
+   *
+   * Between is inclusive of the endpoints: if `column`
+   * is equal to `min` or `max`, it will be TRUE.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Select cars made between 1990 and 2000
+   * db.select().from(cars)
+   *   .where(between(cars.year, 1990, 2000))
+   * ```
+   *
+   * @see notBetween for the inverse of this test
+   */
+  between?: [number, number];
+  /**
+   * Test whether an expression is not between two values.
+   *
+   * This, like `between`, includes its endpoints, so if
+   * the `column` is equal to `min` or `max`, in this case
+   * it will evaluate to FALSE.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Exclude cars made in the 1970s
+   * db.select().from(cars)
+   *   .where(notBetween(cars.year, 1970, 1979))
+   * ```
+   *
+   * @see between for the inverse of this test
+   */
+  notBetween?: [number, number];
+  /**
+   * Compare a column to a pattern, which can include `%` and `_`
+   * characters to match multiple variations. Including `%`
+   * in the pattern matches zero or more characters, and including
+   * `_` will match a single character.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Select all cars with 'Turbo' in their names.
+   * db.select().from(cars)
+   *   .where(like(cars.name, '%Turbo%'))
+   * ```
+   *
+   * @see ilike for a case-insensitive version of this condition
+   */
+  like?: string;
+  /**
+   * The inverse of like - this tests that a given column
+   * does not match a pattern, which can include `%` and `_`
+   * characters to match multiple variations. Including `%`
+   * in the pattern matches zero or more characters, and including
+   * `_` will match a single character.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Select all cars that don't have "ROver" in their name.
+   * db.select().from(cars)
+   *   .where(notLike(cars.name, '%Rover%'))
+   * ```
+   *
+   * @see like for the inverse condition
+   * @see notIlike for a case-insensitive version of this condition
+   */
+  notLike?: string;
+  /**
+   * Case-insensitively compare a column to a pattern,
+   * which can include `%` and `_`
+   * characters to match multiple variations. Including `%`
+   * in the pattern matches zero or more characters, and including
+   * `_` will match a single character.
+   *
+   * Unlike like, this performs a case-insensitive comparison.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Select all cars with 'Turbo' in their names.
+   * db.select().from(cars)
+   *   .where(ilike(cars.name, '%Turbo%'))
+   * ```
+   *
+   * @see like for a case-sensitive version of this condition
+   */
+  ilike?: string;
+  /**
+   * The inverse of ilike - this case-insensitively tests that a given column
+   * does not match a pattern, which can include `%` and `_`
+   * characters to match multiple variations. Including `%`
+   * in the pattern matches zero or more characters, and including
+   * `_` will match a single character.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Select all cars that don't have "Rover" in their name.
+   * db.select().from(cars)
+   *   .where(notLike(cars.name, '%Rover%'))
+   * ```
+   *
+   * @see ilike for the inverse condition
+   * @see notLike for a case-sensitive version of this condition
+   */
+  notIlike?: string;
+  /**
+   * Test that a column or expression contains all elements of
+   * the list passed as the second argument.
+   *
+   * ## Throws
+   *
+   * The argument passed in the second array can't be empty:
+   * if an empty is provided, this method will throw.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Select posts where its tags contain "Typescript" and "ORM".
+   * db.select().from(posts)
+   *   .where(arrayContains(posts.tags, ['Typescript', 'ORM']))
+   * ```
+   *
+   * @see arrayContained to find if an array contains all elements of a column or expression
+   * @see arrayOverlaps to find if a column or expression contains any elements of an array
+   */
+  arrayContains?: TValue;
+  /**
+   * Test that the list passed as the second argument contains
+   * all elements of a column or expression.
+   *
+   * ## Throws
+   *
+   * The argument passed in the second array can't be empty:
+   * if an empty is provided, this method will throw.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Select posts where its tags contain "Typescript", "ORM" or both,
+   * // but filtering posts that have additional tags.
+   * db.select().from(posts)
+   *   .where(arrayContained(posts.tags, ['Typescript', 'ORM']))
+   * ```
+   *
+   * @see arrayContains to find if a column or expression contains all elements of an array
+   * @see arrayOverlaps to find if a column or expression contains any elements of an array
+   */
+  arrayContained?: TValue;
+  /**
+   * Test that a column or expression contains any elements of
+   * the list passed as the second argument.
+   *
+   * ## Throws
+   *
+   * The argument passed in the second array can't be empty:
+   * if an empty is provided, this method will throw.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Select posts where its tags contain "Typescript", "ORM" or both.
+   * db.select().from(posts)
+   *   .where(arrayOverlaps(posts.tags, ['Typescript', 'ORM']))
+   * ```
+   *
+   * @see arrayContains to find if a column or expression contains all elements of an array
+   * @see arrayContained to find if an array contains all elements of a column or expression
+   */
+  arrayOverlaps?: TValue;
+}
+//#endregion
+//#region src/interfaces/PgQueryWhere.d.ts
+type PgQueryWhere<T extends TObject, Relations extends PgRelationMap<TObject> | undefined = undefined> = (PgQueryWhereOperators<T> & PgQueryWhereConditions<T>) | (PgQueryWhereRelations<Relations> & PgQueryWhereOperators<T> & PgQueryWhereConditions<T, Relations>);
+type PgQueryWhereOrSQL<T extends TObject, Relations extends PgRelationMap<TObject> | undefined = undefined> = SQLWrapper | PgQueryWhere<T, Relations>;
+type PgQueryWhereOperators<T extends TObject> = { [Key in keyof Static<T>]?: FilterOperators<Static<T>[Key]> | Static<T>[Key] | (Static<T>[Key] extends object ? NestedJsonbQuery<Static<T>[Key]> : never) };
+type PgQueryWhereConditions<T extends TObject, Relations extends PgRelationMap<TObject> | undefined = undefined> = {
+  /**
+   * Combine a list of conditions with the `and` operator. Conditions
+   * that are equal `undefined` are automatically ignored.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * db.select().from(cars)
+   *   .where(
+   *     and(
+   *       eq(cars.make, 'Volvo'),
+   *       eq(cars.year, 1950),
+   *     )
+   *   )
+   * ```
+   */
+  and?: Array<PgQueryWhereOrSQL<T, Relations>>;
+  /**
+   * Combine a list of conditions with the `or` operator. Conditions
+   * that are equal `undefined` are automatically ignored.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * db.select().from(cars)
+   *   .where(
+   *     or(
+   *       eq(cars.make, 'GM'),
+   *       eq(cars.make, 'Ford'),
+   *     )
+   *   )
+   * ```
+   */
+  or?: Array<PgQueryWhereOrSQL<T, Relations>>;
+  /**
+   * Negate the meaning of an expression using the `not` keyword.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Select cars _not_ made by GM or Ford.
+   * db.select().from(cars)
+   *   .where(not(inArray(cars.make, ['GM', 'Ford'])))
+   * ```
+   */
+  not?: PgQueryWhereOrSQL<T, Relations>;
+  /**
+   * Test whether a subquery evaluates to have any rows.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Users whose `homeCity` column has a match in a cities
+   * // table.
+   * db
+   *   .select()
+   *   .from(users)
+   *   .where(
+   *     exists(db.select()
+   *       .from(cities)
+   *       .where(eq(users.homeCity, cities.id))),
+   *   );
+   * ```
+   *
+   * @see notExists for the inverse of this test
+   */
+  exists?: SQLWrapper;
+};
+type PgQueryWhereRelations<Relations extends PgRelationMap<TObject> | undefined = undefined> = Relations extends PgRelationMap<TObject> ? { [K in keyof Relations]?: PgQueryWhere<Relations[K]["join"]["schema"], Relations[K]["with"]> } : {};
+/**
+ * Recursively allow nested queries for JSONB object/array types
+ */
+type NestedJsonbQuery<T> = T extends object ? T extends Array<infer U> ? U extends object ? { [K in keyof U]?: FilterOperators<U[K]> | U[K] } : FilterOperators<U> | U : { [K in keyof T]?: FilterOperators<T[K]> | T[K] | (T[K] extends object ? NestedJsonbQuery<T[K]> : never) } : FilterOperators<T> | T;
+//#endregion
+//#region src/interfaces/PgQuery.d.ts
+/**
+ * Order direction for sorting
+ */
+type OrderDirection = "asc" | "desc";
+/**
+ * Single order by clause with column and direction
+ */
+interface OrderByClause<T> {
+  column: keyof T;
+  direction?: OrderDirection;
+}
+/**
+ * Order by parameter - supports 3 modes:
+ * 1. String: orderBy: "name" (defaults to ASC)
+ * 2. Single object: orderBy: { column: "name", direction: "desc" }
+ * 3. Array: orderBy: [{ column: "name", direction: "asc" }, { column: "age", direction: "desc" }]
+ */
+type OrderBy<T> = keyof T | OrderByClause<T> | Array<OrderByClause<T>>;
+/**
+ * Generic query interface for PostgreSQL entities
+ */
+interface PgQuery<T extends TObject = TObject> {
+  distinct?: (keyof Static<T>)[];
+  columns?: (keyof Static<T>)[];
+  where?: PgQueryWhereOrSQL<T>;
+  limit?: number;
+  offset?: number;
+  orderBy?: OrderBy<Static<T>>;
+  groupBy?: (keyof Static<T>)[];
+}
+type PgStatic<T extends TObject, Relations extends PgRelationMap<T>> = Static<T> & { [K in keyof Relations]: Static<Relations[K]["join"]["schema"]> & (Relations[K]["with"] extends PgRelationMap<TObject> ? PgStatic<Relations[K]["join"]["schema"], Relations[K]["with"]> : {}) };
+interface PgQueryRelations<T extends TObject = TObject, Relations extends PgRelationMap<T> | undefined = undefined> extends PgQuery<T> {
+  with?: Relations;
+  where?: PgQueryWhereOrSQL<T, Relations>;
+}
+type PgRelationMap<Base extends TObject> = Record<string, PgRelation<Base>>;
+type PgRelation<Base extends TObject> = {
+  type?: "left" | "inner" | "right";
+  join: {
+    schema: TObject;
+    name: string;
+  };
+  on: SQLWrapper | [keyof Static<Base>, {
+    name: string;
+  }];
+  with?: PgRelationMap<TObject>;
+};
+//#endregion
+//#region src/descriptors/$sequence.d.ts
+/**
+ * Creates a PostgreSQL sequence descriptor for generating unique numeric values.
+ */
+declare const $sequence: {
+  (options?: SequenceDescriptorOptions): SequenceDescriptor;
+  [KIND]: typeof SequenceDescriptor;
+};
+interface SequenceDescriptorOptions extends PgSequenceOptions {
+  /**
+   * The name of the sequence. If not provided, the property key will be used.
+   */
+  name?: string;
+  provider?: DatabaseProvider;
+}
+declare class SequenceDescriptor extends Descriptor<SequenceDescriptorOptions> {
+  readonly provider: DatabaseProvider;
+  onInit(): void;
+  get name(): string;
+  next(): Promise<number>;
+  current(): Promise<number>;
+  protected $provider(): DatabaseProvider;
+}
+//#endregion
+//#region src/services/ModelBuilder.d.ts
+/**
+ * Database-specific table configuration functions
+ */
+interface TableConfigBuilders<TConfig> {
+  index: (name: string) => {
+    on: (...columns: any[]) => TConfig;
+  };
+  uniqueIndex: (name: string) => {
+    on: (...columns: any[]) => TConfig;
+  };
+  unique: (name: string) => {
+    on: (...columns: any[]) => TConfig;
+  };
+  check: (name: string, sql: SQL) => TConfig;
+  foreignKey: (config: {
+    name: string;
+    columns: any[];
+    foreignColumns: any[];
+  }) => TConfig;
+}
+/**
+ * Abstract base class for transforming Alepha Descriptors (Entity, Sequence, etc...)
+ * into drizzle models (tables, enums, sequences, etc...).
+ */
+declare abstract class ModelBuilder {
+  /**
+   * Build a table from an entity descriptor.
+   */
+  abstract buildTable(entity: EntityDescriptor, options: {
+    tables: Map<string, unknown>;
+    enums: Map<string, unknown>;
+    schema: string;
+  }): void;
+  /**
+   * Build a sequence from a sequence descriptor.
+   */
+  abstract buildSequence(sequence: SequenceDescriptor, options: {
+    sequences: Map<string, unknown>;
+    schema: string;
+  }): void;
+  /**
+   * Convert camelCase to snake_case for column names.
+   */
+  protected toColumnName(str: string): string;
+  /**
+   * Build the table configuration function for any database.
+   * This includes indexes, foreign keys, constraints, and custom config.
+   *
+   * @param entity - The entity descriptor
+   * @param builders - Database-specific builder functions
+   * @param tableResolver - Function to resolve entity references to table columns
+   * @param customConfigHandler - Optional handler for custom config
+   */
+  protected buildTableConfig<TConfig, TSelf>(entity: EntityDescriptor, builders: TableConfigBuilders<TConfig>, tableResolver?: (entityName: string) => any, customConfigHandler?: (config: any, self: TSelf) => TConfig[]): ((self: TSelf) => TConfig[]) | undefined;
+}
+//#endregion
+//#region src/providers/drivers/DatabaseProvider.d.ts
+type SQLLike = SQLWrapper | string;
+declare abstract class DatabaseProvider {
+  protected readonly alepha: Alepha;
+  protected abstract readonly builder: ModelBuilder;
+  abstract readonly db: PgDatabase<any>;
+  abstract readonly dialect: "postgres" | "sqlite";
+  readonly enums: Map<string, unknown>;
+  readonly tables: Map<string, unknown>;
+  readonly sequences: Map<string, unknown>;
+  table<T extends TObject>(entity: EntityDescriptor<T>): PgTableWithColumns<SchemaToTableConfig<T>>;
+  get schema(): string;
+  registerEntity(entity: EntityDescriptor): void;
+  registerSequence(sequence: SequenceDescriptor): void;
+  abstract execute(statement: SQLLike): Promise<Record<string, unknown>[]>;
+  run<T extends TObject>(statement: SQLLike, schema: T): Promise<Array<Static<T>>>;
+}
+//#endregion
+//#region src/schemas/pageQuerySchema.d.ts
+declare const pageQuerySchema: typebox11.TObject<{
+  page: typebox11.TOptional<typebox11.TInteger>;
+  size: typebox11.TOptional<typebox11.TInteger>;
+  sort: typebox11.TOptional<typebox11.TString>;
+}>;
+type PageQuery = Static<typeof pageQuerySchema>;
+//#endregion
+//#region src/services/PgJsonQueryManager.d.ts
+/**
+ * Manages JSONB query generation for nested object and array queries in PostgreSQL.
+ * This class handles complex nested queries using PostgreSQL's JSONB operators.
+ */
+declare class PgJsonQueryManager {
+  /**
+   * Check if a query contains nested JSONB queries.
+   * A nested query is when the value is an object with operator keys.
+   */
+  hasNestedQuery(where: PgQueryWhere<TObject>): boolean;
+  /**
+   * Build a JSONB query condition for nested object queries.
+   * Supports deep nesting like: { profile: { contact: { email: { eq: "test@example.com" } } } }
+   *
+   * @param column The JSONB column
+   * @param path The path to the nested property (e.g., ['profile', 'contact', 'email'])
+   * @param operator The filter operator (e.g., { eq: "test@example.com" })
+   * @returns SQL condition
+   */
+  buildJsonbCondition(column: PgColumn, path: string[], operator: FilterOperators<any>): SQL | undefined;
+  /**
+   * Build JSONB array query conditions.
+   * Supports queries like: { addresses: { city: { eq: "Wonderland" } } }
+   * which translates to: EXISTS (SELECT 1 FROM jsonb_array_elements(addresses) elem WHERE elem->>'city' = 'Wonderland')
+   */
+  buildJsonbArrayCondition(column: PgColumn, path: string[], arrayPath: string, operator: FilterOperators<any>): SQL | undefined;
+  /**
+   * Apply a filter operator to a JSONB value.
+   */
+  private applyOperatorToJsonValue;
+  /**
+   * Parse a nested query object and extract the path and operator.
+   * For example: { profile: { contact: { email: { eq: "test@example.com" } } } }
+   * Returns: { path: ['profile', 'contact', 'email'], operator: { eq: "test@example.com" } }
+   */
+  parseNestedQuery(nestedQuery: any, currentPath?: string[]): Array<{
+    path: string[];
+    operator: FilterOperators<any>;
+  }>;
+  /**
+   * Determine if a property is a JSONB column based on the schema.
+   * A column is JSONB if it's defined as an object or array in the TypeBox schema.
+   */
+  isJsonbColumn(schema: TObject, columnName: string): boolean;
+  /**
+   * Check if an array property contains primitive types (string, number, boolean, etc.)
+   * rather than objects. Primitive arrays should use native Drizzle operators.
+   * @returns true if the array contains primitives, false if it contains objects
+   */
+  isPrimitiveArray(schema: TObject, columnName: string): boolean;
+  /**
+   * Check if a nested path points to an array property.
+   */
+  isArrayProperty(schema: TObject, path: string[]): boolean;
+}
+//#endregion
+//#region src/services/PgQueryManager.d.ts
+declare class PgQueryManager {
+  protected readonly jsonQueryManager: PgJsonQueryManager;
+  protected readonly alepha: Alepha;
+  /**
+   * Convert a query object to a SQL query.
+   */
+  toSQL(query: PgQueryWhereOrSQL<TObject>, options: {
+    schema: TObject;
+    col: (key: string) => PgColumn;
+    joins?: PgJoin[];
+  }): SQL | undefined;
+  /**
+   * Build a JSONB query for nested object/array queries.
+   */
+  protected buildJsonbQuery(column: PgColumn, nestedQuery: any, schema: TObject, columnName: string): SQL | undefined;
+  /**
+   * Check if an object has any filter operator properties.
+   */
+  protected hasFilterOperatorProperties(obj: any): boolean;
+  /**
+   * Map a filter operator to a SQL query.
+   */
+  mapOperatorToSql(operator: FilterOperators<any> | any, column: PgColumn, columnSchema?: TObject, columnName?: string): SQL | undefined;
+  /**
+   * Parse pagination sort string to orderBy format.
+   * Format: "firstName,-lastName" -> [{ column: "firstName", direction: "asc" }, { column: "lastName", direction: "desc" }]
+   * - Columns separated by comma
+   * - Prefix with '-' for DESC direction
+   *
+   * @param sort Pagination sort string
+   * @returns OrderBy array or single object
+   */
+  parsePaginationSort(sort: string): Array<{
+    column: string;
+    direction: "asc" | "desc";
+  }> | {
+    column: string;
+    direction: "asc" | "desc";
+  };
+  /**
+   * Normalize orderBy parameter to array format.
+   * Supports 3 modes:
+   * 1. String: "name" -> [{ column: "name", direction: "asc" }]
+   * 2. Object: { column: "name", direction: "desc" } -> [{ column: "name", direction: "desc" }]
+   * 3. Array: [{ column: "name" }, { column: "age", direction: "desc" }] -> normalized array
+   *
+   * @param orderBy The orderBy parameter
+   * @returns Normalized array of order by clauses
+   */
+  normalizeOrderBy(orderBy: any): Array<{
+    column: string;
+    direction: "asc" | "desc";
+  }>;
+  /**
+   * Create a pagination object.
+   *
+   * @deprecated Use `createPagination` from @alepha/core instead.
+   * This method now delegates to the framework-level helper.
+   *
+   * @param entities The entities to paginate.
+   * @param limit The limit of the pagination.
+   * @param offset The offset of the pagination.
+   * @param sort Optional sort metadata to include in response.
+   */
+  createPagination<T>(entities: T[], limit?: number, offset?: number, sort?: Array<{
+    column: string;
+    direction: "asc" | "desc";
+  }>): _alepha_core10.Page<T>;
+}
+interface PgJoin {
+  table: string;
+  schema: TObject;
+  key: string;
+  col: (key: string) => PgColumn;
+  parent?: string;
+}
+//#endregion
+//#region src/services/PgRelationManager.d.ts
+declare class PgRelationManager {
+  /**
+   * Recursively build joins for the query builder based on the relations map
+   */
+  buildJoins(provider: DatabaseProvider, builder: PgSelectBase<any, any, any>, joins: Array<PgJoin>, withRelations: PgRelationMap<TObject>, table: PgTableWithColumns<any>, parentKey?: string): void;
+  /**
+   * Map a row with its joined relations based on the joins definition
+   */
+  mapRowWithJoins(record: Record<string, unknown>, row: Record<string, unknown>, schema: TObject, joins: PgJoin[], parentKey?: string): Record<string, unknown>;
+  /**
+   * Check if all values in an object are null (indicates a left join with no match)
+   */
+  private isAllNull;
+  /**
+   * Build a schema that includes all join properties recursively
+   */
+  buildSchemaWithJoins(baseSchema: TObject, joins: PgJoin[], parentPath?: string): TObject;
+}
+//#endregion
+//#region src/descriptors/$repository.d.ts
+/**
+ * Creates a repository for database operations on a defined entity.
+ *
+ * This descriptor provides a comprehensive, type-safe interface for performing all
+ * database operations on entities defined with $entity. It offers a rich set of
+ * CRUD operations, advanced querying capabilities, pagination, transactions, and
+ * built-in support for audit trails and soft deletes.
+ */
+declare const $repository: {
+  <T extends TObject>(optionsOrEntity: EntityDescriptor<T> | EntityDescriptorOptions<T> | RepositoryDescriptorOptions<T>): RepositoryDescriptor<T>;
+  [KIND]: typeof RepositoryDescriptor;
+};
+interface RepositoryDescriptorOptions<T extends TObject> {
+  /**
+   * The entity table definition created with $entity.
+   *
+   * This table:
+   * - Must be created using the $entity descriptor
+   * - Defines the schema, indexes, and constraints for the repository
+   * - Provides type information for all repository operations
+   * - Must include exactly one primary key field
+   *
+   * The repository will automatically:
+   * - Generate typed CRUD operations based on the entity schema
+   * - Handle audit fields like createdAt, updatedAt, deletedAt
+   * - Support optimistic locking if version field is present
+   * - Provide soft delete functionality if deletedAt field exists
+   *
+   * **Entity Requirements**:
+   * - Must have been created with $entity descriptor
+   * - Schema must include a primary key field marked with `pg.primaryKey()`
+   * - Corresponding database table must exist (created via migrations)
+   *
+   * @example
+   * ```ts
+   * const User = $entity({
+   *   name: "users",
+   *   schema: t.object({
+   *     id: pg.primaryKey(t.uuid()),
+   *     email: t.text({ format: "email" }),
+   *     name: t.text()
+   *   })
+   * });
+   *
+   * const userRepository = $repository({ table: User });
+   * ```
+   */
+  entity: EntityDescriptor<T>;
+  /**
+   * Override the default PostgreSQL database provider.
+   *
+   * By default, the repository will use the injected PostgresProvider from the
+   * dependency injection container. Use this option to:
+   * - Connect to a different database
+   * - Use a specific connection pool
+   * - Implement custom database behavior
+   * - Support multi-tenant architectures with database per tenant
+   *
+   * **Common Use Cases**:
+   * - Multi-database applications
+   * - Read replicas for query optimization
+   * - Different databases for different entity types
+   * - Testing with separate test databases
+   *
+   * @default Uses injected PostgresProvider
+   *
+   * @example ReadOnlyPostgresProvider
+   * @example TenantSpecificPostgresProvider
+   * @example TestDatabaseProvider
+   */
+  provider?: DatabaseProvider;
+  name?: string;
+}
+declare class RepositoryDescriptor<T extends TObject = TObject> extends Descriptor<RepositoryDescriptorOptions<T>> {
+  protected readonly relationManager: PgRelationManager;
+  protected readonly queryManager: PgQueryManager;
+  protected readonly dateTimeProvider: DateTimeProvider;
+  protected readonly alepha: Alepha;
+  readonly provider: DatabaseProvider;
+  constructor(args: DescriptorArgs<RepositoryDescriptorOptions<T>>);
+  /**
+   * Get the entity descriptor associated with this repository.
+   */
+  get entity(): EntityDescriptor<T>;
+  /**
+   * Represents the primary key of the table.
+   * - Key is the name of the primary key column.
+   * - Type is the type (TypeBox) of the primary key column.
+   *
+   * ID is mandatory. If the table does not have a primary key, it will throw an error.
+   */
+  get id(): {
+    type: TSchema;
+    key: keyof T["properties"];
+    col: PgColumn;
+  };
+  /**
+   * Get Drizzle table object.
+   */
+  get table(): PgTableWithColumns<SchemaToTableConfig<T>>;
+  /**
+   * Get SQL table name. (from Drizzle table object)
+   */
+  get tableName(): string;
+  /**
+   * Getter for the database connection from the database provider.
+   */
+  protected get db(): PgDatabase<any>;
+  /**
+   * Execute a SQL query.
+   *
+   * This method allows executing raw SQL queries against the database.
+   * This is by far the easiest way to run custom queries that are not covered by the repository's built-in methods!
+   *
+   * You must use the `sql` tagged template function from Drizzle ORM to create the query. https://orm.drizzle.team/docs/sql
+   *
+   * @example
+   * ```ts
+   * class App {
+   *   repository = $repository({ ... });
+   *   async getAdults() {
+   *     const users = repository.table; // Drizzle table object
+   *     await repository.query(sql`SELECT * FROM ${users} WHERE ${users.age} > ${18}`);
+   *     // or better
+   *     await repository.query((users) => sql`SELECT * FROM ${users} WHERE ${users.age} > ${18}`);
+   *   }
+   * }
+   * ```
+   */
+  query<R extends TObject = T>(query: SQLLike | ((table: PgTableWithColumns<SchemaToTableConfig<T>>, db: PgDatabase<any>) => SQLLike), schema?: R): Promise<Static<R>[]>;
+  /**
+   * Map raw database fields to entity fields. (handles column name differences)
+   */
+  protected mapRawFieldsToEntity(row: Record<string, unknown>): any;
+  /**
+   * Get a Drizzle column from the table by his name.
+   */
+  protected col(name: keyof StaticEncode<T>): PgColumn;
+  /**
+   * Run a transaction.
+   */
+  transaction<T>(transaction: (tx: PgTransaction<any, Record<string, any>, any>) => Promise<T>, config?: PgTransactionConfig): Promise<T>;
+  /**
+   * Start a SELECT query on the table.
+   */
+  protected select(opts?: StatementOptions): drizzle_orm_pg_core0.PgSelectBase<string, Record<string, PgColumn<drizzle_orm0.ColumnBaseConfig<drizzle_orm0.ColumnDataType, string>, {}, {}>>, "single", Record<string, "not-null">, false, never, {
+    [x: string]: unknown;
+  }[], {
+    [x: string]: PgColumn<drizzle_orm0.ColumnBaseConfig<drizzle_orm0.ColumnDataType, string>, {}, {}>;
+  }>;
+  /**
+   * Start a SELECT DISTINCT query on the table.
+   */
+  protected selectDistinct(opts?: StatementOptions, columns?: (keyof Static<T>)[]): drizzle_orm_pg_core0.PgSelectBase<string, Record<string, any>, "partial", Record<string, "not-null">, false, never, {
+    [x: string]: any;
+  }[], {
+    [x: string]: any;
+  }>;
+  /**
+   * Start an INSERT query on the table.
+   */
+  protected insert(opts?: StatementOptions): drizzle_orm_pg_core0.PgInsertBuilder<PgTableWithColumns<SchemaToTableConfig<T>>, any, false>;
+  /**
+   * Start an UPDATE query on the table.
+   */
+  protected update(opts?: StatementOptions): drizzle_orm_pg_core0.PgUpdateBuilder<PgTableWithColumns<SchemaToTableConfig<T>>, any>;
+  /**
+   * Start a DELETE query on the table.
+   */
+  protected delete(opts?: StatementOptions): drizzle_orm_pg_core0.PgDeleteBase<PgTableWithColumns<SchemaToTableConfig<T>>, any, undefined, undefined, false, never>;
+  /**
+   * Create a Drizzle `select` query based on a JSON query object.
+   *
+   * > This method is the base for `find`, `findOne`, `findById`, and `paginate`.
+   */
+  find<R extends PgRelationMap<T>>(query?: PgQueryRelations<T, R>, opts?: StatementOptions): Promise<PgStatic<T, R>[]>;
+  /**
+   * Find a single entity.
+   */
+  findOne<R extends PgRelationMap<T>>(query: Pick<PgQueryRelations<T, R>, "with" | "where">, opts?: StatementOptions): Promise<PgStatic<T, R>>;
+  /**
+   * Find entities with pagination.
+   *
+   * It uses the same parameters as `find()`, but adds pagination metadata to the response.
+   *
+   * > Pagination CAN also do a count query to get the total number of elements.
+   */
+  paginate<R extends PgRelationMap<T>>(pagination?: PageQuery, query?: PgQueryRelations<T, R>, opts?: StatementOptions & {
+    count?: boolean;
+  }): Promise<Page<PgStatic<T, R>>>;
+  /**
+   * Find an entity by ID.
+   *
+   * This is a convenience method for `findOne` with a where clause on the primary key.
+   * If you need more complex queries, use `findOne` instead.
+   */
+  findById(id: string | number, opts?: StatementOptions): Promise<Static<T>>;
+  /**
+   * Helper to create a type-safe query object.
+   */
+  createQuery(): PgQuery<T>;
+  /**
+   * Helper to create a type-safe where clause.
+   */
+  createQueryWhere(): PgQueryWhere<T>;
+  /**
+   * Create an entity.
+   *
+   * @param data The entity to create.
+   * @param opts The options for creating the entity.
+   * @returns The ID of the created entity.
+   */
+  create(data: Static<TObjectInsert<T>>, opts?: StatementOptions): Promise<Static<T>>;
+  /**
+   * Create many entities.
+   *
+   * @param values The entities to create.
+   * @param opts The statement options.
+   * @returns The created entities.
+   */
+  createMany(values: Array<Static<TObjectInsert<T>>>, opts?: StatementOptions): Promise<Static<T>[]>;
+  /**
+   * Find an entity and update it.
+   */
+  updateOne(where: PgQueryWhereOrSQL<T>, data: Partial<Static<TObjectUpdate<T>>>, opts?: StatementOptions): Promise<Static<T>>;
+  /**
+   * Save a given entity.
+   *
+   * @example
+   * ```ts
+   * const entity = await repository.findById(1);
+   * entity.name = "New Name"; // update a field
+   * delete entity.description; // delete a field
+   * await repository.save(entity);
+   * ```
+   *
+   * Difference with `updateById/updateOne`:
+   *
+   * - requires the entity to be fetched first (whole object is expected)
+   * - check pg.version() if present -> optimistic locking
+   * - validate entity against schema
+   * - undefined values will be set to null, not ignored!
+   *
+   * @see {@link PostgresTypeProvider#version}
+   * @see {@link PgVersionMismatchError}
+   */
+  save(entity: Static<T>, opts?: StatementOptions): Promise<void>;
+  /**
+   * Find an entity by ID and update it.
+   */
+  updateById(id: string | number, data: Partial<Static<TObjectUpdate<T>>>, opts?: StatementOptions): Promise<Static<T>>;
+  /**
+   * Find many entities and update all of them.
+   */
+  updateMany(where: PgQueryWhereOrSQL<T>, data: Partial<Static<TObjectUpdate<T>>>, opts?: StatementOptions): Promise<Array<number | string>>;
+  /**
+   * Find many and delete all of them.
+   * @returns Array of deleted entity IDs
+   */
+  deleteMany(where?: PgQueryWhereOrSQL<T>, opts?: StatementOptions): Promise<Array<number | string>>;
+  /**
+   * Delete all entities.
+   * @returns Array of deleted entity IDs
+   */
+  clear(opts?: StatementOptions): Promise<Array<number | string>>;
+  /**
+   * Delete the given entity.
+   *
+   * You must fetch the entity first in order to delete it.
+   * @returns Array containing the deleted entity ID
+   */
+  destroy(entity: Static<T>, opts?: StatementOptions): Promise<Array<number | string>>;
+  /**
+   * Find an entity and delete it.
+   * @returns Array of deleted entity IDs (should contain at most one ID)
+   */
+  deleteOne(where?: PgQueryWhereOrSQL<T>, opts?: StatementOptions): Promise<Array<number | string>>;
+  /**
+   * Find an entity by ID and delete it.
+   * @returns Array containing the deleted entity ID
+   * @throws PgEntityNotFoundError if the entity is not found
+   */
+  deleteById(id: string | number, opts?: StatementOptions): Promise<Array<number | string>>;
+  /**
+   * Count entities.
+   */
+  count(where?: PgQueryWhereOrSQL<T>, opts?: StatementOptions): Promise<number>;
+  protected conflictMessagePattern: string;
+  protected handleError(error: unknown, message: string): PgError;
+  protected withDeletedAt(where: PgQueryWhereOrSQL<T>, opts?: {
+    force?: boolean;
+  }): PgQueryWhereOrSQL<T>;
+  protected deletedAt(): PgAttrField | undefined;
+  /**
+   * Convert something to valid Pg Insert Value.
+   */
+  protected cast(data: any, insert: boolean): PgInsertValue<PgTableWithColumns<SchemaToTableConfig<T>>>;
+  /**
+   * Transform a row from the database into a clean entity.
+   *
+   * - Validate against schema
+   * - Replace all null values by undefined
+   * - Fix date-time and date fields to ISO strings
+   * - Cast BigInt to string
+   */
+  protected clean<T extends TObject>(row: Record<string, unknown>, schema: T): Static<T>;
+  /**
+   * Clean a row with joins recursively
+   */
+  protected cleanWithJoins<T extends TObject>(row: Record<string, unknown>, schema: T, joins: PgJoin[], parentPath?: string): Static<T>;
+  /**
+   * Convert a where clause to SQL.
+   */
+  protected toSQL(where: PgQueryWhereOrSQL<T>, joins?: PgJoin[]): SQL | undefined;
+  /**
+   * Get the where clause for an ID.
+   *
+   * @param id The ID to get the where clause for.
+   * @returns The where clause for the ID.
+   */
+  protected getWhereId(id: string | number): PgQueryWhere<T>;
+  /**
+   * Find a primary key in the schema.
+   */
+  protected getPrimaryKey(schema: TObject): {
+    key: string;
+    col: PgColumn<drizzle_orm0.ColumnBaseConfig<drizzle_orm0.ColumnDataType, string>, {}, {}>;
+    type: TSchema;
+  };
+  protected $provider(): DatabaseProvider;
+}
+/**
+ * The options for a statement.
+ */
+interface StatementOptions {
+  /**
+   * Transaction to use.
+   */
+  tx?: PgTransaction<any, Record<string, any>>;
+  /**
+   * Lock strength.
+   */
+  for?: LockStrength | {
+    config: LockConfig;
+    strength: LockStrength;
+  };
+  /**
+   * If true, ignore soft delete.
+   */
+  force?: boolean;
+  /**
+   * Force the current time.
+   */
+  now?: DateTime;
+}
+//#endregion
+//#region src/descriptors/$transaction.d.ts
+/**
+ * Creates a transaction descriptor for database operations requiring atomicity and consistency.
+ *
+ * This descriptor provides a convenient way to wrap database operations in PostgreSQL
+ * transactions, ensuring ACID properties and automatic retry logic for version conflicts.
+ * It integrates seamlessly with the repository pattern and provides built-in handling
+ * for optimistic locking scenarios with automatic retry on version mismatches.
+ *
+ * **Important Notes**:
+ * - All operations within the transaction handler are atomic
+ * - Automatic retry on `PgVersionMismatchError` for optimistic locking
+ * - Pass `{ tx }` option to all repository operations within the transaction
+ * - Transactions are automatically rolled back on any unhandled error
+ * - Use appropriate isolation levels based on your consistency requirements
+ */
+declare const $transaction: <T extends any[], R>(opts: TransactionDescriptorOptions<T, R>) => _alepha_retry0.RetryDescriptorFn<(...args: T) => Promise<R>>;
+interface TransactionDescriptorOptions<T extends any[], R> {
+  /**
+   * Transaction handler function that contains all database operations to be executed atomically.
+   *
+   * This function:
+   * - Receives a transaction object as the first parameter
+   * - Should pass the transaction to all repository operations via `{ tx }` option
+   * - All operations within are automatically rolled back if any error occurs
+   * - Has access to the full Alepha dependency injection container
+   * - Will be automatically retried if a `PgVersionMismatchError` occurs
+   *
+   * **Transaction Guidelines**:
+   * - Keep transactions as short as possible to minimize lock contention
+   * - Always pass the `tx` parameter to repository operations
+   * - Handle expected business errors gracefully
+   * - Log important operations for debugging and audit trails
+   * - Consider the impact of long-running transactions on performance
+   *
+   * **Error Handling**:
+   * - Throwing any error will automatically roll back the transaction
+   * - `PgVersionMismatchError` triggers automatic retry logic
+   * - Other database errors will be propagated after rollback
+   * - Use try-catch within the handler for business-specific error handling
+   *
+   * @param tx - The PostgreSQL transaction object to use for all database operations
+   * @param ...args - Additional arguments passed to the transaction function
+   * @returns Promise resolving to the transaction result
+   *
+   * @example
+   * ```ts
+   * handler: async (tx, orderId: string, newStatus: string) => {
+   *   // Get the current order (with transaction)
+   *   const order = await this.orders.findById(orderId, { tx });
+   *
+   *   // Validate business rules
+   *   if (!this.isValidStatusTransition(order.status, newStatus)) {
+   *     throw new Error(`Invalid status transition: ${order.status} -> ${newStatus}`);
+   *   }
+   *
+   *   // Update order status (with transaction)
+   *   const updatedOrder = await this.orders.updateById(
+   *     orderId,
+   *     { status: newStatus },
+   *     { tx }
+   *   );
+   *
+   *   // Create audit log (with transaction)
+   *   await this.auditLogs.create({
+   *     id: generateUUID(),
+   *     entityId: orderId,
+   *     action: 'status_change',
+   *     oldValue: order.status,
+   *     newValue: newStatus,
+   *     timestamp: new Date().toISOString()
+   *   }, { tx });
+   *
+   *   return updatedOrder;
+   * }
+   * ```
+   */
+  handler: (tx: PgTransaction<any, any, any>, ...args: T) => Promise<R>;
+  /**
+   * PostgreSQL transaction configuration options.
+   *
+   * This allows you to customize transaction behavior including:
+   * - **Isolation Level**: Controls visibility of concurrent transaction changes
+   * - **Access Mode**: Whether the transaction is read-only or read-write
+   * - **Deferrable**: For serializable transactions, allows deferring to avoid conflicts
+   *
+   * **Isolation Levels**:
+   * - **read_uncommitted**: Lowest isolation, allows dirty reads (rarely used)
+   * - **read_committed**: Default level, prevents dirty reads
+   * - **repeatable_read**: Prevents dirty and non-repeatable reads
+   * - **serializable**: Highest isolation, full ACID compliance
+   *
+   * **Access Modes**:
+   * - **read_write**: Default, allows both read and write operations
+   * - **read_only**: Only allows read operations, can provide performance benefits
+   *
+   * **When to Use Different Isolation Levels**:
+   * - **read_committed**: Most common operations, good balance of consistency and performance
+   * - **repeatable_read**: When you need consistent reads throughout the transaction
+   * - **serializable**: Critical financial operations, when absolute consistency is required
+   *
+   * @example
+   * ```ts
+   * config: {
+   *   isolationLevel: 'serializable',  // Highest consistency for financial operations
+   *   accessMode: 'read_write'
+   * }
+   * ```
+   *
+   * @example
+   * ```ts
+   * config: {
+   *   isolationLevel: 'read_committed', // Default level for most operations
+   *   accessMode: 'read_only'          // Performance optimization for read-only operations
+   * }
+   * ```
+   */
+  config?: PgTransactionConfig$1;
+}
+type TransactionContext = PgTransaction<any, any, any>;
+//#endregion
+//#region src/errors/PgConflictError.d.ts
+declare class PgConflictError extends PgError {
+  readonly name = "PgConflictError";
+  readonly status = 409;
+}
+//#endregion
+//#region src/errors/PgEntityNotFoundError.d.ts
+declare class PgEntityNotFoundError extends PgError {
+  readonly name = "EntityNotFoundError";
+  readonly status = 404;
+  constructor(entityName: string);
+}
+//#endregion
+//#region src/errors/PgMigrationError.d.ts
+declare class PgMigrationError extends PgError {
+  readonly name = "PgMigrationError";
+  constructor(cause?: unknown);
+}
+//#endregion
+//#region src/errors/PgVersionMismatchError.d.ts
+/**
+ * Error thrown when there is a version mismatch.
+ * It's thrown by {@link RepositoryDescriptor#save} when the updated entity version does not match the one in the database.
+ * This is used for optimistic concurrency control.
+ */
+declare class PgVersionMismatchError extends PgError {
+  readonly name = "PgVersionMismatchError";
+  constructor(table: string, id: any);
+}
+//#endregion
+//#region src/providers/DrizzleKitProvider.d.ts
+declare class DrizzleKitProvider {
+  protected readonly log: _alepha_logger0.Logger;
+  protected readonly alepha: Alepha;
+  /**
+   * Synchronize database with current schema definitions.
+   *
+   * In development mode, it will generate and execute migrations based on the current state.
+   * In testing mode, it will generate migrations from scratch without applying them.
+   *
+   * Does nothing in production mode, you must handle migrations manually.
+   */
+  synchronize(provider: DatabaseProvider): Promise<void>;
+  /**
+   * Mostly used for testing purposes. You can generate SQL migration statements without executing them.
+   */
+  generateMigration(provider: DatabaseProvider, prevSnapshot?: any): Promise<{
+    statements: string[];
+    models: Record<string, unknown>;
+    snapshot?: any;
+  }>;
+  /**
+   * Load all tables, enums, sequences, etc. from the provider's repositories.
+   */
+  getModels(provider: DatabaseProvider): Record<string, unknown>;
+  /**
+   * Load the migration snapshot from the database.
+   */
+  protected loadDevMigrations(provider: DatabaseProvider): Promise<DevMigrations | undefined>;
+  protected saveDevMigrations(provider: DatabaseProvider, curr: Record<string, any>, devMigrations?: DevMigrations): Promise<void>;
+  protected executeStatements(statements: string[], provider: DatabaseProvider, catchErrors?: boolean): Promise<void>;
+  protected createSchemaIfNotExists(provider: DatabaseProvider, schemaName: string): Promise<void>;
+  /**
+   * Try to load the official Drizzle Kit API.
+   * If not available, fallback to the local kit import.
+   */
+  protected importDrizzleKit(): typeof DrizzleKit;
+}
+declare const devMigrationsSchema: typebox11.TObject<{
+  id: typebox11.TNumber;
+  name: typebox11.TString;
+  snapshot: typebox11.TString;
+  created_at: typebox11.TString;
+}>;
+type DevMigrations = Static<typeof devMigrationsSchema>;
+//#endregion
+//#region src/services/PostgresModelBuilder.d.ts
+declare class PostgresModelBuilder extends ModelBuilder {
+  protected schemas: Map<string, drizzle_orm_pg_core0.PgSchema<string>>;
+  protected getPgSchema(name: string): any;
+  buildTable(entity: EntityDescriptor<any>, options: {
+    tables: Map<string, unknown>;
+    enums: Map<string, unknown>;
+    schema: string;
+  }): void;
+  buildSequence(sequence: SequenceDescriptor, options: {
+    sequences: Map<string, unknown>;
+    schema: string;
+  }): void;
+  /**
+   * Get PostgreSQL-specific config builder for the table.
+   */
+  protected getTableConfig(entity: EntityDescriptor, tables: Map<string, unknown>): ((self: BuildExtraConfigColumns<string, any, "pg">) => PgTableExtraConfigValue[]) | undefined;
+  schemaToPgColumns: <T extends TObject>(tableName: string, schema: T, nsp: PgSchema, enums: Map<string, unknown>, tables: Map<string, unknown>) => FromSchema<T>;
+  mapFieldToColumn: (tableName: string, fieldName: string, value: TSchema, nsp: PgSchema, enums: Map<string, any>) => any;
+  /**
+   * Map a string to a PG column.
+   *
+   * @param key The key of the field.
+   * @param value The value of the field.
+   */
+  mapStringToColumn: (key: string, value: TSchema) => drizzle_orm_pg_core0.PgUUIDBuilderInitial<string> | drizzle_orm_pg_core0.PgCustomColumnBuilder<{
+    name: string;
+    dataType: "custom";
+    columnType: "PgCustomColumn";
+    data: Buffer<ArrayBufferLike>;
+    driverParam: unknown;
+    enumValues: undefined;
+  }> | drizzle_orm_pg_core0.PgTimestampStringBuilderInitial<string> | drizzle_orm_pg_core0.PgDateStringBuilderInitial<string> | drizzle_orm_pg_core0.PgTextBuilderInitial<string, [string, ...string[]]>;
+}
+//#endregion
+//#region src/providers/drivers/NodePostgresProvider.d.ts
+declare module "alepha" {
+  interface Env extends Partial<Static<typeof envSchema>> {}
+}
+declare const envSchema: _alepha_core10.TObject<{
+  /**
+   * Main configuration for database connection.
+   * Accept a string in the format of a Postgres connection URL.
+   * Example: postgres://user:password@localhost:5432/database
+   * or
+   * Example: postgres://user:password@localhost:5432/database?sslmode=require
+   */
+  DATABASE_URL: _alepha_core10.TOptional<_alepha_core10.TString>;
+  /**
+   * In addition to the DATABASE_URL, you can specify the postgres schema name.
+   *
+   * It will monkey patch drizzle tables.
+   */
+  POSTGRES_SCHEMA: _alepha_core10.TOptional<_alepha_core10.TString>;
+  /**
+   * Synchronize the database schema with the models.
+   * It uses a custom implementation, it's not related to `drizzle-kit push` command.
+   * It will generate the migration script and save it to the DB.
+   *
+   * This is recommended for development and testing purposes only.
+   */
+  POSTGRES_SYNCHRONIZE: _alepha_core10.TOptional<_alepha_core10.TBoolean>;
+}>;
+interface NodePostgresProviderOptions {
+  migrations: MigrationConfig;
+  connection: postgres.Options<any>;
+}
+declare class NodePostgresProvider extends DatabaseProvider {
+  static readonly SSL_MODES: readonly ["require", "allow", "prefer", "verify-full"];
+  readonly dialect = "postgres";
+  protected readonly log: _alepha_logger0.Logger;
+  protected readonly env: {
+    DATABASE_URL?: string | undefined;
+    POSTGRES_SCHEMA?: string | undefined;
+    POSTGRES_SYNCHRONIZE?: boolean | undefined;
+  };
+  protected readonly alepha: Alepha;
+  protected readonly kit: DrizzleKitProvider;
+  protected readonly builder: PostgresModelBuilder;
+  protected client?: postgres.Sql;
+  protected pg?: PostgresJsDatabase;
+  readonly options: NodePostgresProviderOptions;
+  /**
+   * In testing mode, the schema name will be generated and deleted after the test.
+   */
+  protected schemaForTesting: string | undefined;
+  execute(statement: SQLLike): Promise<Array<Record<string, unknown>>>;
+  /**
+   * Get Postgres schema.
+   */
+  get schema(): string;
+  get db(): PostgresJsDatabase;
+  protected readonly onStart: _alepha_core10.HookDescriptor<"start">;
+  protected readonly onStop: _alepha_core10.HookDescriptor<"stop">;
+  connect(): Promise<void>;
+  close(): Promise<void>;
+  protected migrate: _alepha_lock0.LockDescriptor<() => Promise<void>>;
+  /**
+   * Generate a minimal migration configuration.
+   */
+  protected getMigrationOptions(): MigrationConfig;
+  /**
+   * Map the DATABASE_URL to postgres client options.
+   */
+  protected getClientOptions(): postgres.Options<any>;
+  protected ssl(url: URL): "require" | "allow" | "prefer" | "verify-full" | undefined;
+  /**
+   * For testing purposes, generate a unique schema name.
+   * The schema name will be generated based on the current date and time.
+   * It will be in the format of `test_YYYYMMDD_HHMMSS_randomSuffix`.
+   */
+  protected generateTestSchemaName(): string;
+}
+//#endregion
+//#region src/providers/PostgresTypeProvider.d.ts
+declare class PostgresTypeProvider {
+  readonly attr: <T extends TSchema, Attr extends PgSymbolKeys>(type: T, attr: Attr, value?: PgSymbols[Attr]) => PgAttr<T, Attr>;
+  /**
+   * Creates a primary key with an identity column.
+   */
+  readonly identityPrimaryKey: (identity?: PgIdentityOptions, options?: TNumberOptions) => PgAttr<PgAttr<PgAttr<TInteger, typeof PG_PRIMARY_KEY>, typeof PG_IDENTITY>, typeof PG_DEFAULT>;
+  /**
+   * Creates a primary key with a big identity column. (default)
+   */
+  readonly bigIdentityPrimaryKey: (identity?: PgIdentityOptions, options?: TNumberOptions) => PgAttr<PgAttr<PgAttr<TNumber, typeof PG_PRIMARY_KEY>, typeof PG_IDENTITY>, typeof PG_DEFAULT>;
+  /**
+   * Creates a primary key with a UUID column.
+   */
+  readonly uuidPrimaryKey: () => PgAttr<PgAttr<TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
+  /**
+   * Creates a primary key for a given type. Supports:
+   * - `t.int()` -> PG INT (default)
+   * - `t.bigint()` -> PG BIGINT
+   * - `t.uuid()` -> PG UUID
+   */
+  primaryKey(): PgAttr<PgAttr<TInteger, PgPrimaryKey>, PgDefault>;
+  primaryKey(type: TString, options?: TStringOptions): PgAttr<PgAttr<TString, PgPrimaryKey>, PgDefault>;
+  primaryKey(type: TInteger, options?: TNumberOptions, identity?: PgIdentityOptions): PgAttr<PgAttr<TInteger, PgPrimaryKey>, PgDefault>;
+  primaryKey(type: TNumber, options?: TNumberOptions, identity?: PgIdentityOptions): PgAttr<PgAttr<TNumber, PgPrimaryKey>, PgDefault>;
+  primaryKey(type: TBigInt, options?: TNumberOptions, identity?: PgIdentityOptions): PgAttr<PgAttr<TBigInt, PgPrimaryKey>, PgDefault>;
+  /**
+   * Wrap a schema with "default" attribute.
+   * This is used to set a default value for a column in the database.
+   */
+  readonly default: <T extends TSchema>(type: T, value?: Static<T>) => PgAttr<T, PgDefault>;
+  /**
+   * Creates a column 'version'.
+   *
+   * This is used to track the version of a row in the database.
+   *
+   * You can use it for optimistic concurrency control (OCC) with {@link RepositoryDescriptor#save}.
+   *
+   * @see {@link RepositoryDescriptor#save}
+   * @see {@link PgVersionMismatchError}
+   */
+  readonly version: (options?: TNumberOptions) => PgAttr<PgAttr<TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
+  /**
+   * Creates a column Created At. So just a datetime column with a default value of the current timestamp.
+   */
+  readonly createdAt: (options?: TStringOptions) => PgAttr<PgAttr<typebox11.TCodec<TString, dayjs0.Dayjs>, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
+  /**
+   * Creates a column Updated At. Like createdAt, but it is updated on every update of the row.
+   */
+  readonly updatedAt: (options?: TStringOptions) => PgAttr<PgAttr<typebox11.TCodec<TString, dayjs0.Dayjs>, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
+  /**
+   * Creates a column Deleted At for soft delete functionality.
+   * This is used to mark rows as deleted without actually removing them from the database.
+   * The column is nullable - NULL means not deleted, timestamp means deleted.
+   */
+  readonly deletedAt: (options?: TStringOptions) => PgAttr<typebox11.TOptional<typebox11.TCodec<TString, dayjs0.Dayjs>>, typeof PG_DELETED_AT>;
+  /**
+   * Creates a Postgres ENUM type.
+   *
+   * > By default, `t.enum()` is mapped to a TEXT column in Postgres.
+   * > Using this method, you can create a real ENUM type in the database.
+   *
+   * @example
+   * ```ts
+   * const statusEnum = pg.enum(["pending", "active", "archived"], { name: "status_enum" });
+   * ```
+   */
+  readonly enum: <T extends string[]>(values: [...T], pgEnumOptions?: PgEnumOptions, typeOptions?: TStringOptions) => PgAttr<TUnsafe<T[number]>, typeof PG_ENUM>;
+  /**
+   * Creates a reference to another table or schema. Basically a foreign key.
+   */
+  readonly ref: <T extends TSchema>(type: T, ref: () => any, actions?: {
+    onUpdate?: UpdateDeleteAction$1;
+    onDelete?: UpdateDeleteAction$1;
+  }) => PgAttr<T, PgRef>;
+  /**
+   * Creates a page schema for a given object schema.
+   * It's used by {@link RepositoryDescriptor#paginate} method.
+   */
+  readonly page: <T extends TObject>(resource: T, options?: TObjectOptions) => TPage<T>;
+}
+declare const pg: PostgresTypeProvider;
+//#endregion
+//#region src/schemas/legacyIdSchema.d.ts
+/**
+ * @deprecated Use `pg.primaryKey()` instead.
+ */
+declare const legacyIdSchema: PgAttr<PgAttr<PgAttr<typebox11.TInteger, typeof PG_PRIMARY_KEY>, typeof PG_SERIAL>, typeof PG_DEFAULT>;
+//#endregion
+//#region src/types/schema.d.ts
+/**
+ * Postgres schema type.
+ */
+declare const schema: <TDocument extends TSchema>(name: string, document: TDocument) => drizzle_orm0.$Type<drizzle_orm_pg_core0.PgCustomColumnBuilder<{
+  name: string;
+  dataType: "custom";
+  columnType: "PgCustomColumn";
+  data: typebox11.StaticType<[], "Decode", {}, {}, TDocument>;
+  driverParam: string;
+  enumValues: undefined;
+}>, typebox11.StaticType<[], "Decode", {}, {}, TDocument>>;
+//#endregion
+//#region src/index.d.ts
+/**
+ * Postgres client based on Drizzle ORM, Alepha type-safe friendly.
+ *
+ * ```ts
+ * const users = $entity({
+ *   name: "users",
+ *   schema: t.object({
+ *     id: pg.primaryKey(),
+ *     name: t.text(),
+ *     email: t.text(),
+ *   }),
+ * });
+ *
+ * class Db {
+ *   users = $repository(users);
+ * }
+ *
+ * const db = alepha.inject(Db);
+ * const user = await db.users.one({ name: { eq: "John Doe" } });
+ * ```
+ *
+ * This is not a full ORM, but rather a set of tools to work with Postgres databases in a type-safe way.
+ *
+ * It provides:
+ * - A type-safe way to define entities and repositories. (via `$entity` and `$repository`)
+ * - Custom query builders and filters.
+ * - Built-in special columns like `createdAt`, `updatedAt`, `deletedAt`, `version`.
+ * - Automatic JSONB support.
+ * - Automatic synchronization of entities with the database schema (for testing and development).
+ * - Fallback to raw SQL via Drizzle ORM `sql` function.
+ *
+ * Migrations are supported via Drizzle ORM, you need to use the `drizzle-kit` CLI tool to generate and run migrations.
+ *
+ * @see {@link $entity}
+ * @see {@link $sequence}
+ * @see {@link $repository}
+ * @see {@link $transaction}
+ * @module alepha.postgres
+ */
+declare const AlephaPostgres: _alepha_core10.Service<_alepha_core10.Module<{}>>;
+//#endregion
+export { $entity, $repository, $sequence, $transaction, AlephaPostgres, DatabaseProvider, DrizzleKitProvider, EntityColumn, EntityColumns, EntityDescriptor, EntityDescriptorOptions, FilterOperators, FromSchema, NodePostgresProvider, NodePostgresProviderOptions, OrderBy, OrderByClause, OrderDirection, PG_CREATED_AT, PG_DEFAULT, PG_DELETED_AT, PG_ENUM, PG_IDENTITY, PG_PRIMARY_KEY, PG_REF, PG_SERIAL, PG_UPDATED_AT, PG_VERSION, type Page, PageQuery, PgAttr, PgAttrField, PgConflictError, PgDefault, PgEntityNotFoundError, PgEnumOptions, PgError, PgIdentityOptions, PgMigrationError, PgPrimaryKey, PgQuery, PgQueryRelations, PgQueryWhere, PgQueryWhereOrSQL, PgRef, PgRefOptions, PgRelation, PgRelationMap, PgStatic, PgSymbolKeys, PgSymbols, PgVersionMismatchError, PostgresTypeProvider, RepositoryDescriptor, RepositoryDescriptorOptions, SQLLike, SchemaToTableConfig, SequenceDescriptor, SequenceDescriptorOptions, StatementOptions, TObjectInsert, TObjectUpdate, type TPage, TransactionContext, TransactionDescriptorOptions, drizzle_orm0 as drizzle, getAttrFields, insertSchema, legacyIdSchema, pageQuerySchema, pageSchema, pg, pgAttr, schema, sql, updateSchema };
+//# sourceMappingURL=index.d.ts.map