openapi-typesafe 1.0.0-rc.0 → 1.0.0-rc.1

package/dist/transform/components-object.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"components-object.mjs","sources":["../../src/transform/components-object.ts"],"sourcesContent":["import { createTransformContext } from \"../api/transform-context.js\";\nimport { componentsType } from \"../application/transform/document/components.js\";\nimport type { IrType, IrTypeAliasDeclaration } from \"../domain/ir/nodes.js\";\nimport { isEnumSchema, singularizeComponentKind } from \"../domain/openapi/components-object.js\";\nimport type { ComponentsObject, GlobalContext } from \"../types.js\";\n\nexport { isEnumSchema };\n\n/** `requestBodies` → `requestBody`; other keys drop the final `s`. */\nexport const singularizeComponentKey = singularizeComponentKind;\n\n/**\n * Transform the ComponentsObject (4.8.7)\n * @see https://spec.openapis.org/oas/latest.html#components-object\n *\n * Ported to IR (ENGINEERING_PLAN Phase 5, step 6). Same name and parameters as the original;\n * returns IR (task 6.2). For the public API: the `components` type, then the root type aliases.\n */\nexport default function transformComponentsObject(\n  componentsObject: ComponentsObject,\n  ctx: GlobalContext,\n): (IrType | IrTypeAliasDeclaration)[] {\n  const { type, rootTypes } = componentsType(componentsObject, createTransformContext(ctx));\n  return [type, ...rootTypes];\n}\n"],"names":[],"mappings":";;;AAkBA,SAAwB,yBAAA,CACtB,kBACA,GAAA,EACqC;AACrC,EAAA,MAAM,EAAE,MAAM,SAAA,EAAU,GAAI,eAAe,gBAAA,EAAkB,sBAAA,CAAuB,GAAG,CAAC,CAAA;AACxF,EAAA,OAAO,CAAC,IAAA,EAAM,GAAG,SAAS,CAAA;AAC5B;;"}
+{"version":3,"file":"components-object.mjs","sources":["../../src/transform/components-object.ts"],"sourcesContent":["import { createTransformContext } from \"../api/transform-context.js\";\nimport { componentsType } from \"../application/transform/document/components.js\";\nimport { renameTakenAliases } from \"../application/transform/document/root-type-aliases.js\";\nimport type { IrType, IrTypeAliasDeclaration } from \"../domain/ir/nodes.js\";\nimport { isEnumSchema, singularizeComponentKind } from \"../domain/openapi/components-object.js\";\nimport type { ComponentsObject, GlobalContext } from \"../types.js\";\n\nexport { isEnumSchema };\n\n/** `requestBodies` → `requestBody`; other keys drop the final `s`. */\nexport const singularizeComponentKey = singularizeComponentKind;\n\n/**\n * Transform the ComponentsObject (4.8.7)\n * @see https://spec.openapis.org/oas/latest.html#components-object\n *\n * Ported to IR (ENGINEERING_PLAN Phase 5, step 6). Same name and parameters as the original;\n * returns IR (task 6.2). For the public API: the `components` type, then the root type aliases.\n */\nexport default function transformComponentsObject(\n  componentsObject: ComponentsObject,\n  ctx: GlobalContext,\n): (IrType | IrTypeAliasDeclaration)[] {\n  const { type, rootTypes } = componentsType(componentsObject, createTransformContext(ctx));\n  // No footer here: only the aliases the `root-type-numbering` fix keeps get numbers.\n  return [type, ...renameTakenAliases(rootTypes, [])];\n}\n"],"names":[],"mappings":";;;;AAmBA,SAAwB,yBAAA,CACtB,kBACA,GAAA,EACqC;AACrC,EAAA,MAAM,EAAE,MAAM,SAAA,EAAU,GAAI,eAAe,gBAAA,EAAkB,sBAAA,CAAuB,GAAG,CAAC,CAAA;AAExF,EAAA,OAAO,CAAC,IAAA,EAAM,GAAG,mBAAmB,SAAA,EAAW,EAAE,CAAC,CAAA;AACpD;;"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "openapi-typesafe",
   "description": "Convert OpenAPI 3.0 & 3.1 schemas to TypeScript",
-  "version": "1.0.0-rc.0",
+  "version": "1.0.0-rc.1",
   "author": {
     "name": "Fedor Chishchin",
     "url": "https://github.com/fedorello"

package/src/adapters/redocly-loader/redocly-config-source.ts

@@ -1,10 +1,43 @@
 import fs from "node:fs";
 import path from "node:path";
-import { createConfig, findConfig, loadConfig } from "@redocly/openapi-core";
+import { createConfig, findConfig, IGNORE_FILE, loadConfig } from "@redocly/openapi-core";
 import type {
   RedoclyConfig,
   RedoclyConfigSource,
 } from "../../application/ports/redocly-config-source.js";
+import { ERROR_CODES, OpenAPITypesafeError } from "../../domain/errors.js";
+
+/**
+ * The first line of a failure, with the error's name: a YAML error goes on with a snippet of the
+ * file, and the name tells a YAML error from a file system one.
+ */
+function reasonOf(error: unknown): string {
+  return String(error).replace(/\n[\s\S]*$/, "");
+}
+
+/**
+ * The config, or `CLI_CONFIG_INVALID`. Redocly reads the config file and the lint-ignore file
+ * next to it (or in the working directory); either can be malformed, and its error does not
+ * always name the file, so the message names both.
+ */
+async function loadedConfig(
+  load: () => Promise<RedoclyConfig>,
+  configPath: string | undefined,
+): Promise<RedoclyConfig> {
+  try {
+    return await load();
+  } catch (error) {
+    const config =
+      configPath === undefined ? "the default Redocly config" : `the Redocly config ${configPath}`;
+    const where = configPath === undefined ? "in the working directory" : "next to it";
+    throw new OpenAPITypesafeError({
+      code: ERROR_CODES.CLI_CONFIG_INVALID,
+      message: `Cannot load ${config} or the ${IGNORE_FILE} ${where}: ${reasonOf(error)}`,
+      details: { configPath },
+      cause: error,
+    });
+  }
+}
 
 /** The Redocly config port on `@redocly/openapi-core`, resolving paths from `cwd`. */
 class RedoclyConfigFiles implements RedoclyConfigSource {
@@ -26,14 +59,16 @@ class RedoclyConfigFiles implements RedoclyConfigSource {
   }
 
   load(configPath: string): Promise<RedoclyConfig> {
-    return loadConfig({ configPath });
+    return loadedConfig(() => loadConfig({ configPath }), configPath);
   }
 
   createDefault(): Promise<RedoclyConfig> {
-    return createConfig(
-      { rules: { "operation-operationId-unique": { severity: "warn" } } },
-      { extends: ["minimal"] },
-    );
+    const create = () =>
+      createConfig(
+        { rules: { "operation-operationId-unique": { severity: "warn" } } },
+        { extends: ["minimal"] },
+      );
+    return loadedConfig(create, undefined);
   }
 }
 

package/src/adapters/redocly-loader/redocly-schema-loader.ts

@@ -74,12 +74,17 @@ function assertOpenAPI3(document: unknown): void {
   throw versionUnsupportedError(UNSUPPORTED_FORMAT_MESSAGE, parsed);
 }
 
-/** The base for relative `$ref`s: the source file or URL itself, else the working directory. */
+/**
+ * The name an inline source (a string, object, buffer or stream) gets inside the working
+ * directory. Redocly resolves relative `$ref`s against the directory of the document, so the
+ * document must be named as a file in the working directory, not as the directory itself.
+ */
+const INLINE_SOURCE_NAME = "inline-source";
+
+/** The base for relative `$ref`s: the source file or URL itself, else a file in the cwd. */
 function sourceAbsoluteRef(source: unknown, cwd: URL): string {
-  if (source instanceof URL) {
-    return source.protocol === "file:" ? sourceFilePath(source) : source.href;
-  }
-  return fileURLToPath(cwd);
+  const document = source instanceof URL ? source : new URL(INLINE_SOURCE_NAME, cwd);
+  return document.protocol === "file:" ? sourceFilePath(document) : document.href;
 }
 
 /**
@@ -217,10 +222,21 @@ class RedoclySchemaLoader implements SchemaLoader {
     return bundled.bundle.parsed;
   }
 
-  /** Report every problem; then throw if any of them is an error. */
+  /**
+   * Report every problem; then throw if any of them is an error. A problem that the Redocly
+   * config's `.redocly.lint-ignore.yaml` lists is left out, as `redocly lint` leaves it out
+   * (upstream #2189).
+   */
   #report(problems: readonly NormalizedProblem[]): void {
     const errorMessages: string[] = [];
     for (const problem of problems) {
+      if (problem.ignored === true) {
+        this.#options.logger.debug(
+          `Ignored by the lint ignore file: ${problemMessage(problem)}`,
+          "lint",
+        );
+        continue;
+      }
       const message = problemMessage(problem);
       if (problem.severity === "error") {
         errorMessages.push(message);

package/src/adapters/type-ast-bridge/ir-to-typescript.ts

@@ -74,6 +74,9 @@ function toStringLiteralType(
 
 function toTupleElement(ts: TypeScriptModule, element: IrTupleElement): ts.TypeNode {
   const type = toTypeNode(ts, element.type);
+  if (element.isOptional) {
+    return ts.factory.createOptionalTypeNode(type);
+  }
   return element.isRest ? ts.factory.createRestTypeNode(type) : type;
 }
 

package/src/adapters/type-ast-bridge/typescript-to-ir.ts

@@ -6,6 +6,7 @@ import type {
   IrMember,
   IrPropertyName,
   IrPropertySignature,
+  IrTupleElement,
   IrType,
 } from "../../domain/ir/nodes.js";
 import type { TypeScriptModule } from "./load-typescript.js";
@@ -83,20 +84,31 @@ function fromReference(ts: TypeScriptModule, node: ts.TypeReferenceNode): IrType
   return { kind: "reference", name: ts.idText(node.typeName), typeArguments };
 }
 
+function fromTupleElement(
+  ts: TypeScriptModule,
+  element: ts.TypeNode,
+  convert: (node: ts.TypeNode) => IrType,
+): IrTupleElement {
+  if (ts.isRestTypeNode(element)) {
+    return { type: convert(element.type), isRest: true, isOptional: false };
+  }
+  if (ts.isOptionalTypeNode(element)) {
+    // The `?` is the parent of the type: it decides which parentheses the factory put in.
+    return { type: fromTypeNode(ts, element.type, element), isRest: false, isOptional: true };
+  }
+  return { type: convert(element), isRest: false, isOptional: false };
+}
+
+/** A tuple of plain, rest and optional elements; one with named members stays text. */
 function fromTuple(ts: TypeScriptModule, node: ts.TupleTypeNode): IrType | null {
-  const isPlain = node.elements.every(
-    (element) => !ts.isNamedTupleMember(element) && !ts.isOptionalTypeNode(element),
-  );
-  if (!isPlain) {
+  if (node.elements.some((element) => ts.isNamedTupleMember(element))) {
     return null;
   }
   const convert = childrenOf(ts, node);
-  const elements = node.elements.map((element) =>
-    ts.isRestTypeNode(element)
-      ? { type: convert(element.type), isRest: true }
-      : { type: convert(element), isRest: false },
-  );
-  return { kind: "tuple", elements };
+  return {
+    kind: "tuple",
+    elements: node.elements.map((element) => fromTupleElement(ts, element, convert)),
+  };
 }
 
 /**
@@ -237,8 +249,9 @@ function fromStructure(ts: TypeScriptModule, node: ts.TypeNode): IrType | null {
 
 /**
  * Whether the factory's parenthesizer put these parentheses in (same rules as the IR printer):
- * unions, intersections and `readonly` types as array elements, indexed objects and `readonly`
- * operands; unions and intersections as members of other unions or intersections.
+ * unions, intersections and `readonly` types as array elements, indexed objects, optional tuple
+ * elements and `readonly` operands; unions and intersections as members of other unions or
+ * intersections.
  */
 function isFactoryParenthesis(
   ts: TypeScriptModule,
@@ -252,6 +265,7 @@ function isFactoryParenthesis(
   const isPostfixOrReadonlyParent =
     ts.isArrayTypeNode(parent) ||
     ts.isIndexedAccessTypeNode(parent) ||
+    ts.isOptionalTypeNode(parent) ||
     ts.isTypeOperatorNode(parent);
   if (isPostfixOrReadonlyParent) {
     return isComposite || ts.isTypeOperatorNode(inner);

package/src/api/discriminator-conflict-warnings.ts

@@ -0,0 +1,43 @@
+import type { Logger } from "../application/ports/logger.js";
+import {
+  type DiscriminatorValueConflict,
+  findDiscriminatorValueConflicts,
+} from "../domain/openapi/discriminator-conflicts.js";
+import { OutputFix } from "../domain/output-fixes.js";
+import { WARNING_CODES, warningText } from "../domain/warnings.js";
+
+const DOCS_BASE_URL = "https://github.com/openapi-typesafe/openapi-typesafe/blob/main/docs";
+const DOCS_URL = `${DOCS_BASE_URL}/advanced.md#discriminator-values`;
+
+function listed(values: readonly unknown[]): string {
+  return values.map((value) => JSON.stringify(value)).join(", ");
+}
+
+function warningOf(conflict: DiscriminatorValueConflict): string {
+  const { member, owner, propertyName, values, allowed, isImplicit } = conflict;
+  const rule = isImplicit
+    ? "A Discriminator Object without a mapping entry for a schema gives it its schema name as " +
+      `the value; add a mapping entry such as ${JSON.stringify(allowed[0])}: "${member}".`
+    : "The Discriminator Object maps these values to the schema; map the values it allows.";
+  return (
+    `${member}: the discriminator "${propertyName}" of ${owner} gives this schema the value ` +
+    `${listed(values)}, which its "${propertyName}" property does not allow ` +
+    `(${listed(allowed)}), so no value of the schema matches the discriminator. ${rule} ` +
+    `See ${DOCS_URL}`
+  );
+}
+
+/**
+ * Warn once per discriminator member whose value its own property does not allow. The members
+ * depend on the run's fixes (`allof-discriminated-union`).
+ */
+export function warnDiscriminatorValueConflicts(
+  document: unknown,
+  fixes: readonly OutputFix[],
+  logger: Logger,
+): void {
+  const isUnionReused = fixes.includes(OutputFix.ALLOF_DISCRIMINATED_UNION);
+  for (const conflict of findDiscriminatorValueConflicts(document, { isUnionReused })) {
+    logger.warn(warningText(warningOf(conflict), WARNING_CODES.DISCRIMINATOR_VALUE_NOT_ALLOWED));
+  }
+}

package/src/api/discriminator-enum-names.ts

@@ -0,0 +1,26 @@
+import type { SharedEnumNames } from "../application/transform/footer/shared-enum-names.js";
+import type { EnumDeclarationRequest } from "../application/transform/schema/schema-context.js";
+
+/**
+ * `--dedupe-enums` names a shared enum after the first schema that declares it. With
+ * `discriminator-values` and `--enum`, a member's value refers to the owner's enum, which is then
+ * declared when the member is typed, maybe before that first schema; the shared enum would take
+ * the owner's name. A first pass records the names of the declaring schemas only, so the second
+ * pass names each shared enum as the document order does (`OtherKind`, not `PetPetType`).
+ */
+export class FirstSchemaNameRecorder implements SharedEnumNames {
+  private readonly names = new Map<string, string>();
+
+  nameOf(key: string, name: string, request: EnumDeclarationRequest): string {
+    if (!request.isOwnerReference && !this.names.has(key)) {
+      this.names.set(key, name);
+    }
+    return name;
+  }
+
+  /** The recorded name of each shared enum, for the second pass. */
+  chosenNames(): SharedEnumNames {
+    const chosen = new Map(this.names);
+    return { nameOf: (key, name) => chosen.get(key) ?? name };
+  }
+}

package/src/api/discriminator-enum-parent.ts

@@ -0,0 +1,129 @@
+import { createRef, parseRefPointer } from "../domain/openapi/json-pointer.js";
+import type { SchemaObject } from "../types.js";
+import type { EnumPatch } from "./discriminator-enum.js";
+
+/**
+ * The `discriminator-values` fix (#1700). With `--enum`, the enum the scan adds to a member
+ * (`petType: "Cat"`) is declared as an enum of its own (`CatPetType`), which is not assignable to
+ * the parent's enum (`PetType`). The parent's enum is found here, so the member's property can be
+ * typed with its members (`PetType.Cat`).
+ */
+
+/** The parent's enum schema and the location it is typed at, which gives the enum its name. */
+export interface EnumParent {
+  readonly schema: SchemaObject;
+  readonly path: string;
+}
+
+type ResolveSchemaRef = (ref: string) => unknown;
+
+/** A declared property schema and the location the transformer types it at. */
+interface DeclaredProperty {
+  readonly property: unknown;
+  readonly path: string;
+}
+
+const PROPERTIES_KEYWORD = "properties";
+/** `components`, `schemas` and the schema name: the segments before the schema's own keywords. */
+const ROOT_SEGMENTS = 3;
+
+/** The location a `$ref` is typed at: object properties are nested without `properties`. */
+function typedAt(ref: string): string {
+  const segments = parseRefPointer(ref);
+  const nested = segments.slice(ROOT_SEGMENTS).filter((segment) => segment !== PROPERTIES_KEYWORD);
+  return createRef([...segments.slice(0, ROOT_SEGMENTS), ...nested]);
+}
+
+function isSchemaObject(value: unknown): value is SchemaObject {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/** The property `name` of a schema object typed at `ref`. */
+function ownProperty(item: SchemaObject, ref: string, name: string): DeclaredProperty | undefined {
+  const property = ("properties" in item ? item.properties : undefined)?.[name];
+  return property === undefined ? undefined : { property, path: createRef([ref, name]) };
+}
+
+/** The property `name` of the schema at `ref`, its own or from an `allOf` item, depth first. */
+function declaredProperty(
+  ref: string,
+  name: string,
+  resolve: ResolveSchemaRef,
+  visited: Set<string>,
+): DeclaredProperty | undefined {
+  const schema = resolve(ref);
+  if (visited.has(ref) || !isSchemaObject(schema)) {
+    return undefined;
+  }
+  visited.add(ref);
+  // An inline `allOf` item is typed at its parent's location, so both share the path.
+  for (const item of [schema, ...(schema.allOf ?? [])]) {
+    if (!isSchemaObject(item)) {
+      continue;
+    }
+    const found =
+      "$ref" in item
+        ? declaredProperty(item.$ref as string, name, resolve, visited)
+        : ownProperty(item, ref, name);
+    if (found !== undefined) {
+      return found;
+    }
+  }
+  return undefined;
+}
+
+/**
+ * A discriminator and the `$ref` of the schema that declares its property; `ref` is the member
+ * whose value the discriminator gives, where there is one.
+ */
+export type DiscriminatorOwner = Pick<EnumPatch, "discriminator" | "discriminatorRef"> &
+  Partial<Pick<EnumPatch, "ref">>;
+
+/**
+ * The property `name` that the member at `ref` inherits through its `allOf` `$ref`s. Its own
+ * keywords and inline items are left out: the scan writes the added value there.
+ */
+function inheritedProperty(
+  ref: string,
+  name: string,
+  resolve: ResolveSchemaRef,
+): DeclaredProperty | undefined {
+  const schema = resolve(ref);
+  const visited = new Set([ref]);
+  for (const item of isSchemaObject(schema) ? (schema.allOf ?? []) : []) {
+    const found =
+      isSchemaObject(item) && "$ref" in item
+        ? declaredProperty(item.$ref as string, name, resolve, visited)
+        : undefined;
+    if (found !== undefined) {
+      return found;
+    }
+  }
+  return undefined;
+}
+
+/**
+ * The enum of the property that the discriminator owner declares, if it is one. An owner that
+ * declares no such property (a `oneOf` with a mapping) leaves the member's type to the property
+ * the member inherits, so that property's enum is the one.
+ */
+export function enumParentOf(
+  patch: DiscriminatorOwner,
+  resolve: ResolveSchemaRef,
+): EnumParent | undefined {
+  const name = patch.discriminator.propertyName;
+  const declared =
+    declaredProperty(patch.discriminatorRef, name, resolve, new Set()) ??
+    (patch.ref === undefined ? undefined : inheritedProperty(patch.ref, name, resolve));
+  if (declared === undefined || !isSchemaObject(declared.property)) {
+    return undefined;
+  }
+  const ref = (declared.property as { readonly $ref?: unknown }).$ref;
+  const parent =
+    typeof ref === "string"
+      ? { schema: resolve(ref), path: typedAt(ref) }
+      : { schema: declared.property, path: declared.path };
+  return isSchemaObject(parent.schema) && Array.isArray(parent.schema.enum)
+    ? { schema: parent.schema, path: parent.path }
+    : undefined;
+}

package/src/api/discriminator-enum.ts

@@ -61,6 +61,45 @@ function isObjectSchema(schema: unknown): schema is SchemaObject & ObjectSubtype
   );
 }
 
+/** The values a property schema allows, from `const` or `enum`; null when it lists none. */
+function listedValues(property: unknown): readonly unknown[] | null {
+  if (typeof property !== "object" || property === null) {
+    return null;
+  }
+  const { const: constant, enum: values } = property as SchemaObject;
+  if (constant !== undefined) {
+    return [constant];
+  }
+  return Array.isArray(values) ? values : null;
+}
+
+/** Whether one schema object requires the property and allows exactly the values. */
+function requiresValues(schema: unknown, name: string, values: readonly string[]): boolean {
+  if (typeof schema !== "object" || schema === null || "$ref" in schema) {
+    return false;
+  }
+  const { required, properties } = schema as SchemaObject & ObjectSubtype;
+  const listed = listedValues(properties?.[name]);
+  return (
+    Boolean(required?.includes(name)) &&
+    listed !== null &&
+    listed.length === values.length &&
+    values.every((value) => listed.includes(value))
+  );
+}
+
+/**
+ * Whether `schema`, or an inline `allOf` item of it, already requires the discriminator property
+ * with exactly the patch's values (the `discriminator-values` fix). Then a patch would
+ * only repeat it (#2124).
+ */
+export function declaresValues(schema: SchemaObject | undefined, patch: EnumPatch): boolean {
+  const name = patch.discriminator.propertyName;
+  return [schema, ...(schema?.allOf ?? [])].some((item) =>
+    requiresValues(item, name, patch.values),
+  );
+}
+
 /**
  * Add or replace the enum property in `schema`, an `allOf` or object schema. Returns the added
  * enum schema, or null for another kind of schema, which is left as it is.

package/src/api/discriminator-other-owners.ts

@@ -0,0 +1,97 @@
+import type { DiscriminatorObject, ReferenceObject, SchemaObject } from "../types.js";
+import type { EnumPatch } from "./discriminator-enum.js";
+import { enumKey, patchDiscriminatorEnum, type ScanState } from "./discriminator-patch.js";
+import { resolveDocumentRef } from "./document-refs.js";
+
+/**
+ * The `discriminator-values` fix: a schema inherits one discriminator per property. A schema that
+ * owns a discriminator keeps its own (#2200), so the scan does not record the one it inherits for
+ * another property (`Content` owns `subtype` and `allOf`s `Element`, which owns `contentType`).
+ * Its members (`Video`) still get a value of that property, found here from the owners above.
+ */
+
+/** A discriminator and the schema that defines it. */
+interface OtherOwner {
+  readonly discriminator: DiscriminatorObject;
+  readonly ownerRef: string;
+}
+
+/** The `$ref`s of a schema's `allOf` items. */
+function allOfRefs(state: ScanState, ref: string): string[] {
+  const { silent, logger } = state;
+  const schema = resolveDocumentRef<SchemaObject>(state.schema, ref, { silent, logger });
+  const items = (schema?.allOf ?? []) as (SchemaObject | ReferenceObject)[];
+  return items.flatMap((item) =>
+    "$ref" in item && typeof item.$ref === "string" ? [item.$ref] : [],
+  );
+}
+
+/**
+ * The owners' discriminators that the schema at `parentRef` and its `allOf` parents define, the
+ * nearest one per property, except the property of `parentRef`'s own discriminator.
+ */
+function otherOwners(state: ScanState, parentRef: string): OtherOwner[] {
+  const own = state.objects[parentRef]?.propertyName;
+  const found = new Map<string, OtherOwner>();
+  const visited = new Set<string>();
+  const queue = [parentRef];
+  for (let ref = queue.shift(); ref !== undefined; ref = queue.shift()) {
+    if (visited.has(ref)) {
+      continue;
+    }
+    visited.add(ref);
+    const discriminator = state.owners.has(ref) ? state.objects[ref] : undefined;
+    const name = discriminator?.propertyName;
+    if (discriminator && name !== undefined && name !== own && !found.has(name)) {
+      found.set(name, { discriminator, ownerRef: ref });
+    }
+    queue.push(...allOfRefs(state, ref));
+  }
+  return [...found.values()];
+}
+
+/**
+ * The child redefines this property, so its `allOf` items omit it: a parent may have a value of
+ * its own, as `Content` has when `Element`'s mapping names it.
+ */
+function recordOtherProperty(state: ScanState, ref: string, propertyName: string): void {
+  const names = state.otherProperties[ref] ?? [];
+  if (!names.includes(propertyName)) {
+    names.push(propertyName);
+  }
+  state.otherProperties[ref] = names;
+}
+
+/**
+ * The child at `ref` of the schema at `parentRef` gets a value of each other property: a mapped
+ * one at once, else its schema name after both passes, where no mapping gives one. The schema's
+ * own discriminator property is still added, so these patches do not mark it handled.
+ */
+export function inheritOtherOwners(state: ScanState, parentRef: string, ref: string): void {
+  const childProperty = state.objects[ref]?.propertyName;
+  for (const { discriminator, ownerRef } of otherOwners(state, parentRef)) {
+    if (discriminator.propertyName === childProperty) {
+      continue;
+    }
+    recordOtherProperty(state, ref, discriminator.propertyName);
+    const mapped = Object.entries(discriminator.mapping ?? {})
+      .filter(([, target]) => target === ref)
+      .map(([value]) => value);
+    const name = ref.slice(ref.lastIndexOf("/") + 1);
+    const patch: EnumPatch = { ref, values: mapped, discriminator, discriminatorRef: ownerRef };
+    if (mapped.length > 0) {
+      patchDiscriminatorEnum(state, patch);
+    } else {
+      state.otherInferredPatches.push({ ...patch, values: [name] });
+    }
+  }
+}
+
+/** The deferred schema-name values of other properties; see `inheritOtherOwners`. */
+export function applyOtherInferredPatches(state: ScanState, mapped: ReadonlySet<string>): void {
+  for (const patch of state.otherInferredPatches) {
+    if (!mapped.has(enumKey(patch))) {
+      patchDiscriminatorEnum(state, patch);
+    }
+  }
+}