schema-components 1.12.11 → 1.14.0

package/dist/types-D_5ST7SS.d.mts

@@ -0,0 +1,269 @@
+//#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" | "never" | "unknown";
+/** Constraints that apply to string schemas. */
+interface StringConstraints {
+  minLength?: number;
+  maxLength?: number;
+  pattern?: string;
+  format?: string;
+  /** Derived RegExp from the format string, if the format is recognised. */
+  formatPattern?: RegExp;
+  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;
+}
+/** Schema position where `false` appears — the field cannot have any value. */
+interface NeverField extends FieldBase {
+  type: "never";
+  constraints: Record<string, never>;
+}
+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 | 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;
+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 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 };

package/dist/version-B5NV-35j.d.mts

@@ -0,0 +1,69 @@
+//#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.
+ * When `$schema` is absent, uses heuristic keyword detection via
+ * `inferJsonSchemaDraft` to guess the draft version.
+ * Returns `"draft-2020-12"` as the final fallback when no heuristic
+ * matches either.
+ */
+declare function detectJsonSchemaDraft(schema: Record<string, unknown>): JsonSchemaDraft;
+/**
+ * Inference result carrying the detected draft and the heuristic
+ * that triggered it.
+ */
+interface InferredDraft {
+  draft: JsonSchemaDraft;
+  inferredFrom: string;
+}
+/**
+ * Infer the JSON Schema draft from keyword presence when `$schema`
+ * is absent. Examined from highest-confidence to lowest.
+ *
+ * Heuristics:
+ * 1. `$dynamicRef` / `$dynamicAnchor` / `prefixItems` → Draft 2020-12
+ * 2. `$recursiveRef` / `$recursiveAnchor` / `unevaluatedProperties` /
+ *    `dependentSchemas` → Draft 2019-09
+ * 3. `if` / `then` / `else`, `contentEncoding` / `contentMediaType` → Draft 07
+ * 4. `const`, `examples` (array), `propertyNames` → Draft 06
+ * 5. Boolean `exclusiveMinimum`, `id` (no `$`), `definitions` only → Draft 04
+ * 6. No signal → Draft 2020-12
+ */
+declare function inferJsonSchemaDraft(schema: Record<string, unknown>): JsonSchemaDraft;
+/**
+ * Like `inferJsonSchemaDraft` but also returns the heuristic that
+ * triggered the inference, for diagnostic emission.
+ */
+declare function inferJsonSchemaDraftWithReason(schema: Record<string, unknown>): InferredDraft;
+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 { detectOpenApiVersion as a, isOpenApi30 as c, detectJsonSchemaDraft as i, isOpenApi31 as l, JsonSchemaDraft as n, inferJsonSchemaDraft as o, OpenApiVersionInfo as r, inferJsonSchemaDraftWithReason as s, InferredDraft as t, isSwagger2 as u };

package/package.json

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

package/dist/types-BJzEgJdX.d.mts

@@ -1,335 +0,0 @@
-//#region src/core/renderer.d.ts
-/**
- * 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: FieldConstraints;
-  /** Dot-separated path from root (e.g. "address.city"). */
-  path: string;
-  /** For enums: the allowed values. */
-  enumValues?: string[];
-  /** For arrays: the element schema. */
-  element?: WalkedField;
-  /** 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;
-  /** 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;
-  record?: RenderFunction;
-  union?: RenderFunction;
-  discriminatedUnion?: 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;
-  record?: HtmlRenderFunction;
-  union?: HtmlRenderFunction;
-  discriminatedUnion?: HtmlRenderFunction;
-  literal?: HtmlRenderFunction;
-  file?: HtmlRenderFunction;
-  unknown?: HtmlRenderFunction;
-}
-declare const RESOLVER_KEYS: readonly ["string", "number", "boolean", "enum", "object", "array", "record", "union", "discriminatedUnion", "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
-//#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;
-};
-type SchemaType = "string" | "number" | "boolean" | "null" | "enum" | "literal" | "object" | "array" | "record" | "union" | "discriminatedUnion" | "optional" | "nullable" | "default" | "readonly" | "pipe" | "lazy" | "file" | "unknown";
-interface WalkedField {
-  type: SchemaType;
-  editability: Editability;
-  meta: SchemaMeta;
-  /** For objects: map of field name → WalkedField. */
-  fields?: Record<string, WalkedField>;
-  /** For arrays: the element schema. */
-  element?: WalkedField;
-  /** For enums: the allowed values. */
-  enumValues?: string[];
-  /** For unions/discriminated unions: the options. */
-  options?: WalkedField[];
-  discriminator?: string;
-  /** For records: key and value schemas. */
-  keyType?: WalkedField;
-  valueType?: WalkedField;
-  /** For literals: the literal value(s). */
-  literalValues?: (string | number | boolean | null)[];
-  /** Whether the field is optional. */
-  isOptional?: boolean;
-  /** Whether the field is nullable. */
-  isNullable?: boolean;
-  /** Default value if present on the schema. */
-  defaultValue?: unknown;
-  /** Constraints from Zod checks (min, max, pattern, etc.). */
-  constraints: FieldConstraints;
-}
-interface FieldConstraints {
-  minLength?: number;
-  maxLength?: number;
-  minimum?: number;
-  maximum?: number;
-  pattern?: string;
-  format?: string;
-  mimeTypes?: string[];
-  minItems?: number;
-  maxItems?: number;
-}
-/**
- * Maps a JSON Schema structure to a TypeScript type.
- * Works with `as const` literals — provides full autocomplete for `fields`.
- */
-type FromJSONSchema<S> = S extends {
-  type: "string";
-} ? string : S extends {
-  type: "number" | "integer";
-} ? number : S extends {
-  type: "boolean";
-} ? boolean : S extends {
-  type: "null";
-} ? null : S extends {
-  type: "array";
-  items: infer I;
-} ? FromJSONSchema<I>[] : S extends {
-  type: "object";
-  properties: infer P;
-  required?: infer R;
-} ? { [K in keyof P]: K extends R ? FromJSONSchema<P[K]> : FromJSONSchema<P[K]> | undefined } : unknown;
-/**
- * Resolves an OpenAPI `ref` string to its JSON Schema, then parses it.
- */
-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 `${string}/${string}` ? 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. */
-type RequestBodySchemaOf<Op> = Op extends {
-  requestBody: {
-    content: {
-      "application/json": {
-        schema: infer S;
-      };
-    };
-  };
-} ? S : Op extends {
-  requestBody: {
-    content: Record<string, {
-      schema: infer S;
-    }>;
-  };
-} ? S : unknown;
-/** Extract the schema from response content. */
-type ResponseSchemaOf<Op, Status extends string> = Op extends {
-  responses: Record<string, unknown>;
-} ? Status extends keyof Op["responses"] ? Op["responses"][Status] extends {
-  content: {
-    "application/json": {
-      schema: infer S;
-    };
-  };
-} ? S : Op["responses"][Status] extends {
-  content: Record<string, {
-    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 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 { mergeResolvers as A, HtmlResolver as C, getHtmlRenderFn as D, RenderProps as E, getRenderFunction as O, HtmlRenderProps as S, RenderFunction as T, WalkedField as _, FromJSONSchema as a, ComponentResolver as b, InferResponseFields as c, OpenAPIResponseType as d, PathOfType as f, TypeAtPath as g, SchemaType as h, FieldOverrides as i, typeToKey as j, mergeHtmlResolvers as k, JsonObject as l, SchemaMeta as m, FieldConstraints as n, InferParameterOverrides as o, ResolveOpenAPIRef as p, FieldOverride as r, InferRequestBodyFields as s, Editability as t, OpenAPIRequestBodyType as u, resolveEditability as v, RESOLVER_KEYS as w, HtmlRenderFunction as x, BaseFieldProps as y };