schema-components 1.12.11 → 1.14.0

package/dist/core/merge.mjs

@@ -0,0 +1,125 @@
+import { isObject } from "./guards.mjs";
+//#region src/core/merge.ts
+/**
+* Schema merging, nullable detection, and discriminated union detection.
+*
+* Used by the walker to handle `allOf`, `anyOf [T, null]`, and
+* `oneOf` with discriminator properties.
+*/
+function getString(obj, key) {
+	const value = obj[key];
+	return typeof value === "string" ? value : void 0;
+}
+function getArray(obj, key) {
+	const value = obj[key];
+	return Array.isArray(value) ? value : void 0;
+}
+function getObject(obj, key) {
+	const value = obj[key];
+	return isObject(value) ? value : void 0;
+}
+/**
+* Annotation keywords that can appear as siblings of `$ref` per
+* Draft 2020-12 / OpenAPI 3.1. Structural keywords (type, properties,
+* etc.) are NOT annotation siblings and should not be merged.
+*/
+const ANNOTATION_SIBLINGS = new Set([
+	"title",
+	"description",
+	"default",
+	"examples",
+	"deprecated",
+	"readOnly",
+	"writeOnly",
+	"$comment"
+]);
+/**
+* Merge annotation siblings from the referencing node onto the
+* resolved target's annotations. The referencer wins for annotations.
+*
+* Structural keywords on the referencer are NOT merged — per spec,
+* `$ref` with structural siblings was invalid pre-2019-09.
+*
+* Returns a new meta object with the merged annotations.
+*/
+function mergeRefSiblings(referencer, resolvedMeta) {
+	const merged = { ...resolvedMeta };
+	for (const key of ANNOTATION_SIBLINGS) if (key in referencer) merged[key] = referencer[key];
+	return merged;
+}
+/**
+* Merge multiple JSON Schema objects from allOf into one.
+* Merges: properties, required, meta fields, and constraints.
+*/
+function mergeAllOf(schemas) {
+	const merged = {};
+	const properties = {};
+	const required = [];
+	for (const entry of schemas) {
+		if (!isObject(entry)) continue;
+		const props = getObject(entry, "properties");
+		if (props !== void 0) for (const [key, value] of Object.entries(props)) properties[key] = value;
+		const req = getArray(entry, "required");
+		if (req !== void 0) {
+			for (const r of req) if (typeof r === "string" && !required.includes(r)) required.push(r);
+		}
+		for (const [key, value] of Object.entries(entry)) {
+			if (key === "properties" || key === "required" || key === "allOf" || key === "type") continue;
+			if (!(key in merged)) merged[key] = value;
+		}
+		if (!("type" in merged)) {
+			const type = getString(entry, "type");
+			if (type !== void 0) merged.type = type;
+		}
+	}
+	if (Object.keys(properties).length > 0) merged.properties = properties;
+	if (required.length > 0) merged.required = required;
+	return merged;
+}
+/**
+* Detect `anyOf: [T, { type: "null" }]` → nullable T.
+* Returns the non-null schema and a nullable flag.
+*/
+function normaliseAnyOf(options) {
+	if (options.length !== 2) return void 0;
+	let inner;
+	let hasNull = false;
+	for (const opt of options) {
+		if (!isObject(opt)) return void 0;
+		if (opt.type === "null") hasNull = true;
+		else inner = opt;
+	}
+	if (!hasNull || inner === void 0) return void 0;
+	return {
+		inner,
+		isNullable: true
+	};
+}
+/**
+* Detect oneOf where every option is an object with a property
+* that has a `const` value → discriminated union.
+*/
+function detectDiscriminated(options) {
+	if (options.length === 0) return void 0;
+	let discriminator;
+	for (const opt of options) {
+		if (!isObject(opt)) return void 0;
+		const props = getObject(opt, "properties");
+		if (props === void 0) return void 0;
+		let foundKey;
+		for (const [key, value] of Object.entries(props)) if (isObject(value) && "const" in value) {
+			foundKey = key;
+			break;
+		}
+		if (foundKey === void 0) return void 0;
+		if (discriminator === void 0) discriminator = foundKey;
+		else if (discriminator !== foundKey) return;
+	}
+	if (discriminator === void 0) return void 0;
+	return {
+		options: options.filter(isObject),
+		discriminator
+	};
+}
+//#endregion
+export { ANNOTATION_SIBLINGS, detectDiscriminated, mergeAllOf, mergeRefSiblings, normaliseAnyOf };

package/dist/core/normalise.d.mts

@@ -0,0 +1,41 @@
+import { i as DiagnosticsOptions } from "../diagnostics-DzbZmcLI.mjs";
+import { n as JsonSchemaDraft, r as OpenApiVersionInfo } from "../version-B5NV-35j.mjs";
+
+//#region src/core/normalise.d.ts
+type NodeTransform = (node: Record<string, unknown>) => Record<string, unknown>;
+/**
+ * Deep-normalise a JSON Schema object by applying a per-node transform
+ * and recursing into every sub-schema location.
+ */
+declare function deepNormalise(schema: Record<string, unknown>, transform: NodeTransform): Record<string, unknown>;
+/**
+ * Normalise Draft 04 `exclusiveMinimum`/`exclusiveMaximum` from boolean
+ * to number form.
+ *
+ * In Draft 04:
+ * - `exclusiveMinimum: true` + `minimum: 5` → value must be > 5
+ * - `exclusiveMinimum: false` (or absent) + `minimum: 5` → value must be >= 5
+ *
+ * In Draft 06+:
+ * - `exclusiveMinimum: 5` → value must be > 5 (no separate `minimum`)
+ * - `minimum: 5` → value must be >= 5
+ *
+ * The transform converts boolean form to number form so the walker can
+ * treat `exclusiveMinimum`/`exclusiveMaximum` uniformly as numbers.
+ */
+declare function normaliseDraft04Node(node: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Normalise a JSON Schema to canonical Draft 2020-12 form.
+ * Deep-clones the input — the original is never mutated.
+ */
+declare function normaliseJsonSchema(schema: Record<string, unknown>, draft: JsonSchemaDraft): Record<string, unknown>;
+/**
+ * Normalise an OpenAPI document's schemas for walker consumption.
+ * Handles version-specific keyword transformations.
+ *
+ * Returns the same object reference if no normalisation is needed
+ * (OpenAPI 3.1.x), or a deep-cloned normalised copy otherwise.
+ */
+declare function normaliseOpenApiSchemas(doc: Record<string, unknown>, version: OpenApiVersionInfo, diagnostics?: DiagnosticsOptions): Record<string, unknown>;
+//#endregion
+export { NodeTransform, deepNormalise, normaliseDraft04Node, normaliseJsonSchema, normaliseOpenApiSchemas };

package/dist/core/normalise.mjs

@@ -0,0 +1,2 @@
+import { i as normaliseOpenApiSchemas, n as normaliseDraft04Node, r as normaliseJsonSchema, t as deepNormalise } from "../normalise-tL9FckAk.mjs";
+export { deepNormalise, normaliseDraft04Node, normaliseJsonSchema, normaliseOpenApiSchemas };

package/dist/core/openapi30.d.mts

@@ -0,0 +1,41 @@
+import { NodeTransform } from "./normalise.mjs";
+
+//#region src/core/openapi30.d.ts
+/**
+ * Normalise OpenAPI 3.0.x `nullable` keyword to `anyOf [T, null]`.
+ *
+ * OpenAPI 3.0 uses `nullable: true` instead of the JSON Schema standard
+ * `anyOf: [T, { type: "null" }]`. The walker understands the latter form
+ * natively, so this normaliser converts `nullable` to `anyOf`.
+ *
+ * Only applied when `nullable` is explicitly `true`. `nullable: false` or
+ * absent is the default and requires no transformation.
+ */
+declare function normaliseOpenApi30Node(node: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Normalise OpenAPI 3.0.x `discriminator` keyword by injecting `const`
+ * values into each `oneOf`/`anyOf` option's discriminator property.
+ *
+ * In OpenAPI 3.0, `discriminator` is a sibling of `oneOf`/`anyOf`:
+ *   discriminator: { propertyName: "type" }
+ * The walker detects discriminated unions from `oneOf` + `const` on a
+ * property, so this normaliser injects the `const` values from the
+ * `mapping` or infers them from `$ref` fragment names.
+ */
+declare function normaliseOpenApi30Discriminator(node: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Combined OpenAPI 3.0.x node transform: Draft 04 + nullable + discriminator.
+ * Applied to every schema node in an OpenAPI 3.0 document.
+ *
+ * Draft 04 normalisation is included because OpenAPI 3.0 inherits
+ * Draft 04/05 schema semantics including `exclusiveMinimum: boolean`.
+ */
+declare function normaliseOpenApi30Combined(node: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Deep-normalise all schemas in an OpenAPI 3.0.x document.
+ * Walks components/schemas, path operations, parameters, request bodies,
+ * and responses — applying `nullable` normalisation to each schema.
+ */
+declare function deepNormaliseOpenApi30Doc(doc: Record<string, unknown>, deepNormalise: (schema: Record<string, unknown>, transform: NodeTransform) => Record<string, unknown>): Record<string, unknown>;
+//#endregion
+export { deepNormaliseOpenApi30Doc, normaliseOpenApi30Combined, normaliseOpenApi30Discriminator, normaliseOpenApi30Node };

package/dist/core/openapi30.mjs

@@ -0,0 +1,2 @@
+import { c as normaliseOpenApi30Discriminator, l as normaliseOpenApi30Node, o as deepNormaliseOpenApi30Doc, s as normaliseOpenApi30Combined } from "../normalise-tL9FckAk.mjs";
+export { deepNormaliseOpenApi30Doc, normaliseOpenApi30Combined, normaliseOpenApi30Discriminator, normaliseOpenApi30Node };

package/dist/core/ref.d.mts

@@ -0,0 +1,2 @@
+import { a as findAnchor, i as dereference, n as RefOptions, o as resolveRef, r as countDistinctRefs, t as ExternalResolver } from "../ref-DvWoULcy.mjs";
+export { ExternalResolver, RefOptions, countDistinctRefs, dereference, findAnchor, resolveRef };

package/dist/core/ref.mjs

@@ -0,0 +1,165 @@
+import { isObject } from "./guards.mjs";
+import { emitDiagnostic } from "./diagnostics.mjs";
+//#region src/core/ref.ts
+/**
+* $ref resolution for JSON Schema.
+*
+* Handles JSON Pointer dereference, $anchor lookup, cycle detection,
+* and depth limiting derived from the document's own $ref count.
+*/
+function getString(obj, key) {
+	const value = obj[key];
+	return typeof value === "string" ? value : void 0;
+}
+/**
+* Count all distinct `$ref` strings reachable from a root document.
+* A chain longer than the number of distinct refs is necessarily cyclic.
+* Returns at least 1 so that single-ref schemas have a usable bound.
+*/
+function countDistinctRefs(root) {
+	const refs = /* @__PURE__ */ new Set();
+	collectRefs(root, refs);
+	return Math.max(refs.size, 1);
+}
+function collectRefs(node, refs) {
+	if (!isObject(node)) return;
+	const ref = node.$ref;
+	if (typeof ref === "string") refs.add(ref);
+	for (const value of Object.values(node)) if (isObject(value)) collectRefs(value, refs);
+	else if (Array.isArray(value)) for (const item of value) collectRefs(item, refs);
+}
+/**
+* Resolve a `$ref` in a schema against a root document.
+* Returns the original schema if no `$ref` is present.
+* Returns an unknown-schema placeholder on cycle or depth exceeded.
+*
+* The depth bound is derived from the number of distinct `$ref` strings
+* in the root document — a chain longer than that count is necessarily
+* cyclic. When `maxDepth` is not provided, a reasonable default is used.
+*/
+function resolveRef(schema, rootDocument, visited, diagnostics, maxDepth, externalResolver) {
+	const ref = getString(schema, "$ref");
+	if (ref === void 0) return schema;
+	if (visited.has(ref)) {
+		emitDiagnostic(diagnostics, {
+			code: "unresolved-ref",
+			message: `Circular $ref detected: ${ref}`,
+			pointer: ref,
+			detail: { ref }
+		});
+		return {
+			type: "unknown",
+			editability: "editable",
+			meta: {},
+			constraints: {}
+		};
+	}
+	const depthLimit = maxDepth ?? 64;
+	if (visited.size >= depthLimit) {
+		emitDiagnostic(diagnostics, {
+			code: "depth-exceeded",
+			message: `$ref depth exceeded derived bound (${String(depthLimit)}): ${ref}`,
+			pointer: ref,
+			detail: {
+				ref,
+				depth: visited.size,
+				bound: depthLimit
+			}
+		});
+		return {
+			type: "unknown",
+			editability: "editable",
+			meta: {},
+			constraints: {}
+		};
+	}
+	if (!ref.startsWith("#") && externalResolver !== void 0) {
+		const hashIndex = ref.indexOf("#");
+		const uri = hashIndex >= 0 ? ref.slice(0, hashIndex) : ref;
+		const fragment = hashIndex >= 0 ? ref.slice(hashIndex) : "#";
+		const externalDoc = externalResolver(uri);
+		if (isObject(externalDoc)) {
+			const target = dereference(fragment, externalDoc);
+			if (target !== void 0) {
+				const nextVisited = new Set(visited);
+				nextVisited.add(ref);
+				return resolveRef(target, externalDoc, nextVisited, diagnostics, maxDepth, externalResolver);
+			}
+		}
+		emitDiagnostic(diagnostics, {
+			code: "external-ref",
+			message: `External resolver returned no document for: ${ref}`,
+			pointer: ref,
+			detail: {
+				ref,
+				uri
+			}
+		});
+		return {
+			type: "unknown",
+			editability: "editable",
+			meta: {},
+			constraints: {}
+		};
+	}
+	const resolved = dereference(ref, rootDocument);
+	if (resolved === void 0) {
+		emitDiagnostic(diagnostics, {
+			code: "unresolved-ref",
+			message: `Could not resolve $ref: ${ref}`,
+			pointer: ref,
+			detail: { ref }
+		});
+		return {
+			type: "unknown",
+			editability: "editable",
+			meta: {},
+			constraints: {}
+		};
+	}
+	const nextVisited = new Set(visited);
+	nextVisited.add(ref);
+	return resolveRef(resolved, rootDocument, nextVisited, diagnostics, maxDepth, externalResolver);
+}
+/**
+* Dereference a JSON Pointer fragment (`#/path/to/schema`) or an
+* `$anchor` (`#SomeName`) against a root document.
+*/
+function dereference(ref, root) {
+	if (ref === "#") return root;
+	if (ref.startsWith("#/")) {
+		const parts = ref.slice(2).split("/");
+		if (parts.length === 1 && parts[0] === "") return root;
+		let current = root;
+		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 : void 0;
+	}
+	if (ref.startsWith("#") && ref.length > 1) {
+		const found = findAnchor(root, ref.slice(1));
+		if (found !== void 0) return found;
+	}
+}
+/**
+* Recursively scan a schema document for a `$anchor` matching the given name.
+* Returns the schema object containing the anchor, or undefined.
+*/
+function findAnchor(node, anchorName) {
+	if (!isObject(node)) return void 0;
+	if (node.$anchor === anchorName) return node;
+	for (const value of Object.values(node)) {
+		if (isObject(value)) {
+			const found = findAnchor(value, anchorName);
+			if (found !== void 0) return found;
+		}
+		if (Array.isArray(value)) for (const item of value) {
+			const found = findAnchor(item, anchorName);
+			if (found !== void 0) return found;
+		}
+	}
+}
+//#endregion
+export { countDistinctRefs, dereference, findAnchor, resolveRef };

package/dist/core/renderer.d.mts

@@ -1,2 +1,2 @@
-import { A as mergeResolvers, C as HtmlResolver, D as getHtmlRenderFn, E as RenderProps, O as getRenderFunction, S as HtmlRenderProps, T as RenderFunction, b as ComponentResolver, j as typeToKey, k as mergeHtmlResolvers, w as RESOLVER_KEYS, x as HtmlRenderFunction, y as BaseFieldProps } from "../types-BJzEgJdX.mjs";
-export { BaseFieldProps, ComponentResolver, HtmlRenderFunction, HtmlRenderProps, HtmlResolver, RESOLVER_KEYS, RenderFunction, RenderProps, getHtmlRenderFn, getRenderFunction, mergeHtmlResolvers, mergeResolvers, typeToKey };
+import { a as HtmlRenderProps, c as RenderFunction, d as getRenderFunction, f as mergeHtmlResolvers, i as HtmlRenderFunction, l as RenderProps, m as typeToKey, n as BaseFieldProps, o as HtmlResolver, p as mergeResolvers, r as ComponentResolver, s as RESOLVER_KEYS, t as AllConstraints, u as getHtmlRenderFn } from "../renderer-BdSqllx5.mjs";
+export { AllConstraints, BaseFieldProps, ComponentResolver, HtmlRenderFunction, HtmlRenderProps, HtmlResolver, RESOLVER_KEYS, RenderFunction, RenderProps, getHtmlRenderFn, getRenderFunction, mergeHtmlResolvers, mergeResolvers, typeToKey };

package/dist/core/renderer.mjs

@@ -6,9 +6,13 @@ const RESOLVER_KEYS = [
 	"enum",
 	"object",
 	"array",
+	"tuple",
 	"record",
 	"union",
 	"discriminatedUnion",
+	"conditional",
+	"negation",
+	"recursive",
 	"literal",
 	"file",
 	"unknown"
@@ -25,9 +29,13 @@ function typeToKey(type) {
 		case "enum":
 		case "object":
 		case "array":
+		case "tuple":
 		case "record":
 		case "union":
 		case "discriminatedUnion":
+		case "conditional":
+		case "negation":
+		case "recursive":
 		case "literal":
 		case "file":
 		case "unknown": return type;

package/dist/core/swagger2.d.mts

@@ -0,0 +1,11 @@
+import { i as DiagnosticsOptions } from "../diagnostics-DzbZmcLI.mjs";
+import { NodeTransform } from "./normalise.mjs";
+
+//#region src/core/swagger2.d.ts
+/**
+ * Transform a Swagger 2.0 document into an OpenAPI 3.1-compatible
+ * structure.
+ */
+declare function normaliseSwagger2Document(doc: Record<string, unknown>, deepNormalise: (schema: Record<string, unknown>, transform: NodeTransform) => Record<string, unknown>, normaliseDraft04Node: NodeTransform, diagnostics?: DiagnosticsOptions): Record<string, unknown>;
+//#endregion
+export { normaliseSwagger2Document };

package/dist/core/swagger2.mjs

@@ -0,0 +1,2 @@
+import { a as normaliseSwagger2Document } from "../normalise-tL9FckAk.mjs";
+export { normaliseSwagger2Document };

package/dist/core/typeInference.d.mts

@@ -0,0 +1,2 @@
+import { a as OpenAPIRequestBodyType, c as ResolveOpenAPIRef, d as __SchemaInferenceFellBack, i as InferResponseFields, l as TypeAtPath, n as InferParameterOverrides, o as OpenAPIResponseType, r as InferRequestBodyFields, s as PathOfType, t as FromJSONSchema, u as UnsafeFields } from "../typeInference-k7FXfTVO.mjs";
+export { FromJSONSchema, InferParameterOverrides, InferRequestBodyFields, InferResponseFields, OpenAPIRequestBodyType, OpenAPIResponseType, PathOfType, ResolveOpenAPIRef, TypeAtPath, UnsafeFields, __SchemaInferenceFellBack };

package/dist/core/typeInference.mjs

@@ -0,0 +1 @@
+export {};

package/dist/core/types.d.mts

@@ -1,3 +1,2 @@
-import { C as HtmlResolver, E as RenderProps, S as HtmlRenderProps, T as RenderFunction, _ as WalkedField, a as FromJSONSchema, b as ComponentResolver, c as InferResponseFields, d as OpenAPIResponseType, f as PathOfType, g as TypeAtPath, h as SchemaType, i as FieldOverrides, l as JsonObject, m as SchemaMeta, n as FieldConstraints, o as InferParameterOverrides, p as ResolveOpenAPIRef, r as FieldOverride, s as InferRequestBodyFields, t as Editability, u as OpenAPIRequestBodyType, v as resolveEditability, x as HtmlRenderFunction, y as BaseFieldProps } from "../types-BJzEgJdX.mjs";
-import { i as SchemaRenderError, n as SchemaFieldError, r as SchemaNormalisationError, t as SchemaError } from "../errors-DIKI2C78.mjs";
-export { BaseFieldProps, ComponentResolver, Editability, FieldConstraints, FieldOverride, FieldOverrides, FromJSONSchema, HtmlRenderFunction, HtmlRenderProps, HtmlResolver, InferParameterOverrides, InferRequestBodyFields, InferResponseFields, JsonObject, OpenAPIRequestBodyType, OpenAPIResponseType, PathOfType, RenderFunction, RenderProps, ResolveOpenAPIRef, SchemaError, SchemaFieldError, SchemaMeta, SchemaNormalisationError, SchemaRenderError, SchemaType, TypeAtPath, WalkedField, resolveEditability };
+import { A as UnionField, B as isNegationField, C as RecordField, D as StringConstraints, E as SchemaType, F as isConditionalField, G as isRecordField, H as isNullField, I as isDiscriminatedUnionField, J as isTupleField, K as isRecursiveField, L as isEnumField, M as WalkedField, N as isArrayField, O as StringField, P as isBooleanField, R as isFileField, S as ObjectField, T as SchemaMeta, U as isNumberField, V as isNeverField, W as isObjectField, X as isUnknownField, Y as isUnionField, Z as resolveEditability, _ as NeverField, a as DiscriminatedUnionField, b as NumberField, c as FieldBase, d as FieldOverrides, f as FileConstraints, g as NegationField, h as LiteralField, i as ConditionalField, j as UnknownField, k as TupleField, l as FieldConstraints, m as JsonObject, n as ArrayField, o as Editability, p as FileField, q as isStringField, r as BooleanField, s as EnumField, t as ArrayConstraints, u as FieldOverride, v as NullField, w as RecursiveField, x as ObjectConstraints, y as NumberConstraints, z as isLiteralField } from "../types-D_5ST7SS.mjs";
+export { ArrayConstraints, ArrayField, BooleanField, ConditionalField, DiscriminatedUnionField, Editability, EnumField, FieldBase, FieldConstraints, FieldOverride, FieldOverrides, FileConstraints, FileField, JsonObject, LiteralField, NegationField, NeverField, NullField, NumberConstraints, NumberField, ObjectConstraints, ObjectField, RecordField, RecursiveField, SchemaMeta, SchemaType, StringConstraints, StringField, TupleField, UnionField, UnknownField, WalkedField, isArrayField, isBooleanField, isConditionalField, isDiscriminatedUnionField, isEnumField, isFileField, isLiteralField, isNegationField, isNeverField, isNullField, isNumberField, isObjectField, isRecordField, isRecursiveField, isStringField, isTupleField, isUnionField, isUnknownField, resolveEditability };

package/dist/core/types.mjs

@@ -1,4 +1,3 @@
-import { SchemaError, SchemaFieldError, SchemaNormalisationError, SchemaRenderError } from "./errors.mjs";
 //#region src/core/types.ts
 /**
 * Resolved editability state for a single field.
@@ -36,5 +35,62 @@ function resolveEditability(propertyMeta, componentMeta, rootMeta) {
 	if (rootMeta !== void 0 && ("readOnly" in rootMeta || "writeOnly" in rootMeta)) return "editable";
 	return "editable";
 }
+function isField(field, t) {
+	return field.type === t;
+}
+function isStringField(field) {
+	return isField(field, "string");
+}
+function isNumberField(field) {
+	return isField(field, "number");
+}
+function isBooleanField(field) {
+	return isField(field, "boolean");
+}
+function isNullField(field) {
+	return isField(field, "null");
+}
+function isEnumField(field) {
+	return isField(field, "enum");
+}
+function isLiteralField(field) {
+	return isField(field, "literal");
+}
+function isObjectField(field) {
+	return isField(field, "object");
+}
+function isArrayField(field) {
+	return isField(field, "array");
+}
+function isTupleField(field) {
+	return isField(field, "tuple");
+}
+function isRecordField(field) {
+	return isField(field, "record");
+}
+function isUnionField(field) {
+	return isField(field, "union");
+}
+function isDiscriminatedUnionField(field) {
+	return isField(field, "discriminatedUnion");
+}
+function isConditionalField(field) {
+	return isField(field, "conditional");
+}
+function isNegationField(field) {
+	return isField(field, "negation");
+}
+function isFileField(field) {
+	return isField(field, "file");
+}
+function isRecursiveField(field) {
+	return isField(field, "recursive");
+}
+function isNeverField(field) {
+	return isField(field, "never");
+}
+function isUnknownField(field) {
+	return isField(field, "unknown");
+}
 //#endregion
-export { SchemaError, SchemaFieldError, SchemaNormalisationError, SchemaRenderError, resolveEditability };
+export { isArrayField, isBooleanField, isConditionalField, isDiscriminatedUnionField, isEnumField, isFileField, isLiteralField, isNegationField, isNeverField, isNullField, isNumberField, isObjectField, isRecordField, isRecursiveField, isStringField, isTupleField, isUnionField, isUnknownField, resolveEditability };

package/dist/core/version.d.mts

@@ -0,0 +1,2 @@
+import { a as detectOpenApiVersion, c as isOpenApi30, i as detectJsonSchemaDraft, l as isOpenApi31, n as JsonSchemaDraft, o as inferJsonSchemaDraft, r as OpenApiVersionInfo, s as inferJsonSchemaDraftWithReason, t as InferredDraft, u as isSwagger2 } from "../version-B5NV-35j.mjs";
+export { InferredDraft, JsonSchemaDraft, OpenApiVersionInfo, detectJsonSchemaDraft, detectOpenApiVersion, inferJsonSchemaDraft, inferJsonSchemaDraftWithReason, isOpenApi30, isOpenApi31, isSwagger2 };