schema-components 1.18.1 → 1.19.0

package/dist/openapi/components.mjs

@@ -184,6 +184,10 @@ function OperationHeader({ operation }) {
 			operation.path
 		] }),
 		operation.summary && /* @__PURE__ */ jsx("p", { children: operation.summary }),
+		operation.description && /* @__PURE__ */ jsx("p", {
+			"data-description": true,
+			children: operation.description
+		}),
 		operation.deprecated && /* @__PURE__ */ jsx("span", {
 			"data-deprecated": true,
 			children: "Deprecated"

package/dist/openapi/parser.mjs

@@ -33,7 +33,10 @@ const METHODS = [
 	"post",
 	"put",
 	"patch",
-	"delete"
+	"delete",
+	"head",
+	"options",
+	"trace"
 ];
 /**
 * Resolve a path item, following a `$ref` to `components/pathItems/<Name>`

package/dist/openapi/resolve.d.mts

@@ -7,11 +7,12 @@ import { OpenApiDocument, OperationInfo, ParameterInfo, ResponseInfo, getRequest
  *
  * Before parsing, the document is run through the version-aware
  * normalisation pipeline (`normaliseOpenApiSchemas`) so OpenAPI 3.0.x
- * keywords (`nullable`, `discriminator`, `example`) and Swagger 2.0
- * documents are converted to canonical Draft 2020-12 form. The parser
- * and downstream extractors (`getRequestBody`, `getResponses`, etc.) then
- * observe schemas in the same form `<SchemaComponent>` does, keeping the
- * OpenAPI components on the same pipeline as the top-level adapter.
+ * keywords (`nullable`, `discriminator`, `example`), OpenAPI 3.1.x
+ * `discriminator`, and Swagger 2.0 documents are all converted to
+ * canonical Draft 2020-12 form. The parser and downstream extractors
+ * (`getRequestBody`, `getResponses`, etc.) then observe schemas in the
+ * same form `<SchemaComponent>` does, keeping the OpenAPI components on
+ * the same pipeline as the top-level adapter.
  *
  * The cache is keyed by the caller-supplied document so subsequent calls
  * with the same input bypass both normalisation and parsing.

package/dist/openapi/resolve.mjs

@@ -1,6 +1,6 @@
 import { isObject } from "../core/guards.mjs";
 import { detectOpenApiVersion } from "../core/version.mjs";
-import { i as normaliseOpenApiSchemas } from "../normalise-tL9FckAk.mjs";
+import { a as normaliseOpenApiSchemas } from "../normalise-C0ofw3W6.mjs";
 import { getParameters, getRequestBody, getResponses, listOperations, parseOpenApiDocument } from "./parser.mjs";
 //#region src/openapi/resolve.ts
 /**
@@ -17,11 +17,12 @@ const docCache = /* @__PURE__ */ new WeakMap();
 *
 * Before parsing, the document is run through the version-aware
 * normalisation pipeline (`normaliseOpenApiSchemas`) so OpenAPI 3.0.x
-* keywords (`nullable`, `discriminator`, `example`) and Swagger 2.0
-* documents are converted to canonical Draft 2020-12 form. The parser
-* and downstream extractors (`getRequestBody`, `getResponses`, etc.) then
-* observe schemas in the same form `<SchemaComponent>` does, keeping the
-* OpenAPI components on the same pipeline as the top-level adapter.
+* keywords (`nullable`, `discriminator`, `example`), OpenAPI 3.1.x
+* `discriminator`, and Swagger 2.0 documents are all converted to
+* canonical Draft 2020-12 form. The parser and downstream extractors
+* (`getRequestBody`, `getResponses`, etc.) then observe schemas in the
+* same form `<SchemaComponent>` does, keeping the OpenAPI components on
+* the same pipeline as the top-level adapter.
 *
 * The cache is keyed by the caller-supplied document so subsequent calls
 * with the same input bypass both normalisation and parsing.

package/dist/react/SchemaComponent.d.mts

@@ -1,7 +1,7 @@
 import { M as WalkedField, T as SchemaMeta, d as FieldOverrides, u as FieldOverride } from "../types-D_5ST7SS.mjs";
-import { t as Diagnostic } from "../diagnostics-BYk63jsC.mjs";
-import { t as SchemaError } from "../errors-C5zRC2PU.mjs";
-import { l as RenderProps, r as ComponentResolver } from "../renderer-BAGoX4AK.mjs";
+import { t as Diagnostic } from "../diagnostics-VgEKI_Ct.mjs";
+import { t as SchemaError } from "../errors-CnGjT1cg.mjs";
+import { l as RenderProps, r as ComponentResolver } from "../renderer-BQqiXUYP.mjs";
 import { c as PathOfType, l as ResolveOpenAPIRef, n as FromJSONSchema } from "../typeInference-5JiqIZ8t.mjs";
 import { z } from "zod";
 import * as _$react_jsx_runtime0 from "react/jsx-runtime";

package/dist/react/SchemaComponent.mjs

@@ -78,7 +78,7 @@ function SchemaComponent({ schema: schemaInput, ref: refInput, value, onChange,
 		rootMeta = normalised.rootMeta;
 		rootDocument = normalised.rootDocument;
 	} catch (err) {
-		const error = new SchemaNormalisationError(err instanceof Error ? err.message : "Failed to normalise schema", schemaInput, detectNormalisationKind(err));
+		const error = err instanceof SchemaNormalisationError ? err : new SchemaNormalisationError(err instanceof Error ? err.message : "Failed to normalise schema", schemaInput, "unknown");
 		if (onError !== void 0) {
 			onError(error);
 			return null;
@@ -218,7 +218,8 @@ function SchemaField({ path, schema: schemaInput, ref: refInput, value, onChange
 		rootMeta = normalised.rootMeta;
 		rootDocument = normalised.rootDocument;
 	} catch (err) {
-		throw new SchemaNormalisationError(err instanceof Error ? err.message : "Failed to normalise schema", schemaInput, detectNormalisationKind(err));
+		if (err instanceof SchemaNormalisationError) throw err;
+		throw new SchemaNormalisationError(err instanceof Error ? err.message : "Failed to normalise schema", schemaInput, "unknown");
 	}
 	const fieldTree = resolvePath(walk(jsonSchema, {
 		componentMeta: fieldMeta,
@@ -284,16 +285,5 @@ function isFieldErrorCallback(value) {
 function isCallable(value) {
 	return typeof value === "function";
 }
-function detectNormalisationKind(err) {
-	if (err instanceof Error) {
-		const msg = err.message;
-		if (msg.includes("Zod 3")) return "zod3-unsupported";
-		if (msg.includes("Invalid Zod 4")) return "invalid-zod";
-		if (msg.includes("OpenAPI ref not found")) return "openapi-missing-ref";
-		if (msg.includes("OpenAPI")) return "openapi-invalid";
-		if (msg.includes("JSON Schema")) return "invalid-json-schema";
-	}
-	return "unknown";
-}
 //#endregion
 export { ROOT_PATH, SchemaComponent, SchemaField, SchemaProvider, joinPath, registerWidget, renderField, sanitisePrefix };

package/dist/react/SchemaView.d.mts

@@ -1,6 +1,6 @@
 import { T as SchemaMeta } from "../types-D_5ST7SS.mjs";
-import { t as Diagnostic } from "../diagnostics-BYk63jsC.mjs";
-import { r as ComponentResolver } from "../renderer-BAGoX4AK.mjs";
+import { t as Diagnostic } from "../diagnostics-VgEKI_Ct.mjs";
+import { r as ComponentResolver } from "../renderer-BQqiXUYP.mjs";
 import { WidgetMap } from "./SchemaComponent.mjs";
 import { ReactNode } from "react";
 

package/dist/react/SchemaView.mjs

@@ -62,6 +62,7 @@ function SchemaView({ schema: schemaInput, ref: refInput, value, fields, meta: c
 		rootMeta = normalised.rootMeta;
 		rootDocument = normalised.rootDocument;
 	} catch (err) {
+		if (err instanceof SchemaNormalisationError) throw err;
 		throw new SchemaNormalisationError(err instanceof Error ? err.message : "Failed to normalise schema", schemaInput, "unknown");
 	}
 	const walkOptions = {

package/dist/react/headless.d.mts

@@ -1,10 +1,16 @@
-import { r as ComponentResolver } from "../renderer-BAGoX4AK.mjs";
+import { r as ComponentResolver } from "../renderer-BQqiXUYP.mjs";
 
 //#region src/react/headless.d.ts
 /**
  * The headless resolver uses props.renderChild for recursive rendering.
  * No factory function needed — the renderChild is always available
  * on RenderProps.
+ *
+ * Every WalkedField variant the walker can emit has a registered renderer.
+ * Missing a registration causes `getRenderFunction` to return `undefined`
+ * and the field to render as nothing — silent invisibility. The
+ * `ComponentResolver` interface keeps each key optional for theme
+ * adapters, so the registration here is the single source of completeness.
  */
 declare const headlessResolver: ComponentResolver;
 //#endregion

package/dist/react/headless.mjs

@@ -1,22 +1,34 @@
-import { renderArray, renderBoolean, renderDiscriminatedUnion, renderEnum, renderFile, renderNumber, renderObject, renderRecord, renderRecursive, renderString, renderUnion, renderUnknown } from "./headlessRenderers.mjs";
+import { renderArray, renderBoolean, renderConditional, renderDiscriminatedUnion, renderEnum, renderFile, renderLiteral, renderNegation, renderNever, renderNull, renderNumber, renderObject, renderRecord, renderRecursive, renderString, renderTuple, renderUnion, renderUnknown } from "./headlessRenderers.mjs";
 //#region src/react/headless.tsx
 /**
 * The headless resolver uses props.renderChild for recursive rendering.
 * No factory function needed — the renderChild is always available
 * on RenderProps.
+*
+* Every WalkedField variant the walker can emit has a registered renderer.
+* Missing a registration causes `getRenderFunction` to return `undefined`
+* and the field to render as nothing — silent invisibility. The
+* `ComponentResolver` interface keeps each key optional for theme
+* adapters, so the registration here is the single source of completeness.
 */
 const headlessResolver = {
 	string: renderString,
 	number: renderNumber,
 	boolean: renderBoolean,
+	null: renderNull,
 	enum: renderEnum,
 	object: renderObject,
 	record: renderRecord,
 	array: renderArray,
+	tuple: renderTuple,
 	union: renderUnion,
 	discriminatedUnion: renderDiscriminatedUnion,
+	conditional: renderConditional,
+	negation: renderNegation,
+	literal: renderLiteral,
 	file: renderFile,
 	recursive: renderRecursive,
+	never: renderNever,
 	unknown: renderUnknown
 };
 //#endregion

package/dist/react/headlessRenderers.d.mts

@@ -1,5 +1,5 @@
 import { M as WalkedField } from "../types-D_5ST7SS.mjs";
-import { l as RenderProps } from "../renderer-BAGoX4AK.mjs";
+import { l as RenderProps } from "../renderer-BQqiXUYP.mjs";
 import { ReactNode } from "react";
 
 //#region src/react/headlessRenderers.d.ts
@@ -57,6 +57,57 @@ declare function renderDiscriminatedUnion(props: RenderProps): ReactNode;
 declare function discriminatedUnionValueForTab(optionLabels: readonly string[], discKey: string, newIndex: number): Record<string, string> | undefined;
 declare function renderFile(props: RenderProps): ReactNode;
 declare function renderRecursive(props: RenderProps): ReactNode;
+/**
+ * Render a literal field — `z.literal("a")` or `{ const: 5 }`.
+ *
+ * Literals are non-editable by nature (the value is fixed at the schema
+ * level), so both read-only and editable modes display the literal value(s).
+ * Multiple literals (`z.literal(["a", "b"])`) render comma-separated.
+ */
+declare function renderLiteral(props: RenderProps): ReactNode;
+/**
+ * Render a null field — `z.null()` or `{ type: "null" }`.
+ *
+ * The only valid value is `null`, so render an em-dash placeholder
+ * regardless of mode. There is nothing the user can usefully change.
+ */
+declare function renderNull(props: RenderProps): ReactNode;
+/**
+ * Render a never field — `z.never()` or `{ not: {} }` / `false` schema.
+ *
+ * `never` indicates a position that cannot hold any value. We render a
+ * visible placeholder rather than throwing because some valid schemas
+ * intentionally contain `never` branches (e.g. exhaustive discriminated
+ * unions), and a runtime crash on render would be worse than a visible
+ * indicator.
+ */
+declare function renderNever(props: RenderProps): ReactNode;
+/**
+ * Render a tuple field — `z.tuple([z.string(), z.number()])` or
+ * `{ prefixItems: [...] }`.
+ *
+ * Positional rendering: each `prefixItems` entry is rendered at its index.
+ * The structural index (e.g. `[0]`) is passed as the path suffix so
+ * children get unique ids and labels.
+ */
+declare function renderTuple(props: RenderProps): ReactNode;
+/**
+ * Render a conditional field — JSON Schema `if`/`then`/`else`.
+ *
+ * Conditional schemas describe constraints rather than a single value
+ * shape, so the renderer surfaces each clause as a labelled fieldset.
+ * This mirrors the HTML renderer's annotation approach and gives a
+ * predictable structure for theme adapters that want to override it.
+ */
+declare function renderConditional(props: RenderProps): ReactNode;
+/**
+ * Render a negation field — JSON Schema `{ not: { ... } }`.
+ *
+ * Negation describes a constraint ("value must NOT match this schema")
+ * rather than a value shape. The renderer surfaces the negated schema
+ * beneath an explanatory preamble.
+ */
+declare function renderNegation(props: RenderProps): ReactNode;
 declare function renderUnknown(props: RenderProps): ReactNode;
 //#endregion
-export { defaultRecordValue, discriminatedUnionValueForTab, inputId, nextRecordKey, renameRecordKey, renderArray, renderBoolean, renderDiscriminatedUnion, renderEnum, renderFile, renderNumber, renderObject, renderRecord, renderRecursive, renderString, renderUnion, renderUnknown, toReactNode };
+export { defaultRecordValue, discriminatedUnionValueForTab, inputId, nextRecordKey, renameRecordKey, renderArray, renderBoolean, renderConditional, renderDiscriminatedUnion, renderEnum, renderFile, renderLiteral, renderNegation, renderNever, renderNull, renderNumber, renderObject, renderRecord, renderRecursive, renderString, renderTuple, renderUnion, renderUnknown, toReactNode };

package/dist/react/headlessRenderers.mjs

@@ -595,6 +595,144 @@ function renderRecursive(props) {
 		" (recursive)"
 	] }) });
 }
+/**
+* Render a literal field — `z.literal("a")` or `{ const: 5 }`.
+*
+* Literals are non-editable by nature (the value is fixed at the schema
+* level), so both read-only and editable modes display the literal value(s).
+* Multiple literals (`z.literal(["a", "b"])`) render comma-separated.
+*/
+function renderLiteral(props) {
+	const id = inputId(props.path);
+	if (props.tree.type !== "literal") return null;
+	const values = props.tree.literalValues;
+	if (values.length === 0) return /* @__PURE__ */ jsx("span", {
+		id,
+		"aria-readonly": "true",
+		children: "—"
+	});
+	return /* @__PURE__ */ jsx("span", {
+		id,
+		"aria-readonly": "true",
+		children: values.map((v) => v === null ? "null" : String(v)).join(", ")
+	});
+}
+/**
+* Render a null field — `z.null()` or `{ type: "null" }`.
+*
+* The only valid value is `null`, so render an em-dash placeholder
+* regardless of mode. There is nothing the user can usefully change.
+*/
+function renderNull(props) {
+	return /* @__PURE__ */ jsx("span", {
+		id: inputId(props.path),
+		"aria-readonly": "true",
+		children: "—"
+	});
+}
+/**
+* Render a never field — `z.never()` or `{ not: {} }` / `false` schema.
+*
+* `never` indicates a position that cannot hold any value. We render a
+* visible placeholder rather than throwing because some valid schemas
+* intentionally contain `never` branches (e.g. exhaustive discriminated
+* unions), and a runtime crash on render would be worse than a visible
+* indicator.
+*/
+function renderNever(props) {
+	return /* @__PURE__ */ jsx("span", {
+		id: inputId(props.path),
+		"aria-readonly": "true",
+		className: "sc-never",
+		children: /* @__PURE__ */ jsx("em", { children: "never matches" })
+	});
+}
+/**
+* Render a tuple field — `z.tuple([z.string(), z.number()])` or
+* `{ prefixItems: [...] }`.
+*
+* Positional rendering: each `prefixItems` entry is rendered at its index.
+* The structural index (e.g. `[0]`) is passed as the path suffix so
+* children get unique ids and labels.
+*/
+function renderTuple(props) {
+	if (props.tree.type !== "tuple") return null;
+	const prefixItems = props.tree.prefixItems;
+	if (prefixItems.length === 0) return null;
+	const arr = Array.isArray(props.value) ? props.value : [];
+	return /* @__PURE__ */ jsx("div", {
+		role: "group",
+		"aria-label": props.meta.description ?? void 0,
+		children: prefixItems.map((element, i) => {
+			const itemValue = arr[i];
+			const childOnChange = (v) => {
+				const next = arr.slice();
+				next[i] = v;
+				props.onChange(next);
+			};
+			return /* @__PURE__ */ jsx("div", { children: toReactNode(props.renderChild(element, itemValue, childOnChange, `[${String(i)}]`)) }, String(i));
+		})
+	});
+}
+/**
+* Render a conditional field — JSON Schema `if`/`then`/`else`.
+*
+* Conditional schemas describe constraints rather than a single value
+* shape, so the renderer surfaces each clause as a labelled fieldset.
+* This mirrors the HTML renderer's annotation approach and gives a
+* predictable structure for theme adapters that want to override it.
+*/
+function renderConditional(props) {
+	if (props.tree.type !== "conditional") return null;
+	const { ifClause, thenClause, elseClause } = props.tree;
+	return /* @__PURE__ */ jsxs("fieldset", {
+		className: "sc-conditional",
+		children: [
+			/* @__PURE__ */ jsxs("div", {
+				className: "sc-conditional-if",
+				children: [
+					/* @__PURE__ */ jsx("strong", { children: "if:" }),
+					" ",
+					toReactNode(props.renderChild(ifClause, props.value, props.onChange))
+				]
+			}),
+			thenClause !== void 0 && /* @__PURE__ */ jsxs("div", {
+				className: "sc-conditional-then",
+				children: [
+					/* @__PURE__ */ jsx("strong", { children: "then:" }),
+					" ",
+					toReactNode(props.renderChild(thenClause, props.value, props.onChange))
+				]
+			}),
+			elseClause !== void 0 && /* @__PURE__ */ jsxs("div", {
+				className: "sc-conditional-else",
+				children: [
+					/* @__PURE__ */ jsx("strong", { children: "else:" }),
+					" ",
+					toReactNode(props.renderChild(elseClause, props.value, props.onChange))
+				]
+			})
+		]
+	});
+}
+/**
+* Render a negation field — JSON Schema `{ not: { ... } }`.
+*
+* Negation describes a constraint ("value must NOT match this schema")
+* rather than a value shape. The renderer surfaces the negated schema
+* beneath an explanatory preamble.
+*/
+function renderNegation(props) {
+	if (props.tree.type !== "negation") return null;
+	return /* @__PURE__ */ jsxs("fieldset", {
+		className: "sc-negation",
+		children: [
+			/* @__PURE__ */ jsx("strong", { children: "Must NOT match:" }),
+			" ",
+			toReactNode(props.renderChild(props.tree.negated, props.value, props.onChange))
+		]
+	});
+}
 function renderUnknown(props) {
 	const id = inputId(props.path);
 	if (props.readOnly) {
@@ -627,4 +765,4 @@ function matchUnionOption(options, value) {
 	if (typeof value === "object" && value !== null) return options.find((o) => o.type === "object");
 }
 //#endregion
-export { defaultRecordValue, discriminatedUnionValueForTab, inputId, nextRecordKey, renameRecordKey, renderArray, renderBoolean, renderDiscriminatedUnion, renderEnum, renderFile, renderNumber, renderObject, renderRecord, renderRecursive, renderString, renderUnion, renderUnknown, toReactNode };
+export { defaultRecordValue, discriminatedUnionValueForTab, inputId, nextRecordKey, renameRecordKey, renderArray, renderBoolean, renderConditional, renderDiscriminatedUnion, renderEnum, renderFile, renderLiteral, renderNegation, renderNever, renderNull, renderNumber, renderObject, renderRecord, renderRecursive, renderString, renderTuple, renderUnion, renderUnknown, toReactNode };

package/dist/{ref-Ckt5liZs.d.mts → ref-Bb43ZURY.d.mts}

@@ -1,4 +1,4 @@
-import { i as DiagnosticsOptions } from "./diagnostics-BYk63jsC.mjs";
+import { i as DiagnosticsOptions } from "./diagnostics-VgEKI_Ct.mjs";
 
 //#region src/core/ref.d.ts
 /**

package/dist/{renderer-BAGoX4AK.d.mts → renderer-BQqiXUYP.d.mts}

@@ -98,6 +98,7 @@ interface ComponentResolver {
   string?: RenderFunction;
   number?: RenderFunction;
   boolean?: RenderFunction;
+  null?: RenderFunction;
   enum?: RenderFunction;
   object?: RenderFunction;
   array?: RenderFunction;
@@ -110,6 +111,7 @@ interface ComponentResolver {
   recursive?: RenderFunction;
   literal?: RenderFunction;
   file?: RenderFunction;
+  never?: RenderFunction;
   unknown?: RenderFunction;
 }
 /** An HTML render function returns a string. */
@@ -122,6 +124,7 @@ interface HtmlResolver {
   string?: HtmlRenderFunction;
   number?: HtmlRenderFunction;
   boolean?: HtmlRenderFunction;
+  null?: HtmlRenderFunction;
   enum?: HtmlRenderFunction;
   object?: HtmlRenderFunction;
   array?: HtmlRenderFunction;
@@ -134,13 +137,16 @@ interface HtmlResolver {
   recursive?: HtmlRenderFunction;
   literal?: HtmlRenderFunction;
   file?: HtmlRenderFunction;
+  never?: HtmlRenderFunction;
   unknown?: HtmlRenderFunction;
 }
-declare const RESOLVER_KEYS: readonly ["string", "number", "boolean", "enum", "object", "array", "tuple", "record", "union", "discriminatedUnion", "conditional", "negation", "recursive", "literal", "file", "unknown"];
+declare const RESOLVER_KEYS: readonly ["string", "number", "boolean", "null", "enum", "object", "array", "tuple", "record", "union", "discriminatedUnion", "conditional", "negation", "recursive", "literal", "file", "never", "unknown"];
 type ResolverKey = (typeof RESOLVER_KEYS)[number];
 /**
  * Map a schema type to the resolver key that handles it.
- * `discriminatedUnion` → `union`. Unknown types → `unknown`.
+ * Every WalkedField variant has a direct resolver key — exhaustive switch
+ * ensures new variants surface as a type error rather than silently
+ * falling through to "unknown".
  */
 declare function typeToKey(type: WalkedField["type"]): ResolverKey;
 /**

package/dist/themes/mantine.d.mts

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

package/dist/themes/mui.d.mts

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

package/dist/themes/radix.d.mts

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

package/dist/themes/shadcn.d.mts

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

package/dist/{version-B5NV-35j.d.mts → version-XNH7PRGP.d.mts}

@@ -7,6 +7,13 @@
  * before the walker processes the schema.
  */
 type JsonSchemaDraft = "draft-04" | "draft-06" | "draft-07" | "draft-2019-09" | "draft-2020-12";
+/**
+ * Match a `$schema` URI string to a known draft. Returns `undefined`
+ * when the URI matches none of the documented Draft 04 – Draft 2020-12
+ * schema URIs (including the known prefix patterns) — callers can use
+ * this to distinguish an authoritative match from a silent fallback.
+ */
+declare function matchJsonSchemaDraftUri(uri: string): JsonSchemaDraft | undefined;
 /**
  * Detect the JSON Schema draft version from a schema's `$schema` URI.
  * When `$schema` is absent, uses heuristic keyword detection via
@@ -66,4 +73,4 @@ declare function isOpenApi31(version: OpenApiVersionInfo): boolean;
  */
 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 };
+export { detectOpenApiVersion as a, isOpenApi30 as c, matchJsonSchemaDraftUri as d, 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.18.1",
+    "version": "1.19.0",
     "description": "React components that render UI from Zod schemas, JSON Schema, and OpenAPI documents",
     "type": "module",
     "main": "./dist/index.mjs",