@vantreeseba/drizzle-graphql 9.1.0 → 10.0.0

package/dist/index.d.cts

@@ -1,11 +1,13 @@
-import { Column, Table, Relation, SQL, TablesRelationalConfig, One, Many } from 'drizzle-orm';
-import { MySqlAsyncDatabase } from 'drizzle-orm/mysql-core';
-import { PgAsyncDatabase } from 'drizzle-orm/pg-core';
-import { SQLiteAsyncDatabase } from 'drizzle-orm/sqlite-core';
-import { ASTNode, GraphQLError, GraphQLScalarType, GraphQLOutputType, GraphQLInputType, GraphQLFieldResolver, GraphQLResolveInfo, GraphQLSchema, GraphQLInputObjectType, GraphQLObjectType, GraphQLNonNull, GraphQLList, GraphQLEnumType } from 'graphql';
-import { ResolveTree } from 'graphql-parse-resolve-info';
-export { GraphQLDate, GraphQLDateTime, GraphQLJSON, GraphQLUUID } from 'graphql-scalars';
-
+import { Column, Many, One, Relation, SQL, Table, TablesRelationalConfig } from "drizzle-orm";
+import { MySqlAsyncDatabase } from "drizzle-orm/mysql-core";
+import "drizzle-orm/mysql-core/query-builders/query";
+import { PgAsyncDatabase } from "drizzle-orm/pg-core";
+import "drizzle-orm/pg-core/query-builders/query";
+import { SQLiteAsyncDatabase } from "drizzle-orm/sqlite-core";
+import "drizzle-orm/sqlite-core/query-builders/query";
+import { ASTNode, GraphQLEnumType, GraphQLError, GraphQLFieldResolver, GraphQLInputObjectType, GraphQLInputType, GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLOutputType, GraphQLResolveInfo, GraphQLScalarType, GraphQLSchema } from "graphql";
+import { GraphQLDate, GraphQLDateTime, GraphQLJSON, GraphQLUUID } from "graphql-scalars";
+//#region src/util/extensions.d.ts
 /**
  * The identity a generated field publishes about itself, under `extensions.drizzle`.
  *
@@ -27,48 +29,48 @@ type DrizzleFieldOperation = 'select' | 'insert' | 'update' | 'updateMany' | 'up
 type DrizzleTargetArg = 'where' | 'values' | 'updates';
 /** `extensions.drizzle` on a generated field. */
 type DrizzleFieldExtension = {
-    /** The Drizzle schema key of the table the field reads or writes. */
-    table: string;
-    kind: Exclude<DrizzleFieldKind, 'type'>;
-    operation: DrizzleFieldOperation;
-    /** Whether the field resolves to one row (or one aggregate) rather than a list. */
-    single: boolean;
-    /**
-     * Which argument names the rows: `where` for select/update/delete/aggregate, `values`
-     * for insert and upsert, `updates` for the batch update's per-entry `{ where, set }`.
-     * Absent when the field takes no such argument.
-     */
-    targetArg?: DrizzleTargetArg;
-    /**
-     * Primary-key property names of `table`, in schema order. Empty when the table declares
-     * no primary key. Carried here so {@link identifyRows} works from the field alone.
-     */
-    primaryKey: readonly string[];
-    /**
-     * For `operation: 'delete'` on a soft-deleting table that opted into `hardDelete`: the
-     * field takes a `hard` argument that issues a real `DELETE` rather than writing the marker.
-     * Absent everywhere else, so a wrapper can gate purging without parsing arguments.
-     */
-    hardDelete?: boolean;
-    /** For `kind: 'relation'` and `operation: 'relationAggregate'`: the relation's name. */
-    relation?: string;
-    /** For `kind: 'relation'` and `operation: 'relationAggregate'`: the table it hangs off. */
-    parentTable?: string;
+  /** The Drizzle schema key of the table the field reads or writes. */
+  table: string;
+  kind: Exclude<DrizzleFieldKind, 'type'>;
+  operation: DrizzleFieldOperation;
+  /** Whether the field resolves to one row (or one aggregate) rather than a list. */
+  single: boolean;
+  /**
+   * Which argument names the rows: `where` for select/update/delete/aggregate, `values`
+   * for insert and upsert, `updates` for the batch update's per-entry `{ where, set }`.
+   * Absent when the field takes no such argument.
+   */
+  targetArg?: DrizzleTargetArg;
+  /**
+   * Primary-key property names of `table`, in schema order. Empty when the table declares
+   * no primary key. Carried here so {@link identifyRows} works from the field alone.
+   */
+  primaryKey: readonly string[];
+  /**
+   * For `operation: 'delete'` on a soft-deleting table that opted into `hardDelete`: the
+   * field takes a `hard` argument that issues a real `DELETE` rather than writing the marker.
+   * Absent everywhere else, so a wrapper can gate purging without parsing arguments.
+   */
+  hardDelete?: boolean;
+  /** For `kind: 'relation'` and `operation: 'relationAggregate'`: the relation's name. */
+  relation?: string;
+  /** For `kind: 'relation'` and `operation: 'relationAggregate'`: the table it hangs off. */
+  parentTable?: string;
 };
 /** `extensions.drizzle` on a generated object type. */
 type DrizzleTypeExtension = {
-    /** The Drizzle schema key this type was generated from. */
-    table: string;
-    kind: 'type';
-    /** Primary-key property names of `table`, in schema order. Empty when there is none. */
-    primaryKey: readonly string[];
+  /** The Drizzle schema key this type was generated from. */
+  table: string;
+  kind: 'type';
+  /** Primary-key property names of `table`, in schema order. Empty when there is none. */
+  primaryKey: readonly string[];
 };
 type DrizzleExtension = DrizzleFieldExtension | DrizzleTypeExtension;
 /** Anything carrying GraphQL `extensions` — a field config, a field, or a named type. */
 type WithExtensions = {
-    extensions?: {
-        drizzle?: unknown;
-    } | null;
+  extensions?: {
+    drizzle?: unknown;
+  } | null;
 } | null | undefined;
 /**
  * Reads the `drizzle` extension off a field or type, typed. Returns `undefined` for
@@ -80,22 +82,22 @@ declare const drizzleExtension: (target: WithExtensions) => DrizzleExtension | u
 declare const isDrizzleFieldExtension: (value: DrizzleExtension | undefined) => value is DrizzleFieldExtension;
 /** The rows a field's arguments name. */
 type IdentifiedRows = {
-    /** The Drizzle schema key of the table being read or written. */
-    table: string;
-    /** Primary-key property names, in schema order. */
-    primaryKey: readonly string[];
-    /** One entry per identified row: the primary-key values, keyed by property name. */
-    rows: Record<string, unknown>[];
-    /**
-     * Whether `rows` is exactly the set the operation affects.
-     *
-     * `false` means the arguments do not pin the rows down — an insert whose key the
-     * database generates, a `where` that filters on something other than the primary key,
-     * a plural update with no filter at all, or a table with no primary key. `rows` is then
-     * a best-effort subset-free superset: every entry in it is a row the key values name,
-     * but other filters may narrow the real set further, and it may be empty.
-     */
-    complete: boolean;
+  /** The Drizzle schema key of the table being read or written. */
+  table: string;
+  /** Primary-key property names, in schema order. */
+  primaryKey: readonly string[];
+  /** One entry per identified row: the primary-key values, keyed by property name. */
+  rows: Record<string, unknown>[];
+  /**
+   * Whether `rows` is exactly the set the operation affects.
+   *
+   * `false` means the arguments do not pin the rows down — an insert whose key the
+   * database generates, a `where` that filters on something other than the primary key,
+   * a plural update with no filter at all, or a table with no primary key. `rows` is then
+   * a best-effort subset-free superset: every entry in it is a row the key values name,
+   * but other filters may narrow the real set further, and it may be empty.
+   */
+  complete: boolean;
 };
 /**
  * The rows a generated field's arguments are about, as primary-key values.
@@ -115,53 +117,56 @@ type IdentifiedRows = {
  * `complete` before treating `rows` as the affected set — see {@link IdentifiedRows}.
  */
 declare const identifyRows: (field: WithExtensions, args: Record<string, unknown> | undefined) => IdentifiedRows | undefined;
-
+//#endregion
+//#region src/util/builders/common/errors.d.ts
 /**
  * The classification of an error drizzle-graphql raised itself, published as
  * `extensions.code`. A consumer maps these onto its own vocabulary; the prose is written for
  * a client to read and may be reworded in any release, so it is not something to match on.
  */
-type DrizzleErrorCode = 
+type DrizzleErrorCode =
 /** A `Single` write's `where` matched more than one row, so nothing was written. */
-'DRIZZLE_MULTI_ROW_MATCH'
+'DRIZZLE_MULTI_ROW_MATCH' |
 /** A write that refuses to run unbounded was given no `where`, or one matching every row. */
- | 'DRIZZLE_WHERE_REQUIRED'
+'DRIZZLE_WHERE_REQUIRED' |
 /** The requested `limit` is above the maximum the field's limit policy allows. */
- | 'DRIZZLE_LIMIT_EXCEEDED'
+'DRIZZLE_LIMIT_EXCEEDED' |
 /** A write's `values` / `set` carried nothing to write. */
- | 'DRIZZLE_NO_VALUES'
+'DRIZZLE_NO_VALUES' |
 /** An insert reported no row back, so there is nothing to return or attach. */
- | 'DRIZZLE_NO_ROW_RETURNED'
+'DRIZZLE_NO_ROW_RETURNED' |
 /** The driver reported no row count for a returnless write. */
- | 'DRIZZLE_ROW_COUNT_UNAVAILABLE'
+'DRIZZLE_ROW_COUNT_UNAVAILABLE' |
 /** A nested write was passed to a field that cannot run one. */
- | 'DRIZZLE_NESTED_WRITES_UNSUPPORTED'
+'DRIZZLE_NESTED_WRITES_UNSUPPORTED' |
 /** A nested `create` / `connect` / `disconnect` / `set` operand was not usable. */
- | 'DRIZZLE_NESTED_WRITE_INVALID'
+'DRIZZLE_NESTED_WRITE_INVALID' |
 /** A `groupBy` named no column, or one that cannot be grouped by. */
- | 'DRIZZLE_INVALID_GROUP_BY'
+'DRIZZLE_INVALID_GROUP_BY' |
 /** An `after` cursor did not decode, or was issued for a different ordering. */
- | 'DRIZZLE_INVALID_CURSOR'
+'DRIZZLE_INVALID_CURSOR' |
 /** A `where` key was not a filter of the table, or a relation was used as one. */
- | 'DRIZZLE_INVALID_FILTER'
+'DRIZZLE_INVALID_FILTER' |
 /** A column's update operations input held none, or more than one. */
- | 'DRIZZLE_INVALID_UPDATE_OPERATION'
+'DRIZZLE_INVALID_UPDATE_OPERATION' |
 /** A configured `scope` hook returned something that is not a predicate. */
- | 'DRIZZLE_INVALID_SCOPE'
+'DRIZZLE_INVALID_SCOPE' |
 /** An `orderBy` named something that cannot be ordered by in this query. */
- | 'DRIZZLE_INVALID_ORDER_BY'
+'DRIZZLE_INVALID_ORDER_BY' |
 /** `distinct` was asked for where it cannot be applied. */
- | 'DRIZZLE_INVALID_DISTINCT'
+'DRIZZLE_INVALID_DISTINCT' |
 /** An `onConflict` named a target or update column the upsert cannot use. */
- | 'DRIZZLE_INVALID_ON_CONFLICT'
+'DRIZZLE_INVALID_ON_CONFLICT' |
 /** A written value could not be converted to what its column stores. */
- | 'DRIZZLE_INVALID_INPUT_VALUE'
+'DRIZZLE_INVALID_INPUT_VALUE' |
+/** An update's `set` gave a column that cannot hold null an explicit null. */
+'DRIZZLE_NOT_NULL' |
 /** A write's input named a key that is not a column of the table. */
- | 'DRIZZLE_UNKNOWN_COLUMN'
+'DRIZZLE_UNKNOWN_COLUMN' |
 /** A stored value could not be represented by the scalar that transports it. */
- | 'DRIZZLE_UNREPRESENTABLE_VALUE'
+'DRIZZLE_UNREPRESENTABLE_VALUE' |
 /** The request's shared mutation transaction was rolled back, so this field never ran. */
- | 'DRIZZLE_TRANSACTION_ABORTED';
+'DRIZZLE_TRANSACTION_ABORTED';
 /**
  * What an error was about, published as `extensions.drizzle` beside the code — the runtime
  * half of the `extensions.drizzle` markers a generated field carries.
@@ -172,13 +177,13 @@ type DrizzleErrorCode =
  * of. The name the client asked for is already in the error's `path`.
  */
 type DrizzleErrorContext = {
-    /** The Drizzle schema key of the table the field reads or writes. */
-    table?: string;
-    operation?: DrizzleFieldOperation;
-    /** The generated field's own name, pre-rename. */
-    field?: string;
-    /** For a relation field: the relation's name. */
-    relation?: string;
+  /** The Drizzle schema key of the table the field reads or writes. */
+  table?: string;
+  operation?: DrizzleFieldOperation;
+  /** The generated field's own name, pre-rename. */
+  field?: string;
+  /** For a relation field: the relation's name. */
+  relation?: string;
 };
 /**
  * A `GraphQLError` carrying its context as data. The message says what went wrong, in prose
@@ -186,9 +191,9 @@ type DrizzleErrorContext = {
  * table, operation and generated field it came from.
  */
 declare const drizzleError: (message: string, { code, nodes, ...context }: DrizzleErrorContext & {
-    code: DrizzleErrorCode;
-    /** The AST the error is about, where the throw site has one — it becomes the `locations`. */
-    nodes?: ASTNode | readonly ASTNode[];
+  code: DrizzleErrorCode;
+  /** The AST the error is about, where the throw site has one — it becomes the `locations`. */
+  nodes?: ASTNode | readonly ASTNode[];
 }) => GraphQLError;
 /**
  * Default for `config.onError`: keeps drizzle-graphql's own errors, which are written for
@@ -197,12 +202,13 @@ declare const drizzleError: (message: string, { code, nodes, ...context }: Drizz
  * The original is preserved on `originalError` for server-side logging.
  */
 declare const defaultErrorMapper: (error: unknown) => unknown;
-
+//#endregion
+//#region src/util/builders/common/limits.d.ts
 /** {@link BuildSchemaConfig.limits} resolved for one table. `undefined` means no policy. */
 type ResolvedLimitPolicy = {
-    defaultLimit: number | undefined;
-    maxLimit: number | undefined;
-    clampToMax: boolean;
+  defaultLimit: number | undefined;
+  maxLimit: number | undefined;
+  clampToMax: boolean;
 };
 /**
  * Looks up the limit policy for a table by its Drizzle schema key. Built once per schema by
@@ -216,15 +222,16 @@ type LimitPolicyFor = (tableName: string) => ResolvedLimitPolicy | undefined;
  * returns.
  */
 type DefaultOrderByFor = (tableName: string) => Record<string, any> | undefined;
-
+//#endregion
+//#region src/util/type-converter/types.d.ts
 /**
  * A scalar override for one column. A bare scalar applies to both directions; the object form
  * lets output (object type, aggregate min/max) and input (create/update inputs, filter operands)
  * use different scalars — or override only one side, leaving the other on built-in detection.
  */
 type ScalarOverride = GraphQLScalarType | {
-    output?: GraphQLScalarType;
-    input?: GraphQLScalarType;
+  output?: GraphQLScalarType;
+  input?: GraphQLScalarType;
 };
 /**
  * Declarative per-table, per-column scalar overrides. Keys are the Drizzle schema keys —
@@ -233,18 +240,18 @@ type ScalarOverride = GraphQLScalarType | {
 type ScalarOverridesConfig = Record<string, Record<string, ScalarOverride>>;
 /** Context handed to {@link ColumnTypeMapper} alongside the column itself. */
 type ColumnTypeMapperInfo = {
-    /** The table's key in the Drizzle schema object. */
-    tableName: string;
-    /** The column's property name on the table object. */
-    columnName: string;
-    /**
-     * The GraphQL type built-in detection would use for output positions (without nullability
-     * wrapping). `undefined` when detection has no mapping for the column's data type — the
-     * mapper is then the only way to give the column a type.
-     */
-    defaultType: GraphQLOutputType | undefined;
-    /** The input-position counterpart of `defaultType`. */
-    defaultInputType: GraphQLInputType | undefined;
+  /** The table's key in the Drizzle schema object. */
+  tableName: string;
+  /** The column's property name on the table object. */
+  columnName: string;
+  /**
+   * The GraphQL type built-in detection would use for output positions (without nullability
+   * wrapping). `undefined` when detection has no mapping for the column's data type — the
+   * mapper is then the only way to give the column a type.
+   */
+  defaultType: GraphQLOutputType | undefined;
+  /** The input-position counterpart of `defaultType`. */
+  defaultInputType: GraphQLInputType | undefined;
 };
 /**
  * Rule-based scalar mapping, called once per column at build time. Return a scalar (or
@@ -254,20 +261,20 @@ type ColumnTypeMapperInfo = {
 type ColumnTypeMapper = (column: Column, info: ColumnTypeMapperInfo) => ScalarOverride | undefined;
 /** Everything an {@link EnumNameMapper} needs to name — or opt a column out of — a generated enum type. */
 type EnumNameInfo = {
-    /**
-     * The name the enum type was declared with (`pgEnum('status', …)`), shared by every column
-     * that uses it. `undefined` for an inline value list (`text({ enum: [...] })`,
-     * `mysqlEnum(...)`), which belongs to the one column that declares it.
-     */
-    enumName: string | undefined;
-    /** The Postgres schema the named enum was declared in, when it declares one. */
-    schema: string | undefined;
-    /** The table's key in the Drizzle schema object. */
-    tableName: string;
-    /** The column's property name on the table object. */
-    columnName: string;
-    /** The enum's values, in declaration order. */
-    values: readonly string[];
+  /**
+   * The name the enum type was declared with (`pgEnum('status', …)`), shared by every column
+   * that uses it. `undefined` for an inline value list (`text({ enum: [...] })`,
+   * `mysqlEnum(...)`), which belongs to the one column that declares it.
+   */
+  enumName: string | undefined;
+  /** The Postgres schema the named enum was declared in, when it declares one. */
+  schema: string | undefined;
+  /** The table's key in the Drizzle schema object. */
+  tableName: string;
+  /** The column's property name on the table object. */
+  columnName: string;
+  /** The enum's values, in declaration order. */
+  values: readonly string[];
 };
 /**
  * Names a generated GraphQL enum type. Return `undefined` to keep the default name. See
@@ -276,10 +283,10 @@ type EnumNameInfo = {
 type EnumNameMapper = (info: EnumNameInfo) => string | undefined;
 /** Context handed to the documentation and deprecation hooks alongside the column itself. */
 type ColumnDocInfo = {
-    /** The table's key in the Drizzle schema object. */
-    tableName: string;
-    /** The column's property name on the table object. */
-    columnName: string;
+  /** The table's key in the Drizzle schema object. */
+  tableName: string;
+  /** The column's property name on the table object. */
+  columnName: string;
 };
 /**
  * Supplies the GraphQL `description` for a generated column field. See
@@ -304,117 +311,109 @@ type RelationDescriber = (tableName: string, relationName: string) => string | u
  * descriptions at all.
  */
 type SchemaDocs = {
-    describeColumn?: ColumnDescriber;
-    describeTable?: TableDescriber;
-    describeRelation?: RelationDescriber;
-    deprecateColumn?: ColumnDeprecator;
+  describeColumn?: ColumnDescriber;
+  describeTable?: TableDescriber;
+  describeRelation?: RelationDescriber;
+  deprecateColumn?: ColumnDeprecator;
 };
-
+//#endregion
+//#region src/util/builders/types.d.ts
 type TableNamedRelations = {
-    relation: Relation;
-    targetTableName: string;
-    /**
-     * Property names of the target table's primary key, resolved at build time (composite
-     * keys included, via the dialect's getTableConfig). Used to default paginated relations
-     * to a deterministic PK order. Empty when the target has no detectable primary key.
-     */
-    targetPkNames?: readonly string[];
+  relation: Relation;
+  targetTableName: string;
+  /**
+   * Property names of the target table's primary key, resolved at build time (composite
+   * keys included, via the dialect's getTableConfig). Used to default paginated relations
+   * to a deterministic PK order. Empty when the target has no detectable primary key.
+   */
+  targetPkNames?: readonly string[];
 };
 type ColTypeIsNull<TColumn extends Column, TColType> = TColumn['_']['notNull'] extends true ? TColType : TColType | null;
 type ColTypeIsNullOrUndefinedWithDefault<TColumn extends Column, TColType> = TColumn['_']['notNull'] extends true ? TColumn['_']['hasDefault'] extends true ? TColType | null | undefined : TColumn['defaultFn'] extends undefined ? TColType : TColType | null | undefined : TColType | null | undefined;
 type GetColumnGqlDataType<TColumn extends Column> = TColumn['dataType'] extends 'boolean' ? ColTypeIsNull<TColumn, boolean> : TColumn['dataType'] extends 'json' ? TColumn['columnType'] extends 'PgGeometryObject' ? ColTypeIsNull<TColumn, {
-    x: number;
-    y: number;
+  x: number;
+  y: number;
 }> : ColTypeIsNull<TColumn, string> : TColumn['dataType'] extends 'date' | 'string' | 'bigint' ? TColumn['enumValues'] extends [string, ...string[]] ? ColTypeIsNull<TColumn, TColumn['enumValues'][number]> : ColTypeIsNull<TColumn, string> : TColumn['dataType'] extends 'number' ? ColTypeIsNull<TColumn, number> : TColumn['dataType'] extends 'buffer' ? ColTypeIsNull<TColumn, number[]> : TColumn['dataType'] extends 'array' ? TColumn['columnType'] extends 'PgVector' ? ColTypeIsNull<TColumn, number[]> : TColumn['columnType'] extends 'PgGeometry' ? ColTypeIsNullOrUndefinedWithDefault<TColumn, [number, number]> : ColTypeIsNull<TColumn, Array<GetColumnGqlDataType<TColumn extends {
-    baseColumn: Column;
-} ? TColumn['baseColumn'] : never> extends infer InnerColType ? InnerColType extends null | undefined ? never : InnerColType : never>> : never;
+  baseColumn: Column;
+} ? TColumn['baseColumn'] : never> extends (infer InnerColType) ? InnerColType extends null | undefined ? never : InnerColType : never>> : never;
 type GetColumnGqlInsertDataType<TColumn extends Column> = TColumn['dataType'] extends 'boolean' ? ColTypeIsNullOrUndefinedWithDefault<TColumn, boolean> : TColumn['dataType'] extends 'json' ? TColumn['columnType'] extends 'PgGeometryObject' ? ColTypeIsNullOrUndefinedWithDefault<TColumn, {
-    x: number;
-    y: number;
+  x: number;
+  y: number;
 }> : ColTypeIsNullOrUndefinedWithDefault<TColumn, string> : TColumn['dataType'] extends 'date' | 'string' | 'bigint' ? TColumn['enumValues'] extends [string, ...string[]] ? ColTypeIsNullOrUndefinedWithDefault<TColumn, TColumn['enumValues'][number]> : ColTypeIsNullOrUndefinedWithDefault<TColumn, string> : TColumn['dataType'] extends 'number' ? ColTypeIsNullOrUndefinedWithDefault<TColumn, number> : TColumn['dataType'] extends 'buffer' ? ColTypeIsNullOrUndefinedWithDefault<TColumn, number[]> : TColumn['dataType'] extends 'array' ? TColumn['columnType'] extends 'PgVector' ? ColTypeIsNullOrUndefinedWithDefault<TColumn, number[]> : TColumn['columnType'] extends 'PgGeometry' ? ColTypeIsNullOrUndefinedWithDefault<TColumn, [number, number]> : ColTypeIsNullOrUndefinedWithDefault<TColumn, Array<GetColumnGqlDataType<TColumn extends {
-    baseColumn: Column;
-} ? TColumn['baseColumn'] : never> extends infer InnerColType ? InnerColType extends null | undefined ? never : InnerColType : never>> : never;
+  baseColumn: Column;
+} ? TColumn['baseColumn'] : never> extends (infer InnerColType) ? InnerColType extends null | undefined ? never : InnerColType : never>> : never;
 type GetColumnGqlUpdateDataType<TColumn extends Column> = TColumn['dataType'] extends 'boolean' ? boolean | null | undefined : TColumn['dataType'] extends 'json' ? TColumn['columnType'] extends 'PgGeometryObject' ? {
-    x: number;
-    y: number;
+  x: number;
+  y: number;
 } | null | undefined : string | null | undefined : TColumn['dataType'] extends 'date' | 'string' | 'bigint' ? TColumn['enumValues'] extends [string, ...string[]] ? TColumn['enumValues'][number] | null | undefined : string | null | undefined : TColumn['dataType'] extends 'number' ? number | null | undefined : TColumn['dataType'] extends 'buffer' ? number[] | null | undefined : TColumn['dataType'] extends 'array' ? TColumn['columnType'] extends 'PgVector' ? number[] | null | undefined : TColumn['columnType'] extends 'PgGeometry' ? [number, number] | null | undefined : Array<GetColumnGqlDataType<TColumn extends {
-    baseColumn: Column;
-} ? TColumn['baseColumn'] : never> extends infer InnerColType ? InnerColType extends null | undefined ? never : InnerColType : never> | null | undefined : never;
-type GetRemappedTableDataType<TTable extends Table, TColumns extends TTable['_']['columns'] = TTable['_']['columns']> = {
-    [K in keyof TColumns]: GetColumnGqlDataType<TColumns[K]>;
-};
-type GetRemappedTableInsertDataType<TTable extends Table> = {
-    [K in keyof TTable['_']['columns']]: GetColumnGqlInsertDataType<TTable['_']['columns'][K]>;
-};
-type GetRemappedTableUpdateDataType<TTable extends Table> = {
-    [K in keyof TTable['_']['columns']]: GetColumnGqlUpdateDataType<TTable['_']['columns'][K]>;
-};
+  baseColumn: Column;
+} ? TColumn['baseColumn'] : never> extends (infer InnerColType) ? InnerColType extends null | undefined ? never : InnerColType : never> | null | undefined : never;
+type GetRemappedTableDataType<TTable extends Table, TColumns extends TTable['_']['columns'] = TTable['_']['columns']> = { [K in keyof TColumns]: GetColumnGqlDataType<TColumns[K]>; };
+type GetRemappedTableInsertDataType<TTable extends Table> = { [K in keyof TTable['_']['columns']]: GetColumnGqlInsertDataType<TTable['_']['columns'][K]>; };
+type GetRemappedTableUpdateDataType<TTable extends Table> = { [K in keyof TTable['_']['columns']]: GetColumnGqlUpdateDataType<TTable['_']['columns'][K]>; };
 type FilterColumnOperatorsCore<TColumn extends Column, TColType = GetColumnGqlDataType<TColumn>> = Partial<{
-    eq: TColType;
-    ne: TColType;
-    lt: TColType;
-    lte: TColType;
-    gt: TColType;
-    gte: TColType;
-    like: string;
-    notLike: string;
-    ilike: string;
-    notIlike: string;
-    startsWith: string;
-    endsWith: string;
-    /**
-     * String columns: safe substring match (`%`, `_` and `\` matched literally).
-     * JSON columns: structural containment (Postgres `@>` / MySQL JSON_CONTAINS).
-     */
-    contains: string | TColType;
-    iStartsWith: string;
-    iEndsWith: string;
-    iContains: string;
-    inArray: Array<TColType>;
-    notInArray: Array<TColType>;
-    /** Array columns only: the array contains this element. */
-    has: TColType extends Array<infer TElement> ? TElement : never;
-    /** Array columns only: the array overlaps these elements (`&&`). */
-    hasSome: TColType extends Array<infer TElement> ? Array<TElement> : never;
-    /** Array columns only: the array contains all of these elements (`@>`). */
-    hasEvery: TColType extends Array<infer TElement> ? Array<TElement> : never;
-    /** Array columns only: when true, matches arrays with no elements. */
-    isEmpty: boolean;
-    isNull: boolean;
-    isNotNull: boolean;
-    /**
-     * String columns: compares every operator in this object case-insensitively
-     * (`lower(column)` against `lower(operand)`). Applies to the operators beside it only —
-     * a nested `AND`/`OR`/`NOT` branch sets its own.
-     */
-    insensitive: boolean;
-}>;
-type FiltersCore<TTable extends Table> = Partial<{
-    [Column in keyof TTable['_']['columns']]: FilterColumnOperatorsCore<TTable['_']['columns'][Column]>;
+  eq: TColType;
+  ne: TColType;
+  lt: TColType;
+  lte: TColType;
+  gt: TColType;
+  gte: TColType;
+  like: string;
+  notLike: string;
+  ilike: string;
+  notIlike: string;
+  startsWith: string;
+  endsWith: string;
+  /**
+   * String columns: safe substring match (`%`, `_` and `\` matched literally).
+   * JSON columns: structural containment (Postgres `@>` / MySQL JSON_CONTAINS).
+   */
+  contains: string | TColType;
+  iStartsWith: string;
+  iEndsWith: string;
+  iContains: string;
+  inArray: Array<TColType>;
+  notInArray: Array<TColType>;
+  /** Array columns only: the array contains this element. */
+  has: TColType extends Array<infer TElement> ? TElement : never;
+  /** Array columns only: the array overlaps these elements (`&&`). */
+  hasSome: TColType extends Array<infer TElement> ? Array<TElement> : never;
+  /** Array columns only: the array contains all of these elements (`@>`). */
+  hasEvery: TColType extends Array<infer TElement> ? Array<TElement> : never;
+  /** Array columns only: when true, matches arrays with no elements. */
+  isEmpty: boolean;
+  isNull: boolean;
+  isNotNull: boolean;
+  /**
+   * String columns: compares every operator in this object case-insensitively
+   * (`lower(column)` against `lower(operand)`). Applies to the operators beside it only —
+   * a nested `AND`/`OR`/`NOT` branch sets its own.
+   */
+  insensitive: boolean;
 }>;
+type FiltersCore<TTable extends Table> = Partial<{ [Column in keyof TTable['_']['columns']]: FilterColumnOperatorsCore<TTable['_']['columns'][Column]>; }>;
 type Filters<TTable extends Table, TFilterType = FiltersCore<TTable>> = TFilterType & {
-    OR?: Filters<TTable, TFilterType>[];
-    AND?: Filters<TTable, TFilterType>[];
-    NOT?: Filters<TTable, TFilterType>;
-};
-type OrderByArgs<TTable extends Table> = {
-    [Key in keyof TTable['_']['columns']]?: {
-        direction: 'asc' | 'desc';
-        priority: number;
-        /**
-         * Where NULL values sort. Native NULLS FIRST/LAST on PostgreSQL and SQLite;
-         * emulated with an extra `IS NULL` sort key on MySQL.
-         */
-        nulls?: 'first' | 'last';
-        /**
-         * Sort by the column's position in the `inArray` list the same request's `where` gives
-         * it, rather than by the column's own value. Requires that `inArray` filter; cannot be
-         * combined with `after` or `distinct`.
-         */
-        matchFilterOrder?: boolean;
-    };
+  OR?: Filters<TTable, TFilterType>[];
+  AND?: Filters<TTable, TFilterType>[];
+  NOT?: Filters<TTable, TFilterType>;
 };
-
+type OrderByArgs<TTable extends Table> = { [Key in keyof TTable['_']['columns']]?: {
+  direction: 'asc' | 'desc';
+  priority: number;
+  /**
+   * Where NULL values sort. Native NULLS FIRST/LAST on PostgreSQL and SQLite;
+   * emulated with an extra `IS NULL` sort key on MySQL.
+   */
+  nulls?: 'first' | 'last';
+  /**
+   * Sort by the column's position in the `inArray` list the same request's `where` gives
+   * it, rather than by the column's own value. Requires that `inArray` filter; cannot be
+   * combined with `after` or `distinct`.
+   */
+  matchFilterOrder?: boolean;
+}; };
+//#endregion
+//#region src/util/builders/common/type-names.d.ts
 /**
  * What a generated type is, so a name mapper can answer for one kind without matching on the
  * spelling of the default name.
@@ -435,18 +434,18 @@ type OrderByArgs<TTable extends Table> = {
 type GeneratedTypeKind = 'object' | 'filter' | 'listRelationFilter' | 'orderBy' | 'createInput' | 'updateInput' | 'updateManyInput' | 'nestedWriteInput' | 'fieldUpdateInput' | 'aggregate' | 'having' | 'groupBy' | 'groupKeys' | 'onConflict' | 'uniqueKey' | 'columnEnum' | 'columnFilter' | 'shared';
 /** What a name mapper is told about the type it is being asked to name. */
 interface GeneratedTypeInfo {
-    /** Which kind of generated type this is. */
-    kind: GeneratedTypeKind;
-    /** The name the library would use, before any prefix or suffix. */
-    defaultName: string;
-    /** The table key the type belongs to, where it belongs to one. */
-    table?: string;
-    /**
-     * The narrower thing the type is for, where the kind alone does not say: the aggregate
-     * operation (`sum`, `avg`, …), the relation a nested-write input is for, the scalar a
-     * column filter covers, the columns of a unique key.
-     */
-    operation?: string;
+  /** Which kind of generated type this is. */
+  kind: GeneratedTypeKind;
+  /** The name the library would use, before any prefix or suffix. */
+  defaultName: string;
+  /** The table key the type belongs to, where it belongs to one. */
+  table?: string;
+  /**
+   * The narrower thing the type is for, where the kind alone does not say: the aggregate
+   * operation (`sum`, `avg`, …), the relation a nested-write input is for, the scalar a
+   * column filter covers, the columns of a unique key.
+   */
+  operation?: string;
 }
 /**
  * Renames a generated type. Return `undefined` — or the same name — to keep the default,
@@ -454,41 +453,44 @@ interface GeneratedTypeInfo {
  * build's prefix or suffix.
  */
 type DerivedTypeNameMapper = (info: GeneratedTypeInfo) => string | undefined;
-
+//#endregion
+//#region src/util/builders/common/naming.d.ts
 /** Optional mapper from table key to singular/plural name pair. Return undefined to use default naming for a table. */
 type TypeNameMapper = (tableName: string) => {
-    singular: string;
-    plural: string;
+  singular: string;
+  plural: string;
 } | undefined;
-
+//#endregion
+//#region src/util/builders/common/unique-keys.d.ts
 /** A table's unique-key `where` fields: field name → the constraint's member property names. */
 type UniqueKeyMap = Record<string, readonly string[]>;
-
+//#endregion
+//#region src/util/builders/common/relation-filters.d.ts
 /**
  * Everything `extractFilters` needs to turn a relation key in a `where` argument into a
  * correlated subquery. Omitted by callers that don't generate relation filters, in which case
  * relation keys can't appear in the input to begin with.
  */
 interface RelationFilterContext {
-    /** Every table in the schema, keyed by its schema key. */
-    tables: Record<string, Table>;
-    /** Relations keyed by table schema key, then relation name. */
-    relationMap: Record<string, Record<string, TableNamedRelations>>;
-    /**
-     * Schema key of the table being filtered. Not always the same as the `tableName` label
-     * used in error messages (relation `where` callbacks pass the relation name there).
-     */
-    tableKey: string;
-    /** Shared counter making every subquery alias unique within one extraction. */
-    aliases?: {
-        n: number;
-    };
-    /**
-     * The compound-unique-key `where` fields of each table, keyed by table schema key. Only
-     * populated when `features.uniqueKeyFilters` generated them — a key field the build did not
-     * generate is an unknown filter key like any other.
-     */
-    uniqueKeys?: Record<string, UniqueKeyMap>;
+  /** Every table in the schema, keyed by its schema key. */
+  tables: Record<string, Table>;
+  /** Relations keyed by table schema key, then relation name. */
+  relationMap: Record<string, Record<string, TableNamedRelations>>;
+  /**
+   * Schema key of the table being filtered. Not always the same as the `tableName` label
+   * used in error messages (relation `where` callbacks pass the relation name there).
+   */
+  tableKey: string;
+  /** Shared counter making every subquery alias unique within one extraction. */
+  aliases?: {
+    n: number;
+  };
+  /**
+   * The compound-unique-key `where` fields of each table, keyed by table schema key. Only
+   * populated when `features.uniqueKeyFilters` generated them — a key field the build did not
+   * generate is an unknown filter key like any other.
+   */
+  uniqueKeys?: Record<string, UniqueKeyMap>;
 }
 /**
  * The build-scoped half of {@link RelationFilterContext}. Created once per generated schema and
@@ -496,45 +498,47 @@ interface RelationFilterContext {
  */
 type RelationFilterBase = Pick<RelationFilterContext, 'tables' | 'relationMap' | 'uniqueKeys'>;
 declare const extractFilters: <TTable extends Table>(table: TTable, tableName: string, filters: Filters<TTable>, relationCtx?: RelationFilterContext) => SQL | undefined;
-
+//#endregion
+//#region src/util/builders/common/write-hooks.d.ts
 /** The write a hook is attached to. `restore` only exists for a soft-deleting table. */
 type WriteOperation = 'insert' | 'update' | 'updateMany' | 'upsert' | 'delete' | 'restore';
 /** What a write hook is handed. See {@link BuildSchemaConfig.onWrite}. */
 type WriteHookPayload = {
-    /** Drizzle schema key of the table being written. */
-    table: string;
-    operation: WriteOperation;
-    /** `'before'` runs ahead of the statement, `'after'` once it has returned. */
-    position: 'before' | 'after';
-    /** Whether the field writes a single row (`createUsersSingle`) or a list. */
-    single: boolean;
-    /** The field's GraphQL arguments, exactly as the resolver received them. */
-    args: any;
-    /**
-     * The rows the write produced, as the database returned them — before the output mapper,
-     * so values are database-shaped. Empty at the `before` position, and on MySQL, whose
-     * mutations return no rows.
-     */
-    rows: any[];
-    context: any;
-    info: any;
-    /** The executor the mutation itself ran on. Throwing from the hook rolls it back. */
-    tx: any;
+  /** Drizzle schema key of the table being written. */
+  table: string;
+  operation: WriteOperation;
+  /** `'before'` runs ahead of the statement, `'after'` once it has returned. */
+  position: 'before' | 'after';
+  /** Whether the field writes a single row (`createUsersSingle`) or a list. */
+  single: boolean;
+  /** The field's GraphQL arguments, exactly as the resolver received them. */
+  args: any;
+  /**
+   * The rows the write produced, as the database returned them — before the output mapper,
+   * so values are database-shaped. Empty at the `before` position, and on MySQL, whose
+   * mutations return no rows.
+   */
+  rows: any[];
+  context: any;
+  info: any;
+  /** The executor the mutation itself ran on. Throwing from the hook rolls it back. */
+  tx: any;
 };
 type WriteHook = (payload: WriteHookPayload) => void | Promise<void>;
 type WriteHookPositions = {
-    before?: WriteHook;
-    after?: WriteHook;
+  before?: WriteHook;
+  after?: WriteHook;
 };
 type WriteHooks = WriteHook | WriteHookPositions;
 /** Resolved, per-field hooks: `undefined` when the table registered none. */
 type ResolvedWriteHooks = {
-    before?: WriteHook;
-    after?: WriteHook;
+  before?: WriteHook;
+  after?: WriteHook;
 };
 /** Build-time lookup of a table's hooks, installed on {@link TablePolicies}. */
 type WriteHookFor = (tableName: string, operation: WriteOperation) => ResolvedWriteHooks | undefined;
-
+//#endregion
+//#region src/util/builders/common/policies.d.ts
 /**
  * A table's row-level scope: the predicate every generated read, update and delete on that
  * table is narrowed by. See `BuildSchemaConfig.scope`.
@@ -559,30 +563,30 @@ type ScopeFor = (tableName: string) => ScopeHook | undefined;
  * takes the NULL-means-alive reading only when no marker was configured.
  */
 type SoftDeleteInfo = {
-    /** Property name of the column on the drizzle table — also the key on an aliased proxy. */
-    columnName: string;
-    column: Column;
-    nullable: boolean;
-    /** Evaluated per delete, so a timestamp form stamps the moment of the delete. */
-    writeDeleted: () => any;
-    /** Written by the restore mutation. */
-    writeRestored: any;
-    /**
-     * The constant that means "this row is deleted", when the config named one. Required on a
-     * NOT NULL column; optional on a nullable one, which otherwise reads NULL as alive.
-     */
-    marker?: any;
-    /**
-     * Which reads hide marked rows by default — `'all'` (the table's own fields and every
-     * relation pointing at it) or `'root'` (its own fields only). See
-     * {@link relationDeletedDefault}.
-     */
-    scope: 'root' | 'all';
-    /**
-     * Whether the delete mutations take a `hard` argument that issues a real `DELETE`. Off
-     * unless the table opts in, so the generated schema says which tables can be purged.
-     */
-    hardDelete: boolean;
+  /** Property name of the column on the drizzle table — also the key on an aliased proxy. */
+  columnName: string;
+  column: Column;
+  nullable: boolean;
+  /** Evaluated per delete, so a timestamp form stamps the moment of the delete. */
+  writeDeleted: () => any;
+  /** Written by the restore mutation. */
+  writeRestored: any;
+  /**
+   * The constant that means "this row is deleted", when the config named one. Required on a
+   * NOT NULL column; optional on a nullable one, which otherwise reads NULL as alive.
+   */
+  marker?: any;
+  /**
+   * Which reads hide marked rows by default — `'all'` (the table's own fields and every
+   * relation pointing at it) or `'root'` (its own fields only). See
+   * {@link relationDeletedDefault}.
+   */
+  scope: 'root' | 'all';
+  /**
+   * Whether the delete mutations take a `hard` argument that issues a real `DELETE`. Off
+   * unless the table opts in, so the generated schema says which tables can be purged.
+   */
+  hardDelete: boolean;
 };
 /** Build-time lookup: the soft-delete convention of a table, if it declares one. */
 type SoftDeleteFor = (tableName: string) => SoftDeleteInfo | undefined;
@@ -597,18 +601,66 @@ type ContextValuesFor = (tableName: string) => Record<string, ContextValueHook>
  * before doing any work — an unconfigured build generates exactly the SQL it did before.
  */
 type TablePolicies = {
-    /** See `BuildSchemaConfig.scope`. */
-    scope?: ScopeFor;
-    /** See `BuildSchemaConfig.contextValues`. */
-    contextValues?: ContextValuesFor;
-    /** See `BuildSchemaConfig.softDelete`. */
-    softDelete?: SoftDeleteFor;
-    /** See `BuildSchemaConfig.onWrite`. */
-    onWrite?: WriteHookFor;
-    /** See `BuildSchemaConfig.defaults`. */
-    defaultOrderBy?: DefaultOrderByFor;
+  /** See `BuildSchemaConfig.scope`. */
+  scope?: ScopeFor;
+  /** See `BuildSchemaConfig.contextValues`. */
+  contextValues?: ContextValuesFor;
+  /** See `BuildSchemaConfig.softDelete`. */
+  softDelete?: SoftDeleteFor;
+  /** See `BuildSchemaConfig.onWrite`. */
+  onWrite?: WriteHookFor;
+  /** See `BuildSchemaConfig.defaults`. */
+  defaultOrderBy?: DefaultOrderByFor;
 };
-
+//#endregion
+//#region src/util/parse-resolve-info.d.ts
+/**
+ * The selections made against one concrete type, keyed by the *response key* — the field's
+ * alias when it has one, otherwise its name. A selection spanning an abstract type has one
+ * entry per type condition it was written against (the interface or union itself included,
+ * when fields were selected directly on it).
+ */
+interface FieldsByTypeName {
+  [typeName: string]: {
+    [responseKey: string]: ResolveTree;
+  };
+}
+/** One selected field: what was asked for, under what alias, with which arguments. */
+interface ResolveTree {
+  /** The field name as declared in the schema. */
+  name: string;
+  /** The response key — the alias when the selection carried one, otherwise `name`. */
+  alias: string;
+  /** The field's arguments, coerced by graphql's own `getArgumentValues`. */
+  args: {
+    [argName: string]: unknown;
+  };
+  /** The field's own sub-selections, keyed by the type they were written against. */
+  fieldsByTypeName: FieldsByTypeName;
+}
+/** Options accepted by {@link parseResolveInfo}. */
+interface ParseResolveInfoOptions {
+  /**
+   * Whether to descend into sub-selections and fragments. Defaults to `true`; `false` reads
+   * only the root field's own name, alias and arguments.
+   */
+  deep?: boolean;
+}
+/**
+ * Reads the selection under a resolver's own field out of its `info`, as a tree of
+ * {@link ResolveTree} nodes.
+ *
+ * ```ts
+ * const parsed = parseResolveInfo(info, { deep: true })!;
+ * const selected = parsed.fieldsByTypeName['Users']; // keyed by response key
+ * ```
+ *
+ * Returns `undefined` when the resolver's field produced no node at all, which in practice
+ * means `info` carried no field nodes.
+ */
+declare const parseResolveInfo: (info: GraphQLResolveInfo, options?: ParseResolveInfoOptions) => ResolveTree | undefined;
+//#endregion
+//#region src/util/builders/common/order-by.d.ts
 /**
  * Compiles an `orderBy` argument into ORDER BY expressions, highest priority first.
  *
@@ -627,7 +679,8 @@ type TablePolicies = {
  * inputs cannot contain relation keys may omit it.
  */
 declare const extractOrderBy: <TTable extends Table, TArgs extends OrderByArgs<any> = OrderByArgs<TTable>>(table: TTable, orderArgs: TArgs, ctx?: RelationFilterContext, whereArgs?: Record<string, any>) => SQL[];
-
+//#endregion
+//#region src/util/builders/common/cursor.d.ts
 /**
  * Where a dialect's default sort places NULLs relative to non-NULL values:
  * - `nulls-largest` — PostgreSQL: NULLs sort as the largest values (last in ASC, first in DESC).
@@ -636,7 +689,8 @@ declare const extractOrderBy: <TTable extends Table, TArgs extends OrderByArgs<a
  * The keyset predicate has to agree with the dialect's ORDER BY, so each builder passes its own.
  */
 type NullOrdering = 'nulls-largest' | 'nulls-smallest';
-
+//#endregion
+//#region src/util/builders/common/executor.d.ts
 /**
  * Key on the GraphQL context object under which a caller can place a Drizzle transaction
  * (or any other executor: a pooled connection, a logging proxy). Every generated resolver
@@ -654,7 +708,8 @@ type NullOrdering = 'nulls-largest' | 'nulls-smallest';
  * both end up loaded in one process.
  */
 declare const drizzleExecutorKey: unique symbol;
-
+//#endregion
+//#region src/util/builders/common/relations.d.ts
 /**
  * Extracts the join column info from a drizzle-orm v1 Relation object.
  * Returns the JS property name of the local column on the parent table and the
@@ -662,17 +717,18 @@ declare const drizzleExecutorKey: unique symbol;
  * relation internals are not accessible.
  */
 declare const extractRelationJoinColumns: (relEntry: TableNamedRelations, parentTable: Table, targetTable: Table) => {
-    localColPropName: string;
-    foreignCol: Column;
-    foreignColPropName: string;
+  localColPropName: string;
+  foreignCol: Column;
+  foreignColPropName: string;
 } | undefined;
 type RelationResolverFactory = (params: {
-    tableName: string;
-    relationName: string;
-    relEntry: TableNamedRelations;
-    isOne: boolean;
+  tableName: string;
+  relationName: string;
+  relEntry: TableNamedRelations;
+  isOne: boolean;
 }) => GraphQLFieldResolver<any, any> | undefined;
-
+//#endregion
+//#region src/util/builders/common/relation-resolvers.d.ts
 /**
  * Creates a RelationResolverFactory that generates field-level resolvers for each relation.
  * Each resolver:
@@ -688,16 +744,16 @@ type RelationResolverFactory = (params: {
  * MySQL and SQLite.
  */
 declare const createRelationResolverFactory: (db: any, tables: Record<string, Table>, nullOrdering: NullOrdering, filterCtx?: RelationFilterBase, limits?: LimitPolicyFor, policies?: TablePolicies) => RelationResolverFactory;
-
+//#endregion
+//#region src/types.d.ts
 type Relations<TTable extends string = string, TConfig extends Record<string, Relation> = Record<string, Relation>> = {
-    table: {
-        _: {
-            name: TTable;
-        };
+  table: {
+    _: {
+      name: TTable;
     };
-    config: (helpers: unknown) => TConfig;
+  };
+  config: (helpers: unknown) => TConfig;
 };
-
 type AnyDrizzleDB<TSchema extends Record<string, any>> = PgAsyncDatabase<any, TSchema> | SQLiteAsyncDatabase<any, any, TSchema> | MySqlAsyncDatabase<any, TSchema>;
 /**
  * The tables a database handle knows about, keyed by their schema key.
@@ -709,51 +765,41 @@ type AnyDrizzleDB<TSchema extends Record<string, any>> = PgAsyncDatabase<any, TS
  * The two branches differ in one detail: a module's members are `readonly`, a
  * relations config's are not, so the derived entity types are `readonly` only on that path.
  */
-type ExtractTables<TSchema extends Record<string, Table | unknown>> = TSchema extends TablesRelationalConfig ? {
-    [K in keyof TSchema]: TSchema[K]['table'] extends infer TTable extends Table ? TTable : never;
-} : {
-    [K in keyof TSchema as TSchema[K] extends Table ? K : never]: TSchema[K] extends Table ? TSchema[K] : never;
-};
-type ExtractRelations<TSchema extends Record<string, Table | unknown>> = {
-    [K in keyof TSchema as TSchema[K] extends Relations ? K : never]: TSchema[K] extends Relations ? TSchema[K] : never;
-};
-type ExtractTableRelations<TTable extends Table, TSchemaRelations extends Record<string, Relations>> = {
-    [K in keyof TSchemaRelations as TSchemaRelations[K]['table']['_']['name'] extends TTable['_']['name'] ? K : never]: TSchemaRelations[K]['table']['_']['name'] extends TTable['_']['name'] ? TSchemaRelations[K] extends Relations<any, infer RelationConfig> ? RelationConfig : never : never;
-};
-type ExtractTableByName<TTableSchema extends Record<string, Table>, TName extends string> = {
-    [K in keyof TTableSchema as TTableSchema[K]['_']['name'] extends TName ? K : never]: TTableSchema[K]['_']['name'] extends TName ? TTableSchema[K] : never;
-};
+type ExtractTables<TSchema extends Record<string, Table | unknown>> = TSchema extends TablesRelationalConfig ? { [K in keyof TSchema]: TSchema[K]['table'] extends (infer TTable extends Table) ? TTable : never; } : { [K in keyof TSchema as TSchema[K] extends Table ? K : never]: TSchema[K] extends Table ? TSchema[K] : never; };
+type ExtractRelations<TSchema extends Record<string, Table | unknown>> = { [K in keyof TSchema as TSchema[K] extends Relations ? K : never]: TSchema[K] extends Relations ? TSchema[K] : never; };
+type ExtractTableRelations<TTable extends Table, TSchemaRelations extends Record<string, Relations>> = { [K in keyof TSchemaRelations as TSchemaRelations[K]['table']['_']['name'] extends TTable['_']['name'] ? K : never]: TSchemaRelations[K]['table']['_']['name'] extends TTable['_']['name'] ? TSchemaRelations[K] extends Relations<any, infer RelationConfig> ? RelationConfig : never : never; };
+type ExtractTableByName<TTableSchema extends Record<string, Table>, TName extends string> = { [K in keyof TTableSchema as TTableSchema[K]['_']['name'] extends TName ? K : never]: TTableSchema[K]['_']['name'] extends TName ? TTableSchema[K] : never; };
 type MutationReturnlessResult = {
-    isSuccess: boolean;
+  isSuccess: boolean;
 };
 type QueryArgs<TTable extends Table, isSingle extends boolean> = Partial<(isSingle extends true ? {
-    offset: number;
+  offset: number;
 } : {
-    offset: number;
-    limit: number;
+  offset: number;
+  limit: number;
 }) & {
-    where: Filters<TTable>;
-    orderBy: OrderByArgs<TTable>;
+  where: Filters<TTable>;
+  orderBy: OrderByArgs<TTable>;
 }>;
 type InsertArgs<TTable extends Table, isSingle extends boolean> = isSingle extends true ? {
-    values: GetRemappedTableInsertDataType<TTable>;
+  values: GetRemappedTableInsertDataType<TTable>;
 } : {
-    values: Array<GetRemappedTableInsertDataType<TTable>>;
+  values: Array<GetRemappedTableInsertDataType<TTable>>;
 };
 type UpdateArgs<TTable extends Table> = Partial<{
-    set: GetRemappedTableUpdateDataType<TTable>;
-    where?: Filters<TTable>;
+  set: GetRemappedTableUpdateDataType<TTable>;
+  where?: Filters<TTable>;
 }>;
 /**
  * One entry of an `update<Table>Many` mutation: the rows `where` matches get this
  * entry's `set` applied. An omitted `where` matches every row, same as `update<Table>`.
  */
 type UpdateManyEntry<TTable extends Table> = {
-    where?: Filters<TTable>;
-    set: GetRemappedTableUpdateDataType<TTable>;
+  where?: Filters<TTable>;
+  set: GetRemappedTableUpdateDataType<TTable>;
 };
 type UpdateManyArgs<TTable extends Table> = {
-    updates: Array<UpdateManyEntry<TTable>>;
+  updates: Array<UpdateManyEntry<TTable>>;
 };
 /**
  * The `onConflict` argument of the generated upsert mutations.
@@ -763,32 +809,28 @@ type UpdateManyArgs<TTable extends Table> = {
  * predicate, so neither field is generated there.
  */
 type UpsertConflictArgs<TTable extends Table> = {
-    action?: 'UPDATE' | 'NOTHING';
-    target?: string[];
-    update?: string[];
-    where?: Filters<TTable>;
+  action?: 'UPDATE' | 'NOTHING';
+  target?: string[];
+  update?: string[];
+  where?: Filters<TTable>;
 };
 type UpsertArgs<TTable extends Table, isSingle extends boolean> = InsertArgs<TTable, isSingle> & {
-    onConflict?: UpsertConflictArgs<TTable>;
+  onConflict?: UpsertConflictArgs<TTable>;
 };
 type DeleteArgs<TTable extends Table> = {
-    where?: Filters<TTable>;
+  where?: Filters<TTable>;
 };
 /** Arguments of `update<Table>Single` — unlike the plural variant, `where` is required. */
 type UpdateSingleArgs<TTable extends Table> = {
-    set: GetRemappedTableUpdateDataType<TTable>;
-    where: Filters<TTable>;
+  set: GetRemappedTableUpdateDataType<TTable>;
+  where: Filters<TTable>;
 };
 /** Arguments of `delete<Table>Single` — unlike the plural variant, `where` is required. */
 type DeleteSingleArgs<TTable extends Table> = {
-    where: Filters<TTable>;
+  where: Filters<TTable>;
 };
-type SelectResolver<TTable extends Table, TTables extends Record<string, Table>, TRelations extends Record<string, Relation>> = (source: any, args: Partial<QueryArgs<TTable, false>>, context: any, info: GraphQLResolveInfo) => Promise<keyof TRelations extends infer RelKey ? RelKey extends string ? Array<GetRemappedTableDataType<TTable> & {
-    [K in RelKey]: TRelations[K] extends One<infer TTargetName, any> ? GetRemappedTableDataType<ExtractTableByName<TTables, TTargetName> extends infer T ? T[keyof T] : never> | null : TRelations[K] extends Many<infer TTargetName> ? Array<GetRemappedTableDataType<ExtractTableByName<TTables, TTargetName> extends infer T ? T[keyof T] : never>> : never;
-}> : Array<GetRemappedTableDataType<TTable>> : Array<GetRemappedTableDataType<TTable>>>;
-type SelectSingleResolver<TTable extends Table, TTables extends Record<string, Table>, TRelations extends Record<string, Relation>> = (source: any, args: Partial<QueryArgs<TTable, true>>, context: any, info: GraphQLResolveInfo) => Promise<(keyof TRelations extends infer RelKey ? RelKey extends string ? GetRemappedTableDataType<TTable> & {
-    [K in RelKey]: TRelations[K] extends One<infer TTargetName, any> ? GetRemappedTableDataType<ExtractTableByName<TTables, TTargetName> extends infer T ? T[keyof T] : never> | null : TRelations[K] extends Many<infer TTargetName> ? Array<GetRemappedTableDataType<ExtractTableByName<TTables, TTargetName> extends infer T ? T[keyof T] : never>> : never;
-} : GetRemappedTableDataType<TTable> : GetRemappedTableDataType<TTable>) | null>;
+type SelectResolver<TTable extends Table, TTables extends Record<string, Table>, TRelations extends Record<string, Relation>> = (source: any, args: Partial<QueryArgs<TTable, false>>, context: any, info: GraphQLResolveInfo) => Promise<keyof TRelations extends (infer RelKey) ? RelKey extends string ? Array<GetRemappedTableDataType<TTable> & { [K in RelKey]: TRelations[K] extends One<infer TTargetName, any> ? GetRemappedTableDataType<ExtractTableByName<TTables, TTargetName> extends (infer T) ? T[keyof T] : never> | null : TRelations[K] extends Many<infer TTargetName> ? Array<GetRemappedTableDataType<ExtractTableByName<TTables, TTargetName> extends (infer T) ? T[keyof T] : never>> : never; }> : Array<GetRemappedTableDataType<TTable>> : Array<GetRemappedTableDataType<TTable>>>;
+type SelectSingleResolver<TTable extends Table, TTables extends Record<string, Table>, TRelations extends Record<string, Relation>> = (source: any, args: Partial<QueryArgs<TTable, true>>, context: any, info: GraphQLResolveInfo) => Promise<(keyof TRelations extends (infer RelKey) ? RelKey extends string ? GetRemappedTableDataType<TTable> & { [K in RelKey]: TRelations[K] extends One<infer TTargetName, any> ? GetRemappedTableDataType<ExtractTableByName<TTables, TTargetName> extends (infer T) ? T[keyof T] : never> | null : TRelations[K] extends Many<infer TTargetName> ? Array<GetRemappedTableDataType<ExtractTableByName<TTables, TTargetName> extends (infer T) ? T[keyof T] : never>> : never; } : GetRemappedTableDataType<TTable> : GetRemappedTableDataType<TTable>) | null>;
 /** Resolver for `create<Table>Single`: one row in, one row (or `undefined`) out. */
 type InsertResolver<TTable extends Table, IsReturnless extends boolean> = (source: any, args: Partial<InsertArgs<TTable, true>>, context: any, info: GraphQLResolveInfo) => Promise<IsReturnless extends false ? GetRemappedTableDataType<TTable> | undefined : MutationReturnlessResult>;
 /** Resolver for `create<Table>`: an array of rows in, an array of rows out. */
@@ -816,7 +858,7 @@ type UpsertArrResolver<TTable extends Table, IsReturnless extends boolean> = (so
  * (numeric columns, as Float) and `min` / `max` (orderable columns, as the column's type).
  */
 type AggregateResolver<TTable extends Table> = (source: any, args: {
-    where?: Filters<TTable>;
+  where?: Filters<TTable>;
 }, context: any, info: GraphQLResolveInfo) => Promise<Record<string, any>>;
 type DeleteResolver<TTable extends Table, IsReturnless extends boolean> = (source: any, args: DeleteArgs<TTable>, context: any, info: GraphQLResolveInfo) => Promise<IsReturnless extends false ? GetRemappedTableDataType<TTable> | undefined : MutationReturnlessResult>;
 /**
@@ -824,158 +866,134 @@ type DeleteResolver<TTable extends Table, IsReturnless extends boolean> = (sourc
  * out. Throws before writing anything when `where` matches more than one row.
  */
 type DeleteSingleResolver<TTable extends Table, IsReturnless extends boolean> = (source: any, args: DeleteSingleArgs<TTable>, context: any, info: GraphQLResolveInfo) => Promise<IsReturnless extends false ? GetRemappedTableDataType<TTable> | undefined : MutationReturnlessResult>;
-type QueriesCore<TSchemaTables extends Record<string, Table>, TSchemaRelations extends Record<string, Relations>, TInputs extends Record<string, GraphQLInputObjectType>, TOutputs extends Record<string, GraphQLObjectType>> = {
-    [TName in keyof TSchemaTables as TName extends string ? `${Uncapitalize<TName>}` : never]: TName extends string ? {
-        type: GraphQLNonNull<GraphQLList<GraphQLNonNull<TOutputs[Capitalize<TName>]>>>;
-        args: {
-            offset: {
-                type: GraphQLScalarType<number, number>;
-            };
-            limit: {
-                type: GraphQLScalarType<number, number>;
-            };
-            orderBy: {
-                type: TInputs[`${Capitalize<TName>}OrderBy`] extends GraphQLInputObjectType ? TInputs[`${Capitalize<TName>}OrderBy`] : never;
-            };
-            where: {
-                type: TInputs[`${Capitalize<TName>}Filters`] extends GraphQLInputObjectType ? TInputs[`${Capitalize<TName>}Filters`] : never;
-            };
-            distinct: {
-                type: GraphQLList<GraphQLNonNull<GraphQLEnumType>>;
-            };
-        };
-        resolve: SelectResolver<TSchemaTables[TName], TSchemaTables, ExtractTableRelations<TSchemaTables[TName], TSchemaRelations> extends infer R ? R[keyof R] : never>;
-    } : never;
-} & {
-    [TName in keyof TSchemaTables as TName extends string ? `${Uncapitalize<TName>}Single` : never]: TName extends string ? {
-        type: TOutputs[Capitalize<TName>];
-        args: {
-            offset: {
-                type: GraphQLScalarType<number, number>;
-            };
-            orderBy: {
-                type: TInputs[`${Capitalize<TName>}OrderBy`] extends GraphQLInputObjectType ? TInputs[`${Capitalize<TName>}OrderBy`] : never;
-            };
-            where: {
-                type: TInputs[`${Capitalize<TName>}Filters`] extends GraphQLInputObjectType ? TInputs[`${Capitalize<TName>}Filters`] : never;
-            };
-        };
-        resolve: SelectSingleResolver<TSchemaTables[TName], TSchemaTables, ExtractTableRelations<TSchemaTables[TName], TSchemaRelations> extends infer R ? R[keyof R] : never>;
-    } : never;
-} & {
-    [TName in keyof TSchemaTables as TName extends string ? `${Uncapitalize<TName>}Aggregate` : never]: TName extends string ? {
-        type: GraphQLNonNull<TOutputs[`${Capitalize<TName>}Aggregate`] extends GraphQLObjectType ? TOutputs[`${Capitalize<TName>}Aggregate`] : GraphQLObjectType>;
-        args: {
-            where: {
-                type: TInputs[`${Capitalize<TName>}Filters`] extends GraphQLInputObjectType ? TInputs[`${Capitalize<TName>}Filters`] : never;
-            };
-        };
-        resolve: AggregateResolver<TSchemaTables[TName]>;
-    } : never;
-};
-type MutationsCore<TSchemaTables extends Record<string, Table>, TInputs extends Record<string, GraphQLInputObjectType>, TOutputs extends Record<string, GraphQLObjectType>, IsReturnless extends boolean> = {
-    [TName in keyof TSchemaTables as TName extends string ? `create${Capitalize<TName>}` : never]: TName extends string ? {
-        type: IsReturnless extends true ? TOutputs['MutationReturn'] extends GraphQLObjectType ? TOutputs['MutationReturn'] : never : GraphQLNonNull<GraphQLList<GraphQLNonNull<TOutputs[Capitalize<TName>]>>>;
-        args: {
-            values: {
-                type: GraphQLNonNull<GraphQLList<GraphQLNonNull<TInputs[`Create${Capitalize<TName>}Input`]>>>;
-            };
-        };
-        resolve: InsertArrResolver<TSchemaTables[TName], IsReturnless>;
-    } : never;
-} & {
-    [TName in keyof TSchemaTables as TName extends string ? `create${Capitalize<TName>}Single` : never]: TName extends string ? {
-        type: IsReturnless extends true ? TOutputs['MutationReturn'] extends GraphQLObjectType ? TOutputs['MutationReturn'] : never : TOutputs[Capitalize<TName>];
-        args: {
-            values: {
-                type: GraphQLNonNull<TInputs[`Create${Capitalize<TName>}Input`]>;
-            };
-        };
-        resolve: InsertResolver<TSchemaTables[TName], IsReturnless>;
-    } : never;
-} & {
-    [TName in keyof TSchemaTables as TName extends string ? `upsert${Capitalize<TName>}` : never]?: TName extends string ? {
-        type: IsReturnless extends true ? TOutputs['MutationReturn'] extends GraphQLObjectType ? TOutputs['MutationReturn'] : never : GraphQLNonNull<GraphQLList<GraphQLNonNull<TOutputs[Capitalize<TName>]>>>;
-        args: {
-            values: {
-                type: GraphQLNonNull<GraphQLList<GraphQLNonNull<TInputs[`Create${Capitalize<TName>}Input`]>>>;
-            };
-            onConflict: {
-                type: GraphQLInputObjectType;
-            };
-        };
-        resolve: UpsertArrResolver<TSchemaTables[TName], IsReturnless>;
-    } : never;
-} & {
-    [TName in keyof TSchemaTables as TName extends string ? `upsert${Capitalize<TName>}Single` : never]?: TName extends string ? {
-        type: IsReturnless extends true ? TOutputs['MutationReturn'] extends GraphQLObjectType ? TOutputs['MutationReturn'] : never : TOutputs[Capitalize<TName>];
-        args: {
-            values: {
-                type: GraphQLNonNull<TInputs[`Create${Capitalize<TName>}Input`]>;
-            };
-            onConflict: {
-                type: GraphQLInputObjectType;
-            };
-        };
-        resolve: UpsertResolver<TSchemaTables[TName], IsReturnless>;
-    } : never;
-} & {
-    [TName in keyof TSchemaTables as TName extends string ? `update${Capitalize<TName>}` : never]: TName extends string ? {
-        type: IsReturnless extends true ? TOutputs['MutationReturn'] extends GraphQLObjectType ? TOutputs['MutationReturn'] : never : GraphQLNonNull<GraphQLList<GraphQLNonNull<TOutputs[Capitalize<TName>]>>>;
-        args: {
-            set: {
-                type: GraphQLNonNull<TInputs[`Update${Capitalize<TName>}Input`]>;
-            };
-            where: {
-                type: TInputs[`${Capitalize<TName>}Filters`] extends GraphQLInputObjectType ? TInputs[`${Capitalize<TName>}Filters`] : never;
-            };
-        };
-        resolve: UpdateResolver<TSchemaTables[TName], IsReturnless>;
-    } : never;
-} & {
-    [TName in keyof TSchemaTables as TName extends string ? `update${Capitalize<TName>}Many` : never]: TName extends string ? {
-        type: IsReturnless extends true ? TOutputs['MutationReturn'] extends GraphQLObjectType ? TOutputs['MutationReturn'] : never : GraphQLNonNull<GraphQLList<TOutputs[Capitalize<TName>]>>;
-        args: {
-            updates: {
-                type: GraphQLNonNull<GraphQLList<GraphQLNonNull<TInputs[`Update${Capitalize<TName>}ManyInput`]>>>;
-            };
-        };
-        resolve: UpdateManyResolver<TSchemaTables[TName], IsReturnless>;
-    } : never;
-} & {
-    [TName in keyof TSchemaTables as TName extends string ? `update${Capitalize<TName>}Single` : never]: TName extends string ? {
-        type: IsReturnless extends true ? TOutputs['MutationReturn'] extends GraphQLObjectType ? TOutputs['MutationReturn'] : never : TOutputs[Capitalize<TName>];
-        args: {
-            set: {
-                type: GraphQLNonNull<TInputs[`Update${Capitalize<TName>}Input`]>;
-            };
-            where: {
-                type: GraphQLNonNull<TInputs[`${Capitalize<TName>}Filters`] extends GraphQLInputObjectType ? TInputs[`${Capitalize<TName>}Filters`] : never>;
-            };
-        };
-        resolve: UpdateSingleResolver<TSchemaTables[TName], IsReturnless>;
-    } : never;
-} & {
-    [TName in keyof TSchemaTables as TName extends string ? `delete${Capitalize<TName>}` : never]: TName extends string ? {
-        type: IsReturnless extends true ? TOutputs['MutationReturn'] extends GraphQLObjectType ? TOutputs['MutationReturn'] : never : GraphQLNonNull<GraphQLList<GraphQLNonNull<TOutputs[Capitalize<TName>]>>>;
-        args: {
-            where: {
-                type: TInputs[`${Capitalize<TName>}Filters`] extends GraphQLInputObjectType ? TInputs[`${Capitalize<TName>}Filters`] : never;
-            };
-        };
-        resolve: DeleteResolver<TSchemaTables[TName], IsReturnless>;
-    } : never;
-} & {
-    [TName in keyof TSchemaTables as TName extends string ? `delete${Capitalize<TName>}Single` : never]: TName extends string ? {
-        type: IsReturnless extends true ? TOutputs['MutationReturn'] extends GraphQLObjectType ? TOutputs['MutationReturn'] : never : TOutputs[Capitalize<TName>];
-        args: {
-            where: {
-                type: GraphQLNonNull<TInputs[`${Capitalize<TName>}Filters`] extends GraphQLInputObjectType ? TInputs[`${Capitalize<TName>}Filters`] : never>;
-            };
-        };
-        resolve: DeleteSingleResolver<TSchemaTables[TName], IsReturnless>;
-    } : never;
-};
+type QueriesCore<TSchemaTables extends Record<string, Table>, TSchemaRelations extends Record<string, Relations>, TInputs extends Record<string, GraphQLInputObjectType>, TOutputs extends Record<string, GraphQLObjectType>> = { [TName in keyof TSchemaTables as TName extends string ? `${Uncapitalize<TName>}` : never]: TName extends string ? {
+  type: GraphQLNonNull<GraphQLList<GraphQLNonNull<TOutputs[Capitalize<TName>]>>>;
+  args: {
+    offset: {
+      type: GraphQLScalarType<number, number>;
+    };
+    limit: {
+      type: GraphQLScalarType<number, number>;
+    };
+    orderBy: {
+      type: TInputs[`${Capitalize<TName>}OrderBy`] extends GraphQLInputObjectType ? TInputs[`${Capitalize<TName>}OrderBy`] : never;
+    };
+    where: {
+      type: TInputs[`${Capitalize<TName>}Filters`] extends GraphQLInputObjectType ? TInputs[`${Capitalize<TName>}Filters`] : never;
+    };
+    distinct: {
+      type: GraphQLList<GraphQLNonNull<GraphQLEnumType>>;
+    };
+  };
+  resolve: SelectResolver<TSchemaTables[TName], TSchemaTables, ExtractTableRelations<TSchemaTables[TName], TSchemaRelations> extends (infer R) ? R[keyof R] : never>;
+} : never; } & { [TName in keyof TSchemaTables as TName extends string ? `${Uncapitalize<TName>}Single` : never]: TName extends string ? {
+  type: TOutputs[Capitalize<TName>];
+  args: {
+    offset: {
+      type: GraphQLScalarType<number, number>;
+    };
+    orderBy: {
+      type: TInputs[`${Capitalize<TName>}OrderBy`] extends GraphQLInputObjectType ? TInputs[`${Capitalize<TName>}OrderBy`] : never;
+    };
+    where: {
+      type: TInputs[`${Capitalize<TName>}Filters`] extends GraphQLInputObjectType ? TInputs[`${Capitalize<TName>}Filters`] : never;
+    };
+  };
+  resolve: SelectSingleResolver<TSchemaTables[TName], TSchemaTables, ExtractTableRelations<TSchemaTables[TName], TSchemaRelations> extends (infer R) ? R[keyof R] : never>;
+} : never; } & { [TName in keyof TSchemaTables as TName extends string ? `${Uncapitalize<TName>}Aggregate` : never]: TName extends string ? {
+  type: GraphQLNonNull<TOutputs[`${Capitalize<TName>}Aggregate`] extends GraphQLObjectType ? TOutputs[`${Capitalize<TName>}Aggregate`] : GraphQLObjectType>;
+  args: {
+    where: {
+      type: TInputs[`${Capitalize<TName>}Filters`] extends GraphQLInputObjectType ? TInputs[`${Capitalize<TName>}Filters`] : never;
+    };
+  };
+  resolve: AggregateResolver<TSchemaTables[TName]>;
+} : never; };
+type MutationsCore<TSchemaTables extends Record<string, Table>, TInputs extends Record<string, GraphQLInputObjectType>, TOutputs extends Record<string, GraphQLObjectType>, IsReturnless extends boolean> = { [TName in keyof TSchemaTables as TName extends string ? `create${Capitalize<TName>}` : never]: TName extends string ? {
+  type: IsReturnless extends true ? TOutputs['MutationReturn'] extends GraphQLObjectType ? TOutputs['MutationReturn'] : never : GraphQLNonNull<GraphQLList<GraphQLNonNull<TOutputs[Capitalize<TName>]>>>;
+  args: {
+    values: {
+      type: GraphQLNonNull<GraphQLList<GraphQLNonNull<TInputs[`Create${Capitalize<TName>}Input`]>>>;
+    };
+  };
+  resolve: InsertArrResolver<TSchemaTables[TName], IsReturnless>;
+} : never; } & { [TName in keyof TSchemaTables as TName extends string ? `create${Capitalize<TName>}Single` : never]: TName extends string ? {
+  type: IsReturnless extends true ? TOutputs['MutationReturn'] extends GraphQLObjectType ? TOutputs['MutationReturn'] : never : TOutputs[Capitalize<TName>];
+  args: {
+    values: {
+      type: GraphQLNonNull<TInputs[`Create${Capitalize<TName>}Input`]>;
+    };
+  };
+  resolve: InsertResolver<TSchemaTables[TName], IsReturnless>;
+} : never; } & { [TName in keyof TSchemaTables as TName extends string ? `upsert${Capitalize<TName>}` : never]?: TName extends string ? {
+  type: IsReturnless extends true ? TOutputs['MutationReturn'] extends GraphQLObjectType ? TOutputs['MutationReturn'] : never : GraphQLNonNull<GraphQLList<GraphQLNonNull<TOutputs[Capitalize<TName>]>>>;
+  args: {
+    values: {
+      type: GraphQLNonNull<GraphQLList<GraphQLNonNull<TInputs[`Create${Capitalize<TName>}Input`]>>>;
+    };
+    onConflict: {
+      type: GraphQLInputObjectType;
+    };
+  };
+  resolve: UpsertArrResolver<TSchemaTables[TName], IsReturnless>;
+} : never; } & { [TName in keyof TSchemaTables as TName extends string ? `upsert${Capitalize<TName>}Single` : never]?: TName extends string ? {
+  type: IsReturnless extends true ? TOutputs['MutationReturn'] extends GraphQLObjectType ? TOutputs['MutationReturn'] : never : TOutputs[Capitalize<TName>];
+  args: {
+    values: {
+      type: GraphQLNonNull<TInputs[`Create${Capitalize<TName>}Input`]>;
+    };
+    onConflict: {
+      type: GraphQLInputObjectType;
+    };
+  };
+  resolve: UpsertResolver<TSchemaTables[TName], IsReturnless>;
+} : never; } & { [TName in keyof TSchemaTables as TName extends string ? `update${Capitalize<TName>}` : never]: TName extends string ? {
+  type: IsReturnless extends true ? TOutputs['MutationReturn'] extends GraphQLObjectType ? TOutputs['MutationReturn'] : never : GraphQLNonNull<GraphQLList<GraphQLNonNull<TOutputs[Capitalize<TName>]>>>;
+  args: {
+    set: {
+      type: GraphQLNonNull<TInputs[`Update${Capitalize<TName>}Input`]>;
+    };
+    where: {
+      type: TInputs[`${Capitalize<TName>}Filters`] extends GraphQLInputObjectType ? TInputs[`${Capitalize<TName>}Filters`] : never;
+    };
+  };
+  resolve: UpdateResolver<TSchemaTables[TName], IsReturnless>;
+} : never; } & { [TName in keyof TSchemaTables as TName extends string ? `update${Capitalize<TName>}Many` : never]: TName extends string ? {
+  type: IsReturnless extends true ? TOutputs['MutationReturn'] extends GraphQLObjectType ? TOutputs['MutationReturn'] : never : GraphQLNonNull<GraphQLList<TOutputs[Capitalize<TName>]>>;
+  args: {
+    updates: {
+      type: GraphQLNonNull<GraphQLList<GraphQLNonNull<TInputs[`Update${Capitalize<TName>}ManyInput`]>>>;
+    };
+  };
+  resolve: UpdateManyResolver<TSchemaTables[TName], IsReturnless>;
+} : never; } & { [TName in keyof TSchemaTables as TName extends string ? `update${Capitalize<TName>}Single` : never]: TName extends string ? {
+  type: IsReturnless extends true ? TOutputs['MutationReturn'] extends GraphQLObjectType ? TOutputs['MutationReturn'] : never : TOutputs[Capitalize<TName>];
+  args: {
+    set: {
+      type: GraphQLNonNull<TInputs[`Update${Capitalize<TName>}Input`]>;
+    };
+    where: {
+      type: GraphQLNonNull<TInputs[`${Capitalize<TName>}Filters`] extends GraphQLInputObjectType ? TInputs[`${Capitalize<TName>}Filters`] : never>;
+    };
+  };
+  resolve: UpdateSingleResolver<TSchemaTables[TName], IsReturnless>;
+} : never; } & { [TName in keyof TSchemaTables as TName extends string ? `delete${Capitalize<TName>}` : never]: TName extends string ? {
+  type: IsReturnless extends true ? TOutputs['MutationReturn'] extends GraphQLObjectType ? TOutputs['MutationReturn'] : never : GraphQLNonNull<GraphQLList<GraphQLNonNull<TOutputs[Capitalize<TName>]>>>;
+  args: {
+    where: {
+      type: TInputs[`${Capitalize<TName>}Filters`] extends GraphQLInputObjectType ? TInputs[`${Capitalize<TName>}Filters`] : never;
+    };
+  };
+  resolve: DeleteResolver<TSchemaTables[TName], IsReturnless>;
+} : never; } & { [TName in keyof TSchemaTables as TName extends string ? `delete${Capitalize<TName>}Single` : never]: TName extends string ? {
+  type: IsReturnless extends true ? TOutputs['MutationReturn'] extends GraphQLObjectType ? TOutputs['MutationReturn'] : never : TOutputs[Capitalize<TName>];
+  args: {
+    where: {
+      type: GraphQLNonNull<TInputs[`${Capitalize<TName>}Filters`] extends GraphQLInputObjectType ? TInputs[`${Capitalize<TName>}Filters`] : never>;
+    };
+  };
+  resolve: DeleteSingleResolver<TSchemaTables[TName], IsReturnless>;
+} : never; };
 /**
  * Keys of `entities.inputs`, which is keyed by generated GraphQL input type name.
  *
@@ -985,17 +1003,7 @@ type MutationsCore<TSchemaTables extends Record<string, Table>, TInputs extends
  * enabled — `${Table}OnConflict` for upsert, `${Table}Having` for group-by — are not listed,
  * since whether they were generated is a runtime decision.
  */
-type GeneratedInputs<TSchema extends Record<string, Table>> = {
-    [TName in keyof TSchema as TName extends string ? `Create${Capitalize<TName>}Input` : never]: GraphQLInputObjectType;
-} & {
-    [TName in keyof TSchema as TName extends string ? `Update${Capitalize<TName>}Input` : never]: GraphQLInputObjectType;
-} & {
-    [TName in keyof TSchema as TName extends string ? `Update${Capitalize<TName>}ManyInput` : never]: GraphQLInputObjectType;
-} & {
-    [TName in keyof TSchema as TName extends string ? `${Capitalize<TName>}OrderBy` : never]: GraphQLInputObjectType;
-} & {
-    [TName in keyof TSchema as TName extends string ? `${Capitalize<TName>}Filters` : never]: GraphQLInputObjectType;
-};
+type GeneratedInputs<TSchema extends Record<string, Table>> = { [TName in keyof TSchema as TName extends string ? `Create${Capitalize<TName>}Input` : never]: GraphQLInputObjectType; } & { [TName in keyof TSchema as TName extends string ? `Update${Capitalize<TName>}Input` : never]: GraphQLInputObjectType; } & { [TName in keyof TSchema as TName extends string ? `Update${Capitalize<TName>}ManyInput` : never]: GraphQLInputObjectType; } & { [TName in keyof TSchema as TName extends string ? `${Capitalize<TName>}OrderBy` : never]: GraphQLInputObjectType; } & { [TName in keyof TSchema as TName extends string ? `${Capitalize<TName>}Filters` : never]: GraphQLInputObjectType; };
 /**
  * Keys of `entities.types`, which is keyed by generated GraphQL type name.
  *
@@ -1004,33 +1012,25 @@ type GeneratedInputs<TSchema extends Record<string, Table>> = {
  * type kept those names long after the generator stopped producing them. MySQL still has a
  * shared `MutationReturn` instead of per-table return types, because its writes return no rows.
  */
-type GeneratedOutputs<TSchema extends Record<string, Table>, IsReturnless extends boolean> = {
-    [TName in keyof TSchema as TName extends string ? Capitalize<TName> : never]: GraphQLObjectType;
-} & {
-    [TName in keyof TSchema as TName extends string ? `${Capitalize<TName>}Aggregate` : never]: GraphQLObjectType;
-} & (IsReturnless extends true ? {
-    MutationReturn: GraphQLObjectType;
-} : {
-    [TName in keyof TSchema as TName extends string ? Capitalize<TName> : never]: GraphQLObjectType;
-});
+type GeneratedOutputs<TSchema extends Record<string, Table>, IsReturnless extends boolean> = { [TName in keyof TSchema as TName extends string ? Capitalize<TName> : never]: GraphQLObjectType; } & { [TName in keyof TSchema as TName extends string ? `${Capitalize<TName>}Aggregate` : never]: GraphQLObjectType; } & (IsReturnless extends true ? {
+  MutationReturn: GraphQLObjectType;
+} : { [TName in keyof TSchema as TName extends string ? Capitalize<TName> : never]: GraphQLObjectType; });
 type GeneratedEntities<TDatabase extends AnyDrizzleDB<TSchema>, TSchema extends Record<string, unknown> = TDatabase extends AnyDrizzleDB<infer ISchema> ? ISchema : never, TSchemaTables extends ExtractTables<TSchema> = ExtractTables<TSchema>, TSchemaRelations extends ExtractRelations<TSchema> = ExtractRelations<TSchema>, TInputs extends GeneratedInputs<TSchemaTables> = GeneratedInputs<TSchemaTables>, TOutputs extends GeneratedOutputs<TSchemaTables, TDatabase extends MySqlAsyncDatabase<any, any> ? true : false> = GeneratedOutputs<TSchemaTables, TDatabase extends MySqlAsyncDatabase<any, any> ? true : false>> = {
-    queries: QueriesCore<TSchemaTables, TSchemaRelations, TInputs, TOutputs>;
-    mutations: MutationsCore<TSchemaTables, TInputs, TOutputs, TDatabase extends MySqlAsyncDatabase<any, any> ? true : false>;
-    inputs: TInputs;
-    types: TOutputs;
-    /**
-     * Field-level resolvers for each relation on each table.
-     * Each resolver handles both the eager path (data pre-fetched by the parent query)
-     * and the lazy path (data fetched on demand with N+1 protection via request-scoped batching).
-     * Keyed as `fieldResolvers[tableSchemaKey][relationName]`.
-     */
-    fieldResolvers: {
-        [TName in keyof TSchemaTables as TName extends string ? TName : never]?: Record<string, (source: any, args: any, context: any, info: GraphQLResolveInfo) => Promise<any>>;
-    };
+  queries: QueriesCore<TSchemaTables, TSchemaRelations, TInputs, TOutputs>;
+  mutations: MutationsCore<TSchemaTables, TInputs, TOutputs, TDatabase extends MySqlAsyncDatabase<any, any> ? true : false>;
+  inputs: TInputs;
+  types: TOutputs;
+  /**
+   * Field-level resolvers for each relation on each table.
+   * Each resolver handles both the eager path (data pre-fetched by the parent query)
+   * and the lazy path (data fetched on demand with N+1 protection via request-scoped batching).
+   * Keyed as `fieldResolvers[tableSchemaKey][relationName]`.
+   */
+  fieldResolvers: { [TName in keyof TSchemaTables as TName extends string ? TName : never]?: Record<string, (source: any, args: any, context: any, info: GraphQLResolveInfo) => Promise<any>>; };
 };
 type GeneratedData<TDatabase extends AnyDrizzleDB<any>> = {
-    schema: GraphQLSchema;
-    entities: GeneratedEntities<TDatabase>;
+  schema: GraphQLSchema;
+  entities: GeneratedEntities<TDatabase>;
 };
 /**
  * A feature switch. `true` / `false` decides for the whole build; a predicate decides per
@@ -1050,196 +1050,196 @@ type FeatureSwitch = boolean | ((tableName: string) => boolean);
  * See {@link BuildSchemaConfig.features}.
  */
 type SchemaFeatures = {
-    /** `<plural>Aggregate` root queries and the aggregate output types. @default true */
-    aggregates?: FeatureSwitch;
-    /**
-     * `<plural>GroupBy` root queries — the same aggregates, one row per group. Requires
-     * `aggregates`, whose output types the grouped result reuses.
-     *
-     * @default true
-     */
-    groupBy?: FeatureSwitch;
-    /** `<relation>Aggregate` fields on object types, for to-many relations. @default true */
-    relationAggregates?: FeatureSwitch;
-    /** The `distinct` argument on list queries. @default true */
-    distinct?: FeatureSwitch;
-    /** `create<Table>` / `create<Table>Single` mutations. @default true */
-    insert?: FeatureSwitch;
-    /** `update<Table>` / `update<Table>Single` mutations. @default true */
-    update?: FeatureSwitch;
-    /**
-     * `update<Table>Many` mutations — batch update with a per-entry `set` and `where`,
-     * executed inside one transaction. Only generated when `update` is also enabled,
-     * since the entries reuse the update `set` input.
-     *
-     * @default true
-     */
-    updateMany?: FeatureSwitch;
-    /** `delete<Table>` / `delete<Table>Single` mutations. @default true */
-    delete?: FeatureSwitch;
-    /**
-     * `upsert<Table>` / `upsert<Table>Single` mutations — insert, or update the row that
-     * already holds the same unique key. Off unless asked for, so an existing schema does
-     * not grow new mutations on upgrade.
-     *
-     * @default false
-     */
-    upsert?: FeatureSwitch;
-    /**
-     * Relation fields on `Create<Table>Input` and `Update<Table>Input`, so a parent row and
-     * the rows it is related to can be written in one mutation. Off unless asked for: it adds
-     * a field per writable relation to every create and update input.
-     *
-     * ```graphql
-     * createPostsSingle(values: {
-     *   title: "Hello"
-     *   author: { connect: { id: { eq: "a1" } } }
-     *   tags: { create: [{ name: "drizzle" }] }
-     * }) { id }
-     * ```
-     *
-     * Each relation field offers `create` and `connect`; the update input adds `disconnect`
-     * and, for a to-many relation, `set` (replace the whole set). `disconnect` and `set` are
-     * generated only when the foreign key is nullable — there is no way to detach a row whose
-     * key is NOT NULL. Nesting is one level deep: the row a nested `create` inserts takes
-     * columns only.
-     *
-     * A many-to-many (`.through()`) relation is written as junction rows: `connect` on the
-     * create input, and `connect` / `disconnect` / `set` on the update input, all
-     * unconditional, since unlinking deletes a junction row rather than nulling a column.
-     * It offers no `create` — inserting a row and linking it are two writes to two tables —
-     * and `set: []` clears the relation.
-     *
-     * The whole tree runs in one transaction (a savepoint when the request already carries
-     * one), and a column a relation fills in (`authorId`, when `author: { create: … }` is
-     * offered) becomes nullable on the create input, since the relation is the other way to
-     * supply it.
-     *
-     * PostgreSQL and SQLite only. MySQL cannot return the rows it just wrote, which is how a
-     * nested write learns the parent's key, so `buildSchema` rejects the flag there. On SQLite
-     * the driver must be asynchronous (libsql, D1, …): a synchronous one commits before an
-     * awaited statement runs, so `buildSchema` rejects the combination outright.
-     *
-     * @default false
-     */
-    nestedWrites?: boolean;
-    /**
-     * Operation inputs on the update `set`, so a column can be changed relative to its current
-     * value instead of only replaced.
-     *
-     * ```graphql
-     * updatePostsSingle(where: { id: { eq: "p1" } }, set: { views: { increment: 1 } }) { views }
-     * ```
-     *
-     * Every numeric column's field on `Update<Table>Input` becomes a `<Scalar>FieldUpdate`
-     * input carrying `set`, `increment`, `decrement`, `multiply` and `divide`; every array
-     * column's becomes a `<Scalar>ListFieldUpdate` carrying `set` and `push`. Exactly one
-     * operation per field, checked at resolve time. `set` is the explicit spelling of what the
-     * field did before, so `set: { views: 42 }` becomes `set: { views: { set: 42 } }`.
-     *
-     * The arithmetic happens in the database (`SET views = views + 1`), so a counter no longer
-     * needs a read-modify-write round trip and no longer loses concurrent updates. Rounding on
-     * an integer column, and division by zero, follow the database's own rules rather than
-     * being guarded here. Columns owned by a scalar override keep their plain type — an
-     * override owns what the column accepts.
-     *
-     * Off by default: it changes the type of every numeric and array field on every update
-     * input, which no existing document is written against.
-     *
-     * @default false
-     */
-    fieldUpdateOperations?: FeatureSwitch;
-    /**
-     * `update<Table>Count` / `delete<Table>Count` mutations — the same write as the plural
-     * `update<Table>` / `delete<Table>`, returning the number of rows affected instead of the
-     * rows themselves.
-     *
-     * ```graphql
-     * deletePostsCount(where: { published: { eq: false } })   # Int!
-     * ```
-     *
-     * A mass update or delete otherwise has to `RETURNING *` every row it touched purely so
-     * the caller can count them, which crosses the driver and is serialized through GraphQL
-     * for nothing. Each mutation is generated only when its plural counterpart is
-     * (`features.update` / `features.delete`), and honours `features.requireWhere`.
-     *
-     * Off unless asked for, so an existing schema does not grow new mutations on upgrade.
-     *
-     * @default false
-     */
-    countMutations?: FeatureSwitch;
-    /**
-     * Makes `where` non-null on the plural `update<Table>` / `delete<Table>` mutations, and
-     * rejects a `where` that collapses to no filters (e.g. `where: {}`), so a schema can rule
-     * out unbounded writes at the type level. Off by default for backwards compatibility.
-     *
-     * The `Single` variants (`update<Table>Single` / `delete<Table>Single`) require a
-     * non-empty `where` regardless of this flag.
-     *
-     * @default false
-     */
-    requireWhere?: FeatureSwitch;
-    /**
-     * One `where` field per compound unique constraint, so a lookup by a natural key names the
-     * key instead of restating its columns:
-     *
-     * ```graphql
-     * stockSingle(where: { itemId_locationId: { itemId: "i1", locationId: "l1" } }) { quantity }
-     * ```
-     *
-     * The field is named after its member columns and every member is non-null, so a half-
-     * supplied key fails query validation rather than becoming a broader filter that returns
-     * whichever row happens to come first. It compiles to the same equalities the columns would
-     * have — the guarantee is in the input type.
-     *
-     * Single-column constraints get no field (`eq` on the column already says it), and a
-     * constraint whose field name is taken by a column or a relation is skipped. The fields live
-     * on `<Type>Filters`, so they are accepted wherever a filter is: the `Single` reads and
-     * writes they are meant for, but also list queries, relation filters and `onConflict.where`.
-     *
-     * Off unless asked for: it adds an input type per compound constraint.
-     *
-     * @default false
-     */
-    uniqueKeyFilters?: FeatureSwitch;
+  /** `<plural>Aggregate` root queries and the aggregate output types. @default true */
+  aggregates?: FeatureSwitch;
+  /**
+   * `<plural>GroupBy` root queries — the same aggregates, one row per group. Requires
+   * `aggregates`, whose output types the grouped result reuses.
+   *
+   * @default true
+   */
+  groupBy?: FeatureSwitch;
+  /** `<relation>Aggregate` fields on object types, for to-many relations. @default true */
+  relationAggregates?: FeatureSwitch;
+  /** The `distinct` argument on list queries. @default true */
+  distinct?: FeatureSwitch;
+  /** `create<Table>` / `create<Table>Single` mutations. @default true */
+  insert?: FeatureSwitch;
+  /** `update<Table>` / `update<Table>Single` mutations. @default true */
+  update?: FeatureSwitch;
+  /**
+   * `update<Table>Many` mutations — batch update with a per-entry `set` and `where`,
+   * executed inside one transaction. Only generated when `update` is also enabled,
+   * since the entries reuse the update `set` input.
+   *
+   * @default true
+   */
+  updateMany?: FeatureSwitch;
+  /** `delete<Table>` / `delete<Table>Single` mutations. @default true */
+  delete?: FeatureSwitch;
+  /**
+   * `upsert<Table>` / `upsert<Table>Single` mutations — insert, or update the row that
+   * already holds the same unique key. Off unless asked for, so an existing schema does
+   * not grow new mutations on upgrade.
+   *
+   * @default false
+   */
+  upsert?: FeatureSwitch;
+  /**
+   * Relation fields on `Create<Table>Input` and `Update<Table>Input`, so a parent row and
+   * the rows it is related to can be written in one mutation. Off unless asked for: it adds
+   * a field per writable relation to every create and update input.
+   *
+   * ```graphql
+   * createPostsSingle(values: {
+   *   title: "Hello"
+   *   author: { connect: { id: { eq: "a1" } } }
+   *   tags: { create: [{ name: "drizzle" }] }
+   * }) { id }
+   * ```
+   *
+   * Each relation field offers `create` and `connect`; the update input adds `disconnect`
+   * and, for a to-many relation, `set` (replace the whole set). `disconnect` and `set` are
+   * generated only when the foreign key is nullable — there is no way to detach a row whose
+   * key is NOT NULL. Nesting is one level deep: the row a nested `create` inserts takes
+   * columns only.
+   *
+   * A many-to-many (`.through()`) relation is written as junction rows: `connect` on the
+   * create input, and `connect` / `disconnect` / `set` on the update input, all
+   * unconditional, since unlinking deletes a junction row rather than nulling a column.
+   * It offers no `create` — inserting a row and linking it are two writes to two tables —
+   * and `set: []` clears the relation.
+   *
+   * The whole tree runs in one transaction (a savepoint when the request already carries
+   * one), and a column a relation fills in (`authorId`, when `author: { create: … }` is
+   * offered) becomes nullable on the create input, since the relation is the other way to
+   * supply it.
+   *
+   * PostgreSQL and SQLite only. MySQL cannot return the rows it just wrote, which is how a
+   * nested write learns the parent's key, so `buildSchema` rejects the flag there. On SQLite
+   * the driver must be asynchronous (libsql, D1, …): a synchronous one commits before an
+   * awaited statement runs, so `buildSchema` rejects the combination outright.
+   *
+   * @default false
+   */
+  nestedWrites?: boolean;
+  /**
+   * Operation inputs on the update `set`, so a column can be changed relative to its current
+   * value instead of only replaced.
+   *
+   * ```graphql
+   * updatePostsSingle(where: { id: { eq: "p1" } }, set: { views: { increment: 1 } }) { views }
+   * ```
+   *
+   * Every numeric column's field on `Update<Table>Input` becomes a `<Scalar>FieldUpdate`
+   * input carrying `set`, `increment`, `decrement`, `multiply` and `divide`; every array
+   * column's becomes a `<Scalar>ListFieldUpdate` carrying `set` and `push`. Exactly one
+   * operation per field, checked at resolve time. `set` is the explicit spelling of what the
+   * field did before, so `set: { views: 42 }` becomes `set: { views: { set: 42 } }`.
+   *
+   * The arithmetic happens in the database (`SET views = views + 1`), so a counter no longer
+   * needs a read-modify-write round trip and no longer loses concurrent updates. Rounding on
+   * an integer column, and division by zero, follow the database's own rules rather than
+   * being guarded here. Columns owned by a scalar override keep their plain type — an
+   * override owns what the column accepts.
+   *
+   * Off by default: it changes the type of every numeric and array field on every update
+   * input, which no existing document is written against.
+   *
+   * @default false
+   */
+  fieldUpdateOperations?: FeatureSwitch;
+  /**
+   * `update<Table>Count` / `delete<Table>Count` mutations — the same write as the plural
+   * `update<Table>` / `delete<Table>`, returning the number of rows affected instead of the
+   * rows themselves.
+   *
+   * ```graphql
+   * deletePostsCount(where: { published: { eq: false } })   # Int!
+   * ```
+   *
+   * A mass update or delete otherwise has to `RETURNING *` every row it touched purely so
+   * the caller can count them, which crosses the driver and is serialized through GraphQL
+   * for nothing. Each mutation is generated only when its plural counterpart is
+   * (`features.update` / `features.delete`), and honours `features.requireWhere`.
+   *
+   * Off unless asked for, so an existing schema does not grow new mutations on upgrade.
+   *
+   * @default false
+   */
+  countMutations?: FeatureSwitch;
+  /**
+   * Makes `where` non-null on the plural `update<Table>` / `delete<Table>` mutations, and
+   * rejects a `where` that collapses to no filters (e.g. `where: {}`), so a schema can rule
+   * out unbounded writes at the type level. Off by default for backwards compatibility.
+   *
+   * The `Single` variants (`update<Table>Single` / `delete<Table>Single`) require a
+   * non-empty `where` regardless of this flag.
+   *
+   * @default false
+   */
+  requireWhere?: FeatureSwitch;
+  /**
+   * One `where` field per compound unique constraint, so a lookup by a natural key names the
+   * key instead of restating its columns:
+   *
+   * ```graphql
+   * stockSingle(where: { itemId_locationId: { itemId: "i1", locationId: "l1" } }) { quantity }
+   * ```
+   *
+   * The field is named after its member columns and every member is non-null, so a half-
+   * supplied key fails query validation rather than becoming a broader filter that returns
+   * whichever row happens to come first. It compiles to the same equalities the columns would
+   * have — the guarantee is in the input type.
+   *
+   * Single-column constraints get no field (`eq` on the column already says it), and a
+   * constraint whose field name is taken by a column or a relation is skipped. The fields live
+   * on `<Type>Filters`, so they are accepted wherever a filter is: the `Single` reads and
+   * writes they are meant for, but also list queries, relation filters and `onConflict.where`.
+   *
+   * Off unless asked for: it adds an input type per compound constraint.
+   *
+   * @default false
+   */
+  uniqueKeyFilters?: FeatureSwitch;
 };
 /**
  * Per-field cost hints for `graphql-query-complexity` (or any estimator that reads
  * `extensions.complexity`). See {@link BuildSchemaConfig.complexity}.
  */
 type ComplexityConfig = {
-    /**
-     * Rows a list field is assumed to return when the query passes no `limit`. Raise it if your
-     * tables are large and clients routinely omit `limit`.
-     *
-     * @default 10
-     */
-    defaultListSize?: number;
-    /**
-     * Flat cost charged for an aggregate field, on top of whatever is selected inside it. An
-     * aggregate returns one row but reads however many match, so it is priced as a scan.
-     *
-     * @default 10
-     */
-    aggregateCost?: number;
+  /**
+   * Rows a list field is assumed to return when the query passes no `limit`. Raise it if your
+   * tables are large and clients routinely omit `limit`.
+   *
+   * @default 10
+   */
+  defaultListSize?: number;
+  /**
+   * Flat cost charged for an aggregate field, on top of whatever is selected inside it. An
+   * aggregate returns one row but reads however many match, so it is priced as a scan.
+   *
+   * @default 10
+   */
+  aggregateCost?: number;
 };
 /**
  * A limit policy: what a request without `limit` gets, and how large a `limit` may be.
  * Every field is optional — an empty policy is the default unbounded behavior.
  */
 type TableLimitPolicy = {
-    /** Applied when the client passes no `limit`. Capped by `maxLimit` when both are set. */
-    defaultLimit?: number;
-    /**
-     * The largest `limit` a client may ask for. Also bounds a request that passes no `limit` at
-     * all, since that means every row.
-     */
-    maxLimit?: number;
-    /**
-     * `false` (default) rejects a `limit` above `maxLimit` with a GraphQL error; `true` reduces
-     * it to `maxLimit` instead.
-     */
-    clampToMax?: boolean;
+  /** Applied when the client passes no `limit`. Capped by `maxLimit` when both are set. */
+  defaultLimit?: number;
+  /**
+   * The largest `limit` a client may ask for. Also bounds a request that passes no `limit` at
+   * all, since that means every row.
+   */
+  maxLimit?: number;
+  /**
+   * `false` (default) rejects a `limit` above `maxLimit` with a GraphQL error; `true` reduces
+   * it to `maxLimit` instead.
+   */
+  clampToMax?: boolean;
 };
 /**
  * One entry of a {@link TableDefaults} ordering: a direction, or a direction with the
@@ -1247,23 +1247,23 @@ type TableLimitPolicy = {
  * generated `orderBy` argument).
  */
 type DefaultOrderByEntry = 'asc' | 'desc' | {
-    direction: 'asc' | 'desc';
-    priority?: number;
+  direction: 'asc' | 'desc';
+  priority?: number;
 };
 /** {@link DefaultsConfig} — what one table falls back to when the request does not say. */
 type TableDefaults = {
-    /**
-     * The ordering a read of this table runs with when the request passes no `orderBy`, keyed
-     * by column property name.
-     */
-    orderBy?: Record<string, DefaultOrderByEntry>;
+  /**
+   * The ordering a read of this table runs with when the request passes no `orderBy`, keyed
+   * by column property name.
+   */
+  orderBy?: Record<string, DefaultOrderByEntry>;
 };
 /** {@link BuildSchemaConfig.defaults} — per-table defaults, keyed by the Drizzle schema key. */
 type DefaultsConfig = Record<string, TableDefaults>;
 /** {@link BuildSchemaConfig.limits} — a global policy plus per-table overrides. */
 type LimitsConfig = TableLimitPolicy & {
-    /** Per-table overrides, keyed by the table's key in the Drizzle schema. */
-    tables?: Record<string, TableLimitPolicy>;
+  /** Per-table overrides, keyed by the table's key in the Drizzle schema. */
+  tables?: Record<string, TableLimitPolicy>;
 };
 /**
  * What a {@link RowScope} may return: a Drizzle `SQL` expression, a filter object in the same
@@ -1298,49 +1298,48 @@ type ContextValuesConfig<TContext = any> = Record<string, Record<string, (contex
  * written on delete and on restore. See {@link BuildSchemaConfig.softDelete}.
  */
 type SoftDeleteColumn = string | {
-    /** Property name of the column that marks a row deleted. */
-    column: string;
-    /**
-     * Written when a row is deleted. A function is evaluated per delete. Defaults by column
-     * type: `new Date()` for a timestamp, an ISO string for text, `Date.now()` for a number,
-     * `true` for a boolean. Required, as a constant, when the column is NOT NULL and not a
-     * boolean — the predicate that hides marked rows has to compare against it.
-     */
-    deletedValue?: any;
-    /**
-     * Written when a row is restored. Defaults to `null` for a nullable column and `false`
-     * for a NOT NULL boolean; required for any other NOT NULL column.
-     */
-    restoredValue?: any;
-    /**
-     * Which generated reads hide marked rows by default.
-     *
-     * - `'all'` (the default) — the table's own query fields and every relation field that
-     *   points at it. A *required* to-one relation is the one exception: hiding the row
-     *   there can only produce "Cannot return null for non-nullable field", never a usable
-     *   result, so it reads `INCLUDE` unless the request says otherwise.
-     * - `'root'` — only the table's own query fields. Relation fields read marked rows,
-     *   which is what "retired, not erased" usually means: keep the row off the pickers and
-     *   the lists, keep rendering it on the historical rows that reference it.
-     *
-     * The `deleted` argument is generated either way, so either default can be overridden
-     * per request.
-     */
-    scope?: 'root' | 'all';
-    /**
-     * Whether the table's delete mutations accept `hard: Boolean = false`, which issues a
-     * real `DELETE` instead of writing the marker — emptying the trash, reclaiming a unique
-     * key, clearing a table. Opt-in per table, and the argument is only generated when it is
-     * on, so the schema itself says which tables can be purged.
-     *
-     * A hard delete reads at `INCLUDE`: it reaches already-marked rows, which is the case it
-     * mostly exists for. A `scope` still confines it, exactly as it confines every other write.
-     *
-     * @default false
-     */
-    hardDelete?: boolean;
+  /** Property name of the column that marks a row deleted. */
+  column: string;
+  /**
+   * Written when a row is deleted. A function is evaluated per delete. Defaults by column
+   * type: `new Date()` for a timestamp, an ISO string for text, `Date.now()` for a number,
+   * `true` for a boolean. Required, as a constant, when the column is NOT NULL and not a
+   * boolean — the predicate that hides marked rows has to compare against it.
+   */
+  deletedValue?: any;
+  /**
+   * Written when a row is restored. Defaults to `null` for a nullable column and `false`
+   * for a NOT NULL boolean; required for any other NOT NULL column.
+   */
+  restoredValue?: any;
+  /**
+   * Which generated reads hide marked rows by default.
+   *
+   * - `'all'` (the default) — the table's own query fields and every relation field that
+   *   points at it. A *required* to-one relation is the one exception: hiding the row
+   *   there can only produce "Cannot return null for non-nullable field", never a usable
+   *   result, so it reads `INCLUDE` unless the request says otherwise.
+   * - `'root'` — only the table's own query fields. Relation fields read marked rows,
+   *   which is what "retired, not erased" usually means: keep the row off the pickers and
+   *   the lists, keep rendering it on the historical rows that reference it.
+   *
+   * The `deleted` argument is generated either way, so either default can be overridden
+   * per request.
+   */
+  scope?: 'root' | 'all';
+  /**
+   * Whether the table's delete mutations accept `hard: Boolean = false`, which issues a
+   * real `DELETE` instead of writing the marker — emptying the trash, reclaiming a unique
+   * key, clearing a table. Opt-in per table, and the argument is only generated when it is
+   * on, so the schema itself says which tables can be purged.
+   *
+   * A hard delete reads at `INCLUDE`: it reaches already-marked rows, which is the case it
+   * mostly exists for. A `scope` still confines it, exactly as it confines every other write.
+   *
+   * @default false
+   */
+  hardDelete?: boolean;
 };
-
 /**
  * Write hooks, either applied to every table (a bare function, or an object naming the
  * positions) or registered per table by Drizzle schema key. See
@@ -1359,707 +1358,708 @@ type SoftDeleteConfig = Record<string, SoftDeleteColumn> | ((table: any, tableNa
  * GraphQL name.
  */
 type SchemaExclusions = {
-    /**
-     * Tables that generate nothing at all: no object type, no queries, no mutations, and no
-     * relation fields on other tables that point at them.
-     */
-    tables?: string[];
-    /** Per-table column exclusions, keyed by the table's key in the Drizzle schema. */
-    columns?: Record<string, string[]>;
+  /**
+   * Tables that generate nothing at all: no object type, no queries, no mutations, and no
+   * relation fields on other tables that point at them.
+   */
+  tables?: string[];
+  /** Per-table column exclusions, keyed by the table's key in the Drizzle schema. */
+  columns?: Record<string, string[]>;
 };
 type BuildSchemaConfig = {
-    /**
-     * Determines whether generated mutations will be passed to returned schema.
-     *
-     * Set value to `false` to omit mutations from returned schema.
-     *
-     * Flag is treated as if set to `true` by default.
-     */
-    mutations?: boolean;
-    /**
-     * Limits depth of relation-field generation.
-     *
-     * Expects a non-negative integer or `undefined`.
-     *
-     * `undefined` (default) — no limit; all relations are generated recursively
-     * until a cycle is detected.
-     *
-     * `0` — no relation fields are generated on any type. Useful for a flat,
-     * columns-only schema.
-     *
-     * `N > 0` — each table's own direct relations are still generated (every
-     * table's root type is processed at depth 0, which is always < N). The
-     * depth limit controls how deep the generation RECURSES when traversing
-     * related types; because all types share a single instance via the type
-     * cache, setting N > 0 currently behaves the same as `undefined` for the
-     * final schema shape. The principal useful values are `0` (no relations)
-     * and `undefined` (unlimited).
-     */
-    relationsDepthLimit?: number;
-    /**
-     * Customizes query name prefixes for generated GraphQL operations.
-     *
-     * @default { insert: 'create', delete: 'delete', update: 'update', upsert: 'upsert' }
-     */
-    prefixes?: {
-        /** Prefix for insert mutations (e.g., 'users' -> 'createUsers') */
-        insert?: string;
-        /** Prefix for delete mutations (e.g., 'users' -> 'deleteUsers') */
-        delete?: string;
-        /** Prefix for update mutations (e.g., 'users' -> 'updateUsers') */
-        update?: string;
-        /** Prefix for upsert mutations (e.g., 'users' -> 'upsertUsers') */
-        upsert?: string;
-        /**
-         * Prefix for the restore mutations of a soft-deleting table (e.g., 'users' ->
-         * 'restoreUsers'). Only used when {@link BuildSchemaConfig.softDelete} names the table.
-         */
-        restore?: string;
-    };
-    /**
-     * Customizes query name suffixes for generated GraphQL operations.
-     *
-     * @default { list: '', single: 'Single' }
-     */
-    suffixes?: {
-        /** Suffix for list queries (e.g., 'users' -> 'users' + suffix) */
-        list?: string;
-        /** Suffix for single queries (e.g., 'users' -> 'users' + suffix) */
-        single?: string;
-    };
-    /**
-     * When true, insert mutations will use onConflictDoNothing() to silently
-     * ignore duplicate key violations. Defaults to false (conflicts throw errors).
-     *
-     * PostgreSQL and SQLite only — MySQL's insert builder has no equivalent, so the flag is
-     * ignored there and conflicts keep throwing.
-     *
-     * @deprecated Build-wide and unconditional: a request cannot opt out of it, and a
-     * swallowed insert returns `null` with no indication why. Turn on `features.upsert` and
-     * pass `onConflict: { action: NOTHING }` per request instead. This flag keeps working
-     * until the next major.
-     */
-    conflictDoNothing?: boolean;
-    /**
-     * Cost hints published as `extensions.complexity` on the generated fields, for
-     * `graphql-query-complexity`'s `fieldExtensionsEstimator`.
-     *
-     * The generator knows which fields are paginated and which are aggregates, so a list field is
-     * priced at `(limit ?? defaultListSize) * childComplexity` and an aggregate at
-     * `aggregateCost + childComplexity`. Everything else is left alone and falls through to your
-     * estimator's default. The hints are inert until you install a complexity rule, so they are on
-     * by default; pass `false` to omit them.
-     *
-     * Cost is not a depth bound — a cyclic relation graph still lets a client nest arbitrarily
-     * deep. Put a depth limit in front of a publicly exposed schema as well.
-     *
-     * ```ts
-     * import { createComplexityRule, fieldExtensionsEstimator, simpleEstimator } from 'graphql-query-complexity';
-     *
-     * const rule = createComplexityRule({
-     *   maximumComplexity: 1000,
-     *   estimators: [fieldExtensionsEstimator(), simpleEstimator({ defaultComplexity: 1 })],
-     * });
-     * ```
-     *
-     * @default true
-     */
-    complexity?: boolean | ComplexityConfig;
-    /**
-     * Turns individual generated features off, for the whole build or per table.
-     *
-     * Every flag defaults to `true` except `upsert` and `nestedWrites`, which are opt-in: a
-     * build with no `features` block generates exactly what it generated before this option
-     * existed. Turning one off removes both the schema surface it adds and the work behind it.
-     *
-     * ```ts
-     * buildSchema(db, {
-     *   features: {
-     *     aggregates: false,         // no `<plural>Aggregate` root queries
-     *     relationAggregates: false, // no `<relation>Aggregate` fields on object types
-     *     distinct: false,           // no `distinct` argument on list queries
-     *     delete: false,             // no delete mutations
-     *     upsert: true,              // opt in to `upsert<Table>` mutations
-     *   },
-     * });
-     * ```
-     *
-     * Any flag may instead be a predicate, which is asked once per table with the table's key
-     * in the Drizzle schema — the usual case, where a handful of tables must not be written
-     * through the API and the rest want the full set:
-     *
-     * ```ts
-     * buildSchema(db, {
-     *   features: {
-     *     delete: (table) => table !== 'auditLog',
-     *     update: (table) => !ownedByCustomResolver.has(table),
-     *     upsert: (table) => table === 'settings',
-     *   },
-     * });
-     * ```
-     *
-     * A table that generates nothing at all belongs in {@link BuildSchemaConfig.exclude}; this
-     * decides which operations a table that *is* in the schema offers. `nestedWrites` is the one
-     * flag that stays build-wide: its plans are computed once over the whole relation graph, and
-     * a nested write reaches a second table by definition.
-     *
-     * Some operations are built out of others — an upsert writes through insert and update, a
-     * batch update reuses the update input, a grouped query reuses the aggregate types. Flags
-     * that contradict those implications warn on the console at build time (naming the tables)
-     * rather than leaving a second write path past the operation you turned off to be found
-     * later.
-     *
-     * Turning off every mutation feature for every table omits the `Mutation` type entirely,
-     * exactly as `mutations: false` does. Query-side features can all be off — the list and
-     * single queries are always generated, so `Query` is never empty.
-     */
-    features?: SchemaFeatures;
-    /**
-     * Automatic transactions for GraphQL documents that fire more than one mutation.
-     *
-     * `'none'` (default) — every root mutation field runs on its own connection, so a failure
-     * mid-document leaves the earlier mutations committed (today's behavior).
-     *
-     * `'auto'` — when a request's document selects more than one root mutation field, the
-     * library opens `db.transaction()` once for the whole request and runs every mutation
-     * field (and the reads nested under them) inside it. The transaction commits when the
-     * last mutation field completes and rolls back when any of them fails; mutation fields
-     * after a failure are not executed against the rolled-back transaction — they fail fast.
-     * The object form additionally sets the safety timeout (default 30000ms) after which an
-     * abandoned transaction — e.g. the host server stopped calling resolvers because of a
-     * non-null completion error — is rolled back instead of leaking a connection.
-     *
-     * Never nests: a caller-supplied executor on the GraphQL context under
-     * `drizzleExecutorKey` always wins, and the library opens nothing of its own.
-     *
-     * Requirements and caveats:
-     * - The driver must support `db.transaction()` (e.g. `neon-http` does not). For SQLite
-     *   only asynchronous drivers (libsql, better-sqlite3 is synchronous) can hold a
-     *   transaction open across resolvers; `buildSchema` throws for synchronous ones.
-     * - The GraphQL context value must be a fresh object per request (every mainstream
-     *   server does this) — it keys the per-request transaction state.
-     * - Documents that mix in mutation fields not generated by this build (consumer
-     *   extensions) are left alone: their completion cannot be tracked, so no transaction
-     *   is opened.
-     *
-     * @default 'none'
-     */
-    transactions?: 'auto' | 'none' | {
-        mode: 'auto';
-        timeoutMs?: number;
-    };
-    /**
-     * Bounds on the `limit` argument of list queries and to-many relation fields.
-     *
-     * Both knobs are off by default: without them a client can omit `limit` and pull a whole
-     * table, or pass `limit: 1000000` and do the same thing politely. Turning either on changes
-     * observable behavior for existing consumers, so nothing is applied unless asked for.
-     *
-     * ```ts
-     * buildSchema(db, {
-     *   limits: {
-     *     defaultLimit: 50,  // used when the client passes no `limit`
-     *     maxLimit: 500,     // anything above is rejected
-     *     tables: {
-     *       auditLog: { defaultLimit: 20, maxLimit: 100 },
-     *     },
-     *   },
-     * });
-     * ```
-     *
-     * - Applies to root list queries **and** to to-many relation fields — an unbounded relation
-     *   inside a bounded root is the same scan one level down. A relation field takes the policy
-     *   of the table it *targets*, so a table is bounded wherever it is reached from. Single-row
-     *   queries and aggregates take no `limit` and are unaffected.
-     * - A `limit` above `maxLimit` is rejected with a GraphQL error. Set `clampToMax: true` to
-     *   silently reduce it instead — honest paginating clients prefer the error, since a clamped
-     *   page looks like the end of the results.
-     * - `maxLimit` on its own also bounds the *omitted* case: no `limit` means every row, which
-     *   is above any maximum. `defaultLimit` is what a request without `limit` gets, capped by
-     *   `maxLimit` if both are set.
-     * - `tables` overrides per table, keyed by the Drizzle schema key. A table's entry replaces
-     *   the top-level value for whichever keys it sets.
-     * - Cursor pagination inherits the same policy — a keyset page needs a limit to be
-     *   meaningful, and `defaultLimit` is what makes `after`-only pagination well-formed.
-     * - The complexity hints price the *effective* limit, so cost estimation and enforcement
-     *   agree.
-     */
-    limits?: LimitsConfig;
-    /**
-     * Per-table defaults for arguments the request leaves out. Today that is `orderBy`: the
-     * presentation order a table has, declared once on the server instead of repeated by every
-     * client.
-     *
-     * ```ts
-     * buildSchema(db, {
-     *   defaults: {
-     *     Todos: { orderBy: { priority: 'desc', createdAt: 'desc' } },
-     *     AuditLog: { orderBy: { createdAt: { direction: 'desc', priority: 10 } } },
-     *   },
-     * });
-     * ```
-     *
-     * - Applies to the table's list and single queries, and to every to-many relation field
-     *   that *targets* it — a relation is ordered by the default of the table it reads, so a
-     *   table presents the same way wherever it is reached from. Eagerly and lazily loaded
-     *   relations agree.
-     * - Only a missing `orderBy` is replaced. `orderBy: {}` is a request for no ordering and
-     *   stays one, and any `orderBy` the client sends replaces the default outright rather than
-     *   merging with it.
-     * - Cursor pagination is defined over the effective ordering, so a default `orderBy` is
-     *   what an `after`-only page is ordered by. Changing a table's default changes what its
-     *   existing cursors mean.
-     * - Entries name column property names of that table; a direction alone is shorthand for
-     *   `{ direction }`. Unknown table or column names throw at build time.
-     * - Aggregates and `groupBy` take their own ordering and are unaffected.
-     *
-     * Off by default: a table with no entry keeps returning rows in whatever order the database
-     * gives them, tiebroken by primary key where an operation needs a total order.
-     */
-    defaults?: DefaultsConfig;
-    /**
-     * Row-level scoping: a predicate, derived from the GraphQL context, that every read and
-     * write of a table is confined to. This is the multi-tenancy / ownership knob — the one
-     * rule a wrapper cannot enforce from outside, because a nested relation field never passes
-     * through a root resolver.
-     *
-     * ```ts
-     * import { and, eq } from 'drizzle-orm';
-     *
-     * buildSchema(db, {
-     *   scope: {
-     *     posts: (ctx, table) => eq(table.orgId, ctx.orgId),
-     *     // A filter object works too, and can scope through a relation:
-     *     comments: (ctx) => ({ post: { orgId: { eq: ctx.orgId } } }),
-     *   },
-     * });
-     * ```
-     *
-     * - The predicate is ANDed on **last**, after the client's `where`, so a client filter can
-     *   only ever narrow the scope, never widen it.
-     * - It applies to every path that reads the table: list and single queries, aggregates and
-     *   `groupBy`, relation fields (batched and eager), relation aggregates, and cursor pages.
-     * - It applies to every path that writes it: `update`, `updateMany`, `delete`, the
-     *   conflict-update half of an upsert (PostgreSQL and SQLite), and the rows a nested
-     *   `connect` / `disconnect` / `set` is allowed to reach. An out-of-scope row is simply not
-     *   matched — a scoped `delete` reports zero rows rather than refusing.
-     * - It cannot apply to a plain `insert`: there is no existing row to filter. Use
-     *   {@link BuildSchemaConfig.contextValues} to stamp the owning column on the way in.
-     * - `table` is the table the current statement runs against, which for a relational read is
-     *   Drizzle's aliased copy — always build the predicate from that argument.
-     * - Returning `undefined` means "no restriction for this context", so a hook can let an
-     *   admin through. A table with no entry is unscoped.
-     * - MySQL's `ON DUPLICATE KEY UPDATE` takes no predicate, so a MySQL upsert cannot be
-     *   scoped on the conflict path; scope the table's `update` and rely on `contextValues`
-     *   for the insert half.
-     */
-    scope?: ScopeConfig;
-    /**
-     * Columns whose value the server derives from the request context rather than accepting
-     * from the client — the write-side half of {@link BuildSchemaConfig.scope}.
-     *
-     * ```ts
-     * buildSchema(db, {
-     *   contextValues: {
-     *     posts: {
-     *       orgId: (ctx) => ctx.orgId,
-     *       authorId: (ctx) => ctx.userId,
-     *     },
-     *   },
-     * });
-     * ```
-     *
-     * - The column is removed from the generated insert and update inputs, so a client cannot
-     *   send it at all — the schema itself documents that it is server-owned.
-     * - Every insert stamps it, including the rows created by a nested `create`.
-     * - Updates never write it: an update cannot hand a row to another owner.
-     * - Keyed by the Drizzle schema key, then by the column's property name (not its database
-     *   name), the same keying {@link BuildSchemaConfig.exclude} uses.
-     */
-    contextValues?: ContextValuesConfig;
-    /**
-     * Tables that mark rows deleted instead of removing them.
-     *
-     * ```ts
-     * buildSchema(db, {
-     *   softDelete: {
-     *     users: 'deletedAt',                          // nullable timestamp: stamped on delete
-     *     posts: { column: 'isDeleted', deletedValue: true, restoredValue: false },
-     *   },
-     * });
-     *
-     * // or as a convention across the whole schema:
-     * buildSchema(db, { softDelete: (table) => ('deletedAt' in table ? 'deletedAt' : undefined) });
-     * ```
-     *
-     * For a table that declares one:
-     *
-     * - `delete<Table>` and `delete<Table>Single` issue an `UPDATE` of the marker column
-     *   instead of a `DELETE`, and return the rows as they now stand.
-     * - `restore<Table>` and `restore<Table>Single` are generated alongside them, matching only
-     *   marked rows and writing the restored value. The prefix is configurable through
-     *   {@link BuildSchemaConfig.prefixes}.
-     * - Every generated read hides marked rows: list and single queries, aggregates, `groupBy`,
-     *   relation fields on both the eager and the batched path, and relation aggregates. Each
-     *   of those fields takes a `deleted: EXCLUDE | INCLUDE | ONLY` argument (default
-     *   `EXCLUDE`); `ONLY` is a trash view.
-     * - Every generated write skips them too: an `update`, a `delete`, or a nested `connect`
-     *   cannot reach a row that is already marked.
-     * - The marker column is removed from the create and update inputs, so the only ways to set
-     *   or clear it are the delete and restore mutations.
-     * - The predicate is ANDed on before {@link BuildSchemaConfig.scope}, and both are ANDed
-     *   after the client's `where` — a request can only ever narrow them.
-     *
-     * Two consequences of the pattern itself, which this does not paper over:
-     *
-     * - A marked row still occupies its unique keys, so inserting a row that reuses the natural
-     *   key of a deleted one still fails on the constraint.
-     * - An upsert whose conflict target hits a marked row updates nothing on PostgreSQL and
-     *   SQLite (the conflict predicate excludes it) but revives it on MySQL, whose
-     *   `ON DUPLICATE KEY UPDATE` takes no predicate.
-     *
-     * Marking a parent deleted does not mark its children — a cascade is a schema decision.
-     */
-    softDelete?: SoftDeleteConfig;
-    /**
-     * A hook that runs **inside the mutation's transaction**, so its writes commit or roll back
-     * with the mutation itself — the position an audit row, an outbox row, or a denormalized
-     * counter needs, and the one a `graphql-middleware` wrapper cannot occupy.
-     *
-     * ```ts
-     * buildSchema(db, {
-     *   onWrite: {
-     *     posts: async ({ table, operation, rows, tx }) => {
-     *       await tx.insert(auditLog).values(rows.map((row) => ({ table, operation, rowId: row.id })));
-     *     },
-     *   },
-     * });
-     * ```
-     *
-     * A bare function is the **`after`** hook — the position that has rows. `{ before, after }`
-     * names them explicitly; `before` receives the field's args ahead of the statement, for a
-     * check that has to read inside the same snapshot. Registering a bare function (or a
-     * positions object) at the top level applies it to every table; anything else is read as a
-     * table map keyed by Drizzle schema key, and an unknown name fails the build.
-     *
-     * - **`tx` is the executor the mutation ran on** — a caller-supplied executor under
-     *   `drizzleExecutorKey`, the request's auto-transaction, or, for a field that would
-     *   otherwise have run unwrapped, a transaction opened for it because the hook is there.
-     * - **Throwing rolls the mutation back.** That is the point of the position.
-     * - **`rows` are the post-write rows as the database returned them**, before the output
-     *   mapper. Empty at the `before` position, and on MySQL, whose mutations return no rows.
-     * - The hook fires for the **mutation field's own table**. Rows a nested write creates in
-     *   another table do not fire that table's hook.
-     *
-     * Off by default, and a build without it opens exactly the transactions it did before.
-     */
-    onWrite?: OnWriteConfig;
-    /**
-     * Tables and columns to leave out of the generated schema entirely.
-     *
-     * ```ts
-     * buildSchema(db, {
-     *   exclude: {
-     *     tables: ['magicLinks', 'sessions'],
-     *     columns: { apiKeys: ['keyHash'] },
-     *   },
-     * });
-     * ```
-     *
-     * An excluded **table** generates nothing: no object type, no root queries or mutations, no
-     * aggregates, and no relation field on any other table that points at it. Filtering another
-     * table by a relation to it is gone too, so it is unreachable rather than merely unnamed.
-     *
-     * An excluded **column** disappears from every surface at once — the object type, the
-     * create/update/upsert inputs, the filter type, `orderBy`, the aggregate fields, the
-     * `distinct` and `groupBy` enums, and the upsert conflict targets. The exclusion is
-     * deliberately all-or-nothing: a column you can filter on but not select is an oracle, since
-     * `where: { keyHash: { eq: '…' } }` confirms a value without ever returning it.
-     *
-     * Excluding a `NOT NULL` column that has no default makes that table's inserts impossible to
-     * satisfy — `buildSchema` warns on the console when it sees this, and still builds, since a
-     * read-only table is a reasonable thing to want.
-     *
-     * Names that match nothing throw, so a renamed column fails the build instead of quietly
-     * un-hiding itself.
-     */
-    exclude?: SchemaExclusions;
-    /**
-     * Optional mapper from table key to singular/plural name pair.
-     * When provided for a table, overrides the default (table key) naming for GraphQL type names,
-     * query field names, and mutation field names.
-     * Return `undefined` for tables that should use the default naming.
-     *
-     * Example: `(name) => name === 'users' ? { singular: 'user', plural: 'users' } : undefined`
-     * produces type `User`, queries `users` / `user`, mutations `createUsers` / `createUser` for
-     * the `users` table, and leaves other tables with their default names.
-     *
-     * Pass the string `'singularize'` for the built-in preset, which derives both forms of every
-     * table key with the library's own `pluralize` — the mapper most schemas with plural table
-     * keys would otherwise write by hand:
-     *
-     * ```ts
-     * buildSchema(db, { typeNameMapper: 'singularize' });
-     * // tasks -> type Task, queries `tasks` / `task`, mutations `createTasks` / `createTask`
-     * ```
-     *
-     * The same function is exported as `singularizeMapper` for wrapping — e.g. to keep one
-     * table's names as they are: `(t) => (t === 'audit_log' ? undefined : singularizeMapper(t))`.
-     *
-     * The function half is the exported {@link TypeNameMapper}, so a mapper can be declared once
-     * and handed both to `buildSchema` and to `selectionToWith` / `resolveSelection`, which need
-     * the same naming rule to read a selection back out of a schema built with it.
-     */
-    typeNameMapper?: 'singularize' | TypeNameMapper;
-    /**
-     * Renames the types generated *around* a table — the filter, the write inputs, the
-     * order-by, the aggregate family, the group-by types, the conflict input, the shared scalar
-     * filters. `typeNameMapper` names a table's object type and its root fields; those derived
-     * names follow from it by a fixed rule, and this is the hook that overrides the rule.
-     *
-     * Asked once per generated type, with the kind, the name the library would use, and the
-     * table it belongs to where it belongs to one. Return `undefined` — or the same name — to
-     * keep the default, so a mapper that answers for one kind leaves everything else alone:
-     *
-     * ```ts
-     * buildSchema(db, {
-     *   derivedTypeNameMapper: ({ kind, table, operation, defaultName }) =>
-     *     kind === 'aggregate' && operation ? `${table}Aggregate${operation}` : undefined,
-     * });
-     * ```
-     *
-     * A returned name is used verbatim — {@link BuildSchemaConfig.typeNamePrefix} and
-     * {@link BuildSchemaConfig.typeNameSuffix} do not wrap it, since the more specific of the
-     * two knobs wins.
-     *
-     * The point of it is stitching: a schema merged with a second generator over the same
-     * tables collides on the derived names constantly, because both derive them from the model
-     * name by the same obvious rule. Renaming them here means the collision never exists, rather
-     * than being papered over by a `RenameTypes` transform on the way out.
-     */
-    derivedTypeNameMapper?: DerivedTypeNameMapper;
-    /**
-     * Prepended to every generated type name — object types, filters, write inputs, the
-     * aggregate family, the shared scalar filters, everything — that
-     * {@link BuildSchemaConfig.derivedTypeNameMapper} did not answer for. The one-line way to
-     * make a whole subschema collision-free before stitching it:
-     *
-     * ```ts
-     * buildSchema(db, { typeNamePrefix: 'Db' });
-     * // type DbUsers, input DbUsersFilters, input DbStringFilter, enum DbOrderNulls, …
-     * ```
-     *
-     * Custom scalars, database enum types and `PgGeometryObject` keep their own names: their
-     * definition does not vary between builds, so a gateway merges them rather than colliding
-     * on them. Field and argument names are untouched too — only type names move, so a client's
-     * queries are unaffected apart from the names it spells in variable declarations.
-     *
-     * Must be a valid GraphQL name start (`/^[_A-Za-z][_0-9A-Za-z]*$/`); anything else throws.
-     */
-    typeNamePrefix?: string;
-    /**
-     * Appended to every generated type name that {@link BuildSchemaConfig.derivedTypeNameMapper}
-     * did not answer for. The counterpart of {@link BuildSchemaConfig.typeNamePrefix}; both may
-     * be given at once.
-     */
-    typeNameSuffix?: string;
-    /**
-     * Controls whether a relation is eagerly pre-fetched via Drizzle's `with:` clause
-     * when its parent is loaded through a generated query or mutation.
-     *
-     * `true` (default) — every selected relation is eager-loaded in the parent's query.
-     *
-     * `false` — no relation is ever eager-loaded; all relations resolve lazily through
-     * their (request-batched) field resolvers.
-     *
-     * `(tableName, relationName) => boolean` — decide per relation. Return `false` to
-     * exclude that relation from `with:` (and from the mutation eager re-fetch).
-     *
-     * Opting a relation out does NOT remove its field resolver — it still resolves
-     * lazily via the request-scoped batch loader. This is the hook for overriding a
-     * relation's resolver (e.g. via `@graphql-tools/schema`'s `addResolversToSchema`)
-     * without the eager `with:` query also fetching it from the database:
-     *
-     * ```ts
-     * const { schema } = buildSchema(db, {
-     *   eagerLoadRelations: (t, r) => !(t === 'Users' && r === 'posts'),
-     * });
-     * const finalSchema = addResolversToSchema({
-     *   schema,
-     *   resolvers: { Users: { posts: (parent) => myLoader.load(parent.id) } },
-     * });
-     * ```
-     *
-     * Table and relation names are the Drizzle schema keys (e.g. `Users`, `posts`),
-     * matching the keys of `entities.fieldResolvers`.
-     *
-     * @default true
-     */
-    eagerLoadRelations?: boolean | ((tableName: string, relationName: string) => boolean);
-    /**
-     * Declarative per-table, per-column scalar overrides — replaces the GraphQL type built-in
-     * detection would pick for a column with the scalar you provide, everywhere that column's
-     * type surfaces: the object type, create/update inputs, filter operands (in a filter type
-     * named `${Scalar}Filter`), and aggregate min/max fields.
-     *
-     * Keys are the Drizzle schema keys: the table's key in your schema object and the column's
-     * property name. The value is either one scalar for both directions, or `{ output, input }`
-     * to type outputs and inputs differently (either side may be omitted to keep the default).
-     *
-     * ```ts
-     * buildSchema(db, {
-     *   scalars: {
-     *     users: {
-     *       balance: GraphQLBigIntString,                      // both directions
-     *       settings: { output: PrettyJSON },                  // output only, input stays default
-     *     },
-     *   },
-     * });
-     * ```
-     *
-     * Validation and coercion become the scalar's job: for an overridden column the generated
-     * resolvers pass values through untouched — `parseValue`/`parseLiteral` results go to the
-     * database driver as-is, and raw driver values go to `serialize` as-is — so the scalar must
-     * accept what the driver produces and produce what the driver accepts.
-     *
-     * A declarative entry fully decides its column and wins over {@link mapColumnType}.
-     */
-    scalars?: ScalarOverridesConfig;
-    /**
-     * Rule-based scalar mapping, called once per column at build time — the tool for applying
-     * a convention across many columns (e.g. "every `numeric` column is `Money`") or for typing
-     * custom column types the built-in detection does not know.
-     *
-     * Return a scalar (or `{ output, input }` pair) to override the column, or `undefined` to
-     * keep the default. `info` carries the table/column schema keys and the types built-in
-     * detection would use (`defaultType` / `defaultInputType`), so rules can key off either the
-     * Drizzle column or the default GraphQL type.
-     *
-     * ```ts
-     * buildSchema(db, {
-     *   mapColumnType: (column, { columnName }) =>
-     *     column.columnType === 'PgNumeric' ? MoneyScalar : undefined,
-     * });
-     * ```
-     *
-     * Same semantics as {@link scalars} otherwise; a column matched by both is decided by
-     * `scalars` alone.
-     */
-    mapColumnType?: ColumnTypeMapper;
-    /**
-     * Called for every error thrown by a generated resolver, before it reaches the client.
-     *
-     * Return an error to surface that one instead. Return nothing to fall through to the
-     * default handling, which makes this a pure logging hook:
-     *
-     * ```ts
-     * buildSchema(db, { onError: (error) => { logger.error(error) } })
-     * ```
-     *
-     * The default passes through errors drizzle-graphql raises itself (bad filter, missing
-     * values, invalid date, …) and replaces everything else — driver and database errors —
-     * with a generic `Internal server error`, keeping the original on `originalError` so it
-     * is still available to server-side logging. Database messages routinely name tables,
-     * columns, constraints and the values that violated them, which is not something a
-     * public API should hand back.
-     *
-     * To surface raw database errors instead (useful in development):
-     *
-     * ```ts
-     * buildSchema(db, { onError: (error) => error as Error })
-     * ```
-     */
-    onError?: (error: unknown) => unknown;
-    /**
-     * Supplies the GraphQL `description` for a column, everywhere that column becomes a field:
-     * the object type, the create/update inputs, the filter input, and the aggregate
-     * `min`/`max`/`group` fields.
-     *
-     * Nothing is generated by default. The library used to emit the column's own type name
-     * ("DateTime", "JSON") as its description, which documented nothing a reader could not see
-     * from the type — that is gone, and this hook is what puts real prose in its place. Drizzle
-     * carries no column-comment metadata to read, so the text has to come from here.
-     *
-     * ```ts
-     * const columnDocs = { Users: { email: 'Primary contact address. Unique, case-insensitive.' } };
-     *
-     * buildSchema(db, {
-     *   describeColumn: (_column, { tableName, columnName }) => columnDocs[tableName]?.[columnName],
-     * });
-     * ```
-     *
-     * `tableName` and `columnName` are the Drizzle schema keys. Return `undefined` to leave the
-     * field undocumented.
-     */
-    describeColumn?: ColumnDescriber;
-    /**
-     * Supplies the GraphQL `description` for a table's object type.
-     *
-     * ```ts
-     * buildSchema(db, { describeTable: (tableName) => tableDocs[tableName] });
-     * ```
-     */
-    describeTable?: TableDescriber;
-    /**
-     * Supplies the GraphQL `description` for a relation field on a table's object type.
-     *
-     * ```ts
-     * buildSchema(db, {
-     *   describeRelation: (tableName, relationName) =>
-     *     tableName === 'Users' && relationName === 'posts' ? 'Posts this user authored.' : undefined,
-     * });
-     * ```
-     *
-     * The generated `<relation>Aggregate` companion fields are not covered — they are derived
-     * fields rather than the relation itself.
-     */
-    describeRelation?: RelationDescriber;
-    /**
-     * Supplies the GraphQL `deprecationReason` for a column, marking it `@deprecated` on the
-     * object type and on the create/update inputs.
-     *
-     * ```ts
-     * buildSchema(db, {
-     *   deprecateColumn: (_column, { columnName }) =>
-     *     columnName === 'legacyFlag' ? 'Use `status` instead.' : undefined,
-     * });
-     * ```
-     *
-     * A required input field cannot be deprecated — GraphQL rejects the schema, since a client
-     * has no way to stop sending it — so the reason is dropped on non-null input fields and
-     * kept everywhere else. Filter and orderBy fields are never deprecated either: filtering on
-     * a deprecated column is how a caller finds the rows that still use it.
-     */
-    deprecateColumn?: ColumnDeprecator;
-    /**
-     * Names the GraphQL enum types generated for enum columns.
-     *
-     * By default a column declared with a named `pgEnum` gets one shared type named after the
-     * enum (`pgEnum('status', …)` → `StatusEnum`), reused by every column declared with that
-     * same `pgEnum` — the database column is the same type, so a client variable typed
-     * `StatusEnum!` is passable to any of them. A column with an inline value list
-     * (`text({ enum: [...] })`, `mysqlEnum(...)`) keeps a per-column type named for its table
-     * and column (`UsersRoleTextEnum`), because its values are shared with nothing.
-     *
-     * This hook overrides the name either way — for lining the schema up with another schema it
-     * is stitched into, or for opting a specific column back into a type of its own:
-     *
-     * ```ts
-     * buildSchema(db, {
-     *   enumNameMapper: (info) => (info.enumName === 'status' ? 'PublicationStatus' : undefined),
-     * });
-     * ```
-     *
-     * Two columns the mapper sends to the same name share one type when their values match —
-     * the way to unify inline enums declared separately that mean the same thing. Sending two
-     * *different* value lists to one name throws at build time rather than producing an
-     * invalid schema.
-     *
-     * Return `undefined` to keep the default name.
-     */
-    enumNameMapper?: EnumNameMapper;
+  /**
+   * Determines whether generated mutations will be passed to returned schema.
+   *
+   * Set value to `false` to omit mutations from returned schema.
+   *
+   * Flag is treated as if set to `true` by default.
+   */
+  mutations?: boolean;
+  /**
+   * Limits depth of relation-field generation.
+   *
+   * Expects a non-negative integer or `undefined`.
+   *
+   * `undefined` (default) — no limit; all relations are generated recursively
+   * until a cycle is detected.
+   *
+   * `0` — no relation fields are generated on any type. Useful for a flat,
+   * columns-only schema.
+   *
+   * `N > 0` — each table's own direct relations are still generated (every
+   * table's root type is processed at depth 0, which is always < N). The
+   * depth limit controls how deep the generation RECURSES when traversing
+   * related types; because all types share a single instance via the type
+   * cache, setting N > 0 currently behaves the same as `undefined` for the
+   * final schema shape. The principal useful values are `0` (no relations)
+   * and `undefined` (unlimited).
+   */
+  relationsDepthLimit?: number;
+  /**
+   * Customizes query name prefixes for generated GraphQL operations.
+   *
+   * @default { insert: 'create', delete: 'delete', update: 'update', upsert: 'upsert' }
+   */
+  prefixes?: {
+    /** Prefix for insert mutations (e.g., 'users' -> 'createUsers') */
+    insert?: string;
+    /** Prefix for delete mutations (e.g., 'users' -> 'deleteUsers') */
+    delete?: string;
+    /** Prefix for update mutations (e.g., 'users' -> 'updateUsers') */
+    update?: string;
+    /** Prefix for upsert mutations (e.g., 'users' -> 'upsertUsers') */
+    upsert?: string;
+    /**
+     * Prefix for the restore mutations of a soft-deleting table (e.g., 'users' ->
+     * 'restoreUsers'). Only used when {@link BuildSchemaConfig.softDelete} names the table.
+     */
+    restore?: string;
+  };
+  /**
+   * Customizes query name suffixes for generated GraphQL operations.
+   *
+   * @default { list: '', single: 'Single' }
+   */
+  suffixes?: {
+    /** Suffix for list queries (e.g., 'users' -> 'users' + suffix) */
+    list?: string;
+    /** Suffix for single queries (e.g., 'users' -> 'users' + suffix) */
+    single?: string;
+  };
+  /**
+   * When true, insert mutations will use onConflictDoNothing() to silently
+   * ignore duplicate key violations. Defaults to false (conflicts throw errors).
+   *
+   * PostgreSQL and SQLite only — MySQL's insert builder has no equivalent, so the flag is
+   * ignored there and conflicts keep throwing.
+   *
+   * @deprecated Build-wide and unconditional: a request cannot opt out of it, and a
+   * swallowed insert returns `null` with no indication why. Turn on `features.upsert` and
+   * pass `onConflict: { action: NOTHING }` per request instead. This flag keeps working
+   * until the next major.
+   */
+  conflictDoNothing?: boolean;
+  /**
+   * Cost hints published as `extensions.complexity` on the generated fields, for
+   * `graphql-query-complexity`'s `fieldExtensionsEstimator`.
+   *
+   * The generator knows which fields are paginated and which are aggregates, so a list field is
+   * priced at `(limit ?? defaultListSize) * childComplexity` and an aggregate at
+   * `aggregateCost + childComplexity`. Everything else is left alone and falls through to your
+   * estimator's default. The hints are inert until you install a complexity rule, so they are on
+   * by default; pass `false` to omit them.
+   *
+   * Cost is not a depth bound — a cyclic relation graph still lets a client nest arbitrarily
+   * deep. Put a depth limit in front of a publicly exposed schema as well.
+   *
+   * ```ts
+   * import { createComplexityRule, fieldExtensionsEstimator, simpleEstimator } from 'graphql-query-complexity';
+   *
+   * const rule = createComplexityRule({
+   *   maximumComplexity: 1000,
+   *   estimators: [fieldExtensionsEstimator(), simpleEstimator({ defaultComplexity: 1 })],
+   * });
+   * ```
+   *
+   * @default true
+   */
+  complexity?: boolean | ComplexityConfig;
+  /**
+   * Turns individual generated features off, for the whole build or per table.
+   *
+   * Every flag defaults to `true` except `upsert` and `nestedWrites`, which are opt-in: a
+   * build with no `features` block generates exactly what it generated before this option
+   * existed. Turning one off removes both the schema surface it adds and the work behind it.
+   *
+   * ```ts
+   * buildSchema(db, {
+   *   features: {
+   *     aggregates: false,         // no `<plural>Aggregate` root queries
+   *     relationAggregates: false, // no `<relation>Aggregate` fields on object types
+   *     distinct: false,           // no `distinct` argument on list queries
+   *     delete: false,             // no delete mutations
+   *     upsert: true,              // opt in to `upsert<Table>` mutations
+   *   },
+   * });
+   * ```
+   *
+   * Any flag may instead be a predicate, which is asked once per table with the table's key
+   * in the Drizzle schema — the usual case, where a handful of tables must not be written
+   * through the API and the rest want the full set:
+   *
+   * ```ts
+   * buildSchema(db, {
+   *   features: {
+   *     delete: (table) => table !== 'auditLog',
+   *     update: (table) => !ownedByCustomResolver.has(table),
+   *     upsert: (table) => table === 'settings',
+   *   },
+   * });
+   * ```
+   *
+   * A table that generates nothing at all belongs in {@link BuildSchemaConfig.exclude}; this
+   * decides which operations a table that *is* in the schema offers. `nestedWrites` is the one
+   * flag that stays build-wide: its plans are computed once over the whole relation graph, and
+   * a nested write reaches a second table by definition.
+   *
+   * Some operations are built out of others — an upsert writes through insert and update, a
+   * batch update reuses the update input, a grouped query reuses the aggregate types. Flags
+   * that contradict those implications warn on the console at build time (naming the tables)
+   * rather than leaving a second write path past the operation you turned off to be found
+   * later.
+   *
+   * Turning off every mutation feature for every table omits the `Mutation` type entirely,
+   * exactly as `mutations: false` does. Query-side features can all be off — the list and
+   * single queries are always generated, so `Query` is never empty.
+   */
+  features?: SchemaFeatures;
+  /**
+   * Automatic transactions for GraphQL documents that fire more than one mutation.
+   *
+   * `'none'` (default) — every root mutation field runs on its own connection, so a failure
+   * mid-document leaves the earlier mutations committed (today's behavior).
+   *
+   * `'auto'` — when a request's document selects more than one root mutation field, the
+   * library opens `db.transaction()` once for the whole request and runs every mutation
+   * field (and the reads nested under them) inside it. The transaction commits when the
+   * last mutation field completes and rolls back when any of them fails; mutation fields
+   * after a failure are not executed against the rolled-back transaction — they fail fast.
+   * The object form additionally sets the safety timeout (default 30000ms) after which an
+   * abandoned transaction — e.g. the host server stopped calling resolvers because of a
+   * non-null completion error — is rolled back instead of leaking a connection.
+   *
+   * Never nests: a caller-supplied executor on the GraphQL context under
+   * `drizzleExecutorKey` always wins, and the library opens nothing of its own.
+   *
+   * Requirements and caveats:
+   * - The driver must support `db.transaction()` (e.g. `neon-http` does not). For SQLite
+   *   only asynchronous drivers (libsql, better-sqlite3 is synchronous) can hold a
+   *   transaction open across resolvers; `buildSchema` throws for synchronous ones.
+   * - The GraphQL context value must be a fresh object per request (every mainstream
+   *   server does this) — it keys the per-request transaction state.
+   * - Documents that mix in mutation fields not generated by this build (consumer
+   *   extensions) are left alone: their completion cannot be tracked, so no transaction
+   *   is opened.
+   *
+   * @default 'none'
+   */
+  transactions?: 'auto' | 'none' | {
+    mode: 'auto';
+    timeoutMs?: number;
+  };
+  /**
+   * Bounds on the `limit` argument of list queries and to-many relation fields.
+   *
+   * Both knobs are off by default: without them a client can omit `limit` and pull a whole
+   * table, or pass `limit: 1000000` and do the same thing politely. Turning either on changes
+   * observable behavior for existing consumers, so nothing is applied unless asked for.
+   *
+   * ```ts
+   * buildSchema(db, {
+   *   limits: {
+   *     defaultLimit: 50,  // used when the client passes no `limit`
+   *     maxLimit: 500,     // anything above is rejected
+   *     tables: {
+   *       auditLog: { defaultLimit: 20, maxLimit: 100 },
+   *     },
+   *   },
+   * });
+   * ```
+   *
+   * - Applies to root list queries **and** to to-many relation fields — an unbounded relation
+   *   inside a bounded root is the same scan one level down. A relation field takes the policy
+   *   of the table it *targets*, so a table is bounded wherever it is reached from. Single-row
+   *   queries and aggregates take no `limit` and are unaffected.
+   * - A `limit` above `maxLimit` is rejected with a GraphQL error. Set `clampToMax: true` to
+   *   silently reduce it instead — honest paginating clients prefer the error, since a clamped
+   *   page looks like the end of the results.
+   * - `maxLimit` on its own also bounds the *omitted* case: no `limit` means every row, which
+   *   is above any maximum. `defaultLimit` is what a request without `limit` gets, capped by
+   *   `maxLimit` if both are set.
+   * - `tables` overrides per table, keyed by the Drizzle schema key. A table's entry replaces
+   *   the top-level value for whichever keys it sets.
+   * - Cursor pagination inherits the same policy — a keyset page needs a limit to be
+   *   meaningful, and `defaultLimit` is what makes `after`-only pagination well-formed.
+   * - The complexity hints price the *effective* limit, so cost estimation and enforcement
+   *   agree.
+   */
+  limits?: LimitsConfig;
+  /**
+   * Per-table defaults for arguments the request leaves out. Today that is `orderBy`: the
+   * presentation order a table has, declared once on the server instead of repeated by every
+   * client.
+   *
+   * ```ts
+   * buildSchema(db, {
+   *   defaults: {
+   *     Todos: { orderBy: { priority: 'desc', createdAt: 'desc' } },
+   *     AuditLog: { orderBy: { createdAt: { direction: 'desc', priority: 10 } } },
+   *   },
+   * });
+   * ```
+   *
+   * - Applies to the table's list and single queries, and to every to-many relation field
+   *   that *targets* it — a relation is ordered by the default of the table it reads, so a
+   *   table presents the same way wherever it is reached from. Eagerly and lazily loaded
+   *   relations agree.
+   * - Only a missing `orderBy` is replaced. `orderBy: {}` is a request for no ordering and
+   *   stays one, and any `orderBy` the client sends replaces the default outright rather than
+   *   merging with it.
+   * - Cursor pagination is defined over the effective ordering, so a default `orderBy` is
+   *   what an `after`-only page is ordered by. Changing a table's default changes what its
+   *   existing cursors mean.
+   * - Entries name column property names of that table; a direction alone is shorthand for
+   *   `{ direction }`. Unknown table or column names throw at build time.
+   * - Aggregates and `groupBy` take their own ordering and are unaffected.
+   *
+   * Off by default: a table with no entry keeps returning rows in whatever order the database
+   * gives them, tiebroken by primary key where an operation needs a total order.
+   */
+  defaults?: DefaultsConfig;
+  /**
+   * Row-level scoping: a predicate, derived from the GraphQL context, that every read and
+   * write of a table is confined to. This is the multi-tenancy / ownership knob — the one
+   * rule a wrapper cannot enforce from outside, because a nested relation field never passes
+   * through a root resolver.
+   *
+   * ```ts
+   * import { and, eq } from 'drizzle-orm';
+   *
+   * buildSchema(db, {
+   *   scope: {
+   *     posts: (ctx, table) => eq(table.orgId, ctx.orgId),
+   *     // A filter object works too, and can scope through a relation:
+   *     comments: (ctx) => ({ post: { orgId: { eq: ctx.orgId } } }),
+   *   },
+   * });
+   * ```
+   *
+   * - The predicate is ANDed on **last**, after the client's `where`, so a client filter can
+   *   only ever narrow the scope, never widen it.
+   * - It applies to every path that reads the table: list and single queries, aggregates and
+   *   `groupBy`, relation fields (batched and eager), relation aggregates, and cursor pages.
+   * - It applies to every path that writes it: `update`, `updateMany`, `delete`, the
+   *   conflict-update half of an upsert (PostgreSQL and SQLite), and the rows a nested
+   *   `connect` / `disconnect` / `set` is allowed to reach. An out-of-scope row is simply not
+   *   matched — a scoped `delete` reports zero rows rather than refusing.
+   * - It cannot apply to a plain `insert`: there is no existing row to filter. Use
+   *   {@link BuildSchemaConfig.contextValues} to stamp the owning column on the way in.
+   * - `table` is the table the current statement runs against, which for a relational read is
+   *   Drizzle's aliased copy — always build the predicate from that argument.
+   * - Returning `undefined` means "no restriction for this context", so a hook can let an
+   *   admin through. A table with no entry is unscoped.
+   * - MySQL's `ON DUPLICATE KEY UPDATE` takes no predicate, so a MySQL upsert cannot be
+   *   scoped on the conflict path; scope the table's `update` and rely on `contextValues`
+   *   for the insert half.
+   */
+  scope?: ScopeConfig;
+  /**
+   * Columns whose value the server derives from the request context rather than accepting
+   * from the client — the write-side half of {@link BuildSchemaConfig.scope}.
+   *
+   * ```ts
+   * buildSchema(db, {
+   *   contextValues: {
+   *     posts: {
+   *       orgId: (ctx) => ctx.orgId,
+   *       authorId: (ctx) => ctx.userId,
+   *     },
+   *   },
+   * });
+   * ```
+   *
+   * - The column is removed from the generated insert and update inputs, so a client cannot
+   *   send it at all — the schema itself documents that it is server-owned.
+   * - Every insert stamps it, including the rows created by a nested `create`.
+   * - Updates never write it: an update cannot hand a row to another owner.
+   * - Keyed by the Drizzle schema key, then by the column's property name (not its database
+   *   name), the same keying {@link BuildSchemaConfig.exclude} uses.
+   */
+  contextValues?: ContextValuesConfig;
+  /**
+   * Tables that mark rows deleted instead of removing them.
+   *
+   * ```ts
+   * buildSchema(db, {
+   *   softDelete: {
+   *     users: 'deletedAt',                          // nullable timestamp: stamped on delete
+   *     posts: { column: 'isDeleted', deletedValue: true, restoredValue: false },
+   *   },
+   * });
+   *
+   * // or as a convention across the whole schema:
+   * buildSchema(db, { softDelete: (table) => ('deletedAt' in table ? 'deletedAt' : undefined) });
+   * ```
+   *
+   * For a table that declares one:
+   *
+   * - `delete<Table>` and `delete<Table>Single` issue an `UPDATE` of the marker column
+   *   instead of a `DELETE`, and return the rows as they now stand.
+   * - `restore<Table>` and `restore<Table>Single` are generated alongside them, matching only
+   *   marked rows and writing the restored value. The prefix is configurable through
+   *   {@link BuildSchemaConfig.prefixes}.
+   * - Every generated read hides marked rows: list and single queries, aggregates, `groupBy`,
+   *   relation fields on both the eager and the batched path, and relation aggregates. Each
+   *   of those fields takes a `deleted: EXCLUDE | INCLUDE | ONLY` argument (default
+   *   `EXCLUDE`); `ONLY` is a trash view.
+   * - Every generated write skips them too: an `update`, a `delete`, or a nested `connect`
+   *   cannot reach a row that is already marked.
+   * - The marker column is removed from the create and update inputs, so the only ways to set
+   *   or clear it are the delete and restore mutations.
+   * - The predicate is ANDed on before {@link BuildSchemaConfig.scope}, and both are ANDed
+   *   after the client's `where` — a request can only ever narrow them.
+   *
+   * Two consequences of the pattern itself, which this does not paper over:
+   *
+   * - A marked row still occupies its unique keys, so inserting a row that reuses the natural
+   *   key of a deleted one still fails on the constraint.
+   * - An upsert whose conflict target hits a marked row updates nothing on PostgreSQL and
+   *   SQLite (the conflict predicate excludes it) but revives it on MySQL, whose
+   *   `ON DUPLICATE KEY UPDATE` takes no predicate.
+   *
+   * Marking a parent deleted does not mark its children — a cascade is a schema decision.
+   */
+  softDelete?: SoftDeleteConfig;
+  /**
+   * A hook that runs **inside the mutation's transaction**, so its writes commit or roll back
+   * with the mutation itself — the position an audit row, an outbox row, or a denormalized
+   * counter needs, and the one a `graphql-middleware` wrapper cannot occupy.
+   *
+   * ```ts
+   * buildSchema(db, {
+   *   onWrite: {
+   *     posts: async ({ table, operation, rows, tx }) => {
+   *       await tx.insert(auditLog).values(rows.map((row) => ({ table, operation, rowId: row.id })));
+   *     },
+   *   },
+   * });
+   * ```
+   *
+   * A bare function is the **`after`** hook — the position that has rows. `{ before, after }`
+   * names them explicitly; `before` receives the field's args ahead of the statement, for a
+   * check that has to read inside the same snapshot. Registering a bare function (or a
+   * positions object) at the top level applies it to every table; anything else is read as a
+   * table map keyed by Drizzle schema key, and an unknown name fails the build.
+   *
+   * - **`tx` is the executor the mutation ran on** — a caller-supplied executor under
+   *   `drizzleExecutorKey`, the request's auto-transaction, or, for a field that would
+   *   otherwise have run unwrapped, a transaction opened for it because the hook is there.
+   * - **Throwing rolls the mutation back.** That is the point of the position.
+   * - **`rows` are the post-write rows as the database returned them**, before the output
+   *   mapper. Empty at the `before` position, and on MySQL, whose mutations return no rows.
+   * - The hook fires for the **mutation field's own table**. Rows a nested write creates in
+   *   another table do not fire that table's hook.
+   *
+   * Off by default, and a build without it opens exactly the transactions it did before.
+   */
+  onWrite?: OnWriteConfig;
+  /**
+   * Tables and columns to leave out of the generated schema entirely.
+   *
+   * ```ts
+   * buildSchema(db, {
+   *   exclude: {
+   *     tables: ['magicLinks', 'sessions'],
+   *     columns: { apiKeys: ['keyHash'] },
+   *   },
+   * });
+   * ```
+   *
+   * An excluded **table** generates nothing: no object type, no root queries or mutations, no
+   * aggregates, and no relation field on any other table that points at it. Filtering another
+   * table by a relation to it is gone too, so it is unreachable rather than merely unnamed.
+   *
+   * An excluded **column** disappears from every surface at once — the object type, the
+   * create/update/upsert inputs, the filter type, `orderBy`, the aggregate fields, the
+   * `distinct` and `groupBy` enums, and the upsert conflict targets. The exclusion is
+   * deliberately all-or-nothing: a column you can filter on but not select is an oracle, since
+   * `where: { keyHash: { eq: '…' } }` confirms a value without ever returning it.
+   *
+   * Excluding a `NOT NULL` column that has no default makes that table's inserts impossible to
+   * satisfy — `buildSchema` warns on the console when it sees this, and still builds, since a
+   * read-only table is a reasonable thing to want.
+   *
+   * Names that match nothing throw, so a renamed column fails the build instead of quietly
+   * un-hiding itself.
+   */
+  exclude?: SchemaExclusions;
+  /**
+   * Optional mapper from table key to singular/plural name pair.
+   * When provided for a table, overrides the default (table key) naming for GraphQL type names,
+   * query field names, and mutation field names.
+   * Return `undefined` for tables that should use the default naming.
+   *
+   * Example: `(name) => name === 'users' ? { singular: 'user', plural: 'users' } : undefined`
+   * produces type `User`, queries `users` / `user`, mutations `createUsers` / `createUser` for
+   * the `users` table, and leaves other tables with their default names.
+   *
+   * Pass the string `'singularize'` for the built-in preset, which derives both forms of every
+   * table key with the library's own `pluralize` — the mapper most schemas with plural table
+   * keys would otherwise write by hand:
+   *
+   * ```ts
+   * buildSchema(db, { typeNameMapper: 'singularize' });
+   * // tasks -> type Task, queries `tasks` / `task`, mutations `createTasks` / `createTask`
+   * ```
+   *
+   * The same function is exported as `singularizeMapper` for wrapping — e.g. to keep one
+   * table's names as they are: `(t) => (t === 'audit_log' ? undefined : singularizeMapper(t))`.
+   *
+   * The function half is the exported {@link TypeNameMapper}, so a mapper can be declared once
+   * and handed both to `buildSchema` and to `selectionToWith` / `resolveSelection`, which need
+   * the same naming rule to read a selection back out of a schema built with it.
+   */
+  typeNameMapper?: 'singularize' | TypeNameMapper;
+  /**
+   * Renames the types generated *around* a table — the filter, the write inputs, the
+   * order-by, the aggregate family, the group-by types, the conflict input, the shared scalar
+   * filters. `typeNameMapper` names a table's object type and its root fields; those derived
+   * names follow from it by a fixed rule, and this is the hook that overrides the rule.
+   *
+   * Asked once per generated type, with the kind, the name the library would use, and the
+   * table it belongs to where it belongs to one. Return `undefined` — or the same name — to
+   * keep the default, so a mapper that answers for one kind leaves everything else alone:
+   *
+   * ```ts
+   * buildSchema(db, {
+   *   derivedTypeNameMapper: ({ kind, table, operation, defaultName }) =>
+   *     kind === 'aggregate' && operation ? `${table}Aggregate${operation}` : undefined,
+   * });
+   * ```
+   *
+   * A returned name is used verbatim — {@link BuildSchemaConfig.typeNamePrefix} and
+   * {@link BuildSchemaConfig.typeNameSuffix} do not wrap it, since the more specific of the
+   * two knobs wins.
+   *
+   * The point of it is stitching: a schema merged with a second generator over the same
+   * tables collides on the derived names constantly, because both derive them from the model
+   * name by the same obvious rule. Renaming them here means the collision never exists, rather
+   * than being papered over by a `RenameTypes` transform on the way out.
+   */
+  derivedTypeNameMapper?: DerivedTypeNameMapper;
+  /**
+   * Prepended to every generated type name — object types, filters, write inputs, the
+   * aggregate family, the shared scalar filters, everything — that
+   * {@link BuildSchemaConfig.derivedTypeNameMapper} did not answer for. The one-line way to
+   * make a whole subschema collision-free before stitching it:
+   *
+   * ```ts
+   * buildSchema(db, { typeNamePrefix: 'Db' });
+   * // type DbUsers, input DbUsersFilters, input DbStringFilter, enum DbOrderNulls, …
+   * ```
+   *
+   * Custom scalars, database enum types and `PgGeometryObject` keep their own names: their
+   * definition does not vary between builds, so a gateway merges them rather than colliding
+   * on them. Field and argument names are untouched too — only type names move, so a client's
+   * queries are unaffected apart from the names it spells in variable declarations.
+   *
+   * Must be a valid GraphQL name start (`/^[_A-Za-z][_0-9A-Za-z]*$/`); anything else throws.
+   */
+  typeNamePrefix?: string;
+  /**
+   * Appended to every generated type name that {@link BuildSchemaConfig.derivedTypeNameMapper}
+   * did not answer for. The counterpart of {@link BuildSchemaConfig.typeNamePrefix}; both may
+   * be given at once.
+   */
+  typeNameSuffix?: string;
+  /**
+   * Controls whether a relation is eagerly pre-fetched via Drizzle's `with:` clause
+   * when its parent is loaded through a generated query or mutation.
+   *
+   * `true` (default) — every selected relation is eager-loaded in the parent's query.
+   *
+   * `false` — no relation is ever eager-loaded; all relations resolve lazily through
+   * their (request-batched) field resolvers.
+   *
+   * `(tableName, relationName) => boolean` — decide per relation. Return `false` to
+   * exclude that relation from `with:` (and from the mutation eager re-fetch).
+   *
+   * Opting a relation out does NOT remove its field resolver — it still resolves
+   * lazily via the request-scoped batch loader. This is the hook for overriding a
+   * relation's resolver (e.g. via `@graphql-tools/schema`'s `addResolversToSchema`)
+   * without the eager `with:` query also fetching it from the database:
+   *
+   * ```ts
+   * const { schema } = buildSchema(db, {
+   *   eagerLoadRelations: (t, r) => !(t === 'Users' && r === 'posts'),
+   * });
+   * const finalSchema = addResolversToSchema({
+   *   schema,
+   *   resolvers: { Users: { posts: (parent) => myLoader.load(parent.id) } },
+   * });
+   * ```
+   *
+   * Table and relation names are the Drizzle schema keys (e.g. `Users`, `posts`),
+   * matching the keys of `entities.fieldResolvers`.
+   *
+   * @default true
+   */
+  eagerLoadRelations?: boolean | ((tableName: string, relationName: string) => boolean);
+  /**
+   * Declarative per-table, per-column scalar overrides — replaces the GraphQL type built-in
+   * detection would pick for a column with the scalar you provide, everywhere that column's
+   * type surfaces: the object type, create/update inputs, filter operands (in a filter type
+   * named `${Scalar}Filter`), and aggregate min/max fields.
+   *
+   * Keys are the Drizzle schema keys: the table's key in your schema object and the column's
+   * property name. The value is either one scalar for both directions, or `{ output, input }`
+   * to type outputs and inputs differently (either side may be omitted to keep the default).
+   *
+   * ```ts
+   * buildSchema(db, {
+   *   scalars: {
+   *     users: {
+   *       balance: GraphQLBigIntString,                      // both directions
+   *       settings: { output: PrettyJSON },                  // output only, input stays default
+   *     },
+   *   },
+   * });
+   * ```
+   *
+   * Validation and coercion become the scalar's job: for an overridden column the generated
+   * resolvers pass values through untouched — `parseValue`/`parseLiteral` results go to the
+   * database driver as-is, and raw driver values go to `serialize` as-is — so the scalar must
+   * accept what the driver produces and produce what the driver accepts.
+   *
+   * A declarative entry fully decides its column and wins over {@link mapColumnType}.
+   */
+  scalars?: ScalarOverridesConfig;
+  /**
+   * Rule-based scalar mapping, called once per column at build time — the tool for applying
+   * a convention across many columns (e.g. "every `numeric` column is `Money`") or for typing
+   * custom column types the built-in detection does not know.
+   *
+   * Return a scalar (or `{ output, input }` pair) to override the column, or `undefined` to
+   * keep the default. `info` carries the table/column schema keys and the types built-in
+   * detection would use (`defaultType` / `defaultInputType`), so rules can key off either the
+   * Drizzle column or the default GraphQL type.
+   *
+   * ```ts
+   * buildSchema(db, {
+   *   mapColumnType: (column, { columnName }) =>
+   *     column.columnType === 'PgNumeric' ? MoneyScalar : undefined,
+   * });
+   * ```
+   *
+   * Same semantics as {@link scalars} otherwise; a column matched by both is decided by
+   * `scalars` alone.
+   */
+  mapColumnType?: ColumnTypeMapper;
+  /**
+   * Called for every error thrown by a generated resolver, before it reaches the client.
+   *
+   * Return an error to surface that one instead. Return nothing to fall through to the
+   * default handling, which makes this a pure logging hook:
+   *
+   * ```ts
+   * buildSchema(db, { onError: (error) => { logger.error(error) } })
+   * ```
+   *
+   * The default passes through errors drizzle-graphql raises itself (bad filter, missing
+   * values, invalid date, …) and replaces everything else — driver and database errors —
+   * with a generic `Internal server error`, keeping the original on `originalError` so it
+   * is still available to server-side logging. Database messages routinely name tables,
+   * columns, constraints and the values that violated them, which is not something a
+   * public API should hand back.
+   *
+   * To surface raw database errors instead (useful in development):
+   *
+   * ```ts
+   * buildSchema(db, { onError: (error) => error as Error })
+   * ```
+   */
+  onError?: (error: unknown) => unknown;
+  /**
+   * Supplies the GraphQL `description` for a column, everywhere that column becomes a field:
+   * the object type, the create/update inputs, the filter input, and the aggregate
+   * `min`/`max`/`group` fields.
+   *
+   * Nothing is generated by default. The library used to emit the column's own type name
+   * ("DateTime", "JSON") as its description, which documented nothing a reader could not see
+   * from the type — that is gone, and this hook is what puts real prose in its place. Drizzle
+   * carries no column-comment metadata to read, so the text has to come from here.
+   *
+   * ```ts
+   * const columnDocs = { Users: { email: 'Primary contact address. Unique, case-insensitive.' } };
+   *
+   * buildSchema(db, {
+   *   describeColumn: (_column, { tableName, columnName }) => columnDocs[tableName]?.[columnName],
+   * });
+   * ```
+   *
+   * `tableName` and `columnName` are the Drizzle schema keys. Return `undefined` to leave the
+   * field undocumented.
+   */
+  describeColumn?: ColumnDescriber;
+  /**
+   * Supplies the GraphQL `description` for a table's object type.
+   *
+   * ```ts
+   * buildSchema(db, { describeTable: (tableName) => tableDocs[tableName] });
+   * ```
+   */
+  describeTable?: TableDescriber;
+  /**
+   * Supplies the GraphQL `description` for a relation field on a table's object type.
+   *
+   * ```ts
+   * buildSchema(db, {
+   *   describeRelation: (tableName, relationName) =>
+   *     tableName === 'Users' && relationName === 'posts' ? 'Posts this user authored.' : undefined,
+   * });
+   * ```
+   *
+   * The generated `<relation>Aggregate` companion fields are not covered — they are derived
+   * fields rather than the relation itself.
+   */
+  describeRelation?: RelationDescriber;
+  /**
+   * Supplies the GraphQL `deprecationReason` for a column, marking it `@deprecated` on the
+   * object type and on the create/update inputs.
+   *
+   * ```ts
+   * buildSchema(db, {
+   *   deprecateColumn: (_column, { columnName }) =>
+   *     columnName === 'legacyFlag' ? 'Use `status` instead.' : undefined,
+   * });
+   * ```
+   *
+   * A required input field cannot be deprecated — GraphQL rejects the schema, since a client
+   * has no way to stop sending it — so the reason is dropped on non-null input fields and
+   * kept everywhere else. Filter and orderBy fields are never deprecated either: filtering on
+   * a deprecated column is how a caller finds the rows that still use it.
+   */
+  deprecateColumn?: ColumnDeprecator;
+  /**
+   * Names the GraphQL enum types generated for enum columns.
+   *
+   * By default a column declared with a named `pgEnum` gets one shared type named after the
+   * enum (`pgEnum('status', …)` → `StatusEnum`), reused by every column declared with that
+   * same `pgEnum` — the database column is the same type, so a client variable typed
+   * `StatusEnum!` is passable to any of them. A column with an inline value list
+   * (`text({ enum: [...] })`, `mysqlEnum(...)`) keeps a per-column type named for its table
+   * and column (`UsersRoleTextEnum`), because its values are shared with nothing.
+   *
+   * This hook overrides the name either way — for lining the schema up with another schema it
+   * is stitched into, or for opting a specific column back into a type of its own:
+   *
+   * ```ts
+   * buildSchema(db, {
+   *   enumNameMapper: (info) => (info.enumName === 'status' ? 'PublicationStatus' : undefined),
+   * });
+   * ```
+   *
+   * Two columns the mapper sends to the same name share one type when their values match —
+   * the way to unify inline enums declared separately that mean the same thing. Sending two
+   * *different* value lists to one name throws at build time rather than producing an
+   * invalid schema.
+   *
+   * Return `undefined` to keep the default name.
+   */
+  enumNameMapper?: EnumNameMapper;
 };
-
+//#endregion
+//#region src/util/case-ops/index.d.ts
 /**
  * The `typeNameMapper` preset behind `typeNameMapper: 'singularize'`.
  *
@@ -2075,10 +2075,11 @@ type BuildSchemaConfig = {
  * the schema key looks like. The type name is capitalized by the generator either way.
  */
 declare const singularizeMapper: (tableName: string) => {
-    singular: string;
-    plural: string;
+  singular: string;
+  plural: string;
 };
-
+//#endregion
+//#region src/util/scalars/index.d.ts
 /**
  * A 64-bit integer. Always transported as a decimal string, in both directions, so no value
  * is ever silently rounded by JSON's double-precision numbers. `graphql-scalars`' own
@@ -2093,27 +2094,28 @@ declare const GraphQLBigIntString: GraphQLScalarType<string, string>;
  * non-numeric strings (including 'NaN' and 'Infinity').
  */
 declare const GraphQLDecimalString: GraphQLScalarType<string, string>;
-
+//#endregion
+//#region src/util/selection.d.ts
 /** Options shared by {@link selectionToWith} and {@link resolveSelection}. */
 type SelectionOptions = {
-    /** The drizzle instance the schema was built from. */
-    db: AnyDrizzleDB<any>;
-    /** The Drizzle schema key of the table the selection is rooted at. */
-    table: string;
-    /**
-     * The `typeNameMapper` the schema was built with, when one was configured. The translation
-     * matches selections against GraphQL type names, so a build that renames its types has to
-     * pass the same mapper here or nothing will match.
-     */
-    typeNameMapper?: TypeNameMapper;
-    /**
-     * The `derivedTypeNameMapper` / `typeNamePrefix` / `typeNameSuffix` the schema was built
-     * with, when any were configured. Same reason as `typeNameMapper`: the translation matches
-     * selections against the names the build actually published.
-     */
-    derivedTypeNameMapper?: DerivedTypeNameMapper;
-    typeNamePrefix?: string;
-    typeNameSuffix?: string;
+  /** The drizzle instance the schema was built from. */
+  db: AnyDrizzleDB<any>;
+  /** The Drizzle schema key of the table the selection is rooted at. */
+  table: string;
+  /**
+   * The `typeNameMapper` the schema was built with, when one was configured. The translation
+   * matches selections against GraphQL type names, so a build that renames its types has to
+   * pass the same mapper here or nothing will match.
+   */
+  typeNameMapper?: TypeNameMapper;
+  /**
+   * The `derivedTypeNameMapper` / `typeNamePrefix` / `typeNameSuffix` the schema was built
+   * with, when any were configured. Same reason as `typeNameMapper`: the translation matches
+   * selections against the names the build actually published.
+   */
+  derivedTypeNameMapper?: DerivedTypeNameMapper;
+  typeNamePrefix?: string;
+  typeNameSuffix?: string;
 };
 /**
  * Translates a GraphQL selection set into the relational query builder's `with` tree — the
@@ -2139,21 +2141,21 @@ type SelectionOptions = {
 declare const selectionToWith: (info: GraphQLResolveInfo | ResolveTree, options: SelectionOptions) => Record<string, any> | undefined;
 /** Options for {@link resolveSelection} — the selection options plus the read itself. */
 type ResolveSelectionOptions = SelectionOptions & {
-    /**
-     * The transaction (or other drizzle executor) to read on. Defaults to `db`, so an override
-     * that has opened its own transaction passes it here to see its own uncommitted writes.
-     */
-    executor?: any;
-    /** Whether to return one row or a list. A single read ignores `limit`. */
-    single?: boolean;
-    /** The generated `where` argument, in the schema's filter DSL — compiled the same way. */
-    where?: any;
-    /** The generated `orderBy` argument. */
-    orderBy?: any;
-    limit?: number;
-    offset?: number;
-    /** The generated `after` cursor argument, for keyset pagination. */
-    after?: string;
+  /**
+   * The transaction (or other drizzle executor) to read on. Defaults to `db`, so an override
+   * that has opened its own transaction passes it here to see its own uncommitted writes.
+   */
+  executor?: any;
+  /** Whether to return one row or a list. A single read ignores `limit`. */
+  single?: boolean;
+  /** The generated `where` argument, in the schema's filter DSL — compiled the same way. */
+  where?: any;
+  /** The generated `orderBy` argument. */
+  orderBy?: any;
+  limit?: number;
+  offset?: number;
+  /** The generated `after` cursor argument, for keyset pagination. */
+  after?: string;
 };
 /**
  * Runs the read a generated select resolver would have run, against whichever executor is
@@ -2170,7 +2172,9 @@ type ResolveSelectionOptions = SelectionOptions & {
  * because it is the generated schema's own code path.
  */
 declare const resolveSelection: (info: GraphQLResolveInfo | ResolveTree, options: ResolveSelectionOptions) => Promise<any>;
-
+//#endregion
+//#region src/index.d.ts
 declare const buildSchema: <TDbClient extends AnyDrizzleDB<any>>(db: TDbClient, config?: BuildSchemaConfig) => GeneratedData<TDbClient>;
-
-export { type AggregateResolver, type AnyDrizzleDB, type BuildSchemaConfig, type ColumnDeprecator, type ColumnDescriber, type ColumnDocInfo, type ColumnTypeMapper, type ColumnTypeMapperInfo, type ComplexityConfig, type ContextValuesConfig, type DefaultOrderByEntry, type DefaultsConfig, type DeleteResolver, type DeleteSingleResolver, type DerivedTypeNameMapper, type DrizzleErrorCode, type DrizzleErrorContext, type DrizzleExtension, type DrizzleFieldExtension, type DrizzleFieldKind, type DrizzleFieldOperation, type DrizzleTargetArg, type DrizzleTypeExtension, type EnumNameInfo, type EnumNameMapper, type ExtractRelations, type ExtractTableByName, type ExtractTableRelations, type ExtractTables, type FeatureSwitch, type GeneratedData, type GeneratedEntities, type GeneratedInputs, type GeneratedOutputs, type GeneratedTypeInfo, type GeneratedTypeKind, GraphQLBigIntString, GraphQLDecimalString, type IdentifiedRows, type InsertArrResolver, type InsertResolver, type LimitsConfig, type MutationReturnlessResult, type MutationsCore, type OnWriteConfig, type QueriesCore, type RelationDescriber, type RelationResolverFactory, type ResolveSelectionOptions, type RowScope, type RowScopeFilter, type ScalarOverride, type ScalarOverridesConfig, type SchemaDocs, type SchemaExclusions, type SchemaFeatures, type ScopeConfig, type SelectResolver, type SelectSingleResolver, type SelectionOptions, type SoftDeleteColumn, type SoftDeleteConfig, type TableDefaults, type TableDescriber, type TableLimitPolicy, type TableNamedRelations, type TypeNameMapper, type UpdateManyArgs, type UpdateManyEntry, type UpdateManyResolver, type UpdateResolver, type UpdateSingleResolver, type UpsertArgs, type UpsertArrResolver, type UpsertConflictArgs, type UpsertResolver, type WriteHook, type WriteHookPayload, type WriteHookPositions, type WriteHooks, type WriteOperation, buildSchema, createRelationResolverFactory, defaultErrorMapper, drizzleError, drizzleExecutorKey, drizzleExtension, extractFilters, extractOrderBy, extractRelationJoinColumns, identifyRows, isDrizzleFieldExtension, resolveSelection, selectionToWith, singularizeMapper };
+//#endregion
+export { type AggregateResolver, type AnyDrizzleDB, type BuildSchemaConfig, type ColumnDeprecator, type ColumnDescriber, type ColumnDocInfo, type ColumnTypeMapper, type ColumnTypeMapperInfo, type ComplexityConfig, type ContextValuesConfig, type DefaultOrderByEntry, type DefaultsConfig, type DeleteResolver, type DeleteSingleResolver, type DerivedTypeNameMapper, type DrizzleErrorCode, type DrizzleErrorContext, type DrizzleExtension, type DrizzleFieldExtension, type DrizzleFieldKind, type DrizzleFieldOperation, type DrizzleTargetArg, type DrizzleTypeExtension, type EnumNameInfo, type EnumNameMapper, type ExtractRelations, type ExtractTableByName, type ExtractTableRelations, type ExtractTables, type FeatureSwitch, type FieldsByTypeName, type GeneratedData, type GeneratedEntities, type GeneratedInputs, type GeneratedOutputs, type GeneratedTypeInfo, type GeneratedTypeKind, GraphQLBigIntString, GraphQLDate, GraphQLDateTime, GraphQLDecimalString, GraphQLJSON, GraphQLUUID, type IdentifiedRows, type InsertArrResolver, type InsertResolver, type LimitsConfig, type MutationReturnlessResult, type MutationsCore, type OnWriteConfig, type ParseResolveInfoOptions, type QueriesCore, type RelationDescriber, type RelationResolverFactory, type ResolveSelectionOptions, type ResolveTree, type RowScope, type RowScopeFilter, type ScalarOverride, type ScalarOverridesConfig, type SchemaDocs, type SchemaExclusions, type SchemaFeatures, type ScopeConfig, type SelectResolver, type SelectSingleResolver, type SelectionOptions, type SoftDeleteColumn, type SoftDeleteConfig, type TableDefaults, type TableDescriber, type TableLimitPolicy, type TableNamedRelations, type TypeNameMapper, type UpdateManyArgs, type UpdateManyEntry, type UpdateManyResolver, type UpdateResolver, type UpdateSingleResolver, type UpsertArgs, type UpsertArrResolver, type UpsertConflictArgs, type UpsertResolver, type WriteHook, type WriteHookPayload, type WriteHookPositions, type WriteHooks, type WriteOperation, buildSchema, createRelationResolverFactory, defaultErrorMapper, drizzleError, drizzleExecutorKey, drizzleExtension, extractFilters, extractOrderBy, extractRelationJoinColumns, identifyRows, isDrizzleFieldExtension, parseResolveInfo, resolveSelection, selectionToWith, singularizeMapper };
+//# sourceMappingURL=index.d.cts.map