effect-qb 0.17.0 → 0.20.0

package/src/standard/primary-key.ts

@@ -0,0 +1,17 @@
+import * as BaseTable from "../internal/table.js"
+import type { TableOptionSpec } from "../internal/table-options.js"
+
+type PrimaryKeySpec = Extract<TableOptionSpec, { readonly kind: "primaryKey" }>
+
+export const make = BaseTable.primaryKey
+
+export const named = <const Name extends string>(
+  name: BaseTable.NonEmptyStringInput<Name>
+) =>
+  <Spec extends PrimaryKeySpec, TableContext extends BaseTable.TableDefinition<any, any, any, "schema", any>>(
+    option: BaseTable.TableOption<Spec, TableContext>
+  ): BaseTable.TableOption<Spec & { readonly name: Name }, TableContext> =>
+    BaseTable.mapOption(option, (spec) => ({
+      ...spec,
+      name
+    } as Spec & { readonly name: Name }))

package/src/standard/query.ts

@@ -0,0 +1,152 @@
+import {
+  type as standardType
+} from "../internal/standard-dsl.js"
+import type * as Expression from "../internal/scalar.js"
+
+export {
+  literal,
+  column,
+  cast,
+  eq,
+  neq,
+  lt,
+  lte,
+  gt,
+  gte,
+  isNull,
+  isNotNull,
+  like,
+  ilike,
+  collate,
+  regexMatch,
+  regexIMatch,
+  regexNotMatch,
+  regexNotIMatch,
+  and,
+  or,
+  not,
+  all,
+  any,
+  case_ as case,
+  match,
+  in_ as in,
+  notIn,
+  between,
+  contains,
+  containedBy,
+  overlaps,
+  exists,
+  isDistinctFrom,
+  isNotDistinctFrom,
+  excluded,
+  as,
+  with_ as with,
+  withRecursive,
+  lateral,
+  scalar,
+  inSubquery,
+  compareAny,
+  compareAll,
+  values,
+  unnest,
+  select,
+  returning,
+  onConflict,
+  insert,
+  update,
+  upsert,
+  delete_ as delete,
+  truncate,
+  merge,
+  transaction,
+  commit,
+  rollback,
+  savepoint,
+  rollbackTo,
+  releaseSavepoint,
+  createTable,
+  dropTable,
+  createIndex,
+  dropIndex,
+  union,
+  unionAll,
+  intersect,
+  intersectAll,
+  except,
+  exceptAll,
+  where,
+  having,
+  from,
+  innerJoin,
+  leftJoin,
+  rightJoin,
+  fullJoin,
+  crossJoin,
+  distinct,
+  limit,
+  offset,
+  lock,
+  orderBy,
+  groupBy,
+  lower,
+  upper,
+  concat,
+  coalesce,
+  call,
+  count,
+  max,
+  min,
+  over,
+  rowNumber,
+  rank,
+  denseRank
+} from "../internal/standard-dsl.js"
+
+export { standardType as type }
+export { union_query_capabilities } from "../internal/query.js"
+
+export type MutationInputOf<Shape> = {
+  readonly [K in keyof Shape]:
+    | Shape[K]
+    | Expression.Scalar<Shape[K], Expression.DbType.Any, Expression.Nullability, "standard", Expression.ScalarKind, Expression.BindingId>
+}
+
+export type {
+  AnyTableFunctionSource,
+  AnyUnnestSource,
+  AnyValuesSource,
+  CapabilitiesOfPlan,
+  CompletePlan,
+  CteSource,
+  DialectCompatiblePlan,
+  DerivedSourceRequiredError,
+  EffectiveNullability,
+  ExpressionInput,
+  ExpressionOutput,
+  GroupByInput,
+  HavingPredicateInput,
+  MergeCapabilities,
+  MergeCapabilityTuple,
+  MutationTargetLike,
+  NumericExpressionInput,
+  OrderDirection,
+  OutputOfSelection,
+  PredicateInput,
+  QueryCapability,
+  QueryPlan,
+  QueryRequirement,
+  QueryStatement,
+  ResultRow,
+  ResultRows,
+  RuntimeResultRow,
+  RuntimeResultRows,
+  SchemaTableLike,
+  SetCompatiblePlan,
+  SetCompatibleRightPlan,
+  SetOperator,
+  SourceCapabilitiesOf,
+  SourceRequiredOf,
+  SourceRequirementError,
+  StatementOfPlan,
+  StringExpressionInput
+} from "../internal/query.js"

package/src/standard/renderer.ts

@@ -0,0 +1,49 @@
+import { pipeArguments, type Pipeable } from "effect/Pipeable"
+
+import * as CoreRenderer from "../internal/renderer.js"
+import * as Casing from "../internal/casing.js"
+import type * as Expression from "../internal/scalar.js"
+import type { StandardDatatypeFamily, StandardDatatypeKind } from "./datatypes/spec.js"
+import { renderStandardPlan } from "./internal/renderer.js"
+
+export type RenderedQuery<Row> = CoreRenderer.RenderedQuery<Row, "standard">
+
+export type RowOf<Value extends RenderedQuery<any>> = CoreRenderer.RowOf<Value>
+
+export type Renderer = CoreRenderer.Renderer<"standard"> & Pipeable & {
+  readonly [Casing.TypeId]: Casing.State
+  readonly withCasing: (options: Casing.Options) => Renderer
+}
+
+export type ValueMappings = Expression.DriverValueMappingsFor<StandardDatatypeKind | "uuid", StandardDatatypeFamily | "uuid">
+
+export interface MakeOptions {
+  readonly valueMappings?: ValueMappings
+}
+
+interface RendererState extends MakeOptions {
+  readonly casing?: Casing.Options
+}
+
+const RendererProto = {
+  pipe(this: Pipeable) {
+    return pipeArguments(this, arguments)
+  }
+}
+
+const makeWithState = (state: RendererState = {}): Renderer => {
+  const renderer = CoreRenderer.makeTrusted("standard", (plan) => renderStandardPlan(plan, state))
+  return Object.assign(Object.create(RendererProto), renderer, {
+    [Casing.TypeId]: {
+      casing: state.casing
+    },
+    withCasing: (override: Casing.Options) =>
+      makeWithState({
+        ...state,
+        casing: Casing.merge(state.casing, override)
+      })
+  }) as Renderer
+}
+
+export const make = (options: MakeOptions = {}): Renderer =>
+  makeWithState({ valueMappings: options.valueMappings })

package/src/standard/table.ts

@@ -0,0 +1,151 @@
+import type { AnyColumnDefinition } from "../internal/column-state.js"
+import * as BaseTable from "../internal/table.js"
+
+type Dialect = string
+
+type DialectColumn = AnyColumnDefinition
+
+type DialectFieldMap = Record<string, DialectColumn>
+
+type InlinePrimaryKeyKeys<Fields extends DialectFieldMap> = Extract<{
+  [K in keyof Fields]: Fields[K]["metadata"]["primaryKey"] extends true ? K : never
+}[keyof Fields], string>
+
+export type TableDefinition<
+  Name extends string,
+  Fields extends DialectFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string = InlinePrimaryKeyKeys<Fields>,
+  Kind extends "schema" | "alias" = "schema",
+  SchemaName extends string = "public",
+  ConflictArbiters extends BaseTable.ConflictArbiter = BaseTable.TableDefinition<
+    Name,
+    Fields,
+    PrimaryKeyColumns,
+    Kind,
+    SchemaName
+  >[typeof BaseTable.TypeId]["conflictArbiters"][number]
+> = BaseTable.TableDefinition<Name, Fields, PrimaryKeyColumns, Kind, SchemaName, ConflictArbiters>
+
+export type TableClassStatic<
+  Name extends string,
+  Fields extends DialectFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string = InlinePrimaryKeyKeys<Fields>,
+  SchemaName extends string = "public",
+  ConflictArbiters extends BaseTable.ConflictArbiter = BaseTable.TableClassStatic<
+    Name,
+    Fields,
+    PrimaryKeyColumns,
+    SchemaName
+  >[typeof BaseTable.TypeId]["conflictArbiters"][number]
+> = BaseTable.TableClassStatic<Name, Fields, PrimaryKeyColumns, SchemaName, ConflictArbiters>
+
+export type AnyTable = BaseTable.AnyTable<Dialect>
+
+type FieldsOfTable<Table extends BaseTable.AnyTable> = Table[typeof BaseTable.TypeId]["fields"] extends infer Fields extends DialectFieldMap
+  ? Fields
+  : never
+
+type PrimaryKeyOfTable<Table extends BaseTable.AnyTable> = Table[typeof BaseTable.TypeId]["primaryKey"][number]
+
+type SchemaNameOfTable<Table extends BaseTable.AnyTable> =
+  Table[typeof BaseTable.TypeId]["schemaName"] extends infer SchemaName extends string ? SchemaName : "public"
+
+type ConflictArbiterOfTable<Table extends BaseTable.AnyTable> = Table[typeof BaseTable.TypeId]["conflictArbiters"][number]
+
+export type TableOption = BaseTable.TableOption
+
+export const TypeId = BaseTable.TypeId
+export const OptionsSymbol = BaseTable.OptionsSymbol
+export const options = BaseTable.options
+export const option = BaseTable.option
+
+export function make<
+  Name extends string,
+  Fields extends DialectFieldMap
+>(
+  name: BaseTable.NonEmptyStringInput<Name>,
+  fields: Fields & BaseTable.NonEmptyFieldMap<Fields>
+): TableDefinition<Name, Fields, InlinePrimaryKeyKeys<Fields>, "schema", "public">
+export function make<
+  Name extends string,
+  Fields extends DialectFieldMap,
+  const SchemaName extends string
+>(
+  name: BaseTable.NonEmptyStringInput<Name>,
+  fields: Fields & BaseTable.NonEmptyFieldMap<Fields>,
+  schemaName: BaseTable.NonEmptySchemaNameInput<SchemaName>
+): TableDefinition<Name, Fields, InlinePrimaryKeyKeys<Fields>, "schema", SchemaName>
+export function make(
+  name: string,
+  fields: DialectFieldMap,
+  schemaName?: string
+): any {
+  return arguments.length >= 3
+    ? BaseTable.make(name, fields, schemaName as string) as TableDefinition<string, DialectFieldMap, string, "schema", string>
+    : BaseTable.make(name, fields) as TableDefinition<string, DialectFieldMap, string, "schema", string>
+}
+
+export const alias = <
+  Table extends AnyTable,
+  AliasName extends string
+>(
+  table: Table,
+  aliasName: BaseTable.LiteralStringInput<AliasName>
+): TableDefinition<
+  AliasName,
+  FieldsOfTable<Table>,
+  PrimaryKeyOfTable<Table>,
+  "alias",
+  SchemaNameOfTable<Table>,
+  ConflictArbiterOfTable<Table>
+> =>
+  BaseTable.alias(table as any, aliasName) as TableDefinition<
+    AliasName,
+    FieldsOfTable<Table>,
+    PrimaryKeyOfTable<Table>,
+    "alias",
+    SchemaNameOfTable<Table>,
+    ConflictArbiterOfTable<Table>
+  >
+
+type ClassApi = {
+  <Self = never>(
+    name: "",
+    schemaName?: string | undefined
+  ): never
+  <Self = never>(
+    name: string,
+    schemaName: ""
+  ): never
+  <Self = never, const SchemaName extends string = "public", const Name extends string = string>(
+    name: BaseTable.NonEmptyStringInput<Name>,
+    schemaName?: BaseTable.NonEmptySchemaNameInput<SchemaName>
+  ): <
+    Fields extends DialectFieldMap
+  >(fields: Fields & BaseTable.NonEmptyFieldMap<Fields>) => [Self] extends [never]
+    ? BaseTable.MissingSelfGeneric
+    : TableClassStatic<Name, Fields, InlinePrimaryKeyKeys<Fields>, SchemaName>
+}
+
+export const Class: ClassApi = ((
+  name: string,
+  schemaName: string | undefined = undefined
+) => {
+  const base = BaseTable.Class(name as never, schemaName)
+  return base
+}) as ClassApi
+
+export const primaryKey = BaseTable.primaryKey
+export const unique = BaseTable.unique
+export const index = BaseTable.index
+export const foreignKey = BaseTable.foreignKey
+
+export const check = BaseTable.check
+
+export const selectSchema = BaseTable.selectSchema
+export const insertSchema = BaseTable.insertSchema
+export const updateSchema = BaseTable.updateSchema
+
+export type SelectOf<Table extends AnyTable> = BaseTable.SelectOf<Table>
+export type InsertOf<Table extends AnyTable> = BaseTable.InsertOf<Table>
+export type UpdateOf<Table extends AnyTable> = BaseTable.UpdateOf<Table>

package/src/standard/unique.ts

@@ -0,0 +1,17 @@
+import * as BaseTable from "../internal/table.js"
+import type { TableOptionSpec } from "../internal/table-options.js"
+
+type UniqueSpec = Extract<TableOptionSpec, { readonly kind: "unique" }>
+
+export const make = BaseTable.unique
+
+export const named = <const Name extends string>(
+  name: BaseTable.NonEmptyStringInput<Name>
+) =>
+  <Spec extends UniqueSpec, TableContext extends BaseTable.TableDefinition<any, any, any, "schema", any>>(
+    option: BaseTable.TableOption<Spec, TableContext>
+  ): BaseTable.TableOption<Spec & { readonly name: Name }, TableContext> =>
+    BaseTable.mapOption(option, (spec) => ({
+      ...spec,
+      name
+    } as Spec & { readonly name: Name }))

package/src/standard.ts

@@ -0,0 +1,32 @@
+/** Standard SQL column-definition DSL. */
+export * as Column from "./standard/column.js"
+/** Standard SQL cast helpers. */
+export * as Cast from "./standard/cast.js"
+/** Standard SQL datatype witnesses and coercion families. */
+export * as Datatypes from "./standard/datatypes/index.js"
+/** Shared scalar SQL interfaces and DB-type descriptors. */
+export * as Scalar from "./internal/scalar.js"
+/** Standard SQL function expressions. */
+export * as Function from "./standard/function/index.js"
+/** Standard SQL JSON expression helpers and path segments. */
+export * as Json from "./standard/json.js"
+/** Standard SQL typed query execution contracts. */
+export * as Executor from "./internal/executor.js"
+/** Shared logical row-set interfaces. */
+export * as RowSet from "./internal/row-set.js"
+/** Standard SQL query-construction DSL. */
+export * as Query from "./standard/query.js"
+/** Standard SQL table-definition DSL. */
+export * as Table from "./standard/table.js"
+/** Standard SQL table-level primary-key options. */
+export * as PrimaryKey from "./standard/primary-key.js"
+/** Standard SQL table-level unique-constraint options. */
+export * as Unique from "./standard/unique.js"
+/** Standard SQL table-level index options. */
+export * as Index from "./standard/index.js"
+/** Standard SQL table-level foreign-key options. */
+export * as ForeignKey from "./standard/foreign-key.js"
+/** Standard SQL table-level check-constraint options. */
+export * as Check from "./standard/check.js"
+/** Standard SQL built-in renderer entrypoint. */
+export * as Renderer from "./standard/renderer.js"

package/src/internal/aggregation-validation.ts

@@ -1,57 +0,0 @@
-import * as Expression from "./scalar.js"
-import { groupingKeyOfExpression } from "./grouping-key.js"
-
-/** Recursive selection value accepted by aggregate-shape validation. */
-export type SelectionValue =
-  | Expression.Any
-  | {
-      readonly [key: string]: SelectionValue
-    }
-
-const isExpression = (value: unknown): value is Expression.Any =>
-  typeof value === "object" && value !== null && Expression.TypeId in value
-
-const selectionHasAggregate = (selection: SelectionValue): boolean => {
-  if (isExpression(selection)) {
-    return selection[Expression.TypeId].kind === "aggregate"
-  }
-  return Object.values(selection).some((value) => selectionHasAggregate(value))
-}
-
-const isGroupedSelectionValid = (
-  selection: SelectionValue,
-  groupedExpressions: ReadonlySet<string>
-): boolean => {
-  if (isExpression(selection)) {
-    const aggregation = selection[Expression.TypeId].kind
-    if (aggregation === "aggregate") {
-      return true
-    }
-    if (aggregation === "window") {
-      return false
-    }
-    if (Object.keys(selection[Expression.TypeId].dependencies).length === 0) {
-      return true
-    }
-    return groupedExpressions.has(groupingKeyOfExpression(selection))
-  }
-  return Object.values(selection).every((value) => isGroupedSelectionValid(value, groupedExpressions))
-}
-
-/**
- * Validates that grouped/scalar selection mixing is legal for the provided
- * `groupBy(...)` expressions.
- */
-export const validateAggregationSelection = (
-  selection: SelectionValue,
-  grouped: readonly Expression.Any[]
-): void => {
-  const groupedExpressions = new Set(grouped.map(groupingKeyOfExpression))
-  const hasAggregate = selectionHasAggregate(selection)
-  const isValid = hasAggregate || grouped.length > 0
-    ? isGroupedSelectionValid(selection, groupedExpressions)
-    : true
-  if (!isValid) {
-    throw new Error("Invalid grouped selection: scalar expressions must be covered by groupBy(...) when aggregates are present")
-  }
-}

package/src/internal/table.d.ts

@@ -1,173 +0,0 @@
-import { type Pipeable } from "effect/Pipeable";
-import * as Schema from "effect/Schema";
-import * as Plan from "./row-set.js";
-import type { TrueFormula } from "./predicate/formula.js";
-import type { BoundColumnFrom } from "./column-state.js";
-import { type DdlExpressionLike, type NormalizeColumns, type TableOptionSpec, type ValidateKnownColumns, type ValidatePrimaryKeyColumns } from "./table-options.js";
-import { type InsertRow, type SelectRow, type TableFieldMap, type UpdateRow } from "./schema-derivation.js";
-/** Symbol used to attach table-definition metadata. */
-export declare const TypeId: unique symbol;
-/** Symbol for the normalized table option list. */
-export declare const OptionsSymbol: unique symbol;
-/** Symbol used by `Table.Class` to declare table-level options. */
-export declare const options: unique symbol;
-declare const DeclaredOptionsSymbol: unique symbol;
-type InlinePrimaryKeyKeys<Fields extends TableFieldMap> = Extract<{
-    [K in keyof Fields]: Fields[K]["metadata"]["primaryKey"] extends true ? K : never;
-}[keyof Fields], string>;
-type TableDialect<Fields extends TableFieldMap> = Fields[keyof Fields][typeof import("./column-state.js").ColumnTypeId]["dbType"]["dialect"];
-type TableKind = "schema" | "alias";
-type DefaultSchemaName = "public";
-type ClassOptionSpec = Exclude<TableOptionSpec, {
-    readonly kind: "primaryKey";
-}>;
-interface TableOptionBuilderLike<Spec extends TableOptionSpec = TableOptionSpec> {
-    (table: TableDefinition<any, any, any, "schema", any>): TableDefinition<any, any, any, "schema", any>;
-    readonly option: Spec;
-}
-type ClassTableOption = TableOptionBuilderLike<ClassOptionSpec>;
-type ClassDeclaredTableOptions = readonly ClassTableOption[];
-type BuildPrimaryKey<Table extends TableDefinition<any, any, any, "schema", any>, Spec extends TableOptionSpec> = Spec extends {
-    readonly kind: "primaryKey";
-    readonly columns: infer Columns extends readonly string[];
-} ? Columns[number] & keyof Table[typeof TypeId]["fields"] & string : Table[typeof TypeId]["primaryKey"][number];
-type OptionInputTable<Table extends TableDefinition<any, any, any, "schema", any>, Spec extends TableOptionSpec> = Spec extends {
-    readonly kind: "primaryKey";
-    readonly columns: infer Columns extends readonly string[];
-} ? ValidatePrimaryKeyColumns<Table[typeof TypeId]["fields"], Columns> extends never ? never : Table : Spec extends {
-    readonly columns: infer Columns extends readonly string[];
-} ? ValidateKnownColumns<Table[typeof TypeId]["fields"], Columns> extends never ? never : Table : Table;
-type ApplyOption<Table extends TableDefinition<any, any, any, "schema", any>, Spec extends TableOptionSpec> = Spec extends {
-    readonly kind: "primaryKey";
-} ? TableDefinition<Table[typeof TypeId]["name"], Table[typeof TypeId]["fields"], BuildPrimaryKey<Table, Spec>, "schema"> : TableDefinition<Table[typeof TypeId]["name"], Table[typeof TypeId]["fields"], Table[typeof TypeId]["primaryKey"][number], "schema">;
-export type MissingSelfGeneric = "Missing `Self` generic - use `class Self extends Table.Class<Self>(...) {}`";
-/** Bound columns keyed by field name for a particular table. */
-export type BoundColumns<Name extends string, Fields extends TableFieldMap> = {
-    readonly [K in keyof Fields]: BoundColumnFrom<Fields[K], Name, Extract<K, string>>;
-};
-/** Derived runtime schemas exposed by a table definition. */
-export interface TableSchemas<Name extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string> {
-    readonly select: Schema.Schema<SelectRow<Name, Fields>>;
-    readonly insert: Schema.Schema<InsertRow<Name, Fields>>;
-    readonly update: Schema.Schema<UpdateRow<Name, Fields, PrimaryKeyColumns>>;
-}
-interface TableState<Name extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string, Kind extends TableKind = "schema", SchemaName extends string | undefined = DefaultSchemaName> {
-    readonly name: Name;
-    readonly baseName: string;
-    readonly schemaName: SchemaName;
-    readonly fields: Fields;
-    readonly primaryKey: readonly PrimaryKeyColumns[];
-    readonly kind: Kind;
-}
-/** Namespace-scoped table builder. */
-export interface TableSchemaNamespace<SchemaName extends string> {
-    readonly schemaName: SchemaName;
-    readonly table: <Name extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string = InlinePrimaryKeyKeys<Fields>>(name: Name, fields: Fields, ...options: DeclaredTableOptions) => TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>;
-}
-export type DeclaredTableOptions = readonly TableOptionBuilderLike[];
-export type { DdlExpressionLike, IndexKeySpec, NormalizeColumns, ReferentialAction } from "./table-options.js";
-export type TableDefinition<Name extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string = InlinePrimaryKeyKeys<Fields>, Kind extends TableKind = "schema", SchemaName extends string | undefined = DefaultSchemaName> = Pipeable & {
-    readonly name: Name;
-    readonly columns: BoundColumns<Name, Fields>;
-    readonly schemas: TableSchemas<Name, Fields, PrimaryKeyColumns>;
-    readonly [TypeId]: TableState<Name, Fields, PrimaryKeyColumns, Kind, SchemaName>;
-    readonly [Plan.TypeId]: Plan.State<BoundColumns<Name, Fields>, never, Record<Name, Plan.Source<Name, "required", TrueFormula>>, TableDialect<Fields>>;
-    readonly [OptionsSymbol]: readonly TableOptionSpec[];
-    readonly [DeclaredOptionsSymbol]: readonly TableOptionSpec[];
-} & BoundColumns<Name, Fields> & Plan.RowSet<BoundColumns<Name, Fields>, never, Record<Name, Plan.Source<Name, "required", TrueFormula>>, TableDialect<Fields>>;
-/**
- * Static class-based table definition.
- *
- * The class object itself acts as the table definition, exposing static bound
- * columns, derived schemas, and plan metadata.
- */
-export type TableClassStatic<Name extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string = InlinePrimaryKeyKeys<Fields>, SchemaName extends string | undefined = DefaultSchemaName> = (abstract new (...args: any[]) => any) & Pipeable & {
-    readonly columns: BoundColumns<Name, Fields>;
-    readonly schemas: TableSchemas<Name, Fields, PrimaryKeyColumns>;
-    readonly [TypeId]: TableState<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>;
-    readonly [Plan.TypeId]: Plan.State<BoundColumns<Name, Fields>, never, Record<Name, Plan.Source<Name, "required", TrueFormula>>, TableDialect<Fields>>;
-    readonly [OptionsSymbol]: readonly TableOptionSpec[];
-    readonly [DeclaredOptionsSymbol]?: readonly TableOptionSpec[];
-    readonly [options]?: ClassDeclaredTableOptions;
-    readonly tableName: Name;
-} & BoundColumns<Name, Fields> & Plan.RowSet<BoundColumns<Name, Fields>, never, Record<Name, Plan.Source<Name, "required", TrueFormula>>, TableDialect<Fields>>;
-/** Minimal structural table-like contract used across helper APIs. */
-export type AnyTable = TableDefinition<any, any, any, any, any> | TableClassStatic<any, any, any, any>;
-/** Public table-option builder type used by `Table.index`, `Table.primaryKey`, and friends. */
-export type TableOption<Spec extends TableOptionSpec = TableOptionSpec> = {
-    <Name extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string>(table: OptionInputTable<TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", any>, Spec>): ApplyOption<TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", any>, Spec>;
-    readonly option: Spec;
-};
-export declare const option: <Spec extends TableOptionSpec>(spec: Spec) => TableOption<Spec>;
-export declare const optionFromTable: <Spec extends TableOptionSpec>(spec: Spec, resolve: (table: TableDefinition<any, any, any, "schema", any>) => Spec) => TableOption<Spec>;
-/** Creates a table definition from a name and field map. */
-export declare function make<Name extends string, Fields extends TableFieldMap, SchemaName extends string | undefined = DefaultSchemaName>(name: Name, fields: Fields, schemaName?: SchemaName): TableDefinition<Name, Fields, InlinePrimaryKeyKeys<Fields>, "schema", SchemaName>;
-/**
- * Creates a namespace-scoped builder for a concrete SQL schema/database.
- */
-export declare const schema: <SchemaName extends string>(schemaName: SchemaName) => TableSchemaNamespace<SchemaName>;
-/**
- * Creates an aliased source from an existing table definition.
- *
- * The alias becomes the logical source identity used by the query layer while
- * the original physical table name is retained in bound-column provenance for
- * downstream SQL rendering work.
- */
-export declare const alias: <Name extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string, SchemaName extends string, AliasName extends string>(table: TableClassStatic<Name, Fields, PrimaryKeyColumns, SchemaName> | TableDefinition<Name, Fields, PrimaryKeyColumns, any, SchemaName>, aliasName: AliasName) => TableDefinition<AliasName, Fields, PrimaryKeyColumns, "alias", SchemaName>;
-/**
- * Class-based table constructor mirroring `Schema.Class`.
- *
- * The returned base class can be extended and configured with
- * `static readonly [Table.options]`.
- */
-export declare function Class<Self = never, SchemaName extends string | undefined = DefaultSchemaName>(name: string, schemaName?: SchemaName): <Fields extends TableFieldMap>(fields: Fields) => [Self] extends [never] ? "Missing `Self` generic - use `class Self extends Table.Class<Self>(...) {}`" : TableClassStatic<string, Fields, Extract<{ [K in keyof Fields]: Fields[K]["metadata"]["primaryKey"] extends true ? K : never; }[keyof Fields], string>, SchemaName>;
-/** Declares a table-level primary key. */
-export declare const primaryKey: <const Columns extends string | readonly string[]>(columns: Columns) => TableOption<{
-    readonly kind: "primaryKey";
-    readonly columns: NormalizeColumns<Columns>;
-}>;
-/** Declares a table-level unique constraint. */
-export declare const unique: <const Columns extends string | readonly string[]>(columns: Columns) => TableOption<{
-    readonly kind: "unique";
-    readonly columns: NormalizeColumns<Columns>;
-}>;
-/** Declares a table-level index. */
-export declare const index: <const Columns extends string | readonly string[]>(columns: Columns) => TableOption<{
-    readonly kind: "index";
-    readonly columns: NormalizeColumns<Columns>;
-}>;
-/** Declares a table-level foreign key. */
-export declare const foreignKey: <const LocalColumns extends string | readonly string[], TargetTable extends AnyTable, const TargetColumns extends string | readonly string[]>(columns: LocalColumns, target: () => TargetTable, referencedColumns: TargetColumns) => TableOption<{
-    readonly kind: "foreignKey";
-    readonly columns: NormalizeColumns<LocalColumns>;
-    readonly references: () => {
-        readonly tableName: string;
-        readonly schemaName?: string | undefined;
-        readonly columns: NormalizeColumns<TargetColumns>;
-        readonly knownColumns: readonly string[];
-    };
-}>;
-/** Declares a check constraint expression. */
-export declare const check: <Name extends string>(name: Name, predicate: DdlExpressionLike) => TableOption<{
-    readonly kind: "check";
-    readonly name: Name;
-    readonly predicate: DdlExpressionLike;
-}>;
-/** Extracts the row type of a table's select schema. */
-export type SelectOf<Table extends {
-    readonly schemas: {
-        readonly select: Schema.Schema<any>;
-    };
-}> = Schema.Schema.Type<Table["schemas"]["select"]>;
-/** Extracts the payload type of a table's insert schema. */
-export type InsertOf<Table extends {
-    readonly schemas: {
-        readonly insert: Schema.Schema<any>;
-    };
-}> = Schema.Schema.Type<Table["schemas"]["insert"]>;
-/** Extracts the payload type of a table's update schema. */
-export type UpdateOf<Table extends {
-    readonly schemas: {
-        readonly update: Schema.Schema<any>;
-    };
-}> = Schema.Schema.Type<Table["schemas"]["update"]>;