schema-components 1.28.2 → 2.0.0

package/dist/themes/shadcn.mjs

@@ -2,7 +2,7 @@ import { toRecord } from "../core/guards.mjs";
 import { sortFieldsByOrder } from "../core/fieldOrder.mjs";
 import { displayJsonValue } from "../core/walkBuilders.mjs";
 import { inputId, toReactNode } from "../react/headlessRenderers.mjs";
-import { headlessResolver } from "../react/headless.mjs";
+import { FieldShell } from "../react/fieldShell.mjs";
 import { jsx, jsxs } from "react/jsx-runtime";
 //#region src/themes/shadcn.tsx
 function isString(value) {
@@ -20,27 +20,23 @@ function renderStringInput(props) {
 		className: "text-sm",
 		children: strValue || "—"
 	});
-	if (props.writeOnly) return /* @__PURE__ */ jsx("input", {
-		id,
-		type: props.constraints.format === "email" ? "email" : "text",
-		className,
-		placeholder: typeof props.meta.description === "string" ? props.meta.description : void 0,
-		value: "",
-		onChange: (e) => {
-			props.onChange(e.target.value);
-		}
-	});
-	return /* @__PURE__ */ jsx("input", {
-		id,
-		type: props.constraints.format === "email" ? "email" : "text",
-		className,
-		value: strValue,
-		onChange: (e) => {
-			props.onChange(e.target.value);
-		},
-		placeholder: typeof props.meta.description === "string" ? props.meta.description : void 0,
-		minLength: props.constraints.minLength,
-		maxLength: props.constraints.maxLength
+	const placeholder = typeof props.meta.description === "string" ? props.meta.description : void 0;
+	return /* @__PURE__ */ jsx(FieldShell, {
+		props,
+		inputId: id,
+		children: (aria) => /* @__PURE__ */ jsx("input", {
+			id,
+			type: props.constraints.format === "email" ? "email" : "text",
+			className,
+			placeholder,
+			value: props.writeOnly ? "" : strValue,
+			onChange: (e) => {
+				props.onChange(e.target.value);
+			},
+			minLength: props.constraints.minLength,
+			maxLength: props.constraints.maxLength,
+			...aria
+		})
 	});
 }
 function renderNumberInput(props) {
@@ -58,16 +54,21 @@ function renderNumberInput(props) {
 			children: props.value.toLocaleString()
 		});
 	}
-	return /* @__PURE__ */ jsx("input", {
-		id,
-		type: "number",
-		className,
-		value: props.writeOnly ? "" : typeof props.value === "number" ? props.value : "",
-		onChange: (e) => {
-			props.onChange(Number(e.target.value));
-		},
-		min: props.constraints.minimum,
-		max: props.constraints.maximum
+	return /* @__PURE__ */ jsx(FieldShell, {
+		props,
+		inputId: id,
+		children: (aria) => /* @__PURE__ */ jsx("input", {
+			id,
+			type: "number",
+			className,
+			value: props.writeOnly ? "" : typeof props.value === "number" ? props.value : "",
+			onChange: (e) => {
+				props.onChange(Number(e.target.value));
+			},
+			min: props.constraints.minimum,
+			max: props.constraints.maximum,
+			...aria
+		})
 	});
 }
 function renderBooleanInput(props) {
@@ -85,14 +86,52 @@ function renderBooleanInput(props) {
 			children: props.value ? "Yes" : "No"
 		});
 	}
-	return /* @__PURE__ */ jsx("input", {
+	return /* @__PURE__ */ jsx(FieldShell, {
+		props,
+		inputId: id,
+		children: (aria) => /* @__PURE__ */ jsx("input", {
+			id,
+			type: "checkbox",
+			className,
+			checked: props.writeOnly ? false : props.value === true,
+			onChange: (e) => {
+				props.onChange(e.target.checked);
+			},
+			...aria
+		})
+	});
+}
+function renderEnumInput(props) {
+	const id = inputId(props.path);
+	const className = buildClassNames("flex h-9 w-full items-center justify-between rounded-md border border-input bg-transparent px-3 py-2 text-sm shadow-sm", "focus:outline-none focus:ring-1 focus:ring-ring", "disabled:cursor-not-allowed disabled:opacity-50");
+	const enumValue = typeof props.value === "string" ? props.value : "";
+	if (props.readOnly) return /* @__PURE__ */ jsx("span", {
 		id,
-		type: "checkbox",
-		className,
-		checked: props.writeOnly ? false : props.value === true,
-		onChange: (e) => {
-			props.onChange(e.target.checked);
-		}
+		className: "text-sm",
+		children: enumValue || "—"
+	});
+	return /* @__PURE__ */ jsx(FieldShell, {
+		props,
+		inputId: id,
+		children: (aria) => /* @__PURE__ */ jsxs("select", {
+			id,
+			className,
+			value: props.writeOnly ? "" : enumValue,
+			onChange: (e) => {
+				props.onChange(e.target.value);
+			},
+			...aria,
+			children: [/* @__PURE__ */ jsxs("option", {
+				value: "",
+				children: ["Select", "…"]
+			}), props.tree.type === "enum" ? props.tree.enumValues.map((v) => {
+				const display = displayJsonValue(v);
+				return /* @__PURE__ */ jsx("option", {
+					value: display,
+					children: display
+				}, display);
+			}) : null]
+		})
 	});
 }
 function renderObjectContainer(props) {
@@ -106,20 +145,15 @@ function renderObjectContainer(props) {
 			children: props.meta.description
 		}), sortFieldsByOrder(fields).map(([key, field]) => {
 			const childValue = toRecord(obj)[key];
-			const childId = inputId(`${props.path}.${key}`);
 			const childOnChange = (v) => {
 				const updated = {};
 				for (const [k, val] of Object.entries(obj)) updated[k] = val;
 				updated[key] = v;
 				props.onChange(updated);
 			};
-			return /* @__PURE__ */ jsxs("div", {
+			return /* @__PURE__ */ jsx("div", {
 				className: "space-y-1",
-				children: [/* @__PURE__ */ jsx("label", {
-					htmlFor: childId,
-					className: "text-sm font-medium leading-none",
-					children: field.meta.description ?? key
-				}), toReactNode(props.renderChild(field, childValue, childOnChange, key))]
+				children: toReactNode(props.renderChild(field, childValue, childOnChange, key))
 			}, key);
 		})]
 	});
@@ -141,50 +175,37 @@ function renderArrayContainer(props) {
 		})
 	});
 }
-function renderEnumInput(props) {
-	const id = inputId(props.path);
-	const className = buildClassNames("flex h-9 w-full items-center justify-between rounded-md border border-input bg-transparent px-3 py-2 text-sm shadow-sm", "focus:outline-none focus:ring-1 focus:ring-ring", "disabled:cursor-not-allowed disabled:opacity-50");
-	const enumValue = typeof props.value === "string" ? props.value : "";
-	if (props.readOnly) return /* @__PURE__ */ jsx("span", {
-		id,
-		className: "text-sm",
-		children: enumValue || "—"
-	});
-	return /* @__PURE__ */ jsxs("select", {
-		id,
-		className,
-		value: props.writeOnly ? "" : enumValue,
-		onChange: (e) => {
-			props.onChange(e.target.value);
-		},
-		children: [/* @__PURE__ */ jsxs("option", {
-			value: "",
-			children: ["Select", "…"]
-		}), props.tree.type === "enum" ? props.tree.enumValues.map((v) => {
-			const display = displayJsonValue(v);
-			return /* @__PURE__ */ jsx("option", {
-				value: display,
-				children: display
-			}, display);
-		}) : null]
-	});
-}
-function buildResolver() {
-	const resolver = {
-		string: renderStringInput,
-		number: renderNumberInput,
-		boolean: renderBooleanInput,
-		enum: renderEnumInput,
-		object: renderObjectContainer,
-		array: renderArrayContainer
-	};
-	if (headlessResolver.literal !== void 0) resolver.literal = headlessResolver.literal;
-	if (headlessResolver.union !== void 0) resolver.union = headlessResolver.union;
-	if (headlessResolver.record !== void 0) resolver.record = headlessResolver.record;
-	if (headlessResolver.file !== void 0) resolver.file = headlessResolver.file;
-	if (headlessResolver.unknown !== void 0) resolver.unknown = headlessResolver.unknown;
-	return resolver;
-}
-const shadcnResolver = buildResolver();
+/**
+* Component resolver mapping schema field types to shadcn/ui components.
+*
+* Pass to `SchemaProvider` to render every `<SchemaComponent>` /
+* `<SchemaView>` in the subtree with shadcn/ui inputs, selects, and
+* cards. Returns only the keys this theme overrides — the runtime
+* `mergeResolvers` call inside `<SchemaComponent>` / `<SchemaView>`
+* fills unset keys from `headlessResolver`, so variants like literal,
+* union, discriminatedUnion, record, file, and unknown still render via
+* the headless fallback.
+*
+* Requires `shadcn/ui` components installed in the consuming project.
+*
+* @group Themes
+* @example
+* ```tsx
+* import { SchemaProvider } from "schema-components/react/SchemaComponent";
+* import { shadcnResolver } from "schema-components/themes/shadcn";
+*
+* <SchemaProvider resolver={shadcnResolver}>
+*   <SchemaComponent schema={userSchema} value={user} onChange={setUser} />
+* </SchemaProvider>
+* ```
+*/
+const shadcnResolver = {
+	string: renderStringInput,
+	number: renderNumberInput,
+	boolean: renderBooleanInput,
+	enum: renderEnumInput,
+	object: renderObjectContainer,
+	array: renderArrayContainer
+};
 //#endregion
 export { shadcnResolver };

package/dist/{types-BTB73MB8.d.mts → types-BrYbjC7_.d.mts}

@@ -26,6 +26,12 @@ interface SchemaMeta {
   /** Arbitrary UI hints passed through to theme adapters. */
   [key: string]: unknown;
 }
+/**
+ * Resolved editability state for a walked field. `presentation` renders
+ * as a read-only value, `input` as a write-only input (e.g. password
+ * fields), `editable` as a full input that round-trips through
+ * `onChange`. Produced by {@link resolveEditability}.
+ */
 type Editability = "presentation" | "input" | "editable";
 /**
  * Resolved editability state for a single field.
@@ -124,6 +130,13 @@ interface StringField extends FieldBase {
 interface NumberField extends FieldBase {
   type: "number";
   constraints: NumberConstraints;
+  /**
+   * True when the underlying schema declared `type: "integer"` rather
+   * than `type: "number"`. Renderers consult this to set HTML
+   * `inputmode="numeric"` and `step="1"` (for whole-number editing)
+   * instead of `inputmode="decimal"`.
+   */
+  isInteger: boolean;
 }
 interface BooleanField extends FieldBase {
   type: "boolean";
@@ -285,22 +298,39 @@ interface UnknownField extends FieldBase {
  * 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 | NeverField | FileField | UnknownField;
+/** Type guard: narrows a `WalkedField` to its `string` variant. */
 declare function isStringField(field: WalkedField): field is StringField;
+/** Type guard: narrows a `WalkedField` to its `number` variant. */
 declare function isNumberField(field: WalkedField): field is NumberField;
+/** Type guard: narrows a `WalkedField` to its `boolean` variant. */
 declare function isBooleanField(field: WalkedField): field is BooleanField;
+/** Type guard: narrows a `WalkedField` to its `null` variant. */
 declare function isNullField(field: WalkedField): field is NullField;
+/** Type guard: narrows a `WalkedField` to its `enum` variant. */
 declare function isEnumField(field: WalkedField): field is EnumField;
+/** Type guard: narrows a `WalkedField` to its `literal` variant. */
 declare function isLiteralField(field: WalkedField): field is LiteralField;
+/** Type guard: narrows a `WalkedField` to its `object` variant. */
 declare function isObjectField(field: WalkedField): field is ObjectField;
+/** Type guard: narrows a `WalkedField` to its `array` variant. */
 declare function isArrayField(field: WalkedField): field is ArrayField;
+/** Type guard: narrows a `WalkedField` to its `tuple` variant. */
 declare function isTupleField(field: WalkedField): field is TupleField;
+/** Type guard: narrows a `WalkedField` to its `record` variant. */
 declare function isRecordField(field: WalkedField): field is RecordField;
+/** Type guard: narrows a `WalkedField` to its plain `union` variant. */
 declare function isUnionField(field: WalkedField): field is UnionField;
+/** Type guard: narrows a `WalkedField` to its `discriminatedUnion` variant. */
 declare function isDiscriminatedUnionField(field: WalkedField): field is DiscriminatedUnionField;
+/** Type guard: narrows a `WalkedField` to its `conditional` (if/then/else) variant. */
 declare function isConditionalField(field: WalkedField): field is ConditionalField;
+/** Type guard: narrows a `WalkedField` to its `negation` (`not`) variant. */
 declare function isNegationField(field: WalkedField): field is NegationField;
+/** Type guard: narrows a `WalkedField` to its `file` variant. */
 declare function isFileField(field: WalkedField): field is FileField;
+/** Type guard: narrows a `WalkedField` to its `never` variant (false schema). */
 declare function isNeverField(field: WalkedField): field is NeverField;
+/** Type guard: narrows a `WalkedField` to its `unknown` variant (permissive). */
 declare function isUnknownField(field: WalkedField): field is UnknownField;
 //#endregion
 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/dist/{version-ZzL5R6cS.d.mts → version-DL8U5RuA.d.mts}

@@ -49,6 +49,12 @@ declare function inferJsonSchemaDraft(schema: Record<string, unknown>): JsonSche
  * triggered the inference, for diagnostic emission.
  */
 declare function inferJsonSchemaDraftWithReason(schema: Record<string, unknown>): InferredDraft;
+/**
+ * Parsed OpenAPI version triple (e.g. `{ major: 3, minor: 1, patch: 0 }`).
+ * Produced by `detectOpenApiVersion` so downstream helpers can switch on
+ * the canonical numeric form rather than re-parsing the raw `openapi` /
+ * `swagger` string.
+ */
 interface OpenApiVersionInfo {
   major: number;
   minor: number;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "schema-components",
-    "version": "1.28.2",
+    "version": "2.0.0",
     "description": "React components that render UI from Zod schemas, JSON Schema, and OpenAPI documents",
     "type": "module",
     "exports": {
@@ -41,6 +41,7 @@
         "_test:coverage": "vitest run --project=unit --coverage",
         "_build": "tsdown && cp src/html/styles.css dist/html/styles.css",
         "_typedoc": "typedoc",
+        "_api-urls": "node scripts/build-api-urls.mjs",
         "_readme": "node scripts/build-readme-inventory.mjs",
         "typecheck": "turbo run _typecheck",
         "lint": "turbo run _lint",
@@ -51,6 +52,7 @@
         "validate": "turbo run _validate",
         "build": "turbo run _build",
         "typedoc": "turbo run _typedoc",
+        "api-urls": "turbo run _api-urls",
         "readme": "turbo run _readme"
     },
     "keywords": [
@@ -88,6 +90,9 @@
         "@vitest/coverage-v8": "4.1.5",
         "eslint": "10.3.0",
         "eslint-config-prettier": "10.1.8",
+        "eslint-plugin-import": "2.32.0",
+        "eslint-plugin-jsx-a11y": "6.10.2",
+        "eslint-plugin-no-only-tests": "3.4.0",
         "eslint-plugin-prettier": "5.5.5",
         "happy-dom": "20.9.0",
         "prettier": "3.8.3",
@@ -96,6 +101,8 @@
         "tsdown": "0.22.0",
         "tslib": "2.8.1",
         "typedoc": "0.28.19",
+        "typedoc-material-theme": "1.4.1",
+        "typedoc-plugin-mermaid": "1.12.0",
         "typedoc-plugin-missing-exports": "4.1.3",
         "typescript": "6.0.3",
         "typescript-eslint": "8.59.2",

package/dist/adapter-DqlAnZ_w.d.mts

@@ -1,172 +0,0 @@
-import { m as JsonObject, w as SchemaMeta } from "./types-BTB73MB8.mjs";
-import { i as DiagnosticsOptions } from "./diagnostics-Cbwak-ZX.mjs";
-
-//#region src/core/adapter.d.ts
-type SchemaInput = Record<string, unknown>;
-type SchemaKind = "zod4" | "zod3" | "jsonSchema" | "openapi" | "unsupported-schema-lib";
-/**
- * Classify the input schema by its structural markers.
- *
- * - `zod4` — has a `_zod` marker (further validation that `_zod.def` is a
- *   non-null object happens inside `normaliseZod4`).
- * - `zod3` — has `_def` and no `_zod`. The `typeName` field is no longer
- *   required: any `_def` without `_zod` is treated as a probable Zod 3
- *   schema. Third-party libraries that expose `_def` without `_zod` are
- *   nearly always Zod 3 forks; surfacing the migration message is the
- *   correct response.
- * - `openapi` — has `openapi` or `swagger` at the root.
- * - `unsupported-schema-lib` — has `parse` and `safeParse` callables but
- *   no `_zod` and no `_def` marker. This catches Standard Schema
- *   implementations (valibot, arktype, etc.) that would otherwise flow
- *   through as "malformed JSON Schema".
- * - `jsonSchema` — fallback for anything that does not match the above.
- */
-declare function detectSchemaKind(input: unknown): SchemaKind;
-/**
- * Wraps z.toJSONSchema() for a runtime-validated Zod schema.
- *
- * The _zod guard in normaliseZod4 has confirmed this is a valid Zod schema,
- * but TypeScript cannot represent "has _zod.def" as the $ZodType parameter
- * that z.toJSONSchema expects. This is the library boundary equivalent of
- * object → Record<string, unknown> — the type mismatch is genuinely unavoidable.
- *
- * # Options
- *
- * `z.toJSONSchema` is invoked with an explicit options object rather than
- * Zod's defaults so the conversion contract is pinned and stable:
- *
- * - `target: "draft-2020-12"` — matches the walker's draft target.
- * - `unrepresentable: "throw"` — keeps the unrepresentable-type rules in
- *   the classifier table firing instead of silently emitting `{}`.
- * - `cycles: "ref"` — converts cyclic graphs into $ref pairs rather than
- *   throwing. Cycles in user schemas surface through the walker's $ref
- *   resolution rather than the adapter.
- * - `io` — selects which side of every transform / pipe / codec is
- *   converted. Defaults to `"output"` (the OUTPUT side); pass `"input"`
- *   to render the INPUT side instead. The input side is invisible to
- *   the converted schema when `io: "output"` is in force, even though
- *   `safeParse` on the same Zod schema consumes the input shape. For
- *   transforms this divergence is fatal and the call throws via
- *   `Transforms cannot be represented`; for `z.codec(...)` the call
- *   succeeds but only the selected side is rendered. Consumers receive
- *   a `zod-codec-output-only` diagnostic in the codec case so the
- *   asymmetry is visible — see `screenPreConversion`.
- *
- * # Error classification
- *
- * Any exception thrown by z.toJSONSchema is classified into a
- * SchemaNormalisationError so the caller does not have to re-parse error
- * message strings. The classification covers:
- *
- * - Nested Zod 3 schemas inside a Zod 4 tree → zod3-unsupported.
- *   Detected structurally (presence of `_def.typeName` markers anywhere
- *   in the schema tree) so the check works across V8, JavaScriptCore,
- *   and SpiderMonkey, none of which agree on the wording of
- *   "Cannot read properties of undefined".
- * - Transforms → zod-transform-unsupported. This also catches `z.codec(…)`
- *   because Zod implements codecs as a pipe + transform internally, so
- * they trip the same processor when round-tripping is forced. (Plain
- *   `z.toJSONSchema(codec)` itself does NOT throw because Zod picks one
- *   side of the codec; the static rejection in `typeInference.ts` is the
- *   compile-time guard.)
- * - Dynamic catch values whose handler throws → zod-type-unrepresentable
- *   with zodType "dynamic-catch".
- * - Unrepresentable types — bigint, date, map, set, symbol, function, custom,
- *   undefined, void, NaN, and the literal-only forms `z.literal(undefined)`
- *   ("undefined-literal") and `z.literal(<bigint>)` ("bigint-literal") →
- *   zod-type-unrepresentable.
- * - The catch-all "Non-representable type encountered: <type>" fallback Zod
- *   emits for any new schema kind without a registered processor →
- *   zod-type-unrepresentable with zodType set to the offending def.type.
- * - Cycle detected (`cycles: "throw"`) → zod-cycle-detected.
- * - Duplicate schema id → zod-duplicate-id.
- * - "Unprocessed schema. This is a bug in Zod." → zod-conversion-bug.
- * - "Error converting schema to JSON." → zod-conversion-failed (explicit
- *   classification rather than the generic fallback so the contract test
- *   protects the prefix from drift).
- * - Anything else → zod-conversion-failed.
- *
- * The original error is preserved on each classified error via the `cause`
- * field so consumers can still inspect the Zod stack trace.
- */
-/**
- * IO side passed to the internal `callToJsonSchema` helper. The Zod runtime accepts
- * `"input" | "output"` for the corresponding `io` option on
- * `z.toJSONSchema`. Defaults to `"output"` everywhere in the adapter
- * pipeline; the parameter exists so a future renderer or component
- * (currently SchemaComponent — see TODO below) can request the input
- * side without forking the helper.
- */
-type SchemaIoSide = "input" | "output";
-/**
- * True when `value` is a Zod schema implemented as a codec
- * (`z.codec(...)`). Detection looks for the `$ZodCodec` marker on the
- * schema's `_zod.traits` Set — the same structural check used by Zod
- * itself in `to-json-schema.ts`'s `isTransforming` helper.
- *
- * Promoted from a duplicated local helper in `react/SchemaComponent.tsx`
- * so the validation boundary inside `runValidation` can branch on
- * codec-vs-not-codec without re-implementing the trait check. The
- * shared helper anchors a single source of truth for codec detection:
- * any future change to Zod's trait naming flows through here, not
- * through two parallel copies.
- *
- * Returns `false` for non-objects, plain JSON Schema inputs, OpenAPI
- * documents, or Zod schemas of any other kind. This is structural
- * rather than nominal — a Zod 4 codec produced by any path that ends
- * up tagging `_zod.traits` with `$ZodCodec` is recognised, including
- * schemas wrapped by user-defined helpers.
- */
-declare function isCodecSchema(value: unknown): boolean;
-/**
- * Exposed for unit testing — lets the contract test enumerate every rule's
- * `prefix` value and assert mutual non-prefixing.
- */
-declare const __CLASSIFIER_RULES_FOR_TEST: readonly {
-  readonly prefix: string;
-}[];
-interface NormalisedSchema {
-  /** JSON Schema object — the authoritative schema for rendering. */
-  jsonSchema: JsonObject;
-  /** Original Zod schema, if input was Zod. Used for validation. */
-  zodSchema?: unknown;
-  /** Root-level metadata. */
-  rootMeta: SchemaMeta | undefined;
-  /** The root document for $ref resolution. */
-  rootDocument: JsonObject;
-}
-interface NormaliseOptions {
-  /** Diagnostics channel for surfacing silent fallbacks. */
-  diagnostics?: DiagnosticsOptions;
-  /**
-   * Side of every transform / pipe / codec to render. Defaults to
-   * `"output"`, matching `z.toJSONSchema`'s default and the
-   * historic behaviour of the adapter. Passing `"input"` flips the
-   * conversion so consumers rendering the input shape of a
-   * `z.codec(...)` chain receive that side instead of the output
-   * side. Only the Zod 4 branch consults this option — JSON Schema
-   * and OpenAPI inputs are already a single canonical shape.
-   */
-  io?: SchemaIoSide;
-}
-declare function normaliseSchema(input: unknown, ref?: string, options?: NormaliseOptions): NormalisedSchema;
-/**
- * Surface root-level metadata from the JSON Schema into the `rootMeta`
- * shape consumed by the walker. Pulls `readOnly`, `writeOnly`,
- * `description`, `title`, `deprecated`, `examples`, and `default`
- * directly from the schema root.
- *
- * `examples` is forwarded only when present as an array (per JSON Schema
- * Draft 2020-12 — Draft 04's `example` singular is normalised upstream).
- * `default` is forwarded for any value the schema declares (any JSON
- * value, including `null` and `false`); the presence check uses `in`
- * so a literal `false` or `null` default is preserved.
- *
- * `examples` and `default` ride on the `[key: string]: unknown` index
- * signature of {@link SchemaMeta}. They are not declared as named fields
- * on `SchemaMeta` because that type lives in `types.ts` and is shared
- * with the walker; the index signature is the agreed extension point.
- */
-declare function extractRootMetaFromJson(jsonSchema: JsonObject): SchemaMeta | undefined;
-//#endregion
-export { SchemaKind as a, extractRootMetaFromJson as c, SchemaIoSide as i, isCodecSchema as l, NormalisedSchema as n, __CLASSIFIER_RULES_FOR_TEST as o, SchemaInput as r, detectSchemaKind as s, NormaliseOptions as t, normaliseSchema as u };