effect-qb 0.14.0 → 0.15.0

package/src/internal/column.ts

@@ -1,7 +1,7 @@
 import type * as Brand from "effect/Brand"
 import * as Schema from "effect/Schema"
 
-import * as Expression from "./expression.js"
+import * as Expression from "./scalar.js"
 import type { CanCastDbType } from "./datatypes/lookup.js"
 import {
   BigIntStringSchema,
@@ -18,7 +18,7 @@ import {
   type DecimalString,
   type LocalDateTimeString,
   type BigIntString
-} from "./runtime-value.js"
+} from "./runtime/value.js"
 import {
   type AnyBoundColumn,
   type AnyColumnDefinition,
@@ -48,8 +48,8 @@ type ReferentialAction = "noAction" | "restrict" | "cascade" | "setNull" | "setD
 type CompatibleReference<
   Self extends AnyColumnDefinition,
   Target extends AnyBoundColumn
-> = [BaseSelectType<Self>] extends [BaseSelectType<Target>]
-  ? [BaseSelectType<Target>] extends [BaseSelectType<Self>]
+> = [Self[typeof ColumnTypeId]["dbType"]] extends [Target[typeof ColumnTypeId]["dbType"]]
+  ? [Target[typeof ColumnTypeId]["dbType"]] extends [Self[typeof ColumnTypeId]["dbType"]]
     ? Self
     : never
   : never
@@ -237,7 +237,6 @@ type ColumnWithSchema<
   IsPrimaryKey<Column>,
   Column[typeof ColumnTypeId]["unique"],
   ReferencesOf<Column>,
-  Column[typeof ColumnTypeId]["source"],
   Column[typeof ColumnTypeId]["dependencies"]
 > & PreserveBrand<Column>
 
@@ -259,9 +258,9 @@ type PreserveBrand<Column extends AnyColumnDefinition> = Column["metadata"]["bra
   ? BrandMetadata<Column>
   : {}
 
-type BrandedColumn<
+type BrandedBoundColumn<
   Column extends AnyBoundColumn
-> = ColumnDefinition<
+> = BoundColumn<
   BrandedValue<SelectType<Column>, BrandNameOf<Column>>,
   BrandedValue<InsertType<Column>, BrandNameOf<Column>>,
   BrandedValue<UpdateType<Column>, BrandNameOf<Column>>,
@@ -272,8 +271,9 @@ type BrandedColumn<
   IsPrimaryKey<Column>,
   Column[typeof ColumnTypeId]["unique"],
   ReferencesOf<Column>,
-  Column[typeof ColumnTypeId]["source"],
-  Column[typeof ColumnTypeId]["dependencies"]
+  Column[typeof BoundColumnTypeId]["tableName"],
+  Column[typeof BoundColumnTypeId]["columnName"],
+  Column[typeof BoundColumnTypeId]["baseTableName"]
 > & BrandMetadata<Column>
 
 type BrandMarkedColumn<
@@ -289,7 +289,6 @@ type BrandMarkedColumn<
   IsPrimaryKey<Column>,
   Column[typeof ColumnTypeId]["unique"],
   ReferencesOf<Column>,
-  Column[typeof ColumnTypeId]["source"],
   Column[typeof ColumnTypeId]["dependencies"]
 > & BrandMetadata<Column>
 
@@ -346,7 +345,6 @@ type ArrayColumn<
   IsPrimaryKey<Column>,
   Column[typeof ColumnTypeId]["unique"],
   ReferencesOf<Column>,
-  Column[typeof ColumnTypeId]["source"],
   Column[typeof ColumnTypeId]["dependencies"]
 > & PreserveBrand<Column>
 
@@ -429,288 +427,6 @@ type ColumnModule<
   >
 }
 
-type PostgresColumnModule = ColumnModule<
-  "postgres",
-  "uuid",
-  "text",
-  "int4",
-  "numeric",
-  "bool",
-  "date",
-  "timestamp",
-  "json"
-> & {
-  readonly int2: () => ColumnDefinition<number, number, number, Expression.DbType.Base<"postgres", "int2">, false, false, false, false, false, undefined>
-  readonly int8: () => ColumnDefinition<BigIntString, BigIntString, BigIntString, Expression.DbType.Base<"postgres", "int8">, false, false, false, false, false, undefined>
-  readonly float4: () => ColumnDefinition<number, number, number, Expression.DbType.Base<"postgres", "float4">, false, false, false, false, false, undefined>
-  readonly float8: () => ColumnDefinition<number, number, number, Expression.DbType.Base<"postgres", "float8">, false, false, false, false, false, undefined>
-  readonly char: (length?: number) => ColumnDefinition<string, string, string, Expression.DbType.Base<"postgres", "char">, false, false, false, false, false, undefined>
-  readonly varchar: (length?: number) => ColumnDefinition<string, string, string, Expression.DbType.Base<"postgres", "varchar">, false, false, false, false, false, undefined>
-  readonly time: () => ColumnDefinition<LocalTimeString, LocalTimeString, LocalTimeString, Expression.DbType.Base<"postgres", "time">, false, false, false, false, false, undefined>
-  readonly timetz: () => ColumnDefinition<OffsetTimeString, OffsetTimeString, OffsetTimeString, Expression.DbType.Base<"postgres", "timetz">, false, false, false, false, false, undefined>
-  readonly timestamptz: () => ColumnDefinition<InstantString, InstantString, InstantString, Expression.DbType.Base<"postgres", "timestamptz">, false, false, false, false, false, undefined>
-  readonly interval: () => ColumnDefinition<string, string, string, Expression.DbType.Base<"postgres", "interval">, false, false, false, false, false, undefined>
-  readonly bytea: () => ColumnDefinition<Uint8Array, Uint8Array, Uint8Array, Expression.DbType.Base<"postgres", "bytea">, false, false, false, false, false, undefined>
-  readonly name: () => ColumnDefinition<string, string, string, Expression.DbType.Base<"postgres", "name">, false, false, false, false, false, undefined>
-  readonly oid: () => ColumnDefinition<number, number, number, Expression.DbType.Base<"postgres", "oid">, false, false, false, false, false, undefined>
-  readonly regclass: () => ColumnDefinition<string, string, string, Expression.DbType.Base<"postgres", "regclass">, false, false, false, false, false, undefined>
-  readonly bit: () => ColumnDefinition<string, string, string, Expression.DbType.Base<"postgres", "bit">, false, false, false, false, false, undefined>
-  readonly varbit: () => ColumnDefinition<string, string, string, Expression.DbType.Base<"postgres", "varbit">, false, false, false, false, false, undefined>
-  readonly xml: () => ColumnDefinition<string, string, string, Expression.DbType.Base<"postgres", "xml">, false, false, false, false, false, undefined>
-  readonly pg_lsn: () => ColumnDefinition<string, string, string, Expression.DbType.Base<"postgres", "pg_lsn">, false, false, false, false, false, undefined>
-  readonly jsonb: <SchemaType extends Schema.Schema.Any>(
-    schema: SchemaType
-  ) => ColumnDefinition<
-    Schema.Schema.Type<SchemaType>,
-    Schema.Schema.Type<SchemaType>,
-    Schema.Schema.Type<SchemaType>,
-    Expression.DbType.Json<"postgres", "jsonb">,
-    false,
-    false,
-    false,
-    false,
-    false,
-    undefined
-  >
-}
-
-const typeFactory = <Dialect extends string>(dialect: Dialect) =>
-  <Kind extends string>(kind: Kind): Expression.DbType.Base<Dialect, Kind> => ({
-    dialect,
-    kind
-  })
-
-const postgresType = typeFactory("postgres")
-
-const renderNumericDdlType = (
-  kind: string,
-  options?: NumericOptions
-): string | undefined => {
-  if (options === undefined || options.precision === undefined) {
-    return undefined
-  }
-  return options.scale === undefined
-    ? `${kind}(${options.precision})`
-    : `${kind}(${options.precision},${options.scale})`
-}
-
-const makeColumnModule = <
-  Dialect extends string,
-  UuidKind extends string,
-  TextKind extends string,
-  IntKind extends string,
-  NumberKind extends string,
-  BooleanKind extends string,
-  DateKind extends string,
-  TimestampKind extends string,
-  JsonKind extends string
->(
-  dialect: Dialect,
-  kinds: {
-    readonly uuid: UuidKind
-    readonly text: TextKind
-    readonly int: IntKind
-    readonly number: NumberKind
-    readonly boolean: BooleanKind
-    readonly date: DateKind
-    readonly timestamp: TimestampKind
-    readonly json: JsonKind
-  }
-): ColumnModule<Dialect, UuidKind, TextKind, IntKind, NumberKind, BooleanKind, DateKind, TimestampKind, JsonKind> => {
-  const dialectType = typeFactory(dialect)
-  return {
-    custom: <SchemaType extends Schema.Schema.Any, Db extends Expression.DbType.Any>(
-      schema: SchemaType,
-      dbType: Db
-    ) =>
-      makeColumnDefinition(schema as unknown as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>, any, any>, {
-        dbType,
-        nullable: false,
-        hasDefault: false,
-        generated: false,
-        primaryKey: false,
-        unique: false,
-        references: undefined,
-        ddlType: undefined,
-        identity: undefined
-      }),
-    uuid: () => primitive(Schema.UUID, dialectType(kinds.uuid)),
-    text: () => primitive(Schema.String, dialectType(kinds.text)),
-    int: () => primitive(Schema.Int, dialectType(kinds.int)),
-    number: (options?: NumericOptions) =>
-      makeColumnDefinition(DecimalStringSchema, {
-        dbType: dialectType(kinds.number),
-        nullable: false,
-        hasDefault: false,
-        generated: false,
-        primaryKey: false,
-        unique: false,
-        references: undefined,
-        ddlType: renderNumericDdlType(kinds.number, options),
-        identity: undefined
-      }),
-    boolean: () => primitive(Schema.Boolean, dialectType(kinds.boolean)),
-    date: () => primitive(LocalDateStringSchema, dialectType(kinds.date)),
-    timestamp: () => primitive(LocalDateTimeStringSchema, dialectType(kinds.timestamp)),
-    json: <SchemaType extends Schema.Schema.Any>(schema: SchemaType) =>
-      makeColumnDefinition(schema as unknown as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>, any, any>, {
-        dbType: {
-          ...dialectType(kinds.json),
-          variant: "json"
-        } as Expression.DbType.Json<Dialect, JsonKind>,
-        nullable: false,
-        hasDefault: false,
-        generated: false,
-        primaryKey: false,
-        unique: false,
-        references: undefined,
-        ddlType: undefined,
-        identity: undefined
-      })
-  }
-}
-
-const postgresBase = makeColumnModule("postgres", {
-  uuid: "uuid",
-  text: "text",
-  int: "int4",
-  number: "numeric",
-  boolean: "bool",
-  date: "date",
-  timestamp: "timestamp",
-  json: "json"
-})
-
-/** Postgres-specialized column constructors. */
-export const postgres: PostgresColumnModule = {
-  ...postgresBase,
-  int2: () => primitive(Schema.Int, postgresType("int2")),
-  int8: () => primitive(BigIntStringSchema, postgresType("int8")),
-  float4: () => primitive(Schema.Number, postgresType("float4")),
-  float8: () => primitive(Schema.Number, postgresType("float8")),
-  char: (length = 1) =>
-    makeColumnDefinition(Schema.String, {
-      dbType: postgresType("char"),
-      nullable: false,
-      hasDefault: false,
-      generated: false,
-      primaryKey: false,
-      unique: false,
-      references: undefined,
-      ddlType: `char(${length})`,
-      identity: undefined
-    }),
-  varchar: (length?: number) =>
-    makeColumnDefinition(Schema.String, {
-      dbType: postgresType("varchar"),
-      nullable: false,
-      hasDefault: false,
-      generated: false,
-      primaryKey: false,
-      unique: false,
-      references: undefined,
-      ddlType: length === undefined ? "varchar" : `varchar(${length})`,
-      identity: undefined
-    }),
-  time: () => primitive(LocalTimeStringSchema, postgresType("time")),
-  timetz: () => primitive(OffsetTimeStringSchema, postgresType("timetz")),
-  timestamptz: () => primitive(InstantStringSchema, postgresType("timestamptz")),
-  interval: () => primitive(Schema.String, postgresType("interval")),
-  bytea: () => primitive(Schema.Uint8ArrayFromSelf, postgresType("bytea")),
-  name: () => primitive(Schema.String, postgresType("name")),
-  oid: () => primitive(Schema.Int, postgresType("oid")),
-  regclass: () => primitive(Schema.String, postgresType("regclass")),
-  bit: () => primitive(Schema.String, postgresType("bit")),
-  varbit: () => primitive(Schema.String, postgresType("varbit")),
-  xml: () => primitive(Schema.String, postgresType("xml")),
-  pg_lsn: () => primitive(Schema.String, postgresType("pg_lsn")),
-  jsonb: <SchemaType extends Schema.Schema.Any>(schema: SchemaType) =>
-    makeColumnDefinition(schema as unknown as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>, any, any>, {
-      dbType: {
-        ...postgresType("jsonb"),
-        variant: "jsonb"
-      } as Expression.DbType.Json<"postgres", "jsonb">,
-      nullable: false,
-      hasDefault: false,
-      generated: false,
-      primaryKey: false,
-      unique: false,
-      references: undefined,
-      ddlType: undefined,
-      identity: undefined
-    })
-}
-
-/** MySQL-specialized column constructors. */
-export const mysql = makeColumnModule("mysql", {
-  uuid: "uuid",
-  text: "text",
-  int: "int",
-  number: "decimal",
-  boolean: "boolean",
-  date: "date",
-  timestamp: "timestamp",
-  json: "json"
-})
-
-/** Creates a Postgres `uuid` column. */
-export const uuid = postgres.uuid
-/** Creates a Postgres `text` column. */
-export const text = postgres.text
-/** Creates a Postgres `int4` column. */
-export const int = postgres.int
-/** Creates a Postgres `int2` column. */
-export const int2 = postgres.int2
-/** Creates a Postgres `int8` column. */
-export const int8 = postgres.int8
-/** Creates a Postgres `numeric` column decoded as `DecimalString`. */
-export const number = postgres.number
-/** Creates a Postgres `float4` column. */
-export const float4 = postgres.float4
-/** Creates a Postgres `float8` column. */
-export const float8 = postgres.float8
-/** Creates a Postgres `bool` column. */
-export const boolean = postgres.boolean
-/** Creates a Postgres `date` column decoded as `LocalDateString`. */
-export const date = postgres.date
-/** Creates a Postgres `timestamp` column decoded as `LocalDateTimeString`. */
-export const timestamp = postgres.timestamp
-/** Creates a Postgres `time` column decoded as `LocalTimeString`. */
-export const time = postgres.time
-/** Creates a Postgres `timetz` column decoded as `OffsetTimeString`. */
-export const timetz = postgres.timetz
-/** Creates a Postgres `timestamptz` column decoded as `InstantString`. */
-export const timestamptz = postgres.timestamptz
-/** Creates a Postgres `char` column. */
-export const char = postgres.char
-/** Creates a Postgres `varchar` column. */
-export const varchar = postgres.varchar
-/** Creates a Postgres `interval` column. */
-export const interval = postgres.interval
-/** Creates a Postgres `bytea` column. */
-export const bytea = postgres.bytea
-/** Creates a Postgres `name` column. */
-export const name = postgres.name
-/** Creates a Postgres `oid` column. */
-export const oid = postgres.oid
-/** Creates a Postgres `regclass` column. */
-export const regclass = postgres.regclass
-/** Creates a Postgres `bit` column. */
-export const bit = postgres.bit
-/** Creates a Postgres `varbit` column. */
-export const varbit = postgres.varbit
-/** Creates a Postgres `xml` column. */
-export const xml = postgres.xml
-/** Creates a Postgres `pg_lsn` column. */
-export const pg_lsn = postgres.pg_lsn
-
-/** Creates a Postgres `json` column backed by an arbitrary Effect schema. */
-export const json = postgres.json
-/** Creates a Postgres `jsonb` column backed by an arbitrary Effect schema. */
-export const jsonb = postgres.jsonb
-/** Creates a Postgres column backed by an arbitrary SQL type and Effect schema. */
-export const custom = postgres.custom
-
 /** Replaces a column's runtime schema while preserving its SQL type metadata. */
 export const schema = <SchemaType extends Schema.Schema.Any>(nextSchema: SchemaType) =>
   <Column extends AnyColumnDefinition>(
@@ -721,7 +437,7 @@ export const schema = <SchemaType extends Schema.Schema.Any>(nextSchema: SchemaT
     }) as ColumnWithSchema<Column, SchemaType>
 
 type BrandResult<Column extends AnyColumnDefinition> = Column extends AnyBoundColumn
-  ? BrandedColumn<Column>
+  ? BrandedBoundColumn<Column>
   : BrandMarkedColumn<Column>
 
 /** Brands a column with its `table.column` provenance. */
@@ -754,7 +470,7 @@ export const nullable = <Column extends AnyColumnDefinition>(
   mapColumn(column, {
     ...column.metadata,
     nullable: true
-  })
+  }) as NullableColumn<Column>
 
 /** Marks a column as a primary key. Primary keys are always unique and non-null. */
 export const primaryKey = <Column extends AnyColumnDefinition>(
@@ -765,7 +481,7 @@ export const primaryKey = <Column extends AnyColumnDefinition>(
     nullable: false,
     primaryKey: true,
     unique: true
-  })
+  }) as PrimaryKeyColumn<Column>
 
 type UniqueModifier = {
   <Column extends AnyColumnDefinition>(column: Column): UniqueColumn<Column>
@@ -780,7 +496,7 @@ export const unique: UniqueModifier = Object.assign(
     mapColumn(column, {
       ...column.metadata,
       unique: true
-    }),
+    }) as UniqueColumn<Column>,
   {
     options: <const Options extends ColumnUniqueOptions>(options: Options) =>
       <Column extends AnyColumnDefinition>(column: Column): UniqueColumn<Column> =>
@@ -788,7 +504,7 @@ export const unique: UniqueModifier = Object.assign(
           ...column.metadata,
           unique: true,
           uniqueConstraint: options
-        })
+        }) as UniqueColumn<Column>
   }
 )
 
@@ -803,7 +519,7 @@ export const default_ = <Value extends DdlExpression>(value: Value) =>
       defaultValue: value,
       generatedValue: undefined,
       identity: undefined
-    })
+    }) as HasDefaultColumn<Column>
 
 /** Marks a column as generated by the database expression and omitted from insert/update. */
 export const generated = <Value extends DdlExpression>(value: Value) =>
@@ -817,7 +533,7 @@ export const generated = <Value extends DdlExpression>(value: Value) =>
       defaultValue: undefined,
       generatedValue: value,
       identity: undefined
-    })
+    }) as GeneratedColumn<Column>
 
 /** Preserves the exact SQL type used for DDL rendering. */
 export const ddlType = <SqlType extends string>(sqlType: SqlType) =>
@@ -825,7 +541,7 @@ export const ddlType = <SqlType extends string>(sqlType: SqlType) =>
     mapColumn(column, {
       ...column.metadata,
       ddlType: sqlType
-    })
+    }) as DdlTypedColumn<Column>
 
 /** Marks a column as a Postgres array type. */
 export const array = <Options extends ArrayOptions | undefined = undefined>(
@@ -888,7 +604,7 @@ export const identityByDefault = <Column extends AnyColumnDefinition>(
     identity: {
       generation: "byDefault"
     }
-  })
+  }) as ByDefaultIdentityColumn<Column>
 
 /** Marks a column as `generated always as identity`. */
 export const identityAlways = <Column extends AnyColumnDefinition>(
@@ -903,7 +619,7 @@ export const identityAlways = <Column extends AnyColumnDefinition>(
     identity: {
       generation: "always"
     }
-  })
+  }) as AlwaysIdentityColumn<Column>
 
 /**
  * Attaches a lazy foreign-key reference to another bound column.
@@ -929,7 +645,7 @@ export function foreignKey(arg: unknown): unknown {
       mapColumn(column, {
         ...column.metadata,
         references: { target }
-      })
+      }) as ReferencingColumn<Column, AnyBoundColumn>
   }
   const options = arg as ForeignKeyOptions<AnyBoundColumn>
   return <Column extends AnyColumnDefinition>(
@@ -938,7 +654,7 @@ export function foreignKey(arg: unknown): unknown {
     mapColumn(column, {
       ...column.metadata,
       references: options
-    })
+    }) as ReferencingColumn<Column, ReturnType<typeof options.target>>
 }
 
 export const references = <Target extends AnyBoundColumn>(target: () => Target) =>

package/src/internal/datatypes/define.d.ts

@@ -0,0 +1,17 @@
+import type * as Expression from "../scalar.js";
+import type { DatatypeFamilySpec, DatatypeKindSpec } from "./shape.js";
+type DatatypeWitness<Dialect extends string, Kinds extends Record<string, DatatypeKindSpec>, Families extends Record<string, DatatypeFamilySpec>, Kind extends keyof Kinds & string> = Expression.DbType.Base<Dialect, Kind> & {
+    readonly family: Kinds[Kind]["family"];
+    readonly runtime: Kinds[Kind]["runtime"];
+    readonly compareGroup: Families[Kinds[Kind]["family"]]["compareGroup"];
+    readonly castTargets: Families[Kinds[Kind]["family"]]["castTargets"];
+    readonly traits: Families[Kinds[Kind]["family"]]["traits"];
+};
+export type DatatypeModule<Dialect extends string, Kinds extends Record<string, DatatypeKindSpec>, Families extends Record<string, DatatypeFamilySpec>, Aliases extends Record<string, string> = Record<never, never>> = {
+    readonly custom: <Kind extends string>(kind: Kind) => Expression.DbType.Base<Dialect, Kind>;
+} & {
+    readonly [Kind in keyof Kinds]: () => DatatypeWitness<Dialect, Kinds, Families, Kind & string>;
+} & {
+    readonly [Alias in keyof Aliases]: () => DatatypeWitness<Dialect, Kinds, Families, Aliases[Alias] & keyof Kinds & string>;
+};
+export {};

package/src/internal/datatypes/define.ts

@@ -1,14 +1,28 @@
-import type * as Expression from ".././expression.js"
-import type { DatatypeKindSpec } from "./shape.js"
+import type * as Expression from "../scalar.js"
+import type { DatatypeFamilySpec, DatatypeKindSpec } from "./shape.js"
+
+type DatatypeWitness<
+  Dialect extends string,
+  Kinds extends Record<string, DatatypeKindSpec>,
+  Families extends Record<string, DatatypeFamilySpec>,
+  Kind extends keyof Kinds & string
+> = Expression.DbType.Base<Dialect, Kind> & {
+  readonly family: Kinds[Kind]["family"]
+  readonly runtime: Kinds[Kind]["runtime"]
+  readonly compareGroup: Families[Kinds[Kind]["family"]]["compareGroup"]
+  readonly castTargets: Families[Kinds[Kind]["family"]]["castTargets"]
+  readonly traits: Families[Kinds[Kind]["family"]]["traits"]
+}
 
 export type DatatypeModule<
   Dialect extends string,
   Kinds extends Record<string, DatatypeKindSpec>,
+  Families extends Record<string, DatatypeFamilySpec>,
   Aliases extends Record<string, string> = Record<never, never>
 > = {
   readonly custom: <Kind extends string>(kind: Kind) => Expression.DbType.Base<Dialect, Kind>
 } & {
-  readonly [Kind in keyof Kinds]: () => Expression.DbType.Base<Dialect, Kind & string>
+  readonly [Kind in keyof Kinds]: () => DatatypeWitness<Dialect, Kinds, Families, Kind & string>
 } & {
-  readonly [Alias in keyof Aliases]: () => Expression.DbType.Base<Dialect, Aliases[Alias] & string>
+  readonly [Alias in keyof Aliases]: () => DatatypeWitness<Dialect, Kinds, Families, Aliases[Alias] & keyof Kinds & string>
 }

package/src/internal/datatypes/lookup.d.ts

@@ -0,0 +1,44 @@
+import type * as Expression from "../scalar.js";
+import type { RuntimeOfTag, RuntimeTag } from "./shape.js";
+type ExactKindFamily = "array" | "range" | "multirange" | "record" | "enum" | "set";
+type BaseFamilyOf<Db extends Expression.DbType.Base<any, any>> = Db extends {
+    readonly family?: infer Family extends string;
+} ? Family : Db["kind"] extends "null" ? "null" : `other:${Db["dialect"]}:${Db["kind"]}`;
+type BaseRuntimeTagOf<Db extends Expression.DbType.Base<any, any>> = Db extends {
+    readonly runtime?: infer Runtime extends RuntimeTag;
+} ? Runtime : "unknown";
+type BaseCompareGroupOf<Db extends Expression.DbType.Base<any, any>> = Db extends {
+    readonly compareGroup?: infer CompareGroup extends string;
+} ? CompareGroup : BaseFamilyOf<Db>;
+type BaseCastTargetsOf<Db extends Expression.DbType.Base<any, any>> = Db extends {
+    readonly castTargets?: readonly (infer Target extends string)[];
+} ? Target : never;
+type BaseHasTextualTrait<Db extends Expression.DbType.Base<any, any>> = Db extends {
+    readonly traits?: infer Traits;
+} ? Traits extends {
+    readonly textual: true;
+} ? true : false : false;
+export type FamilyOfDbType<Db extends Expression.DbType.Any> = Db extends Expression.DbType.Domain<any, infer Base extends Expression.DbType.Any, any> ? FamilyOfDbType<Base> : Db extends Expression.DbType.Array<any, any, any> ? "array" : Db extends Expression.DbType.Range<any, any, any> ? "range" : Db extends Expression.DbType.Multirange<any, any, any> ? "multirange" : Db extends Expression.DbType.Composite<any, any, any> ? "record" : Db extends Expression.DbType.Enum<any, any> ? "enum" : Db extends Expression.DbType.Set<any, any> ? "set" : Db extends Expression.DbType.Json<any, any> ? "json" : Db extends Expression.DbType.Base<any, any> ? BaseFamilyOf<Db> : "other:unknown:unknown";
+export type CompareGroupOfDbType<Db extends Expression.DbType.Any> = Db extends Expression.DbType.Domain<any, infer Base extends Expression.DbType.Any, any> ? CompareGroupOfDbType<Base> : Db extends Expression.DbType.Array<any, any, infer Kind extends string> ? Kind : Db extends Expression.DbType.Range<any, any, infer Kind extends string> ? Kind : Db extends Expression.DbType.Multirange<any, any, infer Kind extends string> ? Kind : Db extends Expression.DbType.Composite<any, any, infer Kind extends string> ? Kind : Db extends Expression.DbType.Enum<any, infer Kind extends string> ? Kind : Db extends Expression.DbType.Set<any, infer Kind extends string> ? Kind : Db extends Expression.DbType.Json<any, any> ? never : Db extends Expression.DbType.Base<any, any> ? BaseCompareGroupOf<Db> : "other:unknown:unknown";
+export type RuntimeOfDbType<Db extends Expression.DbType.Any> = Db extends Expression.DbType.Domain<any, infer Base extends Expression.DbType.Any, any> ? RuntimeOfDbType<Base> : Db extends Expression.DbType.Array<any, infer Element extends Expression.DbType.Any, any> ? ReadonlyArray<RuntimeOfDbType<Element>> : Db extends Expression.DbType.Composite<any, infer Fields extends Record<string, Expression.DbType.Any>, any> ? {
+    readonly [K in keyof Fields]: RuntimeOfDbType<Fields[K]>;
+} : Db extends Expression.DbType.Range<any, any, any> | Expression.DbType.Multirange<any, any, any> ? unknown : Db extends Expression.DbType.Json<any, any> ? import("../runtime/value.js").JsonValue : Db extends Expression.DbType.Enum<any, any> | Expression.DbType.Set<any, any> ? string : Db extends Expression.DbType.Base<any, any> ? BaseRuntimeTagOf<Db> extends infer Runtime extends RuntimeTag ? RuntimeOfTag<Runtime> : unknown : unknown;
+export type CanCompareDbTypes<Left extends Expression.DbType.Any, Right extends Expression.DbType.Any, Dialect extends string> = Left extends {
+    readonly dialect: Dialect;
+} ? Right extends {
+    readonly dialect: Dialect;
+} ? CompareGroupOfDbType<Left> extends never ? false : CompareGroupOfDbType<Right> extends never ? false : CompareGroupOfDbType<Left> extends "null" ? false : CompareGroupOfDbType<Right> extends "null" ? false : [CompareGroupOfDbType<Left>] extends [CompareGroupOfDbType<Right>] ? [CompareGroupOfDbType<Right>] extends [CompareGroupOfDbType<Left>] ? true : false : false : false : false;
+export type CanContainDbTypes<Left extends Expression.DbType.Any, Right extends Expression.DbType.Any, Dialect extends string> = Left extends {
+    readonly dialect: Dialect;
+} ? Right extends {
+    readonly dialect: Dialect;
+} ? FamilyOfDbType<Left> extends "array" | "range" | "multirange" ? FamilyOfDbType<Right> extends "array" | "range" | "multirange" ? [CompareGroupOfDbType<Left>] extends [CompareGroupOfDbType<Right>] ? [CompareGroupOfDbType<Right>] extends [CompareGroupOfDbType<Left>] ? true : false : false : false : false : false : false;
+export type CanTextuallyCoerceDbType<Db extends Expression.DbType.Any, Dialect extends string> = Db extends {
+    readonly dialect: Dialect;
+} ? Db extends Expression.DbType.Domain<any, infer Base extends Expression.DbType.Any, any> ? CanTextuallyCoerceDbType<Base, Dialect> : Db extends Expression.DbType.Enum<any, any> | Expression.DbType.Set<any, any> ? true : Db extends Expression.DbType.Json<any, any> ? false : Db extends Expression.DbType.Base<any, any> ? BaseHasTextualTrait<Db> : false : false;
+export type CanCastDbType<Source extends Expression.DbType.Any, Target extends Expression.DbType.Any, Dialect extends string> = Source extends {
+    readonly dialect: Dialect;
+} ? Target extends {
+    readonly dialect: Dialect;
+} ? Source extends Expression.DbType.Domain<any, infer Base extends Expression.DbType.Any, any> ? CanCastDbType<Base, Target, Dialect> : Target extends Expression.DbType.Domain<any, infer TargetBase extends Expression.DbType.Any, any> ? CanCastDbType<Source, TargetBase, Dialect> : [CompareGroupOfDbType<Source>] extends [CompareGroupOfDbType<Target>] ? [CompareGroupOfDbType<Target>] extends [CompareGroupOfDbType<Source>] ? true : false : Target extends Expression.DbType.Array<any, any, any> | Expression.DbType.Range<any, any, any> | Expression.DbType.Multirange<any, any, any> | Expression.DbType.Composite<any, any, any> | Expression.DbType.Enum<any, any> | Expression.DbType.Set<any, any> ? true : Source extends Expression.DbType.Base<any, any> ? Target extends Expression.DbType.Base<any, any> ? BaseFamilyOf<Target> extends ExactKindFamily ? false : BaseFamilyOf<Target> extends BaseCastTargetsOf<Source> ? true : false : false : false : false : false;
+export {};