effect-qb 0.13.0 → 0.15.0

package/package.json

@@ -1,11 +1,23 @@
 {
   "name": "effect-qb",
-  "version": "0.13.0",
+  "version": "0.15.0",
   "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/relsunkaev/effect-qb.git"
+  },
+  "bugs": {
+    "url": "https://github.com/relsunkaev/effect-qb/issues"
+  },
+  "homepage": "https://github.com/relsunkaev/effect-qb#readme",
+  "engines": {
+    "node": ">=22",
+    "bun": ">=1.3.5"
+  },
   "files": [
     "dist",
     "src",
-    "CHANGELOG.md",
     "README.md"
   ],
   "exports": {
@@ -13,6 +25,10 @@
       "types": "./src/postgres.ts",
       "import": "./dist/postgres.js"
     },
+    "./postgres/metadata": {
+      "types": "./src/postgres/metadata.ts",
+      "import": "./dist/postgres/metadata.js"
+    },
     "./mysql": {
       "types": "./src/mysql.ts",
       "import": "./dist/mysql.js"
@@ -28,22 +44,17 @@
     "access": "public"
   },
   "scripts": {
-    "build": "bun scripts/build-package.ts",
-    "release": "bun scripts/release.ts",
-    "test": "bun test",
-    "test:types": "bunx tsgo -p tsconfig.type-tests.json",
-    "test:integration": "bun scripts/test-integration.ts",
+    "build": "bun scripts/build.ts",
     "prepack": "bun run build"
   },
   "devDependencies": {
-    "@effect/sql-mysql2": "0.48.0",
-    "@effect/sql-pg": "0.48.0",
     "@types/bun": "latest",
     "@typescript/native-preview": "latest"
   },
   "dependencies": {
     "@effect/experimental": "^0.57.0",
     "@effect/sql": "^0.48.0",
-    "effect": "^3.19.3"
+    "effect": "^3.19.3",
+    "pgsql-ast-parser": "^12.0.2"
   }
 }

package/src/internal/aggregation-validation.ts

@@ -1,4 +1,4 @@
-import * as Expression from "./expression.js"
+import * as Expression from "./scalar.js"
 import { groupingKeyOfExpression } from "./grouping-key.js"
 
 /** Recursive selection value accepted by aggregate-shape validation. */
@@ -13,7 +13,7 @@ const isExpression = (value: unknown): value is Expression.Any =>
 
 const selectionHasAggregate = (selection: SelectionValue): boolean => {
   if (isExpression(selection)) {
-    return selection[Expression.TypeId].aggregation === "aggregate"
+    return selection[Expression.TypeId].kind === "aggregate"
   }
   return Object.values(selection).some((value) => selectionHasAggregate(value))
 }
@@ -23,7 +23,7 @@ const isGroupedSelectionValid = (
   groupedExpressions: ReadonlySet<string>
 ): boolean => {
   if (isExpression(selection)) {
-    const aggregation = selection[Expression.TypeId].aggregation
+    const aggregation = selection[Expression.TypeId].kind
     if (aggregation === "aggregate") {
       return true
     }

package/src/internal/case-analysis.d.ts

@@ -0,0 +1,18 @@
+import type * as Expression from "./scalar.js";
+import type * as ExpressionAst from "./expression-ast.js";
+import type { PredicateFormula } from "./predicate/formula.js";
+import type { AssumeFormulaFalse, AssumeFormulaTrue, Contradicts, Implies } from "./predicate/analysis.js";
+import type { FormulaOfExpression } from "./predicate/normalize.js";
+export interface CasePath<Assumptions extends PredicateFormula, Value extends Expression.Any> {
+    readonly assumptions: Assumptions;
+    readonly value: Value;
+}
+type PredicateFormulaOf<Predicate extends Expression.Any> = FormulaOfExpression<Predicate>;
+export type CaseBranchAssumeTrue<Assumptions extends PredicateFormula, Predicate extends Expression.Any> = AssumeFormulaTrue<Assumptions, PredicateFormulaOf<Predicate>>;
+export type CaseBranchAssumeFalse<Assumptions extends PredicateFormula, Predicate extends Expression.Any> = AssumeFormulaFalse<Assumptions, PredicateFormulaOf<Predicate>>;
+export type CaseBranchDecision<Assumptions extends PredicateFormula, Predicate extends Expression.Any> = Contradicts<Assumptions, Predicate> extends true ? "skip" : Implies<Assumptions, Predicate> extends true ? "take" : "branch";
+export type ReachableCasePaths<Assumptions extends PredicateFormula, Branches extends readonly ExpressionAst.CaseBranchNode[], Else extends Expression.Any> = Branches extends readonly [
+    infer Head extends ExpressionAst.CaseBranchNode,
+    ...infer Tail extends readonly ExpressionAst.CaseBranchNode[]
+] ? CaseBranchDecision<Assumptions, Head["when"]> extends "skip" ? ReachableCasePaths<Assumptions, Tail, Else> : CaseBranchDecision<Assumptions, Head["when"]> extends "take" ? CasePath<CaseBranchAssumeTrue<Assumptions, Head["when"]>, Head["then"]> : CasePath<CaseBranchAssumeTrue<Assumptions, Head["when"]>, Head["then"]> | ReachableCasePaths<CaseBranchAssumeFalse<Assumptions, Head["when"]>, Tail, Else> : CasePath<Assumptions, Else>;
+export {};

package/src/internal/case-analysis.ts

@@ -1,8 +1,8 @@
-import type * as Expression from "./expression.js"
+import type * as Expression from "./scalar.js"
 import type * as ExpressionAst from "./expression-ast.js"
-import type { PredicateFormula } from "./predicate-formula.js"
-import type { AssumeFormulaFalse, AssumeFormulaTrue, Contradicts, Implies } from "./predicate-analysis.js"
-import type { FormulaOfExpression } from "./predicate-normalize.js"
+import type { PredicateFormula } from "./predicate/formula.js"
+import type { AssumeFormulaFalse, AssumeFormulaTrue, Contradicts, Implies } from "./predicate/analysis.js"
+import type { FormulaOfExpression } from "./predicate/normalize.js"
 
 export interface CasePath<
   Assumptions extends PredicateFormula,

package/src/internal/coercion/analysis.d.ts

@@ -0,0 +1,7 @@
+import type * as Expression from "../scalar.js";
+import type { CastTargetError, OperandCompatibilityError } from "./errors.js";
+import type { CanCastDbType, CanCompareDbTypes, CanTextuallyCoerceDbType } from "./rules.js";
+export type ComparableDbType<Left extends Expression.DbType.Any, Right extends Expression.DbType.Any, Dialect extends string, Operator extends string = "comparison"> = CanCompareDbTypes<Left, Right, Dialect> extends true ? Right : OperandCompatibilityError<Operator, Left, Right, Dialect, "the same db type family">;
+export type TextCompatibleDbType<Db extends Expression.DbType.Any, Dialect extends string, Operator extends string = "text operator"> = CanTextuallyCoerceDbType<Db, Dialect> extends true ? Db : OperandCompatibilityError<Operator, Db, Db, Dialect, "a text-compatible db type">;
+export type CastableDbType<Source extends Expression.DbType.Any, Target extends Expression.DbType.Any, Dialect extends string> = CanCastDbType<Source, Target, Dialect> extends true ? Target : CastTargetError<Source, Target, Dialect>;
+export type RuntimeOfDbType<Db extends Expression.DbType.Any> = Expression.RuntimeOfDbType<Db>;

package/src/internal/{coercion-analysis.ts → coercion/analysis.ts}

@@ -1,6 +1,6 @@
-import type * as Expression from "./expression.js"
-import type { CastTargetError, OperandCompatibilityError } from "./coercion-errors.js"
-import type { CanCastDbType, CanCompareDbTypes, CanTextuallyCoerceDbType } from "./coercion-rules.js"
+import type * as Expression from "../scalar.js"
+import type { CastTargetError, OperandCompatibilityError } from "./errors.js"
+import type { CanCastDbType, CanCompareDbTypes, CanTextuallyCoerceDbType } from "./rules.js"
 
 export type ComparableDbType<
   Left extends Expression.DbType.Any,

package/src/internal/coercion/errors.d.ts

@@ -0,0 +1,17 @@
+import type * as Expression from "../scalar.js";
+export type OperandCompatibilityError<Operator extends string, Left extends Expression.DbType.Any, Right extends Expression.DbType.Any, Dialect extends string, Expected extends string> = {
+    readonly __effect_qb_error__: "effect-qb: incompatible operand types";
+    readonly __effect_qb_operator__: Operator;
+    readonly __effect_qb_left_db_type__: Left;
+    readonly __effect_qb_right_db_type__: Right;
+    readonly __effect_qb_dialect__: Dialect;
+    readonly __effect_qb_expected__: Expected;
+    readonly __effect_qb_hint__: "Use cast(...) or pick values from the same db type family";
+};
+export type CastTargetError<Source extends Expression.DbType.Any, Target extends Expression.DbType.Any, Dialect extends string> = {
+    readonly __effect_qb_error__: "effect-qb: unsupported cast target";
+    readonly __effect_qb_source_db_type__: Source;
+    readonly __effect_qb_target_db_type__: Target;
+    readonly __effect_qb_dialect__: Dialect;
+    readonly __effect_qb_hint__: "Use one of the supported Q.type.<kind>() witnesses";
+};

package/src/internal/{coercion-errors.ts → coercion/errors.ts}

@@ -1,4 +1,4 @@
-import type * as Expression from "./expression.js"
+import type * as Expression from "../scalar.js"
 
 export type OperandCompatibilityError<
   Operator extends string,

package/src/internal/coercion/kind.d.ts

@@ -0,0 +1,4 @@
+import type * as Expression from "../scalar.js";
+import type { FamilyOfDbType } from "../datatypes/lookup.js";
+export type CoercionKind = "text" | "numeric" | "boolean" | "date" | "time" | "timestamp" | "binary" | "interval" | "uuid" | "json" | "xml" | "bit" | "identifier" | "network" | "spatial" | "textsearch" | "range" | "multirange" | "array" | "record" | "domain" | "enum" | "set" | "money" | "null" | `other:${string}`;
+export type CoercionKindOf<Db extends Expression.DbType.Any> = FamilyOfDbType<Db>;

package/src/internal/{coercion-kind.ts → coercion/kind.ts}

@@ -1,5 +1,5 @@
-import type * as Expression from "./expression.js"
-import type { FamilyOfDbType } from "./datatypes/lookup.js"
+import type * as Expression from "../scalar.js"
+import type { FamilyOfDbType } from "../datatypes/lookup.js"
 
 export type CoercionKind =
   | "text"

package/src/internal/{coercion-normalize.ts → coercion/normalize.ts}

@@ -1,4 +1,4 @@
-import type * as Expression from "./expression.js"
+import type * as Expression from "../scalar.js"
 
 /** Extracts the database type carried by an expression. */
 export type DbTypeOfExpression<Value extends Expression.Any> = Expression.DbTypeOf<Value>

package/src/internal/coercion/rules.d.ts

@@ -0,0 +1,6 @@
+import type * as Expression from "../scalar.js";
+import type { CanCastDbType as LookupCanCastDbType, CanCompareDbTypes as LookupCanCompareDbTypes, CanContainDbTypes as LookupCanContainDbTypes, CanTextuallyCoerceDbType as LookupCanTextuallyCoerceDbType } from "../datatypes/lookup.js";
+export type CanCompareDbTypes<Left extends Expression.DbType.Any, Right extends Expression.DbType.Any, Dialect extends string> = LookupCanCompareDbTypes<Left, Right, Dialect>;
+export type CanContainDbTypes<Left extends Expression.DbType.Any, Right extends Expression.DbType.Any, Dialect extends string> = LookupCanContainDbTypes<Left, Right, Dialect>;
+export type CanTextuallyCoerceDbType<Db extends Expression.DbType.Any, Dialect extends string> = LookupCanTextuallyCoerceDbType<Db, Dialect>;
+export type CanCastDbType<Source extends Expression.DbType.Any, Target extends Expression.DbType.Any, Dialect extends string> = LookupCanCastDbType<Source, Target, Dialect>;

package/src/internal/{coercion-rules.ts → coercion/rules.ts}

@@ -1,5 +1,5 @@
-import type * as Expression from "./expression.js"
-import type { CanCastDbType as LookupCanCastDbType, CanCompareDbTypes as LookupCanCompareDbTypes, CanContainDbTypes as LookupCanContainDbTypes, CanTextuallyCoerceDbType as LookupCanTextuallyCoerceDbType } from "./datatypes/lookup.js"
+import type * as Expression from "../scalar.js"
+import type { CanCastDbType as LookupCanCastDbType, CanCompareDbTypes as LookupCanCompareDbTypes, CanContainDbTypes as LookupCanContainDbTypes, CanTextuallyCoerceDbType as LookupCanTextuallyCoerceDbType } from "../datatypes/lookup.js"
 
 export type CanCompareDbTypes<
   Left extends Expression.DbType.Any,

package/src/internal/column-state.d.ts

@@ -0,0 +1,190 @@
+import type * as Brand from "effect/Brand";
+import { type Pipeable } from "effect/Pipeable";
+import * as Schema from "effect/Schema";
+import * as Expression from "./scalar.js";
+import * as ExpressionAst from "./expression-ast.js";
+import type * as SchemaExpression from "./schema-expression.js";
+/** Symbol used to attach column-definition metadata. */
+export declare const ColumnTypeId: unique symbol;
+/** Symbol used to attach bound-column provenance. */
+export declare const BoundColumnTypeId: unique symbol;
+export type ColumnTypeId = typeof ColumnTypeId;
+export type BoundColumnTypeId = typeof BoundColumnTypeId;
+export type DdlExpression = Expression.Any | SchemaExpression.Any;
+/** Lazy reference to another bound column. */
+export interface ColumnReference<Target = unknown> {
+    readonly target: () => Target;
+    readonly name?: string;
+    readonly onUpdate?: "noAction" | "restrict" | "cascade" | "setNull" | "setDefault";
+    readonly onDelete?: "noAction" | "restrict" | "cascade" | "setNull" | "setDefault";
+    readonly deferrable?: boolean;
+    readonly initiallyDeferred?: boolean;
+}
+/** Inline single-column index metadata. */
+export interface ColumnIndexOptions {
+    readonly name?: string;
+    readonly method?: string;
+    readonly include?: readonly string[];
+    readonly predicate?: DdlExpression;
+    readonly order?: "asc" | "desc";
+    readonly nulls?: "first" | "last";
+    readonly operatorClass?: string;
+    readonly collation?: string;
+}
+/** Inline single-column unique-constraint metadata. */
+export interface ColumnUniqueOptions {
+    readonly name?: string;
+    readonly nullsNotDistinct?: boolean;
+    readonly deferrable?: boolean;
+    readonly initiallyDeferred?: boolean;
+}
+/** Complete static state tracked for a column definition. */
+export interface ColumnState<Select, Insert, Update, Db extends Expression.DbType.Any, Nullable extends boolean, HasDefault extends boolean, Generated extends boolean, PrimaryKey extends boolean, Unique extends boolean, Ref, Dependencies extends Expression.BindingId = never> {
+    readonly select: Select;
+    readonly insert: Insert;
+    readonly update: Update;
+    readonly dbType: Db;
+    readonly nullable: Nullable;
+    readonly hasDefault: HasDefault;
+    readonly generated: Generated;
+    readonly primaryKey: PrimaryKey;
+    readonly unique: Unique;
+    readonly references: Ref;
+    readonly brand?: true;
+    readonly index?: ColumnIndexOptions;
+    readonly uniqueConstraint?: ColumnUniqueOptions;
+    readonly defaultValue?: DdlExpression;
+    readonly generatedValue?: DdlExpression;
+    readonly ddlType?: string;
+    readonly identity?: {
+        readonly generation: "always" | "byDefault";
+    };
+    readonly enum?: {
+        readonly name: string;
+        readonly schemaName?: string;
+        readonly values: readonly [string, ...string[]];
+    };
+    readonly dependencies?: Dependencies;
+}
+/** Unbound column definition produced by the `Column` DSL. */
+export interface ColumnDefinition<Select, Insert, Update, Db extends Expression.DbType.Any, Nullable extends boolean, HasDefault extends boolean, Generated extends boolean, PrimaryKey extends boolean, Unique extends boolean, Ref, Dependencies extends Expression.BindingId = never> extends Pipeable, Expression.Scalar<Select, Db, Nullable extends true ? "maybe" : "never", Db["dialect"], "scalar", Dependencies> {
+    readonly pipe: Pipeable["pipe"];
+    readonly [ColumnTypeId]: ColumnState<Select, Insert, Update, Db, Nullable, HasDefault, Generated, PrimaryKey, Unique, Ref, Dependencies>;
+    readonly schema: Schema.Schema<NonNullable<Select>, any, any>;
+    readonly metadata: {
+        readonly dbType: Db;
+        readonly nullable: Nullable;
+        readonly hasDefault: HasDefault;
+        readonly generated: Generated;
+        readonly primaryKey: PrimaryKey;
+        readonly unique: Unique;
+        readonly references: Ref;
+        readonly brand?: true;
+        readonly index?: ColumnIndexOptions;
+        readonly uniqueConstraint?: ColumnUniqueOptions;
+        readonly defaultValue?: DdlExpression;
+        readonly generatedValue?: DdlExpression;
+        readonly ddlType?: string;
+        readonly identity?: {
+            readonly generation: "always" | "byDefault";
+        };
+        readonly enum?: {
+            readonly name: string;
+            readonly schemaName?: string;
+            readonly values: readonly [string, ...string[]];
+        };
+    };
+}
+/** Column definition bound to a concrete table and column name. */
+export interface BoundColumn<Select, Insert, Update, Db extends Expression.DbType.Any, Nullable extends boolean, HasDefault extends boolean, Generated extends boolean, PrimaryKey extends boolean, Unique extends boolean, Ref, TableName extends string, ColumnName extends string, BaseTableName extends string = TableName> extends ColumnDefinition<Select, Insert, Update, Db, Nullable, HasDefault, Generated, PrimaryKey, Unique, Ref, TableName> {
+    readonly [BoundColumnTypeId]: {
+        readonly tableName: TableName;
+        readonly columnName: ColumnName;
+        readonly baseTableName: BaseTableName;
+        readonly schemaName?: string;
+    };
+    readonly [Expression.TypeId]: Expression.State<Select, Db, Nullable extends true ? "maybe" : "never", Db["dialect"], "scalar", TableName>;
+    readonly [ExpressionAst.TypeId]: ExpressionAst.ColumnNode<TableName, ColumnName>;
+}
+/** Convenience alias for any column definition. */
+export type AnyColumnDefinition = ColumnDefinition<any, any, any, Expression.DbType.Any, boolean, boolean, boolean, boolean, boolean, any, any>;
+/** Convenience alias for any bound column. */
+export type AnyBoundColumn = BoundColumn<any, any, any, Expression.DbType.Any, boolean, boolean, boolean, boolean, boolean, any, string, string, string>;
+/** Constructs a runtime column-definition object from schema and metadata. */
+export declare const makeColumnDefinition: <Select, Insert, Update, Db extends Expression.DbType.Any, Nullable extends boolean, HasDefault extends boolean, Generated extends boolean, PrimaryKey extends boolean, Unique extends boolean, Ref, Dependencies extends string = never>(schema: Schema.Schema<NonNullable<Select>, any, any>, metadata: {
+    readonly dbType: Db;
+    readonly nullable: Nullable;
+    readonly hasDefault: HasDefault;
+    readonly generated: Generated;
+    readonly primaryKey: PrimaryKey;
+    readonly unique: Unique;
+    readonly references: Ref;
+    readonly brand?: true | undefined;
+    readonly index?: ColumnIndexOptions | undefined;
+    readonly uniqueConstraint?: ColumnUniqueOptions | undefined;
+    readonly defaultValue?: DdlExpression | undefined;
+    readonly generatedValue?: DdlExpression | undefined;
+    readonly ddlType?: string | undefined;
+    readonly identity?: {
+        readonly generation: "always" | "byDefault";
+    } | undefined;
+    readonly enum?: {
+        readonly name: string;
+        readonly schemaName?: string | undefined;
+        readonly values: readonly [string, ...string[]];
+    } | undefined;
+}) => ColumnDefinition<Select, Insert, Update, Db, Nullable, HasDefault, Generated, PrimaryKey, Unique, Ref, Dependencies>;
+export declare const remapColumnDefinition: <Select, Insert, Update, Db extends Expression.DbType.Any, Nullable extends boolean, HasDefault extends boolean, Generated extends boolean, PrimaryKey extends boolean, Unique extends boolean, Ref, Dependencies extends string = never>(column: ColumnDefinition<Select, Insert, Update, Db, Nullable, HasDefault, Generated, PrimaryKey, Unique, Ref, Dependencies>, options?: {
+    readonly schema?: Schema.Schema.Any | undefined;
+    readonly metadata?: {
+        readonly dbType: Db;
+        readonly nullable: Nullable;
+        readonly hasDefault: HasDefault;
+        readonly generated: Generated;
+        readonly primaryKey: PrimaryKey;
+        readonly unique: Unique;
+        readonly references: Ref;
+        readonly brand?: true | undefined;
+        readonly index?: ColumnIndexOptions | undefined;
+        readonly uniqueConstraint?: ColumnUniqueOptions | undefined;
+        readonly defaultValue?: DdlExpression | undefined;
+        readonly generatedValue?: DdlExpression | undefined;
+        readonly ddlType?: string | undefined;
+        readonly identity?: {
+            readonly generation: "always" | "byDefault";
+        } | undefined;
+        readonly enum?: {
+            readonly name: string;
+            readonly schemaName?: string | undefined;
+            readonly values: readonly [string, ...string[]];
+        } | undefined;
+    } | undefined;
+}) => ColumnDefinition<Select, Insert, Update, Db, Nullable, HasDefault, Generated, PrimaryKey, Unique, Ref, Dependencies>;
+/** Attaches table/column provenance to an existing column definition. */
+export declare const bindColumn: <TableName extends string, ColumnName extends string, BaseTableName extends string, SchemaName extends string | undefined, Column extends AnyColumnDefinition>(tableName: TableName, columnName: ColumnName, column: Column, baseTableName: BaseTableName, schemaName?: SchemaName | undefined) => BoundColumnFrom<Column, TableName, ColumnName, BaseTableName>;
+/** Extracts the internal state record for a column. */
+export type ColumnStateOf<Column extends AnyColumnDefinition> = Column[typeof ColumnTypeId];
+/** Extracts the read/select type of a column. */
+export type SelectType<Column extends AnyColumnDefinition> = ColumnStateOf<Column>["select"];
+/** Extracts the insert type of a column. */
+export type InsertType<Column extends AnyColumnDefinition> = ColumnStateOf<Column>["insert"];
+/** Extracts the update type of a column. */
+export type UpdateType<Column extends AnyColumnDefinition> = ColumnStateOf<Column>["update"];
+/** Extracts whether a column is nullable. */
+export type IsNullable<Column extends AnyColumnDefinition> = ColumnStateOf<Column>["nullable"];
+/** Extracts whether a column has a server-side default. */
+export type HasDefault<Column extends AnyColumnDefinition> = ColumnStateOf<Column>["hasDefault"];
+/** Extracts whether a column is generated by the database. */
+export type IsGenerated<Column extends AnyColumnDefinition> = ColumnStateOf<Column>["generated"];
+/** Extracts whether a column is part of a primary key. */
+export type IsPrimaryKey<Column extends AnyColumnDefinition> = ColumnStateOf<Column>["primaryKey"];
+/** Extracts whether a column is unique. */
+export type IsUnique<Column extends AnyColumnDefinition> = ColumnStateOf<Column>["unique"];
+/** Extracts a column's foreign-key reference metadata. */
+export type ReferencesOf<Column extends AnyColumnDefinition> = ColumnStateOf<Column>["references"];
+/** Extracts the non-null select type of a column. */
+export type BaseSelectType<Column extends AnyColumnDefinition> = NonNullable<SelectType<Column>>;
+type BrandedValue<Value, BrandName extends string> = [Extract<Value, null | undefined>] extends [never] ? Value & Brand.Brand<BrandName> : (Exclude<Value, null | undefined> & Brand.Brand<BrandName>) | Extract<Value, null | undefined>;
+/** Rebinds a generic column definition to a specific table and key. */
+export type BoundColumnFrom<Column extends AnyColumnDefinition, TableName extends string, ColumnName extends string, BaseTableName extends string = TableName> = BoundColumn<Column["metadata"]["brand"] extends true ? BrandedValue<SelectType<Column>, `${TableName}.${ColumnName}`> : SelectType<Column>, Column["metadata"]["brand"] extends true ? BrandedValue<InsertType<Column>, `${TableName}.${ColumnName}`> : InsertType<Column>, Column["metadata"]["brand"] extends true ? BrandedValue<UpdateType<Column>, `${TableName}.${ColumnName}`> : UpdateType<Column>, ColumnStateOf<Column>["dbType"], IsNullable<Column>, HasDefault<Column>, IsGenerated<Column>, IsPrimaryKey<Column>, IsUnique<Column>, ReferencesOf<Column>, TableName, ColumnName, BaseTableName>;
+export {};