alepha 0.20.3 → 0.20.4

package/dist/orm/core/index.d.ts

@@ -1,5 +1,5 @@
 import * as _$alepha from "alepha";
-import { Alepha, AlephaError, KIND, Middleware, Page, Page as Page$1, PageQuery, PageQuery as PageQuery$1, Primitive, Service, Static, StaticEncode, TBigInt, TInteger, TNull, TNumber, TNumberOptions, TObject, TObjectOptions, TOptional, TPage, TSchema, TString, TStringOptions, TUnion, pageQuerySchema, pageSchema } from "alepha";
+import { Alepha, AlephaError, KIND, Middleware, Page, Page as Page$1, PageQuery, PageQuery as PageQuery$1, Primitive, SchemaValidator, Service, Static, StaticEncode, TBigInt, TInteger, TNull, TNumber, TNumberOptions, TObject, TObjectOptions, TOptional, TPage, TSchema, TString, TStringOptions, TUnion, pageQuerySchema, pageSchema } from "alepha";
 import { DateTime, DateTimeProvider } from "alepha/datetime";
 import * as _$alepha_logger0 from "alepha/logger";
 import * as _$drizzle_orm0 from "drizzle-orm";
@@ -11,7 +11,10 @@ import { SQLiteColumnBuilderBase } from "drizzle-orm/sqlite-core";
 import { DatabaseSync } from "node:sqlite";
 import * as _$typebox from "typebox";
 import { PgTransactionConfig } from "drizzle-orm/pg-core/session";
-import * as DrizzleKit from "drizzle-kit/api";
+import { LibSQLDatabase } from "drizzle-orm/libsql";
+import { MySql2Database } from "drizzle-orm/mysql2";
+import { SingleStoreDriverDatabase } from "drizzle-orm/singlestore";
+import { ConnectionOptions } from "tls";
 import { UpdateDeleteAction as UpdateDeleteAction$1 } from "drizzle-orm/pg-core/foreign-keys";
 import { DrizzleD1Database } from "drizzle-orm/d1";
 import { Database } from "bun:sqlite";
@@ -378,6 +381,4870 @@ declare abstract class ModelBuilder {
   protected buildTableConfig<TConfig, TSelf>(entity: EntityPrimitive, builders: TableConfigBuilders<TConfig>, tableResolver?: (entityName: string) => any, customConfigHandler?: (config: any, self: TSelf) => TConfig[]): ((self: TSelf) => TConfig[]) | undefined;
 }
 //#endregion
+//#region ../../../../node_modules/@electric-sql/pglite/dist/pglite-BZlQ7pL-.d.ts
+type MessageName = 'parseComplete' | 'bindComplete' | 'closeComplete' | 'noData' | 'portalSuspended' | 'replicationStart' | 'emptyQuery' | 'copyDone' | 'copyData' | 'rowDescription' | 'parameterDescription' | 'parameterStatus' | 'backendKeyData' | 'notification' | 'readyForQuery' | 'commandComplete' | 'dataRow' | 'copyInResponse' | 'copyOutResponse' | 'authenticationOk' | 'authenticationMD5Password' | 'authenticationCleartextPassword' | 'authenticationSASL' | 'authenticationSASLContinue' | 'authenticationSASLFinal' | 'error' | 'notice';
+type BackendMessage = {
+  name: MessageName;
+  length: number;
+};
+interface NoticeOrError {
+  message: string | undefined;
+  severity: string | undefined;
+  code: string | undefined;
+  detail: string | undefined;
+  hint: string | undefined;
+  position: string | undefined;
+  internalPosition: string | undefined;
+  internalQuery: string | undefined;
+  where: string | undefined;
+  schema: string | undefined;
+  table: string | undefined;
+  column: string | undefined;
+  dataType: string | undefined;
+  constraint: string | undefined;
+  file: string | undefined;
+  line: string | undefined;
+  routine: string | undefined;
+}
+declare class NoticeMessage implements BackendMessage, NoticeOrError {
+  readonly length: number;
+  readonly message: string | undefined;
+  constructor(length: number, message: string | undefined);
+  readonly name = "notice";
+  severity: string | undefined;
+  code: string | undefined;
+  detail: string | undefined;
+  hint: string | undefined;
+  position: string | undefined;
+  internalPosition: string | undefined;
+  internalQuery: string | undefined;
+  where: string | undefined;
+  schema: string | undefined;
+  table: string | undefined;
+  column: string | undefined;
+  dataType: string | undefined;
+  constraint: string | undefined;
+  file: string | undefined;
+  line: string | undefined;
+  routine: string | undefined;
+}
+type IDBFS = Emscripten.FileSystemType & {
+  quit: () => void;
+  dbs: Record<string, IDBDatabase>;
+};
+type FS = typeof FS & {
+  filesystems: {
+    MEMFS: Emscripten.FileSystemType;
+    NODEFS: Emscripten.FileSystemType;
+    IDBFS: IDBFS;
+  };
+  quit: () => void;
+};
+interface PostgresMod extends Omit<EmscriptenModule, 'preInit' | 'preRun' | 'postRun'> {
+  preInit: Array<{
+    (mod: PostgresMod): void;
+  }>;
+  preRun: Array<{
+    (mod: PostgresMod): void;
+  }>;
+  postRun: Array<{
+    (mod: PostgresMod): void;
+  }>;
+  thisProgram: string;
+  stdin: (() => number | null) | null;
+  FS: FS;
+  wasmMemory: WebAssembly.Memory;
+  PROXYFS: Emscripten.FileSystemType;
+  WASM_PREFIX: string;
+  pg_extensions: Record<string, Promise<Blob | null>>;
+  UTF8ToString: (ptr: number, maxBytesToRead?: number) => string;
+  stringToUTF8OnStack: (s: string) => number;
+  _pgl_set_system_fn: (system_fn: number) => void;
+  _pgl_set_popen_fn: (popen_fn: number) => void;
+  _pgl_set_pclose_fn: (pclose_fn: number) => void;
+  _pgl_set_rw_cbs: (read_cb: number, write_cb: number) => void;
+  _pgl_set_pipe_fn: (pipe_fn: number) => number;
+  _pgl_freopen: (filepath: number, mode: number, stream: number) => number;
+  _pgl_pq_flush: () => void;
+  _fopen: (path: number, mode: number) => number;
+  _fclose: (stream: number) => number;
+  _fflush: (stream: number) => void;
+  _pgl_proc_exit: (code: number) => number;
+  addFunction: (cb: (ptr: any, length: number) => void, signature: string) => number;
+  removeFunction: (f: number) => void;
+  callMain: (args?: string[]) => number;
+  _PostgresMainLoopOnce: () => void;
+  _PostgresMainLongJmp: () => void;
+  _PostgresSendReadyForQueryIfNecessary: () => void;
+  _ProcessStartupPacket: (Port: number, ssl_done: boolean, gss_done: boolean) => number;
+  _IsTransactionBlock: () => number;
+  _pgl_setPGliteActive: (newValue: number) => number;
+  _pgl_startPGlite: () => void;
+  _pgl_getMyProcPort: () => number;
+  _pgl_sendConnData: () => void;
+  ENV: any;
+  _emscripten_force_exit: (status: number) => void;
+  _pgl_run_atexit_funcs: () => void;
+  _pq_buffer_remaining_data: () => number;
+}
+type DumpTarCompressionOptions = 'none' | 'gzip' | 'auto';
+/**
+ * Filesystem interface.
+ * All virtual filesystems that are compatible with PGlite must implement
+ * this interface.
+ */
+interface Filesystem {
+  /**
+   * Initiate the filesystem and return the options to pass to the emscripten module.
+   */
+  init(pg: PGlite, emscriptenOptions: Partial<PostgresMod>): Promise<{
+    emscriptenOpts: Partial<PostgresMod>;
+  }>;
+  /**
+   * Sync the filesystem to any underlying storage.
+   */
+  syncToFs(relaxedDurability?: boolean): Promise<void>;
+  /**
+   * Sync the filesystem from any underlying storage.
+   */
+  initialSyncFs(): Promise<void>;
+  /**
+   * Dump the PGDATA dir from the filesystem to a gzipped tarball.
+   */
+  dumpTar(dbname: string, compression?: DumpTarCompressionOptions): Promise<File | Blob>;
+  /**
+   * Close the filesystem.
+   */
+  closeFs(): Promise<void>;
+}
+/**
+ * Base class for all emscripten built-in filesystems.
+ */
+type DebugLevel = 0 | 1 | 2 | 3 | 4 | 5;
+type RowMode = 'array' | 'object';
+interface ParserOptions {
+  [pgType: number]: (value: string) => any;
+}
+interface SerializerOptions {
+  [pgType: number]: (value: any) => string;
+}
+interface QueryOptions {
+  rowMode?: RowMode;
+  parsers?: ParserOptions;
+  serializers?: SerializerOptions;
+  blob?: Blob | File;
+  onNotice?: (notice: NoticeMessage) => void;
+  paramTypes?: number[];
+}
+interface ExecProtocolOptions {
+  syncToFs?: boolean;
+  throwOnError?: boolean;
+  onNotice?: (notice: NoticeMessage) => void;
+}
+interface ExecProtocolOptionsStream {
+  syncToFs?: boolean;
+  onRawData: (data: Uint8Array) => void;
+}
+interface ExtensionSetupResult<TNamespace = any> {
+  emscriptenOpts?: any;
+  namespaceObj?: TNamespace;
+  bundlePath?: URL;
+  init?: () => Promise<void>;
+  close?: () => Promise<void>;
+}
+type ExtensionSetup<TNamespace = any> = (pg: PGliteInterface, emscriptenOpts: any, clientOnly?: boolean) => Promise<ExtensionSetupResult<TNamespace>>;
+interface Extension<TNamespace = any> {
+  name: string;
+  setup: ExtensionSetup<TNamespace>;
+}
+type ExtensionNamespace<T> = T extends Extension<infer TNamespace> ? TNamespace : any;
+type Extensions = {
+  [namespace: string]: Extension | URL;
+};
+type InitializedExtensions<TExtensions extends Extensions = Extensions> = { [K in keyof TExtensions]: ExtensionNamespace<TExtensions[K]> };
+interface ExecProtocolResult {
+  messages: BackendMessage[];
+  data: Uint8Array;
+}
+interface PGliteOptions<TExtensions extends Extensions = Extensions> {
+  noInitDb?: boolean;
+  dataDir?: string;
+  username?: string;
+  database?: string;
+  fs?: Filesystem;
+  debug?: DebugLevel;
+  relaxedDurability?: boolean;
+  extensions?: TExtensions;
+  loadDataDir?: Blob | File;
+  initialMemory?: number;
+  pgliteWasmModule?: WebAssembly.Module;
+  initdbWasmModule?: WebAssembly.Module;
+  fsBundle?: Blob | File;
+  parsers?: ParserOptions;
+  serializers?: SerializerOptions;
+  startParams?: string[];
+}
+type PGliteInterface<T extends Extensions = Extensions> = InitializedExtensions<T> & {
+  readonly waitReady: Promise<void>;
+  readonly debug: DebugLevel;
+  readonly ready: boolean;
+  readonly closed: boolean;
+  close(): Promise<void>;
+  query<T>(query: string, params?: any[], options?: QueryOptions): Promise<Results<T>>;
+  sql<T>(sqlStrings: TemplateStringsArray, ...params: any[]): Promise<Results<T>>;
+  exec(query: string, options?: QueryOptions): Promise<Array<Results>>;
+  describeQuery(query: string): Promise<DescribeQueryResult>;
+  transaction<T>(callback: (tx: Transaction) => Promise<T>): Promise<T>;
+  execProtocolRaw(message: Uint8Array, options?: ExecProtocolOptions): Promise<Uint8Array>;
+  execProtocolRawStream(message: Uint8Array, options?: ExecProtocolOptionsStream): Promise<void>;
+  execProtocol(message: Uint8Array, options?: ExecProtocolOptions): Promise<ExecProtocolResult>;
+  runExclusive<T>(fn: () => Promise<T>): Promise<T>;
+  listen(channel: string, callback: (payload: string) => void, tx?: Transaction): Promise<(tx?: Transaction) => Promise<void>>;
+  unlisten(channel: string, callback?: (payload: string) => void, tx?: Transaction): Promise<void>;
+  onNotification(callback: (channel: string, payload: string) => void): () => void;
+  offNotification(callback: (channel: string, payload: string) => void): void;
+  dumpDataDir(compression?: DumpTarCompressionOptions): Promise<File | Blob>;
+  refreshArrayTypes(): Promise<void>;
+};
+type PGliteInterfaceExtensions<E> = E extends Extensions ? { [K in keyof E]: E[K] extends Extension ? Awaited<ReturnType<E[K]['setup']>>['namespaceObj'] extends infer N ? N extends undefined | null | void ? never : N : never : never } : Record<string, never>;
+type Row<T = {
+  [key: string]: any;
+}> = T;
+type Results<T = {
+  [key: string]: any;
+}> = {
+  rows: Row<T>[];
+  affectedRows?: number;
+  fields: {
+    name: string;
+    dataTypeID: number;
+  }[];
+  blob?: Blob;
+};
+interface Transaction {
+  query<T>(query: string, params?: any[], options?: QueryOptions): Promise<Results<T>>;
+  sql<T>(sqlStrings: TemplateStringsArray, ...params: any[]): Promise<Results<T>>;
+  exec(query: string, options?: QueryOptions): Promise<Array<Results>>;
+  rollback(): Promise<void>;
+  listen(channel: string, callback: (payload: string) => void): Promise<(tx?: Transaction) => Promise<void>>;
+  get closed(): boolean;
+}
+type DescribeQueryResult = {
+  queryParams: {
+    dataTypeID: number;
+    serializer: Serializer;
+  }[];
+  resultFields: {
+    name: string;
+    dataTypeID: number;
+    parser: Parser;
+  }[];
+};
+type Parser = (x: string, typeId?: number) => any;
+type Serializer = (x: any) => string;
+declare abstract class BasePGlite implements Pick<PGliteInterface, 'query' | 'sql' | 'exec' | 'transaction'> {
+  #private;
+  serializers: Record<number | string, Serializer>;
+  parsers: Record<number | string, Parser>;
+  abstract debug: DebugLevel;
+  /**
+   * Execute a postgres wire protocol message
+   * @param message The postgres wire protocol message to execute
+   * @returns The result of the query
+   */
+  abstract execProtocol(message: Uint8Array, {
+    syncToFs,
+    onNotice
+  }: ExecProtocolOptions): Promise<ExecProtocolResult>;
+  /**
+   * Execute a postgres wire protocol message
+   * @param message The postgres wire protocol message to execute
+   * @returns The parsed results of the query
+   */
+  abstract execProtocolStream(message: Uint8Array, {
+    syncToFs,
+    onNotice
+  }: ExecProtocolOptions): Promise<BackendMessage[]>;
+  /**
+   * Execute a postgres wire protocol message directly without wrapping the response.
+   * Only use if `execProtocol()` doesn't suite your needs.
+   *
+   * **Warning:** This bypasses PGlite's protocol wrappers that manage error/notice messages,
+   * transactions, and notification listeners. Only use if you need to bypass these wrappers and
+   * don't intend to use the above features.
+   *
+   * @param message The postgres wire protocol message to execute
+   * @returns The direct message data response produced by Postgres
+   */
+  abstract execProtocolRaw(message: Uint8Array, {
+    syncToFs
+  }: ExecProtocolOptions): Promise<Uint8Array>;
+  /**
+   * Execute a postgres wire protocol message directly without wrapping the response.
+   * Only use if `execProtocol()` doesn't suite your needs.
+   *
+   * **Warning:** This bypasses PGlite's protocol wrappers that manage error/notice messages,
+   * transactions, and notification listeners. Only use if you need to bypass these wrappers and
+   * don't intend to use the above features.
+   *
+   * @param message The postgres wire protocol message to execute
+   * @param options.onRawData Callback to receive streaming data
+   */
+  abstract execProtocolRawStream(message: Uint8Array, {
+    syncToFs,
+    onRawData
+  }: ExecProtocolOptionsStream): Promise<void>;
+  /**
+   * Sync the database to the filesystem
+   * @returns Promise that resolves when the database is synced to the filesystem
+   */
+  abstract syncToFs(): Promise<void>;
+  /**
+   * Handle a file attached to the current query
+   * @param file The file to handle
+   */
+  abstract _handleBlob(blob?: File | Blob): Promise<void>;
+  /**
+   * Get the written file
+   */
+  abstract _getWrittenBlob(): Promise<File | Blob | undefined>;
+  /**
+   * Cleanup the current file
+   */
+  abstract _cleanupBlob(): Promise<void>;
+  abstract _checkReady(): Promise<void>;
+  abstract _runExclusiveQuery<T>(fn: () => Promise<T>): Promise<T>;
+  abstract _runExclusiveTransaction<T>(fn: () => Promise<T>): Promise<T>;
+  /**
+   * Listen for notifications on a channel
+   */
+  abstract listen(channel: string, callback: (payload: string) => void, tx?: Transaction): Promise<(tx?: Transaction) => Promise<void>>;
+  /**
+   * Initialize the array types
+   * The oid if the type of an element and the typarray is the oid of the type of the
+   * array.
+   * We extract these from the database then create the serializers/parsers for
+   * each type.
+   * This should be called at the end of #init() in the implementing class.
+   */
+  _initArrayTypes({
+    force
+  }?: {
+    force?: boolean | undefined;
+  }): Promise<void>;
+  /**
+   * Re-syncs the array types from the database
+   * This is useful if you add a new type to the database and want to use it, otherwise pglite won't recognize it.
+   */
+  refreshArrayTypes(): Promise<void>;
+  /**
+   * Execute a single SQL statement
+   * This uses the "Extended Query" postgres wire protocol message.
+   * @param query The query to execute
+   * @param params Optional parameters for the query
+   * @returns The result of the query
+   */
+  query<T>(query: string, params?: any[], options?: QueryOptions): Promise<Results<T>>;
+  /**
+   * Execute a single SQL statement like with {@link PGlite.query}, but with a
+   * templated statement where template values will be treated as parameters.
+   *
+   * You can use helpers from `/template` to further format the query with
+   * identifiers, raw SQL, and nested statements.
+   *
+   * This uses the "Extended Query" postgres wire protocol message.
+   *
+   * @param query The query to execute with parameters as template values
+   * @returns The result of the query
+   *
+   * @example
+   * ```ts
+   * const results = await db.sql`SELECT * FROM ${identifier`foo`} WHERE id = ${id}`
+   * ```
+   */
+  sql<T>(sqlStrings: TemplateStringsArray, ...params: any[]): Promise<Results<T>>;
+  /**
+   * Execute a SQL query, this can have multiple statements.
+   * This uses the "Simple Query" postgres wire protocol message.
+   * @param query The query to execute
+   * @returns The result of the query
+   */
+  exec(query: string, options?: QueryOptions): Promise<Array<Results>>;
+  /**
+   * Describe a query
+   * @param query The query to describe
+   * @returns A description of the result types for the query
+   */
+  describeQuery(query: string, options?: QueryOptions): Promise<DescribeQueryResult>;
+  /**
+   * Execute a transaction
+   * @param callback A callback function that takes a transaction object
+   * @returns The result of the transaction
+   */
+  transaction<T>(callback: (tx: Transaction) => Promise<T>): Promise<T>;
+  /**
+   * Run a function exclusively, no other transactions or queries will be allowed
+   * while the function is running.
+   * This is useful when working with the execProtocol methods as they are not blocked,
+   * and do not block the locks used by transactions and queries.
+   * @param fn The function to run
+   * @returns The result of the function
+   */
+  runExclusive<T>(fn: () => Promise<T>): Promise<T>;
+}
+declare class PGlite extends BasePGlite implements PGliteInterface, AsyncDisposable {
+  #private;
+  fs?: Filesystem;
+  protected mod?: PostgresMod;
+  private readonly POSTGRES_MAIN_LONGJMP;
+  get ENV(): any;
+  readonly dataDir?: string;
+  readonly waitReady: Promise<void>;
+  readonly debug: DebugLevel;
+  static readonly DEFAULT_RECV_BUF_SIZE: number;
+  static readonly MAX_BUFFER_SIZE: number;
+  externalCommandStreamFd: number | null;
+  static readonly defaultStartParams: string[];
+  /**
+   * Create a new PGlite instance
+   * @param dataDir The directory to store the database files
+   *                Prefix with idb:// to use indexeddb filesystem in the browser
+   *                Use memory:// to use in-memory filesystem
+   * @param options PGlite options
+   */
+  constructor(dataDir?: string, options?: PGliteOptions);
+  /**
+   * Create a new PGlite instance
+   * @param options PGlite options including the data directory
+   */
+  constructor(options?: PGliteOptions);
+  /**
+   * Create a new PGlite instance with extensions on the Typescript interface
+   * (The main constructor does enable extensions, however due to the limitations
+   * of Typescript, the extensions are not available on the instance interface)
+   * @param options PGlite options including the data directory
+   * @returns A promise that resolves to the PGlite instance when it's ready.
+   */
+  static create<O extends PGliteOptions>(options?: O): Promise<PGlite & PGliteInterfaceExtensions<O['extensions']>>;
+  /**
+   * Create a new PGlite instance with extensions on the Typescript interface
+   * (The main constructor does enable extensions, however due to the limitations
+   * of Typescript, the extensions are not available on the instance interface)
+   * @param dataDir The directory to store the database files
+   *                Prefix with idb:// to use indexeddb filesystem in the browser
+   *                Use memory:// to use in-memory filesystem
+   * @param options PGlite options
+   * @returns A promise that resolves to the PGlite instance when it's ready.
+   */
+  static create<O extends PGliteOptions>(dataDir?: string, options?: O): Promise<PGlite & PGliteInterfaceExtensions<O['extensions']>>;
+  handleExternalCmd(cmd: string, mode: string): number;
+  /**
+   * The Postgres Emscripten Module
+   */
+  get Module(): PostgresMod;
+  /**
+   * The ready state of the database
+   */
+  get ready(): boolean;
+  /**
+   * The closed state of the database
+   */
+  get closed(): boolean;
+  /**
+   * Close the database
+   * @returns A promise that resolves when the database is closed
+   */
+  close(): Promise<void>;
+  /**
+   * Close the database when the object exits scope
+   * Stage 3 ECMAScript Explicit Resource Management
+   * https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-2.html#using-declarations-and-explicit-resource-management
+   */
+  [Symbol.asyncDispose](): Promise<void>;
+  /**
+   * Handle a file attached to the current query
+   * @param file The file to handle
+   */
+  _handleBlob(blob?: File | Blob): Promise<void>;
+  /**
+   * Cleanup the current file
+   */
+  _cleanupBlob(): Promise<void>;
+  /**
+   * Get the written blob from the current query
+   * @returns The written blob
+   */
+  _getWrittenBlob(): Promise<Blob | undefined>;
+  /**
+   * Wait for the database to be ready
+   */
+  _checkReady(): Promise<void>;
+  /**
+   * Execute a postgres wire protocol synchronously
+   * @param message The postgres wire protocol message to execute
+   * @returns The direct message data response produced by Postgres
+   */
+  execProtocolRawSync(message: Uint8Array): Uint8Array;
+  /**
+   * Execute a postgres wire protocol message directly without wrapping the response.
+   * Only use if `execProtocol()` doesn't suite your needs.
+   *
+   * **Warning:** This bypasses PGlite's protocol wrappers that manage error/notice messages,
+   * transactions, and notification listeners. Only use if you need to bypass these wrappers and
+   * don't intend to use the above features.
+   *
+   * @param message The postgres wire protocol message to execute
+   * @returns The direct message data response produced by Postgres
+   */
+  execProtocolRaw(message: Uint8Array, {
+    syncToFs
+  }?: ExecProtocolOptions): Promise<Uint8Array>;
+  /**
+   * Execute a postgres wire protocol message directly without wrapping the response.
+   * Only use if `execProtocol()` doesn't suite your needs.
+   *
+   * **Warning:** This bypasses PGlite's protocol wrappers that manage error/notice messages,
+   * transactions, and notification listeners. Only use if you need to bypass these wrappers and
+   * don't intend to use the above features.
+   *
+   * @param message The postgres wire protocol message to execute
+   * @param options.onRawData Callback to receive results as streaming data
+   */
+  execProtocolRawStream(message: Uint8Array, {
+    syncToFs,
+    onRawData
+  }: ExecProtocolOptionsStream): Promise<void>;
+  /**
+   * Execute a postgres wire protocol message
+   * @param message The postgres wire protocol message to execute
+   * @returns The result of the query
+   */
+  execProtocol(message: Uint8Array, {
+    syncToFs,
+    throwOnError,
+    onNotice
+  }?: ExecProtocolOptions): Promise<ExecProtocolResult>;
+  /**
+   * Execute a postgres wire protocol message
+   * @param message The postgres wire protocol message to execute
+   * @returns The parsed results of the query
+   */
+  execProtocolStream(message: Uint8Array, {
+    syncToFs,
+    throwOnError,
+    onNotice
+  }?: ExecProtocolOptions): Promise<BackendMessage[]>;
+  /**
+   * Check if the database is in a transaction
+   * @returns True if the database is in a transaction, false otherwise
+   */
+  isInTransaction(): boolean;
+  /**
+   * Perform any sync operations implemented by the filesystem, this is
+   * run after every query to ensure that the filesystem is synced.
+   */
+  syncToFs(): Promise<void>;
+  /**
+   * Listen for a notification
+   * @param channel The channel to listen on
+   * @param callback The callback to call when a notification is received
+   */
+  listen(channel: string, callback: (payload: string) => void, tx?: Transaction): Promise<(tx?: Transaction) => Promise<void>>;
+  /**
+   * Stop listening for a notification
+   * @param channel The channel to stop listening on
+   * @param callback The callback to remove
+   */
+  unlisten(channel: string, callback?: (payload: string) => void, tx?: Transaction): Promise<void>;
+  /**
+   * Listen to notifications
+   * @param callback The callback to call when a notification is received
+   */
+  onNotification(callback: (channel: string, payload: string) => void): () => void;
+  /**
+   * Stop listening to notifications
+   * @param callback The callback to remove
+   */
+  offNotification(callback: (channel: string, payload: string) => void): void;
+  /**
+   * Dump the PGDATA dir from the filesystem to a gzipped tarball.
+   * @param compression The compression options to use - 'gzip', 'auto', 'none'
+   * @returns The tarball as a File object where available, and fallback to a Blob
+   */
+  dumpDataDir(compression?: DumpTarCompressionOptions): Promise<File | Blob>;
+  /**
+   * Run a function in a mutex that's exclusive to queries
+   * @param fn The query to run
+   * @returns The result of the query
+   */
+  _runExclusiveQuery<T>(fn: () => Promise<T>): Promise<T>;
+  /**
+   * Run a function in a mutex that's exclusive to transactions
+   * @param fn The function to run
+   * @returns The result of the function
+   */
+  _runExclusiveTransaction<T>(fn: () => Promise<T>): Promise<T>;
+  clone(): Promise<PGliteInterface>;
+  _runExclusiveListen<T>(fn: () => Promise<T>): Promise<T>;
+  callMain(args: string[]): number;
+}
+//#endregion
+//#region ../../../../node_modules/zod/lib/helpers/typeAliases.d.ts
+declare type Primitive$1 = string | number | symbol | bigint | boolean | null | undefined;
+//#endregion
+//#region ../../../../node_modules/zod/lib/helpers/util.d.ts
+declare namespace util {
+  type AssertEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends (<V>() => V extends U ? 1 : 2) ? true : false;
+  export type isAny<T> = 0 extends 1 & T ? true : false;
+  export const assertEqual: <A, B>(val: AssertEqual<A, B>) => AssertEqual<A, B>;
+  export function assertIs<T>(_arg: T): void;
+  export function assertNever(_x: never): never;
+  export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+  export type OmitKeys<T, K extends string> = Pick<T, Exclude<keyof T, K>>;
+  export type MakePartial<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+  export const arrayToEnum: <T extends string, U extends [T, ...T[]]>(items: U) => { [k in U[number]]: k };
+  export const getValidEnumValues: (obj: any) => any[];
+  export const objectValues: (obj: any) => any[];
+  export const objectKeys: ObjectConstructor["keys"];
+  export const find: <T>(arr: T[], checker: (arg: T) => any) => T | undefined;
+  export type identity<T> = objectUtil.identity<T>;
+  export type flatten<T> = objectUtil.flatten<T>;
+  export type noUndefined<T> = T extends undefined ? never : T;
+  export const isInteger: NumberConstructor["isInteger"];
+  export function joinValues<T extends any[]>(array: T, separator?: string): string;
+  export const jsonStringifyReplacer: (_: string, value: any) => any;
+  export {};
+}
+declare namespace objectUtil {
+  export type MergeShapes<U, V> = { [k in Exclude<keyof U, keyof V>]: U[k] } & V;
+  type requiredKeys<T extends object> = { [k in keyof T]: undefined extends T[k] ? never : k }[keyof T];
+  export type addQuestionMarks<T extends object, R extends keyof T = requiredKeys<T>> = Pick<Required<T>, R> & Partial<T>;
+  export type identity<T> = T;
+  export type flatten<T> = identity<{ [k in keyof T]: T[k] }>;
+  export type noNeverKeys<T> = { [k in keyof T]: [T[k]] extends [never] ? never : k }[keyof T];
+  export type noNever<T> = identity<{ [k in noNeverKeys<T>]: k extends keyof T ? T[k] : never }>;
+  export const mergeShapes: <U, T>(first: U, second: T) => T & U;
+  export type extendShape<A, B> = flatten<Omit<A, keyof B> & B>;
+  export {};
+}
+declare const ZodParsedType: {
+  function: "function";
+  number: "number";
+  string: "string";
+  nan: "nan";
+  integer: "integer";
+  float: "float";
+  boolean: "boolean";
+  date: "date";
+  bigint: "bigint";
+  symbol: "symbol";
+  undefined: "undefined";
+  null: "null";
+  array: "array";
+  object: "object";
+  unknown: "unknown";
+  promise: "promise";
+  void: "void";
+  never: "never";
+  map: "map";
+  set: "set";
+};
+declare type ZodParsedType = keyof typeof ZodParsedType;
+//#endregion
+//#region ../../../../node_modules/zod/lib/ZodError.d.ts
+declare type allKeys<T> = T extends any ? keyof T : never;
+declare type typeToFlattenedError<T, U = string> = {
+  formErrors: U[];
+  fieldErrors: { [P in allKeys<T>]?: U[] };
+};
+declare const ZodIssueCode: {
+  invalid_type: "invalid_type";
+  invalid_literal: "invalid_literal";
+  custom: "custom";
+  invalid_union: "invalid_union";
+  invalid_union_discriminator: "invalid_union_discriminator";
+  invalid_enum_value: "invalid_enum_value";
+  unrecognized_keys: "unrecognized_keys";
+  invalid_arguments: "invalid_arguments";
+  invalid_return_type: "invalid_return_type";
+  invalid_date: "invalid_date";
+  invalid_string: "invalid_string";
+  too_small: "too_small";
+  too_big: "too_big";
+  invalid_intersection_types: "invalid_intersection_types";
+  not_multiple_of: "not_multiple_of";
+  not_finite: "not_finite";
+};
+declare type ZodIssueCode = keyof typeof ZodIssueCode;
+declare type ZodIssueBase = {
+  path: (string | number)[];
+  message?: string;
+};
+interface ZodInvalidTypeIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.invalid_type;
+  expected: ZodParsedType;
+  received: ZodParsedType;
+}
+interface ZodInvalidLiteralIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.invalid_literal;
+  expected: unknown;
+  received: unknown;
+}
+interface ZodUnrecognizedKeysIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.unrecognized_keys;
+  keys: string[];
+}
+interface ZodInvalidUnionIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.invalid_union;
+  unionErrors: ZodError[];
+}
+interface ZodInvalidUnionDiscriminatorIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.invalid_union_discriminator;
+  options: Primitive$1[];
+}
+interface ZodInvalidEnumValueIssue extends ZodIssueBase {
+  received: string | number;
+  code: typeof ZodIssueCode.invalid_enum_value;
+  options: (string | number)[];
+}
+interface ZodInvalidArgumentsIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.invalid_arguments;
+  argumentsError: ZodError;
+}
+interface ZodInvalidReturnTypeIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.invalid_return_type;
+  returnTypeError: ZodError;
+}
+interface ZodInvalidDateIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.invalid_date;
+}
+declare type StringValidation = "email" | "url" | "emoji" | "uuid" | "regex" | "cuid" | "cuid2" | "ulid" | "datetime" | "ip" | {
+  includes: string;
+  position?: number;
+} | {
+  startsWith: string;
+} | {
+  endsWith: string;
+};
+interface ZodInvalidStringIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.invalid_string;
+  validation: StringValidation;
+}
+interface ZodTooSmallIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.too_small;
+  minimum: number | bigint;
+  inclusive: boolean;
+  exact?: boolean;
+  type: "array" | "string" | "number" | "set" | "date" | "bigint";
+}
+interface ZodTooBigIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.too_big;
+  maximum: number | bigint;
+  inclusive: boolean;
+  exact?: boolean;
+  type: "array" | "string" | "number" | "set" | "date" | "bigint";
+}
+interface ZodInvalidIntersectionTypesIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.invalid_intersection_types;
+}
+interface ZodNotMultipleOfIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.not_multiple_of;
+  multipleOf: number | bigint;
+}
+interface ZodNotFiniteIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.not_finite;
+}
+interface ZodCustomIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.custom;
+  params?: {
+    [k: string]: any;
+  };
+}
+declare type ZodIssueOptionalMessage = ZodInvalidTypeIssue | ZodInvalidLiteralIssue | ZodUnrecognizedKeysIssue | ZodInvalidUnionIssue | ZodInvalidUnionDiscriminatorIssue | ZodInvalidEnumValueIssue | ZodInvalidArgumentsIssue | ZodInvalidReturnTypeIssue | ZodInvalidDateIssue | ZodInvalidStringIssue | ZodTooSmallIssue | ZodTooBigIssue | ZodInvalidIntersectionTypesIssue | ZodNotMultipleOfIssue | ZodNotFiniteIssue | ZodCustomIssue;
+declare type ZodIssue = ZodIssueOptionalMessage & {
+  fatal?: boolean;
+  message: string;
+};
+declare type recursiveZodFormattedError<T> = T extends [any, ...any[]] ? { [K in keyof T]?: ZodFormattedError<T[K]> } : T extends any[] ? {
+  [k: number]: ZodFormattedError<T[number]>;
+} : T extends object ? { [K in keyof T]?: ZodFormattedError<T[K]> } : unknown;
+declare type ZodFormattedError<T, U = string> = {
+  _errors: U[];
+} & recursiveZodFormattedError<NonNullable<T>>;
+declare class ZodError<T = any> extends Error {
+  issues: ZodIssue[];
+  get errors(): ZodIssue[];
+  constructor(issues: ZodIssue[]);
+  format(): ZodFormattedError<T>;
+  format<U>(mapper: (issue: ZodIssue) => U): ZodFormattedError<T, U>;
+  static create: (issues: ZodIssue[]) => ZodError<any>;
+  toString(): string;
+  get message(): string;
+  get isEmpty(): boolean;
+  addIssue: (sub: ZodIssue) => void;
+  addIssues: (subs?: ZodIssue[]) => void;
+  flatten(): typeToFlattenedError<T>;
+  flatten<U>(mapper?: (issue: ZodIssue) => U): typeToFlattenedError<T, U>;
+  get formErrors(): typeToFlattenedError<T, string>;
+}
+declare type stripPath<T extends object> = T extends any ? util.OmitKeys<T, "path"> : never;
+declare type IssueData = stripPath<ZodIssueOptionalMessage> & {
+  path?: (string | number)[];
+  fatal?: boolean;
+};
+declare type ErrorMapCtx = {
+  defaultError: string;
+  data: any;
+};
+declare type ZodErrorMap = (issue: ZodIssueOptionalMessage, _ctx: ErrorMapCtx) => {
+  message: string;
+};
+//#endregion
+//#region ../../../../node_modules/zod/lib/helpers/parseUtil.d.ts
+declare type ParseParams = {
+  path: (string | number)[];
+  errorMap: ZodErrorMap;
+  async: boolean;
+};
+declare type ParsePathComponent = string | number;
+declare type ParsePath = ParsePathComponent[];
+interface ParseContext {
+  readonly common: {
+    readonly issues: ZodIssue[];
+    readonly contextualErrorMap?: ZodErrorMap;
+    readonly async: boolean;
+  };
+  readonly path: ParsePath;
+  readonly schemaErrorMap?: ZodErrorMap;
+  readonly parent: ParseContext | null;
+  readonly data: any;
+  readonly parsedType: ZodParsedType;
+}
+declare type ParseInput = {
+  data: any;
+  path: (string | number)[];
+  parent: ParseContext;
+};
+declare class ParseStatus {
+  value: "aborted" | "dirty" | "valid";
+  dirty(): void;
+  abort(): void;
+  static mergeArray(status: ParseStatus, results: SyncParseReturnType<any>[]): SyncParseReturnType;
+  static mergeObjectAsync(status: ParseStatus, pairs: {
+    key: ParseReturnType<any>;
+    value: ParseReturnType<any>;
+  }[]): Promise<SyncParseReturnType<any>>;
+  static mergeObjectSync(status: ParseStatus, pairs: {
+    key: SyncParseReturnType<any>;
+    value: SyncParseReturnType<any>;
+    alwaysSet?: boolean;
+  }[]): SyncParseReturnType;
+}
+declare type INVALID = {
+  status: "aborted";
+};
+declare const INVALID: INVALID;
+declare type DIRTY<T> = {
+  status: "dirty";
+  value: T;
+};
+declare const DIRTY: <T>(value: T) => DIRTY<T>;
+declare type OK<T> = {
+  status: "valid";
+  value: T;
+};
+declare const OK: <T>(value: T) => OK<T>;
+declare type SyncParseReturnType<T = any> = OK<T> | DIRTY<T> | INVALID;
+declare type AsyncParseReturnType<T> = Promise<SyncParseReturnType<T>>;
+declare type ParseReturnType<T> = SyncParseReturnType<T> | AsyncParseReturnType<T>;
+//#endregion
+//#region ../../../../node_modules/zod/lib/helpers/enumUtil.d.ts
+declare namespace enumUtil {
+  type UnionToIntersectionFn<T> = (T extends unknown ? (k: () => T) => void : never) extends ((k: infer Intersection) => void) ? Intersection : never;
+  type GetUnionLast<T> = UnionToIntersectionFn<T> extends (() => infer Last) ? Last : never;
+  type UnionToTuple<T, Tuple extends unknown[] = []> = [T] extends [never] ? Tuple : UnionToTuple<Exclude<T, GetUnionLast<T>>, [GetUnionLast<T>, ...Tuple]>;
+  type CastToStringTuple<T> = T extends [string, ...string[]] ? T : never;
+  export type UnionToTupleString<T> = CastToStringTuple<UnionToTuple<T>>;
+  export {};
+}
+//#endregion
+//#region ../../../../node_modules/zod/lib/helpers/errorUtil.d.ts
+declare namespace errorUtil {
+  type ErrMessage = string | {
+    message?: string;
+  };
+  const errToObj: (message?: ErrMessage | undefined) => {
+    message?: string | undefined;
+  };
+  const toString: (message?: ErrMessage | undefined) => string | undefined;
+}
+//#endregion
+//#region ../../../../node_modules/zod/lib/helpers/partialUtil.d.ts
+declare namespace partialUtil {
+  type DeepPartial<T extends ZodTypeAny> = T extends ZodObject<ZodRawShape> ? ZodObject<{ [k in keyof T["shape"]]: ZodOptional<DeepPartial<T["shape"][k]>> }, T["_def"]["unknownKeys"], T["_def"]["catchall"]> : T extends ZodArray<infer Type, infer Card> ? ZodArray<DeepPartial<Type>, Card> : T extends ZodOptional<infer Type> ? ZodOptional<DeepPartial<Type>> : T extends ZodNullable<infer Type> ? ZodNullable<DeepPartial<Type>> : T extends ZodTuple<infer Items> ? { [k in keyof Items]: Items[k] extends ZodTypeAny ? DeepPartial<Items[k]> : never } extends infer PI ? PI extends ZodTupleItems ? ZodTuple<PI> : never : never : T;
+}
+//#endregion
+//#region ../../../../node_modules/zod/lib/types.d.ts
+declare type RefinementCtx = {
+  addIssue: (arg: IssueData) => void;
+  path: (string | number)[];
+};
+declare type ZodRawShape = {
+  [k: string]: ZodTypeAny;
+};
+declare type ZodTypeAny = ZodType<any, any, any>;
+declare type TypeOf<T extends ZodType<any, any, any>> = T["_output"];
+declare type input<T extends ZodType<any, any, any>> = T["_input"];
+declare type output<T extends ZodType<any, any, any>> = T["_output"];
+declare type CustomErrorParams = Partial<util.Omit<ZodCustomIssue, "code">>;
+interface ZodTypeDef {
+  errorMap?: ZodErrorMap;
+  description?: string;
+}
+declare type RawCreateParams = {
+  errorMap?: ZodErrorMap;
+  invalid_type_error?: string;
+  required_error?: string;
+  description?: string;
+} | undefined;
+declare type SafeParseSuccess<Output> = {
+  success: true;
+  data: Output;
+};
+declare type SafeParseError<Input> = {
+  success: false;
+  error: ZodError<Input>;
+};
+declare type SafeParseReturnType<Input, Output> = SafeParseSuccess<Output> | SafeParseError<Input>;
+declare abstract class ZodType<Output = any, Def extends ZodTypeDef = ZodTypeDef, Input = Output> {
+  readonly _type: Output;
+  readonly _output: Output;
+  readonly _input: Input;
+  readonly _def: Def;
+  get description(): string | undefined;
+  abstract _parse(input: ParseInput): ParseReturnType<Output>;
+  _getType(input: ParseInput): string;
+  _getOrReturnCtx(input: ParseInput, ctx?: ParseContext | undefined): ParseContext;
+  _processInputParams(input: ParseInput): {
+    status: ParseStatus;
+    ctx: ParseContext;
+  };
+  _parseSync(input: ParseInput): SyncParseReturnType<Output>;
+  _parseAsync(input: ParseInput): AsyncParseReturnType<Output>;
+  parse(data: unknown, params?: Partial<ParseParams>): Output;
+  safeParse(data: unknown, params?: Partial<ParseParams>): SafeParseReturnType<Input, Output>;
+  parseAsync(data: unknown, params?: Partial<ParseParams>): Promise<Output>;
+  safeParseAsync(data: unknown, params?: Partial<ParseParams>): Promise<SafeParseReturnType<Input, Output>>;
+  /** Alias of safeParseAsync */
+  spa: (data: unknown, params?: Partial<ParseParams> | undefined) => Promise<SafeParseReturnType<Input, Output>>;
+  refine<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, RefinedOutput, Input>;
+  refine(check: (arg: Output) => unknown | Promise<unknown>, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, Output, Input>;
+  refinement<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, refinementData: IssueData | ((arg: Output, ctx: RefinementCtx) => IssueData)): ZodEffects<this, RefinedOutput, Input>;
+  refinement(check: (arg: Output) => boolean, refinementData: IssueData | ((arg: Output, ctx: RefinementCtx) => IssueData)): ZodEffects<this, Output, Input>;
+  _refinement(refinement: RefinementEffect<Output>["refinement"]): ZodEffects<this, Output, Input>;
+  superRefine<RefinedOutput extends Output>(refinement: (arg: Output, ctx: RefinementCtx) => arg is RefinedOutput): ZodEffects<this, RefinedOutput, Input>;
+  superRefine(refinement: (arg: Output, ctx: RefinementCtx) => void): ZodEffects<this, Output, Input>;
+  superRefine(refinement: (arg: Output, ctx: RefinementCtx) => Promise<void>): ZodEffects<this, Output, Input>;
+  constructor(def: Def);
+  optional(): ZodOptional<this>;
+  nullable(): ZodNullable<this>;
+  nullish(): ZodOptional<ZodNullable<this>>;
+  array(): ZodArray<this>;
+  promise(): ZodPromise<this>;
+  or<T extends ZodTypeAny>(option: T): ZodUnion<[this, T]>;
+  and<T extends ZodTypeAny>(incoming: T): ZodIntersection<this, T>;
+  transform<NewOut>(transform: (arg: Output, ctx: RefinementCtx) => NewOut | Promise<NewOut>): ZodEffects<this, NewOut>;
+  default(def: util.noUndefined<Input>): ZodDefault<this>;
+  default(def: () => util.noUndefined<Input>): ZodDefault<this>;
+  brand<B extends string | number | symbol>(brand?: B): ZodBranded<this, B>;
+  catch(def: Output): ZodCatch<this>;
+  catch(def: (ctx: {
+    error: ZodError;
+    input: Input;
+  }) => Output): ZodCatch<this>;
+  describe(description: string): this;
+  pipe<T extends ZodTypeAny>(target: T): ZodPipeline<this, T>;
+  readonly(): ZodReadonly<this>;
+  isOptional(): boolean;
+  isNullable(): boolean;
+}
+declare type IpVersion = "v4" | "v6";
+declare type ZodStringCheck = {
+  kind: "min";
+  value: number;
+  message?: string;
+} | {
+  kind: "max";
+  value: number;
+  message?: string;
+} | {
+  kind: "length";
+  value: number;
+  message?: string;
+} | {
+  kind: "email";
+  message?: string;
+} | {
+  kind: "url";
+  message?: string;
+} | {
+  kind: "emoji";
+  message?: string;
+} | {
+  kind: "uuid";
+  message?: string;
+} | {
+  kind: "cuid";
+  message?: string;
+} | {
+  kind: "includes";
+  value: string;
+  position?: number;
+  message?: string;
+} | {
+  kind: "cuid2";
+  message?: string;
+} | {
+  kind: "ulid";
+  message?: string;
+} | {
+  kind: "startsWith";
+  value: string;
+  message?: string;
+} | {
+  kind: "endsWith";
+  value: string;
+  message?: string;
+} | {
+  kind: "regex";
+  regex: RegExp;
+  message?: string;
+} | {
+  kind: "trim";
+  message?: string;
+} | {
+  kind: "toLowerCase";
+  message?: string;
+} | {
+  kind: "toUpperCase";
+  message?: string;
+} | {
+  kind: "datetime";
+  offset: boolean;
+  precision: number | null;
+  message?: string;
+} | {
+  kind: "ip";
+  version?: IpVersion;
+  message?: string;
+};
+interface ZodStringDef extends ZodTypeDef {
+  checks: ZodStringCheck[];
+  typeName: ZodFirstPartyTypeKind.ZodString;
+  coerce: boolean;
+}
+declare class ZodString extends ZodType<string, ZodStringDef> {
+  _parse(input: ParseInput): ParseReturnType<string>;
+  protected _regex(regex: RegExp, validation: StringValidation, message?: errorUtil.ErrMessage): ZodEffects<this, string, string>;
+  _addCheck(check: ZodStringCheck): ZodString;
+  email(message?: errorUtil.ErrMessage): ZodString;
+  url(message?: errorUtil.ErrMessage): ZodString;
+  emoji(message?: errorUtil.ErrMessage): ZodString;
+  uuid(message?: errorUtil.ErrMessage): ZodString;
+  cuid(message?: errorUtil.ErrMessage): ZodString;
+  cuid2(message?: errorUtil.ErrMessage): ZodString;
+  ulid(message?: errorUtil.ErrMessage): ZodString;
+  ip(options?: string | {
+    version?: "v4" | "v6";
+    message?: string;
+  }): ZodString;
+  datetime(options?: string | {
+    message?: string | undefined;
+    precision?: number | null;
+    offset?: boolean;
+  }): ZodString;
+  regex(regex: RegExp, message?: errorUtil.ErrMessage): ZodString;
+  includes(value: string, options?: {
+    message?: string;
+    position?: number;
+  }): ZodString;
+  startsWith(value: string, message?: errorUtil.ErrMessage): ZodString;
+  endsWith(value: string, message?: errorUtil.ErrMessage): ZodString;
+  min(minLength: number, message?: errorUtil.ErrMessage): ZodString;
+  max(maxLength: number, message?: errorUtil.ErrMessage): ZodString;
+  length(len: number, message?: errorUtil.ErrMessage): ZodString;
+  /**
+   * @deprecated Use z.string().min(1) instead.
+   * @see {@link ZodString.min}
+   */
+  nonempty(message?: errorUtil.ErrMessage): ZodString;
+  trim(): ZodString;
+  toLowerCase(): ZodString;
+  toUpperCase(): ZodString;
+  get isDatetime(): boolean;
+  get isEmail(): boolean;
+  get isURL(): boolean;
+  get isEmoji(): boolean;
+  get isUUID(): boolean;
+  get isCUID(): boolean;
+  get isCUID2(): boolean;
+  get isULID(): boolean;
+  get isIP(): boolean;
+  get minLength(): number | null;
+  get maxLength(): number | null;
+  static create: (params?: ({
+    errorMap?: ZodErrorMap | undefined;
+    invalid_type_error?: string | undefined;
+    required_error?: string | undefined;
+    description?: string | undefined;
+  } & {
+    coerce?: true | undefined;
+  }) | undefined) => ZodString;
+}
+declare type ZodNumberCheck = {
+  kind: "min";
+  value: number;
+  inclusive: boolean;
+  message?: string;
+} | {
+  kind: "max";
+  value: number;
+  inclusive: boolean;
+  message?: string;
+} | {
+  kind: "int";
+  message?: string;
+} | {
+  kind: "multipleOf";
+  value: number;
+  message?: string;
+} | {
+  kind: "finite";
+  message?: string;
+};
+interface ZodNumberDef extends ZodTypeDef {
+  checks: ZodNumberCheck[];
+  typeName: ZodFirstPartyTypeKind.ZodNumber;
+  coerce: boolean;
+}
+declare class ZodNumber extends ZodType<number, ZodNumberDef> {
+  _parse(input: ParseInput): ParseReturnType<number>;
+  static create: (params?: ({
+    errorMap?: ZodErrorMap | undefined;
+    invalid_type_error?: string | undefined;
+    required_error?: string | undefined;
+    description?: string | undefined;
+  } & {
+    coerce?: boolean | undefined;
+  }) | undefined) => ZodNumber;
+  gte(value: number, message?: errorUtil.ErrMessage): ZodNumber;
+  min: (value: number, message?: errorUtil.ErrMessage | undefined) => ZodNumber;
+  gt(value: number, message?: errorUtil.ErrMessage): ZodNumber;
+  lte(value: number, message?: errorUtil.ErrMessage): ZodNumber;
+  max: (value: number, message?: errorUtil.ErrMessage | undefined) => ZodNumber;
+  lt(value: number, message?: errorUtil.ErrMessage): ZodNumber;
+  protected setLimit(kind: "min" | "max", value: number, inclusive: boolean, message?: string): ZodNumber;
+  _addCheck(check: ZodNumberCheck): ZodNumber;
+  int(message?: errorUtil.ErrMessage): ZodNumber;
+  positive(message?: errorUtil.ErrMessage): ZodNumber;
+  negative(message?: errorUtil.ErrMessage): ZodNumber;
+  nonpositive(message?: errorUtil.ErrMessage): ZodNumber;
+  nonnegative(message?: errorUtil.ErrMessage): ZodNumber;
+  multipleOf(value: number, message?: errorUtil.ErrMessage): ZodNumber;
+  step: (value: number, message?: errorUtil.ErrMessage | undefined) => ZodNumber;
+  finite(message?: errorUtil.ErrMessage): ZodNumber;
+  safe(message?: errorUtil.ErrMessage): ZodNumber;
+  get minValue(): number | null;
+  get maxValue(): number | null;
+  get isInt(): boolean;
+  get isFinite(): boolean;
+}
+interface ZodBooleanDef extends ZodTypeDef {
+  typeName: ZodFirstPartyTypeKind.ZodBoolean;
+  coerce: boolean;
+}
+declare class ZodBoolean extends ZodType<boolean, ZodBooleanDef> {
+  _parse(input: ParseInput): ParseReturnType<boolean>;
+  static create: (params?: ({
+    errorMap?: ZodErrorMap | undefined;
+    invalid_type_error?: string | undefined;
+    required_error?: string | undefined;
+    description?: string | undefined;
+  } & {
+    coerce?: boolean | undefined;
+  }) | undefined) => ZodBoolean;
+}
+interface ZodUndefinedDef extends ZodTypeDef {
+  typeName: ZodFirstPartyTypeKind.ZodUndefined;
+}
+declare class ZodUndefined extends ZodType<undefined, ZodUndefinedDef> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  params?: RawCreateParams;
+  static create: (params?: RawCreateParams) => ZodUndefined;
+}
+interface ZodAnyDef extends ZodTypeDef {
+  typeName: ZodFirstPartyTypeKind.ZodAny;
+}
+declare class ZodAny extends ZodType<any, ZodAnyDef> {
+  _any: true;
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  static create: (params?: RawCreateParams) => ZodAny;
+}
+interface ZodArrayDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  type: T;
+  typeName: ZodFirstPartyTypeKind.ZodArray;
+  exactLength: {
+    value: number;
+    message?: string;
+  } | null;
+  minLength: {
+    value: number;
+    message?: string;
+  } | null;
+  maxLength: {
+    value: number;
+    message?: string;
+  } | null;
+}
+declare type ArrayCardinality = "many" | "atleastone";
+declare type arrayOutputType<T extends ZodTypeAny, Cardinality extends ArrayCardinality = "many"> = Cardinality extends "atleastone" ? [T["_output"], ...T["_output"][]] : T["_output"][];
+declare class ZodArray<T extends ZodTypeAny, Cardinality extends ArrayCardinality = "many"> extends ZodType<arrayOutputType<T, Cardinality>, ZodArrayDef<T>, Cardinality extends "atleastone" ? [T["_input"], ...T["_input"][]] : T["_input"][]> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  get element(): T;
+  min(minLength: number, message?: errorUtil.ErrMessage): this;
+  max(maxLength: number, message?: errorUtil.ErrMessage): this;
+  length(len: number, message?: errorUtil.ErrMessage): this;
+  nonempty(message?: errorUtil.ErrMessage): ZodArray<T, "atleastone">;
+  static create: <T_1 extends ZodTypeAny>(schema: T_1, params?: RawCreateParams) => ZodArray<T_1, "many">;
+}
+declare type UnknownKeysParam = "passthrough" | "strict" | "strip";
+interface ZodObjectDef<T extends ZodRawShape = ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  typeName: ZodFirstPartyTypeKind.ZodObject;
+  shape: () => T;
+  catchall: Catchall;
+  unknownKeys: UnknownKeys;
+}
+declare type objectOutputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny, UnknownKeys extends UnknownKeysParam = UnknownKeysParam> = objectUtil.flatten<objectUtil.addQuestionMarks<baseObjectOutputType<Shape>>> & CatchallOutput<Catchall> & PassthroughType<UnknownKeys>;
+declare type baseObjectOutputType<Shape extends ZodRawShape> = { [k in keyof Shape]: Shape[k]["_output"] };
+declare type objectInputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny, UnknownKeys extends UnknownKeysParam = UnknownKeysParam> = objectUtil.flatten<baseObjectInputType<Shape>> & CatchallInput<Catchall> & PassthroughType<UnknownKeys>;
+declare type baseObjectInputType<Shape extends ZodRawShape> = objectUtil.addQuestionMarks<{ [k in keyof Shape]: Shape[k]["_input"] }>;
+declare type CatchallOutput<T extends ZodTypeAny> = ZodTypeAny extends T ? unknown : {
+  [k: string]: T["_output"];
+};
+declare type CatchallInput<T extends ZodTypeAny> = ZodTypeAny extends T ? unknown : {
+  [k: string]: T["_input"];
+};
+declare type PassthroughType<T extends UnknownKeysParam> = T extends "passthrough" ? {
+  [k: string]: unknown;
+} : unknown;
+declare type deoptional<T extends ZodTypeAny> = T extends ZodOptional<infer U> ? deoptional<U> : T extends ZodNullable<infer U> ? ZodNullable<deoptional<U>> : T;
+declare class ZodObject<T extends ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny, Output = objectOutputType<T, Catchall, UnknownKeys>, Input = objectInputType<T, Catchall, UnknownKeys>> extends ZodType<Output, ZodObjectDef<T, UnknownKeys, Catchall>, Input> {
+  private _cached;
+  _getCached(): {
+    shape: T;
+    keys: string[];
+  };
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  get shape(): T;
+  strict(message?: errorUtil.ErrMessage): ZodObject<T, "strict", Catchall>;
+  strip(): ZodObject<T, "strip", Catchall>;
+  passthrough(): ZodObject<T, "passthrough", Catchall>;
+  /**
+   * @deprecated In most cases, this is no longer needed - unknown properties are now silently stripped.
+   * If you want to pass through unknown properties, use `.passthrough()` instead.
+   */
+  nonstrict: () => ZodObject<T, "passthrough", Catchall>;
+  extend<Augmentation extends ZodRawShape>(augmentation: Augmentation): ZodObject<objectUtil.extendShape<T, Augmentation>, UnknownKeys, Catchall>;
+  /**
+   * @deprecated Use `.extend` instead
+   *  */
+  augment: <Augmentation extends ZodRawShape>(augmentation: Augmentation) => ZodObject<{ [k in keyof (Omit<T, keyof Augmentation> & Augmentation)]: (Omit<T, keyof Augmentation> & Augmentation)[k] }, UnknownKeys, Catchall, objectOutputType<{ [k in keyof (Omit<T, keyof Augmentation> & Augmentation)]: (Omit<T, keyof Augmentation> & Augmentation)[k] }, Catchall, UnknownKeys>, objectInputType<{ [k in keyof (Omit<T, keyof Augmentation> & Augmentation)]: (Omit<T, keyof Augmentation> & Augmentation)[k] }, Catchall, UnknownKeys>>;
+  /**
+   * Prior to zod@1.0.12 there was a bug in the
+   * inferred type of merged objects. Please
+   * upgrade if you are experiencing issues.
+   */
+  merge<Incoming extends AnyZodObject, Augmentation extends Incoming["shape"]>(merging: Incoming): ZodObject<objectUtil.extendShape<T, Augmentation>, Incoming["_def"]["unknownKeys"], Incoming["_def"]["catchall"]>;
+  setKey<Key extends string, Schema extends ZodTypeAny>(key: Key, schema: Schema): ZodObject<T & { [k in Key]: Schema }, UnknownKeys, Catchall>;
+  catchall<Index extends ZodTypeAny>(index: Index): ZodObject<T, UnknownKeys, Index>;
+  pick<Mask extends { [k in keyof T]?: true }>(mask: Mask): ZodObject<Pick<T, Extract<keyof T, keyof Mask>>, UnknownKeys, Catchall>;
+  omit<Mask extends { [k in keyof T]?: true }>(mask: Mask): ZodObject<Omit<T, keyof Mask>, UnknownKeys, Catchall>;
+  /**
+   * @deprecated
+   */
+  deepPartial(): partialUtil.DeepPartial<this>;
+  partial(): ZodObject<{ [k in keyof T]: ZodOptional<T[k]> }, UnknownKeys, Catchall>;
+  partial<Mask extends { [k in keyof T]?: true }>(mask: Mask): ZodObject<objectUtil.noNever<{ [k in keyof T]: k extends keyof Mask ? ZodOptional<T[k]> : T[k] }>, UnknownKeys, Catchall>;
+  required(): ZodObject<{ [k in keyof T]: deoptional<T[k]> }, UnknownKeys, Catchall>;
+  required<Mask extends { [k in keyof T]?: true }>(mask: Mask): ZodObject<objectUtil.noNever<{ [k in keyof T]: k extends keyof Mask ? deoptional<T[k]> : T[k] }>, UnknownKeys, Catchall>;
+  keyof(): ZodEnum<enumUtil.UnionToTupleString<keyof T>>;
+  static create: <T_1 extends ZodRawShape>(shape: T_1, params?: RawCreateParams) => ZodObject<T_1, "strip", ZodTypeAny, { [k_1 in keyof objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, { [k in keyof baseObjectOutputType<T_1>]: undefined extends baseObjectOutputType<T_1>[k] ? never : k }[keyof T_1]>]: objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, { [k in keyof baseObjectOutputType<T_1>]: undefined extends baseObjectOutputType<T_1>[k] ? never : k }[keyof T_1]>[k_1] }, { [k_2 in keyof baseObjectInputType<T_1>]: baseObjectInputType<T_1>[k_2] }>;
+  static strictCreate: <T_1 extends ZodRawShape>(shape: T_1, params?: RawCreateParams) => ZodObject<T_1, "strict", ZodTypeAny, { [k_1 in keyof objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, { [k in keyof baseObjectOutputType<T_1>]: undefined extends baseObjectOutputType<T_1>[k] ? never : k }[keyof T_1]>]: objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, { [k in keyof baseObjectOutputType<T_1>]: undefined extends baseObjectOutputType<T_1>[k] ? never : k }[keyof T_1]>[k_1] }, { [k_2 in keyof baseObjectInputType<T_1>]: baseObjectInputType<T_1>[k_2] }>;
+  static lazycreate: <T_1 extends ZodRawShape>(shape: () => T_1, params?: RawCreateParams) => ZodObject<T_1, "strip", ZodTypeAny, { [k_1 in keyof objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, { [k in keyof baseObjectOutputType<T_1>]: undefined extends baseObjectOutputType<T_1>[k] ? never : k }[keyof T_1]>]: objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, { [k in keyof baseObjectOutputType<T_1>]: undefined extends baseObjectOutputType<T_1>[k] ? never : k }[keyof T_1]>[k_1] }, { [k_2 in keyof baseObjectInputType<T_1>]: baseObjectInputType<T_1>[k_2] }>;
+}
+declare type AnyZodObject = ZodObject<any, any, any>;
+declare type ZodUnionOptions = Readonly<[ZodTypeAny, ...ZodTypeAny[]]>;
+interface ZodUnionDef<T extends ZodUnionOptions = Readonly<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>> extends ZodTypeDef {
+  options: T;
+  typeName: ZodFirstPartyTypeKind.ZodUnion;
+}
+declare class ZodUnion<T extends ZodUnionOptions> extends ZodType<T[number]["_output"], ZodUnionDef<T>, T[number]["_input"]> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  get options(): T;
+  static create: <T_1 extends readonly [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>(types: T_1, params?: RawCreateParams) => ZodUnion<T_1>;
+}
+interface ZodIntersectionDef<T extends ZodTypeAny = ZodTypeAny, U extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  left: T;
+  right: U;
+  typeName: ZodFirstPartyTypeKind.ZodIntersection;
+}
+declare class ZodIntersection<T extends ZodTypeAny, U extends ZodTypeAny> extends ZodType<T["_output"] & U["_output"], ZodIntersectionDef<T, U>, T["_input"] & U["_input"]> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  static create: <T_1 extends ZodTypeAny, U_1 extends ZodTypeAny>(left: T_1, right: U_1, params?: RawCreateParams) => ZodIntersection<T_1, U_1>;
+}
+declare type ZodTupleItems = [ZodTypeAny, ...ZodTypeAny[]];
+declare type AssertArray<T> = T extends any[] ? T : never;
+declare type OutputTypeOfTuple<T extends ZodTupleItems | []> = AssertArray<{ [k in keyof T]: T[k] extends ZodType<any, any> ? T[k]["_output"] : never }>;
+declare type OutputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = Rest extends ZodTypeAny ? [...OutputTypeOfTuple<T>, ...Rest["_output"][]] : OutputTypeOfTuple<T>;
+declare type InputTypeOfTuple<T extends ZodTupleItems | []> = AssertArray<{ [k in keyof T]: T[k] extends ZodType<any, any> ? T[k]["_input"] : never }>;
+declare type InputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = Rest extends ZodTypeAny ? [...InputTypeOfTuple<T>, ...Rest["_input"][]] : InputTypeOfTuple<T>;
+interface ZodTupleDef<T extends ZodTupleItems | [] = ZodTupleItems, Rest extends ZodTypeAny | null = null> extends ZodTypeDef {
+  items: T;
+  rest: Rest;
+  typeName: ZodFirstPartyTypeKind.ZodTuple;
+}
+declare class ZodTuple<T extends [ZodTypeAny, ...ZodTypeAny[]] | [] = [ZodTypeAny, ...ZodTypeAny[]], Rest extends ZodTypeAny | null = null> extends ZodType<OutputTypeOfTupleWithRest<T, Rest>, ZodTupleDef<T, Rest>, InputTypeOfTupleWithRest<T, Rest>> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  get items(): T;
+  rest<Rest extends ZodTypeAny>(rest: Rest): ZodTuple<T, Rest>;
+  static create: <T_1 extends [] | [ZodTypeAny, ...ZodTypeAny[]]>(schemas: T_1, params?: RawCreateParams) => ZodTuple<T_1, null>;
+}
+interface ZodRecordDef<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  valueType: Value;
+  keyType: Key;
+  typeName: ZodFirstPartyTypeKind.ZodRecord;
+}
+declare type KeySchema = ZodType<string | number | symbol, any, any>;
+declare type RecordType<K extends string | number | symbol, V> = [string] extends [K] ? Record<K, V> : [number] extends [K] ? Record<K, V> : [symbol] extends [K] ? Record<K, V> : [BRAND<string | number | symbol>] extends [K] ? Record<K, V> : Partial<Record<K, V>>;
+declare class ZodRecord<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> extends ZodType<RecordType<Key["_output"], Value["_output"]>, ZodRecordDef<Key, Value>, RecordType<Key["_input"], Value["_input"]>> {
+  get keySchema(): Key;
+  get valueSchema(): Value;
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  get element(): Value;
+  static create<Value extends ZodTypeAny>(valueType: Value, params?: RawCreateParams): ZodRecord<ZodString, Value>;
+  static create<Keys extends KeySchema, Value extends ZodTypeAny>(keySchema: Keys, valueType: Value, params?: RawCreateParams): ZodRecord<Keys, Value>;
+}
+interface ZodLiteralDef<T = any> extends ZodTypeDef {
+  value: T;
+  typeName: ZodFirstPartyTypeKind.ZodLiteral;
+}
+declare class ZodLiteral<T> extends ZodType<T, ZodLiteralDef<T>> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  get value(): T;
+  static create: <T_1 extends Primitive$1>(value: T_1, params?: RawCreateParams) => ZodLiteral<T_1>;
+}
+declare type EnumValues = [string, ...string[]];
+declare type Values<T extends EnumValues> = { [k in T[number]]: k };
+interface ZodEnumDef<T extends EnumValues = EnumValues> extends ZodTypeDef {
+  values: T;
+  typeName: ZodFirstPartyTypeKind.ZodEnum;
+}
+declare type Writeable<T> = { -readonly [P in keyof T]: T[P] };
+declare type FilterEnum<Values, ToExclude> = Values extends [] ? [] : Values extends [infer Head, ...infer Rest] ? Head extends ToExclude ? FilterEnum<Rest, ToExclude> : [Head, ...FilterEnum<Rest, ToExclude>] : never;
+declare type typecast<A, T> = A extends T ? A : never;
+declare function createZodEnum<U extends string, T extends Readonly<[U, ...U[]]>>(values: T, params?: RawCreateParams): ZodEnum<Writeable<T>>;
+declare function createZodEnum<U extends string, T extends [U, ...U[]]>(values: T, params?: RawCreateParams): ZodEnum<T>;
+declare class ZodEnum<T extends [string, ...string[]]> extends ZodType<T[number], ZodEnumDef<T>> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  get options(): T;
+  get enum(): Values<T>;
+  get Values(): Values<T>;
+  get Enum(): Values<T>;
+  extract<ToExtract extends readonly [T[number], ...T[number][]]>(values: ToExtract): ZodEnum<Writeable<ToExtract>>;
+  exclude<ToExclude extends readonly [T[number], ...T[number][]]>(values: ToExclude): ZodEnum<typecast<Writeable<FilterEnum<T, ToExclude[number]>>, [string, ...string[]]>>;
+  static create: typeof createZodEnum;
+}
+interface ZodPromiseDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  type: T;
+  typeName: ZodFirstPartyTypeKind.ZodPromise;
+}
+declare class ZodPromise<T extends ZodTypeAny> extends ZodType<Promise<T["_output"]>, ZodPromiseDef<T>, Promise<T["_input"]>> {
+  unwrap(): T;
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  static create: <T_1 extends ZodTypeAny>(schema: T_1, params?: RawCreateParams) => ZodPromise<T_1>;
+}
+declare type RefinementEffect<T> = {
+  type: "refinement";
+  refinement: (arg: T, ctx: RefinementCtx) => any;
+};
+declare type TransformEffect<T> = {
+  type: "transform";
+  transform: (arg: T, ctx: RefinementCtx) => any;
+};
+declare type PreprocessEffect<T> = {
+  type: "preprocess";
+  transform: (arg: T, ctx: RefinementCtx) => any;
+};
+declare type Effect<T> = RefinementEffect<T> | TransformEffect<T> | PreprocessEffect<T>;
+interface ZodEffectsDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  schema: T;
+  typeName: ZodFirstPartyTypeKind.ZodEffects;
+  effect: Effect<any>;
+}
+declare class ZodEffects<T extends ZodTypeAny, Output = output<T>, Input = input<T>> extends ZodType<Output, ZodEffectsDef<T>, Input> {
+  innerType(): T;
+  sourceType(): T;
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  static create: <I extends ZodTypeAny>(schema: I, effect: Effect<I["_output"]>, params?: RawCreateParams) => ZodEffects<I, I["_output"], input<I>>;
+  static createWithPreprocess: <I extends ZodTypeAny>(preprocess: (arg: unknown, ctx: RefinementCtx) => unknown, schema: I, params?: RawCreateParams) => ZodEffects<I, I["_output"], unknown>;
+}
+interface ZodOptionalDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  innerType: T;
+  typeName: ZodFirstPartyTypeKind.ZodOptional;
+}
+declare class ZodOptional<T extends ZodTypeAny> extends ZodType<T["_output"] | undefined, ZodOptionalDef<T>, T["_input"] | undefined> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  unwrap(): T;
+  static create: <T_1 extends ZodTypeAny>(type: T_1, params?: RawCreateParams) => ZodOptional<T_1>;
+}
+interface ZodNullableDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  innerType: T;
+  typeName: ZodFirstPartyTypeKind.ZodNullable;
+}
+declare class ZodNullable<T extends ZodTypeAny> extends ZodType<T["_output"] | null, ZodNullableDef<T>, T["_input"] | null> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  unwrap(): T;
+  static create: <T_1 extends ZodTypeAny>(type: T_1, params?: RawCreateParams) => ZodNullable<T_1>;
+}
+interface ZodDefaultDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  innerType: T;
+  defaultValue: () => util.noUndefined<T["_input"]>;
+  typeName: ZodFirstPartyTypeKind.ZodDefault;
+}
+declare class ZodDefault<T extends ZodTypeAny> extends ZodType<util.noUndefined<T["_output"]>, ZodDefaultDef<T>, T["_input"] | undefined> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  removeDefault(): T;
+  static create: <T_1 extends ZodTypeAny>(type: T_1, params: {
+    errorMap?: ZodErrorMap | undefined;
+    invalid_type_error?: string | undefined;
+    required_error?: string | undefined;
+    description?: string | undefined;
+  } & {
+    default: T_1["_input"] | (() => util.noUndefined<T_1["_input"]>);
+  }) => ZodDefault<T_1>;
+}
+interface ZodCatchDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  innerType: T;
+  catchValue: (ctx: {
+    error: ZodError;
+    input: unknown;
+  }) => T["_input"];
+  typeName: ZodFirstPartyTypeKind.ZodCatch;
+}
+declare class ZodCatch<T extends ZodTypeAny> extends ZodType<T["_output"], ZodCatchDef<T>, unknown> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  removeCatch(): T;
+  static create: <T_1 extends ZodTypeAny>(type: T_1, params: {
+    errorMap?: ZodErrorMap | undefined;
+    invalid_type_error?: string | undefined;
+    required_error?: string | undefined;
+    description?: string | undefined;
+  } & {
+    catch: T_1["_output"] | (() => T_1["_output"]);
+  }) => ZodCatch<T_1>;
+}
+interface ZodBrandedDef<T extends ZodTypeAny> extends ZodTypeDef {
+  type: T;
+  typeName: ZodFirstPartyTypeKind.ZodBranded;
+}
+declare const BRAND: unique symbol;
+declare type BRAND<T extends string | number | symbol> = {
+  [BRAND]: { [k in T]: true };
+};
+declare class ZodBranded<T extends ZodTypeAny, B extends string | number | symbol> extends ZodType<T["_output"] & BRAND<B>, ZodBrandedDef<T>, T["_input"]> {
+  _parse(input: ParseInput): ParseReturnType<any>;
+  unwrap(): T;
+}
+interface ZodPipelineDef<A extends ZodTypeAny, B extends ZodTypeAny> extends ZodTypeDef {
+  in: A;
+  out: B;
+  typeName: ZodFirstPartyTypeKind.ZodPipeline;
+}
+declare class ZodPipeline<A extends ZodTypeAny, B extends ZodTypeAny> extends ZodType<B["_output"], ZodPipelineDef<A, B>, A["_input"]> {
+  _parse(input: ParseInput): ParseReturnType<any>;
+  static create<A extends ZodTypeAny, B extends ZodTypeAny>(a: A, b: B): ZodPipeline<A, B>;
+}
+declare type BuiltIn = (((...args: any[]) => any) | (new (...args: any[]) => any)) | {
+  readonly [Symbol.toStringTag]: string;
+} | Date | Error | Generator | Promise<unknown> | RegExp;
+declare type MakeReadonly<T> = T extends Map<infer K, infer V> ? ReadonlyMap<K, V> : T extends Set<infer V> ? ReadonlySet<V> : T extends [infer Head, ...infer Tail] ? readonly [Head, ...Tail] : T extends Array<infer V> ? ReadonlyArray<V> : T extends BuiltIn ? T : Readonly<T>;
+interface ZodReadonlyDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  innerType: T;
+  typeName: ZodFirstPartyTypeKind.ZodReadonly;
+}
+declare class ZodReadonly<T extends ZodTypeAny> extends ZodType<MakeReadonly<T["_output"]>, ZodReadonlyDef<T>, T["_input"]> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  static create: <T_1 extends ZodTypeAny>(type: T_1, params?: RawCreateParams) => ZodReadonly<T_1>;
+}
+declare enum ZodFirstPartyTypeKind {
+  ZodString = "ZodString",
+  ZodNumber = "ZodNumber",
+  ZodNaN = "ZodNaN",
+  ZodBigInt = "ZodBigInt",
+  ZodBoolean = "ZodBoolean",
+  ZodDate = "ZodDate",
+  ZodSymbol = "ZodSymbol",
+  ZodUndefined = "ZodUndefined",
+  ZodNull = "ZodNull",
+  ZodAny = "ZodAny",
+  ZodUnknown = "ZodUnknown",
+  ZodNever = "ZodNever",
+  ZodVoid = "ZodVoid",
+  ZodArray = "ZodArray",
+  ZodObject = "ZodObject",
+  ZodUnion = "ZodUnion",
+  ZodDiscriminatedUnion = "ZodDiscriminatedUnion",
+  ZodIntersection = "ZodIntersection",
+  ZodTuple = "ZodTuple",
+  ZodRecord = "ZodRecord",
+  ZodMap = "ZodMap",
+  ZodSet = "ZodSet",
+  ZodFunction = "ZodFunction",
+  ZodLazy = "ZodLazy",
+  ZodLiteral = "ZodLiteral",
+  ZodEnum = "ZodEnum",
+  ZodEffects = "ZodEffects",
+  ZodNativeEnum = "ZodNativeEnum",
+  ZodOptional = "ZodOptional",
+  ZodNullable = "ZodNullable",
+  ZodDefault = "ZodDefault",
+  ZodCatch = "ZodCatch",
+  ZodPromise = "ZodPromise",
+  ZodBranded = "ZodBranded",
+  ZodPipeline = "ZodPipeline",
+  ZodReadonly = "ZodReadonly"
+}
+declare namespace api_d_exports {
+  export { DrizzleMySQLSnapshotJSON, DrizzleSQLiteSnapshotJSON, DrizzleSingleStoreSnapshotJSON, DrizzleSnapshotJSON, generateDrizzleJson, generateMigration, generateMySQLDrizzleJson, generateMySQLMigration, generateSQLiteDrizzleJson, generateSQLiteMigration, generateSingleStoreDrizzleJson, generateSingleStoreMigration, pushMySQLSchema, pushSQLiteSchema, pushSchema, pushSingleStoreSchema, startStudioMySQLServer, startStudioPostgresServer, startStudioSQLiteServer, startStudioSingleStoreServer, upPgSnapshot };
+}
+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 mysqlCredentials: ZodUnion<[ZodObject<{
+  host: ZodString;
+  port: ZodOptional<ZodNumber>;
+  user: ZodOptional<ZodString>;
+  password: ZodOptional<ZodString>;
+  database: ZodString;
+  ssl: ZodOptional<ZodUnion<[ZodString, ZodObject<{
+    pfx: ZodOptional<ZodString>;
+    key: ZodOptional<ZodString>;
+    passphrase: ZodOptional<ZodString>;
+    cert: ZodOptional<ZodString>;
+    ca: ZodOptional<ZodUnion<[ZodString, ZodArray<ZodString, "many">]>>;
+    crl: ZodOptional<ZodUnion<[ZodString, ZodArray<ZodString, "many">]>>;
+    ciphers: ZodOptional<ZodString>;
+    rejectUnauthorized: ZodOptional<ZodBoolean>;
+  }, "strip", ZodTypeAny, {
+    pfx?: string | undefined;
+    key?: string | undefined;
+    passphrase?: string | undefined;
+    cert?: string | undefined;
+    ca?: string | string[] | undefined;
+    crl?: string | string[] | undefined;
+    ciphers?: string | undefined;
+    rejectUnauthorized?: boolean | undefined;
+  }, {
+    pfx?: string | undefined;
+    key?: string | undefined;
+    passphrase?: string | undefined;
+    cert?: string | undefined;
+    ca?: string | string[] | undefined;
+    crl?: string | string[] | undefined;
+    ciphers?: string | undefined;
+    rejectUnauthorized?: boolean | undefined;
+  }>]>>;
+}, "strip", ZodTypeAny, {
+  host: string;
+  database: string;
+  port?: number | undefined;
+  user?: string | undefined;
+  password?: string | undefined;
+  ssl?: string | {
+    pfx?: string | undefined;
+    key?: string | undefined;
+    passphrase?: string | undefined;
+    cert?: string | undefined;
+    ca?: string | string[] | undefined;
+    crl?: string | string[] | undefined;
+    ciphers?: string | undefined;
+    rejectUnauthorized?: boolean | undefined;
+  } | undefined;
+}, {
+  host: string;
+  database: string;
+  port?: number | undefined;
+  user?: string | undefined;
+  password?: string | undefined;
+  ssl?: string | {
+    pfx?: string | undefined;
+    key?: string | undefined;
+    passphrase?: string | undefined;
+    cert?: string | undefined;
+    ca?: string | string[] | undefined;
+    crl?: string | string[] | undefined;
+    ciphers?: string | undefined;
+    rejectUnauthorized?: boolean | undefined;
+  } | undefined;
+}>, ZodObject<{
+  url: ZodString;
+}, "strip", ZodTypeAny, {
+  url: string;
+}, {
+  url: string;
+}>]>;
+type MysqlCredentials = TypeOf<typeof mysqlCredentials>;
+declare const postgresCredentials: ZodUnion<[ZodEffects<ZodObject<{
+  driver: ZodUndefined;
+  host: ZodString;
+  port: ZodOptional<ZodNumber>;
+  user: ZodOptional<ZodString>;
+  password: ZodOptional<ZodString>;
+  database: ZodString;
+  ssl: ZodOptional<ZodUnion<[ZodLiteral<"require">, ZodLiteral<"allow">, ZodLiteral<"prefer">, ZodLiteral<"verify-full">, ZodBoolean, ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>]>>;
+}, "strip", ZodTypeAny, {
+  host: string;
+  database: string;
+  driver?: undefined;
+  port?: number | undefined;
+  user?: string | undefined;
+  password?: string | undefined;
+  ssl?: boolean | "require" | "allow" | "prefer" | "verify-full" | objectOutputType<{}, ZodTypeAny, "passthrough"> | undefined;
+}, {
+  host: string;
+  database: string;
+  driver?: undefined;
+  port?: number | undefined;
+  user?: string | undefined;
+  password?: string | undefined;
+  ssl?: boolean | "require" | "allow" | "prefer" | "verify-full" | objectInputType<{}, ZodTypeAny, "passthrough"> | undefined;
+}>, Omit<{
+  host: string;
+  database: string;
+  driver?: undefined;
+  port?: number | undefined;
+  user?: string | undefined;
+  password?: string | undefined;
+  ssl?: boolean | "require" | "allow" | "prefer" | "verify-full" | objectOutputType<{}, ZodTypeAny, "passthrough"> | undefined;
+}, "driver">, {
+  host: string;
+  database: string;
+  driver?: undefined;
+  port?: number | undefined;
+  user?: string | undefined;
+  password?: string | undefined;
+  ssl?: boolean | "require" | "allow" | "prefer" | "verify-full" | objectInputType<{}, ZodTypeAny, "passthrough"> | undefined;
+}>, ZodEffects<ZodObject<{
+  driver: ZodUndefined;
+  url: ZodString;
+}, "strip", ZodTypeAny, {
+  url: string;
+  driver?: undefined;
+}, {
+  url: string;
+  driver?: undefined;
+}>, {
+  url: string;
+}, {
+  url: string;
+  driver?: undefined;
+}>, ZodObject<{
+  driver: ZodLiteral<"aws-data-api">;
+  database: ZodString;
+  secretArn: ZodString;
+  resourceArn: ZodString;
+}, "strip", ZodTypeAny, {
+  driver: "aws-data-api";
+  database: string;
+  secretArn: string;
+  resourceArn: string;
+}, {
+  driver: "aws-data-api";
+  database: string;
+  secretArn: string;
+  resourceArn: string;
+}>, ZodObject<{
+  driver: ZodLiteral<"pglite">;
+  url: ZodString;
+}, "strip", ZodTypeAny, {
+  url: string;
+  driver: "pglite";
+}, {
+  url: string;
+  driver: "pglite";
+}>]>;
+type PostgresCredentials = TypeOf<typeof postgresCredentials>;
+declare const singlestoreCredentials: ZodUnion<[ZodObject<{
+  host: ZodString;
+  port: ZodOptional<ZodNumber>;
+  user: ZodOptional<ZodString>;
+  password: ZodOptional<ZodString>;
+  database: ZodString;
+  ssl: ZodOptional<ZodUnion<[ZodString, ZodObject<{
+    pfx: ZodOptional<ZodString>;
+    key: ZodOptional<ZodString>;
+    passphrase: ZodOptional<ZodString>;
+    cert: ZodOptional<ZodString>;
+    ca: ZodOptional<ZodUnion<[ZodString, ZodArray<ZodString, "many">]>>;
+    crl: ZodOptional<ZodUnion<[ZodString, ZodArray<ZodString, "many">]>>;
+    ciphers: ZodOptional<ZodString>;
+    rejectUnauthorized: ZodOptional<ZodBoolean>;
+  }, "strip", ZodTypeAny, {
+    pfx?: string | undefined;
+    key?: string | undefined;
+    passphrase?: string | undefined;
+    cert?: string | undefined;
+    ca?: string | string[] | undefined;
+    crl?: string | string[] | undefined;
+    ciphers?: string | undefined;
+    rejectUnauthorized?: boolean | undefined;
+  }, {
+    pfx?: string | undefined;
+    key?: string | undefined;
+    passphrase?: string | undefined;
+    cert?: string | undefined;
+    ca?: string | string[] | undefined;
+    crl?: string | string[] | undefined;
+    ciphers?: string | undefined;
+    rejectUnauthorized?: boolean | undefined;
+  }>]>>;
+}, "strip", ZodTypeAny, {
+  host: string;
+  database: string;
+  port?: number | undefined;
+  user?: string | undefined;
+  password?: string | undefined;
+  ssl?: string | {
+    pfx?: string | undefined;
+    key?: string | undefined;
+    passphrase?: string | undefined;
+    cert?: string | undefined;
+    ca?: string | string[] | undefined;
+    crl?: string | string[] | undefined;
+    ciphers?: string | undefined;
+    rejectUnauthorized?: boolean | undefined;
+  } | undefined;
+}, {
+  host: string;
+  database: string;
+  port?: number | undefined;
+  user?: string | undefined;
+  password?: string | undefined;
+  ssl?: string | {
+    pfx?: string | undefined;
+    key?: string | undefined;
+    passphrase?: string | undefined;
+    cert?: string | undefined;
+    ca?: string | string[] | undefined;
+    crl?: string | string[] | undefined;
+    ciphers?: string | undefined;
+    rejectUnauthorized?: boolean | undefined;
+  } | undefined;
+}>, ZodObject<{
+  url: ZodString;
+}, "strip", ZodTypeAny, {
+  url: string;
+}, {
+  url: string;
+}>]>;
+type SingleStoreCredentials = TypeOf<typeof singlestoreCredentials>;
+type SqliteCredentials = {
+  driver: 'd1-http';
+  accountId: string;
+  databaseId: string;
+  token: string;
+} | {
+  url: string;
+};
+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;
+/**
+ * **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**
+ *
+ * **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
+ */
+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: ZodObject<{
+  version: ZodLiteral<"5">;
+  dialect: ZodLiteral<"mysql">;
+  tables: ZodRecord<ZodString, ZodObject<{
+    name: ZodString;
+    columns: ZodRecord<ZodString, ZodObject<{
+      name: ZodString;
+      type: ZodString;
+      primaryKey: ZodBoolean;
+      notNull: ZodBoolean;
+      autoincrement: ZodOptional<ZodBoolean>;
+      default: ZodOptional<ZodAny>;
+      onUpdate: ZodOptional<ZodAny>;
+      generated: ZodOptional<ZodObject<{
+        type: ZodEnum<["stored", "virtual"]>;
+        as: ZodString;
+      }, "strip", ZodTypeAny, {
+        type: "stored" | "virtual";
+        as: string;
+      }, {
+        type: "stored" | "virtual";
+        as: string;
+      }>>;
+    }, "strict", 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: ZodRecord<ZodString, ZodObject<{
+      name: ZodString;
+      columns: ZodArray<ZodString, "many">;
+      isUnique: ZodBoolean;
+      using: ZodOptional<ZodEnum<["btree", "hash"]>>;
+      algorithm: ZodOptional<ZodEnum<["default", "inplace", "copy"]>>;
+      lock: ZodOptional<ZodEnum<["default", "none", "shared", "exclusive"]>>;
+    }, "strict", 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: ZodRecord<ZodString, ZodObject<{
+      name: ZodString;
+      tableFrom: ZodString;
+      columnsFrom: ZodArray<ZodString, "many">;
+      tableTo: ZodString;
+      columnsTo: ZodArray<ZodString, "many">;
+      onUpdate: ZodOptional<ZodString>;
+      onDelete: ZodOptional<ZodString>;
+    }, "strict", 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: ZodRecord<ZodString, ZodObject<{
+      name: ZodString;
+      columns: ZodArray<ZodString, "many">;
+    }, "strict", ZodTypeAny, {
+      name: string;
+      columns: string[];
+    }, {
+      name: string;
+      columns: string[];
+    }>>;
+    uniqueConstraints: ZodDefault<ZodRecord<ZodString, ZodObject<{
+      name: ZodString;
+      columns: ZodArray<ZodString, "many">;
+    }, "strict", ZodTypeAny, {
+      name: string;
+      columns: string[];
+    }, {
+      name: string;
+      columns: string[];
+    }>>>;
+    checkConstraint: ZodDefault<ZodRecord<ZodString, ZodObject<{
+      name: ZodString;
+      value: ZodString;
+    }, "strict", ZodTypeAny, {
+      value: string;
+      name: string;
+    }, {
+      value: string;
+      name: string;
+    }>>>;
+  }, "strict", 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: ZodDefault<ZodRecord<ZodString, ZodObject<{
+    name: ZodString;
+    columns: ZodRecord<ZodString, ZodObject<{
+      name: ZodString;
+      type: ZodString;
+      primaryKey: ZodBoolean;
+      notNull: ZodBoolean;
+      autoincrement: ZodOptional<ZodBoolean>;
+      default: ZodOptional<ZodAny>;
+      onUpdate: ZodOptional<ZodAny>;
+      generated: ZodOptional<ZodObject<{
+        type: ZodEnum<["stored", "virtual"]>;
+        as: ZodString;
+      }, "strip", ZodTypeAny, {
+        type: "stored" | "virtual";
+        as: string;
+      }, {
+        type: "stored" | "virtual";
+        as: string;
+      }>>;
+    }, "strict", 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: ZodOptional<ZodString>;
+    isExisting: ZodBoolean;
+  } & {
+    algorithm: ZodEnum<["undefined", "merge", "temptable"]>;
+    sqlSecurity: ZodEnum<["definer", "invoker"]>;
+    withCheckOption: ZodOptional<ZodEnum<["local", "cascaded"]>>;
+  }, "strict", 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: ZodObject<{
+    tables: ZodRecord<ZodString, ZodString>;
+    columns: ZodRecord<ZodString, ZodString>;
+  }, "strip", ZodTypeAny, {
+    tables: Record<string, string>;
+    columns: Record<string, string>;
+  }, {
+    tables: Record<string, string>;
+    columns: Record<string, string>;
+  }>;
+  internal: ZodOptional<ZodObject<{
+    tables: ZodOptional<ZodRecord<ZodString, ZodOptional<ZodObject<{
+      columns: ZodRecord<ZodString, ZodOptional<ZodObject<{
+        isDefaultAnExpression: ZodOptional<ZodBoolean>;
+      }, "strip", ZodTypeAny, {
+        isDefaultAnExpression?: boolean | undefined;
+      }, {
+        isDefaultAnExpression?: boolean | undefined;
+      }>>>;
+    }, "strip", ZodTypeAny, {
+      columns: Record<string, {
+        isDefaultAnExpression?: boolean | undefined;
+      } | undefined>;
+    }, {
+      columns: Record<string, {
+        isDefaultAnExpression?: boolean | undefined;
+      } | undefined>;
+    }>>>>;
+    indexes: ZodOptional<ZodRecord<ZodString, ZodOptional<ZodObject<{
+      columns: ZodRecord<ZodString, ZodOptional<ZodObject<{
+        isExpression: ZodOptional<ZodBoolean>;
+      }, "strip", ZodTypeAny, {
+        isExpression?: boolean | undefined;
+      }, {
+        isExpression?: boolean | undefined;
+      }>>>;
+    }, "strip", ZodTypeAny, {
+      columns: Record<string, {
+        isExpression?: boolean | undefined;
+      } | undefined>;
+    }, {
+      columns: Record<string, {
+        isExpression?: boolean | undefined;
+      } | undefined>;
+    }>>>>;
+  }, "strip", 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: ZodString;
+  prevId: ZodString;
+}, "strip", 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: ZodObject<{
+  version: ZodLiteral<"7">;
+  dialect: ZodLiteral<"postgresql">;
+  tables: ZodRecord<ZodString, ZodObject<{
+    name: ZodString;
+    schema: ZodString;
+    columns: ZodRecord<ZodString, ZodObject<{
+      name: ZodString;
+      type: ZodString;
+      typeSchema: ZodOptional<ZodString>;
+      primaryKey: ZodBoolean;
+      notNull: ZodBoolean;
+      default: ZodOptional<ZodAny>;
+      isUnique: ZodOptional<ZodAny>;
+      uniqueName: ZodOptional<ZodString>;
+      nullsNotDistinct: ZodOptional<ZodBoolean>;
+      generated: ZodOptional<ZodObject<{
+        type: ZodLiteral<"stored">;
+        as: ZodString;
+      }, "strip", ZodTypeAny, {
+        type: "stored";
+        as: string;
+      }, {
+        type: "stored";
+        as: string;
+      }>>;
+      identity: ZodOptional<ZodObject<{
+        name: ZodString;
+        increment: ZodOptional<ZodString>;
+        minValue: ZodOptional<ZodString>;
+        maxValue: ZodOptional<ZodString>;
+        startWith: ZodOptional<ZodString>;
+        cache: ZodOptional<ZodString>;
+        cycle: ZodOptional<ZodBoolean>;
+        schema: ZodString;
+      } & {
+        type: ZodEnum<["always", "byDefault"]>;
+      }, "strip", 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", 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: ZodRecord<ZodString, ZodObject<{
+      name: ZodString;
+      columns: ZodArray<ZodObject<{
+        expression: ZodString;
+        isExpression: ZodBoolean;
+        asc: ZodBoolean;
+        nulls: ZodOptional<ZodString>;
+        opclass: ZodOptional<ZodString>;
+      }, "strip", 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: ZodBoolean;
+      with: ZodOptional<ZodRecord<ZodString, ZodAny>>;
+      method: ZodDefault<ZodString>;
+      where: ZodOptional<ZodString>;
+      concurrently: ZodDefault<ZodBoolean>;
+    }, "strict", 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: ZodRecord<ZodString, ZodObject<{
+      name: ZodString;
+      tableFrom: ZodString;
+      columnsFrom: ZodArray<ZodString, "many">;
+      tableTo: ZodString;
+      schemaTo: ZodOptional<ZodString>;
+      columnsTo: ZodArray<ZodString, "many">;
+      onUpdate: ZodOptional<ZodString>;
+      onDelete: ZodOptional<ZodString>;
+    }, "strict", 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: ZodRecord<ZodString, ZodObject<{
+      name: ZodString;
+      columns: ZodArray<ZodString, "many">;
+    }, "strict", ZodTypeAny, {
+      name: string;
+      columns: string[];
+    }, {
+      name: string;
+      columns: string[];
+    }>>;
+    uniqueConstraints: ZodDefault<ZodRecord<ZodString, ZodObject<{
+      name: ZodString;
+      columns: ZodArray<ZodString, "many">;
+      nullsNotDistinct: ZodBoolean;
+    }, "strict", ZodTypeAny, {
+      name: string;
+      columns: string[];
+      nullsNotDistinct: boolean;
+    }, {
+      name: string;
+      columns: string[];
+      nullsNotDistinct: boolean;
+    }>>>;
+    policies: ZodDefault<ZodRecord<ZodString, ZodObject<{
+      name: ZodString;
+      as: ZodOptional<ZodEnum<["PERMISSIVE", "RESTRICTIVE"]>>;
+      for: ZodOptional<ZodEnum<["ALL", "SELECT", "INSERT", "UPDATE", "DELETE"]>>;
+      to: ZodOptional<ZodArray<ZodString, "many">>;
+      using: ZodOptional<ZodString>;
+      withCheck: ZodOptional<ZodString>;
+      on: ZodOptional<ZodString>;
+      schema: ZodOptional<ZodString>;
+    }, "strict", 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: ZodDefault<ZodRecord<ZodString, ZodObject<{
+      name: ZodString;
+      value: ZodString;
+    }, "strict", ZodTypeAny, {
+      value: string;
+      name: string;
+    }, {
+      value: string;
+      name: string;
+    }>>>;
+    isRLSEnabled: ZodDefault<ZodBoolean>;
+  }, "strict", 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: ZodRecord<ZodString, ZodObject<{
+    name: ZodString;
+    schema: ZodString;
+    values: ZodArray<ZodString, "many">;
+  }, "strict", ZodTypeAny, {
+    values: string[];
+    name: string;
+    schema: string;
+  }, {
+    values: string[];
+    name: string;
+    schema: string;
+  }>>;
+  schemas: ZodRecord<ZodString, ZodString>;
+  views: ZodDefault<ZodRecord<ZodString, ZodObject<{
+    name: ZodString;
+    schema: ZodString;
+    columns: ZodRecord<ZodString, ZodObject<{
+      name: ZodString;
+      type: ZodString;
+      typeSchema: ZodOptional<ZodString>;
+      primaryKey: ZodBoolean;
+      notNull: ZodBoolean;
+      default: ZodOptional<ZodAny>;
+      isUnique: ZodOptional<ZodAny>;
+      uniqueName: ZodOptional<ZodString>;
+      nullsNotDistinct: ZodOptional<ZodBoolean>;
+      generated: ZodOptional<ZodObject<{
+        type: ZodLiteral<"stored">;
+        as: ZodString;
+      }, "strip", ZodTypeAny, {
+        type: "stored";
+        as: string;
+      }, {
+        type: "stored";
+        as: string;
+      }>>;
+      identity: ZodOptional<ZodObject<{
+        name: ZodString;
+        increment: ZodOptional<ZodString>;
+        minValue: ZodOptional<ZodString>;
+        maxValue: ZodOptional<ZodString>;
+        startWith: ZodOptional<ZodString>;
+        cache: ZodOptional<ZodString>;
+        cycle: ZodOptional<ZodBoolean>;
+        schema: ZodString;
+      } & {
+        type: ZodEnum<["always", "byDefault"]>;
+      }, "strip", 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", 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: ZodOptional<ZodString>;
+    materialized: ZodBoolean;
+    with: ZodOptional<ZodObject<{
+      checkOption: ZodOptional<ZodEnum<["local", "cascaded"]>>;
+      securityBarrier: ZodOptional<ZodBoolean>;
+      securityInvoker: ZodOptional<ZodBoolean>;
+    } & {
+      fillfactor: ZodOptional<ZodNumber>;
+      toastTupleTarget: ZodOptional<ZodNumber>;
+      parallelWorkers: ZodOptional<ZodNumber>;
+      autovacuumEnabled: ZodOptional<ZodBoolean>;
+      vacuumIndexCleanup: ZodOptional<ZodEnum<["auto", "off", "on"]>>;
+      vacuumTruncate: ZodOptional<ZodBoolean>;
+      autovacuumVacuumThreshold: ZodOptional<ZodNumber>;
+      autovacuumVacuumScaleFactor: ZodOptional<ZodNumber>;
+      autovacuumVacuumCostDelay: ZodOptional<ZodNumber>;
+      autovacuumVacuumCostLimit: ZodOptional<ZodNumber>;
+      autovacuumFreezeMinAge: ZodOptional<ZodNumber>;
+      autovacuumFreezeMaxAge: ZodOptional<ZodNumber>;
+      autovacuumFreezeTableAge: ZodOptional<ZodNumber>;
+      autovacuumMultixactFreezeMinAge: ZodOptional<ZodNumber>;
+      autovacuumMultixactFreezeMaxAge: ZodOptional<ZodNumber>;
+      autovacuumMultixactFreezeTableAge: ZodOptional<ZodNumber>;
+      logAutovacuumMinDuration: ZodOptional<ZodNumber>;
+      userCatalogTable: ZodOptional<ZodBoolean>;
+    }, "strict", 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: ZodBoolean;
+    withNoData: ZodOptional<ZodBoolean>;
+    using: ZodOptional<ZodString>;
+    tablespace: ZodOptional<ZodString>;
+  }, "strict", 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: ZodDefault<ZodRecord<ZodString, ZodObject<{
+    name: ZodString;
+    increment: ZodOptional<ZodString>;
+    minValue: ZodOptional<ZodString>;
+    maxValue: ZodOptional<ZodString>;
+    startWith: ZodOptional<ZodString>;
+    cache: ZodOptional<ZodString>;
+    cycle: ZodOptional<ZodBoolean>;
+    schema: ZodString;
+  }, "strict", 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: ZodDefault<ZodRecord<ZodString, ZodObject<{
+    name: ZodString;
+    createDb: ZodOptional<ZodBoolean>;
+    createRole: ZodOptional<ZodBoolean>;
+    inherit: ZodOptional<ZodBoolean>;
+  }, "strict", ZodTypeAny, {
+    name: string;
+    createDb?: boolean | undefined;
+    createRole?: boolean | undefined;
+    inherit?: boolean | undefined;
+  }, {
+    name: string;
+    createDb?: boolean | undefined;
+    createRole?: boolean | undefined;
+    inherit?: boolean | undefined;
+  }>>>;
+  policies: ZodDefault<ZodRecord<ZodString, ZodObject<{
+    name: ZodString;
+    as: ZodOptional<ZodEnum<["PERMISSIVE", "RESTRICTIVE"]>>;
+    for: ZodOptional<ZodEnum<["ALL", "SELECT", "INSERT", "UPDATE", "DELETE"]>>;
+    to: ZodOptional<ZodArray<ZodString, "many">>;
+    using: ZodOptional<ZodString>;
+    withCheck: ZodOptional<ZodString>;
+    on: ZodOptional<ZodString>;
+    schema: ZodOptional<ZodString>;
+  }, "strict", 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: ZodObject<{
+    schemas: ZodRecord<ZodString, ZodString>;
+    tables: ZodRecord<ZodString, ZodString>;
+    columns: ZodRecord<ZodString, ZodString>;
+  }, "strip", 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: ZodOptional<ZodObject<{
+    tables: ZodRecord<ZodString, ZodOptional<ZodObject<{
+      columns: ZodRecord<ZodString, ZodOptional<ZodObject<{
+        isArray: ZodOptional<ZodBoolean>;
+        dimensions: ZodOptional<ZodNumber>;
+        rawType: ZodOptional<ZodString>;
+        isDefaultAnExpression: ZodOptional<ZodBoolean>;
+      }, "strip", 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", 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", 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: ZodString;
+  prevId: ZodString;
+}, "strip", 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: ZodObject<{
+  version: ZodLiteral<"1">;
+  dialect: ZodLiteral<"singlestore">;
+  tables: ZodRecord<ZodString, ZodObject<{
+    name: ZodString;
+    columns: ZodRecord<ZodString, ZodObject<{
+      name: ZodString;
+      type: ZodString;
+      primaryKey: ZodBoolean;
+      notNull: ZodBoolean;
+      autoincrement: ZodOptional<ZodBoolean>;
+      default: ZodOptional<ZodAny>;
+      onUpdate: ZodOptional<ZodAny>;
+      generated: ZodOptional<ZodObject<{
+        type: ZodEnum<["stored", "virtual"]>;
+        as: ZodString;
+      }, "strip", ZodTypeAny, {
+        type: "stored" | "virtual";
+        as: string;
+      }, {
+        type: "stored" | "virtual";
+        as: string;
+      }>>;
+    }, "strict", 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: ZodRecord<ZodString, ZodObject<{
+      name: ZodString;
+      columns: ZodArray<ZodString, "many">;
+      isUnique: ZodBoolean;
+      using: ZodOptional<ZodEnum<["btree", "hash"]>>;
+      algorithm: ZodOptional<ZodEnum<["default", "inplace", "copy"]>>;
+      lock: ZodOptional<ZodEnum<["default", "none", "shared", "exclusive"]>>;
+    }, "strict", 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: ZodRecord<ZodString, ZodObject<{
+      name: ZodString;
+      columns: ZodArray<ZodString, "many">;
+    }, "strict", ZodTypeAny, {
+      name: string;
+      columns: string[];
+    }, {
+      name: string;
+      columns: string[];
+    }>>;
+    uniqueConstraints: ZodDefault<ZodRecord<ZodString, ZodObject<{
+      name: ZodString;
+      columns: ZodArray<ZodString, "many">;
+    }, "strict", ZodTypeAny, {
+      name: string;
+      columns: string[];
+    }, {
+      name: string;
+      columns: string[];
+    }>>>;
+  }, "strict", 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: ZodObject<{
+    tables: ZodRecord<ZodString, ZodString>;
+    columns: ZodRecord<ZodString, ZodString>;
+  }, "strip", ZodTypeAny, {
+    tables: Record<string, string>;
+    columns: Record<string, string>;
+  }, {
+    tables: Record<string, string>;
+    columns: Record<string, string>;
+  }>;
+  internal: ZodOptional<ZodObject<{
+    tables: ZodOptional<ZodRecord<ZodString, ZodOptional<ZodObject<{
+      columns: ZodRecord<ZodString, ZodOptional<ZodObject<{
+        isDefaultAnExpression: ZodOptional<ZodBoolean>;
+      }, "strip", ZodTypeAny, {
+        isDefaultAnExpression?: boolean | undefined;
+      }, {
+        isDefaultAnExpression?: boolean | undefined;
+      }>>>;
+    }, "strip", ZodTypeAny, {
+      columns: Record<string, {
+        isDefaultAnExpression?: boolean | undefined;
+      } | undefined>;
+    }, {
+      columns: Record<string, {
+        isDefaultAnExpression?: boolean | undefined;
+      } | undefined>;
+    }>>>>;
+    indexes: ZodOptional<ZodRecord<ZodString, ZodOptional<ZodObject<{
+      columns: ZodRecord<ZodString, ZodOptional<ZodObject<{
+        isExpression: ZodOptional<ZodBoolean>;
+      }, "strip", ZodTypeAny, {
+        isExpression?: boolean | undefined;
+      }, {
+        isExpression?: boolean | undefined;
+      }>>>;
+    }, "strip", ZodTypeAny, {
+      columns: Record<string, {
+        isExpression?: boolean | undefined;
+      } | undefined>;
+    }, {
+      columns: Record<string, {
+        isExpression?: boolean | undefined;
+      } | undefined>;
+    }>>>>;
+  }, "strip", 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: ZodString;
+  prevId: ZodString;
+}, "strip", 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: ZodObject<{
+  version: ZodLiteral<"6">;
+  dialect: ZodEnum<["sqlite"]>;
+  tables: ZodRecord<ZodString, ZodObject<{
+    name: ZodString;
+    columns: ZodRecord<ZodString, ZodObject<{
+      name: ZodString;
+      type: ZodString;
+      primaryKey: ZodBoolean;
+      notNull: ZodBoolean;
+      autoincrement: ZodOptional<ZodBoolean>;
+      default: ZodOptional<ZodAny>;
+      generated: ZodOptional<ZodObject<{
+        type: ZodEnum<["stored", "virtual"]>;
+        as: ZodString;
+      }, "strip", ZodTypeAny, {
+        type: "stored" | "virtual";
+        as: string;
+      }, {
+        type: "stored" | "virtual";
+        as: string;
+      }>>;
+    }, "strict", 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: ZodRecord<ZodString, ZodObject<{
+      name: ZodString;
+      columns: ZodArray<ZodString, "many">;
+      where: ZodOptional<ZodString>;
+      isUnique: ZodBoolean;
+    }, "strict", ZodTypeAny, {
+      name: string;
+      columns: string[];
+      isUnique: boolean;
+      where?: string | undefined;
+    }, {
+      name: string;
+      columns: string[];
+      isUnique: boolean;
+      where?: string | undefined;
+    }>>;
+    foreignKeys: ZodRecord<ZodString, ZodObject<{
+      name: ZodString;
+      tableFrom: ZodString;
+      columnsFrom: ZodArray<ZodString, "many">;
+      tableTo: ZodString;
+      columnsTo: ZodArray<ZodString, "many">;
+      onUpdate: ZodOptional<ZodString>;
+      onDelete: ZodOptional<ZodString>;
+    }, "strict", 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: ZodRecord<ZodString, ZodObject<{
+      columns: ZodArray<ZodString, "many">;
+      name: ZodOptional<ZodString>;
+    }, "strict", ZodTypeAny, {
+      columns: string[];
+      name?: string | undefined;
+    }, {
+      columns: string[];
+      name?: string | undefined;
+    }>>;
+    uniqueConstraints: ZodDefault<ZodRecord<ZodString, ZodObject<{
+      name: ZodString;
+      columns: ZodArray<ZodString, "many">;
+    }, "strict", ZodTypeAny, {
+      name: string;
+      columns: string[];
+    }, {
+      name: string;
+      columns: string[];
+    }>>>;
+    checkConstraints: ZodDefault<ZodRecord<ZodString, ZodObject<{
+      name: ZodString;
+      value: ZodString;
+    }, "strict", ZodTypeAny, {
+      value: string;
+      name: string;
+    }, {
+      value: string;
+      name: string;
+    }>>>;
+  }, "strict", 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: ZodDefault<ZodRecord<ZodString, ZodObject<{
+    name: ZodString;
+    columns: ZodRecord<ZodString, ZodObject<{
+      name: ZodString;
+      type: ZodString;
+      primaryKey: ZodBoolean;
+      notNull: ZodBoolean;
+      autoincrement: ZodOptional<ZodBoolean>;
+      default: ZodOptional<ZodAny>;
+      generated: ZodOptional<ZodObject<{
+        type: ZodEnum<["stored", "virtual"]>;
+        as: ZodString;
+      }, "strip", ZodTypeAny, {
+        type: "stored" | "virtual";
+        as: string;
+      }, {
+        type: "stored" | "virtual";
+        as: string;
+      }>>;
+    }, "strict", 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: ZodOptional<ZodString>;
+    isExisting: ZodBoolean;
+  }, "strict", 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: ZodObject<{}, "strip", ZodTypeAny, {}, {}>;
+  _meta: ZodObject<{
+    tables: ZodRecord<ZodString, ZodString>;
+    columns: ZodRecord<ZodString, ZodString>;
+  }, "strip", ZodTypeAny, {
+    tables: Record<string, string>;
+    columns: Record<string, string>;
+  }, {
+    tables: Record<string, string>;
+    columns: Record<string, string>;
+  }>;
+  internal: ZodOptional<ZodObject<{
+    indexes: ZodOptional<ZodRecord<ZodString, ZodOptional<ZodObject<{
+      columns: ZodRecord<ZodString, ZodOptional<ZodObject<{
+        isExpression: ZodOptional<ZodBoolean>;
+      }, "strip", ZodTypeAny, {
+        isExpression?: boolean | undefined;
+      }, {
+        isExpression?: boolean | undefined;
+      }>>>;
+    }, "strip", ZodTypeAny, {
+      columns: Record<string, {
+        isExpression?: boolean | undefined;
+      } | undefined>;
+    }, {
+      columns: Record<string, {
+        isExpression?: boolean | undefined;
+      } | undefined>;
+    }>>>>;
+  }, "strip", 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: ZodString;
+  prevId: ZodString;
+}, "strict", 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 startStudioPostgresServer: (imports: Record<string, unknown>, credentials: PostgresCredentials | {
+  driver: "pglite";
+  client: PGlite;
+}, options?: {
+  host?: string;
+  port?: number;
+  casing?: CasingType;
+}) => 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 startStudioSQLiteServer: (imports: Record<string, unknown>, credentials: SqliteCredentials | {
+  driver: "d1";
+  binding: D1Database;
+}, options?: {
+  host?: string;
+  port?: number;
+  casing?: CasingType;
+}) => 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 startStudioMySQLServer: (imports: Record<string, unknown>, credentials: MysqlCredentials, options?: {
+  host?: string;
+  port?: number;
+  casing?: CasingType;
+}) => 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 startStudioSingleStoreServer: (imports: Record<string, unknown>, credentials: SingleStoreCredentials, options?: {
+  host?: string;
+  port?: number;
+  casing?: CasingType;
+}) => 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>;
+//#endregion
 //#region ../../src/orm/core/providers/DrizzleKitProvider.d.ts
 declare class DrizzleKitProvider {
   protected readonly log: _$alepha_logger0.Logger;
@@ -436,11 +5303,11 @@ declare class DrizzleKitProvider {
     warnings: string[];
     hasDataLoss: boolean;
   }>;
-  protected pushSqlite(kit: typeof DrizzleKit, models: Record<string, unknown>, provider: DatabaseProvider): Promise<void>;
+  protected pushSqlite(kit: typeof api_d_exports, models: Record<string, unknown>, provider: DatabaseProvider): Promise<void>;
   /**
    * Push schema changes to PostgreSQL using Drizzle Kit's pushSchema with schema filters.
    */
-  protected pushPostgres(kit: typeof DrizzleKit, models: Record<string, unknown>, provider: DatabaseProvider): Promise<void>;
+  protected pushPostgres(kit: typeof api_d_exports, models: Record<string, unknown>, provider: DatabaseProvider): Promise<void>;
   /**
    * Execute a list of SQL statements against the provider.
    */
@@ -464,7 +5331,7 @@ declare class DrizzleKitProvider {
   /**
    * Try to load the official Drizzle Kit API.
    */
-  importDrizzleKit(): typeof DrizzleKit;
+  importDrizzleKit(): typeof api_d_exports;
 }
 //#endregion
 //#region ../../src/orm/core/providers/drivers/DatabaseProvider.d.ts
@@ -1888,6 +6755,7 @@ interface PgJoin {
 //#endregion
 //#region ../../src/orm/core/services/PgRelationManager.d.ts
 declare class PgRelationManager {
+  protected readonly schemaValidator: SchemaValidator;
   /**
    * Recursively build joins for the query builder based on the relations map
    */
@@ -2372,7 +7240,7 @@ declare const $transactional: (options?: TransactionalOptions) => Middleware;
 /**
  * D1Database interface matching Cloudflare's D1 API.
  */
-interface D1Database {
+interface D1Database$1 {
   prepare(query: string): D1PreparedStatement;
   batch<T = unknown>(statements: D1PreparedStatement[]): Promise<T[]>;
   exec(query: string): Promise<D1ExecResult>;
@@ -2408,7 +7276,7 @@ declare class CloudflareD1Provider extends DatabaseProvider {
   protected readonly env: {
     DATABASE_URL: string;
   };
-  protected d1?: D1Database;
+  protected d1?: D1Database$1;
   protected drizzleDb?: DrizzleD1Database;
   get name(): string;
   get driver(): string;
@@ -2565,7 +7433,7 @@ declare class BunSqliteProvider extends DatabaseProvider {
   protected executeMigrations(migrationsFolder: string): Promise<void>;
 }
 declare namespace index_d_exports {
-  export { $entity, $repository, $seed, $sequence, $transactional, AggregateColumnResult, AggregateColumnSelect, AggregateHaving, AggregateOp, AggregateQuery, AggregateResult, AggregateSelect, AlephaOrm, BunSqliteProvider, BunSqliteProviderOptions, CloudflareD1Provider, D1Database, D1ExecResult, D1PreparedStatement, D1Result, DatabaseProvider, DatabaseTypeProvider, DbCacheProvider, DbColumnNotFoundError, DbConflictError, DbConnectionError, DbDeadlockError, DbEntityNotFoundError, DbError, DbForeignKeyError, DbMigrationError, DbMigrationMode, DbNotNullError, DbTableNotFoundError, DbVersionMismatchError, DrizzleKitProvider, EntityColumn, EntityColumns, EntityPrimitive, EntityPrimitiveOptions, FilterOperators, FromSchema, ModelBuilder, NodeSqliteProvider, NodeSqliteProviderOptions, OrderBy, OrderByClause, OrderDirection, PG_CREATED_AT, PG_DEFAULT, PG_DELETED_AT, PG_ENUM, PG_GENERATED, PG_IDENTITY, PG_ORGANIZATION, PG_PRIMARY_KEY, PG_REF, PG_SERIAL, PG_UPDATED_AT, PG_VERSION, Page, PageQuery, PgAttr, PgAttrField, PgDefault, PgEnumOptions, PgGeneratedOptions, PgIdentityOptions, PgPrimaryKey, PgQuery, PgQueryRelations, PgQueryWhere, PgQueryWhereOrSQL, PgRef, PgRefOptions, PgRelation, PgRelationMap, PgStatic, PgSymbolKeys, PgSymbols, Repository, RepositoryProvider, SQLLike, SchemaToTableConfig, SeedOptions, SequencePrimitive, SequencePrimitiveOptions, SqliteProvider, StatementOptions, TObjectInsert, TObjectUpdate, TableConfigBuilders, TransactionalOptions, bunSqliteOptions, databaseEnvSchema, db, _$drizzle_orm0 as drizzle, getAttrFields, insertSchema, legacyIdSchema, nodeSqliteOptions, pageQuerySchema, pageSchema, pgAttr, schema, sql, updateSchema };
+  export { $entity, $repository, $seed, $sequence, $transactional, AggregateColumnResult, AggregateColumnSelect, AggregateHaving, AggregateOp, AggregateQuery, AggregateResult, AggregateSelect, AlephaOrm, BunSqliteProvider, BunSqliteProviderOptions, CloudflareD1Provider, D1Database$1 as D1Database, D1ExecResult, D1PreparedStatement, D1Result, DatabaseProvider, DatabaseTypeProvider, DbCacheProvider, DbColumnNotFoundError, DbConflictError, DbConnectionError, DbDeadlockError, DbEntityNotFoundError, DbError, DbForeignKeyError, DbMigrationError, DbMigrationMode, DbNotNullError, DbTableNotFoundError, DbVersionMismatchError, DrizzleKitProvider, EntityColumn, EntityColumns, EntityPrimitive, EntityPrimitiveOptions, FilterOperators, FromSchema, ModelBuilder, NodeSqliteProvider, NodeSqliteProviderOptions, OrderBy, OrderByClause, OrderDirection, PG_CREATED_AT, PG_DEFAULT, PG_DELETED_AT, PG_ENUM, PG_GENERATED, PG_IDENTITY, PG_ORGANIZATION, PG_PRIMARY_KEY, PG_REF, PG_SERIAL, PG_UPDATED_AT, PG_VERSION, Page, PageQuery, PgAttr, PgAttrField, PgDefault, PgEnumOptions, PgGeneratedOptions, PgIdentityOptions, PgPrimaryKey, PgQuery, PgQueryRelations, PgQueryWhere, PgQueryWhereOrSQL, PgRef, PgRefOptions, PgRelation, PgRelationMap, PgStatic, PgSymbolKeys, PgSymbols, Repository, RepositoryProvider, SQLLike, SchemaToTableConfig, SeedOptions, SequencePrimitive, SequencePrimitiveOptions, SqliteProvider, StatementOptions, TObjectInsert, TObjectUpdate, TableConfigBuilders, TransactionalOptions, bunSqliteOptions, databaseEnvSchema, db, _$drizzle_orm0 as drizzle, getAttrFields, insertSchema, legacyIdSchema, nodeSqliteOptions, pageQuerySchema, pageSchema, pgAttr, schema, sql, updateSchema };
 }
 declare module "alepha" {
   interface State {
@@ -2639,5 +7507,5 @@ declare module "alepha" {
 declare const SqliteProvider: typeof NodeSqliteProvider;
 declare const AlephaOrm: _$alepha.Service<_$alepha.Module>;
 //#endregion
-export { $entity, $repository, $seed, $sequence, $transactional, AggregateColumnResult, AggregateColumnSelect, AggregateHaving, AggregateOp, AggregateQuery, AggregateResult, AggregateSelect, AlephaOrm, BunSqliteProvider, BunSqliteProviderOptions, CloudflareD1Provider, D1Database, D1ExecResult, D1PreparedStatement, D1Result, DatabaseProvider, DatabaseTypeProvider, DbCacheProvider, DbColumnNotFoundError, DbConflictError, DbConnectionError, DbDeadlockError, DbEntityNotFoundError, DbError, DbForeignKeyError, DbMigrationError, DbMigrationMode, DbNotNullError, DbTableNotFoundError, DbVersionMismatchError, DrizzleKitProvider, EntityColumn, EntityColumns, EntityPrimitive, EntityPrimitiveOptions, FilterOperators, FromSchema, ModelBuilder, NodeSqliteProvider, NodeSqliteProviderOptions, OrderBy, OrderByClause, OrderDirection, PG_CREATED_AT, PG_DEFAULT, PG_DELETED_AT, PG_ENUM, PG_GENERATED, PG_IDENTITY, PG_ORGANIZATION, PG_PRIMARY_KEY, PG_REF, PG_SERIAL, PG_UPDATED_AT, PG_VERSION, type Page, type PageQuery, PgAttr, PgAttrField, PgDefault, PgEnumOptions, PgGeneratedOptions, PgIdentityOptions, PgPrimaryKey, PgQuery, PgQueryRelations, PgQueryWhere, PgQueryWhereOrSQL, PgRef, PgRefOptions, PgRelation, PgRelationMap, PgStatic, PgSymbolKeys, PgSymbols, Repository, RepositoryProvider, SQLLike, SchemaToTableConfig, SeedOptions, SequencePrimitive, SequencePrimitiveOptions, SqliteProvider, StatementOptions, TObjectInsert, TObjectUpdate, TableConfigBuilders, TransactionalOptions, bunSqliteOptions, databaseEnvSchema, db, _$drizzle_orm0 as drizzle, getAttrFields, insertSchema, legacyIdSchema, nodeSqliteOptions, pageQuerySchema, pageSchema, pgAttr, schema, sql, updateSchema };
+export { $entity, $repository, $seed, $sequence, $transactional, AggregateColumnResult, AggregateColumnSelect, AggregateHaving, AggregateOp, AggregateQuery, AggregateResult, AggregateSelect, AlephaOrm, BunSqliteProvider, BunSqliteProviderOptions, CloudflareD1Provider, D1Database$1 as D1Database, D1ExecResult, D1PreparedStatement, D1Result, DatabaseProvider, DatabaseTypeProvider, DbCacheProvider, DbColumnNotFoundError, DbConflictError, DbConnectionError, DbDeadlockError, DbEntityNotFoundError, DbError, DbForeignKeyError, DbMigrationError, DbMigrationMode, DbNotNullError, DbTableNotFoundError, DbVersionMismatchError, DrizzleKitProvider, EntityColumn, EntityColumns, EntityPrimitive, EntityPrimitiveOptions, FilterOperators, FromSchema, ModelBuilder, NodeSqliteProvider, NodeSqliteProviderOptions, OrderBy, OrderByClause, OrderDirection, PG_CREATED_AT, PG_DEFAULT, PG_DELETED_AT, PG_ENUM, PG_GENERATED, PG_IDENTITY, PG_ORGANIZATION, PG_PRIMARY_KEY, PG_REF, PG_SERIAL, PG_UPDATED_AT, PG_VERSION, type Page, type PageQuery, PgAttr, PgAttrField, PgDefault, PgEnumOptions, PgGeneratedOptions, PgIdentityOptions, PgPrimaryKey, PgQuery, PgQueryRelations, PgQueryWhere, PgQueryWhereOrSQL, PgRef, PgRefOptions, PgRelation, PgRelationMap, PgStatic, PgSymbolKeys, PgSymbols, Repository, RepositoryProvider, SQLLike, SchemaToTableConfig, SeedOptions, SequencePrimitive, SequencePrimitiveOptions, SqliteProvider, StatementOptions, TObjectInsert, TObjectUpdate, TableConfigBuilders, TransactionalOptions, bunSqliteOptions, databaseEnvSchema, db, _$drizzle_orm0 as drizzle, getAttrFields, insertSchema, legacyIdSchema, nodeSqliteOptions, pageQuerySchema, pageSchema, pgAttr, schema, sql, updateSchema };
 //# sourceMappingURL=index.d.ts.map