schema-components 1.12.11 → 1.13.0

package/dist/themes/radix.d.mts

@@ -1,4 +1,4 @@
-import { b as ComponentResolver } from "../types-BJzEgJdX.mjs";
+import { r as ComponentResolver } from "../renderer-DseHeliw.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-DseHeliw.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-CRPqVwKu.d.mts

@@ -0,0 +1,299 @@
+import { d as FieldOverrides, u as FieldOverride } from "./types-ag2jYLqQ.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;
+/**
+ * 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>> = R extends "#" ? unknown : R extends `#/$defs/${infer Name}` ? Name extends keyof Defs ? FromJSONSchema<Defs[Name], Defs> : unknown : R extends `#/definitions/${infer Name}` ? Name extends keyof Defs ? FromJSONSchema<Defs[Name], Defs> : unknown : R extends `#${infer AnchorName}` ? AnchorName extends keyof Defs ? 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.
+ * Falls back to Record<string, FieldOverride> for runtime documents.
+ */
+type InferRequestBodyFields<Doc, Path extends string, Method extends string> = unknown extends OpenAPIRequestBodyType<Doc, Path, Method> ? Record<string, FieldOverride> : FieldOverrides<OpenAPIRequestBodyType<Doc, Path, Method>>;
+/**
+ * Infer the fields prop type for ApiResponse.
+ * 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> ? 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, InferResponseFields as i, TypeAtPath as l, InferParameterOverrides as n, OpenAPIResponseType as o, InferRequestBodyFields as r, PathOfType as s, FromJSONSchema as t };

package/dist/types-ag2jYLqQ.d.mts

@@ -0,0 +1,261 @@
+//#region src/core/types.d.ts
+/**
+ * Core types for schema-components.
+ *
+ * These types define the vocabulary shared between the schema walker,
+ * component resolver, and React components.
+ */
+/** A raw JSON object (JSON Schema or OpenAPI document). */
+type JsonObject = Record<string, unknown>;
+/**
+ * Metadata attached to schemas via `.meta()` or passed as props to
+ * `<SchemaComponent>`. Every field is also available as a top-level
+ * prop on `<SchemaComponent>` (with TypeScript-enforced exclusivity
+ * between prop and `meta`).
+ */
+interface SchemaMeta {
+  readOnly?: boolean;
+  writeOnly?: boolean;
+  description?: string;
+  title?: string;
+  deprecated?: boolean;
+  /** Component hint — resolved before theme adapter. */
+  component?: string;
+  /** Sort order for object fields. Lower values render first. */
+  order?: number;
+  /** Arbitrary UI hints passed through to theme adapters. */
+  [key: string]: unknown;
+}
+type Editability = "presentation" | "input" | "editable";
+/**
+ * Resolved editability state for a single field.
+ *
+ * Priority (highest wins):
+ * 1. Property-level readOnly → presentation
+ * 2. Property-level writeOnly → input
+ * 3. Component-level readOnly → presentation
+ * 4. Component-level writeOnly → input
+ * 5. Schema root readOnly → presentation
+ * 6. Schema root writeOnly → input
+ * 7. Neither → editable
+ */
+declare function resolveEditability(propertyMeta: SchemaMeta | undefined, componentMeta: SchemaMeta | undefined, rootMeta: SchemaMeta | undefined): Editability;
+/**
+ * Recursive mapped type that mirrors a schema's shape for per-field
+ * overrides. Each leaf accepts schema meta overrides and an optional
+ * per-field validation error callback. Objects recurse and also accept
+ * their own overrides.
+ */
+type FieldOverrides<T> = { [K in keyof T]?: T[K] extends object ? FieldOverrides<T[K]> & FieldOverride : FieldOverride };
+/**
+ * Per-field override. Extends SchemaMeta with rendering controls
+ * and a per-field validation error callback.
+ */
+type FieldOverride = Partial<SchemaMeta> & {
+  /** Called with the ZodError when this field fails validation. */onValidationError?: (error: unknown) => void; /** Hide this field when false. Defaults to true (visible). */
+  visible?: boolean;
+};
+/**
+ * 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" | "unknown";
+/** Constraints that apply to string schemas. */
+interface StringConstraints {
+  minLength?: number;
+  maxLength?: number;
+  pattern?: string;
+  format?: string;
+  contentEncoding?: string;
+  contentMediaType?: string;
+}
+/** Constraints that apply to number/integer schemas. */
+interface NumberConstraints {
+  minimum?: number;
+  maximum?: number;
+  exclusiveMinimum?: number;
+  exclusiveMaximum?: number;
+  multipleOf?: number;
+}
+/** Constraints that apply to array schemas. */
+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. */
+  unevaluatedItems?: Record<string, unknown>;
+}
+/** Constraints that apply to object schemas. */
+interface ObjectConstraints {
+  minProperties?: number;
+  maxProperties?: number;
+}
+/** Constraints that apply to file schemas. */
+interface FileConstraints {
+  mimeTypes?: string[];
+}
+/**
+ * Union of all constraint types. Renderers can narrow by checking
+ * the WalkedField's `type` discriminant.
+ */
+type FieldConstraints = StringConstraints | NumberConstraints | ArrayConstraints | ObjectConstraints | FileConstraints | Record<string, never>;
+/**
+ * Properties common to every WalkedField variant.
+ * The `type` field acts as the discriminant for the tagged union.
+ */
+interface FieldBase {
+  editability: Editability;
+  meta: SchemaMeta;
+  /** Whether the field is optional (not in `required`). */
+  isOptional?: boolean;
+  /** Whether the field is nullable (`anyOf [T, null]` or `type: ["...", "null"]`). */
+  isNullable?: boolean;
+  /** Default value from the schema's `default` keyword. */
+  defaultValue?: unknown;
+  /** Example values from the schema's `examples` keyword. */
+  examples?: unknown[];
+}
+interface StringField extends FieldBase {
+  type: "string";
+  constraints: StringConstraints;
+}
+interface NumberField extends FieldBase {
+  type: "number";
+  constraints: NumberConstraints;
+}
+interface BooleanField extends FieldBase {
+  type: "boolean";
+  constraints: Record<string, never>;
+}
+interface NullField extends FieldBase {
+  type: "null";
+  constraints: Record<string, never>;
+}
+interface EnumField extends FieldBase {
+  type: "enum";
+  constraints: Record<string, never>;
+  enumValues: (string | number | boolean | null)[];
+}
+interface LiteralField extends FieldBase {
+  type: "literal";
+  constraints: Record<string, never>;
+  literalValues: (string | number | boolean | null)[];
+}
+interface ObjectField extends FieldBase {
+  type: "object";
+  constraints: ObjectConstraints;
+  /** Map of property name → walked sub-schema. */
+  fields: Record<string, WalkedField>;
+  /** Property names declared in `required`. */
+  requiredFields: string[];
+  /** Regex-keyed sub-schemas from `patternProperties`. */
+  patternProperties?: Record<string, WalkedField>;
+  /** Whether `additionalProperties` is explicitly `false` (closed). */
+  additionalPropertiesClosed?: boolean;
+  /** Schema for additional properties when not `false` and not a Record. */
+  additionalPropertiesSchema?: WalkedField;
+  /** Property-presence-activated sub-schemas from `dependentSchemas`. */
+  dependentSchemas?: Record<string, WalkedField>;
+  /** Property-presence-conditional required fields from `dependentRequired`. */
+  dependentRequired?: Record<string, string[]>;
+  /** Constraint schema for unevaluated properties. */
+  unevaluatedProperties?: WalkedField;
+  /** Whether unevaluatedProperties is explicitly `false`. */
+  unevaluatedPropertiesClosed?: boolean;
+  /** Schema constraining property names (from `propertyNames`). */
+  propertyNames?: WalkedField;
+}
+interface ArrayField extends FieldBase {
+  type: "array";
+  constraints: ArrayConstraints;
+  /** The element sub-schema. */
+  element?: WalkedField;
+  /** Walked schema for unevaluated items. */
+  unevaluatedItems?: WalkedField;
+}
+interface TupleField extends FieldBase {
+  type: "tuple";
+  constraints: ArrayConstraints;
+  /** Positional element schemas from `prefixItems`. */
+  prefixItems: WalkedField[];
+}
+interface RecordField extends FieldBase {
+  type: "record";
+  constraints: ObjectConstraints;
+  /** Key name validation schema (from `propertyNames`). */
+  keyType: WalkedField;
+  /** Value schema (from `additionalProperties`). */
+  valueType: WalkedField;
+}
+interface UnionField extends FieldBase {
+  type: "union";
+  constraints: Record<string, never>;
+  /** The union options. */
+  options: WalkedField[];
+}
+interface DiscriminatedUnionField extends FieldBase {
+  type: "discriminatedUnion";
+  constraints: Record<string, never>;
+  /** The union options. */
+  options: WalkedField[];
+  /** Property name that discriminates between options. */
+  discriminator: string;
+}
+interface ConditionalField extends FieldBase {
+  type: "conditional";
+  constraints: Record<string, never>;
+  /** The `if` sub-schema. */
+  ifClause: WalkedField;
+  /** The `then` sub-schema. */
+  thenClause?: WalkedField;
+  /** The `else` sub-schema. */
+  elseClause?: WalkedField;
+}
+interface NegationField extends FieldBase {
+  type: "negation";
+  constraints: Record<string, never>;
+  /** The negated sub-schema. */
+  negated: WalkedField;
+}
+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;
+}
+interface UnknownField extends FieldBase {
+  type: "unknown";
+  constraints: Record<string, never>;
+}
+/**
+ * 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 | 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;
+declare function isNullField(field: WalkedField): field is NullField;
+declare function isEnumField(field: WalkedField): field is EnumField;
+declare function isLiteralField(field: WalkedField): field is LiteralField;
+declare function isObjectField(field: WalkedField): field is ObjectField;
+declare function isArrayField(field: WalkedField): field is ArrayField;
+declare function isTupleField(field: WalkedField): field is TupleField;
+declare function isRecordField(field: WalkedField): field is RecordField;
+declare function isUnionField(field: WalkedField): field is UnionField;
+declare function isDiscriminatedUnionField(field: WalkedField): field is DiscriminatedUnionField;
+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 isUnknownField(field: WalkedField): field is UnknownField;
+//#endregion
+export { UnknownField as A, isNullField as B, RecursiveField as C, StringField as D, StringConstraints as E, isDiscriminatedUnionField as F, isStringField as G, isObjectField 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, RecordField as S, SchemaType as T, isRecordField as U, isNumberField as V, isRecursiveField as W, resolveEditability as Y, NullField as _, DiscriminatedUnionField as a, ObjectConstraints 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, NumberConstraints as v, SchemaMeta as w, ObjectField as x, NumberField as y, isNegationField as z };

package/dist/version-CLchheaH.d.mts

@@ -0,0 +1,40 @@
+//#region src/core/version.d.ts
+/**
+ * JSON Schema draft and OpenAPI version detection.
+ *
+ * Detects the version from `$schema` URIs and OpenAPI `openapi`/`swagger`
+ * fields. Used by the normaliser to apply version-specific transformations
+ * before the walker processes the schema.
+ */
+type JsonSchemaDraft = "draft-04" | "draft-06" | "draft-07" | "draft-2019-09" | "draft-2020-12";
+/**
+ * Detect the JSON Schema draft version from a schema's `$schema` URI.
+ * Returns `"draft-2020-12"` as the default when `$schema` is absent —
+ * this is the most compatible assumption for modern schemas.
+ */
+declare function detectJsonSchemaDraft(schema: Record<string, unknown>): JsonSchemaDraft;
+interface OpenApiVersionInfo {
+  major: number;
+  minor: number;
+  patch: number;
+}
+/**
+ * Detect the OpenAPI/Swagger version from a document.
+ * Returns `undefined` for documents that are not OpenAPI or Swagger.
+ */
+declare function detectOpenApiVersion(doc: Record<string, unknown>): OpenApiVersionInfo | undefined;
+/**
+ * Check if an OpenAPI version is 3.0.x (uses modified Draft 04 schemas
+ * with `nullable` instead of `anyOf [T, null]`).
+ */
+declare function isOpenApi30(version: OpenApiVersionInfo): boolean;
+/**
+ * Check if an OpenAPI version is 3.1.x (uses standard Draft 2020-12).
+ */
+declare function isOpenApi31(version: OpenApiVersionInfo): boolean;
+/**
+ * Check if a document is Swagger 2.0.
+ */
+declare function isSwagger2(version: OpenApiVersionInfo): boolean;
+//#endregion
+export { isOpenApi30 as a, detectOpenApiVersion as i, OpenApiVersionInfo as n, isOpenApi31 as o, detectJsonSchemaDraft as r, isSwagger2 as s, JsonSchemaDraft as t };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "schema-components",
-    "version": "1.12.11",
+    "version": "1.13.0",
     "description": "React components that render UI from Zod schemas, JSON Schema, and OpenAPI documents",
     "type": "module",
     "main": "./dist/index.mjs",