alepha 0.6.7 → 0.6.9

package/postgres.d.ts

@@ -1 +1,1452 @@
-export * from '@alepha/postgres';
+import * as _alepha_core from '@alepha/core';
+import { TObject as TObject$1, Static as Static$1, Alepha, KIND, OPTIONS } from '@alepha/core';
+import * as _sinclair_typebox from '@sinclair/typebox';
+import { TObject, Static, TSchema, ObjectOptions, Kind, TProperties, Evaluate, TReadonly, TOptional, TAdditionalProperties, OptionalKind, TArray, TIntersect, TRecord, TBoolean, TInteger, IntegerOptions, StringOptions, TOptionalWithFlag } from '@sinclair/typebox';
+import * as drizzle_orm from 'drizzle-orm';
+import { TableConfig, SQLWrapper, SQL, BuildColumns } from 'drizzle-orm';
+export { sql } from 'drizzle-orm';
+import * as drizzle_orm_pg_core from 'drizzle-orm/pg-core';
+import { PgSequenceOptions, AnyPgTable, AnyPgColumn, UpdateDeleteAction, PgTableExtraConfigValue, PgTableWithColumns, PgColumnBuilderBase, PgDatabase, TableConfig as TableConfig$1, PgColumn, PgTransaction, PgTransactionConfig, LockStrength, LockConfig, PgInsertValue, PgSelectJoinFn } from 'drizzle-orm/pg-core';
+export * from 'drizzle-orm/pg-core';
+import { PgTransactionConfig as PgTransactionConfig$1 } from 'drizzle-orm/pg-core/session';
+import { BuildExtraConfigColumns } from 'drizzle-orm/column-builder';
+import { PgTableExtraConfigValue as PgTableExtraConfigValue$1 } from 'drizzle-orm/pg-core/table';
+import * as _alepha_lock from '@alepha/lock';
+import { MigrationConfig } from 'drizzle-orm/migrator';
+import { NodePgDatabase } from 'drizzle-orm/node-postgres';
+import pg$1, { ClientConfig } from 'pg';
+import { UpdateDeleteAction as UpdateDeleteAction$1 } from 'drizzle-orm/pg-core/foreign-keys';
+
+/**
+ *
+ */
+declare const PG_SCHEMA: unique symbol;
+
+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_VERSION: unique symbol;
+declare const PG_IDENTITY: unique symbol;
+declare const PG_SERIAL: unique symbol;
+declare const PG_MANY: unique symbol;
+declare const PG_ONE: unique symbol;
+declare const PG_REF: unique symbol;
+type PgDefault = typeof PG_DEFAULT;
+type PgMany = typeof PG_MANY;
+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_VERSION]: {};
+    [PG_IDENTITY]: PgIdentityOptions;
+    [PG_SERIAL]: {};
+    [PG_MANY]: PgManyOptions;
+    [PG_ONE]: PgManyOptions;
+    [PG_REF]: PgRefOptions;
+};
+type PgSymbolKeys = keyof PgSymbols;
+type PgIdentityOptions = {
+    mode: "always" | "byDefault";
+} & PgSequenceOptions & {
+    name?: string;
+};
+interface PgManyOptions {
+    table: AnyPgTable;
+    schema: TObject;
+    foreignKey: string;
+}
+interface PgRefOptions {
+    ref: () => AnyPgColumn;
+    actions?: {
+        onUpdate?: UpdateDeleteAction;
+        onDelete?: UpdateDeleteAction;
+    };
+}
+
+interface EntityDescriptorOptions<T extends TObject, Keys = keyof Static<T>> {
+    name: string;
+    schema: T;
+    indexes?: (Keys | {
+        column: Keys;
+        unique?: boolean;
+        name?: string;
+    })[];
+    foreignKeys?: {
+        columns: Keys[];
+        foreignTable: string;
+        foreignColumns: Keys[];
+        onUpdate?: "cascade" | "restrict" | "no action" | "set null" | "set default";
+        onDelete?: "cascade" | "restrict" | "no action" | "set null" | "set default";
+    }[];
+    config?: PgTableExtraConfigValue[];
+}
+/**
+ * Creates a table descriptor for drizzle-orm.
+ */
+declare const $entity: <T extends TObject>(options: EntityDescriptorOptions<T>) => PgTableWithColumnsAndSchema<PgTableConfig<string, T, FromSchema<T>>, T>;
+
+/**
+ * Convert a schema to columns.
+ *
+ * @param schema
+ */
+declare const schemaToColumns: <T extends TObject$1>(schema: T) => FromSchema<T>;
+declare const fromSchema: <T extends TObject$1>(schema: T) => FromSchema<T>;
+/**
+ * Convert a schema to columns.
+ */
+type FromSchema<T extends TObject$1> = {
+    [key in keyof T["properties"]]: PgColumnBuilderBase;
+};
+/**
+ * The symbol for the schema.
+ */
+/**
+ * A table with columns and schema.
+ */
+type PgTableWithColumnsAndSchema<T extends TableConfig, R extends TObject$1> = PgTableWithColumns<T> & {
+    [PG_SCHEMA]: R;
+};
+
+type SQLLike = SQLWrapper | string;
+declare class PostgresProvider {
+    /**
+     * Get the database instance
+     */
+    get db(): PgDatabase<any>;
+    get schema(): string;
+    get dialect(): string;
+    execute(query: SQLLike): Promise<any[]>;
+}
+
+/**
+ * Fork of the original typebox schema "TObject".
+ *
+ * Expect some breaking changes in the future...
+ */
+interface TInsertObject<T extends TObject> extends TSchema, ObjectOptions {
+    [Kind]: "Object";
+    static: ObjectStatic<T["properties"], this["params"]>;
+    additionalProperties?: TAdditionalProperties;
+    type: "object";
+    required?: string[];
+    properties: {
+        [K in keyof T["properties"] as T["properties"][K] extends {
+            [PG_DEFAULT]: any;
+        } ? never : K]: T["properties"][K];
+    };
+}
+type ReadonlyOptionalPropertyKeys<T extends TProperties> = {
+    [K in keyof T]: T[K] extends TReadonly<TSchema> ? T[K] extends TOptional<T[K]> ? K : never : never;
+}[keyof T];
+type ReadonlyPropertyKeys<T extends TProperties> = {
+    [K in keyof T]: T[K] extends TReadonly<TSchema> ? T[K] extends TOptional<T[K]> ? never : K : never;
+}[keyof T];
+type OptionalPropertyKeys<T extends TProperties> = {
+    [K in keyof T]: T[K] extends TOptional<TSchema> ? T[K] extends TReadonly<T[K]> ? never : K : never;
+}[keyof T];
+type RequiredPropertyKeys<T extends TProperties> = keyof Omit<T, ReadonlyOptionalPropertyKeys<T> | ReadonlyPropertyKeys<T> | OptionalPropertyKeys<T>>;
+type ObjectStaticProperties<T extends TProperties, R extends Record<keyof any, unknown>> = Evaluate<Readonly<Partial<Pick<R, ReadonlyOptionalPropertyKeys<T>>>> & Readonly<Pick<R, ReadonlyPropertyKeys<T>>> & Partial<Pick<R, OptionalPropertyKeys<T>>> & Required<Pick<R, RequiredPropertyKeys<T>>>>;
+type ObjectStatic<T extends TProperties, P extends unknown[]> = ObjectStaticProperties<T, {
+    [K in keyof T]: Static<T[K], P>;
+}>;
+
+/**
+ * Replaces all null values in an object with undefined.
+ *
+ * @param value - The object to be processed.
+ * @return A new object with all null values replaced with undefined.
+ */
+declare const nullToUndefined: <T extends object>(value: T) => NullToUndefined<T>;
+/**
+ * Replaces all null values in an object with undefined.
+ */
+type NullToUndefined<T> = T extends null ? undefined : T extends null | undefined | string | number | boolean | symbol | bigint | Function | Date | RegExp ? T : T extends Array<infer U> ? Array<NullToUndefined<U>> : T extends Map<infer K, infer V> ? Map<K, NullToUndefined<V>> : T extends Set<infer U> ? Set<NullToUndefined<U>> : T extends object ? {
+    [K in keyof T]: NullToUndefined<T[K]>;
+} : unknown;
+/**
+ *
+ */
+type NullifyIfOptional<T> = {
+    [K in keyof T]: undefined extends T[K] ? T[K] | null : T[K];
+};
+
+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;
+}
+
+type InferInsert<T extends TObject> = StaticEntry<T> & StaticDefaultEntry<T>;
+type StaticDefaultEntry<T extends TObject> = {
+    [K in keyof T["properties"] as T["properties"][K] extends {
+        [PG_DEFAULT]: any;
+    } | {
+        [OptionalKind]: "Optional";
+    } ? K : never]?: Static<T["properties"][K]>;
+};
+type StaticEntry<T extends TObject> = {
+    [K in keyof T["properties"] as T["properties"][K] extends {
+        [PG_DEFAULT]: any;
+    } | {
+        [OptionalKind]: "Optional";
+    } ? never : K]: Static<T["properties"][K]>;
+};
+
+type PgQueryWhere<T extends object> = {
+    [Key in keyof T]?: FilterOperators<T[Key]>;
+} & {
+    /**
+     * 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<PgQueryWhere<T> | SQL>;
+    /**
+     * 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<PgQueryWhere<T> | SQL>;
+    /**
+     * 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?: PgQueryWhere<T>;
+    /**
+     * 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;
+};
+
+interface PgQuery<T extends TObject> {
+    where?: PgQueryWhereWithMany<T> | SQLWrapper;
+    limit?: number;
+    offset?: number;
+    sort?: {
+        [key in keyof Static<T>]?: "asc" | "desc";
+    };
+    relations?: PgQueryWithMap<T>;
+}
+type PgQueryWhereWithMany<T extends TObject> = PgQueryWhere<Static<RemoveManyRelations<T>>> & ExtractManyRelations<T>;
+type ExtractManyRelations<T extends TObject> = {
+    [K in keyof T["properties"] as T["properties"][K] extends {
+        [PG_MANY]: any;
+    } ? T["properties"][K] extends TArray ? T["properties"][K]["items"] extends TObject ? K : never : never : never]?: PgQueryWhere<Static<T["properties"][K]["items"]>>;
+};
+type RemoveManyRelations<T extends TObject> = TObject<{
+    [K in keyof T["properties"] as T["properties"][K] extends {
+        [PG_MANY]: any;
+    } ? never : K]: T["properties"][K];
+}>;
+type PgQueryWithMap<T extends TObject> = {
+    [K in keyof T["properties"] as T["properties"][K] extends {
+        [PG_MANY]: any;
+    } ? K : never]?: T["properties"][K] extends TObject ? PgQueryWith<T["properties"][K]> : T["properties"][K] extends TArray ? PgQueryWith<T["properties"][K]> : never;
+};
+type PgQueryWith<T extends TObject | TArray> = true | {
+    relations?: {
+        [key: string]: PgQueryWith<T>;
+    };
+};
+
+declare const pageQuerySchema: _sinclair_typebox.TObject<{
+    page: _sinclair_typebox.TOptional<_sinclair_typebox.TInteger>;
+    size: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+    sort: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+}>;
+type PageQuery = Static$1<typeof pageQuerySchema>;
+
+/**
+ * Page Schema
+ *
+ * @param objectSchema
+ * @param options
+ */
+declare const pageSchema: <T extends TObject | TIntersect | TRecord>(objectSchema: T, options?: ObjectOptions) => TPage<T>;
+/**
+ *
+ */
+type TPage<T extends TObject | TIntersect | TRecord> = TObject<{
+    content: TArray<T>;
+    can: TObject<{
+        next: TBoolean;
+        previous: TBoolean;
+    }>;
+    page: TObject<{
+        number: TInteger;
+        size: TInteger;
+    }>;
+}>;
+/**
+ *
+ */
+type Page<T> = {
+    content: T[];
+    can: {
+        next: boolean;
+        previous: boolean;
+    };
+    page: {
+        number: number;
+        size: number;
+    };
+};
+
+/**
+ *
+ */
+declare class Repository<TTable extends PgTableWithColumns<TableConfig$1>, TTableSchema extends TObject> {
+    readonly provider: PostgresProvider;
+    protected readonly alepha: Alepha;
+    static of: <TEntity extends TableConfig$1, TSchema extends TObject>(table: PgTableWithColumnsAndSchema<TEntity, TSchema>) => (new () => Repository<PgTableWithColumnsAndSchema<TEntity, TSchema>, TSchema>);
+    /**
+     * Register Repository as a valid descriptor.
+     * - Required for $repository to work.
+     */
+    [KIND]: string;
+    /**
+     * 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.
+     */
+    readonly id: {
+        type: TSchema;
+        key: keyof TTableSchema["properties"];
+        col: PgColumn;
+    };
+    [OPTIONS]: {
+        table: TTable;
+        schema: TTableSchema;
+    };
+    readonly options: {
+        table: TTable;
+        schema: TTableSchema;
+    };
+    constructor(options: {
+        table: TTable;
+        schema: TTableSchema;
+    });
+    /**
+     * Get the table schema.
+     */
+    get schema(): TTableSchema;
+    /**
+     * Get the insert schema.
+     */
+    get insertSchema(): TInsertObject<TTableSchema>;
+    /**
+     * Get Drizzle table object.
+     */
+    get table(): TTable;
+    /**
+     * Get SQL table name. (from Drizzle table object)
+     */
+    get tableName(): string;
+    /**
+     * Getter for the database connection from the database provider.
+     */
+    get db(): PgDatabase<any, Record<string, never>, drizzle_orm.ExtractTablesWithRelations<Record<string, never>>>;
+    /**
+     *
+     */
+    organization(): PgColumn;
+    /**
+     * Execute a SQL query.
+     *
+     * @param query
+     * @param schema
+     */
+    execute<T extends TObject = TTableSchema>(query: SQLLike | ((table: TTable, db: PgDatabase<any>) => SQLLike), schema?: T): Promise<Static<T>[]>;
+    /**
+     * Get a Drizzle column from the table by his name.
+     *
+     * @param name - The name of the column to get.
+     * @returns The column from the table.
+     */
+    protected col(name: keyof TTable["_"]["columns"]): PgColumn;
+    /**
+     * Run a transaction.
+     *
+     * @param transaction
+     * @param config
+     */
+    transaction<T>(transaction: (tx: PgTransaction<any, Record<string, any>, any>) => Promise<T>, config?: PgTransactionConfig): Promise<T>;
+    /**
+     * Start a SELECT query on the table.
+     *
+     * @returns The SELECT query builder.
+     */
+    protected select(opts?: StatementOptions): drizzle_orm_pg_core.PgSelectBase<string, Record<string, PgColumn<drizzle_orm.ColumnBaseConfig<drizzle_orm.ColumnDataType, string>, {}, {}>>, "single", Record<string, "not-null">, false, never, {
+        [x: string]: unknown;
+    }[], {
+        [x: string]: PgColumn<drizzle_orm.ColumnBaseConfig<drizzle_orm.ColumnDataType, string>, {}, {}>;
+    }>;
+    /**
+     * Start an INSERT query on the table.
+     *
+     * @returns The INSERT query builder.
+     */
+    protected insert(opts?: StatementOptions): drizzle_orm_pg_core.PgInsertBuilder<TTable, any, false>;
+    /**
+     * Start an UPDATE query on the table.
+     *
+     * @returns The UPDATE query builder.
+     */
+    protected update(opts?: StatementOptions): drizzle_orm_pg_core.PgUpdateBuilder<TTable, any>;
+    /**
+     * Start a DELETE query on the table.
+     *
+     * @returns The DELETE query builder.
+     */
+    protected delete(opts?: StatementOptions): drizzle_orm_pg_core.PgDeleteBase<TTable, any, undefined, undefined, false, never>;
+    /**
+     * Find entities.
+     *
+     * @param query The find query.
+     * @param opts The statement options.
+     * @returns The found entities.
+     */
+    find(query?: PgQuery<TTableSchema>, opts?: StatementOptions): Promise<Static<TTableSchema>[]>;
+    /**
+     * Find a single entity.
+     *
+     * @param where The where clause.
+     * @param opts The statement options.
+     * @returns The found entity.
+     */
+    findOne<T extends Static<TTableSchema> = Static<TTableSchema>>(where: PgQueryWhere<T>, opts?: StatementOptions): Promise<Static<TTableSchema>>;
+    /**
+     * Find an entity by ID.
+     *
+     * @param id
+     * @param opts
+     */
+    findById(id: string | number, opts?: StatementOptions): Promise<Static<TTableSchema>>;
+    /**
+     * Paginate entities.
+     *
+     * @param pageQuery The pagination query.
+     * @param findQuery The find query.
+     * @param opts The statement options.
+     * @returns The paginated entities.
+     */
+    paginate(pageQuery?: PageQuery, findQuery?: PgQuery<TTableSchema>, opts?: StatementOptions): Promise<Page<Static<TTableSchema>>>;
+    /**
+     *
+     */
+    createQuery(query?: PgQuery<TTableSchema>): PgQuery<TTableSchema>;
+    /**
+     *
+     */
+    createQueryWhere(where?: PgQueryWhere<Static<TTableSchema>>): PgQueryWhere<Static<TTableSchema>>;
+    /**
+     * 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: InferInsert<TTableSchema>, opts?: StatementOptions): Promise<Static<TTableSchema>>;
+    /**
+     * Create many entities.
+     *
+     * @param values The entities to create.
+     * @param opts The statement options.
+     * @returns The created entities.
+     */
+    createMany(values: Array<InferInsert<TTableSchema>>, opts?: StatementOptions): Promise<Static<TTableSchema>[]>;
+    /**
+     * Update an entity.
+     *
+     * @param query The where clause.
+     * @param data The data to update.
+     * @param opts The statement options.
+     * @returns The updated entity.
+     */
+    updateOne(query: PgQueryWhere<Static<TTableSchema>>, data: Partial<NullifyIfOptional<Static<TTableSchema>>> | {
+        $append: Partial<NullifyIfOptional<Static<TTableSchema>>>;
+    }, opts?: StatementOptions): Promise<Static<TTableSchema>>;
+    save(data: InferInsert<TTableSchema>, opts?: StatementOptions): Promise<Static<TTableSchema>>;
+    /**
+     * Update an entity by ID.
+     *
+     * @param id
+     * @param data
+     * @param opts
+     */
+    updateById(id: string | number, data: Partial<NullifyIfOptional<Static<TTableSchema>>>, opts?: StatementOptions): Promise<Static<TTableSchema>>;
+    /**
+     * Update entities.
+     *
+     * @param where The where clause.
+     * @param data The data to update.
+     * @param opts The statement options.
+     * @returns The updated entities.
+     */
+    updateMany(where: PgQueryWhere<Static<TTableSchema>>, data: Partial<NullifyIfOptional<Static<TTableSchema>>>, opts?: StatementOptions): Promise<Static<TTableSchema>[]>;
+    /**
+     * Delete entities.
+     *
+     * @param where Query.
+     * @param opts The statement options.
+     */
+    deleteMany(where?: PgQueryWhere<Static<TTableSchema>>, opts?: StatementOptions): Promise<void>;
+    /**
+     * Delete all entities.
+     * @param opts
+     */
+    clear(opts?: StatementOptions): Promise<void>;
+    /**
+     * Delete an entity by ID.
+     *
+     * @param id
+     * @param opts
+     */
+    deleteById(id: string | number, opts?: StatementOptions): Promise<void>;
+    /**
+     * Count entities.
+     *
+     * @param where The where clause.
+     * @param opts The statement options.
+     * @returns The count of entities.
+     */
+    count(where?: PgQueryWhere<Static<TTableSchema>>, opts?: StatementOptions): Promise<number>;
+    /**
+     * Convert a query object to a SQL query.
+     *
+     * @param query The query object.
+     * @param schema The schema to use.
+     * @param col The column to use.
+     */
+    jsonQueryToSql(query: PgQueryWhere<Static<TTableSchema>>, schema?: TObject, col?: (key: string) => PgColumn): SQL | undefined;
+    /**
+     * Map a filter operator to a SQL query.
+     *
+     * @param operator
+     * @param column
+     * @protected
+     */
+    protected mapOperatorToSql(operator: FilterOperators<any>, column: PgColumn): SQL | undefined;
+    /**
+     * Create a pagination object.
+     *
+     * @param entities The entities to paginate.
+     * @param limit The limit of the pagination.
+     * @param offset The offset of the pagination.
+     */
+    protected createPagination(entities: Static<TTableSchema>[], limit?: number, offset?: number): Page<Static<TTableSchema>>;
+    /**
+     * Convert something to valid Pg Insert Value.
+     */
+    protected cast(data: any, insert: boolean): PgInsertValue<TTable>;
+    /**
+     * Clean a row. Remove all null values.
+     *
+     * @param row The row to clean.
+     * @param schema The schema to use.
+     * @returns The cleaned row.
+     */
+    protected clean<T extends TObject = TTableSchema>(row: any, schema?: T): Static<T>;
+    /**
+     * 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<Static<TTableSchema>>;
+    /**
+     * Get all fields with a specific attribute.
+     *
+     * @param schema
+     * @param name
+     * @protected
+     */
+    protected getAttrFields(schema: TObject, name: PgSymbolKeys): PgAttrField[];
+    /**
+     * Find a primary key in the schema.
+     *
+     * @param schema
+     * @protected
+     */
+    protected getPrimaryKey(schema: TObject): {
+        key: string;
+        col: PgColumn<drizzle_orm.ColumnBaseConfig<drizzle_orm.ColumnDataType, string>, {}, {}>;
+        type: TSchema;
+    };
+    /**
+     * Try to aggregate the rows after a select JOIN.
+     *
+     * @param rows
+     * @param pgManyFields
+     * @param query
+     * @protected
+     */
+    protected aggregateRows(rows: any[], pgManyFields: PgAttrField[], query: PgQuery<any>): any[];
+    /**
+     * Populate the JOINs in the query.
+     *
+     * @param builder
+     * @param query
+     * @param schema
+     * @param id
+     * @protected
+     */
+    protected withJoins(builder: {
+        leftJoin: PgSelectJoinFn<any, any, "left", true>;
+        innerJoin: PgSelectJoinFn<any, any, "inner", true>;
+    }, query: PgQuery<any>, schema: TObject, id: PgColumn): PgAttrField[];
+}
+/**
+ * The options for a statement.
+ */
+interface StatementOptions {
+    /**
+     * Transaction to use.
+     */
+    tx?: PgTransaction<any, Record<string, any>>;
+    /**
+     * Lock strength.
+     */
+    for?: LockStrength | {
+        config: LockConfig;
+        strength: LockStrength;
+    };
+    /**
+     * Organization ID.
+     *
+     * Multi-tenant support.
+     *
+     * If set, it will be used to filter the results by organization.
+     */
+    organization?: string;
+}
+interface PgAttrField {
+    key: string;
+    type: TSchema;
+    data: any;
+    nested?: any[];
+}
+
+interface RepositoryDescriptorOptions<TEntity extends TableConfig, TSchema extends TObject$1> {
+    /**
+     * The table to create the repository for.
+     */
+    table: PgTableWithColumnsAndSchema<TEntity, TSchema>;
+    /**
+     * Override default provider.
+     */
+    provider?: () => PostgresProvider;
+}
+/**
+ * @param optionsOrTable
+ */
+declare const $repository: {
+    <TEntity extends TableConfig, TSchema extends TObject$1>(optionsOrTable: RepositoryDescriptorOptions<TEntity, TSchema> | PgTableWithColumnsAndSchema<TEntity, TSchema>): Repository<PgTableWithColumnsAndSchema<TEntity, TSchema>, TSchema>;
+    [KIND]: string;
+};
+
+declare const KEY = "SEQUENCE";
+interface SequenceDescriptorOptions {
+    /**
+     *
+     */
+    name?: string;
+    /**
+     *
+     */
+    start?: number;
+    /**
+     *
+     */
+    increment?: number;
+    /**
+     *
+     */
+    min?: number;
+    /**
+     *
+     */
+    max?: number;
+    /**
+     *
+     */
+    cycle?: boolean;
+}
+interface SequenceDescriptor {
+    [KIND]: typeof KEY;
+    [OPTIONS]: SequenceDescriptorOptions;
+    /**
+     *
+     */
+    (): Promise<number>;
+    /**
+     *
+     */
+    next(): Promise<number>;
+    /**
+     *
+     */
+    current(): Promise<number>;
+}
+/**
+ *
+ * @param options
+ */
+declare const $sequence: {
+    (options?: SequenceDescriptorOptions): SequenceDescriptor;
+    [KIND]: string;
+};
+
+interface TransactionDescriptorOptions<T extends any[], R> {
+    /**
+     *
+     * @param tx
+     * @param args
+     */
+    handler: (tx: PgTransaction<any, any, any>, ...args: T) => Promise<R>;
+    /**
+     *
+     */
+    config?: PgTransactionConfig$1;
+}
+type TransactionContext = PgTransaction<any, any, any>;
+/**
+ * Creates a transaction descriptor.
+ */
+declare const $transaction: <T extends any[], R>(opts: TransactionDescriptorOptions<T, R>) => (...parameters: T) => Promise<Promise<R>>;
+
+declare class EntityNotFoundError extends Error {
+    readonly code = "ERR_RESOURCE_NOTFOUND";
+    readonly status = 404;
+    constructor(entityName: string);
+}
+
+/**
+ * Create a table with a json schema.
+ *
+ * @param name The name of the table.
+ * @param schema The json schema of the table.
+ * @param extraConfig Extra configuration for the table.
+ */
+declare const pgTableSchema: <TTableName extends string, TSchema extends TObject, TColumnsMap extends FromSchema<TSchema>>(name: TTableName, schema: TSchema, extraConfig?: (self: BuildExtraConfigColumns<TTableName, TColumnsMap, "pg">) => PgTableExtraConfigValue$1[]) => PgTableWithColumnsAndSchema<PgTableConfig<TTableName, TSchema, TColumnsMap>, TSchema>;
+/**
+ * @alias pgTableSchema
+ */
+declare const table: <TTableName extends string, TSchema extends TObject, TColumnsMap extends FromSchema<TSchema>>(name: TTableName, schema: TSchema, extraConfig?: (self: BuildExtraConfigColumns<TTableName, TColumnsMap, "pg">) => PgTableExtraConfigValue$1[]) => PgTableWithColumnsAndSchema<PgTableConfig<TTableName, TSchema, TColumnsMap>, TSchema>;
+declare const $table: <TTableName extends string, TSchema extends TObject, TColumnsMap extends FromSchema<TSchema>>(name: TTableName, schema: TSchema, extraConfig?: (self: BuildExtraConfigColumns<TTableName, TColumnsMap, "pg">) => PgTableExtraConfigValue$1[]) => PgTableWithColumnsAndSchema<PgTableConfig<TTableName, TSchema, TColumnsMap>, TSchema>;
+declare const table2: <TTableName extends string, TSchema extends TObject, TColumnsMap extends FromSchema<TSchema>>(name: TTableName, schema: TSchema, extraConfig?: (self: BuildExtraConfigColumns<TTableName, TColumnsMap, "pg">) => PgTableExtraConfigValue$1[]) => PgTableWithColumnsAndSchema<PgTableConfig<TTableName, TSchema, TColumnsMap>, TSchema>;
+/**
+ *
+ */
+type PgTableConfig<TTableName extends string, TSchema extends TObject, TColumnsMap extends FromSchema<TSchema>> = {
+    name: TTableName;
+    schema: any;
+    columns: BuildColumns<TTableName, TColumnsMap, "pg">;
+    dialect: "pg";
+};
+
+declare class RepositoryDescriptorProvider {
+    protected readonly log: _alepha_core.Logger;
+    protected readonly alepha: Alepha;
+    protected readonly repositories: Array<Repository<any, TObject>>;
+    constructor();
+    protected readonly configure: _alepha_core.HookDescriptor<"configure">;
+    /**
+     * Get all repositories.
+     *
+     * @param provider - Filter by provider.
+     */
+    getRepositories(provider?: PostgresProvider): Repository<PgTableWithColumns<TableConfig$1>, TObject>[];
+    /**
+     * Get all tables from the repositories.
+     *
+     * @param provider
+     */
+    getTables(provider?: PostgresProvider): PgTableWithColumns<TableConfig$1>[];
+    /**
+     * Get all providers from the repositories.
+     */
+    getProviders(): PostgresProvider[];
+    /**
+     * Process all descriptors.
+     *
+     * @protected
+     */
+    protected processDescriptors(): Promise<void>;
+    /**
+     * Get all models from the repository descriptors.
+     *
+     * By models, we mean the tables.
+     */
+    protected processRepositoryDescriptors(): Promise<void>;
+}
+
+declare class DrizzleKitProvider {
+    protected readonly log: _alepha_core.Logger;
+    protected readonly alepha: Alepha;
+    protected readonly repositoryDescriptorProvider: RepositoryDescriptorProvider;
+    /**
+     * Try to generate migrations from scratch based on the models.
+     * Then, execute the migrations.
+     *
+     * This is useful for testing or development purposes.
+     *
+     * Do not use in production.
+     *
+     * @param provider - The Postgres provider to use.
+     * @param schema - The schema to use.
+     * @returns A promise that resolves once the migrations have been executed.
+     */
+    synchronize(provider: PostgresProvider, schema?: string): Promise<void>;
+    /**
+     * Get the Drizzle Kit API.
+     *
+     * @protected
+     */
+    protected importDrizzleKit(): any;
+}
+
+declare module "alepha" {
+    interface Env extends Partial<Static$1<typeof envSchema$1>> {
+    }
+}
+declare const envSchema$1: _alepha_core.TObject<{
+    PG_HOST: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    PG_USERNAME: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    PG_DATABASE: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    PG_PASSWORD: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    /**
+     *
+     */
+    DATABASE_URL: _sinclair_typebox.TString;
+    /**
+     *
+     */
+    DATABASE_MIGRATIONS_FOLDER: _sinclair_typebox.TString;
+    /**
+     *
+     */
+    DATABASE_MIGRATIONS_SCHEMA: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    /**
+     *
+     */
+    DATABASE_MIGRATIONS_TABLE: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    /**
+     * The schema to use.
+     * Accept a string.
+     */
+    POSTGRES_SCHEMA: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    /**
+     * Synchronize the database schema with the models.
+     * Accept a boolean or a postgres schema name.
+     *
+     * @default false
+     */
+    POSTGRES_SYNCHRONIZE: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+    /**
+     *
+     */
+    POSTGRES_REJECT_UNAUTHORIZED: _sinclair_typebox.TBoolean;
+}>;
+interface NodePostgresProviderState {
+    client: pg$1.Client;
+    db: NodePgDatabase;
+}
+declare class NodePostgresProvider implements PostgresProvider {
+    readonly dialect = "postgres";
+    protected readonly log: _alepha_core.Logger;
+    protected readonly env: {
+        PG_HOST?: string | undefined;
+        PG_USERNAME?: string | undefined;
+        PG_DATABASE?: string | undefined;
+        PG_PASSWORD?: string | undefined;
+        DATABASE_MIGRATIONS_SCHEMA?: string | undefined;
+        DATABASE_MIGRATIONS_TABLE?: string | undefined;
+        POSTGRES_SCHEMA?: string | undefined;
+        POSTGRES_SYNCHRONIZE?: boolean | undefined;
+        DATABASE_URL: string;
+        DATABASE_MIGRATIONS_FOLDER: string;
+        POSTGRES_REJECT_UNAUTHORIZED: boolean;
+    };
+    protected readonly alepha: Alepha;
+    protected readonly kit: DrizzleKitProvider;
+    protected state?: NodePostgresProviderState;
+    /**
+     * In testing mode, the schema name will be generated and deleted after the test.
+     */
+    protected testingSchemaName?: string;
+    get db(): NodePgDatabase;
+    protected readonly configure: _alepha_core.HookDescriptor<"start">;
+    protected readonly stop: _alepha_core.HookDescriptor<"stop">;
+    /**
+     * Get Postgres schema.
+     */
+    get schema(): string;
+    execute(query: SQLLike): Promise<any[]>;
+    connect(): Promise<void>;
+    close(): Promise<void>;
+    /**
+     *
+     * @protected
+     */
+    protected migrate: _alepha_lock.LockDescriptor<() => Promise<void>>;
+    protected createClient(): NodePostgresProviderState;
+    protected getMigrationOptions(): MigrationConfig;
+    protected getClientOptions(): ClientConfig;
+}
+
+/**
+ * Type representation.
+ */
+type PgAttr<T extends TSchema, TAttr extends PgSymbolKeys> = T & {
+    [K in TAttr]: PgSymbols[K];
+};
+
+declare const createdAtSchema: PgAttr<PgAttr<_sinclair_typebox.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
+
+declare const legacyIdSchema: PgAttr<PgAttr<PgAttr<_sinclair_typebox.TInteger, typeof PG_PRIMARY_KEY>, typeof PG_SERIAL>, typeof PG_DEFAULT>;
+
+/**
+ *
+ */
+declare const updatedAtSchema: PgAttr<PgAttr<_sinclair_typebox.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
+
+/**
+ * Entity Schema.
+ *
+ * Add some common SQL properties to an object.
+ */
+declare const entitySchema: TObject<{
+    id: PgAttr<PgAttr<PgAttr<_sinclair_typebox.TInteger, typeof PG_PRIMARY_KEY>, typeof PG_SERIAL>, typeof PG_DEFAULT>;
+    createdAt: PgAttr<PgAttr<_sinclair_typebox.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
+    updatedAt: PgAttr<PgAttr<_sinclair_typebox.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
+}>;
+/**
+ * TypeBox Entity Type.
+ */
+type TEntity<T extends TProperties> = TObject<T & {
+    id: typeof legacyIdSchema;
+    createdAt: typeof createdAtSchema;
+    updatedAt: typeof updatedAtSchema;
+}>;
+/**
+ * The base entity.
+ */
+type BaseEntity = Static$1<typeof entitySchema>;
+/**
+ *  The keys of the base entity.
+ */
+type BaseEntityKeys = keyof BaseEntity;
+/**
+ *  The keys of the base entity.
+ */
+declare const entityKeys: readonly ["id", "createdAt", "updatedAt"];
+
+declare module "alepha/core" {
+    interface TypeProvider {
+        pg: PostgresTypeProvider;
+    }
+}
+declare class PostgresTypeProvider {
+    readonly attr: <T extends TSchema, Attr extends PgSymbolKeys>(type: T, attr: Attr, value?: PgSymbols[Attr]) => PgAttr<T, Attr>;
+    readonly serial: () => PgAttr<_sinclair_typebox.TInteger, typeof PG_SERIAL>;
+    readonly identity: (options?: IntegerOptions) => PgAttr<_sinclair_typebox.TInteger, typeof PG_IDENTITY>;
+    readonly id: (options?: IntegerOptions) => PgAttr<PgAttr<PgAttr<_sinclair_typebox.TInteger, typeof PG_IDENTITY>, typeof PG_DEFAULT>, typeof PG_PRIMARY_KEY>;
+    readonly identityPrimaryKey: (options?: IntegerOptions) => PgAttr<PgAttr<PgAttr<_sinclair_typebox.TInteger, typeof PG_PRIMARY_KEY>, typeof PG_IDENTITY>, typeof PG_DEFAULT>;
+    readonly primaryKey: <T extends TSchema>(type: T) => PgAttr<PgAttr<T, PgDefault>, PgPrimaryKey>;
+    /**
+     *
+     * @param type
+     * @param value
+     */
+    readonly default: <T extends TSchema>(type: T, value?: Static$1<T>) => PgAttr<T, PgDefault>;
+    /**
+     *
+     * @param options
+     */
+    readonly version: (options?: IntegerOptions) => PgAttr<PgAttr<_sinclair_typebox.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
+    /**
+     *
+     * @param options
+     */
+    readonly createdAt: (options?: StringOptions) => PgAttr<PgAttr<_sinclair_typebox.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
+    /**
+     *
+     * @param options
+     */
+    readonly updatedAt: (options?: StringOptions) => PgAttr<PgAttr<_sinclair_typebox.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
+    /**
+     *
+     * @param properties
+     * @param options
+     */
+    readonly entity: <T extends TProperties>(properties: T, options?: ObjectOptions) => TEntity<T>;
+    /**
+     *
+     * @param obj
+     */
+    readonly insert: <T extends TObject>(obj: T) => TInsertObject<T>;
+    /**
+     * @alias insert
+     */
+    readonly input: <T extends TObject>(obj: T) => TInsertObject<T>;
+    /**
+     *
+     * @param resource
+     * @param options
+     */
+    readonly page: <T extends TObject>(resource: T, options?: ObjectOptions) => TPage<T>;
+    /**
+     *
+     * @param type
+     * @param ref
+     * @param actions
+     */
+    readonly ref: <T extends TSchema>(type: T, ref: () => any, actions?: {
+        onUpdate?: UpdateDeleteAction$1;
+        onDelete?: UpdateDeleteAction$1;
+    }) => PgAttr<T, PgRef>;
+    /**
+     *
+     * @param table
+     * @param foreignKey
+     */
+    readonly many: <T extends TObject, Config extends TableConfig$1>(table: PgTableWithColumnsAndSchema<Config, T>, foreignKey: keyof T["properties"]) => TOptionalWithFlag<PgAttr<PgAttr<TArray<T>, PgMany>, PgDefault>, true>;
+}
+declare const pg: PostgresTypeProvider;
+
+/**
+ * Postgres schema type.
+ */
+declare const schema: <TDocument extends TSchema>(name: string, document: TDocument) => drizzle_orm.$Type<drizzle_orm_pg_core.PgCustomColumnBuilder<{
+    name: string;
+    dataType: "custom";
+    columnType: "PgCustomColumn";
+    data: (TDocument & {
+        params: [];
+    })["static"];
+    driverParam: string;
+    enumValues: undefined;
+}>, (TDocument & {
+    params: [];
+})["static"]>;
+
+declare const envSchema: _alepha_core.TObject<{
+    POSTGRES_PROVIDER: _sinclair_typebox.TOptional<_sinclair_typebox.TUnsafe<"pg">>;
+}>;
+declare module "@alepha/core" {
+    interface Env extends Partial<Static$1<typeof envSchema>> {
+    }
+}
+declare class PostgresModule {
+    protected readonly alepha: Alepha;
+    protected readonly env: {
+        POSTGRES_PROVIDER?: "pg" | undefined;
+    };
+    constructor();
+    protected getDefaultProviderName(): "pg";
+}
+
+export { $entity, $repository, $sequence, $table, $transaction, type BaseEntity, type BaseEntityKeys, type EntityDescriptorOptions, EntityNotFoundError, type ExtractManyRelations, type FilterOperators, type FromSchema, NodePostgresProvider, type NodePostgresProviderState, type NullToUndefined, type NullifyIfOptional, PG_CREATED_AT, PG_DEFAULT, PG_IDENTITY, PG_MANY, PG_ONE, PG_PRIMARY_KEY, PG_REF, PG_SCHEMA, PG_SERIAL, PG_UPDATED_AT, PG_VERSION, type Page, type PageQuery, type PgAttrField, type PgDefault, type PgIdentityOptions, type PgMany, type PgManyOptions, type PgPrimaryKey, type PgQuery, type PgQueryWhere, type PgQueryWhereWithMany, type PgQueryWith, type PgQueryWithMap, type PgRef, type PgRefOptions, type PgSymbolKeys, type PgSymbols, type PgTableConfig, type PgTableWithColumnsAndSchema, PostgresModule, PostgresProvider, PostgresTypeProvider, type RemoveManyRelations, Repository, type RepositoryDescriptorOptions, RepositoryDescriptorProvider, type SQLLike, type SequenceDescriptor, type SequenceDescriptorOptions, type StatementOptions, type TEntity, type TPage, type TransactionContext, type TransactionDescriptorOptions, entityKeys, entitySchema, fromSchema, nullToUndefined, pageQuerySchema, pageSchema, pg, pgTableSchema, schema, schemaToColumns, table, table2 };