alepha 0.7.0 → 0.7.2

package/postgres.d.ts

@@ -1,20 +1,26 @@
 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, TOptionalWithFlag, IntegerOptions, StringOptions } from '@sinclair/typebox';
-import * as drizzle_orm_query_builders_query_builder from 'drizzle-orm/query-builders/query-builder';
-import * as drizzleOrm from 'drizzle-orm';
-import { TableConfig, BuildExtraConfigColumns, SQLWrapper, SQL, BuildColumns } from 'drizzle-orm';
+import { TObject, TSchema, ObjectOptions, Kind, TProperties, Evaluate, TReadonly, TOptional, Static, TAdditionalProperties, OptionalKind, TArray, TIntersect, TRecord, TBoolean, TInteger, TOptionalWithFlag, IntegerOptions, NumberOptions, StringOptions } from '@sinclair/typebox';
+import * as drizzle_orm from 'drizzle-orm';
+import { TableConfig, BuildColumns, BuildExtraConfigColumns as BuildExtraConfigColumns$1, SQLWrapper, SQL } from 'drizzle-orm';
 export { sql } from 'drizzle-orm';
 import * as drizzle_orm_pg_core from 'drizzle-orm/pg-core';
 import { PgSequenceOptions, AnyPgTable, AnyPgColumn, UpdateDeleteAction, PgTableWithColumns, PgColumnBuilderBase, PgTableExtraConfigValue, PgDatabase, TableConfig as TableConfig$1, PgColumn, PgTransaction, PgTransactionConfig, LockStrength, LockConfig, PgInsertValue, PgSelectJoinFn } from 'drizzle-orm/pg-core';
 export * from 'drizzle-orm/pg-core';
+import { BuildExtraConfigColumns } from 'drizzle-orm/column-builder';
+import * as _alepha_retry from '@alepha/retry';
 import { PgTransactionConfig as PgTransactionConfig$1 } from 'drizzle-orm/pg-core/session';
-import { BuildExtraConfigColumns as BuildExtraConfigColumns$1 } from 'drizzle-orm/column-builder';
+import { LibSQLDatabase } from 'drizzle-orm/libsql';
+import { MySql2Database } from 'drizzle-orm/mysql2';
+import { SingleStoreDriverDatabase } from 'drizzle-orm/singlestore';
+import { ConnectionOptions } from 'tls';
+import * as zod from 'zod';
+import { TypeOf } from 'zod';
 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 { PostgresJsDatabase } from 'drizzle-orm/postgres-js';
+import postgres from 'postgres';
 import { UpdateDeleteAction as UpdateDeleteAction$1 } from 'drizzle-orm/pg-core/foreign-keys';
 
 /**
@@ -28,10 +34,13 @@ 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;
+/**
+ * @deprecated Use `PG_IDENTITY` instead.
+ */
+declare const PG_SERIAL: unique symbol;
 type PgDefault = typeof PG_DEFAULT;
 type PgMany = typeof PG_MANY;
 type PgRef = typeof PG_REF;
@@ -43,10 +52,13 @@ type PgSymbols = {
     [PG_UPDATED_AT]: {};
     [PG_VERSION]: {};
     [PG_IDENTITY]: PgIdentityOptions;
-    [PG_SERIAL]: {};
     [PG_MANY]: PgManyOptions;
     [PG_ONE]: PgManyOptions;
     [PG_REF]: PgRefOptions;
+    /**
+     * @deprecated Use `PG_IDENTITY` instead.
+     */
+    [PG_SERIAL]: {};
 };
 type PgSymbolKeys = keyof PgSymbols;
 type PgIdentityOptions = {
@@ -67,13 +79,48 @@ interface PgRefOptions {
     };
 }
 
+/**
+ * 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<{
+        [K in keyof T["properties"] as T["properties"][K] extends {
+            [PG_DEFAULT]: any;
+        } ? never : K]: T["properties"][K];
+    }, 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>;
+}>;
+
 /**
  * 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.
  */
@@ -87,16 +134,33 @@ type FromSchema<T extends TObject$1> = {
  * A table with columns and schema.
  */
 type PgTableWithColumnsAndSchema<T extends TableConfig, R extends TObject$1> = PgTableWithColumns<T> & {
-    [PG_SCHEMA]: R;
+    get $table(): PgTableWithColumns<T>;
+    get $schema(): R;
+    get $insertSchema(): TInsertObject<R>;
 };
 
-interface EntityDescriptorOptions<T extends TObject, Keys = keyof Static<T>> {
+/**
+ * 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[]) => 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";
+};
+
+interface EntityDescriptorOptions<TTableName extends string, T extends TObject, Keys = keyof Static<T>> {
     /**
      * The name of the table. This is the name that will be used in the database.
      * @example
      * name: "user"
      */
-    name: string;
+    name: TTableName;
     /**
      * The schema of the table. This is a TypeBox schema that describes the columns and their types.
      * @example
@@ -117,19 +181,29 @@ interface EntityDescriptorOptions<T extends TObject, Keys = keyof Static<T>> {
         column: Keys;
         unique?: boolean;
         name?: string;
+    } | {
+        columns: Keys[];
+        unique?: boolean;
+        name?: string;
     })[];
+    relations?: Record<string, {
+        type: "one" | "many";
+        table: () => any;
+        foreignColumn?: keyof Static<T>;
+    }>;
     /**
      * Extra configuration for the table. See drizzle-orm documentation for more details.
      *
      * @param self The table descriptor.
      * @returns The extra configuration for the table.
      */
-    config?: (self: BuildExtraConfigColumns<string, FromSchema<T>, "pg">) => PgTableExtraConfigValue[];
+    config?: (self: BuildExtraConfigColumns$1<string, FromSchema<T>, "pg">) => PgTableExtraConfigValue[];
 }
 /**
  * Creates a table descriptor for drizzle-orm.
  */
-declare const $entity: <T extends TObject>(options: EntityDescriptorOptions<T>) => PgTableWithColumnsAndSchema<PgTableConfig<string, T, FromSchema<T>>, T>;
+declare const $entity: <TTableName extends string, TSchema extends TObject, TColumnsMap extends FromSchema<TSchema>>(options: EntityDescriptorOptions<TTableName, TSchema>) => PgTableWithColumnsAndSchema<PgTableConfig<TTableName, TSchema, TColumnsMap>, TSchema>;
+type Entity<T extends TObject> = PgTableWithColumnsAndSchema<PgTableConfig<string, T, FromSchema<T>>, T>;
 
 type SQLLike = SQLWrapper | string;
 declare class PostgresProvider {
@@ -140,41 +214,9 @@ declare class PostgresProvider {
     get db(): PgDatabase<any>;
     get schema(): string;
     get dialect(): string;
-    execute(query: SQLLike): Promise<any[]>;
+    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.
  *
@@ -727,7 +769,7 @@ declare class Repository<TTable extends PgTableWithColumns<TableConfig$1>, TTabl
     protected readonly env: {
         POSTGRES_PAGINATION_COUNT_ENABLED: boolean;
     };
-    static of: <TEntity extends TableConfig$1, TSchema extends TObject>(table: PgTableWithColumnsAndSchema<TEntity, TSchema>) => (new () => Repository<PgTableWithColumnsAndSchema<TEntity, TSchema>, TSchema>);
+    static of: <TEntity extends TableConfig$1, TSchema extends TObject>(opts: PgTableWithColumnsAndSchema<TEntity, TSchema>) => (new () => Repository<PgTableWithColumns<TEntity>, TSchema>);
     /**
      * Register Repository as a valid descriptor.
      * - Required for $repository to work.
@@ -776,7 +818,7 @@ declare class Repository<TTable extends PgTableWithColumns<TableConfig$1>, TTabl
     /**
      * Getter for the database connection from the database provider.
      */
-    get db(): PgDatabase<any, Record<string, never>, drizzleOrm.ExtractTablesWithRelations<Record<string, never>>>;
+    get db(): PgDatabase<any, Record<string, never>, drizzle_orm.ExtractTablesWithRelations<Record<string, never>>>;
     /**
      *
      */
@@ -807,10 +849,10 @@ declare class Repository<TTable extends PgTableWithColumns<TableConfig$1>, TTabl
      *
      * @returns The SELECT query builder.
      */
-    protected select(opts?: StatementOptions): drizzle_orm_pg_core.PgSelectBase<string, Record<string, PgColumn<drizzleOrm.ColumnBaseConfig<drizzleOrm.ColumnDataType, string>, {}, {}>>, "single", Record<string, "not-null">, false, never, {
+    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<drizzleOrm.ColumnBaseConfig<drizzleOrm.ColumnDataType, string>, {}, {}>;
+        [x: string]: PgColumn<drizzle_orm.ColumnBaseConfig<drizzle_orm.ColumnDataType, string>, {}, {}>;
     }>;
     /**
      * Start an INSERT query on the table.
@@ -1001,7 +1043,7 @@ declare class Repository<TTable extends PgTableWithColumns<TableConfig$1>, TTabl
      */
     protected getPrimaryKey(schema: TObject): {
         key: string;
-        col: PgColumn<drizzleOrm.ColumnBaseConfig<drizzleOrm.ColumnDataType, string>, {}, {}>;
+        col: PgColumn<drizzle_orm.ColumnBaseConfig<drizzle_orm.ColumnDataType, string>, {}, {}>;
         type: TSchema;
     };
     /**
@@ -1144,7 +1186,7 @@ type TransactionContext = PgTransaction<any, any, any>;
 /**
  * Creates a transaction descriptor.
  */
-declare const $transaction: <T extends any[], R>(opts: TransactionDescriptorOptions<T, R>) => (...parameters: T) => Promise<R>;
+declare const $transaction: <T extends any[], R>(opts: TransactionDescriptorOptions<T, R>) => _alepha_retry.RetryDescriptor<(...args: T) => Promise<R>>;
 
 declare class EntityNotFoundError extends Error {
     readonly code = "ERR_RESOURCE_NOTFOUND";
@@ -1152,26 +1194,3096 @@ declare class EntityNotFoundError extends Error {
     constructor(entityName: string);
 }
 
+declare const prefixes: readonly ["index", "timestamp", "supabase", "unix", "none"];
+type Prefix = (typeof prefixes)[number];
+declare const casingTypes: readonly ["snake_case", "camelCase"];
+type CasingType = (typeof casingTypes)[number];
+declare const drivers: readonly ["d1-http", "expo", "aws-data-api", "pglite", "durable-sqlite"];
+type Driver = (typeof drivers)[number];
+
+declare const dialects: readonly ["postgresql", "mysql", "sqlite", "turso", "singlestore", "gel"];
+type Dialect = (typeof dialects)[number];
+
+type SslOptions = {
+    pfx?: string;
+    key?: string;
+    passphrase?: string;
+    cert?: string;
+    ca?: string | string[];
+    crl?: string | string[];
+    ciphers?: string;
+    rejectUnauthorized?: boolean;
+};
+type Verify<T, U extends T> = U;
 /**
- * Create a table with a json schema.
+ * **You are currently using version 0.21.0+ of drizzle-kit. If you have just upgraded to this version, please make sure to read the changelog to understand what changes have been made and what
+ * adjustments may be necessary for you. See https://orm.drizzle.team/kit-docs/upgrade-21#how-to-migrate-to-0210**
  *
- * @param name The name of the table.
- * @param schema The json schema of the table.
- * @param extraConfig Extra configuration for the table.
+ * **Config** usage:
+ *
+ * `dialect` - mandatory and is responsible for explicitly providing a databse dialect you are using for all the commands
+ * *Possible values*: `postgresql`, `mysql`, `sqlite`, `singlestore
+ *
+ * See https://orm.drizzle.team/kit-docs/config-reference#dialect
+ *
+ * ---
+ * `schema` - param lets you define where your schema file/files live.
+ * You can have as many separate schema files as you want and define paths to them using glob or array of globs syntax.
+ *
+ * See https://orm.drizzle.team/kit-docs/config-reference#schema
+ *
+ * ---
+ * `out` - allows you to define the folder for your migrations and a folder, where drizzle will introspect the schema and relations
+ *
+ * See https://orm.drizzle.team/kit-docs/config-reference#out
+ *
+ * ---
+ * `driver` - optional param that is responsible for explicitly providing a driver to use when accessing a database
+ * *Possible values*: `aws-data-api`, `d1-http`, `expo`, `turso`, `pglite`
+ * If you don't use AWS Data API, D1, Turso or Expo - ypu don't need this driver. You can check a driver strategy choice here: https://orm.drizzle.team/kit-docs/upgrade-21
+ *
+ * See https://orm.drizzle.team/kit-docs/config-reference#driver
+ *
+ * ---
+ *
+ * `dbCredentials` - an object to define your connection to the database. For more info please check the docs
+ *
+ * See https://orm.drizzle.team/kit-docs/config-reference#dbcredentials
+ *
+ * ---
+ *
+ * `migrations` - param let’s use specify custom table and schema(PostgreSQL only) for migrations.
+ * By default, all information about executed migrations will be stored in the database inside
+ * the `__drizzle_migrations` table, and for PostgreSQL, inside the drizzle schema.
+ * However, you can configure where to store those records.
+ *
+ * See https://orm.drizzle.team/kit-docs/config-reference#migrations
+ *
+ * ---
+ *
+ * `breakpoints` - param lets you enable/disable SQL statement breakpoints in generated migrations.
+ * It’s optional and true by default, it’s necessary to properly apply migrations on databases,
+ * that do not support multiple DDL alternation statements in one transaction(MySQL, SQLite, SingleStore) and
+ * Drizzle ORM has to apply them sequentially one by one.
+ *
+ * See https://orm.drizzle.team/kit-docs/config-reference#breakpoints
+ *
+ * ---
+ *
+ * `tablesFilters` - param lets you filter tables with glob syntax for db push command.
+ * It’s useful when you have only one database avaialable for several separate projects with separate sql schemas.
+ *
+ * How to define multi-project tables with Drizzle ORM — see https://orm.drizzle.team/docs/goodies#multi-project-schema
+ *
+ * See https://orm.drizzle.team/kit-docs/config-reference#tablesfilters
+ *
+ * ---
+ *
+ * `schemaFilter` - parameter allows you to define which schema in PostgreSQL should be used for either introspect or push commands.
+ * This parameter accepts a single schema as a string or an array of schemas as strings.
+ * No glob pattern is supported here. By default, drizzle will use the public schema for both commands,
+ * but you can add any schema you need.
+ *
+ * For example, having schemaFilter: ["my_schema"] will only look for tables in both the database and
+ * drizzle schema that are a part of the my_schema schema.
+ *
+ * See https://orm.drizzle.team/kit-docs/config-reference#schemafilter
+ *
+ * ---
+ *
+ * `verbose` - command is used for drizzle-kit push commands and prints all statements that will be executed.
+ *
+ * > Note: This command will only print the statements that should be executed.
+ * To approve them before applying, please refer to the `strict` command.
+ *
+ * See https://orm.drizzle.team/kit-docs/config-reference#verbose
+ *
+ * ---
+ *
+ * `strict` - command is used for drizzle-kit push commands and will always ask for your confirmation,
+ * either to execute all statements needed to sync your schema with the database or not.
+ *
+ * See https://orm.drizzle.team/kit-docs/config-reference#strict
  */
-declare const pgTableSchema: <TTableName extends string, TSchema extends TObject, TColumnsMap extends FromSchema<TSchema>>(name: TTableName, schema: TSchema, extraConfig?: (self: BuildExtraConfigColumns$1<TTableName, TColumnsMap, "pg">) => PgTableExtraConfigValue[]) => 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";
-};
+type Config = {
+    dialect: Dialect;
+    out?: string;
+    breakpoints?: boolean;
+    tablesFilter?: string | string[];
+    extensionsFilters?: 'postgis'[];
+    schemaFilter?: string | string[];
+    schema?: string | string[];
+    verbose?: boolean;
+    strict?: boolean;
+    casing?: 'camelCase' | 'snake_case';
+    migrations?: {
+        table?: string;
+        schema?: string;
+        prefix?: Prefix;
+    };
+    introspect?: {
+        casing: 'camel' | 'preserve';
+    };
+    entities?: {
+        roles?: boolean | {
+            provider?: 'supabase' | 'neon' | string & {};
+            exclude?: string[];
+            include?: string[];
+        };
+    };
+} & ({
+    dialect: Verify<Dialect, 'turso'>;
+    dbCredentials: {
+        url: string;
+        authToken?: string;
+    };
+} | {
+    dialect: Verify<Dialect, 'sqlite'>;
+    dbCredentials: {
+        url: string;
+    };
+} | {
+    dialect: Verify<Dialect, 'postgresql'>;
+    dbCredentials: ({
+        host: string;
+        port?: number;
+        user?: string;
+        password?: string;
+        database: string;
+        ssl?: boolean | 'require' | 'allow' | 'prefer' | 'verify-full' | ConnectionOptions;
+    } & {}) | {
+        url: string;
+    };
+} | {
+    dialect: Verify<Dialect, 'postgresql'>;
+    driver: Verify<Driver, 'aws-data-api'>;
+    dbCredentials: {
+        database: string;
+        secretArn: string;
+        resourceArn: string;
+    };
+} | {
+    dialect: Verify<Dialect, 'postgresql'>;
+    driver: Verify<Driver, 'pglite'>;
+    dbCredentials: {
+        url: string;
+    };
+} | {
+    dialect: Verify<Dialect, 'mysql'>;
+    dbCredentials: {
+        host: string;
+        port?: number;
+        user?: string;
+        password?: string;
+        database: string;
+        ssl?: string | SslOptions;
+    } | {
+        url: string;
+    };
+} | {
+    dialect: Verify<Dialect, 'sqlite'>;
+    driver: Verify<Driver, 'd1-http'>;
+    dbCredentials: {
+        accountId: string;
+        databaseId: string;
+        token: string;
+    };
+} | {
+    dialect: Verify<Dialect, 'sqlite'>;
+    driver: Verify<Driver, 'expo'>;
+} | {
+    dialect: Verify<Dialect, 'sqlite'>;
+    driver: Verify<Driver, 'durable-sqlite'>;
+} | {} | {
+    dialect: Verify<Dialect, 'singlestore'>;
+    dbCredentials: {
+        host: string;
+        port?: number;
+        user?: string;
+        password?: string;
+        database: string;
+        ssl?: string | SslOptions;
+    } | {
+        url: string;
+    };
+} | {
+    dialect: Verify<Dialect, 'gel'>;
+    dbCredentials?: {
+        tlsSecurity?: 'insecure' | 'no_host_verification' | 'strict' | 'default';
+    } & ({
+        url: string;
+    } | ({
+        host: string;
+        port?: number;
+        user?: string;
+        password?: string;
+        database: string;
+    }));
+});
+
+declare const schema$2: zod.ZodObject<{
+    version: zod.ZodLiteral<"5">;
+    dialect: zod.ZodLiteral<"mysql">;
+    tables: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
+        name: zod.ZodString;
+        columns: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
+            name: zod.ZodString;
+            type: zod.ZodString;
+            primaryKey: zod.ZodBoolean;
+            notNull: zod.ZodBoolean;
+            autoincrement: zod.ZodOptional<zod.ZodBoolean>;
+            default: zod.ZodOptional<zod.ZodAny>;
+            onUpdate: zod.ZodOptional<zod.ZodAny>;
+            generated: zod.ZodOptional<zod.ZodObject<{
+                type: zod.ZodEnum<["stored", "virtual"]>;
+                as: zod.ZodString;
+            }, "strip", zod.ZodTypeAny, {
+                type: "stored" | "virtual";
+                as: string;
+            }, {
+                type: "stored" | "virtual";
+                as: string;
+            }>>;
+        }, "strict", zod.ZodTypeAny, {
+            type: string;
+            name: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            generated?: {
+                type: "stored" | "virtual";
+                as: string;
+            } | undefined;
+            onUpdate?: any;
+            autoincrement?: boolean | undefined;
+        }, {
+            type: string;
+            name: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            generated?: {
+                type: "stored" | "virtual";
+                as: string;
+            } | undefined;
+            onUpdate?: any;
+            autoincrement?: boolean | undefined;
+        }>>;
+        indexes: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
+            name: zod.ZodString;
+            columns: zod.ZodArray<zod.ZodString, "many">;
+            isUnique: zod.ZodBoolean;
+            using: zod.ZodOptional<zod.ZodEnum<["btree", "hash"]>>;
+            algorithm: zod.ZodOptional<zod.ZodEnum<["default", "inplace", "copy"]>>;
+            lock: zod.ZodOptional<zod.ZodEnum<["default", "none", "shared", "exclusive"]>>;
+        }, "strict", zod.ZodTypeAny, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+        }, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+        }>>;
+        foreignKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
+            name: zod.ZodString;
+            tableFrom: zod.ZodString;
+            columnsFrom: zod.ZodArray<zod.ZodString, "many">;
+            tableTo: zod.ZodString;
+            columnsTo: zod.ZodArray<zod.ZodString, "many">;
+            onUpdate: zod.ZodOptional<zod.ZodString>;
+            onDelete: zod.ZodOptional<zod.ZodString>;
+        }, "strict", zod.ZodTypeAny, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>>;
+        compositePrimaryKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
+            name: zod.ZodString;
+            columns: zod.ZodArray<zod.ZodString, "many">;
+        }, "strict", zod.ZodTypeAny, {
+            name: string;
+            columns: string[];
+        }, {
+            name: string;
+            columns: string[];
+        }>>;
+        uniqueConstraints: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
+            name: zod.ZodString;
+            columns: zod.ZodArray<zod.ZodString, "many">;
+        }, "strict", zod.ZodTypeAny, {
+            name: string;
+            columns: string[];
+        }, {
+            name: string;
+            columns: string[];
+        }>>>;
+        checkConstraint: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
+            name: zod.ZodString;
+            value: zod.ZodString;
+        }, "strict", zod.ZodTypeAny, {
+            value: string;
+            name: string;
+        }, {
+            value: string;
+            name: string;
+        }>>>;
+    }, "strict", zod.ZodTypeAny, {
+        name: string;
+        columns: Record<string, {
+            type: string;
+            name: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            generated?: {
+                type: "stored" | "virtual";
+                as: string;
+            } | undefined;
+            onUpdate?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+        uniqueConstraints: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+        checkConstraint: Record<string, {
+            value: string;
+            name: string;
+        }>;
+    }, {
+        name: string;
+        columns: Record<string, {
+            type: string;
+            name: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            generated?: {
+                type: "stored" | "virtual";
+                as: string;
+            } | undefined;
+            onUpdate?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+        }> | undefined;
+        checkConstraint?: Record<string, {
+            value: string;
+            name: string;
+        }> | undefined;
+    }>>;
+    views: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
+        name: zod.ZodString;
+        columns: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
+            name: zod.ZodString;
+            type: zod.ZodString;
+            primaryKey: zod.ZodBoolean;
+            notNull: zod.ZodBoolean;
+            autoincrement: zod.ZodOptional<zod.ZodBoolean>;
+            default: zod.ZodOptional<zod.ZodAny>;
+            onUpdate: zod.ZodOptional<zod.ZodAny>;
+            generated: zod.ZodOptional<zod.ZodObject<{
+                type: zod.ZodEnum<["stored", "virtual"]>;
+                as: zod.ZodString;
+            }, "strip", zod.ZodTypeAny, {
+                type: "stored" | "virtual";
+                as: string;
+            }, {
+                type: "stored" | "virtual";
+                as: string;
+            }>>;
+        }, "strict", zod.ZodTypeAny, {
+            type: string;
+            name: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            generated?: {
+                type: "stored" | "virtual";
+                as: string;
+            } | undefined;
+            onUpdate?: any;
+            autoincrement?: boolean | undefined;
+        }, {
+            type: string;
+            name: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            generated?: {
+                type: "stored" | "virtual";
+                as: string;
+            } | undefined;
+            onUpdate?: any;
+            autoincrement?: boolean | undefined;
+        }>>;
+        definition: zod.ZodOptional<zod.ZodString>;
+        isExisting: zod.ZodBoolean;
+    } & {
+        algorithm: zod.ZodEnum<["undefined", "merge", "temptable"]>;
+        sqlSecurity: zod.ZodEnum<["definer", "invoker"]>;
+        withCheckOption: zod.ZodOptional<zod.ZodEnum<["local", "cascaded"]>>;
+    }, "strict", zod.ZodTypeAny, {
+        name: string;
+        columns: Record<string, {
+            type: string;
+            name: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            generated?: {
+                type: "stored" | "virtual";
+                as: string;
+            } | undefined;
+            onUpdate?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        isExisting: boolean;
+        algorithm: "undefined" | "merge" | "temptable";
+        sqlSecurity: "definer" | "invoker";
+        definition?: string | undefined;
+        withCheckOption?: "local" | "cascaded" | undefined;
+    }, {
+        name: string;
+        columns: Record<string, {
+            type: string;
+            name: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            generated?: {
+                type: "stored" | "virtual";
+                as: string;
+            } | undefined;
+            onUpdate?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        isExisting: boolean;
+        algorithm: "undefined" | "merge" | "temptable";
+        sqlSecurity: "definer" | "invoker";
+        definition?: string | undefined;
+        withCheckOption?: "local" | "cascaded" | undefined;
+    }>>>;
+    _meta: zod.ZodObject<{
+        tables: zod.ZodRecord<zod.ZodString, zod.ZodString>;
+        columns: zod.ZodRecord<zod.ZodString, zod.ZodString>;
+    }, "strip", zod.ZodTypeAny, {
+        tables: Record<string, string>;
+        columns: Record<string, string>;
+    }, {
+        tables: Record<string, string>;
+        columns: Record<string, string>;
+    }>;
+    internal: zod.ZodOptional<zod.ZodObject<{
+        tables: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
+            columns: zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
+                isDefaultAnExpression: zod.ZodOptional<zod.ZodBoolean>;
+            }, "strip", zod.ZodTypeAny, {
+                isDefaultAnExpression?: boolean | undefined;
+            }, {
+                isDefaultAnExpression?: boolean | undefined;
+            }>>>;
+        }, "strip", zod.ZodTypeAny, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        }, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        }>>>>;
+        indexes: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
+            columns: zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
+                isExpression: zod.ZodOptional<zod.ZodBoolean>;
+            }, "strip", zod.ZodTypeAny, {
+                isExpression?: boolean | undefined;
+            }, {
+                isExpression?: boolean | undefined;
+            }>>>;
+        }, "strip", zod.ZodTypeAny, {
+            columns: Record<string, {
+                isExpression?: boolean | undefined;
+            } | undefined>;
+        }, {
+            columns: Record<string, {
+                isExpression?: boolean | undefined;
+            } | undefined>;
+        }>>>>;
+    }, "strip", zod.ZodTypeAny, {
+        tables?: Record<string, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined> | undefined;
+        indexes?: Record<string, {
+            columns: Record<string, {
+                isExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined> | undefined;
+    }, {
+        tables?: Record<string, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined> | undefined;
+        indexes?: Record<string, {
+            columns: Record<string, {
+                isExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined> | undefined;
+    }>>;
+} & {
+    id: zod.ZodString;
+    prevId: zod.ZodString;
+}, "strip", zod.ZodTypeAny, {
+    version: "5";
+    dialect: "mysql";
+    tables: Record<string, {
+        name: string;
+        columns: Record<string, {
+            type: string;
+            name: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            generated?: {
+                type: "stored" | "virtual";
+                as: string;
+            } | undefined;
+            onUpdate?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+        uniqueConstraints: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+        checkConstraint: Record<string, {
+            value: string;
+            name: string;
+        }>;
+    }>;
+    views: Record<string, {
+        name: string;
+        columns: Record<string, {
+            type: string;
+            name: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            generated?: {
+                type: "stored" | "virtual";
+                as: string;
+            } | undefined;
+            onUpdate?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        isExisting: boolean;
+        algorithm: "undefined" | "merge" | "temptable";
+        sqlSecurity: "definer" | "invoker";
+        definition?: string | undefined;
+        withCheckOption?: "local" | "cascaded" | undefined;
+    }>;
+    _meta: {
+        tables: Record<string, string>;
+        columns: Record<string, string>;
+    };
+    id: string;
+    prevId: string;
+    internal?: {
+        tables?: Record<string, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined> | undefined;
+        indexes?: Record<string, {
+            columns: Record<string, {
+                isExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined> | undefined;
+    } | undefined;
+}, {
+    version: "5";
+    dialect: "mysql";
+    tables: Record<string, {
+        name: string;
+        columns: Record<string, {
+            type: string;
+            name: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            generated?: {
+                type: "stored" | "virtual";
+                as: string;
+            } | undefined;
+            onUpdate?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+        }> | undefined;
+        checkConstraint?: Record<string, {
+            value: string;
+            name: string;
+        }> | undefined;
+    }>;
+    _meta: {
+        tables: Record<string, string>;
+        columns: Record<string, string>;
+    };
+    id: string;
+    prevId: string;
+    views?: Record<string, {
+        name: string;
+        columns: Record<string, {
+            type: string;
+            name: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            generated?: {
+                type: "stored" | "virtual";
+                as: string;
+            } | undefined;
+            onUpdate?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        isExisting: boolean;
+        algorithm: "undefined" | "merge" | "temptable";
+        sqlSecurity: "definer" | "invoker";
+        definition?: string | undefined;
+        withCheckOption?: "local" | "cascaded" | undefined;
+    }> | undefined;
+    internal?: {
+        tables?: Record<string, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined> | undefined;
+        indexes?: Record<string, {
+            columns: Record<string, {
+                isExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined> | undefined;
+    } | undefined;
+}>;
+type MySqlSchema = TypeOf<typeof schema$2>;
+
+declare const pgSchema: zod.ZodObject<{
+    version: zod.ZodLiteral<"7">;
+    dialect: zod.ZodLiteral<"postgresql">;
+    tables: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
+        name: zod.ZodString;
+        schema: zod.ZodString;
+        columns: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
+            name: zod.ZodString;
+            type: zod.ZodString;
+            typeSchema: zod.ZodOptional<zod.ZodString>;
+            primaryKey: zod.ZodBoolean;
+            notNull: zod.ZodBoolean;
+            default: zod.ZodOptional<zod.ZodAny>;
+            isUnique: zod.ZodOptional<zod.ZodAny>;
+            uniqueName: zod.ZodOptional<zod.ZodString>;
+            nullsNotDistinct: zod.ZodOptional<zod.ZodBoolean>;
+            generated: zod.ZodOptional<zod.ZodObject<{
+                type: zod.ZodLiteral<"stored">;
+                as: zod.ZodString;
+            }, "strip", zod.ZodTypeAny, {
+                type: "stored";
+                as: string;
+            }, {
+                type: "stored";
+                as: string;
+            }>>;
+            identity: zod.ZodOptional<zod.ZodObject<{
+                name: zod.ZodString;
+                increment: zod.ZodOptional<zod.ZodString>;
+                minValue: zod.ZodOptional<zod.ZodString>;
+                maxValue: zod.ZodOptional<zod.ZodString>;
+                startWith: zod.ZodOptional<zod.ZodString>;
+                cache: zod.ZodOptional<zod.ZodString>;
+                cycle: zod.ZodOptional<zod.ZodBoolean>;
+                schema: zod.ZodString;
+            } & {
+                type: zod.ZodEnum<["always", "byDefault"]>;
+            }, "strip", zod.ZodTypeAny, {
+                type: "always" | "byDefault";
+                name: string;
+                schema: string;
+                increment?: string | undefined;
+                minValue?: string | undefined;
+                maxValue?: string | undefined;
+                startWith?: string | undefined;
+                cache?: string | undefined;
+                cycle?: boolean | undefined;
+            }, {
+                type: "always" | "byDefault";
+                name: string;
+                schema: string;
+                increment?: string | undefined;
+                minValue?: string | undefined;
+                maxValue?: string | undefined;
+                startWith?: string | undefined;
+                cache?: string | undefined;
+                cycle?: boolean | undefined;
+            }>>;
+        }, "strict", zod.ZodTypeAny, {
+            type: string;
+            name: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            typeSchema?: string | undefined;
+            default?: any;
+            isUnique?: any;
+            uniqueName?: string | undefined;
+            nullsNotDistinct?: boolean | undefined;
+            generated?: {
+                type: "stored";
+                as: string;
+            } | undefined;
+            identity?: {
+                type: "always" | "byDefault";
+                name: string;
+                schema: string;
+                increment?: string | undefined;
+                minValue?: string | undefined;
+                maxValue?: string | undefined;
+                startWith?: string | undefined;
+                cache?: string | undefined;
+                cycle?: boolean | undefined;
+            } | undefined;
+        }, {
+            type: string;
+            name: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            typeSchema?: string | undefined;
+            default?: any;
+            isUnique?: any;
+            uniqueName?: string | undefined;
+            nullsNotDistinct?: boolean | undefined;
+            generated?: {
+                type: "stored";
+                as: string;
+            } | undefined;
+            identity?: {
+                type: "always" | "byDefault";
+                name: string;
+                schema: string;
+                increment?: string | undefined;
+                minValue?: string | undefined;
+                maxValue?: string | undefined;
+                startWith?: string | undefined;
+                cache?: string | undefined;
+                cycle?: boolean | undefined;
+            } | undefined;
+        }>>;
+        indexes: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
+            name: zod.ZodString;
+            columns: zod.ZodArray<zod.ZodObject<{
+                expression: zod.ZodString;
+                isExpression: zod.ZodBoolean;
+                asc: zod.ZodBoolean;
+                nulls: zod.ZodOptional<zod.ZodString>;
+                opclass: zod.ZodOptional<zod.ZodString>;
+            }, "strip", zod.ZodTypeAny, {
+                expression: string;
+                isExpression: boolean;
+                asc: boolean;
+                nulls?: string | undefined;
+                opclass?: string | undefined;
+            }, {
+                expression: string;
+                isExpression: boolean;
+                asc: boolean;
+                nulls?: string | undefined;
+                opclass?: string | undefined;
+            }>, "many">;
+            isUnique: zod.ZodBoolean;
+            with: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodAny>>;
+            method: zod.ZodDefault<zod.ZodString>;
+            where: zod.ZodOptional<zod.ZodString>;
+            concurrently: zod.ZodDefault<zod.ZodBoolean>;
+        }, "strict", zod.ZodTypeAny, {
+            name: string;
+            columns: {
+                expression: string;
+                isExpression: boolean;
+                asc: boolean;
+                nulls?: string | undefined;
+                opclass?: string | undefined;
+            }[];
+            isUnique: boolean;
+            method: string;
+            concurrently: boolean;
+            with?: Record<string, any> | undefined;
+            where?: string | undefined;
+        }, {
+            name: string;
+            columns: {
+                expression: string;
+                isExpression: boolean;
+                asc: boolean;
+                nulls?: string | undefined;
+                opclass?: string | undefined;
+            }[];
+            isUnique: boolean;
+            with?: Record<string, any> | undefined;
+            method?: string | undefined;
+            where?: string | undefined;
+            concurrently?: boolean | undefined;
+        }>>;
+        foreignKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
+            name: zod.ZodString;
+            tableFrom: zod.ZodString;
+            columnsFrom: zod.ZodArray<zod.ZodString, "many">;
+            tableTo: zod.ZodString;
+            schemaTo: zod.ZodOptional<zod.ZodString>;
+            columnsTo: zod.ZodArray<zod.ZodString, "many">;
+            onUpdate: zod.ZodOptional<zod.ZodString>;
+            onDelete: zod.ZodOptional<zod.ZodString>;
+        }, "strict", zod.ZodTypeAny, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            schemaTo?: string | undefined;
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            schemaTo?: string | undefined;
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>>;
+        compositePrimaryKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
+            name: zod.ZodString;
+            columns: zod.ZodArray<zod.ZodString, "many">;
+        }, "strict", zod.ZodTypeAny, {
+            name: string;
+            columns: string[];
+        }, {
+            name: string;
+            columns: string[];
+        }>>;
+        uniqueConstraints: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
+            name: zod.ZodString;
+            columns: zod.ZodArray<zod.ZodString, "many">;
+            nullsNotDistinct: zod.ZodBoolean;
+        }, "strict", zod.ZodTypeAny, {
+            name: string;
+            columns: string[];
+            nullsNotDistinct: boolean;
+        }, {
+            name: string;
+            columns: string[];
+            nullsNotDistinct: boolean;
+        }>>>;
+        policies: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
+            name: zod.ZodString;
+            as: zod.ZodOptional<zod.ZodEnum<["PERMISSIVE", "RESTRICTIVE"]>>;
+            for: zod.ZodOptional<zod.ZodEnum<["ALL", "SELECT", "INSERT", "UPDATE", "DELETE"]>>;
+            to: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
+            using: zod.ZodOptional<zod.ZodString>;
+            withCheck: zod.ZodOptional<zod.ZodString>;
+            on: zod.ZodOptional<zod.ZodString>;
+            schema: zod.ZodOptional<zod.ZodString>;
+        }, "strict", zod.ZodTypeAny, {
+            name: string;
+            schema?: string | undefined;
+            as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
+            for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
+            to?: string[] | undefined;
+            using?: string | undefined;
+            withCheck?: string | undefined;
+            on?: string | undefined;
+        }, {
+            name: string;
+            schema?: string | undefined;
+            as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
+            for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
+            to?: string[] | undefined;
+            using?: string | undefined;
+            withCheck?: string | undefined;
+            on?: string | undefined;
+        }>>>;
+        checkConstraints: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
+            name: zod.ZodString;
+            value: zod.ZodString;
+        }, "strict", zod.ZodTypeAny, {
+            value: string;
+            name: string;
+        }, {
+            value: string;
+            name: string;
+        }>>>;
+        isRLSEnabled: zod.ZodDefault<zod.ZodBoolean>;
+    }, "strict", zod.ZodTypeAny, {
+        name: string;
+        schema: string;
+        columns: Record<string, {
+            type: string;
+            name: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            typeSchema?: string | undefined;
+            default?: any;
+            isUnique?: any;
+            uniqueName?: string | undefined;
+            nullsNotDistinct?: boolean | undefined;
+            generated?: {
+                type: "stored";
+                as: string;
+            } | undefined;
+            identity?: {
+                type: "always" | "byDefault";
+                name: string;
+                schema: string;
+                increment?: string | undefined;
+                minValue?: string | undefined;
+                maxValue?: string | undefined;
+                startWith?: string | undefined;
+                cache?: string | undefined;
+                cycle?: boolean | undefined;
+            } | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: {
+                expression: string;
+                isExpression: boolean;
+                asc: boolean;
+                nulls?: string | undefined;
+                opclass?: string | undefined;
+            }[];
+            isUnique: boolean;
+            method: string;
+            concurrently: boolean;
+            with?: Record<string, any> | undefined;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            schemaTo?: string | undefined;
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+        uniqueConstraints: Record<string, {
+            name: string;
+            columns: string[];
+            nullsNotDistinct: boolean;
+        }>;
+        policies: Record<string, {
+            name: string;
+            schema?: string | undefined;
+            as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
+            for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
+            to?: string[] | undefined;
+            using?: string | undefined;
+            withCheck?: string | undefined;
+            on?: string | undefined;
+        }>;
+        checkConstraints: Record<string, {
+            value: string;
+            name: string;
+        }>;
+        isRLSEnabled: boolean;
+    }, {
+        name: string;
+        schema: string;
+        columns: Record<string, {
+            type: string;
+            name: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            typeSchema?: string | undefined;
+            default?: any;
+            isUnique?: any;
+            uniqueName?: string | undefined;
+            nullsNotDistinct?: boolean | undefined;
+            generated?: {
+                type: "stored";
+                as: string;
+            } | undefined;
+            identity?: {
+                type: "always" | "byDefault";
+                name: string;
+                schema: string;
+                increment?: string | undefined;
+                minValue?: string | undefined;
+                maxValue?: string | undefined;
+                startWith?: string | undefined;
+                cache?: string | undefined;
+                cycle?: boolean | undefined;
+            } | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: {
+                expression: string;
+                isExpression: boolean;
+                asc: boolean;
+                nulls?: string | undefined;
+                opclass?: string | undefined;
+            }[];
+            isUnique: boolean;
+            with?: Record<string, any> | undefined;
+            method?: string | undefined;
+            where?: string | undefined;
+            concurrently?: boolean | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            schemaTo?: string | undefined;
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+            nullsNotDistinct: boolean;
+        }> | undefined;
+        policies?: Record<string, {
+            name: string;
+            schema?: string | undefined;
+            as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
+            for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
+            to?: string[] | undefined;
+            using?: string | undefined;
+            withCheck?: string | undefined;
+            on?: string | undefined;
+        }> | undefined;
+        checkConstraints?: Record<string, {
+            value: string;
+            name: string;
+        }> | undefined;
+        isRLSEnabled?: boolean | undefined;
+    }>>;
+    enums: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
+        name: zod.ZodString;
+        schema: zod.ZodString;
+        values: zod.ZodArray<zod.ZodString, "many">;
+    }, "strict", zod.ZodTypeAny, {
+        values: string[];
+        name: string;
+        schema: string;
+    }, {
+        values: string[];
+        name: string;
+        schema: string;
+    }>>;
+    schemas: zod.ZodRecord<zod.ZodString, zod.ZodString>;
+    views: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
+        name: zod.ZodString;
+        schema: zod.ZodString;
+        columns: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
+            name: zod.ZodString;
+            type: zod.ZodString;
+            typeSchema: zod.ZodOptional<zod.ZodString>;
+            primaryKey: zod.ZodBoolean;
+            notNull: zod.ZodBoolean;
+            default: zod.ZodOptional<zod.ZodAny>;
+            isUnique: zod.ZodOptional<zod.ZodAny>;
+            uniqueName: zod.ZodOptional<zod.ZodString>;
+            nullsNotDistinct: zod.ZodOptional<zod.ZodBoolean>;
+            generated: zod.ZodOptional<zod.ZodObject<{
+                type: zod.ZodLiteral<"stored">;
+                as: zod.ZodString;
+            }, "strip", zod.ZodTypeAny, {
+                type: "stored";
+                as: string;
+            }, {
+                type: "stored";
+                as: string;
+            }>>;
+            identity: zod.ZodOptional<zod.ZodObject<{
+                name: zod.ZodString;
+                increment: zod.ZodOptional<zod.ZodString>;
+                minValue: zod.ZodOptional<zod.ZodString>;
+                maxValue: zod.ZodOptional<zod.ZodString>;
+                startWith: zod.ZodOptional<zod.ZodString>;
+                cache: zod.ZodOptional<zod.ZodString>;
+                cycle: zod.ZodOptional<zod.ZodBoolean>;
+                schema: zod.ZodString;
+            } & {
+                type: zod.ZodEnum<["always", "byDefault"]>;
+            }, "strip", zod.ZodTypeAny, {
+                type: "always" | "byDefault";
+                name: string;
+                schema: string;
+                increment?: string | undefined;
+                minValue?: string | undefined;
+                maxValue?: string | undefined;
+                startWith?: string | undefined;
+                cache?: string | undefined;
+                cycle?: boolean | undefined;
+            }, {
+                type: "always" | "byDefault";
+                name: string;
+                schema: string;
+                increment?: string | undefined;
+                minValue?: string | undefined;
+                maxValue?: string | undefined;
+                startWith?: string | undefined;
+                cache?: string | undefined;
+                cycle?: boolean | undefined;
+            }>>;
+        }, "strict", zod.ZodTypeAny, {
+            type: string;
+            name: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            typeSchema?: string | undefined;
+            default?: any;
+            isUnique?: any;
+            uniqueName?: string | undefined;
+            nullsNotDistinct?: boolean | undefined;
+            generated?: {
+                type: "stored";
+                as: string;
+            } | undefined;
+            identity?: {
+                type: "always" | "byDefault";
+                name: string;
+                schema: string;
+                increment?: string | undefined;
+                minValue?: string | undefined;
+                maxValue?: string | undefined;
+                startWith?: string | undefined;
+                cache?: string | undefined;
+                cycle?: boolean | undefined;
+            } | undefined;
+        }, {
+            type: string;
+            name: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            typeSchema?: string | undefined;
+            default?: any;
+            isUnique?: any;
+            uniqueName?: string | undefined;
+            nullsNotDistinct?: boolean | undefined;
+            generated?: {
+                type: "stored";
+                as: string;
+            } | undefined;
+            identity?: {
+                type: "always" | "byDefault";
+                name: string;
+                schema: string;
+                increment?: string | undefined;
+                minValue?: string | undefined;
+                maxValue?: string | undefined;
+                startWith?: string | undefined;
+                cache?: string | undefined;
+                cycle?: boolean | undefined;
+            } | undefined;
+        }>>;
+        definition: zod.ZodOptional<zod.ZodString>;
+        materialized: zod.ZodBoolean;
+        with: zod.ZodOptional<zod.ZodObject<{
+            checkOption: zod.ZodOptional<zod.ZodEnum<["local", "cascaded"]>>;
+            securityBarrier: zod.ZodOptional<zod.ZodBoolean>;
+            securityInvoker: zod.ZodOptional<zod.ZodBoolean>;
+        } & {
+            fillfactor: zod.ZodOptional<zod.ZodNumber>;
+            toastTupleTarget: zod.ZodOptional<zod.ZodNumber>;
+            parallelWorkers: zod.ZodOptional<zod.ZodNumber>;
+            autovacuumEnabled: zod.ZodOptional<zod.ZodBoolean>;
+            vacuumIndexCleanup: zod.ZodOptional<zod.ZodEnum<["auto", "off", "on"]>>;
+            vacuumTruncate: zod.ZodOptional<zod.ZodBoolean>;
+            autovacuumVacuumThreshold: zod.ZodOptional<zod.ZodNumber>;
+            autovacuumVacuumScaleFactor: zod.ZodOptional<zod.ZodNumber>;
+            autovacuumVacuumCostDelay: zod.ZodOptional<zod.ZodNumber>;
+            autovacuumVacuumCostLimit: zod.ZodOptional<zod.ZodNumber>;
+            autovacuumFreezeMinAge: zod.ZodOptional<zod.ZodNumber>;
+            autovacuumFreezeMaxAge: zod.ZodOptional<zod.ZodNumber>;
+            autovacuumFreezeTableAge: zod.ZodOptional<zod.ZodNumber>;
+            autovacuumMultixactFreezeMinAge: zod.ZodOptional<zod.ZodNumber>;
+            autovacuumMultixactFreezeMaxAge: zod.ZodOptional<zod.ZodNumber>;
+            autovacuumMultixactFreezeTableAge: zod.ZodOptional<zod.ZodNumber>;
+            logAutovacuumMinDuration: zod.ZodOptional<zod.ZodNumber>;
+            userCatalogTable: zod.ZodOptional<zod.ZodBoolean>;
+        }, "strict", zod.ZodTypeAny, {
+            checkOption?: "local" | "cascaded" | undefined;
+            securityBarrier?: boolean | undefined;
+            securityInvoker?: boolean | undefined;
+            fillfactor?: number | undefined;
+            toastTupleTarget?: number | undefined;
+            parallelWorkers?: number | undefined;
+            autovacuumEnabled?: boolean | undefined;
+            vacuumIndexCleanup?: "on" | "auto" | "off" | undefined;
+            vacuumTruncate?: boolean | undefined;
+            autovacuumVacuumThreshold?: number | undefined;
+            autovacuumVacuumScaleFactor?: number | undefined;
+            autovacuumVacuumCostDelay?: number | undefined;
+            autovacuumVacuumCostLimit?: number | undefined;
+            autovacuumFreezeMinAge?: number | undefined;
+            autovacuumFreezeMaxAge?: number | undefined;
+            autovacuumFreezeTableAge?: number | undefined;
+            autovacuumMultixactFreezeMinAge?: number | undefined;
+            autovacuumMultixactFreezeMaxAge?: number | undefined;
+            autovacuumMultixactFreezeTableAge?: number | undefined;
+            logAutovacuumMinDuration?: number | undefined;
+            userCatalogTable?: boolean | undefined;
+        }, {
+            checkOption?: "local" | "cascaded" | undefined;
+            securityBarrier?: boolean | undefined;
+            securityInvoker?: boolean | undefined;
+            fillfactor?: number | undefined;
+            toastTupleTarget?: number | undefined;
+            parallelWorkers?: number | undefined;
+            autovacuumEnabled?: boolean | undefined;
+            vacuumIndexCleanup?: "on" | "auto" | "off" | undefined;
+            vacuumTruncate?: boolean | undefined;
+            autovacuumVacuumThreshold?: number | undefined;
+            autovacuumVacuumScaleFactor?: number | undefined;
+            autovacuumVacuumCostDelay?: number | undefined;
+            autovacuumVacuumCostLimit?: number | undefined;
+            autovacuumFreezeMinAge?: number | undefined;
+            autovacuumFreezeMaxAge?: number | undefined;
+            autovacuumFreezeTableAge?: number | undefined;
+            autovacuumMultixactFreezeMinAge?: number | undefined;
+            autovacuumMultixactFreezeMaxAge?: number | undefined;
+            autovacuumMultixactFreezeTableAge?: number | undefined;
+            logAutovacuumMinDuration?: number | undefined;
+            userCatalogTable?: boolean | undefined;
+        }>>;
+        isExisting: zod.ZodBoolean;
+        withNoData: zod.ZodOptional<zod.ZodBoolean>;
+        using: zod.ZodOptional<zod.ZodString>;
+        tablespace: zod.ZodOptional<zod.ZodString>;
+    }, "strict", zod.ZodTypeAny, {
+        name: string;
+        schema: string;
+        columns: Record<string, {
+            type: string;
+            name: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            typeSchema?: string | undefined;
+            default?: any;
+            isUnique?: any;
+            uniqueName?: string | undefined;
+            nullsNotDistinct?: boolean | undefined;
+            generated?: {
+                type: "stored";
+                as: string;
+            } | undefined;
+            identity?: {
+                type: "always" | "byDefault";
+                name: string;
+                schema: string;
+                increment?: string | undefined;
+                minValue?: string | undefined;
+                maxValue?: string | undefined;
+                startWith?: string | undefined;
+                cache?: string | undefined;
+                cycle?: boolean | undefined;
+            } | undefined;
+        }>;
+        materialized: boolean;
+        isExisting: boolean;
+        with?: {
+            checkOption?: "local" | "cascaded" | undefined;
+            securityBarrier?: boolean | undefined;
+            securityInvoker?: boolean | undefined;
+            fillfactor?: number | undefined;
+            toastTupleTarget?: number | undefined;
+            parallelWorkers?: number | undefined;
+            autovacuumEnabled?: boolean | undefined;
+            vacuumIndexCleanup?: "on" | "auto" | "off" | undefined;
+            vacuumTruncate?: boolean | undefined;
+            autovacuumVacuumThreshold?: number | undefined;
+            autovacuumVacuumScaleFactor?: number | undefined;
+            autovacuumVacuumCostDelay?: number | undefined;
+            autovacuumVacuumCostLimit?: number | undefined;
+            autovacuumFreezeMinAge?: number | undefined;
+            autovacuumFreezeMaxAge?: number | undefined;
+            autovacuumFreezeTableAge?: number | undefined;
+            autovacuumMultixactFreezeMinAge?: number | undefined;
+            autovacuumMultixactFreezeMaxAge?: number | undefined;
+            autovacuumMultixactFreezeTableAge?: number | undefined;
+            logAutovacuumMinDuration?: number | undefined;
+            userCatalogTable?: boolean | undefined;
+        } | undefined;
+        using?: string | undefined;
+        definition?: string | undefined;
+        withNoData?: boolean | undefined;
+        tablespace?: string | undefined;
+    }, {
+        name: string;
+        schema: string;
+        columns: Record<string, {
+            type: string;
+            name: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            typeSchema?: string | undefined;
+            default?: any;
+            isUnique?: any;
+            uniqueName?: string | undefined;
+            nullsNotDistinct?: boolean | undefined;
+            generated?: {
+                type: "stored";
+                as: string;
+            } | undefined;
+            identity?: {
+                type: "always" | "byDefault";
+                name: string;
+                schema: string;
+                increment?: string | undefined;
+                minValue?: string | undefined;
+                maxValue?: string | undefined;
+                startWith?: string | undefined;
+                cache?: string | undefined;
+                cycle?: boolean | undefined;
+            } | undefined;
+        }>;
+        materialized: boolean;
+        isExisting: boolean;
+        with?: {
+            checkOption?: "local" | "cascaded" | undefined;
+            securityBarrier?: boolean | undefined;
+            securityInvoker?: boolean | undefined;
+            fillfactor?: number | undefined;
+            toastTupleTarget?: number | undefined;
+            parallelWorkers?: number | undefined;
+            autovacuumEnabled?: boolean | undefined;
+            vacuumIndexCleanup?: "on" | "auto" | "off" | undefined;
+            vacuumTruncate?: boolean | undefined;
+            autovacuumVacuumThreshold?: number | undefined;
+            autovacuumVacuumScaleFactor?: number | undefined;
+            autovacuumVacuumCostDelay?: number | undefined;
+            autovacuumVacuumCostLimit?: number | undefined;
+            autovacuumFreezeMinAge?: number | undefined;
+            autovacuumFreezeMaxAge?: number | undefined;
+            autovacuumFreezeTableAge?: number | undefined;
+            autovacuumMultixactFreezeMinAge?: number | undefined;
+            autovacuumMultixactFreezeMaxAge?: number | undefined;
+            autovacuumMultixactFreezeTableAge?: number | undefined;
+            logAutovacuumMinDuration?: number | undefined;
+            userCatalogTable?: boolean | undefined;
+        } | undefined;
+        using?: string | undefined;
+        definition?: string | undefined;
+        withNoData?: boolean | undefined;
+        tablespace?: string | undefined;
+    }>>>;
+    sequences: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
+        name: zod.ZodString;
+        increment: zod.ZodOptional<zod.ZodString>;
+        minValue: zod.ZodOptional<zod.ZodString>;
+        maxValue: zod.ZodOptional<zod.ZodString>;
+        startWith: zod.ZodOptional<zod.ZodString>;
+        cache: zod.ZodOptional<zod.ZodString>;
+        cycle: zod.ZodOptional<zod.ZodBoolean>;
+        schema: zod.ZodString;
+    }, "strict", zod.ZodTypeAny, {
+        name: string;
+        schema: string;
+        increment?: string | undefined;
+        minValue?: string | undefined;
+        maxValue?: string | undefined;
+        startWith?: string | undefined;
+        cache?: string | undefined;
+        cycle?: boolean | undefined;
+    }, {
+        name: string;
+        schema: string;
+        increment?: string | undefined;
+        minValue?: string | undefined;
+        maxValue?: string | undefined;
+        startWith?: string | undefined;
+        cache?: string | undefined;
+        cycle?: boolean | undefined;
+    }>>>;
+    roles: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
+        name: zod.ZodString;
+        createDb: zod.ZodOptional<zod.ZodBoolean>;
+        createRole: zod.ZodOptional<zod.ZodBoolean>;
+        inherit: zod.ZodOptional<zod.ZodBoolean>;
+    }, "strict", zod.ZodTypeAny, {
+        name: string;
+        createDb?: boolean | undefined;
+        createRole?: boolean | undefined;
+        inherit?: boolean | undefined;
+    }, {
+        name: string;
+        createDb?: boolean | undefined;
+        createRole?: boolean | undefined;
+        inherit?: boolean | undefined;
+    }>>>;
+    policies: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
+        name: zod.ZodString;
+        as: zod.ZodOptional<zod.ZodEnum<["PERMISSIVE", "RESTRICTIVE"]>>;
+        for: zod.ZodOptional<zod.ZodEnum<["ALL", "SELECT", "INSERT", "UPDATE", "DELETE"]>>;
+        to: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
+        using: zod.ZodOptional<zod.ZodString>;
+        withCheck: zod.ZodOptional<zod.ZodString>;
+        on: zod.ZodOptional<zod.ZodString>;
+        schema: zod.ZodOptional<zod.ZodString>;
+    }, "strict", zod.ZodTypeAny, {
+        name: string;
+        schema?: string | undefined;
+        as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
+        for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
+        to?: string[] | undefined;
+        using?: string | undefined;
+        withCheck?: string | undefined;
+        on?: string | undefined;
+    }, {
+        name: string;
+        schema?: string | undefined;
+        as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
+        for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
+        to?: string[] | undefined;
+        using?: string | undefined;
+        withCheck?: string | undefined;
+        on?: string | undefined;
+    }>>>;
+    _meta: zod.ZodObject<{
+        schemas: zod.ZodRecord<zod.ZodString, zod.ZodString>;
+        tables: zod.ZodRecord<zod.ZodString, zod.ZodString>;
+        columns: zod.ZodRecord<zod.ZodString, zod.ZodString>;
+    }, "strip", zod.ZodTypeAny, {
+        tables: Record<string, string>;
+        columns: Record<string, string>;
+        schemas: Record<string, string>;
+    }, {
+        tables: Record<string, string>;
+        columns: Record<string, string>;
+        schemas: Record<string, string>;
+    }>;
+    internal: zod.ZodOptional<zod.ZodObject<{
+        tables: zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
+            columns: zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
+                isArray: zod.ZodOptional<zod.ZodBoolean>;
+                dimensions: zod.ZodOptional<zod.ZodNumber>;
+                rawType: zod.ZodOptional<zod.ZodString>;
+                isDefaultAnExpression: zod.ZodOptional<zod.ZodBoolean>;
+            }, "strip", zod.ZodTypeAny, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+                isDefaultAnExpression?: boolean | undefined;
+            }, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+                isDefaultAnExpression?: boolean | undefined;
+            }>>>;
+        }, "strip", zod.ZodTypeAny, {
+            columns: Record<string, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        }, {
+            columns: Record<string, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        }>>>;
+    }, "strip", zod.ZodTypeAny, {
+        tables: Record<string, {
+            columns: Record<string, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined>;
+    }, {
+        tables: Record<string, {
+            columns: Record<string, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined>;
+    }>>;
+} & {
+    id: zod.ZodString;
+    prevId: zod.ZodString;
+}, "strip", zod.ZodTypeAny, {
+    version: "7";
+    dialect: "postgresql";
+    tables: Record<string, {
+        name: string;
+        schema: string;
+        columns: Record<string, {
+            type: string;
+            name: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            typeSchema?: string | undefined;
+            default?: any;
+            isUnique?: any;
+            uniqueName?: string | undefined;
+            nullsNotDistinct?: boolean | undefined;
+            generated?: {
+                type: "stored";
+                as: string;
+            } | undefined;
+            identity?: {
+                type: "always" | "byDefault";
+                name: string;
+                schema: string;
+                increment?: string | undefined;
+                minValue?: string | undefined;
+                maxValue?: string | undefined;
+                startWith?: string | undefined;
+                cache?: string | undefined;
+                cycle?: boolean | undefined;
+            } | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: {
+                expression: string;
+                isExpression: boolean;
+                asc: boolean;
+                nulls?: string | undefined;
+                opclass?: string | undefined;
+            }[];
+            isUnique: boolean;
+            method: string;
+            concurrently: boolean;
+            with?: Record<string, any> | undefined;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            schemaTo?: string | undefined;
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+        uniqueConstraints: Record<string, {
+            name: string;
+            columns: string[];
+            nullsNotDistinct: boolean;
+        }>;
+        policies: Record<string, {
+            name: string;
+            schema?: string | undefined;
+            as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
+            for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
+            to?: string[] | undefined;
+            using?: string | undefined;
+            withCheck?: string | undefined;
+            on?: string | undefined;
+        }>;
+        checkConstraints: Record<string, {
+            value: string;
+            name: string;
+        }>;
+        isRLSEnabled: boolean;
+    }>;
+    policies: Record<string, {
+        name: string;
+        schema?: string | undefined;
+        as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
+        for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
+        to?: string[] | undefined;
+        using?: string | undefined;
+        withCheck?: string | undefined;
+        on?: string | undefined;
+    }>;
+    enums: Record<string, {
+        values: string[];
+        name: string;
+        schema: string;
+    }>;
+    schemas: Record<string, string>;
+    views: Record<string, {
+        name: string;
+        schema: string;
+        columns: Record<string, {
+            type: string;
+            name: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            typeSchema?: string | undefined;
+            default?: any;
+            isUnique?: any;
+            uniqueName?: string | undefined;
+            nullsNotDistinct?: boolean | undefined;
+            generated?: {
+                type: "stored";
+                as: string;
+            } | undefined;
+            identity?: {
+                type: "always" | "byDefault";
+                name: string;
+                schema: string;
+                increment?: string | undefined;
+                minValue?: string | undefined;
+                maxValue?: string | undefined;
+                startWith?: string | undefined;
+                cache?: string | undefined;
+                cycle?: boolean | undefined;
+            } | undefined;
+        }>;
+        materialized: boolean;
+        isExisting: boolean;
+        with?: {
+            checkOption?: "local" | "cascaded" | undefined;
+            securityBarrier?: boolean | undefined;
+            securityInvoker?: boolean | undefined;
+            fillfactor?: number | undefined;
+            toastTupleTarget?: number | undefined;
+            parallelWorkers?: number | undefined;
+            autovacuumEnabled?: boolean | undefined;
+            vacuumIndexCleanup?: "on" | "auto" | "off" | undefined;
+            vacuumTruncate?: boolean | undefined;
+            autovacuumVacuumThreshold?: number | undefined;
+            autovacuumVacuumScaleFactor?: number | undefined;
+            autovacuumVacuumCostDelay?: number | undefined;
+            autovacuumVacuumCostLimit?: number | undefined;
+            autovacuumFreezeMinAge?: number | undefined;
+            autovacuumFreezeMaxAge?: number | undefined;
+            autovacuumFreezeTableAge?: number | undefined;
+            autovacuumMultixactFreezeMinAge?: number | undefined;
+            autovacuumMultixactFreezeMaxAge?: number | undefined;
+            autovacuumMultixactFreezeTableAge?: number | undefined;
+            logAutovacuumMinDuration?: number | undefined;
+            userCatalogTable?: boolean | undefined;
+        } | undefined;
+        using?: string | undefined;
+        definition?: string | undefined;
+        withNoData?: boolean | undefined;
+        tablespace?: string | undefined;
+    }>;
+    sequences: Record<string, {
+        name: string;
+        schema: string;
+        increment?: string | undefined;
+        minValue?: string | undefined;
+        maxValue?: string | undefined;
+        startWith?: string | undefined;
+        cache?: string | undefined;
+        cycle?: boolean | undefined;
+    }>;
+    roles: Record<string, {
+        name: string;
+        createDb?: boolean | undefined;
+        createRole?: boolean | undefined;
+        inherit?: boolean | undefined;
+    }>;
+    _meta: {
+        tables: Record<string, string>;
+        columns: Record<string, string>;
+        schemas: Record<string, string>;
+    };
+    id: string;
+    prevId: string;
+    internal?: {
+        tables: Record<string, {
+            columns: Record<string, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined>;
+    } | undefined;
+}, {
+    version: "7";
+    dialect: "postgresql";
+    tables: Record<string, {
+        name: string;
+        schema: string;
+        columns: Record<string, {
+            type: string;
+            name: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            typeSchema?: string | undefined;
+            default?: any;
+            isUnique?: any;
+            uniqueName?: string | undefined;
+            nullsNotDistinct?: boolean | undefined;
+            generated?: {
+                type: "stored";
+                as: string;
+            } | undefined;
+            identity?: {
+                type: "always" | "byDefault";
+                name: string;
+                schema: string;
+                increment?: string | undefined;
+                minValue?: string | undefined;
+                maxValue?: string | undefined;
+                startWith?: string | undefined;
+                cache?: string | undefined;
+                cycle?: boolean | undefined;
+            } | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: {
+                expression: string;
+                isExpression: boolean;
+                asc: boolean;
+                nulls?: string | undefined;
+                opclass?: string | undefined;
+            }[];
+            isUnique: boolean;
+            with?: Record<string, any> | undefined;
+            method?: string | undefined;
+            where?: string | undefined;
+            concurrently?: boolean | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            schemaTo?: string | undefined;
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+            nullsNotDistinct: boolean;
+        }> | undefined;
+        policies?: Record<string, {
+            name: string;
+            schema?: string | undefined;
+            as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
+            for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
+            to?: string[] | undefined;
+            using?: string | undefined;
+            withCheck?: string | undefined;
+            on?: string | undefined;
+        }> | undefined;
+        checkConstraints?: Record<string, {
+            value: string;
+            name: string;
+        }> | undefined;
+        isRLSEnabled?: boolean | undefined;
+    }>;
+    enums: Record<string, {
+        values: string[];
+        name: string;
+        schema: string;
+    }>;
+    schemas: Record<string, string>;
+    _meta: {
+        tables: Record<string, string>;
+        columns: Record<string, string>;
+        schemas: Record<string, string>;
+    };
+    id: string;
+    prevId: string;
+    policies?: Record<string, {
+        name: string;
+        schema?: string | undefined;
+        as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
+        for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
+        to?: string[] | undefined;
+        using?: string | undefined;
+        withCheck?: string | undefined;
+        on?: string | undefined;
+    }> | undefined;
+    views?: Record<string, {
+        name: string;
+        schema: string;
+        columns: Record<string, {
+            type: string;
+            name: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            typeSchema?: string | undefined;
+            default?: any;
+            isUnique?: any;
+            uniqueName?: string | undefined;
+            nullsNotDistinct?: boolean | undefined;
+            generated?: {
+                type: "stored";
+                as: string;
+            } | undefined;
+            identity?: {
+                type: "always" | "byDefault";
+                name: string;
+                schema: string;
+                increment?: string | undefined;
+                minValue?: string | undefined;
+                maxValue?: string | undefined;
+                startWith?: string | undefined;
+                cache?: string | undefined;
+                cycle?: boolean | undefined;
+            } | undefined;
+        }>;
+        materialized: boolean;
+        isExisting: boolean;
+        with?: {
+            checkOption?: "local" | "cascaded" | undefined;
+            securityBarrier?: boolean | undefined;
+            securityInvoker?: boolean | undefined;
+            fillfactor?: number | undefined;
+            toastTupleTarget?: number | undefined;
+            parallelWorkers?: number | undefined;
+            autovacuumEnabled?: boolean | undefined;
+            vacuumIndexCleanup?: "on" | "auto" | "off" | undefined;
+            vacuumTruncate?: boolean | undefined;
+            autovacuumVacuumThreshold?: number | undefined;
+            autovacuumVacuumScaleFactor?: number | undefined;
+            autovacuumVacuumCostDelay?: number | undefined;
+            autovacuumVacuumCostLimit?: number | undefined;
+            autovacuumFreezeMinAge?: number | undefined;
+            autovacuumFreezeMaxAge?: number | undefined;
+            autovacuumFreezeTableAge?: number | undefined;
+            autovacuumMultixactFreezeMinAge?: number | undefined;
+            autovacuumMultixactFreezeMaxAge?: number | undefined;
+            autovacuumMultixactFreezeTableAge?: number | undefined;
+            logAutovacuumMinDuration?: number | undefined;
+            userCatalogTable?: boolean | undefined;
+        } | undefined;
+        using?: string | undefined;
+        definition?: string | undefined;
+        withNoData?: boolean | undefined;
+        tablespace?: string | undefined;
+    }> | undefined;
+    sequences?: Record<string, {
+        name: string;
+        schema: string;
+        increment?: string | undefined;
+        minValue?: string | undefined;
+        maxValue?: string | undefined;
+        startWith?: string | undefined;
+        cache?: string | undefined;
+        cycle?: boolean | undefined;
+    }> | undefined;
+    roles?: Record<string, {
+        name: string;
+        createDb?: boolean | undefined;
+        createRole?: boolean | undefined;
+        inherit?: boolean | undefined;
+    }> | undefined;
+    internal?: {
+        tables: Record<string, {
+            columns: Record<string, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined>;
+    } | undefined;
+}>;
+type PgSchema = TypeOf<typeof pgSchema>;
+
+declare const schema$1: zod.ZodObject<{
+    version: zod.ZodLiteral<"1">;
+    dialect: zod.ZodLiteral<"singlestore">;
+    tables: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
+        name: zod.ZodString;
+        columns: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
+            name: zod.ZodString;
+            type: zod.ZodString;
+            primaryKey: zod.ZodBoolean;
+            notNull: zod.ZodBoolean;
+            autoincrement: zod.ZodOptional<zod.ZodBoolean>;
+            default: zod.ZodOptional<zod.ZodAny>;
+            onUpdate: zod.ZodOptional<zod.ZodAny>;
+            generated: zod.ZodOptional<zod.ZodObject<{
+                type: zod.ZodEnum<["stored", "virtual"]>;
+                as: zod.ZodString;
+            }, "strip", zod.ZodTypeAny, {
+                type: "stored" | "virtual";
+                as: string;
+            }, {
+                type: "stored" | "virtual";
+                as: string;
+            }>>;
+        }, "strict", zod.ZodTypeAny, {
+            type: string;
+            name: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            generated?: {
+                type: "stored" | "virtual";
+                as: string;
+            } | undefined;
+            onUpdate?: any;
+            autoincrement?: boolean | undefined;
+        }, {
+            type: string;
+            name: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            generated?: {
+                type: "stored" | "virtual";
+                as: string;
+            } | undefined;
+            onUpdate?: any;
+            autoincrement?: boolean | undefined;
+        }>>;
+        indexes: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
+            name: zod.ZodString;
+            columns: zod.ZodArray<zod.ZodString, "many">;
+            isUnique: zod.ZodBoolean;
+            using: zod.ZodOptional<zod.ZodEnum<["btree", "hash"]>>;
+            algorithm: zod.ZodOptional<zod.ZodEnum<["default", "inplace", "copy"]>>;
+            lock: zod.ZodOptional<zod.ZodEnum<["default", "none", "shared", "exclusive"]>>;
+        }, "strict", zod.ZodTypeAny, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+        }, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+        }>>;
+        compositePrimaryKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
+            name: zod.ZodString;
+            columns: zod.ZodArray<zod.ZodString, "many">;
+        }, "strict", zod.ZodTypeAny, {
+            name: string;
+            columns: string[];
+        }, {
+            name: string;
+            columns: string[];
+        }>>;
+        uniqueConstraints: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
+            name: zod.ZodString;
+            columns: zod.ZodArray<zod.ZodString, "many">;
+        }, "strict", zod.ZodTypeAny, {
+            name: string;
+            columns: string[];
+        }, {
+            name: string;
+            columns: string[];
+        }>>>;
+    }, "strict", zod.ZodTypeAny, {
+        name: string;
+        columns: Record<string, {
+            type: string;
+            name: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            generated?: {
+                type: "stored" | "virtual";
+                as: string;
+            } | undefined;
+            onUpdate?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+        uniqueConstraints: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+    }, {
+        name: string;
+        columns: Record<string, {
+            type: string;
+            name: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            generated?: {
+                type: "stored" | "virtual";
+                as: string;
+            } | undefined;
+            onUpdate?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+        }> | undefined;
+    }>>;
+    _meta: zod.ZodObject<{
+        tables: zod.ZodRecord<zod.ZodString, zod.ZodString>;
+        columns: zod.ZodRecord<zod.ZodString, zod.ZodString>;
+    }, "strip", zod.ZodTypeAny, {
+        tables: Record<string, string>;
+        columns: Record<string, string>;
+    }, {
+        tables: Record<string, string>;
+        columns: Record<string, string>;
+    }>;
+    internal: zod.ZodOptional<zod.ZodObject<{
+        tables: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
+            columns: zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
+                isDefaultAnExpression: zod.ZodOptional<zod.ZodBoolean>;
+            }, "strip", zod.ZodTypeAny, {
+                isDefaultAnExpression?: boolean | undefined;
+            }, {
+                isDefaultAnExpression?: boolean | undefined;
+            }>>>;
+        }, "strip", zod.ZodTypeAny, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        }, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        }>>>>;
+        indexes: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
+            columns: zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
+                isExpression: zod.ZodOptional<zod.ZodBoolean>;
+            }, "strip", zod.ZodTypeAny, {
+                isExpression?: boolean | undefined;
+            }, {
+                isExpression?: boolean | undefined;
+            }>>>;
+        }, "strip", zod.ZodTypeAny, {
+            columns: Record<string, {
+                isExpression?: boolean | undefined;
+            } | undefined>;
+        }, {
+            columns: Record<string, {
+                isExpression?: boolean | undefined;
+            } | undefined>;
+        }>>>>;
+    }, "strip", zod.ZodTypeAny, {
+        tables?: Record<string, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined> | undefined;
+        indexes?: Record<string, {
+            columns: Record<string, {
+                isExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined> | undefined;
+    }, {
+        tables?: Record<string, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined> | undefined;
+        indexes?: Record<string, {
+            columns: Record<string, {
+                isExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined> | undefined;
+    }>>;
+} & {
+    id: zod.ZodString;
+    prevId: zod.ZodString;
+}, "strip", zod.ZodTypeAny, {
+    version: "1";
+    dialect: "singlestore";
+    tables: Record<string, {
+        name: string;
+        columns: Record<string, {
+            type: string;
+            name: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            generated?: {
+                type: "stored" | "virtual";
+                as: string;
+            } | undefined;
+            onUpdate?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+        uniqueConstraints: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+    }>;
+    _meta: {
+        tables: Record<string, string>;
+        columns: Record<string, string>;
+    };
+    id: string;
+    prevId: string;
+    internal?: {
+        tables?: Record<string, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined> | undefined;
+        indexes?: Record<string, {
+            columns: Record<string, {
+                isExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined> | undefined;
+    } | undefined;
+}, {
+    version: "1";
+    dialect: "singlestore";
+    tables: Record<string, {
+        name: string;
+        columns: Record<string, {
+            type: string;
+            name: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            generated?: {
+                type: "stored" | "virtual";
+                as: string;
+            } | undefined;
+            onUpdate?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+        }> | undefined;
+    }>;
+    _meta: {
+        tables: Record<string, string>;
+        columns: Record<string, string>;
+    };
+    id: string;
+    prevId: string;
+    internal?: {
+        tables?: Record<string, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined> | undefined;
+        indexes?: Record<string, {
+            columns: Record<string, {
+                isExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined> | undefined;
+    } | undefined;
+}>;
+type SingleStoreSchema = TypeOf<typeof schema$1>;
+
+declare const schema$3: zod.ZodObject<{
+    version: zod.ZodLiteral<"6">;
+    dialect: zod.ZodEnum<["sqlite"]>;
+    tables: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
+        name: zod.ZodString;
+        columns: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
+            name: zod.ZodString;
+            type: zod.ZodString;
+            primaryKey: zod.ZodBoolean;
+            notNull: zod.ZodBoolean;
+            autoincrement: zod.ZodOptional<zod.ZodBoolean>;
+            default: zod.ZodOptional<zod.ZodAny>;
+            generated: zod.ZodOptional<zod.ZodObject<{
+                type: zod.ZodEnum<["stored", "virtual"]>;
+                as: zod.ZodString;
+            }, "strip", zod.ZodTypeAny, {
+                type: "stored" | "virtual";
+                as: string;
+            }, {
+                type: "stored" | "virtual";
+                as: string;
+            }>>;
+        }, "strict", zod.ZodTypeAny, {
+            type: string;
+            name: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            generated?: {
+                type: "stored" | "virtual";
+                as: string;
+            } | undefined;
+            autoincrement?: boolean | undefined;
+        }, {
+            type: string;
+            name: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            generated?: {
+                type: "stored" | "virtual";
+                as: string;
+            } | undefined;
+            autoincrement?: boolean | undefined;
+        }>>;
+        indexes: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
+            name: zod.ZodString;
+            columns: zod.ZodArray<zod.ZodString, "many">;
+            where: zod.ZodOptional<zod.ZodString>;
+            isUnique: zod.ZodBoolean;
+        }, "strict", zod.ZodTypeAny, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>>;
+        foreignKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
+            name: zod.ZodString;
+            tableFrom: zod.ZodString;
+            columnsFrom: zod.ZodArray<zod.ZodString, "many">;
+            tableTo: zod.ZodString;
+            columnsTo: zod.ZodArray<zod.ZodString, "many">;
+            onUpdate: zod.ZodOptional<zod.ZodString>;
+            onDelete: zod.ZodOptional<zod.ZodString>;
+        }, "strict", zod.ZodTypeAny, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>>;
+        compositePrimaryKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
+            columns: zod.ZodArray<zod.ZodString, "many">;
+            name: zod.ZodOptional<zod.ZodString>;
+        }, "strict", zod.ZodTypeAny, {
+            columns: string[];
+            name?: string | undefined;
+        }, {
+            columns: string[];
+            name?: string | undefined;
+        }>>;
+        uniqueConstraints: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
+            name: zod.ZodString;
+            columns: zod.ZodArray<zod.ZodString, "many">;
+        }, "strict", zod.ZodTypeAny, {
+            name: string;
+            columns: string[];
+        }, {
+            name: string;
+            columns: string[];
+        }>>>;
+        checkConstraints: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
+            name: zod.ZodString;
+            value: zod.ZodString;
+        }, "strict", zod.ZodTypeAny, {
+            value: string;
+            name: string;
+        }, {
+            value: string;
+            name: string;
+        }>>>;
+    }, "strict", zod.ZodTypeAny, {
+        name: string;
+        columns: Record<string, {
+            type: string;
+            name: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            generated?: {
+                type: "stored" | "virtual";
+                as: string;
+            } | undefined;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            columns: string[];
+            name?: string | undefined;
+        }>;
+        uniqueConstraints: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+        checkConstraints: Record<string, {
+            value: string;
+            name: string;
+        }>;
+    }, {
+        name: string;
+        columns: Record<string, {
+            type: string;
+            name: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            generated?: {
+                type: "stored" | "virtual";
+                as: string;
+            } | undefined;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            columns: string[];
+            name?: string | undefined;
+        }>;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+        }> | undefined;
+        checkConstraints?: Record<string, {
+            value: string;
+            name: string;
+        }> | undefined;
+    }>>;
+    views: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
+        name: zod.ZodString;
+        columns: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
+            name: zod.ZodString;
+            type: zod.ZodString;
+            primaryKey: zod.ZodBoolean;
+            notNull: zod.ZodBoolean;
+            autoincrement: zod.ZodOptional<zod.ZodBoolean>;
+            default: zod.ZodOptional<zod.ZodAny>;
+            generated: zod.ZodOptional<zod.ZodObject<{
+                type: zod.ZodEnum<["stored", "virtual"]>;
+                as: zod.ZodString;
+            }, "strip", zod.ZodTypeAny, {
+                type: "stored" | "virtual";
+                as: string;
+            }, {
+                type: "stored" | "virtual";
+                as: string;
+            }>>;
+        }, "strict", zod.ZodTypeAny, {
+            type: string;
+            name: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            generated?: {
+                type: "stored" | "virtual";
+                as: string;
+            } | undefined;
+            autoincrement?: boolean | undefined;
+        }, {
+            type: string;
+            name: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            generated?: {
+                type: "stored" | "virtual";
+                as: string;
+            } | undefined;
+            autoincrement?: boolean | undefined;
+        }>>;
+        definition: zod.ZodOptional<zod.ZodString>;
+        isExisting: zod.ZodBoolean;
+    }, "strict", zod.ZodTypeAny, {
+        name: string;
+        columns: Record<string, {
+            type: string;
+            name: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            generated?: {
+                type: "stored" | "virtual";
+                as: string;
+            } | undefined;
+            autoincrement?: boolean | undefined;
+        }>;
+        isExisting: boolean;
+        definition?: string | undefined;
+    }, {
+        name: string;
+        columns: Record<string, {
+            type: string;
+            name: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            generated?: {
+                type: "stored" | "virtual";
+                as: string;
+            } | undefined;
+            autoincrement?: boolean | undefined;
+        }>;
+        isExisting: boolean;
+        definition?: string | undefined;
+    }>>>;
+    enums: zod.ZodObject<{}, "strip", zod.ZodTypeAny, {}, {}>;
+    _meta: zod.ZodObject<{
+        tables: zod.ZodRecord<zod.ZodString, zod.ZodString>;
+        columns: zod.ZodRecord<zod.ZodString, zod.ZodString>;
+    }, "strip", zod.ZodTypeAny, {
+        tables: Record<string, string>;
+        columns: Record<string, string>;
+    }, {
+        tables: Record<string, string>;
+        columns: Record<string, string>;
+    }>;
+    internal: zod.ZodOptional<zod.ZodObject<{
+        indexes: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
+            columns: zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
+                isExpression: zod.ZodOptional<zod.ZodBoolean>;
+            }, "strip", zod.ZodTypeAny, {
+                isExpression?: boolean | undefined;
+            }, {
+                isExpression?: boolean | undefined;
+            }>>>;
+        }, "strip", zod.ZodTypeAny, {
+            columns: Record<string, {
+                isExpression?: boolean | undefined;
+            } | undefined>;
+        }, {
+            columns: Record<string, {
+                isExpression?: boolean | undefined;
+            } | undefined>;
+        }>>>>;
+    }, "strip", zod.ZodTypeAny, {
+        indexes?: Record<string, {
+            columns: Record<string, {
+                isExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined> | undefined;
+    }, {
+        indexes?: Record<string, {
+            columns: Record<string, {
+                isExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined> | undefined;
+    }>>;
+} & {
+    id: zod.ZodString;
+    prevId: zod.ZodString;
+}, "strict", zod.ZodTypeAny, {
+    version: "6";
+    dialect: "sqlite";
+    tables: Record<string, {
+        name: string;
+        columns: Record<string, {
+            type: string;
+            name: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            generated?: {
+                type: "stored" | "virtual";
+                as: string;
+            } | undefined;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            columns: string[];
+            name?: string | undefined;
+        }>;
+        uniqueConstraints: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+        checkConstraints: Record<string, {
+            value: string;
+            name: string;
+        }>;
+    }>;
+    enums: {};
+    views: Record<string, {
+        name: string;
+        columns: Record<string, {
+            type: string;
+            name: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            generated?: {
+                type: "stored" | "virtual";
+                as: string;
+            } | undefined;
+            autoincrement?: boolean | undefined;
+        }>;
+        isExisting: boolean;
+        definition?: string | undefined;
+    }>;
+    _meta: {
+        tables: Record<string, string>;
+        columns: Record<string, string>;
+    };
+    id: string;
+    prevId: string;
+    internal?: {
+        indexes?: Record<string, {
+            columns: Record<string, {
+                isExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined> | undefined;
+    } | undefined;
+}, {
+    version: "6";
+    dialect: "sqlite";
+    tables: Record<string, {
+        name: string;
+        columns: Record<string, {
+            type: string;
+            name: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            generated?: {
+                type: "stored" | "virtual";
+                as: string;
+            } | undefined;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            columns: string[];
+            name?: string | undefined;
+        }>;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+        }> | undefined;
+        checkConstraints?: Record<string, {
+            value: string;
+            name: string;
+        }> | undefined;
+    }>;
+    enums: {};
+    _meta: {
+        tables: Record<string, string>;
+        columns: Record<string, string>;
+    };
+    id: string;
+    prevId: string;
+    views?: Record<string, {
+        name: string;
+        columns: Record<string, {
+            type: string;
+            name: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            generated?: {
+                type: "stored" | "virtual";
+                as: string;
+            } | undefined;
+            autoincrement?: boolean | undefined;
+        }>;
+        isExisting: boolean;
+        definition?: string | undefined;
+    }> | undefined;
+    internal?: {
+        indexes?: Record<string, {
+            columns: Record<string, {
+                isExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined> | undefined;
+    } | undefined;
+}>;
+type SQLiteSchema = TypeOf<typeof schema$3>;
+
+type DrizzleSnapshotJSON = PgSchema;
+type DrizzleSQLiteSnapshotJSON = SQLiteSchema;
+type DrizzleMySQLSnapshotJSON = MySqlSchema;
+type DrizzleSingleStoreSnapshotJSON = SingleStoreSchema;
+declare const generateDrizzleJson: (imports: Record<string, unknown>, prevId?: string, schemaFilters?: string[], casing?: CasingType) => PgSchema;
+declare const generateMigration: (prev: DrizzleSnapshotJSON, cur: DrizzleSnapshotJSON) => Promise<string[]>;
+declare const pushSchema: (imports: Record<string, unknown>, drizzleInstance: PgDatabase<any>, schemaFilters?: string[], tablesFilter?: string[], extensionsFilters?: Config["extensionsFilters"]) => Promise<{
+    hasDataLoss: boolean;
+    warnings: string[];
+    statementsToExecute: string[];
+    apply: () => Promise<void>;
+}>;
+declare const generateSQLiteDrizzleJson: (imports: Record<string, unknown>, prevId?: string, casing?: CasingType) => Promise<SQLiteSchema>;
+declare const generateSQLiteMigration: (prev: DrizzleSQLiteSnapshotJSON, cur: DrizzleSQLiteSnapshotJSON) => Promise<string[]>;
+declare const pushSQLiteSchema: (imports: Record<string, unknown>, drizzleInstance: LibSQLDatabase<any>) => Promise<{
+    hasDataLoss: boolean;
+    warnings: string[];
+    statementsToExecute: string[];
+    apply: () => Promise<void>;
+}>;
+declare const generateMySQLDrizzleJson: (imports: Record<string, unknown>, prevId?: string, casing?: CasingType) => Promise<MySqlSchema>;
+declare const generateMySQLMigration: (prev: DrizzleMySQLSnapshotJSON, cur: DrizzleMySQLSnapshotJSON) => Promise<string[]>;
+declare const pushMySQLSchema: (imports: Record<string, unknown>, drizzleInstance: MySql2Database<any>, databaseName: string) => Promise<{
+    hasDataLoss: boolean;
+    warnings: string[];
+    statementsToExecute: string[];
+    apply: () => Promise<void>;
+}>;
+declare const generateSingleStoreDrizzleJson: (imports: Record<string, unknown>, prevId?: string, casing?: CasingType) => Promise<SingleStoreSchema>;
+declare const generateSingleStoreMigration: (prev: DrizzleSingleStoreSnapshotJSON, cur: DrizzleSingleStoreSnapshotJSON) => Promise<string[]>;
+declare const pushSingleStoreSchema: (imports: Record<string, unknown>, drizzleInstance: SingleStoreDriverDatabase<any>, databaseName: string) => Promise<{
+    hasDataLoss: boolean;
+    warnings: string[];
+    statementsToExecute: string[];
+    apply: () => Promise<void>;
+}>;
+declare const upPgSnapshot: (snapshot: Record<string, unknown>) => {
+    version: "7";
+    dialect: "postgresql";
+    tables: Record<string, {
+        name: string;
+        schema: string;
+        columns: Record<string, {
+            type: string;
+            name: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            typeSchema?: string | undefined;
+            default?: any;
+            isUnique?: any;
+            uniqueName?: string | undefined;
+            nullsNotDistinct?: boolean | undefined;
+            generated?: {
+                type: "stored";
+                as: string;
+            } | undefined;
+            identity?: {
+                type: "always" | "byDefault";
+                name: string;
+                schema: string;
+                increment?: string | undefined;
+                minValue?: string | undefined;
+                maxValue?: string | undefined;
+                startWith?: string | undefined;
+                cache?: string | undefined;
+                cycle?: boolean | undefined;
+            } | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: {
+                expression: string;
+                isExpression: boolean;
+                asc: boolean;
+                nulls?: string | undefined;
+                opclass?: string | undefined;
+            }[];
+            isUnique: boolean;
+            method: string;
+            concurrently: boolean;
+            with?: Record<string, any> | undefined;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            schemaTo?: string | undefined;
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+        uniqueConstraints: Record<string, {
+            name: string;
+            columns: string[];
+            nullsNotDistinct: boolean;
+        }>;
+        policies: Record<string, {
+            name: string;
+            schema?: string | undefined;
+            as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
+            for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
+            to?: string[] | undefined;
+            using?: string | undefined;
+            withCheck?: string | undefined;
+            on?: string | undefined;
+        }>;
+        checkConstraints: Record<string, {
+            value: string;
+            name: string;
+        }>;
+        isRLSEnabled: boolean;
+    }>;
+    policies: Record<string, {
+        name: string;
+        schema?: string | undefined;
+        as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
+        for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
+        to?: string[] | undefined;
+        using?: string | undefined;
+        withCheck?: string | undefined;
+        on?: string | undefined;
+    }>;
+    enums: Record<string, {
+        values: string[];
+        name: string;
+        schema: string;
+    }>;
+    schemas: Record<string, string>;
+    views: Record<string, {
+        name: string;
+        schema: string;
+        columns: Record<string, {
+            type: string;
+            name: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            typeSchema?: string | undefined;
+            default?: any;
+            isUnique?: any;
+            uniqueName?: string | undefined;
+            nullsNotDistinct?: boolean | undefined;
+            generated?: {
+                type: "stored";
+                as: string;
+            } | undefined;
+            identity?: {
+                type: "always" | "byDefault";
+                name: string;
+                schema: string;
+                increment?: string | undefined;
+                minValue?: string | undefined;
+                maxValue?: string | undefined;
+                startWith?: string | undefined;
+                cache?: string | undefined;
+                cycle?: boolean | undefined;
+            } | undefined;
+        }>;
+        materialized: boolean;
+        isExisting: boolean;
+        with?: {
+            checkOption?: "local" | "cascaded" | undefined;
+            securityBarrier?: boolean | undefined;
+            securityInvoker?: boolean | undefined;
+            fillfactor?: number | undefined;
+            toastTupleTarget?: number | undefined;
+            parallelWorkers?: number | undefined;
+            autovacuumEnabled?: boolean | undefined;
+            vacuumIndexCleanup?: "on" | "auto" | "off" | undefined;
+            vacuumTruncate?: boolean | undefined;
+            autovacuumVacuumThreshold?: number | undefined;
+            autovacuumVacuumScaleFactor?: number | undefined;
+            autovacuumVacuumCostDelay?: number | undefined;
+            autovacuumVacuumCostLimit?: number | undefined;
+            autovacuumFreezeMinAge?: number | undefined;
+            autovacuumFreezeMaxAge?: number | undefined;
+            autovacuumFreezeTableAge?: number | undefined;
+            autovacuumMultixactFreezeMinAge?: number | undefined;
+            autovacuumMultixactFreezeMaxAge?: number | undefined;
+            autovacuumMultixactFreezeTableAge?: number | undefined;
+            logAutovacuumMinDuration?: number | undefined;
+            userCatalogTable?: boolean | undefined;
+        } | undefined;
+        using?: string | undefined;
+        definition?: string | undefined;
+        withNoData?: boolean | undefined;
+        tablespace?: string | undefined;
+    }>;
+    sequences: Record<string, {
+        name: string;
+        schema: string;
+        increment?: string | undefined;
+        minValue?: string | undefined;
+        maxValue?: string | undefined;
+        startWith?: string | undefined;
+        cache?: string | undefined;
+        cycle?: boolean | undefined;
+    }>;
+    roles: Record<string, {
+        name: string;
+        createDb?: boolean | undefined;
+        createRole?: boolean | undefined;
+        inherit?: boolean | undefined;
+    }>;
+    _meta: {
+        tables: Record<string, string>;
+        columns: Record<string, string>;
+        schemas: Record<string, string>;
+    };
+    id: string;
+    prevId: string;
+    internal?: {
+        tables: Record<string, {
+            columns: Record<string, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined>;
+    } | undefined;
+} | Record<string, unknown>;
+
+type DrizzleKit_DrizzleMySQLSnapshotJSON = DrizzleMySQLSnapshotJSON;
+type DrizzleKit_DrizzleSQLiteSnapshotJSON = DrizzleSQLiteSnapshotJSON;
+type DrizzleKit_DrizzleSingleStoreSnapshotJSON = DrizzleSingleStoreSnapshotJSON;
+type DrizzleKit_DrizzleSnapshotJSON = DrizzleSnapshotJSON;
+declare const DrizzleKit_generateDrizzleJson: typeof generateDrizzleJson;
+declare const DrizzleKit_generateMigration: typeof generateMigration;
+declare const DrizzleKit_generateMySQLDrizzleJson: typeof generateMySQLDrizzleJson;
+declare const DrizzleKit_generateMySQLMigration: typeof generateMySQLMigration;
+declare const DrizzleKit_generateSQLiteDrizzleJson: typeof generateSQLiteDrizzleJson;
+declare const DrizzleKit_generateSQLiteMigration: typeof generateSQLiteMigration;
+declare const DrizzleKit_generateSingleStoreDrizzleJson: typeof generateSingleStoreDrizzleJson;
+declare const DrizzleKit_generateSingleStoreMigration: typeof generateSingleStoreMigration;
+declare const DrizzleKit_pushMySQLSchema: typeof pushMySQLSchema;
+declare const DrizzleKit_pushSQLiteSchema: typeof pushSQLiteSchema;
+declare const DrizzleKit_pushSchema: typeof pushSchema;
+declare const DrizzleKit_pushSingleStoreSchema: typeof pushSingleStoreSchema;
+declare const DrizzleKit_upPgSnapshot: typeof upPgSnapshot;
+declare namespace DrizzleKit {
+  export { type DrizzleKit_DrizzleMySQLSnapshotJSON as DrizzleMySQLSnapshotJSON, type DrizzleKit_DrizzleSQLiteSnapshotJSON as DrizzleSQLiteSnapshotJSON, type DrizzleKit_DrizzleSingleStoreSnapshotJSON as DrizzleSingleStoreSnapshotJSON, type DrizzleKit_DrizzleSnapshotJSON as DrizzleSnapshotJSON, DrizzleKit_generateDrizzleJson as generateDrizzleJson, DrizzleKit_generateMigration as generateMigration, DrizzleKit_generateMySQLDrizzleJson as generateMySQLDrizzleJson, DrizzleKit_generateMySQLMigration as generateMySQLMigration, DrizzleKit_generateSQLiteDrizzleJson as generateSQLiteDrizzleJson, DrizzleKit_generateSQLiteMigration as generateSQLiteMigration, DrizzleKit_generateSingleStoreDrizzleJson as generateSingleStoreDrizzleJson, DrizzleKit_generateSingleStoreMigration as generateSingleStoreMigration, DrizzleKit_pushMySQLSchema as pushMySQLSchema, DrizzleKit_pushSQLiteSchema as pushSQLiteSchema, DrizzleKit_pushSchema as pushSchema, DrizzleKit_pushSingleStoreSchema as pushSingleStoreSchema, DrizzleKit_upPgSnapshot as upPgSnapshot };
+}
 
 declare class RepositoryDescriptorProvider {
     protected readonly log: _alepha_core.Logger;
     protected readonly alepha: Alepha;
     protected readonly repositories: Array<Repository<any, TObject>>;
     constructor();
+    clearRepositories(): Promise<void>;
     protected readonly configure: _alepha_core.HookDescriptor<"configure">;
     /**
      * Get all repositories.
@@ -1206,7 +4318,8 @@ declare class RepositoryDescriptorProvider {
 declare class DrizzleKitProvider {
     protected readonly log: _alepha_core.Logger;
     protected readonly alepha: Alepha;
-    protected readonly repositoryDescriptorProvider: RepositoryDescriptorProvider;
+    protected readonly repositoryProvider: RepositoryDescriptorProvider;
+    push(provider: PostgresProvider, schema?: string): Promise<void>;
     /**
      * Try to generate migrations from scratch based on the models.
      * Then, execute the migrations.
@@ -1220,12 +4333,19 @@ declare class DrizzleKitProvider {
      * @returns A promise that resolves once the migrations have been executed.
      */
     synchronize(provider: PostgresProvider, schema?: string): Promise<void>;
+    protected getTables(provider: PostgresProvider, schema?: string): Promise<Record<string, any>>;
+    protected loadMigrationSnapshot(provider: PostgresProvider): Promise<any>;
+    protected saveMigrationSnapshot(provider: PostgresProvider, curr: Record<string, any>, entry?: {
+        id: number;
+        snapshot: string;
+    }): Promise<void>;
+    protected executeStatements(statements: string[], provider: PostgresProvider, _schema?: string, catchErrors?: boolean): Promise<void>;
+    protected prepareSchema(schemaName: string, provider: PostgresProvider, repositories: any[]): Promise<void>;
     /**
-     * Get the Drizzle Kit API.
-     *
-     * @protected
+     * Try to load the official Drizzle Kit API.
+     * If not available, fallback to the local kit import.
      */
-    protected importDrizzleKit(): any;
+    protected importDrizzleKit(): Promise<typeof DrizzleKit>;
 }
 
 declare module "alepha" {
@@ -1237,6 +4357,7 @@ declare const envSchema$1: _alepha_core.TObject<{
     PG_USERNAME: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
     PG_DATABASE: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
     PG_PASSWORD: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    PG_PORT: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
     /**
      *
      */
@@ -1245,14 +4366,6 @@ declare const envSchema$1: _alepha_core.TObject<{
      *
      */
     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.
@@ -1266,13 +4379,21 @@ declare const envSchema$1: _alepha_core.TObject<{
      */
     POSTGRES_SYNCHRONIZE: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
     /**
+     * Push the schema to the database.
      *
+     * @default false
+     */
+    POSTGRES_PUSH_SCHEMA: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+    /**
+     * Reject unauthorized SSL connections.
+     *
+     * @default false
      */
     POSTGRES_REJECT_UNAUTHORIZED: _sinclair_typebox.TBoolean;
 }>;
 interface NodePostgresProviderState {
-    client: pg$1.Client;
-    db: NodePgDatabase;
+    client: postgres.Sql;
+    db: PostgresJsDatabase;
 }
 declare class NodePostgresProvider implements PostgresProvider {
     readonly dialect = "postgres";
@@ -1282,10 +4403,10 @@ declare class NodePostgresProvider implements PostgresProvider {
         PG_USERNAME?: string | undefined;
         PG_DATABASE?: string | undefined;
         PG_PASSWORD?: string | undefined;
-        DATABASE_MIGRATIONS_SCHEMA?: string | undefined;
-        DATABASE_MIGRATIONS_TABLE?: string | undefined;
+        PG_PORT?: number | undefined;
         POSTGRES_SCHEMA?: string | undefined;
         POSTGRES_SYNCHRONIZE?: boolean | undefined;
+        POSTGRES_PUSH_SCHEMA?: boolean | undefined;
         DATABASE_URL: string;
         DATABASE_MIGRATIONS_FOLDER: string;
         POSTGRES_REJECT_UNAUTHORIZED: boolean;
@@ -1297,7 +4418,7 @@ declare class NodePostgresProvider implements PostgresProvider {
      * In testing mode, the schema name will be generated and deleted after the test.
      */
     protected testingSchemaName?: string;
-    get db(): NodePgDatabase;
+    get db(): PostgresJsDatabase;
     protected readonly configure: _alepha_core.HookDescriptor<"start">;
     protected readonly stop: _alepha_core.HookDescriptor<"stop">;
     /**
@@ -1307,14 +4428,12 @@ declare class NodePostgresProvider implements PostgresProvider {
     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;
+    protected getClientOptions(): postgres.Options<any>;
+    protected sslModes: readonly ["require", "allow", "prefer", "verify-full"];
+    protected ssl(url: URL | undefined): "require" | "allow" | "prefer" | "verify-full" | undefined;
 }
 
 /**
@@ -1326,6 +4445,9 @@ type PgAttr<T extends TSchema, TAttr extends PgSymbolKeys> = T & {
 
 declare const createdAtSchema: PgAttr<PgAttr<_sinclair_typebox.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
 
+/**
+ * @deprecated Use `pg.primaryKey()` instead.
+ */
 declare const legacyIdSchema: PgAttr<PgAttr<PgAttr<_sinclair_typebox.TInteger, typeof PG_PRIMARY_KEY>, typeof PG_SERIAL>, typeof PG_DEFAULT>;
 
 /**
@@ -1371,41 +4493,49 @@ declare module "alepha/core" {
 }
 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
+     * Creates a primary key with an identity column.
+     */
+    readonly identityPrimaryKey: (identity?: PgIdentityOptions, options?: IntegerOptions) => PgAttr<PgAttr<PgAttr<_sinclair_typebox.TInteger, typeof PG_PRIMARY_KEY>, typeof PG_IDENTITY>, typeof PG_DEFAULT>;
+    /**
+     * Creates a primary key with a big identity column. (default)
      */
-    readonly default: <T extends TSchema>(type: T, value?: Static$1<T>) => PgAttr<T, PgDefault>;
+    readonly bigIdentityPrimaryKey: (identity?: PgIdentityOptions, options?: NumberOptions) => PgAttr<PgAttr<PgAttr<_sinclair_typebox.TNumber, typeof PG_PRIMARY_KEY>, typeof PG_IDENTITY>, typeof PG_DEFAULT>;
+    /**
+     * Creates a primary key with a UUID column.
+     */
+    readonly uuidPrimaryKey: () => PgAttr<PgAttr<_sinclair_typebox.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
     /**
      *
-     * @param options
+     * @alias bigIdentityPrimaryKey
+     */
+    readonly primaryKey: (identity?: PgIdentityOptions, options?: NumberOptions) => PgAttr<PgAttr<PgAttr<_sinclair_typebox.TNumber, typeof PG_PRIMARY_KEY>, typeof PG_IDENTITY>, typeof PG_DEFAULT>;
+    /**
+     * 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.
      */
     readonly version: (options?: IntegerOptions) => PgAttr<PgAttr<_sinclair_typebox.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
     /**
-     *
-     * @param options
+     * Creates a column Created At. So just a datetime column with a default value of the current timestamp.
      */
     readonly createdAt: (options?: StringOptions) => PgAttr<PgAttr<_sinclair_typebox.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
     /**
-     *
-     * @param options
+     * Creates a column Updated At. Like createdAt, but it is updated on every update of the row.
      */
     readonly updatedAt: (options?: StringOptions) => PgAttr<PgAttr<_sinclair_typebox.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
     /**
-     *
-     * @param properties
-     * @param options
+     * @deprecated Build your own entity schema.
      */
     readonly entity: <T extends TProperties>(properties: T, options?: ObjectOptions) => TEntity<T>;
     /**
-     *
-     * @param obj
+     * Creates an insert schema for a given object schema.
+     * - pg.default will be optional
      */
     readonly insert: <T extends TObject>(obj: T) => TInsertObject<T>;
     /**
@@ -1413,25 +4543,27 @@ declare class PostgresTypeProvider {
      */
     readonly input: <T extends TObject>(obj: T) => TInsertObject<T>;
     /**
-     *
-     * @param resource
-     * @param options
+     * Creates a page schema for a given object schema.
      */
     readonly page: <T extends TObject>(resource: T, options?: ObjectOptions) => TPage<T>;
     /**
-     *
-     * @param type
-     * @param ref
-     * @param actions
+     * Creates a reference to another table or schema.
      */
     readonly ref: <T extends TSchema>(type: T, ref: () => any, actions?: {
         onUpdate?: UpdateDeleteAction$1;
         onDelete?: UpdateDeleteAction$1;
     }) => PgAttr<T, PgRef>;
     /**
+     * @alias ref
+     */
+    references: <T extends TSchema>(type: T, ref: () => any, actions?: {
+        onUpdate?: UpdateDeleteAction$1;
+        onDelete?: UpdateDeleteAction$1;
+    }) => PgAttr<T, PgRef>;
+    /**
+     * Creates a reference to another table or schema with a foreign key.
      *
-     * @param table
-     * @param foreignKey
+     * @experimental
      */
     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>;
 }
@@ -1440,7 +4572,7 @@ declare const pg: PostgresTypeProvider;
 /**
  * Postgres schema type.
  */
-declare const schema: <TDocument extends TSchema>(name: string, document: TDocument) => drizzleOrm.$Type<drizzle_orm_pg_core.PgCustomColumnBuilder<{
+declare const schema: <TDocument extends TSchema>(name: string, document: TDocument) => drizzle_orm.$Type<drizzle_orm_pg_core.PgCustomColumnBuilder<{
     name: string;
     dataType: "custom";
     columnType: "PgCustomColumn";
@@ -1453,176 +4585,6 @@ declare const schema: <TDocument extends TSchema>(name: string, document: TDocum
     params: [];
 })["static"]>;
 
-declare const dzl: {
-    pg: typeof drizzle_orm_pg_core;
-    aliasedTable<T extends drizzleOrm.Table | drizzleOrm.View>(table: T, tableAlias: string): T;
-    aliasedRelation<T extends drizzleOrm.Relation>(relation: T, tableAlias: string): T;
-    aliasedTableColumn<T extends drizzleOrm.AnyColumn>(column: T, tableAlias: string): T;
-    mapColumnsInAliasedSQLToAlias(query: drizzleOrm.SQL.Aliased, alias: string): drizzleOrm.SQL.Aliased;
-    mapColumnsInSQLToAlias(query: drizzleOrm.SQL, alias: string): drizzleOrm.SQL;
-    ColumnAliasProxyHandler: typeof drizzleOrm.ColumnAliasProxyHandler;
-    TableAliasProxyHandler: typeof drizzleOrm.TableAliasProxyHandler;
-    RelationTableAliasProxyHandler: typeof drizzleOrm.RelationTableAliasProxyHandler;
-    ColumnBuilder: typeof drizzleOrm.ColumnBuilder;
-    Column: typeof drizzleOrm.Column;
-    is<T extends drizzleOrm.DrizzleEntityClass<any>>(value: any, type: T): value is InstanceType<T>;
-    entityKind: typeof drizzleOrm.entityKind;
-    hasOwnEntityKind: typeof drizzleOrm.hasOwnEntityKind;
-    DrizzleError: typeof drizzleOrm.DrizzleError;
-    TransactionRollbackError: typeof drizzleOrm.TransactionRollbackError;
-    ConsoleLogWriter: typeof drizzleOrm.ConsoleLogWriter;
-    DefaultLogger: typeof drizzleOrm.DefaultLogger;
-    NoopLogger: typeof drizzleOrm.NoopLogger;
-    QueryPromise: typeof drizzleOrm.QueryPromise;
-    getOperators(): {
-        and: typeof drizzleOrm.and;
-        between: typeof drizzleOrm.between;
-        eq: drizzleOrm.BinaryOperator;
-        exists: typeof drizzleOrm.exists;
-        gt: drizzleOrm.BinaryOperator;
-        gte: drizzleOrm.BinaryOperator;
-        ilike: typeof drizzleOrm.ilike;
-        inArray: typeof drizzleOrm.inArray;
-        isNull: typeof drizzleOrm.isNull;
-        isNotNull: typeof drizzleOrm.isNotNull;
-        like: typeof drizzleOrm.like;
-        lt: drizzleOrm.BinaryOperator;
-        lte: drizzleOrm.BinaryOperator;
-        ne: drizzleOrm.BinaryOperator;
-        not: typeof drizzleOrm.not;
-        notBetween: typeof drizzleOrm.notBetween;
-        notExists: typeof drizzleOrm.notExists;
-        notLike: typeof drizzleOrm.notLike;
-        notIlike: typeof drizzleOrm.notIlike;
-        notInArray: typeof drizzleOrm.notInArray;
-        or: typeof drizzleOrm.or;
-        sql: typeof drizzleOrm.sql;
-    };
-    getOrderByOperators(): {
-        sql: typeof drizzleOrm.sql;
-        asc: typeof drizzleOrm.asc;
-        desc: typeof drizzleOrm.desc;
-    };
-    extractTablesRelationalConfig<TTables extends drizzleOrm.TablesRelationalConfig>(schema: Record<string, unknown>, configHelpers: (table: drizzleOrm.Table) => any): {
-        tables: TTables;
-        tableNamesMap: Record<string, string>;
-    };
-    relations<TTableName extends string, TRelations extends Record<string, drizzleOrm.Relation<any>>>(table: drizzleOrm.AnyTable<{
-        name: TTableName;
-    }>, relations: (helpers: drizzleOrm.TableRelationsHelpers<TTableName>) => TRelations): drizzleOrm.Relations<TTableName, TRelations>;
-    createOne<TTableName extends string>(sourceTable: drizzleOrm.Table): <TForeignTable extends drizzleOrm.Table, TColumns extends [drizzleOrm.AnyColumn<{
-        tableName: TTableName;
-    }>, ...drizzleOrm.AnyColumn<{
-        tableName: TTableName;
-    }>[]]>(table: TForeignTable, config?: drizzleOrm.RelationConfig<TTableName, TForeignTable["_"]["name"], TColumns>) => drizzleOrm.One<TForeignTable["_"]["name"], drizzleOrm.Equal<TColumns[number]["_"]["notNull"], true>>;
-    createMany(sourceTable: drizzleOrm.Table): <TForeignTable extends drizzleOrm.Table>(referencedTable: TForeignTable, config?: {
-        relationName: string;
-    }) => drizzleOrm.Many<TForeignTable["_"]["name"]>;
-    normalizeRelation(schema: drizzleOrm.TablesRelationalConfig, tableNamesMap: Record<string, string>, relation: drizzleOrm.Relation): drizzleOrm.NormalizedRelation;
-    createTableRelationsHelpers<TTableName extends string>(sourceTable: drizzleOrm.AnyTable<{
-        name: TTableName;
-    }>): {
-        one: <TForeignTable extends drizzleOrm.Table, TColumns extends [drizzleOrm.AnyColumn<{
-            tableName: TTableName;
-        }>, ...drizzleOrm.AnyColumn<{
-            tableName: TTableName;
-        }>[]]>(table: TForeignTable, config?: drizzleOrm.RelationConfig<TTableName, TForeignTable["_"]["name"], TColumns> | undefined) => drizzleOrm.One<TForeignTable["_"]["name"], drizzleOrm.Equal<TColumns[number]["_"]["notNull"], true>>;
-        many: <TForeignTable extends drizzleOrm.Table>(referencedTable: TForeignTable, config?: {
-            relationName: string;
-        }) => drizzleOrm.Many<TForeignTable["_"]["name"]>;
-    };
-    mapRelationalRow(tablesConfig: drizzleOrm.TablesRelationalConfig, tableConfig: drizzleOrm.TableRelationalConfig, row: unknown[], buildQueryResultSelection: drizzleOrm.BuildRelationalQueryResult["selection"], mapColumnValue?: (value: unknown) => unknown): Record<string, unknown>;
-    Relation: typeof drizzleOrm.Relation;
-    Relations: typeof drizzleOrm.Relations;
-    One: typeof drizzleOrm.One;
-    Many: typeof drizzleOrm.Many;
-    bindIfParam(value: unknown, column: drizzleOrm.SQLWrapper): drizzleOrm.SQLChunk;
-    and(...conditions: (drizzleOrm.SQLWrapper | undefined)[]): drizzleOrm.SQL | undefined;
-    or(...conditions: (drizzleOrm.SQLWrapper | undefined)[]): drizzleOrm.SQL | undefined;
-    not(condition: drizzleOrm.SQLWrapper): drizzleOrm.SQL;
-    inArray<T>(column: drizzleOrm.SQL.Aliased<T>, values: (T | drizzleOrm.Placeholder)[] | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
-    inArray<TColumn extends drizzleOrm.Column>(column: TColumn, values: ReadonlyArray<drizzleOrm.GetColumnData<TColumn, "raw"> | drizzleOrm.Placeholder> | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
-    inArray<T extends drizzleOrm.SQLWrapper>(column: Exclude<T, drizzleOrm.SQL.Aliased | drizzleOrm.Column>, values: ReadonlyArray<unknown | drizzleOrm.Placeholder> | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
-    notInArray<T>(column: drizzleOrm.SQL.Aliased<T>, values: (T | drizzleOrm.Placeholder)[] | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
-    notInArray<TColumn extends drizzleOrm.Column>(column: TColumn, values: (drizzleOrm.GetColumnData<TColumn, "raw"> | drizzleOrm.Placeholder)[] | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
-    notInArray<T extends drizzleOrm.SQLWrapper>(column: Exclude<T, drizzleOrm.SQL.Aliased | drizzleOrm.Column>, values: (unknown | drizzleOrm.Placeholder)[] | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
-    isNull(value: drizzleOrm.SQLWrapper): drizzleOrm.SQL;
-    isNotNull(value: drizzleOrm.SQLWrapper): drizzleOrm.SQL;
-    exists(subquery: drizzleOrm.SQLWrapper): drizzleOrm.SQL;
-    notExists(subquery: drizzleOrm.SQLWrapper): drizzleOrm.SQL;
-    between<T>(column: drizzleOrm.SQL.Aliased, min: T | drizzleOrm.SQLWrapper, max: T | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
-    between<TColumn extends drizzleOrm.AnyColumn>(column: TColumn, min: drizzleOrm.GetColumnData<TColumn, "raw"> | drizzleOrm.SQLWrapper, max: drizzleOrm.GetColumnData<TColumn, "raw"> | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
-    between<T extends drizzleOrm.SQLWrapper>(column: Exclude<T, drizzleOrm.SQL.Aliased | drizzleOrm.Column>, min: unknown, max: unknown): drizzleOrm.SQL;
-    notBetween<T>(column: drizzleOrm.SQL.Aliased, min: T | drizzleOrm.SQLWrapper, max: T | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
-    notBetween<TColumn extends drizzleOrm.AnyColumn>(column: TColumn, min: drizzleOrm.GetColumnData<TColumn, "raw"> | drizzleOrm.SQLWrapper, max: drizzleOrm.GetColumnData<TColumn, "raw"> | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
-    notBetween<T extends drizzleOrm.SQLWrapper>(column: Exclude<T, drizzleOrm.SQL.Aliased | drizzleOrm.Column>, min: unknown, max: unknown): drizzleOrm.SQL;
-    like(column: drizzleOrm.Column | drizzleOrm.SQL.Aliased | drizzleOrm.SQL, value: string | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
-    notLike(column: drizzleOrm.Column | drizzleOrm.SQL.Aliased | drizzleOrm.SQL, value: string | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
-    ilike(column: drizzleOrm.Column | drizzleOrm.SQL.Aliased | drizzleOrm.SQL, value: string | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
-    notIlike(column: drizzleOrm.Column | drizzleOrm.SQL.Aliased | drizzleOrm.SQL, value: string | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
-    arrayContains<T>(column: drizzleOrm.SQL.Aliased<T>, values: (T | drizzleOrm.Placeholder) | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
-    arrayContains<TColumn extends drizzleOrm.Column>(column: TColumn, values: (drizzleOrm.GetColumnData<TColumn, "raw"> | drizzleOrm.Placeholder) | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
-    arrayContains<T extends drizzleOrm.SQLWrapper>(column: Exclude<T, drizzleOrm.SQL.Aliased | drizzleOrm.Column>, values: (unknown | drizzleOrm.Placeholder)[] | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
-    arrayContained<T>(column: drizzleOrm.SQL.Aliased<T>, values: (T | drizzleOrm.Placeholder) | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
-    arrayContained<TColumn extends drizzleOrm.Column>(column: TColumn, values: (drizzleOrm.GetColumnData<TColumn, "raw"> | drizzleOrm.Placeholder) | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
-    arrayContained<T extends drizzleOrm.SQLWrapper>(column: Exclude<T, drizzleOrm.SQL.Aliased | drizzleOrm.Column>, values: (unknown | drizzleOrm.Placeholder)[] | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
-    arrayOverlaps<T>(column: drizzleOrm.SQL.Aliased<T>, values: (T | drizzleOrm.Placeholder) | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
-    arrayOverlaps<TColumn extends drizzleOrm.Column>(column: TColumn, values: (drizzleOrm.GetColumnData<TColumn, "raw"> | drizzleOrm.Placeholder) | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
-    arrayOverlaps<T extends drizzleOrm.SQLWrapper>(column: Exclude<T, drizzleOrm.SQL.Aliased | drizzleOrm.Column>, values: (unknown | drizzleOrm.Placeholder)[] | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
-    eq: drizzleOrm.BinaryOperator;
-    ne: drizzleOrm.BinaryOperator;
-    gt: drizzleOrm.BinaryOperator;
-    gte: drizzleOrm.BinaryOperator;
-    lt: drizzleOrm.BinaryOperator;
-    lte: drizzleOrm.BinaryOperator;
-    asc(column: drizzleOrm.AnyColumn | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
-    desc(column: drizzleOrm.AnyColumn | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
-    count(expression?: drizzleOrm.SQLWrapper): drizzleOrm.SQL<number>;
-    countDistinct(expression: drizzleOrm.SQLWrapper): drizzleOrm.SQL<number>;
-    avg(expression: drizzleOrm.SQLWrapper): drizzleOrm.SQL<string | null>;
-    avgDistinct(expression: drizzleOrm.SQLWrapper): drizzleOrm.SQL<string | null>;
-    sum(expression: drizzleOrm.SQLWrapper): drizzleOrm.SQL<string | null>;
-    sumDistinct(expression: drizzleOrm.SQLWrapper): drizzleOrm.SQL<string | null>;
-    max<T extends drizzleOrm.SQLWrapper>(expression: T): drizzleOrm.SQL<(T extends drizzleOrm.AnyColumn ? T["_"]["data"] : string) | null>;
-    min<T extends drizzleOrm.SQLWrapper>(expression: T): drizzleOrm.SQL<(T extends drizzleOrm.AnyColumn ? T["_"]["data"] : string) | null>;
-    l2Distance(column: drizzleOrm.SQLWrapper | drizzleOrm.AnyColumn, value: number[] | string[] | drizzle_orm_query_builders_query_builder.TypedQueryBuilder<any> | string): drizzleOrm.SQL;
-    l1Distance(column: drizzleOrm.SQLWrapper | drizzleOrm.AnyColumn, value: number[] | string[] | drizzle_orm_query_builders_query_builder.TypedQueryBuilder<any> | string): drizzleOrm.SQL;
-    innerProduct(column: drizzleOrm.SQLWrapper | drizzleOrm.AnyColumn, value: number[] | string[] | drizzle_orm_query_builders_query_builder.TypedQueryBuilder<any> | string): drizzleOrm.SQL;
-    cosineDistance(column: drizzleOrm.SQLWrapper | drizzleOrm.AnyColumn, value: number[] | string[] | drizzle_orm_query_builders_query_builder.TypedQueryBuilder<any> | string): drizzleOrm.SQL;
-    hammingDistance(column: drizzleOrm.SQLWrapper | drizzleOrm.AnyColumn, value: number[] | string[] | drizzle_orm_query_builders_query_builder.TypedQueryBuilder<any> | string): drizzleOrm.SQL;
-    jaccardDistance(column: drizzleOrm.SQLWrapper | drizzleOrm.AnyColumn, value: number[] | string[] | drizzle_orm_query_builders_query_builder.TypedQueryBuilder<any> | string): drizzleOrm.SQL;
-    isSQLWrapper(value: unknown): value is drizzleOrm.SQLWrapper;
-    name(value: string): drizzleOrm.Name;
-    isDriverValueEncoder(value: unknown): value is drizzleOrm.DriverValueEncoder<any, any>;
-    param<TData, TDriver>(value: TData, encoder?: drizzleOrm.DriverValueEncoder<TData, TDriver>): drizzleOrm.Param<TData, TDriver>;
-    sql: typeof drizzleOrm.sql;
-    placeholder<TName extends string>(name: TName): drizzleOrm.Placeholder<TName>;
-    fillPlaceholders(params: unknown[], values: Record<string, unknown>): unknown[];
-    isView(view: unknown): view is drizzleOrm.View;
-    getViewName<T extends drizzleOrm.View>(view: T): T["_"]["name"];
-    FakePrimitiveParam: typeof drizzleOrm.FakePrimitiveParam;
-    StringChunk: typeof drizzleOrm.StringChunk;
-    SQL: typeof drizzleOrm.SQL;
-    Name: typeof drizzleOrm.Name;
-    noopDecoder: drizzleOrm.DriverValueDecoder<any, any>;
-    noopEncoder: drizzleOrm.DriverValueEncoder<any, any>;
-    noopMapper: drizzleOrm.DriverValueMapper<any, any>;
-    Param: typeof drizzleOrm.Param;
-    Placeholder: typeof drizzleOrm.Placeholder;
-    View: typeof drizzleOrm.View;
-    Subquery: typeof drizzleOrm.Subquery;
-    WithSubquery: typeof drizzleOrm.WithSubquery;
-    isTable(table: unknown): table is drizzleOrm.Table;
-    getTableName<T extends drizzleOrm.Table>(table: T): T["_"]["name"];
-    getTableUniqueName<T extends drizzleOrm.Table>(table: T): `${T["_"]["schema"]}.${T["_"]["name"]}`;
-    Table: typeof drizzleOrm.Table;
-    haveSameKeys(left: Record<string, unknown>, right: Record<string, unknown>): boolean;
-    getTableColumns<T extends drizzleOrm.Table>(table: T): T["_"]["columns"];
-    getViewSelectedFields<T extends drizzleOrm.View>(view: T): T["_"]["selectedFields"];
-    isConfig(data: any): boolean;
-    ViewBaseConfig: typeof drizzleOrm.ViewBaseConfig;
-};
-
 declare const envSchema: _alepha_core.TObject<{
     POSTGRES_PROVIDER: _sinclair_typebox.TOptional<_sinclair_typebox.TUnsafe<"pg">>;
 }>;
@@ -1639,4 +4601,4 @@ declare class PostgresModule {
     protected getDefaultProviderName(): "pg";
 }
 
-export { $entity, $repository, $sequence, $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, dzl, entityKeys, entitySchema, fromSchema, nullToUndefined, pageQuerySchema, pageSchema, pg, pgTableSchema, schema, schemaToColumns };
+export { $entity, $repository, $sequence, $transaction, type BaseEntity, type BaseEntityKeys, DrizzleKitProvider, type Entity, 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 TInsertObject, type TPage, type TransactionContext, type TransactionDescriptorOptions, entityKeys, entitySchema, nullToUndefined, pageQuerySchema, pageSchema, pg, pgTableSchema, schema, schemaToColumns };