schema-components 1.18.1 → 1.20.0

package/dist/openapi/ApiCallbacks.d.mts

@@ -1,4 +1,4 @@
-import { T as SchemaMeta } from "../types-D_5ST7SS.mjs";
+import { T as SchemaMeta } from "../types-C9zw9wbX.mjs";
 import { CallbackInfo } from "./parser.mjs";
 import { ReactNode } from "react";
 

package/dist/openapi/ApiLinks.d.mts

@@ -1,4 +1,4 @@
-import { T as SchemaMeta } from "../types-D_5ST7SS.mjs";
+import { T as SchemaMeta } from "../types-C9zw9wbX.mjs";
 import { LinkInfo } from "./parser.mjs";
 import { ReactNode } from "react";
 

package/dist/openapi/ApiResponseHeaders.d.mts

@@ -1,4 +1,4 @@
-import { T as SchemaMeta } from "../types-D_5ST7SS.mjs";
+import { T as SchemaMeta } from "../types-C9zw9wbX.mjs";
 import { HeaderInfo } from "./parser.mjs";
 import { ReactNode } from "react";
 

package/dist/openapi/ApiSecurity.d.mts

@@ -1,4 +1,4 @@
-import { T as SchemaMeta } from "../types-D_5ST7SS.mjs";
+import { T as SchemaMeta } from "../types-C9zw9wbX.mjs";
 import { SecurityRequirement, SecurityScheme } from "./parser.mjs";
 import { ReactNode } from "react";
 

package/dist/openapi/bundle.mjs

@@ -1,4 +1,5 @@
 import { isObject } from "../core/guards.mjs";
+import { isPrototypePollutingKey } from "../core/uri.mjs";
 //#region src/openapi/bundle.ts
 /**
 * OpenAPI document bundler — inlines external $ref files.
@@ -104,6 +105,7 @@ function resolveFragment(doc, fragment) {
 	for (const part of parts) {
 		if (!isObject(current)) return void 0;
 		const decoded = part.replace(/~1/g, "/").replace(/~0/g, "~");
+		if (isPrototypePollutingKey(decoded)) return void 0;
 		current = current[decoded];
 	}
 	return isObject(current) ? current : void 0;

package/dist/openapi/components.d.mts

@@ -1,5 +1,5 @@
-import { T as SchemaMeta, u as FieldOverride } from "../types-D_5ST7SS.mjs";
-import { a as InferResponseFields, d as UnsafeFields, i as InferRequestBodyFields, r as InferParameterOverrides } from "../typeInference-5JiqIZ8t.mjs";
+import { T as SchemaMeta, u as FieldOverride } from "../types-C9zw9wbX.mjs";
+import { a as InferResponseFields, i as InferRequestBodyFields, m as UnsafeFields, r as InferParameterOverrides } from "../typeInference-CDoD_LZ_.mjs";
 import { WidgetMap } from "../react/SchemaComponent.mjs";
 import { ReactNode } from "react";
 

package/dist/openapi/components.mjs

@@ -53,7 +53,10 @@ function ApiOperation({ schema: doc, path, method, requestBodyValue, onRequestBo
 	return /* @__PURE__ */ jsxs("section", {
 		"data-operation": `${method.toUpperCase()} ${path}`,
 		children: [
-			/* @__PURE__ */ jsx(OperationHeader, { operation: resolved.operation }),
+			/* @__PURE__ */ jsx(OperationHeader, {
+				operation: resolved.operation,
+				pathItem: resolved.pathItem
+			}),
 			/* @__PURE__ */ jsx(ApiSecurity, {
 				requirements: securityReqs,
 				schemes: securitySchemes
@@ -176,14 +179,28 @@ function ApiResponse({ schema: doc, path, method, status, value, meta, fields, w
 		idPrefix: instancePrefix
 	});
 }
-function OperationHeader({ operation }) {
+function OperationHeader({ operation, pathItem }) {
 	return /* @__PURE__ */ jsxs("header", { children: [
+		(pathItem.summary !== void 0 || pathItem.description !== void 0) && /* @__PURE__ */ jsxs("div", {
+			"data-path-info": true,
+			children: [pathItem.summary !== void 0 && /* @__PURE__ */ jsx("p", {
+				"data-path-summary": true,
+				children: pathItem.summary
+			}), pathItem.description !== void 0 && /* @__PURE__ */ jsx("p", {
+				"data-path-description": true,
+				children: pathItem.description
+			})]
+		}),
 		/* @__PURE__ */ jsxs("h3", { children: [
 			operation.method.toUpperCase(),
 			" ",
 			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"
@@ -220,9 +237,7 @@ function ResponseCard({ response, rootDoc, value, fields, meta, widgets, path, m
 		]
 	});
 	let links = [];
-	if (path !== void 0 && method !== void 0) try {
-		links = getLinks(getParsed(rootDoc), path, method, response.statusCode);
-	} catch {}
+	if (path !== void 0 && method !== void 0) links = getLinks(getParsed(rootDoc), path, method, response.statusCode);
 	return /* @__PURE__ */ jsxs("div", {
 		"data-status": response.statusCode,
 		children: [

package/dist/openapi/parser.d.mts

@@ -1,4 +1,4 @@
-import { m as JsonObject } from "../types-D_5ST7SS.mjs";
+import { m as JsonObject } from "../types-C9zw9wbX.mjs";
 
 //#region src/openapi/parser.d.ts
 interface OpenApiDocument {

package/dist/openapi/parser.mjs

@@ -1,4 +1,5 @@
 import { getProperty, isObject } from "../core/guards.mjs";
+import { isPrototypePollutingKey } from "../core/uri.mjs";
 //#region src/openapi/parser.ts
 function getString(value, key) {
 	const result = isObject(value) ? value[key] : void 0;
@@ -33,7 +34,10 @@ const METHODS = [
 	"post",
 	"put",
 	"patch",
-	"delete"
+	"delete",
+	"head",
+	"options",
+	"trace"
 ];
 /**
 * Resolve a path item, following a `$ref` to `components/pathItems/<Name>`
@@ -170,6 +174,7 @@ function resolveRefInDoc(doc, ref) {
 	for (const part of parts) {
 		if (!isObject(current)) return void 0;
 		const decoded = part.replace(/~1/g, "/").replace(/~0/g, "~");
+		if (isPrototypePollutingKey(decoded)) return void 0;
 		current = current[decoded];
 	}
 	return isObject(current) ? current : void 0;

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.
@@ -22,8 +23,18 @@ declare function getParsed(doc: Record<string, unknown>): OpenApiDocument;
  * for non-objects.
  */
 declare function toDoc(value: unknown): Record<string, unknown>;
+/**
+ * Path-Item-level metadata. OpenAPI 3.1 added `summary` and `description`
+ * to Path Item Objects alongside the existing operation-level fields.
+ * Both are plain strings (no Markdown rendering at this layer).
+ */
+interface PathItemInfo {
+  summary: string | undefined;
+  description: string | undefined;
+}
 interface ResolvedOperation {
   operation: OperationInfo;
+  pathItem: PathItemInfo;
   parameters: ParameterInfo[];
   requestBody: ReturnType<typeof getRequestBody>;
   responses: ResponseInfo[];
@@ -50,4 +61,4 @@ declare function resolveResponse(doc: Record<string, unknown>, path: string, met
  */
 declare function resolveResponses(doc: Record<string, unknown>, path: string, method: string): ResponseInfo[];
 //#endregion
-export { ResolvedOperation, getParsed, resolveOperation, resolveParameters, resolveRequestBody, resolveResponse, resolveResponses, toDoc };
+export { PathItemInfo, ResolvedOperation, getParsed, resolveOperation, resolveParameters, resolveRequestBody, resolveResponse, resolveResponses, toDoc };

package/dist/openapi/resolve.mjs

@@ -1,6 +1,6 @@
-import { isObject } from "../core/guards.mjs";
+import { getProperty, 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-CMMEl4cd.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.
@@ -44,6 +45,40 @@ function toDoc(value) {
 	return isObject(value) ? value : {};
 }
 /**
+* Look up a Path Item Object on the (already-normalised) parsed document,
+* following a single `$ref` hop into `components/pathItems` (OpenAPI 3.1)
+* if present. Returns `undefined` when the path is not present or the
+* value is not an object.
+*
+* Implemented inside `resolve.ts` to avoid touching `parser.ts` while
+* still surfacing path-item-level metadata to the React layer.
+*/
+function lookupPathItemNode(parsed, path) {
+	return resolvePathItemNode(parsed, getProperty(getProperty(parsed.doc, "paths"), path));
+}
+function resolvePathItemNode(parsed, pathItem) {
+	if (!isObject(pathItem)) return void 0;
+	const ref = getProperty(pathItem, "$ref");
+	if (typeof ref !== "string") return pathItem;
+	if (!ref.startsWith("#/")) return pathItem;
+	const parts = ref.slice(2).split("/");
+	let current = parsed.doc;
+	for (const part of parts) {
+		if (!isObject(current)) return void 0;
+		const decoded = part.replace(/~1/g, "/").replace(/~0/g, "~");
+		current = current[decoded];
+	}
+	return isObject(current) ? current : pathItem;
+}
+function extractPathItemInfo(pathItem) {
+	const summary = pathItem.summary;
+	const description = pathItem.description;
+	return {
+		summary: typeof summary === "string" ? summary : void 0,
+		description: typeof description === "string" ? description : void 0
+	};
+}
+/**
 * Resolve an operation from an OpenAPI document by path and method.
 * Throws if the operation is not found.
 */
@@ -51,8 +86,11 @@ function resolveOperation(doc, path, method) {
 	const parsed = getParsed(doc);
 	const operation = listOperations(parsed).find((op) => op.path === path && op.method === method);
 	if (operation === void 0) throw new Error(`Operation not found: ${method.toUpperCase()} ${path}`);
+	const pathItemNode = lookupPathItemNode(parsed, path);
+	if (pathItemNode === void 0) throw new Error(`Path item missing for ${method.toUpperCase()} ${path}`);
 	return {
 		operation,
+		pathItem: extractPathItemInfo(pathItemNode),
 		parameters: getParameters(parsed, path, method),
 		requestBody: getRequestBody(parsed, path, method),
 		responses: getResponses(parsed, path, method)

package/dist/react/SchemaComponent.d.mts

@@ -1,8 +1,8 @@
-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 { c as PathOfType, l as ResolveOpenAPIRef, n as FromJSONSchema } from "../typeInference-5JiqIZ8t.mjs";
+import { M as WalkedField, T as SchemaMeta, d as FieldOverrides, u as FieldOverride } from "../types-C9zw9wbX.mjs";
+import { t as Diagnostic } from "../diagnostics-CbBPsxSt.mjs";
+import { t as SchemaError } from "../errors-C2iABcn9.mjs";
+import { l as RenderProps, r as ComponentResolver } from "../renderer-SOIbJBtk.mjs";
+import { c as PathOfType, l as RejectUnrepresentableZod, n as FromJSONSchema, u as ResolveOpenAPIRef } from "../typeInference-CDoD_LZ_.mjs";
 import { z } from "zod";
 import * as _$react_jsx_runtime0 from "react/jsx-runtime";
 import { ReactNode } from "react";
@@ -40,8 +40,17 @@ type InferFields<T, Ref extends string | undefined> = T extends z.ZodType ? Fiel
   openapi: unknown;
 } ? Ref extends string ? FieldOverrides<ResolveOpenAPIRef<T & Record<string, unknown>, Ref>> : Record<string, FieldOverride> : T extends object ? unknown extends FromJSONSchema<T> ? Record<string, FieldOverride> : FieldOverrides<FromJSONSchema<T>> : Record<string, FieldOverride>;
 interface SchemaComponentProps<T = unknown, Ref extends string | undefined = undefined> {
-  /** Zod schema, JSON Schema object, or OpenAPI document. */
-  schema: T;
+  /**
+   * Zod schema, JSON Schema object, or OpenAPI document.
+   *
+   * Zod 4 types that cannot round-trip through `z.toJSONSchema()`
+   * (bigint, date, map, set, symbol, function, undefined, void, nan,
+   * codec) are rejected at the type level via
+   * {@link RejectUnrepresentableZod}. Runtime conversion would throw
+   * `SchemaNormalisationError` with kind `zod-type-unrepresentable`
+   * — the static rejection surfaces the same failure at compile time.
+   */
+  schema: RejectUnrepresentableZod<T>;
   /** For OpenAPI: a ref string like "#/components/schemas/User" or "/users/post". */
   ref?: Ref;
   /** Current value to render. */
@@ -128,8 +137,11 @@ interface SchemaFieldProps<T = unknown, Ref extends string | undefined = undefin
    * paths are accepted. Falls back to `string` for runtime schemas.
    */
   path: P;
-  /** The schema to extract the field from. */
-  schema: T;
+  /**
+   * The schema to extract the field from. Subject to the same
+   * unrepresentable-Zod rejection as {@link SchemaComponentProps.schema}.
+   */
+  schema: RejectUnrepresentableZod<T>;
   /** For OpenAPI: a ref string. */
   ref?: Ref;
   /** Current value of the field at the given path. */

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 SchemaMeta } from "../types-C9zw9wbX.mjs";
+import { t as Diagnostic } from "../diagnostics-CbBPsxSt.mjs";
+import { r as ComponentResolver } from "../renderer-SOIbJBtk.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/fieldPath.d.mts

@@ -1,4 +1,4 @@
-import { M as WalkedField } from "../types-D_5ST7SS.mjs";
+import { M as WalkedField } from "../types-C9zw9wbX.mjs";
 
 //#region src/react/fieldPath.d.ts
 /**

package/dist/react/headless.d.mts

@@ -1,10 +1,16 @@
-import { r as ComponentResolver } from "../renderer-BAGoX4AK.mjs";
+import { r as ComponentResolver } from "../renderer-SOIbJBtk.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 { M as WalkedField } from "../types-C9zw9wbX.mjs";
+import { l as RenderProps } from "../renderer-SOIbJBtk.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 };