@event-driven-io/dumbo 0.13.0-beta.40 → 0.13.0-beta.42

package/dist/{index-BDSQvDH2.d.cts → index-CfH0u2y_.d.cts}

@@ -335,6 +335,11 @@ declare const SQLColumnToken: {
   type: "SQL_COLUMN";
 };
 //#endregion
+//#region src/core/sql/valueMappers/reservedSqlWords.d.ts
+declare const ansiSqlReservedMap: {
+  [key: string]: boolean;
+};
+//#endregion
 //#region src/core/sql/valueMappers/sqlValueMapper.d.ts
 interface SQLValueMapper {
   mapValue: MapSQLParamValue;
@@ -420,44 +425,222 @@ declare global {
 }
 declare const defaultProcessorsRegistry: SQLProcessorsRegistry;
 //#endregion
+//#region src/core/schema/sqlMigration.d.ts
+type MigrationStyle = 'None' | 'CreateOrUpdate';
+type SQLMigration = {
+  name: string;
+  sqls: SQL[];
+};
+declare const sqlMigration: (name: string, sqls: SQL[]) => SQLMigration;
+type MigrationRecord = {
+  id: number;
+  name: string;
+  application: string;
+  sqlHash: string;
+  timestamp: Date;
+};
+//#endregion
+//#region src/core/schema/schemaComponent.d.ts
+type SchemaComponent<ComponentKey extends string = string, AdditionalData extends Exclude<Record<string, unknown>, 'schemaComponentKey' | 'components' | 'migrations' | 'addComponent' | 'addMigration'> | undefined = undefined> = {
+  schemaComponentKey: ComponentKey;
+  components: ReadonlyMap<string, SchemaComponent>;
+  migrations: ReadonlyArray<SQLMigration>;
+  addComponent: <SchemaComponentType extends SchemaComponent<string, Record<string, any>> = SchemaComponent<string, Record<string, any>>>(component: SchemaComponentType) => SchemaComponentType;
+  addMigration: (migration: SQLMigration) => void;
+} & Exclude<AdditionalData extends undefined ? {} : AdditionalData, 'schemaComponentKey' | 'components' | 'migrations' | 'addComponent' | 'addMigration'>;
+type ExtractAdditionalData<T> = T extends SchemaComponent<infer _ComponentType, infer Data> ? Data : never;
+type AnySchemaComponent = SchemaComponent<string, Record<string, any>>;
+type AnySchemaComponentOfType<ComponentType extends string = string> = SchemaComponent<ComponentType, any>;
+type SchemaComponentOptions<AdditionalOptions extends Record<string, unknown> = Record<string, unknown>> = {
+  migrations?: ReadonlyArray<SQLMigration>;
+  components?: ReadonlyArray<SchemaComponent>;
+} & Omit<AdditionalOptions, 'migrations' | 'components'>;
+type SchemaComponentType<Kind extends string = string> = `sc:${Kind}`;
+type DumboSchemaComponentType<Kind extends string = string> = SchemaComponentType<`dumbo:${Kind}`>;
+declare const schemaComponent: <const ComponentKey extends string = string>(key: ComponentKey, options: SchemaComponentOptions) => SchemaComponent<ComponentKey>;
+declare const isSchemaComponentOfType: <SchemaComponentOfType extends AnySchemaComponent = AnySchemaComponent>(component: AnySchemaComponent, prefix: string) => component is SchemaComponentOfType;
+declare const filterSchemaComponentsOfType: <T extends AnySchemaComponent>(components: ReadonlyMap<string, AnySchemaComponent>, prefix: string) => ReadonlyMap<string, T>;
+declare const mapSchemaComponentsOfType: <T extends AnySchemaComponent>(components: ReadonlyMap<string, AnySchemaComponent>, prefix: string, keyMapper?: (component: T) => string) => ReadonlyMap<string, T>;
+declare const findSchemaComponentsOfType: <T extends AnySchemaComponent>(root: AnySchemaComponent, prefix: string) => T[];
+//#endregion
+//#region src/core/schema/dumboSchema/dumboSchema.d.ts
+declare const DEFAULT_DATABASE_SCHEMA_NAME = "__default_database_schema__";
+declare function dumboDatabaseSchema<const Tables extends DatabaseSchemaTables = DatabaseSchemaTables>(tables: Tables): DatabaseSchemaSchemaComponent<Tables, typeof DEFAULT_DATABASE_SCHEMA_NAME>;
+declare function dumboDatabaseSchema<const Tables extends DatabaseSchemaTables = DatabaseSchemaTables, const SchemaName extends string = string>(schemaName: SchemaName, tables: Tables, options?: SchemaComponentOptions): DatabaseSchemaSchemaComponent<Tables, SchemaName>;
+declare namespace dumboDatabaseSchema {
+  var from: (schemaName: string | undefined, tableNames: string[]) => DatabaseSchemaSchemaComponent;
+  var defaultName: string;
+}
+type ValidatedDatabaseSchemaComponent<Schemas extends DatabaseSchemas = DatabaseSchemas> = ValidateDatabaseSchemas<Schemas> extends {
+  valid: true;
+} ? DatabaseSchemaComponent<Schemas> : ValidateDatabaseSchemas<Schemas> extends {
+  valid: false;
+  error: infer E;
+} ? {
+  valid: false;
+  error: E;
+} : DatabaseSchemaComponent<Schemas>;
+declare function dumboDatabase<Schemas extends DatabaseSchemas = DatabaseSchemas>(schemas: Schemas): ValidatedDatabaseSchemaComponent<Schemas>;
+declare function dumboDatabase<Schemas extends DatabaseSchemas = DatabaseSchemas>(schema: DatabaseSchemaSchemaComponent): ValidatedDatabaseSchemaComponent<Schemas>;
+declare function dumboDatabase<Schemas extends DatabaseSchemas = DatabaseSchemas>(databaseName: string, schemas: Schemas, options?: SchemaComponentOptions): ValidatedDatabaseSchemaComponent<Schemas>;
+declare function dumboDatabase<Schemas extends DatabaseSchemas = DatabaseSchemas>(databaseName: string, schema: AnyDatabaseSchemaSchemaComponent, options?: SchemaComponentOptions): ValidatedDatabaseSchemaComponent<Schemas>;
+declare namespace dumboDatabase {
+  var from: <Schemas extends DatabaseSchemas = DatabaseSchemas>(databaseName: string | undefined, schemaNames: string[]) => ValidatedDatabaseSchemaComponent<Schemas>;
+  var defaultName: string;
+}
+declare const dumboSchema: {
+  database: typeof dumboDatabase;
+  schema: typeof dumboDatabaseSchema;
+  table: <const Columns extends TableColumns = TableColumns, const TableName extends string = string, const Relationships extends TableRelationships<keyof Columns & string> = TableRelationships<keyof Columns & string>>(name: TableName, definition: {
+    columns?: Columns;
+    primaryKey?: TableColumnNames<TableSchemaComponent<Columns, TableName, Relationships>>[];
+    relationships?: Relationships;
+    indexes?: Record<string, IndexSchemaComponent>;
+  } & SchemaComponentOptions) => TableSchemaComponent<Columns, TableName, Relationships>;
+  column: <const ColumnType extends AnyColumnTypeToken | string = string | AnyColumnTypeToken, const TOptions extends SchemaComponentOptions & Omit<SQLColumnToken<ColumnType>, "name" | "type" | "sqlTokenType"> = Omit<ColumnSchemaComponentOptions<ColumnType>, "type">, const ColumnName extends string = string>(name: ColumnName, type: ColumnType, options?: TOptions) => ({
+    schemaComponentKey: `sc:dumbo:column:${ColumnName}`;
+    components: ReadonlyMap<string, SchemaComponent>;
+    migrations: ReadonlyArray<SQLMigration>;
+    addComponent: <SchemaComponentType extends SchemaComponent<string, Record<string, any>> = SchemaComponent<string, Record<string, any>>>(component: SchemaComponentType) => SchemaComponentType;
+    addMigration: (migration: SQLMigration) => void;
+  } & Readonly<{
+    columnName: ColumnName;
+  }> & {
+    sqlTokenType: "SQL_COLUMN";
+  } & Omit<{
+    name: string;
+    type: ColumnType;
+    notNull?: false;
+    unique?: boolean;
+    primaryKey: never;
+    default?: ColumnType | SQLToken;
+  }, "sqlTokenType"> & (TOptions & {
+    type: ColumnType;
+  } extends infer T ? T extends TOptions & {
+    type: ColumnType;
+  } ? T extends {
+    notNull: true;
+  } | {
+    primaryKey: true;
+  } ? {
+    notNull: true;
+  } : {
+    notNull?: false;
+  } : never : never)) | ({
+    schemaComponentKey: `sc:dumbo:column:${ColumnName}`;
+    components: ReadonlyMap<string, SchemaComponent>;
+    migrations: ReadonlyArray<SQLMigration>;
+    addComponent: <SchemaComponentType extends SchemaComponent<string, Record<string, any>> = SchemaComponent<string, Record<string, any>>>(component: SchemaComponentType) => SchemaComponentType;
+    addMigration: (migration: SQLMigration) => void;
+  } & Readonly<{
+    columnName: ColumnName;
+  }> & {
+    sqlTokenType: "SQL_COLUMN";
+  } & Omit<NullableSQLColumnTokenProps<ColumnType>, "sqlTokenType"> & (TOptions & {
+    type: ColumnType;
+  } extends infer T_1 ? T_1 extends TOptions & {
+    type: ColumnType;
+  } ? T_1 extends {
+    notNull: true;
+  } | {
+    primaryKey: true;
+  } ? {
+    notNull: true;
+  } : {
+    notNull?: false;
+  } : never : never));
+  index: (name: string, columnNames: string[], options?: {
+    unique?: boolean;
+  } & SchemaComponentOptions) => IndexSchemaComponent;
+};
+//#endregion
+//#region src/core/sql/tokenizedSQL/tokenizedSQL.d.ts
+type TokenizedSQL = Readonly<{
+  __brand: 'tokenized-sql';
+  sqlChunks: ReadonlyArray<string>;
+  sqlTokens: ReadonlyArray<AnySQLToken>;
+}>;
+declare const TokenizedSQL: {
+  (strings: ReadonlyArray<string>, values: unknown[]): TokenizedSQL;
+  paramPlaceholder: string;
+  empty: {
+    __brand: "tokenized-sql";
+    sqlChunks: string[];
+    sqlTokens: never[];
+  };
+};
+declare const isTokenizedSQL: (value: unknown) => value is TokenizedSQL;
+//#endregion
 //#region src/core/sql/sql.d.ts
+/** A tokenized SQL statement created with the {@link SQL} template tag. */
 type SQL = string & {
   __brand: 'sql';
 };
-declare function SQL(strings: TemplateStringsArray, ...values: unknown[]): SQL;
-declare namespace SQL {
-  export var EMPTY: SQL;
-  export var concat: (...sqls: SQL[]) => SQL;
-  export var merge: (sqls: SQL[], separator?: string) => SQL;
-  export var format: (sql: SQL | SQL[], formatter: SQLFormatter, options?: FormatSQLOptions) => ParametrizedSQL;
-  export var describe: (sql: SQL | SQL[], formatter: SQLFormatter, options?: FormatSQLOptions) => string;
-  var _a: (column: string, values: unknown[], options?: {
+type SQLTag = {
+  /**
+   * Creates a tokenized SQL statement.
+   *
+   * Interpolated values are treated as bound parameters by default. Use the
+   * helper methods on `SQL` for SQL syntax that cannot be represented as a bound
+   * parameter, such as identifiers or trusted raw fragments.
+   */
+  (strings: TemplateStringsArray, ...values: unknown[]): SQL; /** Empty SQL statement used when optional query fragments are absent. */
+  EMPTY: SQL; /** Concatenates SQL fragments without adding a separator. */
+  concat: (...sqls: SQL[]) => SQL;
+  /**
+   * Merges SQL fragments, skipping empty fragments and inserting a separator
+   * between non-empty fragments.
+   */
+  merge: (sqls: SQL[], separator?: string) => SQL; /** Formats SQL into a parametrized query and params using the selected formatter. */
+  format: (sql: SQL | SQL[], formatter: SQLFormatter, options?: FormatSQLOptions) => ParametrizedSQL; /** Formats SQL into a readable SQL string for diagnostics and migrations. */
+  describe: (sql: SQL | SQL[], formatter: SQLFormatter, options?: FormatSQLOptions) => string; /** Creates a SQL `IN`/native-array token for the provided column and values. */
+  in: (column: string, values: unknown[], options?: {
     mode?: SQLArrayMode;
-  }) => SQLIn;
-  export var array: (values: unknown[], options?: {
+  }) => SQLIn; /** Creates an array token that formatters can render as native or expanded params. */
+  array: (values: unknown[], options?: {
     mode?: SQLArrayMode;
-  }) => SQLArray;
-  export var identifier: (input: string) => SQLIdentifier;
-  export var plain: (input: string) => SQLPlain;
-  export var check: {
+  }) => SQLArray; /** Creates a SQL identifier token, quoting it when required by SQL rules. */
+  identifier: typeof SQLIdentifier.from;
+  /**
+   * Creates a trusted raw SQL fragment.
+   *
+   * This does not quote, escape, or bind the value. Prefer bound parameters for
+   * data values, `SQL.identifier` for identifiers, and `SQL.literal` only when
+   * SQL syntax requires an inline value literal.
+   */
+  plain: typeof SQLPlain.from;
+  /**
+   * Creates an inline SQL value literal.
+   *
+   * Use this for SQL syntax positions that cannot use bound parameters. Data
+   * values in ordinary queries should stay as template interpolations.
+   */
+  literal: (value: string) => SQLPlain; /** Type guards and helpers for SQL tokens. */
+  check: {
     isSQL: (value: unknown) => value is SQL;
-    isTokenizedSQL: (value: unknown) => value is Readonly<{
-      __brand: "tokenized-sql";
-      sqlChunks: ReadonlyArray<string>;
-      sqlTokens: ReadonlyArray<AnySQLToken>;
-    }>;
+    isTokenizedSQL: (value: unknown) => value is TokenizedSQL;
     isEmpty: (sql: SQL) => boolean;
-    isIdentifier: (token: unknown) => token is SQLIdentifier;
-    isPlain: (token: unknown) => token is SQLPlain;
-    isSQLIn: (token: unknown) => token is SQLIn;
-  };
-  export var column: ((input: Omit<SQLColumnToken<string | AnyColumnTypeToken>, "sqlTokenType">) => SQLColumnToken<string | AnyColumnTypeToken>) & {
-    type: typeof SQLColumnTypeTokensFactory;
+    isIdentifier: typeof SQLIdentifier.check;
+    isPlain: typeof SQLPlain.check;
+    isSQLIn: typeof SQLIn.check;
+  }; /** Creates a schema column token for SQL generation. */
+  column: typeof SQLColumnToken.from & {
+    /** Column type token factory. */type: typeof SQLColumnTypeTokensFactory;
+  }; /** Creates a schema column token using Dumbo schema metadata. */
+  columnN: typeof dumboSchema.column & {
+    /** Column type token factory. */type: typeof SQLColumnTypeTokensFactory;
   };
-  export { _a as in };
-}
+};
+/**
+ * Creates SQL by interpolating values directly into the statement.
+ *
+ * Prefer {@link SQL} for query execution. `RawSQL` is for trusted SQL text that
+ * is already safe to inline.
+ */
 declare function RawSQL(strings: TemplateStringsArray, ...values: unknown[]): SQL;
+/** Returns true when the value is a tokenized SQL statement. */
 declare const isSQL: (value: unknown) => value is SQL;
+declare const SQL: SQLTag;
 //#endregion
 //#region src/core/sql/formatters/sqlFormatter.d.ts
 type FormatContext = Partial<SQLProcessorContext> & Pick<SQLProcessorContext, 'serializer'>;
@@ -489,44 +672,13 @@ declare const getFormatter: (dialect: string) => SQLFormatter;
 declare function formatSQL(sql: SQL | SQL[], formatter: SQLFormatter, serializer: JSONSerializer, context?: FormatSQLOptions): ParametrizedSQL;
 declare const describeSQL: (sql: SQL | SQL[], formatter: SQLFormatter, serializer: JSONSerializer, options?: FormatSQLOptions) => string;
 //#endregion
-//#region src/core/schema/sqlMigration.d.ts
-type MigrationStyle = 'None' | 'CreateOrUpdate';
-type SQLMigration = {
-  name: string;
-  sqls: SQL[];
-};
-declare const sqlMigration: (name: string, sqls: SQL[]) => SQLMigration;
-type MigrationRecord = {
-  id: number;
-  name: string;
-  application: string;
-  sqlHash: string;
-  timestamp: Date;
+//#region src/core/sql/parameters/jsonParam.d.ts
+declare const JSONParam: {
+  readonly arrayContaining: (jsonValue: unknown, serializer: JSONSerializer) => string;
+  readonly document: (document: unknown, serializer: JSONSerializer) => string;
+  readonly value: (jsonValue: unknown, serializer: JSONSerializer) => string;
 };
 //#endregion
-//#region src/core/schema/schemaComponent.d.ts
-type SchemaComponent<ComponentKey extends string = string, AdditionalData extends Exclude<Record<string, unknown>, 'schemaComponentKey' | 'components' | 'migrations' | 'addComponent' | 'addMigration'> | undefined = undefined> = {
-  schemaComponentKey: ComponentKey;
-  components: ReadonlyMap<string, SchemaComponent>;
-  migrations: ReadonlyArray<SQLMigration>;
-  addComponent: <SchemaComponentType extends SchemaComponent<string, Record<string, any>> = SchemaComponent<string, Record<string, any>>>(component: SchemaComponentType) => SchemaComponentType;
-  addMigration: (migration: SQLMigration) => void;
-} & Exclude<AdditionalData extends undefined ? {} : AdditionalData, 'schemaComponentKey' | 'components' | 'migrations' | 'addComponent' | 'addMigration'>;
-type ExtractAdditionalData<T> = T extends SchemaComponent<infer _ComponentType, infer Data> ? Data : never;
-type AnySchemaComponent = SchemaComponent<string, Record<string, any>>;
-type AnySchemaComponentOfType<ComponentType extends string = string> = SchemaComponent<ComponentType, any>;
-type SchemaComponentOptions<AdditionalOptions extends Record<string, unknown> = Record<string, unknown>> = {
-  migrations?: ReadonlyArray<SQLMigration>;
-  components?: ReadonlyArray<SchemaComponent>;
-} & Omit<AdditionalOptions, 'migrations' | 'components'>;
-type SchemaComponentType<Kind extends string = string> = `sc:${Kind}`;
-type DumboSchemaComponentType<Kind extends string = string> = SchemaComponentType<`dumbo:${Kind}`>;
-declare const schemaComponent: <const ComponentKey extends string = string>(key: ComponentKey, options: SchemaComponentOptions) => SchemaComponent<ComponentKey>;
-declare const isSchemaComponentOfType: <SchemaComponentOfType extends AnySchemaComponent = AnySchemaComponent>(component: AnySchemaComponent, prefix: string) => component is SchemaComponentOfType;
-declare const filterSchemaComponentsOfType: <T extends AnySchemaComponent>(components: ReadonlyMap<string, AnySchemaComponent>, prefix: string) => ReadonlyMap<string, T>;
-declare const mapSchemaComponentsOfType: <T extends AnySchemaComponent>(components: ReadonlyMap<string, AnySchemaComponent>, prefix: string, keyMapper?: (component: T) => string) => ReadonlyMap<string, T>;
-declare const findSchemaComponentsOfType: <T extends AnySchemaComponent>(root: AnySchemaComponent, prefix: string) => T[];
-//#endregion
 //#region src/core/schema/components/columnSchemaComponent.d.ts
 type ColumnURNType = 'sc:dumbo:column';
 type ColumnURN<ColumnName extends string = string> = `${ColumnURNType}:${ColumnName}`;
@@ -1058,6 +1210,25 @@ type QueryResult<Result extends QueryResultRow = QueryResultRow> = {
   rows: Result[];
 };
 //#endregion
+//#region src/core/query/mappers.d.ts
+declare const mapRows: <Result extends QueryResultRow = QueryResultRow, Mapped = unknown>(getResult: Promise<QueryResult<Result>>, map: (row: Result) => Mapped) => Promise<Mapped[]>;
+declare const toCamelCase: (snakeStr: string) => string;
+declare const mapToCamelCase: <T extends Record<string, unknown>>(obj: Record<string, unknown>) => T;
+//#endregion
+//#region src/core/query/selectors.d.ts
+declare const firstOrNull: <Result extends QueryResultRow = QueryResultRow>(getResult: Promise<QueryResult<Result>>) => Promise<Result | null>;
+declare const first: <Result extends QueryResultRow = QueryResultRow>(getResult: Promise<QueryResult<Result>>) => Promise<Result>;
+declare const singleOrNull: <Result extends QueryResultRow = QueryResultRow>(getResult: Promise<QueryResult<Result>>) => Promise<Result | null>;
+declare const single: <Result extends QueryResultRow = QueryResultRow>(getResult: Promise<QueryResult<Result>>) => Promise<Result>;
+type CountSQLQueryResult = {
+  count: number;
+};
+declare const count: (getResult: Promise<QueryResult<CountSQLQueryResult>>) => Promise<number>;
+type ExistsSQLQueryResult = {
+  exists: boolean | 1 | 0;
+};
+declare const exists: (getResult: Promise<QueryResult<ExistsSQLQueryResult>>) => Promise<boolean>;
+//#endregion
 //#region src/core/execute/execute.d.ts
 declare const mapColumnToJSON: (column: string, serializer: JSONSerializer, options?: JSONDeserializeOptions) => {
   [x: string]: (value: unknown) => unknown;
@@ -1084,6 +1255,8 @@ type BatchSQLCommandOptions = SQLCommandOptions & {
   assertChanges?: boolean;
 };
 declare class BatchCommandNoChangesError extends DumboError {
+  static readonly ErrorCode: number;
+  static readonly ErrorType: string;
   readonly statementIndex: number;
   constructor(statementIndex: number);
 }
@@ -1173,97 +1346,6 @@ declare const resolveDatabaseMetadata: (driverType: DatabaseDriverType, driverOv
 declare const getDefaultDatabase: (driverType: DatabaseDriverType) => string | undefined;
 declare const getDefaultDatabaseAsync: (driverType: DatabaseDriverType) => Promise<string | undefined>;
 //#endregion
-//#region src/core/schema/dumboSchema/dumboSchema.d.ts
-declare const DEFAULT_DATABASE_SCHEMA_NAME = "__default_database_schema__";
-declare function dumboDatabaseSchema<const Tables extends DatabaseSchemaTables = DatabaseSchemaTables>(tables: Tables): DatabaseSchemaSchemaComponent<Tables, typeof DEFAULT_DATABASE_SCHEMA_NAME>;
-declare function dumboDatabaseSchema<const Tables extends DatabaseSchemaTables = DatabaseSchemaTables, const SchemaName extends string = string>(schemaName: SchemaName, tables: Tables, options?: SchemaComponentOptions): DatabaseSchemaSchemaComponent<Tables, SchemaName>;
-declare namespace dumboDatabaseSchema {
-  var from: (schemaName: string | undefined, tableNames: string[]) => DatabaseSchemaSchemaComponent;
-  var defaultName: string;
-}
-type ValidatedDatabaseSchemaComponent<Schemas extends DatabaseSchemas = DatabaseSchemas> = ValidateDatabaseSchemas<Schemas> extends {
-  valid: true;
-} ? DatabaseSchemaComponent<Schemas> : ValidateDatabaseSchemas<Schemas> extends {
-  valid: false;
-  error: infer E;
-} ? {
-  valid: false;
-  error: E;
-} : DatabaseSchemaComponent<Schemas>;
-declare function dumboDatabase<Schemas extends DatabaseSchemas = DatabaseSchemas>(schemas: Schemas): ValidatedDatabaseSchemaComponent<Schemas>;
-declare function dumboDatabase<Schemas extends DatabaseSchemas = DatabaseSchemas>(schema: DatabaseSchemaSchemaComponent): ValidatedDatabaseSchemaComponent<Schemas>;
-declare function dumboDatabase<Schemas extends DatabaseSchemas = DatabaseSchemas>(databaseName: string, schemas: Schemas, options?: SchemaComponentOptions): ValidatedDatabaseSchemaComponent<Schemas>;
-declare function dumboDatabase<Schemas extends DatabaseSchemas = DatabaseSchemas>(databaseName: string, schema: AnyDatabaseSchemaSchemaComponent, options?: SchemaComponentOptions): ValidatedDatabaseSchemaComponent<Schemas>;
-declare namespace dumboDatabase {
-  var from: <Schemas extends DatabaseSchemas = DatabaseSchemas>(databaseName: string | undefined, schemaNames: string[]) => ValidatedDatabaseSchemaComponent<Schemas>;
-  var defaultName: string;
-}
-declare const dumboSchema: {
-  database: typeof dumboDatabase;
-  schema: typeof dumboDatabaseSchema;
-  table: <const Columns extends TableColumns = TableColumns, const TableName extends string = string, const Relationships extends TableRelationships<keyof Columns & string> = TableRelationships<keyof Columns & string>>(name: TableName, definition: {
-    columns?: Columns;
-    primaryKey?: TableColumnNames<TableSchemaComponent<Columns, TableName, Relationships>>[];
-    relationships?: Relationships;
-    indexes?: Record<string, IndexSchemaComponent>;
-  } & SchemaComponentOptions) => TableSchemaComponent<Columns, TableName, Relationships>;
-  column: <const ColumnType extends AnyColumnTypeToken | string = string | AnyColumnTypeToken, const TOptions extends SchemaComponentOptions & Omit<SQLColumnToken<ColumnType>, "name" | "type" | "sqlTokenType"> = Omit<ColumnSchemaComponentOptions<ColumnType>, "type">, const ColumnName extends string = string>(name: ColumnName, type: ColumnType, options?: TOptions) => ({
-    schemaComponentKey: `sc:dumbo:column:${ColumnName}`;
-    components: ReadonlyMap<string, SchemaComponent>;
-    migrations: ReadonlyArray<SQLMigration>;
-    addComponent: <SchemaComponentType extends SchemaComponent<string, Record<string, any>> = SchemaComponent<string, Record<string, any>>>(component: SchemaComponentType) => SchemaComponentType;
-    addMigration: (migration: SQLMigration) => void;
-  } & Readonly<{
-    columnName: ColumnName;
-  }> & {
-    sqlTokenType: "SQL_COLUMN";
-  } & Omit<{
-    name: string;
-    type: ColumnType;
-    notNull?: false;
-    unique?: boolean;
-    primaryKey: never;
-    default?: ColumnType | SQLToken;
-  }, "sqlTokenType"> & (TOptions & {
-    type: ColumnType;
-  } extends infer T ? T extends TOptions & {
-    type: ColumnType;
-  } ? T extends {
-    notNull: true;
-  } | {
-    primaryKey: true;
-  } ? {
-    notNull: true;
-  } : {
-    notNull?: false;
-  } : never : never)) | ({
-    schemaComponentKey: `sc:dumbo:column:${ColumnName}`;
-    components: ReadonlyMap<string, SchemaComponent>;
-    migrations: ReadonlyArray<SQLMigration>;
-    addComponent: <SchemaComponentType extends SchemaComponent<string, Record<string, any>> = SchemaComponent<string, Record<string, any>>>(component: SchemaComponentType) => SchemaComponentType;
-    addMigration: (migration: SQLMigration) => void;
-  } & Readonly<{
-    columnName: ColumnName;
-  }> & {
-    sqlTokenType: "SQL_COLUMN";
-  } & Omit<NullableSQLColumnTokenProps<ColumnType>, "sqlTokenType"> & (TOptions & {
-    type: ColumnType;
-  } extends infer T_1 ? T_1 extends TOptions & {
-    type: ColumnType;
-  } ? T_1 extends {
-    notNull: true;
-  } | {
-    primaryKey: true;
-  } ? {
-    notNull: true;
-  } : {
-    notNull?: false;
-  } : never : never));
-  index: (name: string, columnNames: string[], options?: {
-    unique?: boolean;
-  } & SchemaComponentOptions) => IndexSchemaComponent;
-};
-//#endregion
 //#region src/core/locks/databaseLock.d.ts
 type DatabaseLockOptions = {
   lockId: number;
@@ -1524,6 +1606,28 @@ type CreateConnectionPoolOptions<ConnectionType extends AnyConnection> = Pick<Co
 };
 declare const createConnectionPool: <ConnectionType extends AnyConnection>(pool: CreateConnectionPoolOptions<ConnectionType>) => ConnectionPool<ConnectionType>;
 //#endregion
+//#region src/core/testing/typesTesting.d.ts
+type Expect<T extends true> = T;
+type Equals<X, Y> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;
+type IsError<T> = T extends AnyTypeValidationError ? true : false;
+type IsOK<T> = T extends TypeValidationSuccess ? true : false;
+//#endregion
+//#region src/core/tracing/printing/color.d.ts
+declare const color: {
+  level: 0 | 1;
+  hex: (value: string) => (text: string) => string;
+  red: (value: string) => string;
+  green: (value: string) => string;
+  blue: (value: string) => string;
+  cyan: (value: string) => string;
+  yellow: (value: string) => string;
+};
+//#endregion
+//#region src/core/tracing/printing/pretty.d.ts
+declare const prettyJson: (obj: unknown, options?: {
+  handleMultiline?: boolean;
+}) => string;
+//#endregion
 //#region src/core/tracing/index.d.ts
 declare const tracer: {
   (): void;
@@ -1553,13 +1657,6 @@ type DumboConnectionOptions<DatabaseDriver extends AnyDumboDatabaseDriver = AnyD
   driver?: DatabaseDriver;
   driverType?: DatabaseDriver['driverType'];
 } & Omit<Options, 'driver' | 'driverType' | 'connectionString'> : never : never;
-declare module './sql' {
-  namespace SQL {
-    const columnN: typeof dumboSchema.column & {
-      type: typeof SQLColumnTypeTokensFactory;
-    };
-  }
-}
 //#endregion
 //#region src/storage/all/connections/connectionString.d.ts
 type DatabaseConnectionString<DatabaseTypeName extends DatabaseType = DatabaseType, Format extends string = string> = Format & {
@@ -1581,5 +1678,5 @@ declare function dumbo<DatabaseDriver extends AnyDumboDatabaseDriver = AnyDumboD
   driver?: never;
 }): ExtractDumboTypeFromDriver<DatabaseDriver>;
 //#endregion
-export { transactionFactoryWithAsyncAmbientConnection as $, JSONCodecOptions as $a, mapDefaultSQLColumnProcessors as $i, ValidateTable as $n, NormalizeColumnPath as $r, executeInNewConnection as $t, CreateAmbientConnectionOptions as A, SQLColumnToken as Aa, mapSchemaComponentsOfType as Ai, CollectReferencesErrors as An, InferDatabaseSchemas as Ar, DatabaseLockOptions as At, WithConnectionOptions as B, SQLArrayMode as Ba, describeSQL as Bi, SchemaTablesWithSingle as Bn, AllColumnTypesInSchema as Br, getDefaultDatabase as Bt, createConnectionPool as C, JSONValueType as Ca, ExtractAdditionalData as Ci, NotNullViolationError as Cn, InferTableSchemaComponentTypes as Cr, combineMigrations as Ct, Connection as D, JavaScriptValueTypeToNameMap as Da, filterSchemaComponentsOfType as Di, TransientDatabaseError as Dn, TableURNType as Dr, AcquireDatabaseLockMode as Dt, AnyConnection as E, JavaScriptValueTypeName as Ea, SchemaComponentType as Ei, SystemError as En, TableURN as Er, runSQLMigrations as Et, InferDriverTypeFromConnection as F, TimestamptzToken as Fa, sqlMigration as Fi, DatabaseSchemasWithSingle as Fn, TableRowType as Fr, DatabaseCapabilities as Ft, AnyDatabaseTransaction as G, SQLLiteral as Ga, SQL as Gi, ValidateDatabaseSchemas as Gn, ColumnPath as Gr, DbSQLExecutor as Gt, createConnection as H, SQLDefaultTokensTypes as Ha, getFormatter as Hi, ValidateColumnTypeMatch as Hn, AnyTableRelationshipDefinition as Hr, resolveDatabaseMetadata as Ht, InferTransactionFromConnection as I, VarcharToken as Ia, FormatContext as Ii, NoError as In, Writable as Ir, DatabaseMetadata as It, InferTransactionOptionsFromTransaction as J, ParametrizedSQL as Ja, ExpandArrayProcessor as Ji, ValidateReferences as Jn, ExtractColumnNames as Jr, SQLExecutor as Jt, DatabaseTransaction as K, SQLPlain as Ka, isSQL as Ki, ValidateDatabaseSchemasWithMessages as Kn, ColumnPathToReference as Kr, DbSQLExecutorOptions as Kt, InferTransactionOptionsFromConnection as L, AnySQLToken as La, FormatSQLOptions as Li, RelationshipColumnsMismatchError as Ln, AllColumnReferences as Lr, DumboDatabaseMetadataRegistry as Lt, CreateSingletonConnectionOptions as M, SQLColumnTypeTokensFactory as Ma, MigrationRecord as Mi, ColumnReferenceError as Mn, InferTableRow as Mr, ReleaseDatabaseLockOptions as Mt, CreateTransientConnectionOptions as N, SerialToken as Na, MigrationStyle as Ni, ColumnReferenceExistanceError as Nn, TableColumnNames as Nr, defaultDatabaseLockOptions as Nt, ConnectionFactory as O, NotNullableSQLColumnTokenProps as Oa, findSchemaComponentsOfType as Oi, UniqueConstraintError as On, tableSchemaComponent as Or, AcquireDatabaseLockOptions as Ot, InferDbClientFromConnection as P, TimestampToken as Pa, SQLMigration as Pi, ColumnReferenceTypeMismatchError as Pn, TableColumnType as Pr, dumboSchema as Pt, transactionFactoryWithAmbientConnection as Q, JSONCodec as Qa, DefaultSQLColumnProcessors as Qi, ValidateSchemaTables as Qn, LookupColumnType as Qr, executeInAmbientConnection as Qt, InitTransaction as R, ExtractSQLTokenType as Ra, SQLFormatter as Ri, RelationshipReferencesLengthMismatchError as Rn, AllColumnReferencesInSchema as Rr, dumboDatabaseMetadataRegistry as Rt, createBoundedConnectionPool as S, JSONBToken as Sa, DumboSchemaComponentType as Si, LockNotAvailableError as Sn, InferTableSchemaComponentColumns as Sr, RunSQLMigrationsResult as St, createSingletonConnectionPool as T, JavaScriptValueType as Ta, SchemaComponentOptions as Ti, SerializationError as Tn, TableSchemaComponent as Tr, registerDefaultMigratorOptions as Tt, createSingletonConnection as U, SQLIdentifier as Ua, registerFormatter as Ui, ValidateColumnsMatch as Un, AnyTableRelationshipDefinitionWithColumns as Ur, BatchCommandNoChangesError as Ut, createAmbientConnection as V, SQLDefaultTokens as Va, formatSQL as Vi, ValidateColumnReference as Vn, AnyRelationshipDefinition as Vr, getDefaultDatabaseAsync as Vt, createTransientConnection as W, SQLIn as Wa, RawSQL as Wi, ValidateDatabaseSchema as Wn, ColumnName$1 as Wr, BatchSQLCommandOptions as Wt, WithDatabaseTransactionFactory as X, SerializationCodec as Xa, FormatIdentifierProcessor as Xi, ValidateRelationshipColumns as Xn, ExtractSchemaNames as Xr, SQLQueryResultColumnMapping as Xt, TransactionResult as Y, ParametrizedSQLBuilder as Ya, ExpandSQLInProcessor as Yi, ValidateRelationship as Yn, ExtractColumnTypeName as Yr, SQLQueryOptions as Yt, executeInTransaction as Z, Serializer as Za, MapLiteralProcessor as Zi, ValidateRelationshipLength as Zn, ExtractTableNames as Zr, WithSQLExecutor as Zt, CreateConnectionPoolOptions as _, BigIntegerToken as _a, ColumnURN as _i, ExclusionViolationError as _n, DatabaseSchemaTables as _r, dumboDatabaseDriverRegistry as _t, parseConnectionString as a, SQLProcessorOptions as aa, TableColumnName as ai, sqlExecutor as an, JSONRevivers as ao, FormatTableLevel as ar, DatabaseType as at, createAlwaysNewConnectionPool as b, DefaultSQLColumnToken as ba, AnySchemaComponent as bi, IntegrityConstraintViolationError as bn, databaseSchemaSchemaComponent as br, MIGRATIONS_LOCK_ID as bt, LogLevel as c, DefaultMapSQLParamValueOptions as ca, AnyTypeValidationError as ci, QueryResult as cn, JSONSerializer as co, Join as cr, getDatabaseDriverName as ct, tracer as d, SQLValueMapper as da, IndexURN as di, CheckViolationError as dn, composeJSONRevivers as do, DatabaseSchemas as dr, AnyDumboDatabaseDriver as dt, SQLProcessorsReadonlyRegistry as ea, NormalizeReference as ei, executeInNewDbClient as en, JSONDeserializeOptions as eo, ValidateTableRelationships as er, transactionFactoryWithDbClient as et, AmbientConnectionPoolOptions as f, mapANSISQLParamPlaceholder as fa, IndexURNType as fi, ConcurrencyError as fn, jsonSerializer as fo, DatabaseURN as fr, DumboDatabaseDriver as ft, CreateBoundedConnectionPoolOptions as g, AutoIncrementSQLColumnToken as ga, ColumnSchemaComponentOptions as gi, DumboError as gn, DatabaseSchemaSchemaComponent as gr, canHandleDriverWithConnectionString as gt, CreateAlwaysNewConnectionPoolOptions as h, AnyColumnTypeToken as ha, ColumnSchemaComponent as hi, DeadlockError as hn, AnyDatabaseSchemaSchemaComponent as hr, ExtractDumboTypeFromDriver as ht, DatabaseConnectionString as i, SQLProcessorContext as ia, SchemaColumnName as ii, mapSQLQueryResult as in, JSONReviverContext as io, FormatSingleError as ir, DatabaseDriverTypeParts as it, CreateConnectionOptions as j, SQLColumnTypeTokens as ja, schemaComponent as ji, CollectRelationshipErrors as jn, InferSchemaTables as jr, NoDatabaseLock as jt, ConnectionOptions as k, NullableSQLColumnTokenProps as ka, isSchemaComponentOfType as ki, schemaComponentURN as kn, InferColumnType as kr, DatabaseLock as kt, LogStyle as l, MapSQLParamValue as la, TypeValidationSuccess as li, QueryResultRow as ln, JSONSerializerOptions as lo, AnyDatabaseSchemaComponent as lr, getDatabaseType as lt, ConnectionPoolFactory as m, mapSQLParamValue as ma, AnyColumnSchemaComponent as mi, DataError as mn, databaseSchemaComponent as mr, ExtractDumboDatabaseDriverOptions as mt, sqliteMetadata as n, AnySQLProcessor as na, RelationshipDefinition as ni, mapColumnToDate as nn, JSONReplacers as no, FormatRelationshipBlock as nr, DatabaseDriverName as nt, Dumbo as o, ANSISQLIdentifierQuote as oa, TableRelationships as oi, sqlExecutorInAmbientConnection as on, JSONSerializationOptions as oo, FormatValidationErrors as or, InferDriverDatabaseType as ot, ConnectionPool as p, mapSQLIdentifier as pa, indexSchemaComponent as pi, ConnectionError as pn, DbClientSetup as po, DatabaseURNType as pr, DumboDatabaseDriverRegistry as pt, DatabaseTransactionOptions as q, SQLToken as qa, defaultProcessorsRegistry as qi, ValidateReference as qn, ColumnReference as qr, SQLCommandOptions as qt, postgreSQLMetadata as r, SQLProcessor as ra, RelationshipType as ri, mapColumnToJSON as rn, JSONReviver as ro, FormatSchemaLevel as rr, DatabaseDriverType as rt, DumboConnectionOptions as s, ANSISQLParamPlaceholder as sa, relationship as si, sqlExecutorInNewConnection as sn, JSONSerializeOptions as so, IndentErrors as sr, fromDatabaseDriverType as st, dumbo as t, SQLProcessorsRegistry as ta, ParseReferencePath as ti, mapColumnToBigint as tn, JSONReplacer as to, FormatDatabaseValidationErrors as tr, transactionFactoryWithNewConnection as tt, LogType as u, MapSQLParamValueOptions as ua, IndexSchemaComponent as ui, AdminShutdownError as un, composeJSONReplacers as uo, DatabaseSchemaComponent as ur, toDatabaseDriverType as ut, SingletonClientConnectionPoolOptions as v, BigSerialToken as va, ColumnURNType as vi, ForeignKeyViolationError as vn, DatabaseSchemaURN as vr, SchemaComponentMigrator as vt, createSingletonClientConnectionPool as w, JSONValueTypeName as wa, SchemaComponent as wi, QueryCanceledError as wn, TableColumns as wr, getDefaultMigratorOptionsFromRegistry as wt, createAmbientConnectionPool as x, IntegerToken as xa, AnySchemaComponentOfType as xi, InvalidOperationError as xn, AnyTableSchemaComponent as xr, MigratorOptions as xt, SingletonConnectionPoolOptions as y, ColumnTypeToken as ya, columnSchemaComponent as yi, InsufficientResourcesError as yn, DatabaseSchemaURNType as yr, migrationTableSchemaComponent as yt, WithConnectionFactory as z, SQLArray as za, SQLFormatterOptions as zi, RelationshipValidationError as zn, AllColumnTypes as zr, getDatabaseMetadata as zt };
-//# sourceMappingURL=index-BDSQvDH2.d.cts.map
+export { DatabaseTransactionOptions as $, SerialToken as $a, ExtractAdditionalData as $i, RelationshipColumnsMismatchError as $n, AllColumnReferences as $r, SQLExecutor as $t, createSingletonClientConnectionPool as A, SQLValueMapper as Aa, ColumnSchemaComponentOptions as Ai, DataError as An, composeJSONReplacers as Ao, databaseSchemaComponent as Ar, getDefaultMigratorOptionsFromRegistry as At, InferDbClientFromConnection as B, DefaultSQLColumnToken as Ba, formatSQL as Bi, QueryCanceledError as Bn, TableColumns as Br, DatabaseCapabilities as Bt, CreateConnectionPoolOptions as C, SQLProcessorContext as Ca, relationship as Ci, toCamelCase as Cn, JSONReviver as Co, IndentErrors as Cr, dumboDatabaseDriverRegistry as Ct, createAmbientConnectionPool as D, DefaultMapSQLParamValueOptions as Da, indexSchemaComponent as Di, CheckViolationError as Dn, JSONSerializeOptions as Do, DatabaseSchemas as Dr, MigratorOptions as Dt, createAlwaysNewConnectionPool as E, ANSISQLParamPlaceholder as Ea, IndexURNType as Ei, AdminShutdownError as En, JSONSerializationOptions as Eo, DatabaseSchemaComponent as Er, MIGRATIONS_LOCK_ID as Et, ConnectionOptions as F, AnyColumnTypeToken as Fa, FormatContext as Fi, InsufficientResourcesError as Fn, DatabaseSchemaURNType as Fr, DatabaseLock as Ft, WithConnectionFactory as G, JavaScriptValueType as Ga, SQLTag as Gi, schemaComponentURN as Gn, InferColumnType as Gr, getDefaultDatabase as Gt, InferTransactionFromConnection as H, JSONBToken as Ha, registerFormatter as Hi, SystemError as Hn, TableURN as Hr, DumboDatabaseMetadataRegistry as Ht, CreateAmbientConnectionOptions as I, AutoIncrementSQLColumnToken as Ia, FormatSQLOptions as Ii, IntegrityConstraintViolationError as In, databaseSchemaSchemaComponent as Ir, DatabaseLockOptions as It, createConnection as J, NotNullableSQLColumnTokenProps as Ja, isTokenizedSQL as Ji, ColumnReferenceError as Jn, InferTableRow as Jr, BatchCommandNoChangesError as Jt, WithConnectionOptions as K, JavaScriptValueTypeName as Ka, isSQL as Ki, CollectReferencesErrors as Kn, InferDatabaseSchemas as Kr, getDefaultDatabaseAsync as Kt, CreateConnectionOptions as L, BigIntegerToken as La, SQLFormatter as Li, InvalidOperationError as Ln, AnyTableSchemaComponent as Lr, NoDatabaseLock as Lt, AnyConnection as M, mapSQLIdentifier as Ma, ColumnURNType as Mi, DumboError as Mn, jsonSerializer as Mo, DatabaseSchemaSchemaComponent as Mr, runSQLMigrations as Mt, Connection as N, mapSQLParamValue as Na, columnSchemaComponent as Ni, ExclusionViolationError as Nn, DbClientSetup as No, DatabaseSchemaTables as Nr, AcquireDatabaseLockMode as Nt, createBoundedConnectionPool as O, MapSQLParamValue as Oa, AnyColumnSchemaComponent as Oi, ConcurrencyError as On, JSONSerializer as Oo, DatabaseURN as Or, RunSQLMigrationsResult as Ot, ConnectionFactory as P, ansiSqlReservedMap as Pa, JSONParam as Pi, ForeignKeyViolationError as Pn, DatabaseSchemaURN as Pr, AcquireDatabaseLockOptions as Pt, DatabaseTransaction as Q, SQLColumnTypeTokensFactory as Qa, DumboSchemaComponentType as Qi, NoError as Qn, Writable as Qr, SQLCommandOptions as Qt, CreateSingletonConnectionOptions as R, BigSerialToken as Ra, SQLFormatterOptions as Ri, LockNotAvailableError as Rn, InferTableSchemaComponentColumns as Rr, ReleaseDatabaseLockOptions as Rt, CreateBoundedConnectionPoolOptions as S, SQLProcessor as Sa, TableRelationships as Si, mapToCamelCase as Sn, JSONReplacers as So, FormatValidationErrors as Sr, canHandleDriverWithConnectionString as St, SingletonConnectionPoolOptions as T, ANSISQLIdentifierQuote as Ta, IndexURN as Ti, QueryResultRow as Tn, JSONRevivers as To, AnyDatabaseSchemaComponent as Tr, migrationTableSchemaComponent as Tt, InferTransactionOptionsFromConnection as U, JSONValueType as Ua, RawSQL as Ui, TransientDatabaseError as Un, TableURNType as Ur, dumboDatabaseMetadataRegistry as Ut, InferDriverTypeFromConnection as V, IntegerToken as Va, getFormatter as Vi, SerializationError as Vn, TableSchemaComponent as Vr, DatabaseMetadata as Vt, InitTransaction as W, JSONValueTypeName as Wa, SQL as Wi, UniqueConstraintError as Wn, tableSchemaComponent as Wr, getDatabaseMetadata as Wt, createTransientConnection as X, SQLColumnToken as Xa, AnySchemaComponent as Xi, ColumnReferenceTypeMismatchError as Xn, TableColumnType as Xr, DbSQLExecutor as Xt, createSingletonConnection as Y, NullableSQLColumnTokenProps as Ya, dumboSchema as Yi, ColumnReferenceExistanceError as Yn, TableColumnNames as Yr, BatchSQLCommandOptions as Yt, AnyDatabaseTransaction as Z, SQLColumnTypeTokens as Za, AnySchemaComponentOfType as Zi, DatabaseSchemasWithSingle as Zn, TableRowType as Zr, DbSQLExecutorOptions as Zt, IsOK as _, DefaultSQLColumnProcessors as _a, ParseReferencePath as _i, first as _n, Serializer as _o, FormatDatabaseValidationErrors as _r, AnyDumboDatabaseDriver as _t, parseConnectionString as a, isSchemaComponentOfType as aa, AnyTableRelationshipDefinitionWithColumns as ai, executeInNewDbClient as an, SQLArray as ao, ValidateColumnsMatch as ar, transactionFactoryWithAsyncAmbientConnection as at, ConnectionPoolFactory as b, SQLProcessorsRegistry as ba, SchemaColumnName as bi, singleOrNull as bn, JSONDeserializeOptions as bo, FormatSingleError as br, ExtractDumboDatabaseDriverOptions as bt, LogLevel as c, MigrationRecord as ca, ColumnPathToReference as ci, mapColumnToJSON as cn, SQLDefaultTokensTypes as co, ValidateDatabaseSchemasWithMessages as cr, DatabaseDriverName as ct, tracer as d, sqlMigration as da, ExtractColumnTypeName as di, sqlExecutorInAmbientConnection as dn, SQLLiteral as do, ValidateRelationship as dr, DatabaseType as dt, SchemaComponent as ea, AllColumnReferencesInSchema as ei, SQLQueryOptions as en, TimestampToken as eo, RelationshipReferencesLengthMismatchError as er, InferTransactionOptionsFromTransaction as et, prettyJson as f, defaultProcessorsRegistry as fa, ExtractSchemaNames as fi, sqlExecutorInNewConnection as fn, SQLPlain as fo, ValidateRelationshipColumns as fr, InferDriverDatabaseType as ft, IsError as g, MapLiteralProcessor as ga, NormalizeReference as gi, exists as gn, SerializationCodec as go, ValidateTableRelationships as gr, toDatabaseDriverType as gt, Expect as h, FormatIdentifierProcessor as ha, NormalizeColumnPath as hi, count as hn, ParametrizedSQLBuilder as ho, ValidateTable as hr, getDatabaseType as ht, DatabaseConnectionString as i, findSchemaComponentsOfType as ia, AnyTableRelationshipDefinition as ii, executeInNewConnection as in, ExtractSQLTokenType as io, ValidateColumnTypeMatch as ir, transactionFactoryWithAmbientConnection as it, createSingletonConnectionPool as j, mapANSISQLParamPlaceholder as ja, ColumnURN as ji, DeadlockError as jn, composeJSONRevivers as jo, AnyDatabaseSchemaSchemaComponent as jr, registerDefaultMigratorOptions as jt, createConnectionPool as k, MapSQLParamValueOptions as ka, ColumnSchemaComponent as ki, ConnectionError as kn, JSONSerializerOptions as ko, DatabaseURNType as kr, combineMigrations as kt, LogStyle as l, MigrationStyle as la, ColumnReference as li, mapSQLQueryResult as ln, SQLIdentifier as lo, ValidateReference as lr, DatabaseDriverType as lt, Equals as m, ExpandSQLInProcessor as ma, LookupColumnType as mi, ExistsSQLQueryResult as mn, ParametrizedSQL as mo, ValidateSchemaTables as mr, getDatabaseDriverName as mt, sqliteMetadata as n, SchemaComponentType as na, AllColumnTypesInSchema as ni, WithSQLExecutor as nn, VarcharToken as no, SchemaTablesWithSingle as nr, WithDatabaseTransactionFactory as nt, Dumbo as o, mapSchemaComponentsOfType as oa, ColumnName$1 as oi, mapColumnToBigint as on, SQLArrayMode as oo, ValidateDatabaseSchema as or, transactionFactoryWithDbClient as ot, color as p, ExpandArrayProcessor as pa, ExtractTableNames as pi, CountSQLQueryResult as pn, SQLToken as po, ValidateRelationshipLength as pr, fromDatabaseDriverType as pt, createAmbientConnection as q, JavaScriptValueTypeToNameMap as qa, TokenizedSQL as qi, CollectRelationshipErrors as qn, InferSchemaTables as qr, resolveDatabaseMetadata as qt, postgreSQLMetadata as r, filterSchemaComponentsOfType as ra, AnyRelationshipDefinition as ri, executeInAmbientConnection as rn, AnySQLToken as ro, ValidateColumnReference as rr, executeInTransaction as rt, DumboConnectionOptions as s, schemaComponent as sa, ColumnPath as si, mapColumnToDate as sn, SQLDefaultTokens as so, ValidateDatabaseSchemas as sr, transactionFactoryWithNewConnection as st, dumbo as t, SchemaComponentOptions as ta, AllColumnTypes as ti, SQLQueryResultColumnMapping as tn, TimestamptzToken as to, RelationshipValidationError as tr, TransactionResult as tt, LogType as u, SQLMigration as ua, ExtractColumnNames as ui, sqlExecutor as un, SQLIn as uo, ValidateReferences as ur, DatabaseDriverTypeParts as ut, AmbientConnectionPoolOptions as v, mapDefaultSQLColumnProcessors as va, RelationshipDefinition as vi, firstOrNull as vn, JSONCodec as vo, FormatRelationshipBlock as vr, DumboDatabaseDriver as vt, SingletonClientConnectionPoolOptions as w, SQLProcessorOptions as wa, IndexSchemaComponent as wi, QueryResult as wn, JSONReviverContext as wo, Join as wr, SchemaComponentMigrator as wt, CreateAlwaysNewConnectionPoolOptions as x, AnySQLProcessor as xa, TableColumnName as xi, mapRows as xn, JSONReplacer as xo, FormatTableLevel as xr, ExtractDumboTypeFromDriver as xt, ConnectionPool as y, SQLProcessorsReadonlyRegistry as ya, RelationshipType as yi, single as yn, JSONCodecOptions as yo, FormatSchemaLevel as yr, DumboDatabaseDriverRegistry as yt, CreateTransientConnectionOptions as z, ColumnTypeToken as za, describeSQL as zi, NotNullViolationError as zn, InferTableSchemaComponentTypes as zr, defaultDatabaseLockOptions as zt };
+//# sourceMappingURL=index-CfH0u2y_.d.cts.map

package/dist/{index-BgFHGsuP.d.ts → index-DP9b7v4e.d.cts}

@@ -1,4 +1,5 @@
-import { D as Connection, E as AnyConnection, F as InferDriverTypeFromConnection, Gt as DbSQLExecutor, I as InferTransactionFromConnection, Jt as SQLExecutor, K as DatabaseTransaction, P as InferDbClientFromConnection, R as InitTransaction, Ri as SQLFormatter, Wt as BatchSQLCommandOptions, co as JSONSerializer, gn as DumboError, i as DatabaseConnectionString, k as ConnectionOptions, p as ConnectionPool, q as DatabaseTransactionOptions, qt as SQLCommandOptions, rt as DatabaseDriverType, xt as MigratorOptions } from "./index-zkszkJqP.js";
+import { $ as DatabaseTransactionOptions, $t as SQLExecutor, B as InferDbClientFromConnection, Dt as MigratorOptions, F as ConnectionOptions, H as InferTransactionFromConnection, Li as SQLFormatter, M as AnyConnection, Mn as DumboError, N as Connection, Oo as JSONSerializer, Q as DatabaseTransaction, Qt as SQLCommandOptions, V as InferDriverTypeFromConnection, W as InitTransaction, Xt as DbSQLExecutor, Yt as BatchSQLCommandOptions, fo as SQLPlain, i as DatabaseConnectionString, lt as DatabaseDriverType, y as ConnectionPool } from "./index-CfH0u2y_.cjs";
+
 //#region src/storage/sqlite/core/execute/execute.d.ts
 type SQLiteErrorMapper = (error: unknown) => DumboError;
 declare const sqliteExecute: <Result = void>(database: SQLiteClient, handle: (client: SQLiteClient) => Promise<Result>) => Promise<Result>;
@@ -176,11 +177,16 @@ declare const tableExists: (execute: SQLExecutor, tableName: string) => Promise<
 //#region src/storage/sqlite/core/sql/formatter/index.d.ts
 declare const sqliteFormatter: SQLFormatter;
 //#endregion
+//#region src/storage/sqlite/core/sql/json.d.ts
+declare const SQLiteJSON: {
+  readonly path: (path: string) => SQLPlain;
+};
+//#endregion
 //#region src/storage/sqlite/core/index.d.ts
 type SQLiteDatabaseName = 'SQLite';
 declare const SQLiteDatabaseName = "SQLite";
 type SQLiteDriverType<DriverName extends string = string> = DatabaseDriverType<SQLiteDatabaseName, DriverName>;
 type SQLiteDatabaseType = 'SQLite';
 //#endregion
-export { SQLitePragmaOptions as $, SQLiteClientConnectionDefinitionOptions as A, SQLiteParameters as B, AnySQLiteConnection as C, InMemorySQLiteDatabase as D, DEFAULT_SQLITE_PRAGMA_OPTIONS as E, SQLiteConnection as F, TransactionNestingCounter as G, SQLitePoolClientConnection as H, SQLiteConnectionDefinitionOptions as I, sqliteClientConnection as J, isSQLiteError as K, SQLiteConnectionFactory as L, SQLiteClientOptions as M, SQLiteClientOrPoolClient as N, SQLiteClient as O, SQLiteCommandOptions as P, SQLiteConnectionString as Q, SQLiteConnectionOptions as R, AnySQLiteClientConnection as S, BatchSQLiteCommandOptions as T, SQLitePoolConnectionDefinitionOptions as U, SQLitePoolClient as V, SqliteAmbientClientConnectionOptions as W, sqlitePoolClientConnection as X, sqliteConnection as Y, transactionNestingCounter as Z, sqliteAmbientConnectionPool as _, defaultSQLiteDatabase as a, SQLiteErrorMapper as at, toSqlitePoolOptions as b, SQLiteAlwaysNewConnectionPool as c, sqliteSQLExecutor as ct, SQLitePool as d, parsePragmasFromConnectionString as et, SQLitePoolFactoryOptions as f, sqliteAlwaysNewConnectionPool as g, isInMemoryDatabase as h, sqliteFormatter as i, sqliteTransaction as it, SQLiteClientFactory as j, SQLiteClientConnection as k, SQLiteAmbientConnectionPool as l, SQLiteSingletonConnectionPool as m, SQLiteDatabaseType as n, SQLiteTransactionMode as nt, tableExists as o, SQLiteSQLExecutor as ot, SQLitePoolOptions as p, sqliteAmbientClientConnection as q, SQLiteDriverType as r, SQLiteTransactionOptions as rt, DefaultSQLiteMigratorOptions as s, sqliteExecute as st, SQLiteDatabaseName as t, SQLiteTransaction as tt, SQLiteFileNameOrConnectionString as u, sqlitePool as v, AnySQLitePoolClientConnection as w, mapSqliteError as x, sqliteSingletonConnectionPool as y, SQLiteError as z };
-//# sourceMappingURL=index-BgFHGsuP.d.ts.map
+export { SQLiteConnectionString as $, SQLiteClientConnection as A, SQLiteError as B, AnySQLiteClientConnection as C, DEFAULT_SQLITE_PRAGMA_OPTIONS as D, BatchSQLiteCommandOptions as E, SQLiteCommandOptions as F, SqliteAmbientClientConnectionOptions as G, SQLitePoolClient as H, SQLiteConnection as I, sqliteAmbientClientConnection as J, TransactionNestingCounter as K, SQLiteConnectionDefinitionOptions as L, SQLiteClientFactory as M, SQLiteClientOptions as N, InMemorySQLiteDatabase as O, SQLiteClientOrPoolClient as P, transactionNestingCounter as Q, SQLiteConnectionFactory as R, mapSqliteError as S, AnySQLitePoolClientConnection as T, SQLitePoolClientConnection as U, SQLiteParameters as V, SQLitePoolConnectionDefinitionOptions as W, sqliteConnection as X, sqliteClientConnection as Y, sqlitePoolClientConnection as Z, sqliteAlwaysNewConnectionPool as _, sqliteFormatter as a, sqliteTransaction as at, sqliteSingletonConnectionPool as b, DefaultSQLiteMigratorOptions as c, sqliteExecute as ct, SQLiteFileNameOrConnectionString as d, SQLitePragmaOptions as et, SQLitePool as f, isInMemoryDatabase as g, SQLiteSingletonConnectionPool as h, SQLiteJSON as i, SQLiteTransactionOptions as it, SQLiteClientConnectionDefinitionOptions as j, SQLiteClient as k, SQLiteAlwaysNewConnectionPool as l, sqliteSQLExecutor as lt, SQLitePoolOptions as m, SQLiteDatabaseType as n, SQLiteTransaction as nt, defaultSQLiteDatabase as o, SQLiteErrorMapper as ot, SQLitePoolFactoryOptions as p, isSQLiteError as q, SQLiteDriverType as r, SQLiteTransactionMode as rt, tableExists as s, SQLiteSQLExecutor as st, SQLiteDatabaseName as t, parsePragmasFromConnectionString as tt, SQLiteAmbientConnectionPool as u, sqliteAmbientConnectionPool as v, AnySQLiteConnection as w, toSqlitePoolOptions as x, sqlitePool as y, SQLiteConnectionOptions as z };
+//# sourceMappingURL=index-DP9b7v4e.d.cts.map