schema-components 1.12.11 → 1.14.0

package/dist/renderer-BdSqllx5.d.mts

@@ -0,0 +1,160 @@
+import { D as StringConstraints, M as WalkedField, T as SchemaMeta, f as FileConstraints, t as ArrayConstraints, x as ObjectConstraints, y as NumberConstraints } from "./types-D_5ST7SS.mjs";
+
+//#region src/core/renderer.d.ts
+/**
+ * Flat intersection of all constraint types.
+ * Used in renderer props where the render function receives the union
+ * but knows (by resolver key) which subset applies.
+ *
+ * The walker's discriminated WalkedField enforces type-correct constraints
+ * at construction time; the renderer consumes them as this flat type.
+ */
+type AllConstraints = StringConstraints & NumberConstraints & ArrayConstraints & ObjectConstraints & FileConstraints;
+/**
+ * Properties available on every schema field, regardless of rendering target.
+ * Both React and HTML renderers receive these.
+ */
+interface BaseFieldProps {
+  /** Current field value. */
+  value: unknown;
+  /** Whether to render as read-only display. */
+  readOnly: boolean;
+  /** Whether to render as an empty input. */
+  writeOnly: boolean;
+  /** Schema metadata for this field. */
+  meta: SchemaMeta;
+  /** Constraints from schema checks. */
+  constraints: AllConstraints;
+  /** Dot-separated path from root (e.g. "address.city"). */
+  path: string;
+  /** For enums: the allowed values. */
+  enumValues?: (string | number | boolean | null)[];
+  /** For arrays: the element schema. */
+  element?: WalkedField;
+  /** For tuples: positional element schemas from prefixItems. */
+  prefixItems?: WalkedField[];
+  /** For conditionals: the if/then/else sub-schemas. */
+  ifClause?: WalkedField;
+  thenClause?: WalkedField;
+  elseClause?: WalkedField;
+  /** For negations: the negated sub-schema. */
+  negated?: WalkedField;
+  /** For recursive fields: the $ref string that would create the cycle. */
+  refTarget?: string;
+  /** For objects: map of field name → WalkedField. */
+  fields?: Record<string, WalkedField>;
+  /** For unions: the option schemas. */
+  options?: WalkedField[];
+  /** For discriminated unions: the discriminator key. */
+  discriminator?: string;
+  /** For records: key and value schemas. */
+  keyType?: WalkedField;
+  valueType?: WalkedField;
+  /** For literals: the literal value(s). */
+  literalValues?: (string | number | boolean | null)[];
+  /** Example values from the schema's `examples` keyword. */
+  examples?: unknown[];
+  /** Walked field tree for recursive rendering. */
+  tree: WalkedField;
+}
+/**
+ * Props for React render functions. Extends BaseFieldProps with:
+ * - `onChange` — callback to propagate value changes back to state
+ * - `renderChild` — recursively renders a child field, threading onChange
+ */
+interface RenderProps extends BaseFieldProps {
+  /** Callback to update the field value. */
+  onChange: (value: unknown) => void;
+  /**
+   * Render a child field. Theme adapters call this to recursively render
+   * nested structures (object fields, array elements, union options).
+   * The resolver and rendering context are already wired in.
+   */
+  renderChild: (tree: WalkedField, value: unknown, onChange: (v: unknown) => void) => unknown;
+}
+/**
+ * Props for HTML render functions. Extends BaseFieldProps with:
+ * - `renderChild` — recursively renders a child field to HTML string
+ *
+ * No `onChange` — HTML rendering is pure output with no event handling.
+ */
+interface HtmlRenderProps extends BaseFieldProps {
+  /**
+   * Render a child field to an HTML string. Theme adapters call this
+   * to recursively render nested structures.
+   *
+   * @param tree - The walked field tree for the child
+   * @param value - The child's current value
+   * @param pathSuffix - Path segment from the parent (e.g. "city",
+   *   "[0]"). When omitted, the child's description is used as fallback.
+   */
+  renderChild: (tree: WalkedField, value: unknown, pathSuffix?: string) => string;
+}
+type RenderFunction = (props: RenderProps) => unknown;
+interface ComponentResolver {
+  string?: RenderFunction;
+  number?: RenderFunction;
+  boolean?: RenderFunction;
+  enum?: RenderFunction;
+  object?: RenderFunction;
+  array?: RenderFunction;
+  tuple?: RenderFunction;
+  record?: RenderFunction;
+  union?: RenderFunction;
+  discriminatedUnion?: RenderFunction;
+  conditional?: RenderFunction;
+  negation?: RenderFunction;
+  recursive?: RenderFunction;
+  literal?: RenderFunction;
+  file?: RenderFunction;
+  unknown?: RenderFunction;
+}
+/** An HTML render function returns a string. */
+type HtmlRenderFunction = (props: HtmlRenderProps) => string;
+/**
+ * HTML resolver — maps schema types to HTML string renderers.
+ * Structurally mirrors ComponentResolver but produces strings.
+ */
+interface HtmlResolver {
+  string?: HtmlRenderFunction;
+  number?: HtmlRenderFunction;
+  boolean?: HtmlRenderFunction;
+  enum?: HtmlRenderFunction;
+  object?: HtmlRenderFunction;
+  array?: HtmlRenderFunction;
+  tuple?: HtmlRenderFunction;
+  record?: HtmlRenderFunction;
+  union?: HtmlRenderFunction;
+  discriminatedUnion?: HtmlRenderFunction;
+  conditional?: HtmlRenderFunction;
+  negation?: HtmlRenderFunction;
+  recursive?: HtmlRenderFunction;
+  literal?: HtmlRenderFunction;
+  file?: HtmlRenderFunction;
+  unknown?: HtmlRenderFunction;
+}
+declare const RESOLVER_KEYS: readonly ["string", "number", "boolean", "enum", "object", "array", "tuple", "record", "union", "discriminatedUnion", "conditional", "negation", "recursive", "literal", "file", "unknown"];
+type ResolverKey = (typeof RESOLVER_KEYS)[number];
+/**
+ * Map a schema type to the resolver key that handles it.
+ * `discriminatedUnion` → `union`. Unknown types → `unknown`.
+ */
+declare function typeToKey(type: WalkedField["type"]): ResolverKey;
+/**
+ * Look up the render function for a schema type in a ComponentResolver.
+ */
+declare function getRenderFunction(type: WalkedField["type"], resolver: ComponentResolver): RenderFunction | undefined;
+/**
+ * Look up the render function for a schema type in an HtmlResolver.
+ */
+declare function getHtmlRenderFn(type: WalkedField["type"], resolver: HtmlResolver): HtmlRenderFunction | undefined;
+/**
+ * Merge two ComponentResolvers — user values take priority, fallback fills gaps.
+ */
+declare function mergeResolvers(user: ComponentResolver, fallback: ComponentResolver): ComponentResolver;
+/**
+ * Merge two HtmlResolvers — user values take priority, fallback fills gaps.
+ */
+declare function mergeHtmlResolvers(user: HtmlResolver, fallback: HtmlResolver): HtmlResolver;
+//#endregion
+export { HtmlRenderProps as a, RenderFunction as c, getRenderFunction as d, mergeHtmlResolvers as f, HtmlRenderFunction as i, RenderProps as l, typeToKey as m, BaseFieldProps as n, HtmlResolver as o, mergeResolvers as p, ComponentResolver as r, RESOLVER_KEYS as s, AllConstraints as t, getHtmlRenderFn as u };

package/dist/themes/mantine.d.mts

@@ -1,4 +1,4 @@
-import { b as ComponentResolver } from "../types-BJzEgJdX.mjs";
+import { r as ComponentResolver } from "../renderer-BdSqllx5.mjs";
 
 //#region src/themes/mantine.d.ts
 /**

package/dist/themes/mantine.mjs

@@ -1,5 +1,6 @@
 import { isObject } from "../core/guards.mjs";
-import { headlessResolver, toReactNode } from "../react/headless.mjs";
+import { toReactNode } from "../react/headlessRenderers.mjs";
+import { headlessResolver } from "../react/headless.mjs";
 import { jsx } from "react/jsx-runtime";
 //#region src/themes/mantine.tsx
 function getLabel(props) {

package/dist/themes/mui.d.mts

@@ -1,4 +1,4 @@
-import { b as ComponentResolver } from "../types-BJzEgJdX.mjs";
+import { r as ComponentResolver } from "../renderer-BdSqllx5.mjs";
 
 //#region src/themes/mui.d.ts
 /**

package/dist/themes/mui.mjs

@@ -1,7 +1,8 @@
 import { isObject } from "../core/guards.mjs";
-import { headlessResolver, toReactNode } from "../react/headless.mjs";
-import { isValidElement } from "react";
+import { toReactNode } from "../react/headlessRenderers.mjs";
+import { headlessResolver } from "../react/headless.mjs";
 import { jsx, jsxs } from "react/jsx-runtime";
+import { isValidElement } from "react";
 //#region src/themes/mui.tsx
 function ariaRequired(tree) {
 	return { required: tree.isOptional === false };

package/dist/themes/radix.d.mts

@@ -1,4 +1,4 @@
-import { b as ComponentResolver } from "../types-BJzEgJdX.mjs";
+import { r as ComponentResolver } from "../renderer-BdSqllx5.mjs";
 
 //#region src/themes/radix.d.ts
 /**

package/dist/themes/radix.mjs

@@ -1,5 +1,6 @@
 import { isObject } from "../core/guards.mjs";
-import { headlessResolver, toReactNode } from "../react/headless.mjs";
+import { toReactNode } from "../react/headlessRenderers.mjs";
+import { headlessResolver } from "../react/headless.mjs";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 //#region src/themes/radix.tsx
 function getLabel(props) {

package/dist/themes/shadcn.d.mts

@@ -1,4 +1,4 @@
-import { b as ComponentResolver } from "../types-BJzEgJdX.mjs";
+import { r as ComponentResolver } from "../renderer-BdSqllx5.mjs";
 
 //#region src/themes/shadcn.d.ts
 declare const shadcnResolver: ComponentResolver;

package/dist/themes/shadcn.mjs

@@ -1,5 +1,6 @@
 import { toRecord } from "../core/guards.mjs";
-import { headlessResolver, toReactNode } from "../react/headless.mjs";
+import { toReactNode } from "../react/headlessRenderers.mjs";
+import { headlessResolver } from "../react/headless.mjs";
 import { jsx, jsxs } from "react/jsx-runtime";
 //#region src/themes/shadcn.tsx
 function isString(value) {
@@ -138,11 +139,14 @@ function renderEnumInput(props) {
 		},
 		children: [/* @__PURE__ */ jsx("option", {
 			value: "",
-			children: "Select…"
-		}), props.enumValues?.map((v) => /* @__PURE__ */ jsx("option", {
-			value: v,
-			children: v
-		}, v))]
+			children: "Select\\u2026"
+		}), props.enumValues?.map((v) => {
+			const display = v === null ? "null" : typeof v === "string" ? v : String(v);
+			return /* @__PURE__ */ jsx("option", {
+				value: display,
+				children: display
+			}, display);
+		})]
 	});
 }
 function buildResolver() {

package/dist/typeInference-k7FXfTVO.d.mts

@@ -0,0 +1,335 @@
+import { d as FieldOverrides, u as FieldOverride } from "./types-D_5ST7SS.mjs";
+
+//#region src/core/typeInference.d.ts
+/**
+ * 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 {
+  $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;
+/**
+ * Resolve a $ref against the local definitions context.
+ * Supports:
+ * - `#` (root)
+ * - `#/$defs/Name` and `#/definitions/Name` (named definitions)
+ * - `#SomeName` ($anchor, $dynamicAnchor resolved from definitions)
+ */
+type ResolveSchemaRef<R extends string, Defs extends Record<string, unknown>, Depth extends number = 0> = Depth extends 10 ? __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 `#${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.
+ * 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.
+ */
+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[].
+ *
+ * `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;
+} ? 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` or `$dynamicAnchor` and
+ * creates entries like `{ Tree: <schema-with-$anchor-Tree> }`.
+ */
+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 : 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.
+ *
+ * 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.
+ *
+ * Note: JSON Pointer tilde encoding (~1 for /, ~0 for ~) is not decoded
+ * at the type level. For `as const` literals, use the literal path
+ * character directly (e.g. `#/paths//pets/get/...`).
+ */
+type ResolvePathBasedRef<Spec extends Record<string, unknown>, PathRest extends string> = Spec["paths"] extends Record<string, unknown> ? ResolvePathSegments<Spec["paths"], SplitPath<PathRest>> : unknown;
+/**
+ * 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.
+ */
+type ResolvePathSegments<Doc, Segs extends string[]> = Segs extends [infer Head extends string, ...infer Rest extends string[]] ? Doc extends Record<string, unknown> ? Rest extends [] ? Doc[Head] : ResolvePathSegments<Doc[Head], Rest> : 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). */
+type RequestBodySchemaOf<Op> = Op extends {
+  requestBody: {
+    content: Record<string, {
+      schema: infer S;
+    }>;
+  };
+} ? S : Op extends {
+  requestBody: {
+    content: {
+      "application/json": {
+        schema: infer S;
+      };
+    };
+  };
+} ? S : unknown;
+/** Extract the schema from response content (any media type). */
+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 : Op["responses"][Status] extends {
+  content: {
+    "application/json": {
+      schema: infer S;
+    };
+  };
+} ? S : unknown : unknown : unknown;
+/** Resolve a schema that may be a $ref pointer. */
+type ResolveMaybeRef<Doc, S> = S extends {
+  $ref: infer R extends string;
+} ? ResolveOpenAPIRef<Doc & Record<string, unknown>, R> : S extends {
+  nullable: true;
+} & Record<string, unknown> ? FromJSONSchema<Omit<S, "nullable">> | null : 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;
+/**
+ * Infer the TypeScript type of an OpenAPI operation's request body.
+ */
+type OpenAPIRequestBodyType<Doc, Path extends string, Method extends string> = ResolveMaybeRef<Doc, RequestBodySchemaOf<OperationOf<PathItemOf<Doc, Path>, Method>>>;
+/**
+ * Infer the TypeScript type of an OpenAPI operation's response.
+ */
+type OpenAPIResponseType<Doc, Path extends string, Method extends string, Status extends string> = ResolveMaybeRef<Doc, ResponseSchemaOf<OperationOf<PathItemOf<Doc, Path>, Method>, Status>>;
+/**
+ * Infer the fields prop type for ApiRequestBody.
+ * Surfaces `__SchemaInferenceFellBack` when the schema contains
+ * recursive $ref chains that exceed type-level depth limits.
+ * Falls back to `Record<string, FieldOverride>` for runtime documents.
+ */
+type InferRequestBodyFields<Doc, Path extends string, Method extends string> = unknown extends OpenAPIRequestBodyType<Doc, Path, Method> ? OpenAPIRequestBodyType<Doc, Path, Method> extends __SchemaInferenceFellBack ? __SchemaInferenceFellBack : Record<string, FieldOverride> : FieldOverrides<OpenAPIRequestBodyType<Doc, Path, Method>>;
+/**
+ * Infer the fields prop type for ApiResponse.
+ * Surfaces `__SchemaInferenceFellBack` when the schema contains
+ * recursive $ref chains that exceed type-level depth limits.
+ * Falls back to `Record<string, FieldOverride>` for runtime documents.
+ */
+type InferResponseFields<Doc, Path extends string, Method extends string, Status extends string> = unknown extends OpenAPIResponseType<Doc, Path, Method, Status> ? OpenAPIResponseType<Doc, Path, Method, Status> extends __SchemaInferenceFellBack ? __SchemaInferenceFellBack : Record<string, FieldOverride> : FieldOverrides<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 { OpenAPIRequestBodyType as a, ResolveOpenAPIRef as c, __SchemaInferenceFellBack as d, InferResponseFields as i, TypeAtPath as l, InferParameterOverrides as n, OpenAPIResponseType as o, InferRequestBodyFields as r, PathOfType as s, FromJSONSchema as t, UnsafeFields as u };