schema-components 2.0.2 → 2.1.1

package/dist/solid/SchemaView.d.mts

@@ -0,0 +1,54 @@
+import { w as SchemaMeta } from "../types-BBQaEPfE.mjs";
+import { t as Diagnostic } from "../diagnostics-mftUZI7c.mjs";
+import { r as SchemaIoSide } from "../adapter-ktQaheWB.mjs";
+import { f as RejectUnrepresentableZod } from "../typeInference-Y8tNEQJk.mjs";
+import { a as InferredValue, t as InferFields } from "../inferValue-eAnh50EM.mjs";
+import { SolidComponentResolver, SolidWidgetMap } from "./types.mjs";
+import { JSX } from "solid-js";
+
+//#region src/solid/SchemaView.d.ts
+/**
+ * Props accepted by {@link SchemaView}.
+ *
+ * Mirrors `<SchemaComponent>` for the read-only path — no `onChange`,
+ * no `validate`, and the theme is supplied via the `resolver` prop
+ * rather than `SchemaProvider` so it can be rendered without a
+ * Solid context binding.
+ *
+ * @group Components
+ */
+interface SchemaViewProps<T = unknown, Ref extends string | undefined = undefined, Mode extends SchemaIoSide = "output"> {
+  schema: RejectUnrepresentableZod<T>;
+  ref?: Ref;
+  io?: Mode;
+  value?: InferredValue<T, Ref, undefined, Mode>;
+  fields?: InferFields<T, Ref>;
+  meta?: SchemaMeta;
+  description?: string;
+  /** Theme resolver. Falls back to the headless resolver if omitted. */
+  resolver?: SolidComponentResolver;
+  widgets?: SolidWidgetMap;
+  onDiagnostic?: (diagnostic: Diagnostic) => void;
+  strict?: boolean;
+  idPrefix?: string;
+}
+/**
+ * Read-only Solid renderer that is safe to use outside a Solid context
+ * subtree — the theme adapter is passed via the `resolver` prop.
+ *
+ * Always renders read-only; pair with `SchemaComponent` for editable
+ * forms. Mirrors the contract of the React `<SchemaView>`.
+ *
+ * @group Components
+ * @example
+ * ```tsx
+ * import { SchemaView } from "schema-components/solid/SchemaView";
+ *
+ * export default function UserCard(props: { user: User }) {
+ *   return <SchemaView schema={userSchema} value={props.user} />;
+ * }
+ * ```
+ */
+declare function SchemaView<T = unknown, Ref extends string | undefined = undefined, Mode extends SchemaIoSide = "output">(props: SchemaViewProps<T, Ref, Mode>): JSX.Element;
+//#endregion
+export { SchemaView, SchemaViewProps };

package/dist/solid/SchemaView.mjs

@@ -0,0 +1,168 @@
+import { toRecordOrUndefined } from "../core/guards.mjs";
+import "../core/limits.mjs";
+import { SchemaNormalisationError, SchemaRenderError } from "../core/errors.mjs";
+import { normaliseSchema } from "../core/adapter.mjs";
+import { walk } from "../core/walker.mjs";
+import { headlessSolidResolver } from "./headless.mjs";
+import { joinPath, sanitisePrefix } from "./SchemaComponent.mjs";
+import { createUniqueId } from "solid-js";
+import { jsx, jsxs } from "solid-js/jsx-runtime";
+//#region src/solid/SchemaView.tsx
+/** @jsxImportSource solid-js */
+/**
+* Solid read-only schema renderer.
+*
+* Mirror of `react/SchemaView.tsx` for Solid. Renders a schema in
+* read-only mode without any context — the theme adapter is passed
+* explicitly via the `resolver` prop, matching the React Server
+* Component contract.
+*
+* The compute primitive used is `createUniqueId()` plus a single
+* recursive render dispatcher. There is no per-render hook state; the
+* tree is walked once per render and dispatched to the resolver.
+*
+* SSR note: Solid Start ships a server-component equivalent
+* (server-only directives, etc.) but the API is still moving.
+* `<SchemaView>` is documented as the read-only entry point and works
+* as a normal Solid component inside an SSR-rendered tree; consumers
+* using Solid Start can place it anywhere, including in a server-
+* rendered route. A dedicated Solid Start server-only surface can be
+* added as a thin wrapper once the upstream API stabilises.
+*/
+/**
+* Read-only Solid renderer that is safe to use outside a Solid context
+* subtree — the theme adapter is passed via the `resolver` prop.
+*
+* Always renders read-only; pair with `SchemaComponent` for editable
+* forms. Mirrors the contract of the React `<SchemaView>`.
+*
+* @group Components
+* @example
+* ```tsx
+* import { SchemaView } from "schema-components/solid/SchemaView";
+*
+* export default function UserCard(props: { user: User }) {
+*   return <SchemaView schema={userSchema} value={props.user} />;
+* }
+* ```
+*/
+function SchemaView(props) {
+	const generatedId = createUniqueId();
+	const rootPath = props.idPrefix ?? sanitisePrefix(generatedId);
+	const mergedMeta = {
+		...props.meta,
+		readOnly: true
+	};
+	if (props.description !== void 0) mergedMeta.description = props.description;
+	const diagnostics = props.onDiagnostic !== void 0 || props.strict === true ? {
+		...props.onDiagnostic !== void 0 ? { diagnostics: props.onDiagnostic } : {},
+		...props.strict !== void 0 ? { strict: props.strict } : {}
+	} : void 0;
+	let jsonSchema;
+	let rootMeta;
+	let rootDocument;
+	try {
+		const normaliseOptions = diagnostics !== void 0 || props.io !== void 0 ? {
+			...diagnostics !== void 0 ? { diagnostics } : {},
+			...props.io !== void 0 ? { io: props.io } : {}
+		} : void 0;
+		const normalised = normaliseSchema(props.schema, props.ref, normaliseOptions);
+		jsonSchema = normalised.jsonSchema;
+		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", props.schema, "unknown");
+	}
+	const fieldsRecord = toRecordOrUndefined(props.fields);
+	const walkOptions = {
+		componentMeta: mergedMeta,
+		rootMeta,
+		fieldOverrides: fieldsRecord,
+		rootDocument,
+		...diagnostics !== void 0 ? { diagnostics } : {}
+	};
+	const tree = walk(jsonSchema, walkOptions);
+	const resolver = props.resolver !== void 0 ? mergeSolidResolvers(props.resolver, headlessSolidResolver) : headlessSolidResolver;
+	const makeRenderChild = (currentDepth, parentPath) => (childTree, childValue, _childOnChange, pathSuffix) => {
+		const childPath = joinPath(parentPath, pathSuffix);
+		if (currentDepth >= 10) return /* @__PURE__ */ jsx("fieldset", { children: /* @__PURE__ */ jsxs("em", { children: [
+			"↻ ",
+			typeof childTree.meta.description === "string" ? childTree.meta.description : "schema",
+			" (recursive)"
+		] }) });
+		return renderFieldServer(childTree, childValue, resolver, makeRenderChild(currentDepth + 1, childPath), childPath, props.widgets);
+	};
+	const renderChild = makeRenderChild(0, rootPath);
+	return renderFieldServer(tree, props.value ?? tree.defaultValue, resolver, renderChild, rootPath, props.widgets);
+}
+function renderFieldServer(tree, value, resolver, renderChild, path, widgets) {
+	if (path.length === 0) throw new Error("renderFieldServer requires a non-empty path. Pass the root path at the top and join children via joinPath().");
+	const componentHint = tree.meta.component;
+	if (typeof componentHint === "string") {
+		const widget = widgets?.get(componentHint);
+		if (widget !== void 0) {
+			const result = widget({
+				value,
+				readOnly: true,
+				writeOnly: false,
+				meta: tree.meta,
+				constraints: tree.constraints,
+				path,
+				tree,
+				onChange: () => {},
+				renderChild,
+				...tree.examples !== void 0 ? { examples: tree.examples } : {}
+			});
+			if (result !== null && result !== void 0) return result;
+		}
+	}
+	const renderFn = resolver[tree.type];
+	if (renderFn !== void 0) try {
+		const result = renderFn({
+			value,
+			readOnly: true,
+			writeOnly: false,
+			meta: tree.meta,
+			constraints: tree.constraints,
+			path,
+			tree,
+			onChange: () => {},
+			renderChild,
+			...tree.examples !== void 0 ? { examples: tree.examples } : {}
+		});
+		if (result !== null && result !== void 0) return result;
+	} catch (err) {
+		throw new SchemaRenderError(err instanceof Error ? err.message : `Render function threw for type "${tree.type}"`, tree, tree.type, err);
+	}
+	if (value === void 0 || value === null) return /* @__PURE__ */ jsx("span", { children: "—" });
+	return /* @__PURE__ */ jsx("span", { children: typeof value === "string" ? value : JSON.stringify(value) });
+}
+function mergeSolidResolvers(user, fallback) {
+	const merged = {};
+	for (const key of [
+		"string",
+		"number",
+		"boolean",
+		"null",
+		"enum",
+		"object",
+		"array",
+		"tuple",
+		"record",
+		"union",
+		"discriminatedUnion",
+		"conditional",
+		"negation",
+		"literal",
+		"file",
+		"never",
+		"unknown"
+	]) {
+		const fn = user[key] ?? fallback[key];
+		if (fn !== void 0) merged[key] = fn;
+	}
+	return merged;
+}
+//#endregion
+export { SchemaView };

package/dist/solid/a11y.d.mts

@@ -0,0 +1,70 @@
+import { j as WalkedField } from "../types-BBQaEPfE.mjs";
+import { t as AllConstraints } from "../renderer-ab9E52Bp.mjs";
+
+//#region src/solid/a11y.d.ts
+/**
+ * Build the ARIA attribute bundle for a renderer.
+ *
+ * - `aria-required="true"` whenever the field is non-optional.
+ * - `aria-describedby=<hint-id>` whenever a constraint hint applies.
+ * - `aria-label=<description>` when a non-empty description is supplied.
+ *
+ * Pass `inputId` + `constraints` only when the renderer emits a
+ * constraint-hint sibling; the helper then auto-derives the
+ * `aria-describedby` value from `hintIdFor(inputId)`. Omitting either
+ * argument skips the attribute.
+ */
+declare function buildAriaAttrs(tree: WalkedField, description?: unknown, inputId?: string, constraints?: AllConstraints): Record<string, string>;
+/**
+ * Description for a constraint hint emitted alongside an input.
+ *
+ * Returned by {@link constraintHint} when the field carries one or
+ * more constraint keywords the user should be told about (min/max,
+ * pattern, item count, …). Theme adapters render this as a `<small>`
+ * element wired to the input via `aria-describedby`.
+ */
+interface Hint {
+  /** DOM id matching {@link hintIdFor}(inputId) on the host input. */
+  readonly id: string;
+  /** Human-readable hint text. */
+  readonly text: string;
+}
+/**
+ * Derive the constraint-hint descriptor for a field at `inputId`.
+ * Returns `undefined` when the field has no constraint worth
+ * announcing — callers skip rendering the `<small>` element entirely
+ * rather than emitting an empty node.
+ */
+declare function constraintHint(inputId: string, constraints: AllConstraints): Hint | undefined;
+/**
+ * True when the supplied field is non-optional and therefore deserves
+ * a visual required indicator alongside its label.
+ */
+declare function isFieldRequired(tree: WalkedField): boolean;
+/**
+ * Narrow `meta.description` (typed `unknown`) to a string value safe to
+ * pass into JSX `aria-label`. Returns `undefined` for non-string or
+ * empty-string descriptions so Solid drops the attribute rather than
+ * stringifying e.g. `{}` to `"[object Object]"`.
+ */
+declare function ariaLabel(description: unknown): string | undefined;
+/**
+ * Structured constraint-hint data for the Solid renderers. Identical
+ * shape to `react/a11y.ts` `HintInfo` — the input takes the
+ * `ariaDescribedBy` id, the renderer emits a sibling `<small id={...}>`
+ * whose text is `hint`. Returns `undefined` when the field has no
+ * advertise-able constraints.
+ */
+interface HintInfo {
+  readonly id: string;
+  readonly hint: string;
+  readonly ariaDescribedBy: string;
+}
+/**
+ * Build {@link HintInfo} for a field at `inputId` given its declared
+ * constraints. Returns `undefined` when no constraint message would be
+ * produced.
+ */
+declare function buildHintInfo(inputId: string, constraints: AllConstraints): HintInfo | undefined;
+//#endregion
+export { Hint, HintInfo, ariaLabel, buildAriaAttrs, buildHintInfo, constraintHint, isFieldRequired };

package/dist/solid/a11y.mjs

@@ -0,0 +1,71 @@
+import { constraintHint as constraintHint$1 } from "../core/constraintHint.mjs";
+import { hintIdFor } from "../core/idPath.mjs";
+//#region src/solid/a11y.ts
+/**
+* Build the ARIA attribute bundle for a renderer.
+*
+* - `aria-required="true"` whenever the field is non-optional.
+* - `aria-describedby=<hint-id>` whenever a constraint hint applies.
+* - `aria-label=<description>` when a non-empty description is supplied.
+*
+* Pass `inputId` + `constraints` only when the renderer emits a
+* constraint-hint sibling; the helper then auto-derives the
+* `aria-describedby` value from `hintIdFor(inputId)`. Omitting either
+* argument skips the attribute.
+*/
+function buildAriaAttrs(tree, description, inputId, constraints) {
+	const attrs = {};
+	if (tree.isOptional === false) attrs["aria-required"] = "true";
+	if (inputId !== void 0 && constraints !== void 0 && constraintHint$1(constraints) !== void 0) attrs["aria-describedby"] = hintIdFor(inputId);
+	if (typeof description === "string" && description.length > 0) attrs["aria-label"] = description;
+	return attrs;
+}
+/**
+* Derive the constraint-hint descriptor for a field at `inputId`.
+* Returns `undefined` when the field has no constraint worth
+* announcing — callers skip rendering the `<small>` element entirely
+* rather than emitting an empty node.
+*/
+function constraintHint(inputId, constraints) {
+	const text = constraintHint$1(constraints);
+	if (text === void 0) return void 0;
+	return {
+		id: hintIdFor(inputId),
+		text
+	};
+}
+/**
+* True when the supplied field is non-optional and therefore deserves
+* a visual required indicator alongside its label.
+*/
+function isFieldRequired(tree) {
+	return tree.isOptional === false;
+}
+/**
+* Narrow `meta.description` (typed `unknown`) to a string value safe to
+* pass into JSX `aria-label`. Returns `undefined` for non-string or
+* empty-string descriptions so Solid drops the attribute rather than
+* stringifying e.g. `{}` to `"[object Object]"`.
+*/
+function ariaLabel(description) {
+	if (typeof description !== "string") return void 0;
+	if (description.length === 0) return void 0;
+	return description;
+}
+/**
+* Build {@link HintInfo} for a field at `inputId` given its declared
+* constraints. Returns `undefined` when no constraint message would be
+* produced.
+*/
+function buildHintInfo(inputId, constraints) {
+	const hint = constraintHint$1(constraints);
+	if (hint === void 0) return void 0;
+	const id = hintIdFor(inputId);
+	return {
+		id,
+		hint,
+		ariaDescribedBy: id
+	};
+}
+//#endregion
+export { ariaLabel, buildAriaAttrs, buildHintInfo, constraintHint, isFieldRequired };

package/dist/solid/contexts.d.mts

@@ -0,0 +1,37 @@
+import { ContextPort } from "../core/contexts.mjs";
+import { SolidComponentResolver, SolidWidgetMap } from "./types.mjs";
+import { Context } from "solid-js";
+
+//#region src/solid/contexts.d.ts
+/**
+ * Solid context carrying the theme resolver propagated by
+ * {@link SchemaProvider}. Default value `undefined` — the renderer falls
+ * back to the headless resolver when no provider sits above a
+ * `<SchemaComponent>`.
+ */
+declare const UserResolverContext: Context<SolidComponentResolver | undefined>;
+/**
+ * Solid context carrying the widget map provided by
+ * {@link SchemaProvider}. Default value `undefined` — the renderer
+ * dispatches to instance widgets / globals when no provider supplies a
+ * context-level map.
+ */
+declare const WidgetsContext: Context<SolidWidgetMap | undefined>;
+/**
+ * Solid binding of {@link ContextPort} for the user resolver context.
+ *
+ * Exposed primarily so the {@link ContextPort} contract has a concrete
+ * Solid implementation alongside the React, Vue and Svelte bindings —
+ * generic consumers (cross-framework testing, port-driven adapters)
+ * can read the resolver without depending on Solid's native context
+ * shape. The Solid {@link SchemaProvider} component performs the actual
+ * `<Context.Provider>` wrapping in its template.
+ */
+declare const userResolverPort: ContextPort<SolidComponentResolver | undefined>;
+/**
+ * Solid binding of {@link ContextPort} for the widgets context. Parallel
+ * to {@link userResolverPort}.
+ */
+declare const widgetsPort: ContextPort<SolidWidgetMap | undefined>;
+//#endregion
+export { UserResolverContext, WidgetsContext, userResolverPort, widgetsPort };

package/dist/solid/contexts.mjs

@@ -0,0 +1,66 @@
+import { createContext, useContext } from "solid-js";
+//#region src/solid/contexts.ts
+/**
+* Solid bindings for the framework-agnostic {@link ContextPort} contract.
+*
+* Wraps Solid's native `createContext`/`useContext` primitives into the
+* shape every framework adapter exposes. Two ports are pre-bound for the
+* schema-components subtree — the theme resolver and the widget map —
+* mirroring the React adapter's `UserResolverContext` and
+* `WidgetsContext`.
+*
+* Unlike React's wrapping `<Provider>` JSX, Solid's `<Context.Provider>`
+* is itself a JSX component and must be invoked from inside a JSX tree.
+* The {@link ContextPort.provide} adapter therefore cannot construct the
+* Solid `<Provider>` element directly — it returns `children` unchanged,
+* relying on the Solid `<SchemaProvider>` template to wrap descendants
+* with the underlying `Context.Provider`. The ports exist so the generic
+* {@link ContextPort} contract has a concrete Solid implementation that
+* cross-framework consumers can introspect.
+*/
+/**
+* Solid context carrying the theme resolver propagated by
+* {@link SchemaProvider}. Default value `undefined` — the renderer falls
+* back to the headless resolver when no provider sits above a
+* `<SchemaComponent>`.
+*/
+const UserResolverContext = createContext(void 0);
+/**
+* Solid context carrying the widget map provided by
+* {@link SchemaProvider}. Default value `undefined` — the renderer
+* dispatches to instance widgets / globals when no provider supplies a
+* context-level map.
+*/
+const WidgetsContext = createContext(void 0);
+/**
+* Solid binding of {@link ContextPort} for the user resolver context.
+*
+* Exposed primarily so the {@link ContextPort} contract has a concrete
+* Solid implementation alongside the React, Vue and Svelte bindings —
+* generic consumers (cross-framework testing, port-driven adapters)
+* can read the resolver without depending on Solid's native context
+* shape. The Solid {@link SchemaProvider} component performs the actual
+* `<Context.Provider>` wrapping in its template.
+*/
+const userResolverPort = {
+	provide(_value, children) {
+		return children;
+	},
+	consume() {
+		return useContext(UserResolverContext);
+	}
+};
+/**
+* Solid binding of {@link ContextPort} for the widgets context. Parallel
+* to {@link userResolverPort}.
+*/
+const widgetsPort = {
+	provide(_value, children) {
+		return children;
+	},
+	consume() {
+		return useContext(WidgetsContext);
+	}
+};
+//#endregion
+export { UserResolverContext, WidgetsContext, userResolverPort, widgetsPort };

package/dist/solid/headless.d.mts

@@ -0,0 +1,10 @@
+import { SolidComponentResolver } from "./types.mjs";
+
+//#region src/solid/headless.d.ts
+/**
+ * The Solid headless resolver. Every variant of `WalkedField` is wired
+ * here; theme adapters override individual keys to customise the look.
+ */
+declare const headlessSolidResolver: SolidComponentResolver;
+//#endregion
+export { headlessSolidResolver };

package/dist/solid/headless.mjs

@@ -0,0 +1,27 @@
+import { renderArray, renderBoolean, renderConditional, renderDiscriminatedUnion, renderEnum, renderFile, renderLiteral, renderNegation, renderNever, renderNull, renderNumber, renderObject, renderRecord, renderString, renderTuple, renderUnion, renderUnknown } from "./renderers.mjs";
+//#region src/solid/headless.ts
+/**
+* The Solid headless resolver. Every variant of `WalkedField` is wired
+* here; theme adapters override individual keys to customise the look.
+*/
+const headlessSolidResolver = {
+	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,
+	never: renderNever,
+	unknown: renderUnknown
+};
+//#endregion
+export { headlessSolidResolver };

package/dist/solid/renderers.d.mts

@@ -0,0 +1,79 @@
+import { j as WalkedField } from "../types-BBQaEPfE.mjs";
+import { SolidRenderProps } from "./types.mjs";
+import { JSX } from "solid-js";
+
+//#region src/solid/renderers.d.ts
+/**
+ * Build a stable, unique input ID from the path. Re-exported alias for
+ * {@link fieldDomId} so the Solid adapter has the same import shape as
+ * the React adapter's `inputId`.
+ */
+declare function inputId(path: string): string;
+/** Headless renderer for `StringField` — plain `<input>` / `<span>`. */
+declare function renderString(props: SolidRenderProps): JSX.Element;
+/** Headless renderer for `NumberField` — plain `<input type="number">`. */
+declare function renderNumber(props: SolidRenderProps): JSX.Element;
+/** Headless renderer for `BooleanField` — plain `<input type="checkbox">`. */
+declare function renderBoolean(props: SolidRenderProps): JSX.Element;
+/** Headless renderer for `EnumField` — plain `<select>` listing each option. */
+declare function renderEnum(props: SolidRenderProps): JSX.Element;
+/**
+ * Compute the default value for a freshly added record entry based on
+ * the record's value-type schema. Mirrors the React headless
+ * implementation byte-for-byte so both adapters seed new entries the
+ * same way.
+ */
+declare function defaultRecordValue(valueType: WalkedField): unknown;
+/**
+ * Generate a unique, currently-unused key for a new record entry.
+ * Picks the first of `key`, `key-1`, `key-2`, … not in `existing`.
+ */
+declare function nextRecordKey(existing: readonly string[], base?: string): string;
+/**
+ * Rename a key in an object while preserving insertion order. Returns
+ * the original object reference when the rename is a no-op
+ * (oldKey === newKey) or when newKey collides with an existing key.
+ */
+declare function renameRecordKey(obj: Record<string, unknown>, oldKey: string, newKey: string): Record<string, unknown>;
+/** Headless renderer for `ObjectField` — `<fieldset>` per object. */
+declare function renderObject(props: SolidRenderProps): JSX.Element;
+/** Headless renderer for `RecordField` — editable key/value rows. */
+declare function renderRecord(props: SolidRenderProps): JSX.Element;
+/** Headless renderer for `ArrayField` — ordered list with add/remove controls. */
+declare function renderArray(props: SolidRenderProps): JSX.Element;
+/** Headless renderer for plain `UnionField` — picks the matching option. */
+declare function renderUnion(props: SolidRenderProps): JSX.Element;
+/**
+ * Pure helper: convert a tab index into the new value the discriminated
+ * union should emit. Returns `undefined` when the index is out of bounds.
+ *
+ * Extracted so the contract is unit-testable without rendering the tabs
+ * component. Mirrors the React adapter's `discriminatedUnionValueForTab`.
+ */
+declare function discriminatedUnionValueForTab(optionLabels: readonly string[], discKey: string, newIndex: number): Record<string, string> | undefined;
+/** Headless renderer for `DiscriminatedUnionField` — tabbed UI. */
+declare function renderDiscriminatedUnion(props: SolidRenderProps): JSX.Element;
+/** Headless renderer for `FileField` — plain `<input type="file">`. */
+declare function renderFile(props: SolidRenderProps): JSX.Element;
+/**
+ * Render a literal field — `z.literal("a")` or `{ const: 5 }`.
+ *
+ * Literals are non-editable by nature; both read-only and editable modes
+ * display the literal value(s). Multiple literals (`z.literal(["a","b"])`)
+ * render comma-separated.
+ */
+declare function renderLiteral(props: SolidRenderProps): JSX.Element;
+/** Render a null field — `z.null()` or `{ type: "null" }`. */
+declare function renderNull(props: SolidRenderProps): JSX.Element;
+/** Render a never field — `z.never()` or `{ not: {} }` / `false` schema. */
+declare function renderNever(props: SolidRenderProps): JSX.Element;
+/** Render a tuple field — positional rendering of each prefix item. */
+declare function renderTuple(props: SolidRenderProps): JSX.Element;
+/** Render a conditional field — JSON Schema `if`/`then`/`else`. */
+declare function renderConditional(props: SolidRenderProps): JSX.Element;
+/** Render a negation field — JSON Schema `{ not: { ... } }`. */
+declare function renderNegation(props: SolidRenderProps): JSX.Element;
+/** Headless renderer for `UnknownField` — JSON-encoded fallback. */
+declare function renderUnknown(props: SolidRenderProps): JSX.Element;
+//#endregion
+export { defaultRecordValue, discriminatedUnionValueForTab, inputId, nextRecordKey, renameRecordKey, renderArray, renderBoolean, renderConditional, renderDiscriminatedUnion, renderEnum, renderFile, renderLiteral, renderNegation, renderNever, renderNull, renderNumber, renderObject, renderRecord, renderString, renderTuple, renderUnion, renderUnknown };