schema-components 1.20.0 → 1.22.0

package/dist/{types-C9zw9wbX.d.mts → types-BrRMV0en.d.mts}

@@ -59,7 +59,7 @@ type FieldOverride = Partial<SchemaMeta> & {
  * All schema types the walker can produce.
  * Used as the discriminant in the WalkedField tagged union.
  */
-type SchemaType = "string" | "number" | "boolean" | "null" | "enum" | "literal" | "object" | "array" | "tuple" | "record" | "union" | "discriminatedUnion" | "conditional" | "negation" | "recursive" | "file" | "never" | "unknown";
+type SchemaType = "string" | "number" | "boolean" | "null" | "enum" | "literal" | "object" | "array" | "tuple" | "record" | "union" | "discriminatedUnion" | "conditional" | "negation" | "file" | "never" | "unknown";
 /** Constraints that apply to string schemas. */
 interface StringConstraints {
   minLength?: number;
@@ -84,8 +84,6 @@ interface ArrayConstraints {
   minItems?: number;
   maxItems?: number;
   uniqueItems?: boolean;
-  /** Schema that at least one array item must match. */
-  contains?: Record<string, unknown>;
   minContains?: number;
   maxContains?: number;
   /** Constraint schema for unevaluated items. */
@@ -176,6 +174,12 @@ interface ArrayField extends FieldBase {
   constraints: ArrayConstraints;
   /** The element sub-schema. */
   element?: WalkedField;
+  /**
+   * Walked schema that at least one array item must match
+   * (`contains` keyword). Constrains element membership at runtime;
+   * paired with `minContains`/`maxContains` for cardinality.
+   */
+  contains?: WalkedField;
   /** Walked schema for unevaluated items. */
   unevaluatedItems?: WalkedField;
 }
@@ -190,6 +194,12 @@ interface TupleField extends FieldBase {
    * absent, additional items are permitted but unconstrained.
    */
   restItems?: WalkedField;
+  /**
+   * Walked schema that at least one array item must match
+   * (`contains` keyword). Tuples may declare it alongside positional
+   * element schemas to require the presence of a specific element.
+   */
+  contains?: WalkedField;
 }
 interface RecordField extends FieldBase {
   type: "record";
@@ -233,12 +243,6 @@ interface FileField extends FieldBase {
   type: "file";
   constraints: FileConstraints;
 }
-interface RecursiveField extends FieldBase {
-  type: "recursive";
-  constraints: Record<string, never>;
-  /** The $ref string that would create the cycle (e.g. "#" or "#Node"). */
-  refTarget: string;
-}
 /** Schema position where `false` appears — the field cannot have any value. */
 interface NeverField extends FieldBase {
   type: "never";
@@ -252,7 +256,7 @@ interface UnknownField extends FieldBase {
  * Tagged union of all schema field types produced by the walker.
  * Use `field.type` to narrow to a specific variant.
  */
-type WalkedField = StringField | NumberField | BooleanField | NullField | EnumField | LiteralField | ObjectField | ArrayField | TupleField | RecordField | UnionField | DiscriminatedUnionField | ConditionalField | NegationField | RecursiveField | NeverField | FileField | UnknownField;
+type WalkedField = StringField | NumberField | BooleanField | NullField | EnumField | LiteralField | ObjectField | ArrayField | TupleField | RecordField | UnionField | DiscriminatedUnionField | ConditionalField | NegationField | NeverField | FileField | UnknownField;
 declare function isStringField(field: WalkedField): field is StringField;
 declare function isNumberField(field: WalkedField): field is NumberField;
 declare function isBooleanField(field: WalkedField): field is BooleanField;
@@ -268,8 +272,7 @@ declare function isDiscriminatedUnionField(field: WalkedField): field is Discrim
 declare function isConditionalField(field: WalkedField): field is ConditionalField;
 declare function isNegationField(field: WalkedField): field is NegationField;
 declare function isFileField(field: WalkedField): field is FileField;
-declare function isRecursiveField(field: WalkedField): field is RecursiveField;
 declare function isNeverField(field: WalkedField): field is NeverField;
 declare function isUnknownField(field: WalkedField): field is UnknownField;
 //#endregion
-export { UnionField as A, isNegationField as B, RecordField as C, StringConstraints as D, SchemaType as E, isConditionalField as F, isRecordField as G, isNullField as H, isDiscriminatedUnionField as I, isTupleField as J, isRecursiveField as K, isEnumField as L, WalkedField as M, isArrayField as N, StringField as O, isBooleanField as P, isFileField as R, ObjectField as S, SchemaMeta as T, isNumberField as U, isNeverField as V, isObjectField as W, isUnknownField as X, isUnionField as Y, resolveEditability as Z, NeverField as _, DiscriminatedUnionField as a, NumberField as b, FieldBase as c, FieldOverrides as d, FileConstraints as f, NegationField as g, LiteralField as h, ConditionalField as i, UnknownField as j, TupleField as k, FieldConstraints as l, JsonObject as m, ArrayField as n, Editability as o, FileField as p, isStringField as q, BooleanField as r, EnumField as s, ArrayConstraints as t, FieldOverride as u, NullField as v, RecursiveField as w, ObjectConstraints as x, NumberConstraints as y, isLiteralField as z };
+export { UnknownField as A, isNeverField as B, RecordField as C, StringField as D, StringConstraints as E, isDiscriminatedUnionField as F, isStringField as G, isNumberField as H, isEnumField as I, isUnknownField as J, isTupleField as K, isFileField as L, isArrayField as M, isBooleanField as N, TupleField as O, isConditionalField as P, isLiteralField as R, ObjectField as S, SchemaType as T, isObjectField as U, isNullField as V, isRecordField as W, resolveEditability as Y, NeverField as _, DiscriminatedUnionField as a, NumberField as b, FieldBase as c, FieldOverrides as d, FileConstraints as f, NegationField as g, LiteralField as h, ConditionalField as i, WalkedField as j, UnionField as k, FieldConstraints as l, JsonObject as m, ArrayField as n, Editability as o, FileField as p, isUnionField as q, BooleanField as r, EnumField as s, ArrayConstraints as t, FieldOverride as u, NullField as v, SchemaMeta as w, ObjectConstraints as x, NumberConstraints as y, isNegationField as z };

package/package.json

@@ -1,10 +1,8 @@
 {
     "name": "schema-components",
-    "version": "1.20.0",
+    "version": "1.22.0",
     "description": "React components that render UI from Zod schemas, JSON Schema, and OpenAPI documents",
     "type": "module",
-    "main": "./dist/index.mjs",
-    "types": "./dist/index.d.mts",
     "exports": {
         "./styles.css": "./dist/html/styles.css",
         "./core/*": {

package/dist/typeInference-CDoD_LZ_.d.mts

@@ -1,533 +0,0 @@
-import { d as FieldOverrides, u as FieldOverride } from "./types-C9zw9wbX.mjs";
-import { z } from "zod";
-
-//#region src/core/typeInference.d.ts
-/**
- * Zod 4 types that `z.toJSONSchema()` rejects at runtime because they
- * have no JSON Schema representation. The runtime adapter
- * (`packages/core/src/core/adapter.ts` lines 106-116) catches the
- * thrown error and surfaces it as a `SchemaNormalisationError` with
- * kind `zod-type-unrepresentable` — but the failure only happens on
- * first render. Statically rejecting these types at the props boundary
- * gives the same diagnostic at compile time.
- *
- * SOURCE-OF-TRUTH: list mirrors `UNREPRESENTABLE_ZOD_TYPES` in
- * `adapter.ts`. Add or remove entries here whenever the runtime list
- * changes.
- */
-type UnrepresentableZodType = z.ZodBigInt | z.ZodDate | z.ZodMap | z.ZodSet | z.ZodSymbol | z.ZodFunction | z.ZodUndefined | z.ZodVoid | z.ZodNaN | z.ZodCodec;
-/**
- * Brand returned in place of a rejected Zod input. The descriptive
- * literal is what TypeScript displays when the rejection fires, so
- * developers see why their schema is incompatible.
- */
-interface UnrepresentableZodSchemaError {
-  readonly __schemaComponentsError: "Zod 4 type has no JSON Schema representation. See SchemaNormalisationError code 'zod-type-unrepresentable'.";
-}
-/**
- * Reject Zod 4 inputs whose runtime conversion is known to throw.
- *
- * - When `T` is one of the {@link UnrepresentableZodType} variants, the
- *   resolved type is {@link UnrepresentableZodSchemaError}, which is
- *   not assignable from any legitimate Zod / JSON Schema / OpenAPI
- *   input — so the prop fails to typecheck.
- * - Anything else (Zod 4 schemas that DO convert, JSON Schema literals,
- *   OpenAPI documents, `unknown` for runtime inputs) passes through
- *   unchanged.
- *
- * Wrapped in a tuple to suppress distribution over union types.
- */
-type RejectUnrepresentableZod<T> = [T] extends [UnrepresentableZodType] ? UnrepresentableZodSchemaError : T;
-/**
- * Convert a readonly tuple/array of values to a union type.
- * Handles both `as const` readonly tuples and mutable arrays.
- */
-type ArrayToUnion<A> = A extends readonly unknown[] ? A[number] : never;
-/**
- * Maps a JSON Schema structure to a TypeScript type.
- * Works with `as const` literals -- provides full autocomplete for `fields`.
- *
- * Supports all JSON Schema draft versions (04-2020-12) and OpenAPI 3.x:
- * - Primitive types: string, number, integer, boolean, null
- * - type as array: `["string", "null"]` -> `string | null` (nullable)
- * - enum -> union of literal types
- * - const -> literal type
- * - object with properties/required -> specific object type
- * - object with additionalProperties -> Record<string, T>
- * - array with items -> T[]
- * - array with prefixItems -> tuple type
- * - allOf -> intersection type
- * - anyOf -> union type
- * - oneOf -> union type
- * - $ref -> resolved via $defs/definitions/$anchor context
- * - $dynamicRef -> resolved via $dynamicAnchor in definitions
- * - $recursiveRef -> unknown (recursive types not expressible in TS)
- * - if/then/else -> base schema (conditionals not expressible in TS)
- * - not -> unknown (negation not expressible in TS)
- * - patternProperties -> merged into loose index signature
- */
-type FromJSONSchema<S, Defs extends Record<string, unknown> = Record<string, never>> = S extends {
-  nullable: true;
-} ?
-/**
-* OpenAPI 3.0 `nullable: true` — surface the keyword wherever it
-* appears (not just inside `ResolveMaybeRef`). The runtime path
-* rewrites this to `anyOf: [T, { type: "null" }]` via
-* `normaliseOpenApi30Node` (`openapi30.ts`). Mirroring at the
-* `FromJSONSchema` level means nested fields inside refs preserve
-* nullability when resolved.
-*/
-FromJSONSchema<Omit<S, "nullable">, Defs> | null : S extends {
-  $ref: infer R extends string;
-} ? ResolveSchemaRef<R, Defs> : S extends {
-  $recursiveRef: string;
-} ? unknown : S extends {
-  $dynamicRef: infer R extends string;
-} ? ResolveSchemaRef<R, Defs> : S extends {
-  allOf: infer A;
-} ? AllOfToType<A, Defs> : S extends {
-  anyOf: infer A;
-} ? UnionOfMembers<A, Defs> : S extends {
-  oneOf: infer A;
-} ? UnionOfMembers<A, Defs> : S extends {
-  if: unknown;
-} ? FromJSONSchema<Omit<S, "if" | "then" | "else">, Defs> : S extends {
-  not: unknown;
-} ? unknown : S extends {
-  const: infer V;
-} ? V : S extends {
-  enum: infer E;
-} ? ArrayToUnion<E> : S extends {
-  type: infer T;
-} ? TypeToTs<T, S, Defs> : S extends readonly (infer E)[] ? E : unknown;
-/**
- * Marker type emitted when OpenAPI $ref resolution hits the type-level
- * recursion depth limit. Instead of silently falling back to
- * `Record<string, FieldOverride>`, produces this branded type so
- * consumers can detect it via conditional types.
- *
- * Usage:
- * ```ts
- * type Fields = InferRequestBodyFields<Doc, "/users", "post">;
- * type IsFallback = Fields extends __SchemaInferenceFellBack ? true : false;
- * ```
- */
-interface __SchemaInferenceFellBack {
-  readonly __schemaInferenceFallback: unique symbol;
-}
-/**
- * Escape hatch for recursive schemas where type-level inference
- * cannot proceed. Typed as `Record<string, FieldOverride>` but
- * explicitly branded so callers know they are using the unsafe path.
- *
- * JSDoc trade-off note: This bypasses field-level type safety.
- * Prefer restructuring the schema to avoid deep $ref chains
- * when possible.
- */
-type UnsafeFields = Record<string, FieldOverride> & {
-  /** Marks this as the unsafe fallback for recursive schemas. */readonly __unsafe?: true;
-};
-/**
- * Convert a `FromJSONSchema` result to `unknown` when recursion is detected.
- * Returns the original type when the schema is non-recursive.
- */
-type DetectRecursiveFallback<T> = unknown extends T ? __SchemaInferenceFellBack : T;
-/**
- * Type-level recursion bound for $ref resolution.
- *
- * The TypeScript type system imposes its own recursion limit; without an
- * explicit bound a cyclic schema graph would exhaust it and degrade to
- * `any`/`unknown` silently. Ten levels is the runtime walker's parallel
- * — see `countDistinctRefs` in `ref.ts` (lines 52-55), which derives its
- * bound from the number of distinct `$ref` strings in the document.
- *
- * A fixed bound is used here rather than a derived one because the type
- * system has no way to count distinct strings across a recursive `Defs`
- * map without itself recursing — which is the problem the bound exists
- * to solve. Ten covers every realistic schema graph encountered in
- * practice; deeper graphs surface as `__SchemaInferenceFellBack` so
- * consumers can detect the limit explicitly.
- */
-type DEFAULT_MAX_DEPTH = 10;
-/**
- * Resolve a $ref against the local definitions context.
- *
- * SOURCE-OF-TRUTH: mirrors runtime `resolveRef` in
- * `packages/core/src/core/ref.ts` (line 90). Any change to the runtime
- * ref-resolution rules (new ref forms, different cycle handling) must be
- * reflected here and pinned in
- * `packages/core/tests/typeInference-walker-parity.test.ts`.
- *
- * Supports:
- * - `#` (root)
- * - `#/$defs/Name` and `#/definitions/Name` (named definitions)
- * - `#/components/schemas/Name` (OpenAPI 3.x component schemas)
- * - `#SomeName` ($anchor, $dynamicAnchor resolved from definitions)
- *
- * `#/components/schemas/` is resolved here for parity with the runtime's
- * `dereference` (`ref.ts` line 217), which walks any `#/...` JSON Pointer
- * uniformly. When the runtime walker encounters an inline `$ref` inside
- * a Zod-converted or hand-written JSON Schema that points into the
- * OpenAPI component tree, this branch produces the corresponding type.
- */
-type ResolveSchemaRef<R extends string, Defs extends Record<string, unknown>, Depth extends number = 0> = Depth extends DEFAULT_MAX_DEPTH ? __SchemaInferenceFellBack : R extends "#" ? unknown : R extends `#/$defs/${infer Name}` ? Name extends keyof Defs ? DetectRecursiveFallback<FromJSONSchema<Defs[Name], Defs>> : unknown : R extends `#/definitions/${infer Name}` ? Name extends keyof Defs ? DetectRecursiveFallback<FromJSONSchema<Defs[Name], Defs>> : unknown : R extends `#/components/schemas/${infer Name}` ? Name extends keyof Defs ? DetectRecursiveFallback<FromJSONSchema<Defs[Name], Defs>> : unknown : R extends `#${infer AnchorName}` ? AnchorName extends keyof Defs ? DetectRecursiveFallback<FromJSONSchema<Defs[AnchorName], Defs>> : unknown : unknown;
-/**
- * Merge an allOf array into an intersection type.
- */
-type AllOfToType<A, Defs extends Record<string, unknown>> = A extends readonly unknown[] ? UnionToIntersection<FromJSONSchema<A[number], Defs>> : unknown;
-/**
- * Convert an anyOf/oneOf array into a union type.
- *
- * SOURCE-OF-TRUTH: mirrors runtime `walkUnion` (and the
- * `walkDiscriminatedUnion` fast path) in
- * `packages/core/src/core/walker.ts` (lines 723-752), together with
- * `detectDiscriminated` and `normaliseAnyOf` in
- * `packages/core/src/core/merge.ts` (lines 190-260).
- *
- * Deliberate divergence: the walker collapses qualifying `oneOf` members
- * into a `discriminatedUnion` field at runtime. The type-level helper
- * produces a plain TypeScript union because a discriminated union and a
- * plain union over the same members are structurally indistinguishable
- * at the type level. Parity is pinned in
- * `packages/core/tests/typeInference-walker-parity.test.ts`.
- *
- * Filters out `{ type: "null" }` members and instead makes the result
- * nullable when at least one null member is present — mirrors the
- * walker's `normaliseAnyOf`.
- */
-type UnionOfMembers<A, Defs extends Record<string, unknown>> = A extends readonly unknown[] ? HasNullMember<A> extends true ? Exclude<FromJSONSchema<A[number], Defs>, null> | null : FromJSONSchema<A[number], Defs> : unknown;
-/**
- * Check whether an anyOf/oneOf array contains a `{ type: "null" }` member.
- *
- * SOURCE-OF-TRUTH: mirrors runtime `normaliseAnyOf` in
- * `packages/core/src/core/merge.ts` (lines 190-209). Both implementations
- * only recognise schema-shaped null members (`{ type: "null" }`); a bare
- * `null` literal in the array is treated as non-nullable. Parity is
- * pinned in `packages/core/tests/typeInference-walker-parity.test.ts`.
- */
-type HasNullMember<A> = A extends readonly unknown[] ? null extends A[number] ? false : {
-  type: "null";
-} extends A[number] ? true : false : false;
-/**
- * Dispatch on a `type` value -- handles single types, type arrays,
- * and delegates to the appropriate type-specific resolver.
- */
-type TypeToTs<T, S, Defs extends Record<string, unknown>> = T extends "string" ? string : T extends "number" | "integer" ? number : T extends "boolean" ? boolean : T extends "null" ? null : T extends "array" ? ArraySchemaToTs<S, Defs> : T extends "object" ? ObjectSchemaToTs<S, Defs> : T extends readonly (infer E)[] ? TypeArrayToTs<E, S, Defs> : unknown;
-/**
- * Handle `type` as an array (Draft 04-07): `["string", "null"]`.
- * Filters out "null" and makes the result nullable.
- */
-type TypeArrayToTs<E, S, Defs extends Record<string, unknown>> = E extends "null" ? null : E extends "string" ? NullableResult<string, S> : E extends "number" | "integer" ? NullableResult<number, S> : E extends "boolean" ? NullableResult<boolean, S> : E extends "array" ? NullableResult<ArraySchemaToTs<OmitArrayHelpers<S>, Defs>, S> : E extends "object" ? NullableResult<ObjectSchemaToTs<OmitArrayHelpers<S>, Defs>, S> : unknown;
-/**
- * Make a type nullable if the original schema `type` array includes "null".
- * Detects nullable from the type array directly.
- */
-type NullableResult<Base, S> = S extends {
-  type: readonly (infer T)[];
-} ? "null" extends T ? Base | null : Base : Base;
-/**
- * Omit array-utility keys that interfere with object/array matching
- * when re-parsing a schema for a single type from a type array.
- */
-type OmitArrayHelpers<S> = Omit<S, "prefixItems" | "items" | "additionalProperties">;
-/**
- * Parse an array schema: prefixItems -> tuple, items -> T[], or unknown[].
- *
- * Draft 04 used tuple-form `items` (an array of schemas) for tuple typing;
- * Draft 2020-12 renamed this to `prefixItems`. The runtime normaliser in
- * `packages/core/src/core/normalise.ts` (lines 526-534) rewrites the legacy
- * form to `prefixItems` before the walker sees it. We mirror that rewrite
- * here so `as const` literals using the legacy form infer the same tuple
- * type at compile time.
- *
- * `contains` / `minContains` / `maxContains` constrain elements at runtime
- * but don't change the compile-time array element type.
- */
-type ArraySchemaToTs<S, Defs extends Record<string, unknown>> = S extends {
-  prefixItems: infer P;
-} ? PrefixItemsToTuple<P, Defs> : S extends {
-  items: infer I extends readonly unknown[];
-} ? PrefixItemsToTuple<I, Defs> : S extends {
-  items: infer I;
-} ? FromJSONSchema<I, Defs>[] : unknown[];
-/**
- * Convert a prefixItems array to a TypeScript tuple type.
- */
-type PrefixItemsToTuple<P, Defs extends Record<string, unknown>> = P extends readonly [infer First, ...infer Rest] ? [FromJSONSchema<First, Defs>, ...PrefixItemsToTuple<Rest, Defs>] : [];
-/**
- * Parse an object schema: properties + required -> specific object,
- * additionalProperties -> Record, or empty object.
- *
- * Handles:
- * - `properties` + `required` -> specific object type with required/optional keys
- * - `additionalProperties` as schema -> Record<string, T>
- * - `patternProperties` -> merged into a loose index signature alongside specific props
- *   (TypeScript cannot express regex-keyed properties)
- * - `propertyNames` -> ignored at type level (TS cannot validate key shapes)
- * - `dependentSchemas` / `dependentRequired` -> ignored (runtime-only conditionals)
- * - `unevaluatedProperties` -> ignored (runtime-only)
- */
-type ObjectSchemaToTs<S, Defs extends Record<string, unknown>> = S extends {
-  type: "object";
-  properties: infer P;
-} ? ExtractDefs<S, Defs> extends infer D extends Record<string, unknown> ? MergePatternProps<{ [K in keyof P as K extends RequiredKeysOf<S> ? K : never]: FromJSONSchema<P[K], D> } & { [K in keyof P as K extends RequiredKeysOf<S> ? never : K]?: FromJSONSchema<P[K], D> }, S, D> : never : S extends {
-  additionalProperties: infer V;
-} ? Record<string, FromJSONSchema<V, Defs>> : Record<string, unknown>;
-/**
- * If the schema has `patternProperties`, intersect the base object type
- * with a `Record<string, T>` index signature covering all pattern values.
- * If no `patternProperties`, return the base type unchanged.
- */
-type MergePatternProps<Base, S, Defs extends Record<string, unknown>> = S extends {
-  patternProperties: infer PP;
-} ? PP extends Record<string, unknown> ? Base & Record<string, UnionOfPatternValues<PP, Defs>> : Base : Base;
-/**
- * Extract the union of all pattern property value types.
- */
-type UnionOfPatternValues<PP extends Record<string, unknown>, Defs extends Record<string, unknown>> = { [K in keyof PP]: FromJSONSchema<PP[K], Defs> }[keyof PP];
-/**
- * Extract the `required` array from a schema as a union of string literals.
- * Handles both readonly `as const` arrays and mutable arrays.
- */
-type RequiredKeysOf<S> = S extends {
-  required: infer R;
-} ? R extends readonly string[] ? R[number] : never : never;
-/**
- * Extract $defs / definitions from a schema for $ref resolution context.
- * Also indexes schemas with `$anchor` or `$dynamicAnchor` by their anchor name,
- * enabling `#SomeName` ref resolution.
- * Merges with the existing Defs context from parent schemas.
- */
-type ExtractDefs<S, ParentDefs extends Record<string, unknown>> = ExtractRawDefs<S> extends infer RawDefs extends Record<string, unknown> ? RawDefs & ParentDefs & ExtractAnchors<RawDefs> : ParentDefs;
-/** Extract raw $defs / definitions maps. */
-type ExtractRawDefs<S> = S extends {
-  $defs: infer D;
-} ? D extends Record<string, unknown> ? D : Record<string, never> : S extends {
-  definitions: infer D;
-} ? D extends Record<string, unknown> ? D : Record<string, never> : Record<string, never>;
-/**
- * Build a map of `$anchor` name -> schema from a definitions block.
- * Scans each definition value for `$anchor`, `$dynamicAnchor`, or the
- * Draft 2019-09 `$recursiveAnchor` keyword and creates entries like
- * `{ Tree: <schema-with-$anchor-Tree> }`.
- *
- * SOURCE-OF-TRUTH: mirrors `normaliseDraft201909NodeWithContext` in
- * `packages/core/src/core/normalise.ts` (lines 638-650), which rewrites
- * `$recursiveAnchor: true` to `$anchor: "__recursive__"` and a string
- * `$recursiveAnchor: "name"` to `$anchor: "name"`. The corresponding
- * `$recursiveRef: "#"` therefore resolves through the same `Defs` map
- * as a modern `$ref: "#__recursive__"`.
- */
-type ExtractAnchors<D extends Record<string, unknown>> = { [K in keyof D as D[K] extends {
-  $anchor: infer A extends string;
-} ? A : D[K] extends {
-  $dynamicAnchor: infer A extends string;
-} ? A : D[K] extends {
-  $recursiveAnchor: infer A extends string;
-} ? A : D[K] extends {
-  $recursiveAnchor: true;
-} ? "__recursive__" : never]: D[K] };
-/**
- * Convert a union to an intersection.
- * `A | B` -> `A & B`. Used for allOf merging.
- */
-type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
-/**
- * Resolves an OpenAPI `ref` string to its JSON Schema, then parses it.
- *
- * SOURCE-OF-TRUTH: mirrors runtime `resolveRef` in
- * `packages/core/src/core/ref.ts` (line 90), which is invoked by the
- * walker entry point in `packages/core/src/core/walker.ts` (lines
- * 144-154) for OpenAPI documents. Any change to the runtime ref-resolution
- * rules (new ref forms, different cycle handling, JSON Pointer decoding)
- * must be reflected here and pinned in
- * `packages/core/tests/typeInference-walker-parity.test.ts`.
- *
- * Handles:
- * - `#/components/schemas/Name` (OpenAPI 3.x)
- * - `#/definitions/Name` (Swagger 2.0)
- * - `#/paths/...` (path-based refs, navigating the document tree)
- */
-type ResolveOpenAPIRef<Spec extends Record<string, unknown>, Ref extends string> = Ref extends `#/components/schemas/${infer Name}` ? Spec["components"] extends Record<string, unknown> ? Spec["components"]["schemas"] extends Record<string, unknown> ? Name extends keyof Spec["components"]["schemas"] ? FromJSONSchema<Spec["components"]["schemas"][Name]> : unknown : unknown : unknown : Ref extends `#/definitions/${infer Name}` ? Spec["definitions"] extends Record<string, unknown> ? Name extends keyof Spec["definitions"] ? FromJSONSchema<Spec["definitions"][Name]> : unknown : unknown : Ref extends `#/paths/${infer PathRest}` ? ResolvePathBasedRef<Spec, PathRest> : unknown;
-/**
- * Resolve a path-based $ref after the `#/paths/` prefix.
- * Splits on `/` and navigates the document tree, decoding JSON Pointer
- * tilde escapes (`~1` -> `/`, `~0` -> `~`) on every segment.
- *
- * SOURCE-OF-TRUTH: mirrors runtime `dereference` in
- * `packages/core/src/core/ref.ts` (line 226), which applies the same
- * `~1` -> `/`, `~0` -> `~` substitutions per RFC 6901 §4. The runtime
- * uses ordered string replacement; the type-level mirror does the same
- * via {@link DecodeJsonPointerSegment}.
- */
-type ResolvePathBasedRef<Spec extends Record<string, unknown>, PathRest extends string> = Spec["paths"] extends Record<string, unknown> ? ResolvePathSegments<Spec["paths"], SplitPath<PathRest>> : unknown;
-/**
- * Replace every occurrence of `From` with `To` inside `S`.
- *
- * Pure type-level alternative to `String.prototype.replaceAll` used for
- * JSON Pointer escape decoding. Terminates when no further match is
- * found in the tail.
- */
-type ReplaceAll<S extends string, From extends string, To extends string> = S extends `${infer Head}${From}${infer Tail}` ? `${Head}${To}${ReplaceAll<Tail, From, To>}` : S;
-/**
- * Decode a single JSON Pointer reference token per RFC 6901 §4:
- * apply `~1` -> `/` first, then `~0` -> `~`. The order matters — an
- * encoded `~` containing a literal `1` (e.g. `~01`) must remain `~1`
- * after decoding, which only works when `~1` is processed first.
- */
-type DecodeJsonPointerSegment<S extends string> = ReplaceAll<ReplaceAll<S, "~1", "/">, "~0", "~">;
-/**
- * Split a path string on `/` into a tuple of segments.
- * The first segment is the path key (may be empty for `/pets` -> `""` / `"pets"`).
- */
-type SplitPath<S extends string> = S extends `${infer Head}/${infer Tail}` ? [Head, ...SplitPath<Tail>] : [S];
-/**
- * Recursively navigate into a document object by path segments. Each
- * segment is JSON-Pointer-decoded before indexing so encoded forms such
- * as `~1pets` correctly resolve to the `"/pets"` key.
- */
-type ResolvePathSegments<Doc, Segs extends string[]> = Segs extends [infer Head extends string, ...infer Rest extends string[]] ? Doc extends Record<string, unknown> ? DecodeJsonPointerSegment<Head> extends infer Decoded extends string ? Rest extends [] ? Doc[Decoded] : ResolvePathSegments<Doc[Decoded], Rest> : unknown : unknown : unknown;
-/** Navigate to a path item in an OpenAPI document. */
-type PathItemOf<Doc, Path extends string> = Doc extends {
-  paths: Record<string, unknown>;
-} ? Path extends keyof Doc["paths"] ? Doc["paths"][Path] : unknown : unknown;
-/** Navigate to an operation within a path item. */
-type OperationOf<PathItem, Method extends string> = PathItem extends Record<string, unknown> ? Method extends keyof PathItem ? PathItem[Method] : unknown : unknown;
-/**
- * Extract the schema from request body content (any media type).
- *
- * `Record<string, { schema: infer S }>` already subsumes the previous
- * `application/json`-specific branch — if the JSON content matches the
- * specific shape it also matches the general index-signature pattern.
- * The narrower branch was therefore unreachable and has been removed.
- */
-type RequestBodySchemaOf<Op> = Op extends {
-  requestBody: {
-    content: Record<string, {
-      schema: infer S;
-    }>;
-  };
-} ? S : unknown;
-/**
- * Extract the schema from response content (any media type).
- *
- * Same rationale as `RequestBodySchemaOf`: the index-signature branch
- * subsumes the `application/json` branch, which was unreachable.
- */
-type ResponseSchemaOf<Op, Status extends string> = Op extends {
-  responses: Record<string, unknown>;
-} ? Status extends keyof Op["responses"] ? Op["responses"][Status] extends {
-  content: Record<string, {
-    schema: infer S;
-  }>;
-} ? S : unknown : unknown : unknown;
-/**
- * Resolve a schema that may be a `$ref` pointer.
- *
- * The `nullable: true` handling lives inside `FromJSONSchema` so it
- * applies uniformly to direct schemas, refs, and nested fields. This
- * helper only dispatches between ref-resolution and plain inference.
- */
-type ResolveMaybeRef<Doc, S> = S extends {
-  $ref: infer R extends string;
-} ? ResolveOpenAPIRef<Doc & Record<string, unknown>, R> : S extends Record<string, unknown> ? FromJSONSchema<S> : unknown;
-/** Extract parameter names from an operation. */
-type ParameterNamesOf<Doc, Path extends string, Method extends string> = OperationOf<PathItemOf<Doc, Path>, Method> extends {
-  parameters: readonly unknown[];
-} ? OperationOf<PathItemOf<Doc, Path>, Method>["parameters"][number] extends {
-  name: infer N;
-} ? N extends string ? N : never : never : never;
-/**
- * Detect whether a document is Swagger 2.0 (OpenAPI 2.0).
- *
- * SOURCE-OF-TRUTH: mirrors runtime `isSwagger2` in
- * `packages/core/src/core/version.ts`, which checks for `swagger: "2.0"`.
- * The runtime path also recognises top-level `definitions` / parameters in
- * the body location, but `swagger: "2.0"` is the canonical marker.
- *
- * Type-level Swagger 2.0 documents cannot be fully normalised at compile
- * time — the rewrite reorders the document tree (definitions →
- * components/schemas, body parameters → requestBody, etc.) in ways
- * TypeScript's mapped-type machinery cannot express. Detecting the
- * version is tractable, so we surface `__SchemaInferenceFellBack`
- * deliberately rather than silently producing `unknown`.
- */
-type IsSwagger2Doc<Doc> = Doc extends {
-  swagger: "2.0";
-} ? true : false;
-/**
- * Infer the TypeScript type of an OpenAPI operation's request body.
- *
- * Swagger 2.0 documents are not normalised at the type level. When the
- * input is Swagger 2.0, this returns `__SchemaInferenceFellBack` so
- * callers can detect the fallback explicitly via a conditional type.
- */
-type OpenAPIRequestBodyType<Doc, Path extends string, Method extends string> = IsSwagger2Doc<Doc> extends true ? __SchemaInferenceFellBack : ResolveMaybeRef<Doc, RequestBodySchemaOf<OperationOf<PathItemOf<Doc, Path>, Method>>>;
-/**
- * Infer the TypeScript type of an OpenAPI operation's response.
- *
- * Swagger 2.0 documents are not normalised at the type level. When the
- * input is Swagger 2.0, this returns `__SchemaInferenceFellBack` so
- * callers can detect the fallback explicitly via a conditional type.
- */
-type OpenAPIResponseType<Doc, Path extends string, Method extends string, Status extends string> = IsSwagger2Doc<Doc> extends true ? __SchemaInferenceFellBack : ResolveMaybeRef<Doc, ResponseSchemaOf<OperationOf<PathItemOf<Doc, Path>, Method>, Status>>;
-/**
- * Convert a resolved request/response type into the corresponding
- * `fields` prop type used by ApiRequestBody / ApiResponse:
- *
- * - `__SchemaInferenceFellBack` (Swagger 2.0, depth-exceeded refs) is
- *   preserved verbatim so callers can detect the brand.
- * - `unknown` (no schema found at the supplied path/status) falls back
- *   to the loose `Record<string, FieldOverride>` shape so runtime
- *   documents still typecheck.
- * - Any other concrete type is mapped through `FieldOverrides`.
- *
- * The brand check intentionally precedes the `unknown` check. The brand
- * is a structural object type and is therefore NOT assignable to
- * `unknown extends T` — checking that first would always short-circuit
- * to the loose `Record` fallback and the brand would never surface.
- */
-type FieldsFromInferred<T> = [T] extends [__SchemaInferenceFellBack] ? __SchemaInferenceFellBack : unknown extends T ? Record<string, FieldOverride> : FieldOverrides<T>;
-/**
- * Infer the fields prop type for ApiRequestBody.
- *
- * Surfaces `__SchemaInferenceFellBack` for Swagger 2.0 documents and
- * for schemas whose $ref chains exceed type-level depth limits. Falls
- * back to `Record<string, FieldOverride>` for runtime documents whose
- * shape cannot be inferred at compile time.
- */
-type InferRequestBodyFields<Doc, Path extends string, Method extends string> = FieldsFromInferred<OpenAPIRequestBodyType<Doc, Path, Method>>;
-/**
- * Infer the fields prop type for ApiResponse.
- *
- * Surfaces `__SchemaInferenceFellBack` for Swagger 2.0 documents and
- * for schemas whose $ref chains exceed type-level depth limits. Falls
- * back to `Record<string, FieldOverride>` for runtime documents whose
- * shape cannot be inferred at compile time.
- */
-type InferResponseFields<Doc, Path extends string, Method extends string, Status extends string> = FieldsFromInferred<OpenAPIResponseType<Doc, Path, Method, Status>>;
-/**
- * Infer the overrides prop type for ApiParameters.
- * Falls back to `Record<string, FieldOverride>` for runtime documents.
- */
-type InferParameterOverrides<Doc, Path extends string, Method extends string> = string extends ParameterNamesOf<Doc, Path, Method> ? Record<string, FieldOverride> : Partial<Record<ParameterNamesOf<Doc, Path, Method>, FieldOverride>>;
-/**
- * Check if T is a "narrow" type (not wide like object, Record, or unknown).
- * Used to determine if we can enumerate keys for path inference.
- */
-type IsNarrowObject<T> = T extends string | number | boolean | null | undefined | unknown[] ? false : T extends object ? Record<string, never> extends T ? false : true : false;
-/**
- * Extract all valid dot-separated paths from an object type.
- * Produces paths like "name" | "address.city" | "address.postcode".
- * Stops at leaf types (string, number, boolean, null) and arrays.
- * Returns `string` for wide types (object, Record, unknown).
- * Handles optional/nullable fields by unwrapping T | undefined.
- */
-type PathOfType<T, Prefix extends string = ""> = IsNarrowObject<T> extends true ? { [K in keyof T & string]: T[K] extends string | number | boolean | null | undefined ? `${Prefix}${K}` : T[K] extends unknown[] ? `${Prefix}${K}` : T[K] extends object | undefined ? PathOfType<Exclude<T[K], undefined>, `${Prefix}${K}.`> | `${Prefix}${K}` : `${Prefix}${K}` }[keyof T & string] : string;
-/**
- * Extract the type at a given dot-separated path.
- * PathOfType<T> produces valid paths; TypeAtPath resolves the leaf type.
- */
-type TypeAtPath<T, P extends string> = P extends `${infer Key}.${infer Rest}` ? Key extends keyof T ? TypeAtPath<T[Key], Rest> : unknown : P extends keyof T ? T[P] : unknown;
-//#endregion
-export { InferResponseFields as a, PathOfType as c, TypeAtPath as d, UnrepresentableZodSchemaError as f, __SchemaInferenceFellBack as h, InferRequestBodyFields as i, RejectUnrepresentableZod as l, UnsafeFields as m, FromJSONSchema as n, OpenAPIRequestBodyType as o, UnrepresentableZodType as p, InferParameterOverrides as r, OpenAPIResponseType as s, DEFAULT_MAX_DEPTH as t, ResolveOpenAPIRef as u };