@vantreeseba/drizzle-graphql 12.0.1 → 13.1.0

package/dist/index.d.cts

@@ -7,6 +7,291 @@ 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/type-naming.d.ts
+/** A word the rules decline to decide. Widens the keys derived from it rather than guessing. */
+type Unresolved = string;
+type Letter = 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z';
+type Vowel = 'a' | 'e' | 'i' | 'o' | 'u';
+/** `pluralize`'s `[^aou]` class, from the `[^aou]us` stem both directions share. */
+type NotAOU = Exclude<Letter, 'a' | 'o' | 'u'>;
+/** True when `S` ends with any member of the union `Suffix`. */
+type EndsWith<S extends string, Suffix extends string> = Lowercase<S> extends `${string}${Suffix}` ? true : false;
+/**
+ * `pluralize`'s uncountable list: these are their own singular *and* plural. Trimmed to the
+ * entries that could plausibly name a table; the corpus test pins the ones that are here.
+ */
+type Uncountable = 'advice' | 'agenda' | 'aid' | 'aircraft' | 'alcohol' | 'ammo' | 'analytics' | 'anime' | 'athletics' | 'audio' | 'blood' | 'cash' | 'chassis' | 'chess' | 'clothing' | 'commerce' | 'cooperation' | 'corps' | 'debris' | 'digestion' | 'energy' | 'equipment' | 'expertise' | 'firmware' | 'fun' | 'garbage' | 'graffiti' | 'hardware' | 'headquarters' | 'health' | 'homework' | 'housework' | 'information' | 'jeans' | 'justice' | 'kudos' | 'labour' | 'literature' | 'machinery' | 'mail' | 'manga' | 'media' | 'mews' | 'music' | 'mud' | 'news' | 'personnel' | 'plankton' | 'pliers' | 'police' | 'pollution' | 'premises' | 'rain' | 'research' | 'rice' | 'scissors' | 'series' | 'sewage' | 'shambles' | 'software' | 'species' | 'staff' | 'tennis' | 'traffic' | 'transportation' | 'wealth' | 'welfare' | 'wildlife';
+/** The same list's regex members, as the endings they stand for. */
+type UncountableEnding = 'fish' | 'deer' | 'sheep' | 'pox' | 'measles' | 'pokemon' | 'pokémon' | `${Exclude<Letter, Vowel>}ese` | `o${'i' | 'u'}s`;
+/**
+ * `pluralize`'s irregular pairs, minus the pronouns, plus the handful of words whose rule is
+ * `\b`-anchored and so behaves as a whole word: `mice`/`lice` from `\b((?:tit)?m|l)ice$`,
+ * `people` and `children` from their own rules, and `lives` from the guarded `li` in the
+ * `-ves` rule that leaves `olives` alone.
+ */
+type IrregularPlurals = {
+  anathema: 'anathemata';
+  axe: 'axes';
+  carve: 'carves';
+  child: 'children';
+  die: 'dice';
+  dingo: 'dingoes';
+  dogma: 'dogmata';
+  eave: 'eaves';
+  echo: 'echoes';
+  foot: 'feet';
+  genus: 'genera';
+  goose: 'geese';
+  groove: 'grooves';
+  human: 'humans';
+  lemma: 'lemmata';
+  life: 'lives';
+  louse: 'lice';
+  man: 'men';
+  mouse: 'mice';
+  ox: 'oxen';
+  passerby: 'passersby';
+  person: 'people';
+  pickaxe: 'pickaxes';
+  proof: 'proofs';
+  quiz: 'quizzes';
+  schema: 'schemata';
+  stigma: 'stigmata';
+  stoma: 'stomata';
+  thief: 'thieves';
+  titmouse: 'titmice';
+  tooth: 'teeth';
+  tornado: 'tornadoes';
+  torpedo: 'torpedoes';
+  valve: 'valves';
+  viscus: 'viscera';
+  volcano: 'volcanoes';
+  yes: 'yeses';
+};
+type IrregularSingulars = {
+  anathemata: 'anathema';
+  axes: 'axe';
+  carves: 'carve';
+  children: 'child';
+  dice: 'die';
+  dingoes: 'dingo';
+  dogmata: 'dogma';
+  eaves: 'eave';
+  echoes: 'echo';
+  feet: 'foot';
+  geese: 'goose';
+  genera: 'genus';
+  grooves: 'groove';
+  humans: 'human';
+  lemmata: 'lemma';
+  lice: 'louse';
+  lives: 'life';
+  men: 'man';
+  mice: 'mouse';
+  oxen: 'ox';
+  passersby: 'passerby';
+  people: 'person';
+  pickaxes: 'pickaxe';
+  proofs: 'proof';
+  quizzes: 'quiz';
+  schemata: 'schema';
+  stigmata: 'stigma';
+  stomata: 'stoma';
+  teeth: 'tooth';
+  thieves: 'thief';
+  titmice: 'titmouse';
+  tornadoes: 'tornado';
+  torpedoes: 'torpedo';
+  valves: 'valve';
+  viscera: 'viscus';
+  volcanoes: 'volcano';
+  yeses: 'yes';
+};
+/**
+ * The stems that keep their `ie` instead of collapsing to `y`. `pluralize` anchors this rule
+ * at a word boundary, so these are whole stems and not endings: `ties` gives `tie` and
+ * `cuties` gives `cutie`, but `oldies` gives `oldy` and `cookies` gives `cooky`. Guessing
+ * from the ending is precisely what does not work here, hence the list.
+ */
+type IeWholeStem = 'l' | 't' | 'neckt' | 'crosst' | 'coll' | 'faer' | 'food' | 'gen' | 'goon' | 'group' | 'lass' | 'talk' | 'goal' | 'p' | 'cut' | 'zomb';
+/** `\b(mon|smil)ies$` — the two stems that take `ey` rather than `y` or `ie`. */
+type EyWholeStem = 'mon' | 'smil';
+/** `(movie|twelve|abuse|e[mn]u)s$` — words that just drop the `s`, ahead of the `ies` rule. */
+type PlainSStem = 'movie' | 'twelve' | 'abuse' | `e${'m' | 'n'}u`;
+/**
+ * Stems the big `(x|ch|ss|sh|zz|…)(?:es)?$` rule strips `es` from — the ones expressible as a
+ * plain ending. Its character-class members are {@link EsClassStem}, since a union of endings
+ * cannot say "any letter but these".
+ */
+type EsStem = 'x' | 'ch' | 'ss' | 'sh' | 'zz' | 'tto' | 'go' | 'cho' | 'alias' | 'gas' | 'hero' | 'ato' | 'gro';
+/** The same rule's character classes, expanded into the unions they stand for. */
+type EsClassStem = `${NotAOU}us` | `t${'l' | 'm'}as` | `${Vowel}ris`;
+/**
+ * `(agend|addend|…|quor)(?:a|um)$` and `(apheli|…|automat)(?:a|on)$`. Both directions read
+ * these as endings rather than whole words, so `metadata` gives `metadatum`.
+ */
+type AToUmStem = 'agend' | 'addend' | 'millenni' | 'dat' | 'extrem' | 'bacteri' | 'desiderat' | 'strat' | 'candelabr' | 'errat' | 'ov' | 'symposi' | 'curricul' | 'quor';
+type AToOnStem = 'apheli' | 'hyperbat' | 'periheli' | 'asyndet' | 'noumen' | 'phenomen' | 'criteri' | 'organ' | 'prolegomen' | 'hedr' | 'automat';
+/** `(ax|test)is$` -> `es`. */
+type AxisStem = 'ax' | 'test';
+/** `(analy|diagno|…)(?:sis|ses)$` — the `-sis` family, which keeps its `sis`. */
+type SisStem = 'analy' | 'diagno' | 'parenthe' | 'progno' | 'synop' | 'the' | 'empha' | 'cri' | 'ne';
+/**
+ * `-ves` plurals that restore an `f` or `fe`. These are endings, not whole words, so
+ * `bookshelves` gives `bookshelf` and `housewives` gives `housewife` — but `archives`,
+ * `olives` and `sieves` match none of them and fall through to the plain `s` drop, which is
+ * the whole point of listing the stems rather than keying off `ves`.
+ */
+type VesToFStem = 'ar' | 'wol' | 'al' | 'el' | 'ea' | 'eo' | 'oa' | 'oo';
+type VesToFeStem = 'wi' | 'kni';
+/** The same rule's `\b`-anchored `li`, which is why `lives` is `life` but `olives` is `olive`. */
+type LiWholeStem = 'li' | `${'after' | 'half' | 'high' | 'low' | 'mid' | 'night' | 'non'}li`;
+/** `(cod|mur|sil|vert|ind)ices$` -> `ex` and `(matr|append)ices$` -> `ix`. */
+type IcesToExStem = 'cod' | 'mur' | 'sil' | 'vert' | 'ind';
+type IcesToIxStem = 'matr' | 'append';
+/** Latin plurals whose singular no ending-based rule recovers. */
+type LatinSingulars = {
+  addenda: 'addendum';
+  algae: 'alga';
+  alumnae: 'alumna';
+  alumni: 'alumnus';
+  bacteria: 'bacterium';
+  cacti: 'cactus';
+  candelabra: 'candelabrum';
+  cherubim: 'cherub';
+  criteria: 'criterion';
+  curricula: 'curriculum';
+  data: 'datum';
+  errata: 'erratum';
+  foci: 'focus';
+  fungi: 'fungus';
+  millennia: 'millennium';
+  nuclei: 'nucleus';
+  ova: 'ovum';
+  phenomena: 'phenomenon';
+  radii: 'radius';
+  seraphim: 'seraph';
+  strata: 'stratum';
+  syllabi: 'syllabus';
+  symposia: 'symposium';
+  termini: 'terminus';
+  testes: 'testis';
+  vertebrae: 'vertebra';
+};
+/**
+ * Endings the rules above leave undecided and the plain `s` drop would get wrong — Latin
+ * stems and the `-is` family, mostly. A word ending in one of these that matched nothing
+ * earlier is left unresolved rather than guessed at.
+ */
+type UndecidedSingularEnding = 'a' | 'i' | 'ae' | 'im' | 'ice' | 'ren' | 'eaux' | 'is';
+/**
+ * The singular of a table key, as `pluralize.singular` would return it — or `string` where
+ * these rules decline to decide. Matching is case-insensitive, and the word's interior case
+ * survives (`auditLogs` -> `auditLog`); a whole-word match comes back lower case, which is
+ * immaterial since every caller re-cases the first letter anyway.
+ */
+type Singularize<S extends string> = Lowercase<S> extends Uncountable ? Lowercase<S> : EndsWith<S, UncountableEnding> extends true ? S : Lowercase<S> extends keyof IrregularPlurals ? Lowercase<S> : Lowercase<S> extends keyof IrregularSingulars ? IrregularSingulars[Lowercase<S>] : Lowercase<S> extends keyof LatinSingulars ? LatinSingulars[Lowercase<S>] : S extends `${infer A}men` ? `${A}man` : S extends `${infer A}s` ? SingularizeS<S, A> : S extends `${infer A}a` ? SingularizeA<A> : EndsWith<S, EsStem | EsClassStem> extends true ? S : EndsWith<S, UndecidedSingularEnding> extends true ? Unresolved : S;
+/** The `…s` forks, in `pluralize`'s priority order, each testing a stem it has already split. */
+type SingularizeS<S extends string, A extends string> = EndsWith<A, PlainSStem> extends true ? A : S extends `${infer B}ies` ? SingularizeIes<S, B> : EndsWith<S, 'ss'> extends true ? S : S extends `${infer B}ses` ? SingularizeSes<S, B> : S extends `${infer B}ves` ? SingularizeVes<B> : S extends `${infer B}ices` ? SingularizeIces<B> : S extends `${infer B}es` ? SingularizeEs<S, B> : S extends `${infer B}sis` ? SingularizeSis<S, B> : EndsWith<S, EsStem | EsClassStem> extends true ? S : EndsWith<S, UndecidedSingularEnding> extends true ? Unresolved : A;
+/** `(analy|…)sis$` is already singular; any other `-sis` word the rules leave alone. */
+type SingularizeSis<S extends string, A extends string> = EndsWith<A, SisStem> extends true ? S : Unresolved;
+/** `(agend|…)a$` -> `um` and `(apheli|…)a$` -> `on`, both read as endings. */
+type SingularizeA<A extends string> = EndsWith<A, AToOnStem> extends true ? `${A}on` : EndsWith<A, AToUmStem> extends true ? `${A}um` : Unresolved;
+/** `…ies` -> `y`, `ie` or `ey`, following `pluralize`'s three competing `ies` rules. */
+type SingularizeIes<S extends string, A extends string> = Lowercase<A> extends EyWholeStem ? `${A}ey` : Lowercase<A> extends IeWholeStem ? `${A}ie` : EndsWith<S, 'ss'> extends true ? S : `${A}y`;
+/**
+ * The `…ses` fork. `(analy|…)(?:sis|ses)$` restores that family's `sis`; anything else ending
+ * in `ses` is an ordinary `es` plural (`houses`, `roses`, `statuses`) and is handed on.
+ */
+type SingularizeSes<S extends string, A extends string> = EndsWith<A, SisStem> extends true ? `${A}sis` : S extends `${infer B}es` ? SingularizeEs<S, B> : Unresolved;
+/** The `…ves` fork: `f`/`fe` for the listed stems, an ordinary `e` for everything else. */
+type SingularizeVes<A extends string> = Lowercase<A> extends LiWholeStem ? `${A}fe` : EndsWith<A, VesToFeStem> extends true ? `${A}fe` : EndsWith<A, VesToFStem> extends true ? `${A}f` : `${A}ve`;
+/** The `…ices` fork: `ex`, `ix`, or — for `invoices` and its like — an ordinary `e`. */
+type SingularizeIces<A extends string> = EndsWith<A, IcesToExStem> extends true ? `${A}ex` : EndsWith<A, IcesToIxStem> extends true ? `${A}ix` : `${A}ice`;
+/** The `…es` fork: strip `es` for the stems that call for it, else drop the trailing `s`. */
+type SingularizeEs<S extends string, A extends string> = EndsWith<A, EsStem | EsClassStem> extends true ? A : EndsWith<S, UndecidedSingularEnding> extends true ? Unresolved : `${A}e`;
+/** `([^aeiouy]|qu)y$` -> `ies`. A vowel before the `y` keeps it: `days`, not `daies`. */
+type ConsonantBeforeY = Exclude<Letter, Vowel | 'y'>;
+/** `(x|ch|ss|sh|zz)$` and `(alias|t[lm]as|gas|ris)$`, both -> `es`. */
+type PluralEsStem = 'x' | 'ch' | 'ss' | 'sh' | 'zz' | 'alias' | 'gas' | 'ris' | `t${'l' | 'm'}as`;
+/** `(her|at|gr)o$` -> `oes`. */
+type OesStem = 'hero' | 'ato' | 'gro';
+/** `(matr|cod|mur|sil|vert|ind|append)(?:ix|ex)$` -> `ices`. */
+type IcesStem = 'matr' | 'cod' | 'mur' | 'sil' | 'vert' | 'ind' | 'append';
+/** `(?:(kni|wi|li)fe|(ar|l|ea|eo|oa|hoo)f)$` -> `ves`. */
+type FToVesStem = 'ar' | 'l' | 'ea' | 'eo' | 'oa' | 'hoo';
+type FeToVesStem = 'kni' | 'wi' | 'li';
+/** `(apheli|…|criteri|organ|…|automat)(?:a|on)$` -> `a`. */
+type OnToAStem = 'apheli' | 'hyperbat' | 'periheli' | 'asyndet' | 'noumen' | 'phenomen' | 'criteri' | 'organ' | 'prolegomen' | 'hedr' | 'automat';
+/** `(alumn|syllab|vir|…|strat)(?:us|i)$` -> `i`, which outranks the `[^aou]us` -> `es` rule. */
+type UsToIStem = 'alumn' | 'syllab' | 'vir' | 'radi' | 'nucle' | 'fung' | 'cact' | 'stimul' | 'termin' | 'bacill' | 'foc' | 'uter' | 'loc' | 'strat';
+/** `(seraph|cherub)(?:im)?$` -> `im`. */
+type ImStem = 'seraph' | 'cherub';
+/**
+ * Endings `pluralize` handles with rules these types do not reproduce: the Latin `-a`/`-um`
+ * and `-ae` stems, the `([^l]ias|[aeiou]las|[ejzr]as|[iu]am)$` rule that leaves `atlas`
+ * alone, `(ax|test)is$`, and `eaux$`. Left unresolved, not guessed.
+ */
+type UndecidedPluralEnding = 'ae' | 'i' | 'ias' | 'las' | `${'i' | 'u'}am` | 'eaux';
+/**
+ * The plural of a table key, as `pluralize.plural` would return it — or `string` where these
+ * rules decline to decide. A key that is already plural comes back unchanged, because
+ * `pluralize`'s base rule is `s?$` -> `s` rather than a bare append.
+ */
+type Pluralize<S extends string> = Lowercase<S> extends Uncountable ? Lowercase<S> : EndsWith<S, UncountableEnding> extends true ? S : Lowercase<S> extends keyof IrregularPlurals ? IrregularPlurals[Lowercase<S>] : Lowercase<S> extends keyof IrregularSingulars ? Lowercase<S> : Lowercase<S> extends keyof LatinSingulars ? Lowercase<S> : S extends `${infer A}m${'a' | 'e'}n` ? `${A}men` : S extends `${infer A}${'ix' | 'ex'}` ? PluralizeIxEx<S, A> : S extends `${infer A}${'i' | 'e' | 'o'}${'l' | 'n'}ey` ? PluralizeEy<S, A> : S extends `${infer A}${ConsonantBeforeY}y` ? PluralizeY<S, A> : S extends `${infer A}fe` ? PluralizeFe<S, A> : S extends `${infer A}f` ? PluralizeF<S, A> : S extends `${infer A}sis` ? `${A}ses` : S extends `${infer A}on` ? PluralizeOn<S, A> : S extends `${infer A}um` ? PluralizeUm<A> : S extends `${infer A}a` ? PluralizeA<A> : S extends `${infer A}is` ? PluralizeIs<A> : S extends `${infer A}us` ? PluralizeUs<S, A> : EndsWith<S, ImStem> extends true ? `${S}im` : EndsWith<S, UndecidedPluralEnding> extends true ? Unresolved : EndsWith<S, OesStem> extends true ? `${S}es` : EndsWith<S, PluralEsStem> extends true ? `${S}es` : S extends `${infer A}s` ? `${A}s` : `${S}s`;
+/** Re-attaches the consonant the ending split off, so `category` -> `categories`. */
+type PluralizeY<S extends string, A extends string> = S extends `${A}${infer C}y` ? `${A}${C}ies` : Unresolved;
+/** `([^ch][ieo][ln])ey$` -> `ies`; any other `-ey` word falls through to the `y` rules. */
+type PluralizeEy<S extends string, A extends string> = EndsWith<A, Exclude<Letter, 'c' | 'h'>> extends true ? S extends `${A}${infer Mid}ey` ? `${A}${Mid}ies` : Unresolved : `${S}s`;
+/** `(kni|wi|li)fe$` -> `ves`; any other `-fe` word just takes an `s`. */
+type PluralizeFe<S extends string, A extends string> = EndsWith<A, FeToVesStem> extends true ? `${A}ves` : `${S}s`;
+/** `(ar|l|ea|eo|oa|hoo)f$` -> `ves`; `belief`, `roof` and `chef` take an `s`. */
+type PluralizeF<S extends string, A extends string> = EndsWith<A, FToVesStem> extends true ? `${A}ves` : `${S}s`;
+/** `(matr|cod|…|append)(?:ix|ex)$` -> `ices`; `prefix` and `apex` fall to the `x` -> `es` rule. */
+type PluralizeIxEx<S extends string, A extends string> = EndsWith<A, IcesStem> extends true ? `${A}ices` : `${S}es`;
+/** `(agend|…)um$` -> `a`; `album` and `aquarium` take an `s`. */
+type PluralizeUm<A extends string> = EndsWith<A, AToUmStem> extends true ? `${A}a` : `${A}ums`;
+/** A word already in its Latin `-a` plural stays put; `area` and `villa` take an `s`. */
+type PluralizeA<A extends string> = EndsWith<A, AToUmStem | AToOnStem> extends true ? `${A}a` : `${A}as`;
+/** `(ax|test)is$` -> `es`; every other `-is` word is left undecided. */
+type PluralizeIs<A extends string> = EndsWith<A, AxisStem> extends true ? `${A}es` : Unresolved;
+/** `(criteri|phenomen|…)on$` -> `a`; `session` and `icon` take an `s`. */
+type PluralizeOn<S extends string, A extends string> = EndsWith<A, OnToAStem> extends true ? `${A}a` : `${S}s`;
+/**
+ * The two `-us` rules, in priority order: the Latin stems take `i` (`focus` -> `foci`), and
+ * `[^aou]us` takes `es` (`bus` -> `buses`, `status` -> `statuses`). A `-us` word that is
+ * neither — one with `a`, `o` or `u` before the `us` — just takes an `s`.
+ */
+type PluralizeUs<S extends string, A extends string> = EndsWith<A, UsToIStem> extends true ? `${A}i` : EndsWith<S, `${NotAOU}us`> extends true ? `${S}es` : `${S}s`;
+/**
+ * How a build's `typeNameMapper` decides the keys of the generated entity maps.
+ *
+ * - `false` — no mapper. Every noun is the table key itself and the one-row operations keep
+ *   their `Single` suffix, which is exactly what these types described before singularization
+ *   existed.
+ * - `'singularize'` — the built-in preset, whose two nouns {@link Singularize} and
+ *   {@link Pluralize} replicate. The one-row operations take the singular noun and no suffix.
+ * - `'loose'` — a mapper function, whose output no type can know. Every noun widens to
+ *   `string`, so the entity maps fall back to an index signature rather than naming fields the
+ *   build does not publish.
+ */
+type TypeNaming = 'singularize' | 'loose' | false;
+/** The naming modes whose nouns a type can actually name. */
+type KnownNaming = Exclude<TypeNaming, 'loose'>;
+/** The noun the plural (set-of-rows) operations are named from. */
+type PluralNoun<TNaming extends KnownNaming, TName extends string> = TNaming extends 'singularize' ? Pluralize<TName> : TName;
+/** The noun the singular (one-row) operations and the object type are named from. */
+type SingularNoun<TNaming extends KnownNaming, TName extends string> = TNaming extends 'singularize' ? Singularize<TName> : TName;
+/** The plural noun as a root field name starts — `users` in `usersAggregate`. */
+type LowerPlural<TNaming extends TypeNaming, TName extends string> = TNaming extends 'loose' ? string : Uncapitalize<PluralNoun<Extract<TNaming, KnownNaming>, TName>>;
+/** The plural noun as a field name continues — `Users` in `createUsers`. */
+type UpperPlural<TNaming extends TypeNaming, TName extends string> = TNaming extends 'loose' ? string : Capitalize<PluralNoun<Extract<TNaming, KnownNaming>, TName>>;
+/** The singular noun as a root field name starts — `user` in `user(where:)`. */
+type LowerSingular<TNaming extends TypeNaming, TName extends string> = TNaming extends 'loose' ? string : Uncapitalize<SingularNoun<Extract<TNaming, KnownNaming>, TName>>;
+/** The singular noun as a type or field name continues — `User` in `UserFilters`. */
+type UpperSingular<TNaming extends TypeNaming, TName extends string> = TNaming extends 'loose' ? string : Capitalize<SingularNoun<Extract<TNaming, KnownNaming>, TName>>;
+type SingleSuffix<TNaming extends TypeNaming> = TNaming extends 'singularize' ? '' : TNaming extends 'loose' ? string : 'Single';
+//#endregion
 //#region src/util/extensions.d.ts
 /**
  * The identity a generated field publishes about itself, under `extensions.drizzle`.
@@ -281,6 +566,23 @@ type EnumNameInfo = {
  * `BuildSchemaConfig.enumNameMapper`.
  */
 type EnumNameMapper = (info: EnumNameInfo) => string | undefined;
+/**
+ * Everything an {@link EnumValueNameMapper} needs to name one value of a generated enum: the
+ * value itself, plus the same context an {@link EnumNameMapper} gets for the enum around it.
+ */
+type EnumValueNameInfo = EnumNameInfo & {
+  /** The stored value being named. It stays the GraphQL value's internal `value` either way. */
+  value: string;
+  /** The value's position in {@link EnumNameInfo.values}. */
+  index: number;
+  /** The GraphQL type name the enum was given — after `enumNameMapper`, if there is one. */
+  typeName: string;
+};
+/**
+ * Names one value of a generated GraphQL enum. Return `undefined` to keep the default name.
+ * See `BuildSchemaConfig.enumValueNameMapper`.
+ */
+type EnumValueNameMapper = (info: EnumValueNameInfo) => 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. */
@@ -517,6 +819,10 @@ type WriteHookPayload = {
    * 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.
+   *
+   * Each row holds the columns the client's selection asked for (plus any key a relation or
+   * nested write needed), **and** every column the hook names in `columns`. A column the
+   * client did not select and the hook did not name is absent.
    */
   rows: any[];
   context: any;
@@ -528,12 +834,26 @@ type WriteHook = (payload: WriteHookPayload) => void | Promise<void>;
 type WriteHookPositions = {
   before?: WriteHook;
   after?: WriteHook;
+  /**
+   * Columns the `after` hook's `rows` always carry, whatever the client selected: a list of
+   * column keys (the table object's property names, as `rows` is keyed), or `'all'` for
+   * every column of the table. They are added to the statement's `RETURNING` and taken back
+   * off before the result is mapped, so the client's response is unchanged.
+   *
+   * An unknown column fails the build, and so does `columns` without an `after` hook. On a
+   * top-level (every-table) registration a named column must exist on every table.
+   */
+  columns?: readonly string[] | 'all';
 };
 type WriteHooks = WriteHook | WriteHookPositions;
-/** Resolved, per-field hooks: `undefined` when the table registered none. */
+/**
+ * Resolved, per-field hooks: `undefined` when the table registered none. `columns` is the
+ * hook's `columns` resolved against the table, or `undefined` when it named none.
+ */
 type ResolvedWriteHooks = {
   before?: WriteHook;
   after?: WriteHook;
+  columns?: Record<string, Column>;
 };
 /** Build-time lookup of a table's hooks, installed on {@link TablePolicies}. */
 type WriteHookFor = (tableName: string, operation: WriteOperation) => ResolvedWriteHooks | undefined;
@@ -765,6 +1085,8 @@ 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.
  */
+/** The Drizzle schema a database handle carries. */
+type SchemaOf<TDatabase> = TDatabase extends AnyDrizzleDB<infer ISchema> ? ISchema : 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; };
@@ -866,8 +1188,8 @@ 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>]>>>;
+type QueriesCore<TSchemaTables extends Record<string, Table>, TSchemaRelations extends Record<string, Relations>, TInputs extends Record<string, GraphQLInputObjectType>, TOutputs extends Record<string, GraphQLObjectType>, TNaming extends TypeNaming = false> = { [TName in keyof TSchemaTables as TName extends string ? `${LowerPlural<TNaming, TName>}` : never]: TName extends string ? {
+  type: GraphQLNonNull<GraphQLList<GraphQLNonNull<TOutputs[UpperSingular<TNaming, TName>]>>>;
   args: {
     offset: {
       type: GraphQLScalarType<number, number>;
@@ -876,120 +1198,120 @@ type QueriesCore<TSchemaTables extends Record<string, Table>, TSchemaRelations e
       type: GraphQLScalarType<number, number>;
     };
     orderBy: {
-      type: TInputs[`${Capitalize<TName>}OrderBy`] extends GraphQLInputObjectType ? TInputs[`${Capitalize<TName>}OrderBy`] : never;
+      type: TInputs[`${UpperSingular<TNaming, TName>}OrderBy`] extends GraphQLInputObjectType ? TInputs[`${UpperSingular<TNaming, TName>}OrderBy`] : never;
     };
     where: {
-      type: TInputs[`${Capitalize<TName>}Filters`] extends GraphQLInputObjectType ? TInputs[`${Capitalize<TName>}Filters`] : never;
+      type: TInputs[`${UpperSingular<TNaming, TName>}Filters`] extends GraphQLInputObjectType ? TInputs[`${UpperSingular<TNaming, 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>];
+} : never; } & { [TName in keyof TSchemaTables as TName extends string ? `${LowerSingular<TNaming, TName>}${SingleSuffix<TNaming>}` : never]: TName extends string ? {
+  type: TOutputs[UpperSingular<TNaming, TName>];
   args: {
     offset: {
       type: GraphQLScalarType<number, number>;
     };
     orderBy: {
-      type: TInputs[`${Capitalize<TName>}OrderBy`] extends GraphQLInputObjectType ? TInputs[`${Capitalize<TName>}OrderBy`] : never;
+      type: TInputs[`${UpperSingular<TNaming, TName>}OrderBy`] extends GraphQLInputObjectType ? TInputs[`${UpperSingular<TNaming, TName>}OrderBy`] : never;
     };
     where: {
-      type: TInputs[`${Capitalize<TName>}Filters`] extends GraphQLInputObjectType ? TInputs[`${Capitalize<TName>}Filters`] : never;
+      type: TInputs[`${UpperSingular<TNaming, TName>}Filters`] extends GraphQLInputObjectType ? TInputs[`${UpperSingular<TNaming, 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>;
+} : never; } & { [TName in keyof TSchemaTables as TName extends string ? `${LowerPlural<TNaming, TName>}Aggregate` : never]: TName extends string ? {
+  type: GraphQLNonNull<TOutputs[`${UpperSingular<TNaming, TName>}Aggregate`] extends GraphQLObjectType ? TOutputs[`${UpperSingular<TNaming, TName>}Aggregate`] : GraphQLObjectType>;
   args: {
     where: {
-      type: TInputs[`${Capitalize<TName>}Filters`] extends GraphQLInputObjectType ? TInputs[`${Capitalize<TName>}Filters`] : never;
+      type: TInputs[`${UpperSingular<TNaming, TName>}Filters`] extends GraphQLInputObjectType ? TInputs[`${UpperSingular<TNaming, 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>]>>>;
+type MutationsCore<TSchemaTables extends Record<string, Table>, TInputs extends Record<string, GraphQLInputObjectType>, TOutputs extends Record<string, GraphQLObjectType>, IsReturnless extends boolean, TNaming extends TypeNaming = false> = { [TName in keyof TSchemaTables as TName extends string ? `create${UpperPlural<TNaming, TName>}` : never]: TName extends string ? {
+  type: IsReturnless extends true ? TOutputs['MutationReturn'] extends GraphQLObjectType ? TOutputs['MutationReturn'] : never : GraphQLNonNull<GraphQLList<GraphQLNonNull<TOutputs[UpperSingular<TNaming, TName>]>>>;
   args: {
     values: {
-      type: GraphQLNonNull<GraphQLList<GraphQLNonNull<TInputs[`Create${Capitalize<TName>}Input`]>>>;
+      type: GraphQLNonNull<GraphQLList<GraphQLNonNull<TInputs[`Create${UpperSingular<TNaming, 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>];
+} : never; } & { [TName in keyof TSchemaTables as TName extends string ? `create${UpperSingular<TNaming, TName>}${SingleSuffix<TNaming>}` : never]: TName extends string ? {
+  type: IsReturnless extends true ? TOutputs['MutationReturn'] extends GraphQLObjectType ? TOutputs['MutationReturn'] : never : TOutputs[UpperSingular<TNaming, TName>];
   args: {
     values: {
-      type: GraphQLNonNull<TInputs[`Create${Capitalize<TName>}Input`]>;
+      type: GraphQLNonNull<TInputs[`Create${UpperSingular<TNaming, 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>]>>>;
+} : never; } & { [TName in keyof TSchemaTables as TName extends string ? `upsert${UpperPlural<TNaming, TName>}` : never]?: TName extends string ? {
+  type: IsReturnless extends true ? TOutputs['MutationReturn'] extends GraphQLObjectType ? TOutputs['MutationReturn'] : never : GraphQLNonNull<GraphQLList<GraphQLNonNull<TOutputs[UpperSingular<TNaming, TName>]>>>;
   args: {
     values: {
-      type: GraphQLNonNull<GraphQLList<GraphQLNonNull<TInputs[`Create${Capitalize<TName>}Input`]>>>;
+      type: GraphQLNonNull<GraphQLList<GraphQLNonNull<TInputs[`Create${UpperSingular<TNaming, 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>];
+} : never; } & { [TName in keyof TSchemaTables as TName extends string ? `upsert${UpperSingular<TNaming, TName>}${SingleSuffix<TNaming>}` : never]?: TName extends string ? {
+  type: IsReturnless extends true ? TOutputs['MutationReturn'] extends GraphQLObjectType ? TOutputs['MutationReturn'] : never : TOutputs[UpperSingular<TNaming, TName>];
   args: {
     values: {
-      type: GraphQLNonNull<TInputs[`Create${Capitalize<TName>}Input`]>;
+      type: GraphQLNonNull<TInputs[`Create${UpperSingular<TNaming, 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>]>>>;
+} : never; } & { [TName in keyof TSchemaTables as TName extends string ? `update${UpperPlural<TNaming, TName>}` : never]: TName extends string ? {
+  type: IsReturnless extends true ? TOutputs['MutationReturn'] extends GraphQLObjectType ? TOutputs['MutationReturn'] : never : GraphQLNonNull<GraphQLList<GraphQLNonNull<TOutputs[UpperSingular<TNaming, TName>]>>>;
   args: {
     set: {
-      type: GraphQLNonNull<TInputs[`Update${Capitalize<TName>}Input`]>;
+      type: GraphQLNonNull<TInputs[`Update${UpperSingular<TNaming, TName>}Input`]>;
     };
     where: {
-      type: TInputs[`${Capitalize<TName>}Filters`] extends GraphQLInputObjectType ? TInputs[`${Capitalize<TName>}Filters`] : never;
+      type: TInputs[`${UpperSingular<TNaming, TName>}Filters`] extends GraphQLInputObjectType ? TInputs[`${UpperSingular<TNaming, 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>]>>;
+} : never; } & { [TName in keyof TSchemaTables as TName extends string ? `update${UpperPlural<TNaming, TName>}Many` : never]: TName extends string ? {
+  type: IsReturnless extends true ? TOutputs['MutationReturn'] extends GraphQLObjectType ? TOutputs['MutationReturn'] : never : GraphQLNonNull<GraphQLList<TOutputs[UpperSingular<TNaming, TName>]>>;
   args: {
     updates: {
-      type: GraphQLNonNull<GraphQLList<GraphQLNonNull<TInputs[`Update${Capitalize<TName>}ManyInput`]>>>;
+      type: GraphQLNonNull<GraphQLList<GraphQLNonNull<TInputs[`Update${UpperSingular<TNaming, 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>];
+} : never; } & { [TName in keyof TSchemaTables as TName extends string ? `update${UpperSingular<TNaming, TName>}${SingleSuffix<TNaming>}` : never]: TName extends string ? {
+  type: IsReturnless extends true ? TOutputs['MutationReturn'] extends GraphQLObjectType ? TOutputs['MutationReturn'] : never : TOutputs[UpperSingular<TNaming, TName>];
   args: {
     set: {
-      type: GraphQLNonNull<TInputs[`Update${Capitalize<TName>}Input`]>;
+      type: GraphQLNonNull<TInputs[`Update${UpperSingular<TNaming, TName>}Input`]>;
     };
     where: {
-      type: GraphQLNonNull<TInputs[`${Capitalize<TName>}Filters`] extends GraphQLInputObjectType ? TInputs[`${Capitalize<TName>}Filters`] : never>;
+      type: GraphQLNonNull<TInputs[`${UpperSingular<TNaming, TName>}Filters`] extends GraphQLInputObjectType ? TInputs[`${UpperSingular<TNaming, 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>]>>>;
+} : never; } & { [TName in keyof TSchemaTables as TName extends string ? `delete${UpperPlural<TNaming, TName>}` : never]: TName extends string ? {
+  type: IsReturnless extends true ? TOutputs['MutationReturn'] extends GraphQLObjectType ? TOutputs['MutationReturn'] : never : GraphQLNonNull<GraphQLList<GraphQLNonNull<TOutputs[UpperSingular<TNaming, TName>]>>>;
   args: {
     where: {
-      type: TInputs[`${Capitalize<TName>}Filters`] extends GraphQLInputObjectType ? TInputs[`${Capitalize<TName>}Filters`] : never;
+      type: TInputs[`${UpperSingular<TNaming, TName>}Filters`] extends GraphQLInputObjectType ? TInputs[`${UpperSingular<TNaming, 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>];
+} : never; } & { [TName in keyof TSchemaTables as TName extends string ? `delete${UpperSingular<TNaming, TName>}${SingleSuffix<TNaming>}` : never]: TName extends string ? {
+  type: IsReturnless extends true ? TOutputs['MutationReturn'] extends GraphQLObjectType ? TOutputs['MutationReturn'] : never : TOutputs[UpperSingular<TNaming, TName>];
   args: {
     where: {
-      type: GraphQLNonNull<TInputs[`${Capitalize<TName>}Filters`] extends GraphQLInputObjectType ? TInputs[`${Capitalize<TName>}Filters`] : never>;
+      type: GraphQLNonNull<TInputs[`${UpperSingular<TNaming, TName>}Filters`] extends GraphQLInputObjectType ? TInputs[`${UpperSingular<TNaming, TName>}Filters`] : never>;
     };
   };
   resolve: DeleteSingleResolver<TSchemaTables[TName], IsReturnless>;
@@ -1003,7 +1325,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>, TNaming extends TypeNaming = false> = { [TName in keyof TSchema as TName extends string ? `Create${UpperSingular<TNaming, TName>}Input` : never]: GraphQLInputObjectType; } & { [TName in keyof TSchema as TName extends string ? `Update${UpperSingular<TNaming, TName>}Input` : never]: GraphQLInputObjectType; } & { [TName in keyof TSchema as TName extends string ? `Update${UpperSingular<TNaming, TName>}ManyInput` : never]: GraphQLInputObjectType; } & { [TName in keyof TSchema as TName extends string ? `${UpperSingular<TNaming, TName>}OrderBy` : never]: GraphQLInputObjectType; } & { [TName in keyof TSchema as TName extends string ? `${UpperSingular<TNaming, TName>}Filters` : never]: GraphQLInputObjectType; };
 /**
  * Keys of `entities.types`, which is keyed by generated GraphQL type name.
  *
@@ -1012,12 +1334,12 @@ type GeneratedInputs<TSchema extends Record<string, Table>> = { [TName in keyof
  * 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 ? {
+type GeneratedOutputs<TSchema extends Record<string, Table>, IsReturnless extends boolean, TNaming extends TypeNaming = false> = { [TName in keyof TSchema as TName extends string ? UpperSingular<TNaming, TName> : never]: GraphQLObjectType; } & { [TName in keyof TSchema as TName extends string ? `${UpperSingular<TNaming, 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>;
+} : { [TName in keyof TSchema as TName extends string ? UpperSingular<TNaming, TName> : never]: GraphQLObjectType; });
+type GeneratedEntities<TDatabase extends AnyDrizzleDB<TSchema>, TSchema extends Record<string, unknown> = SchemaOf<TDatabase>, TSchemaTables extends ExtractTables<TSchema> = ExtractTables<TSchema>, TSchemaRelations extends ExtractRelations<TSchema> = ExtractRelations<TSchema>, TNaming extends TypeNaming = false, TInputs extends GeneratedInputs<TSchemaTables, TNaming> = GeneratedInputs<TSchemaTables, TNaming>, TOutputs extends GeneratedOutputs<TSchemaTables, TDatabase extends MySqlAsyncDatabase<any, any> ? true : false, TNaming> = GeneratedOutputs<TSchemaTables, TDatabase extends MySqlAsyncDatabase<any, any> ? true : false, TNaming>> = {
+  queries: QueriesCore<TSchemaTables, TSchemaRelations, TInputs, TOutputs, TNaming>;
+  mutations: MutationsCore<TSchemaTables, TInputs, TOutputs, TDatabase extends MySqlAsyncDatabase<any, any> ? true : false, TNaming>;
   inputs: TInputs;
   types: TOutputs;
   /**
@@ -1028,10 +1350,24 @@ type GeneratedEntities<TDatabase extends AnyDrizzleDB<TSchema>, TSchema extends
    */
   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>> = {
+type GeneratedData<TDatabase extends AnyDrizzleDB<any>, TNaming extends TypeNaming = false> = {
   schema: GraphQLSchema;
-  entities: GeneratedEntities<TDatabase>;
+  entities: GeneratedEntities<TDatabase, SchemaOf<TDatabase>, ExtractTables<SchemaOf<TDatabase>>, ExtractRelations<SchemaOf<TDatabase>>, TNaming>;
 };
+/**
+ * The naming mode a `buildSchema` config selects, which decides how {@link GeneratedEntities}
+ * keys its maps.
+ *
+ * Read off the config's *static* type, so it answers only for a config written inline (or
+ * `as const`): a `typeNameMapper` assigned through a variable of type
+ * {@link BuildSchemaConfig} is invisible here and keys as if there were no mapper, the same
+ * way these types behaved before singularization existed.
+ */
+type NamingOf<TConfig> = TConfig extends {
+  typeNameMapper: 'singularize';
+} ? 'singularize' : TConfig extends {
+  typeNameMapper: (...args: any[]) => any;
+} ? 'loose' : false;
 /**
  * A feature switch. `true` / `false` decides for the whole build; a predicate decides per
  * table, receiving the table's key in the Drizzle schema.
@@ -1418,6 +1754,15 @@ type BuildSchemaConfig = {
   /**
    * Customizes query name suffixes for generated GraphQL operations.
    *
+   * Both reach every operation that comes in a list/single pair, mutations included. The
+   * variants that carry their own disambiguator — `<plural>Aggregate`, `<plural>GroupBy`,
+   * `update<Table>Many`, `update<Table>Count`, `delete<Table>Count` — take neither.
+   *
+   * The two cannot be the same string unless a {@link BuildSchemaConfig.typeNameMapper} is
+   * also configured: without one both nouns are the table key, so the pair would collapse
+   * onto a single field name. With one, the mapper's singular/plural forms separate every
+   * pair on their own and the single side takes no suffix at all — see `typeNameMapper`.
+   *
    * @default { list: '', single: 'Single' }
    */
   suffixes?: {
@@ -1728,8 +2073,12 @@ type BuildSchemaConfig = {
    * ```ts
    * buildSchema(db, {
    *   onWrite: {
-   *     posts: async ({ table, operation, rows, tx }) => {
-   *       await tx.insert(auditLog).values(rows.map((row) => ({ table, operation, rowId: row.id })));
+   *     posts: {
+   *       after: async ({ table, operation, rows, tx }) => {
+   *         await tx.insert(auditLog).values(rows.map((row) => ({ table, operation, rowId: row.id })));
+   *       },
+   *       // `rows` always carries `id`, whether or not the client selected it.
+   *       columns: ['id'],
    *     },
    *   },
    * });
@@ -1747,6 +2096,13 @@ type BuildSchemaConfig = {
    * - **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.
+   * - **A row holds the columns the client selected**, because `RETURNING` is built from the
+   *   selection — plus every column the registration names in `columns` (column keys, or
+   *   `'all'`). Those are added to `RETURNING` for insert, upsert, update, `updateMany`, delete
+   *   and restore, and taken back off before the result is mapped, so the client's response
+   *   is unchanged. An unknown column, or `columns` with no `after` hook, fails the build; on
+   *   a top-level registration a named column must exist on every table. MySQL returns no
+   *   rows, so `columns` has no effect there.
    * - 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.
    *
@@ -1790,8 +2146,15 @@ type BuildSchemaConfig = {
    * 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.
+   * produces type `User`, queries `users` / `user`, mutations `createUsers` / `createUser`,
+   * `updateUsers` / `updateUser` and `deleteUsers` / `deleteUser` for the `users` table, and
+   * leaves other tables with their default names.
+   *
+   * The noun is what separates a mapped table's pairs — plural on the form that operates on
+   * a set of rows, singular on the one that operates on exactly one — so a mapped table's
+   * operations carry no `Single` suffix, whatever {@link BuildSchemaConfig.suffixes} says.
+   * A table the mapper returns `undefined` for is back on the default naming, where
+   * `suffixes.single` is the only thing separating its pairs.
    *
    * 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
@@ -1808,6 +2171,12 @@ type BuildSchemaConfig = {
    * 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.
+   *
+   * `entities` is keyed to match, when the config is written inline so its type is visible:
+   * the preset's two nouns are replicated at the type level, so `entities.queries.task`
+   * autocompletes. A mapper *function* renames types in a way no type can predict, so those
+   * maps fall back to an index signature rather than naming fields the build does not
+   * publish — see {@link NamingOf}.
    */
   typeNameMapper?: 'singularize' | TypeNameMapper;
   /**
@@ -2057,6 +2426,35 @@ type BuildSchemaConfig = {
    * Return `undefined` to keep the default name.
    */
   enumNameMapper?: EnumNameMapper;
+  /**
+   * Names the *values* of the generated GraphQL enum types.
+   *
+   * By default a value's GraphQL name is the stored value itself (`'running'` → `running`),
+   * or `Option<index>` when the stored value is not a usable GraphQL name. This hook overrides
+   * that per value — most often to follow GraphQL's SCREAMING_CASE convention while the
+   * database keeps its lowercase values:
+   *
+   * ```ts
+   * buildSchema(db, {
+   *   enumValueNameMapper: ({ value }) => value.toUpperCase(),
+   * });
+   * // enum RunsStatusEnum { RUNNING OK ERROR STOPPED }
+   * ```
+   *
+   * Only the GraphQL name changes. Each value's internal `value` stays the stored string, so
+   * filters, create/update inputs, outputs and resolvers keep sending and receiving exactly
+   * what the database stores; the generated TypeScript types keep the stored values too.
+   *
+   * Pass the string `'constant'` for the built-in preset, which CONSTANT_CASEs every value
+   * (`inProgress` / `in-progress` → `IN_PROGRESS`).
+   *
+   * The mapper receives the stored `value`, its `index`, the enum's GraphQL `typeName` (after
+   * `enumNameMapper`), and everything `enumNameMapper` receives. Return `undefined` to keep the
+   * default name for that value. The build throws when a returned name is not a valid GraphQL
+   * enum value name, when two values of one enum map to the same name, or when columns sharing
+   * one enum type would name its values differently.
+   */
+  enumValueNameMapper?: 'constant' | EnumValueNameMapper;
 };
 //#endregion
 //#region src/util/case-ops/index.d.ts
@@ -2174,7 +2572,7 @@ type ResolveSelectionOptions = SelectionOptions & {
 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>;
+declare const buildSchema: <TDbClient extends AnyDrizzleDB<any>, TConfig extends BuildSchemaConfig = BuildSchemaConfig>(db: TDbClient, config?: TConfig) => GeneratedData<TDbClient, NamingOf<TConfig>>;
 //#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 };
+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 EnumValueNameInfo, type EnumValueNameMapper, 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 NamingOf, type OnWriteConfig, type ParseResolveInfoOptions, type Pluralize, 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 Singularize, type SoftDeleteColumn, type SoftDeleteConfig, type TableDefaults, type TableDescriber, type TableLimitPolicy, type TableNamedRelations, type TypeNameMapper, type TypeNaming, 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