@power-plant/schema 0.0.35 → 0.0.37

package/dist/index.mjs

@@ -1,28 +1,31 @@
-import { a as SCHEMA_ARRAY_CONCAT_KEYWORDS, i as JsonSchemaTypeNames, n as JSON_SCHEMA_PRIMITIVE_TYPES, o as SCHEMA_RECORD_KEYWORDS, r as JSON_SCHEMA_TYPES, s as SCHEMA_SINGLE_KEYWORDS, t as JSON_SCHEMA_METADATA_KEYS } from "./constants-COGt3eeW.mjs";
-import { $ as isUntypedConfigStrict, A as isJsonSchemaNever, B as isJsonSchemaString, C as isJsonSchemaDecimal, D as isJsonSchemaLiteral, E as isJsonSchemaKeywords, F as isJsonSchemaPrimitiveType, G as isJsonSchemaUnknown, H as isJsonSchemaType, I as isJsonSchemaPrimitiveUnion, J as isSchemaObject, K as isNullOnlyJsonSchema, L as isJsonSchemaRecord, M as isJsonSchemaNullable, N as isJsonSchemaNumber, O as isJsonSchemaMap, P as isJsonSchemaObject, Q as isUntypedConfig, R as isJsonSchemaRef, S as isJsonSchemaDate, T as isJsonSchemaInteger, U as isJsonSchemaUndefined, V as isJsonSchemaTuple, W as isJsonSchemaUnion, X as isSchemaWithSource, Y as isSchemaOf, Z as isStandardSchema, _ as isJsonSchemaAny, a as getPropertiesList, at as applyJsonSchemaMetadata, b as isJsonSchemaBigint, c as isSchemaNullable, d as merge, et as isUntypedInput, f as mergeMetadata, g as isJsonSchemaAllOf, h as isJsonSchema, i as getProperties, it as isValibotSchema, j as isJsonSchemaNull, k as isJsonSchemaNativeEnum, l as isValidSchemaConfigFile, m as isFileReference, n as getJsonSchema, nt as isUntypedSchema, o as getProperty, ot as getPrimarySchemaType, p as traverseSchema, q as isSchema, r as getJsonSchemaObject, rt as isUntypedSchemaStrict, s as isPropertyOptional, st as readSchemaTypes, t as addProperty, tt as isUntypedInputStrict, u as isValidSchemaInputFile, v as isJsonSchemaAnyOf, w as isJsonSchemaEnum, x as isJsonSchemaBoolean, y as isJsonSchemaArray, z as isJsonSchemaSet } from "./helpers-dvxktFml.mjs";
+import { a as JsonSchemaTypeNames, c as SCHEMA_SINGLE_KEYWORDS, i as JSON_SCHEMA_TYPES, n as JSON_SCHEMA_METADATA_KEYS, o as SCHEMA_ARRAY_CONCAT_KEYWORDS, r as JSON_SCHEMA_PRIMITIVE_TYPES, s as SCHEMA_RECORD_KEYWORDS, t as JSON_SCHEMA_CONSTRUCTOR_KEY } from "./constants-BlppSDwG.mjs";
+import { $ as isUntypedConfig, A as isJsonSchemaNativeEnum, B as isJsonSchemaSet, C as isJsonSchemaDate, D as isJsonSchemaKeywords, E as isJsonSchemaInteger, F as isJsonSchemaObject, G as isJsonSchemaUnion, H as isJsonSchemaTuple, I as isJsonSchemaPrimitiveType, J as isSchema, K as isJsonSchemaUnknown, L as isJsonSchemaPrimitiveUnion, M as isJsonSchemaNull, N as isJsonSchemaNullable, O as isJsonSchemaLiteral, P as isJsonSchemaNumber, Q as isStandardSchema, R as isJsonSchemaRecord, S as isJsonSchemaBoolean, T as isJsonSchemaEnum, U as isJsonSchemaType, V as isJsonSchemaString, W as isJsonSchemaUndefined, X as isSchemaOf, Y as isSchemaObject, Z as isSchemaWithSource, _ as isJsonSchemaAllOf, a as getPropertiesList, at as isValibotSchema, b as isJsonSchemaArray, c as isSchemaNullable, ct as readSchemaTypes, d as merge, et as isUntypedConfigStrict, f as mergeMetadata, g as isJsonSchema, h as isFileReference, i as getProperties, it as isUntypedSchemaStrict, j as isJsonSchemaNever, k as isJsonSchemaMap, l as isValidSchemaConfigFile, m as hasJsonSchemaConstructorFlag, n as getJsonSchema, nt as isUntypedInputStrict, o as getProperty, ot as applyJsonSchemaMetadata, p as traverseSchema, q as isNullOnlyJsonSchema, r as getJsonSchemaObject, rt as isUntypedSchema, s as isPropertyOptional, st as getPrimarySchemaType, t as addProperty, tt as isUntypedInput, u as isValidSchemaInputFile, v as isJsonSchemaAny, w as isJsonSchemaDecimal, x as isJsonSchemaBigint, y as isJsonSchemaAnyOf, z as isJsonSchemaRef } from "./helpers-_8ADIMSN.mjs";
+import { getJsonSchemaType } from "./codegen.mjs";
 import { n as createStoragePromises, r as normalizeKey, t as mapStorageToFileSystem } from "./storage-C3BT2Xh-.mjs";
 import { isSetObject } from "@stryke/type-checks/is-set-object";
 import { isSetString } from "@stryke/type-checks/is-set-string";
-import { isSetString as isSetString$1 } from "@stryke/type-checks";
+import { isBigInt, isBoolean, isInteger, isNull, isNumber, isRegExp, isSetArray, isSetObject as isSetObject$1, isSetString as isSetString$1, isString, isUndefined } from "@stryke/type-checks";
+import { ReflectionClass, ReflectionKind, TypeNumberBrand, isType, reflect, stringifyType } from "@deepkit/type";
+import { Cache, DeclarationTransformer, ReflectionTransformer } from "@deepkit/type-compiler";
 import { extractFileReference } from "@stryke/convert/extract-file-reference";
 import { resolveSafe } from "@stryke/fs/resolve";
 import { murmurhash } from "@stryke/hash";
 import { deepClone } from "@stryke/helpers/deep-clone";
+import { omit } from "@stryke/helpers/omit";
 import { isStandardJsonSchema } from "@stryke/json";
 import { appendPath } from "@stryke/path/append";
-import { findFileExtensionSafe, findFilePath } from "@stryke/path/find";
+import { findFileDotExtensionSafe, findFileExtensionSafe, findFilePath } from "@stryke/path/find";
 import { joinPaths } from "@stryke/path/join";
-import { plugin } from "@stryke/resolve/bundle";
 import { VALID_OBJECT_SOURCE_EXTENSIONS } from "@stryke/resolve/constants";
 import { loadSafe } from "@stryke/resolve/load";
-import { resolve } from "@stryke/resolve/resolve";
 import { list } from "@stryke/string-format/list";
 import { extractJsonSchema as extractJsonSchema$1, isZod3Type } from "@stryke/zod";
 import { toJsonSchema } from "@valibot/to-json-schema";
 import { build } from "esbuild";
-import { createGenerator } from "ts-json-schema-generator/dist/factory/generator.js";
-import { DEFAULT_CONFIG } from "ts-json-schema-generator/dist/src/Config.js";
-import ts from "typescript";
+import { createJiti } from "jiti";
+import { readFile } from "node:fs/promises";
+import ts, { DiagnosticCategory } from "typescript";
+import defu from "defu";
 
 //#region src/compatibility.ts
 const METADATA_KEYS = /* @__PURE__ */ new Set([
@@ -126,12 +129,415 @@ function assertSchemasDoNotContradict(base, override, label = "schema") {
 	if (issues.length > 0) throw new Error(`The ${label} schema contradicts the generator schema:\n${issues.map((issue) => `- ${issue}`).join("\n")}`);
 }
 
+//#endregion
+//#region src/reflection.ts
+/**
+* Maps a Deepkit numeric `brand` to JSON Schema `type` and `format`.
+*
+* @remarks
+* This function takes a `TypeNumberBrand` (which represents specific numeric types in Deepkit, such as `integer`, `float`, `int8`, etc.) and returns a corresponding JSON Schema fragment that includes the appropriate `type`, `format`, and any relevant keywords (like `multipleOf` for integers). If the brand is not recognized, it defaults to a generic JSON Schema for numbers.
+*
+* @param brand - The Deepkit numeric brand to convert.
+* @return A JSON Schema fragment representing the numeric type corresponding to the provided brand.
+*/
+function numberBrandToJsonSchema(brand) {
+	switch (brand) {
+		case TypeNumberBrand.integer: return {
+			type: "integer",
+			format: "int32",
+			multipleOf: 1
+		};
+		case TypeNumberBrand.int8: return {
+			type: "integer",
+			format: "int8",
+			multipleOf: 1
+		};
+		case TypeNumberBrand.uint8: return {
+			type: "integer",
+			format: "uint8",
+			multipleOf: 1
+		};
+		case TypeNumberBrand.int16: return {
+			type: "integer",
+			format: "int16",
+			multipleOf: 1
+		};
+		case TypeNumberBrand.uint16: return {
+			type: "integer",
+			format: "uint16",
+			multipleOf: 1
+		};
+		case TypeNumberBrand.int32: return {
+			type: "integer",
+			format: "int32",
+			multipleOf: 1
+		};
+		case TypeNumberBrand.uint32: return {
+			type: "integer",
+			format: "uint32",
+			multipleOf: 1
+		};
+		case TypeNumberBrand.float:
+		case TypeNumberBrand.float32: return {
+			type: "number",
+			format: "float"
+		};
+		case TypeNumberBrand.float64: return {
+			type: "number",
+			format: "double"
+		};
+		case void 0:
+		default: return { type: "number" };
+	}
+}
+function withReflectionTags(reflection, schema) {
+	if (!isSetObject$1(schema) || !isSetObject$1(reflection?.tags)) return schema;
+	const updatedSchema = { ...schema };
+	const tags = reflection.tags;
+	if (isSetString$1(tags.title)) updatedSchema.title = tags.title;
+	if (isSetArray(tags.alias)) updatedSchema.alias = tags.alias;
+	if (!isUndefined(tags.hidden)) updatedSchema.hidden = tags.hidden;
+	if (!isUndefined(tags.ignore)) updatedSchema.ignore = tags.ignore;
+	if (!isUndefined(tags.internal)) updatedSchema.internal = tags.internal;
+	if (!isUndefined(tags.runtime)) updatedSchema.runtime = tags.runtime;
+	if (!isUndefined(tags.readonly)) updatedSchema.readOnly = tags.readonly;
+	return updatedSchema;
+}
+function withNullable(schema) {
+	if (!isSetObject$1(schema)) return { anyOf: [schema, {
+		type: "null",
+		default: null
+	}] };
+	const rawType = schema.type;
+	const types = Array.isArray(rawType) ? [...rawType] : rawType ? [rawType] : [];
+	if (!types.includes("null")) types.push("null");
+	return {
+		...schema,
+		type: types.length === 1 ? types[0] : types
+	};
+}
+/**
+* Converts a Deepkit type reflection into a JSON Schema (draft-07) fragment.
+*/
+function reflectionToJsonSchema(reflection) {
+	return reflectionToJsonSchemaInner(reflection);
+}
+function reflectionToJsonSchemaInner(reflection) {
+	switch (reflection.kind) {
+		case ReflectionKind.any:
+		case ReflectionKind.unknown:
+		case ReflectionKind.void:
+		case ReflectionKind.object: return withReflectionTags(reflection, { name: reflection.typeName });
+		case ReflectionKind.never: return;
+		case ReflectionKind.undefined:
+		case ReflectionKind.null: return withReflectionTags(reflection, {
+			type: "null",
+			name: reflection.typeName,
+			default: null
+		});
+		case ReflectionKind.string: return withReflectionTags(reflection, {
+			type: "string",
+			name: reflection.typeName
+		});
+		case ReflectionKind.boolean: return withReflectionTags(reflection, {
+			type: "boolean",
+			name: reflection.typeName
+		});
+		case ReflectionKind.number: return withReflectionTags(reflection, numberBrandToJsonSchema(reflection.brand));
+		case ReflectionKind.bigint: return withReflectionTags(reflection, {
+			type: "integer",
+			name: reflection.typeName,
+			format: "int64"
+		});
+		case ReflectionKind.regexp: return withReflectionTags(reflection, {
+			type: "string",
+			name: reflection.typeName,
+			format: "regex",
+			contentMediaType: "text/regex"
+		});
+		case ReflectionKind.literal: {
+			const { literal } = reflection;
+			if (isBigInt(literal)) return withReflectionTags(reflection, {
+				type: "integer",
+				name: reflection.typeName,
+				format: "int64",
+				const: literal
+			});
+			if (isRegExp(literal)) return withReflectionTags(reflection, {
+				type: "string",
+				name: reflection.typeName,
+				format: "regex",
+				const: literal.source
+			});
+			return withReflectionTags(reflection, {
+				type: getJsonSchemaType(literal),
+				name: reflection.typeName,
+				const: literal
+			});
+		}
+		case ReflectionKind.templateLiteral: return withReflectionTags(reflection, { type: "string" });
+		case ReflectionKind.enum: {
+			const values = reflection.values.filter((value) => isString(value) || isInteger(value) || isBigInt(value) || isNumber(value) || isBoolean(value) || isNull(value));
+			if (values.length === 0) return withReflectionTags(reflection, {
+				name: reflection.typeName,
+				description: reflection.description,
+				enum: []
+			});
+			return withReflectionTags(reflection, {
+				type: values.every((value) => isString(value)) ? "string" : values.every((value) => isInteger(value) || isBigInt(value)) ? "integer" : values.every((value) => isNumber(value)) ? "number" : values.every((value) => isBoolean(value)) ? "boolean" : values.every((value) => isNull(value)) ? "null" : values.reduce((ret, value) => {
+					const type = getJsonSchemaType(value);
+					if (isJsonSchemaPrimitiveType(type) && !ret.includes(type)) ret.push(type);
+					return ret;
+				}, []),
+				name: reflection.typeName,
+				description: reflection.description,
+				enum: values,
+				default: values.length === 1 ? values[0] : void 0
+			});
+		}
+		case ReflectionKind.array: {
+			const items = reflectionToJsonSchemaInner(reflection.type);
+			return withReflectionTags(reflection, {
+				type: "array",
+				name: reflection.typeName,
+				items: items ?? {}
+			});
+		}
+		case ReflectionKind.tuple: {
+			const items = reflection.types.map((member) => reflectionToJsonSchemaInner(member.type)).filter((item) => item !== void 0);
+			if (items.length <= 1) return withReflectionTags(reflection, {
+				type: "array",
+				name: reflection.typeName,
+				items: items.length === 1 ? items[0] : {}
+			});
+			return withReflectionTags(reflection, {
+				type: "array",
+				name: reflection.typeName,
+				prefixItems: items,
+				minItems: items.length,
+				maxItems: items.length
+			});
+		}
+		case ReflectionKind.union: {
+			const branches = reflection.types.map((inner) => reflectionToJsonSchemaInner(inner)).filter((branch) => branch !== void 0);
+			if (!reflection.types.some((inner) => inner.kind === ReflectionKind.null || inner.kind === ReflectionKind.undefined)) return withReflectionTags(reflection, {
+				name: reflection.typeName,
+				anyOf: branches
+			});
+			const nonNull = branches.filter((branch) => !isNullOnlyJsonSchema(branch));
+			if (nonNull.length === 0) return withReflectionTags(reflection, {
+				type: "null",
+				default: null
+			});
+			if (nonNull.length === 1) {
+				const first = nonNull[0];
+				if (!isSetObject$1(first)) return withNullable(withReflectionTags(reflection, {
+					name: reflection.typeName,
+					anyOf: [first]
+				}));
+				return withNullable(withReflectionTags(reflection, {
+					name: reflection.typeName,
+					...first
+				}));
+			}
+			const enumValues = nonNull.map((branch) => isSetObject$1(branch) ? branch.const : void 0).filter((value) => value === null || typeof value === "string" || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean");
+			if (enumValues.length === nonNull.length) return withNullable(withReflectionTags(reflection, {
+				name: reflection.typeName,
+				enum: enumValues
+			}));
+			const discriminator = tryReflectionDiscriminator(reflection.types);
+			if (discriminator && isSetObject$1(discriminator)) return withNullable(withReflectionTags(reflection, {
+				name: reflection.typeName,
+				...discriminator
+			}));
+			return withNullable(withReflectionTags(reflection, {
+				name: reflection.typeName,
+				anyOf: nonNull
+			}));
+		}
+		case ReflectionKind.intersection: {
+			const members = reflection.types.map((inner) => reflectionToJsonSchemaInner(inner)).filter((item) => item !== void 0);
+			if (members.length === 0) return;
+			if (members.length === 1) {
+				if (!isSetObject$1(members[0])) return members[0];
+				return withReflectionTags(reflection, {
+					name: reflection.typeName,
+					...members[0]
+				});
+			}
+			if (members.every(isJsonSchemaObject)) return withReflectionTags(reflection, {
+				name: reflection.typeName,
+				...mergeObjectSchemas(members)
+			});
+			return withReflectionTags(reflection, {
+				name: reflection.typeName,
+				allOf: members
+			});
+		}
+		case ReflectionKind.promise: return reflectionToJsonSchemaInner(reflection.type);
+		case ReflectionKind.objectLiteral: return objectReflectionToJsonSchema(reflection);
+		case ReflectionKind.class: switch (reflection.classType?.name) {
+			case "Date": return withReflectionTags(reflection, {
+				type: "string",
+				format: "date-time"
+			});
+			case "RegExp": return withReflectionTags(reflection, {
+				type: "string",
+				format: "regex"
+			});
+			case "URL": return withReflectionTags(reflection, {
+				type: "string",
+				format: "uri"
+			});
+			case "Set": {
+				const itemType = reflection.arguments?.[0];
+				return withReflectionTags(reflection, {
+					type: "array",
+					items: (itemType ? reflectionToJsonSchemaInner(itemType) : void 0) ?? {},
+					uniqueItems: true
+				});
+			}
+			case "Map": {
+				const valueType = reflection.arguments?.[1];
+				return withReflectionTags(reflection, {
+					type: "object",
+					additionalProperties: (valueType ? reflectionToJsonSchemaInner(valueType) : void 0) ?? true
+				});
+			}
+			case "Uint8Array":
+			case "Uint8ClampedArray":
+			case "Uint16Array":
+			case "Uint32Array":
+			case "Int8Array":
+			case "Int16Array":
+			case "Int32Array":
+			case "Float32Array":
+			case "Float64Array":
+			case "BigInt64Array":
+			case "BigUint64Array": return withReflectionTags(reflection, {
+				type: "string",
+				format: "byte",
+				contentEncoding: "base64"
+			});
+			case void 0:
+			default: return withReflectionTags(reflection, {
+				name: reflection.typeName,
+				description: reflection.description,
+				...objectReflectionToJsonSchema(reflection)
+			});
+		}
+		case ReflectionKind.symbol:
+		case ReflectionKind.property:
+		case ReflectionKind.method:
+		case ReflectionKind.function:
+		case ReflectionKind.parameter:
+		case ReflectionKind.typeParameter:
+		case ReflectionKind.tupleMember:
+		case ReflectionKind.enumMember:
+		case ReflectionKind.rest:
+		case ReflectionKind.indexSignature:
+		case ReflectionKind.propertySignature:
+		case ReflectionKind.methodSignature:
+		case ReflectionKind.infer:
+		case ReflectionKind.callSignature:
+		default: return;
+	}
+}
+function mergeObjectSchemas(schemas) {
+	const merged = {
+		type: "object",
+		properties: {},
+		required: []
+	};
+	for (const schema of schemas) {
+		if (schema.properties) merged.properties = defu(merged.properties, schema.properties);
+		if (schema.required) merged.required = Array.from(/* @__PURE__ */ new Set([...merged.required ?? [], ...schema.required]));
+		if (schema.additionalProperties !== void 0) merged.additionalProperties = schema.additionalProperties;
+	}
+	if ((merged.required?.length ?? 0) === 0) delete merged.required;
+	return merged;
+}
+function tryReflectionDiscriminator(types) {
+	const nonNullTypes = types.filter((t) => t.kind !== ReflectionKind.null && t.kind !== ReflectionKind.undefined);
+	const objectBranches = nonNullTypes.filter((t) => t.kind === ReflectionKind.objectLiteral || t.kind === ReflectionKind.class);
+	if (objectBranches.length < 2 || objectBranches.length !== nonNullTypes.length) return;
+	let tagKey;
+	const branches = [];
+	for (const branch of objectBranches) {
+		const literalProps = [];
+		for (const member of branch.types) if ((member.kind === ReflectionKind.property || member.kind === ReflectionKind.propertySignature) && typeof member.name === "string" && member.type.kind === ReflectionKind.literal && typeof member.type.literal === "string") literalProps.push({
+			name: member.name,
+			literal: member.type.literal
+		});
+		if (literalProps.length === 0) return;
+		const first = literalProps[0];
+		if (!tagKey) tagKey = first.name;
+		else if (tagKey !== first.name) return;
+		const body = objectReflectionToJsonSchema({
+			...branch,
+			types: branch.types.filter((member) => !((member.kind === ReflectionKind.property || member.kind === ReflectionKind.propertySignature) && member.name === tagKey))
+		});
+		if (!body || !isJsonSchemaObject(body)) return;
+		branches.push({
+			type: "object",
+			properties: {
+				[tagKey]: { const: first.literal },
+				...body.properties ?? {}
+			},
+			required: [tagKey, ...body.required ?? []],
+			additionalProperties: body.additionalProperties ?? false
+		});
+	}
+	if (!tagKey) return;
+	return {
+		oneOf: branches,
+		discriminator: { propertyName: tagKey }
+	};
+}
+function objectReflectionToJsonSchema(type) {
+	const reflection = ReflectionClass.from(type);
+	const schema = {
+		type: "object",
+		name: reflection.getName(),
+		description: reflection.getDescription(),
+		properties: {},
+		required: [],
+		primaryKey: reflection.getPrimaries().map((primary) => primary.getNameAsString()),
+		...isSetString$1(reflection.databaseSchemaName) ? { databaseSchemaName: reflection.databaseSchemaName } : {},
+		...isSetString$1(reflection.getName()) ? { name: reflection.getName() } : {},
+		...isSetString$1(reflection.getDescription()) ? { description: reflection.getDescription() } : {}
+	};
+	for (const propertyReflection of reflection.getProperties()) {
+		if (propertyReflection.getKind() === ReflectionKind.indexSignature) {
+			schema.additionalProperties = reflectionToJsonSchemaInner(propertyReflection.type) ?? true;
+			continue;
+		}
+		let property = reflectionToJsonSchemaInner(propertyReflection.type);
+		if (!property) continue;
+		const propertySchema = isSetObject$1(property) ? property : {};
+		const groups = propertyReflection.getGroups();
+		property = {
+			...propertySchema,
+			name: propertyReflection.getNameAsString(),
+			description: propertyReflection.getDescription(),
+			readOnly: propertyReflection.isReadonly(),
+			...propertyReflection.hasDefault() ? { default: propertyReflection.getDefaultValue() } : {},
+			...isSetArray(groups) ? { tags: groups } : {}
+		};
+		if (propertyReflection.isNullable()) property = withNullable(property);
+		schema.properties ??= {};
+		schema.properties[propertyReflection.name] = property;
+		if (!propertyReflection.isOptional()) {
+			schema.required ??= [];
+			schema.required.push(propertyReflection.name);
+		}
+	}
+	return schema;
+}
+
 //#endregion
 //#region src/extract.ts
 const SCHEMA_BUNDLE_BASE_URI = "https://power-plant.invalid/";
-function normalizePath(filePath) {
-	return filePath.replaceAll("\\", "/");
-}
 function isWrappedSchemaConfig(input) {
 	if (!isSetObject(input) || !("schema" in input)) return false;
 	if ("hash" in input || "variant" in input || "source" in input) return false;
@@ -334,6 +740,10 @@ function extractHash(variant, input) {
 			variant,
 			input: unwrappedConfig._def
 		});
+		else if (isType(unwrappedConfig)) return murmurhash({
+			variant,
+			input: stringifyType(unwrappedConfig)
+		});
 		else if (isStandardJsonSchema(unwrappedConfig)) return murmurhash({
 			variant,
 			input: unwrappedConfig["~standard"]
@@ -358,6 +768,13 @@ function extractHash(variant, input) {
 	throw new Error(`Failed to create an input hash for the provided schema definition input. The input must be a Zod schema, a Standard JSON Schema, a JSON Schema object, a Valibot BaseSchema, or a reflected Deepkit Type object.`);
 }
 /**
+* Converts a reflected Deepkit {@link Type} into a JSON Schema (draft-2020-12) representation.
+*/
+function extractReflection(reflection) {
+	if (!isType(reflection)) return;
+	return reflectionToJsonSchema(reflection);
+}
+/**
 * Extracts a JSON Schema from Zod, Standard Schema, Valibot, untyped, or JSON Schema inputs.
 *
 * @param schema - The schema input to extract a JSON Schema from.
@@ -383,6 +800,7 @@ function extractJsonSchema(schema) {
 function extractResolvedVariant(input) {
 	if (isSetObject(input)) {
 		if (isZod3Type(input)) return "zod3";
+		else if (isType(input)) return "reflection";
 		else if (isUntypedConfigStrict(input) || isUntypedSchemaStrict(input)) return "untyped";
 		else if (isStandardJsonSchema(input)) return "standard-schema";
 		else if (isJsonSchema(input)) return "json-schema";
@@ -415,6 +833,7 @@ async function extractSchema(input, variant) {
 	const resolvedVariant = variant ?? extractResolvedVariant(input);
 	let schema;
 	if (resolvedVariant === "zod3" || resolvedVariant === "json-schema" || resolvedVariant === "standard-schema" || resolvedVariant === "untyped" || resolvedVariant === "valibot") schema = extractJsonSchema(input);
+	else if (resolvedVariant === "reflection") schema = extractReflection(input);
 	if (schema) return bundleReferences(schema);
 	throw new Error(`Failed to extract a valid schema from the provided input. The input must be a Zod schema, a Standard JSON Schema, a JSON Schema object, a Valibot BaseSchema, an untyped schema, or a reflected Deepkit Type object.`);
 }
@@ -452,191 +871,166 @@ function extractSource(variant, input) {
 		variant: "valibot",
 		schema: input
 	};
+	else if (variant === "reflection") return {
+		hash: extractHash(variant, input),
+		variant: "reflection",
+		schema: input
+	};
 	throw new Error(`Failed to extract source information from the provided input. The input must be a Zod schema, a Standard JSON Schema, a JSON Schema object, an untyped schema, or a reflected Deepkit Type object.`);
 }
-function getTsCompilerOptions(config) {
-	if (config.tsconfig) {
-		const raw = ts.sys.readFile(config.tsconfig);
-		if (!raw) throw new Error(`Cannot read config file "${config.tsconfig}"`);
-		const parsedConfig = ts.parseConfigFileTextToJson(config.tsconfig, raw);
-		if (parsedConfig.error) throw new Error(parsedConfig.error.messageText.toString());
-		if (!parsedConfig.config) throw new Error(`Invalid parsed config file "${config.tsconfig}"`);
-		const parseResult = ts.parseJsonConfigFileContent(parsedConfig.config, ts.sys, findFilePath(config.tsconfig), {}, config.tsconfig);
-		parseResult.options.noEmit = true;
-		delete parseResult.options.out;
-		delete parseResult.options.outDir;
-		delete parseResult.options.outFile;
-		delete parseResult.options.declaration;
-		delete parseResult.options.declarationDir;
-		delete parseResult.options.declarationMap;
-		return parseResult.options;
-	}
+const deepkitCache = new Cache();
+function rewriteTypeOnlyImports(source) {
+	return source.replaceAll(/\bimport\s+type\s+/g, "import ").replaceAll(/\bexport\s+type\s+\*\s+from/g, "export * from").replaceAll(/\bexport\s+type\s+\{/g, "export {");
+}
+function resolveReflectionConfig(options) {
+	return {
+		reflection: options.reflection ?? "default",
+		exclude: options.exclude
+	};
+}
+function getCompilerOptions(options) {
+	const cwd = options.cwd || process.cwd();
+	const tsconfigPath = options.tsconfig ? appendPath(options.tsconfig, cwd) : joinPaths(cwd, "tsconfig.json");
+	try {
+		const raw = ts.sys.readFile(tsconfigPath);
+		if (raw) {
+			const parsed = ts.parseConfigFileTextToJson(tsconfigPath, raw);
+			if (parsed.config) return {
+				...ts.parseJsonConfigFileContent(parsed.config, ts.sys, findFilePath(tsconfigPath) || cwd, {}, tsconfigPath).options,
+				noEmit: true,
+				experimentalDecorators: true,
+				emitDecoratorMetadata: true
+			};
+		}
+	} catch {}
 	return {
-		noEmit: true,
-		emitDecoratorMetadata: true,
-		experimentalDecorators: true,
 		target: ts.ScriptTarget.ES2022,
 		module: ts.ModuleKind.ESNext,
 		moduleResolution: ts.ModuleResolutionKind.Bundler,
-		strictNullChecks: false,
+		strictNullChecks: true,
+		experimentalDecorators: true,
+		emitDecoratorMetadata: true,
 		skipLibCheck: true,
-		skipDefaultLibCheck: true,
 		esModuleInterop: true,
-		types: ["node"]
+		noEmit: true
 	};
 }
-/**
-* Rewrites type-only imports/exports so esbuild still walks them while
-* collecting the original TypeScript sources for schema generation.
-*/
-function rewriteTypeOnlyImports(source) {
-	return source.replace(/\bimport\s+type\s+/g, "import ").replace(/\bexport\s+type\s+\*\s+from/g, "export * from").replace(/\bexport\s+type\s+\{/g, "export {");
-}
-function getScriptKind(fileName) {
-	switch (findFileExtensionSafe(fileName)?.toLowerCase()) {
-		case "tsx": return ts.ScriptKind.TSX;
-		case "jsx": return ts.ScriptKind.JSX;
-		case "js":
-		case "cjs":
-		case "mjs": return ts.ScriptKind.JS;
-		default: return ts.ScriptKind.TS;
-	}
-}
-/**
-* Uses esbuild (with `@stryke/resolve` path resolution) to walk the module
-* graph, capturing original TypeScript sources before types are erased.
-*/
-async function bundleTypeScriptSources(filePath, options) {
-	const cwd = options.cwd || process.cwd();
-	const sources = /* @__PURE__ */ new Map();
-	const result = await build({
-		absWorkingDir: cwd,
-		entryPoints: [filePath],
-		bundle: true,
-		write: false,
-		platform: "node",
-		format: "esm",
-		logLevel: "silent",
-		packages: "external",
-		plugins: [{
-			name: "power-plant-capture-ts-sources",
-			setup(buildApi) {
-				buildApi.onLoad({ filter: /.*/ }, async (args) => {
-					if (/[/\\]node_modules[/\\]/.test(args.path)) return null;
-					try {
-						const original = await resolve(args.path, {
-							skipBundle: true,
-							cwd,
-							fs: options.fs
-						});
-						sources.set(normalizePath(args.path), original);
-						const extension = findFileExtensionSafe(args.path);
-						const loader = extension === "tsx" || extension === "jsx" ? extension : extension === "js" || extension === "cjs" || extension === "mjs" ? "js" : "ts";
-						return {
-							contents: rewriteTypeOnlyImports(original),
-							loader
-						};
-					} catch {
-						return null;
-					}
-				});
-			}
-		}, plugin({
-			originalInput: filePath,
-			cwd,
-			fs: options.fs ?? {}
-		})]
+function transpileWithDeepkit(code, fileName, options) {
+	const reflectionConfig = resolveReflectionConfig(options);
+	deepkitCache.tick();
+	return ts.transpileModule(code, {
+		compilerOptions: getCompilerOptions(options),
+		fileName,
+		transformers: {
+			before: [(context) => new ReflectionTransformer(context, deepkitCache).withReflection(reflectionConfig)],
+			after: [(context) => new DeclarationTransformer(context, deepkitCache).withReflection(reflectionConfig)]
+		}
 	});
-	if (result.errors.length > 0) throw new Error(`Failed to bundle TypeScript sources for "${filePath}": ${result.errors.map((error) => error.text).join(", ")}`);
-	if (sources.size === 0) {
-		const fallback = await resolve(filePath, {
-			skipBundle: true,
-			cwd,
-			fs: options.fs
-		});
-		sources.set(normalizePath(filePath), fallback);
+}
+async function readSourceFile(path, fs) {
+	try {
+		if (fs?.promises?.readFile) return await fs.promises.readFile(path, "utf8");
+		return await readFile(path, "utf8");
+	} catch {
+		return;
 	}
-	return {
-		entryFileName: filePath,
-		sources
-	};
 }
-/**
-* Builds a TypeScript program from original sources collected during the
-* esbuild graph walk so type information remains intact for schema generation.
-*/
-function createProgramFromSources(entryFileName, sources, config) {
-	const compilerOptions = getTsCompilerOptions(config);
-	const host = ts.createCompilerHost(compilerOptions, true);
-	const normalizedSources = new Map([...sources.entries()].map(([key, value]) => [normalizePath(key), value]));
-	const getContent = (name) => normalizedSources.get(normalizePath(name)) ?? normalizedSources.get(name);
-	const baseFileExists = host.fileExists.bind(host);
-	const baseReadFile = host.readFile.bind(host);
-	const baseGetSourceFile = host.getSourceFile.bind(host);
-	host.fileExists = (name) => getContent(name) !== void 0 || baseFileExists(name);
-	host.readFile = (name) => getContent(name) ?? baseReadFile(name);
-	host.getSourceFile = (name, languageVersionOrOptions, onError, shouldCreateNewSourceFile) => {
-		const content = getContent(name);
-		if (content !== void 0) {
-			const scriptTarget = typeof languageVersionOrOptions === "object" ? languageVersionOrOptions.languageVersion : languageVersionOrOptions;
-			return ts.createSourceFile(name, content, scriptTarget ?? compilerOptions.target ?? ts.ScriptTarget.ES2022, true, getScriptKind(name));
+function createDeepkitPlugin(options) {
+	return {
+		name: "power-plant:deepkit",
+		setup(pluginBuild) {
+			pluginBuild.onLoad({ filter: /\.(m|c)?tsx?$/ }, async (args) => {
+				if (args.pluginData?.isReflected) {
+					const contents = await readSourceFile(args.path, options.fs);
+					if (!contents) return null;
+					return {
+						contents,
+						loader: "ts",
+						pluginData: { isReflected: true }
+					};
+				}
+				const raw = await readSourceFile(args.path, options.fs);
+				if (!raw) return null;
+				const result = transpileWithDeepkit(rewriteTypeOnlyImports(raw), args.path, options);
+				if (result.diagnostics?.length) {
+					const errors = result.diagnostics.filter((diagnostic) => diagnostic.category === DiagnosticCategory.Error);
+					if (errors.length > 0) {
+						const errorMessage = `Deepkit Type reflection transpilation errors: ${args.path} \n ${errors.map((diagnostic) => `-${diagnostic.file ? `${diagnostic.file.fileName}:` : ""} ${typeof diagnostic.messageText === "string" ? diagnostic.messageText : diagnostic.messageText.messageText} (at ${diagnostic.start}:${diagnostic.length})`).join("\n")}`;
+						options.logger?.error?.(errorMessage);
+						throw new Error(errorMessage);
+					}
+				}
+				return {
+					contents: result.outputText,
+					loader: "ts",
+					pluginData: { isReflected: true }
+				};
+			});
 		}
-		return baseGetSourceFile(name, languageVersionOrOptions, onError, shouldCreateNewSourceFile);
 	};
-	const program = ts.createProgram([entryFileName], compilerOptions, host);
-	if (!config.skipTypeCheck) {
-		const diagnostics = ts.getPreEmitDiagnostics(program);
-		if (diagnostics.length) throw new Error(`Type check error: ${diagnostics.map((diagnostic) => diagnostic.messageText.toString()).join("\n")}`);
-	}
-	return program;
 }
 /**
-* Resolves a type definition to a JSON Schema. First bundles the TypeScript
-* module graph for {@link FileReference.file} with esbuild (preserving original
-* sources), then feeds that program to
-* [ts-json-schema-generator](https://github.com/vega/ts-json-schema-generator)
-* using the referenced export name as the target type when one is provided.
+* Resolves a type definition to a JSON Schema. Bundles the TypeScript module
+* graph with esbuild using `@deepkit/type-compiler` reflection transformers,
+* then converts the reflected Deepkit {@link Type} via {@link reflectionToJsonSchema}.
 *
 * @param input - The type definition to compile. This can be either a string or a {@link FileReference} object.
-* @param options - Optional overrides reserved for API compatibility.
+* @param options - Optional overrides for reflection and file resolution.
 * @returns A promise that resolves to the generated JSON Schema.
+* @see https://deepkit.io/en/documentation/runtime-types/reflection
 */
 async function extractTSType(input, options = {}) {
 	const fileReference = extractFileReference(input);
 	if (!fileReference) throw new Error(`Failed to extract a file reference from the provided input. The input must be a string or an object with a "file" property that specifies the file path and optional export name.`);
-	const exportName = fileReference.export ?? "*";
+	const exportName = fileReference.export ?? "default";
 	const resolvedPath = await resolveSafe(fileReference.file, { fs: options.fs });
 	const filePath = resolvedPath || fileReference.file;
+	const cwd = options.cwd || process.cwd();
 	try {
-		const tsconfig = options.tsconfig ? appendPath(options.tsconfig, options.cwd || process.cwd()) : joinPaths(options.cwd || process.cwd(), "tsconfig.json");
-		const { entryFileName, sources } = await bundleTypeScriptSources(filePath, {
-			cwd: options.cwd || process.cwd(),
-			fs: options.fs
+		options.logger?.debug?.(`Generating JSON schema for bundled "${filePath}" using the type "${exportName}"`);
+		const result = await build({
+			platform: "node",
+			format: "esm",
+			logLevel: "silent",
+			entryPoints: [filePath],
+			write: false,
+			sourcemap: false,
+			splitting: false,
+			treeShaking: true,
+			bundle: true,
+			packages: "bundle",
+			keepNames: true,
+			metafile: false,
+			absWorkingDir: cwd,
+			plugins: [createDeepkitPlugin(options)]
 		});
-		const config = {
-			...DEFAULT_CONFIG,
-			expose: "all",
-			jsDoc: "extended",
-			markdownDescription: true,
-			fullDescription: true,
-			...options,
-			tsconfig,
-			path: entryFileName,
-			type: exportName,
-			skipTypeCheck: true
-		};
-		const tsProgram = createProgramFromSources(entryFileName, sources, config);
-		options.logger?.debug?.(`Generating JSON schema for bundled "${filePath}" using the type "${exportName}" (${sources.size} source file(s))`);
-		return createGenerator({
-			...config,
-			tsProgram
-		}).createSchema(exportName);
+		if (result.errors.length > 0) throw new Error(result.errors.map((error) => error.text).join(", "));
+		const bundled = result.outputFiles?.filter(Boolean)[0]?.text;
+		if (!isSetString$1(bundled)) throw new Error(`No output files generated for "${filePath}". Please check the configuration and try again.`);
+		const evaluated = await createJiti(cwd).evalModule(bundled, {
+			filename: filePath,
+			ext: findFileDotExtensionSafe(filePath) || ".ts"
+		});
+		let resolved = evaluated[exportName] ?? evaluated[`__Ω${exportName}`];
+		if (resolved === void 0) throw new Error(`The export "${exportName}" could not be resolved in the "${filePath}" module. ${Object.keys(evaluated).length === 0 ? `After bundling, no exports were found in the module.` : `After bundling, the available exports were: ${Object.keys(evaluated).join(", ")}.`}`);
+		try {
+			const type = reflect(resolved);
+			if (isType(type)) resolved = type;
+		} catch {}
+		if (isType(resolved)) {
+			const schema = extractReflection(resolved);
+			if (!schema) throw new Error(`Failed to convert the reflected Deepkit type for "${exportName}" to JSON Schema.`);
+			return schema;
+		}
+		const schema = extractJsonSchema(resolved);
+		if (!schema) throw new Error(`The export "${exportName}" could not be converted to a JSON Schema.`);
+		return schema;
 	} catch (error) {
 		throw new Error(`Failed to generate a JSON schema for "${fileReference.file}"${resolvedPath && resolvedPath !== fileReference.file ? ` (resolved: ${resolvedPath})` : ""} using the type "${exportName}". Error: ${error.message}`);
 	}
 }
 /**
-* Extracts a JSON Schema from a given schema definition input, which can be a Zod schema, a Valibot schema, any Standard JSON Schema type, a plain JSON Schema object, an untyped schema, or a {@link FileReferenceInput} to an exported TypeScript type definition or any of the previous options. If the input is a {@link FileReferenceInput} (e.g. a file path with an export), the source code will be bundled with [esbuild](esbuild.github.io) using [ts-json-schema-generator](https://github.com/vega/ts-json-schema-generator) to obtain the actual schema definition before extraction.
+* Extracts a JSON Schema from a given schema definition input, which can be a Zod schema, a Valibot schema, any Standard JSON Schema type, a plain JSON Schema object, an untyped schema, a Deepkit Type object, or a {@link FileReferenceInput} to an exported TypeScript type definition or any of the previous options. If the input is a {@link FileReferenceInput} (e.g. a file path with an export), the source code will be bundled with [esbuild](https://esbuild.github.io) using [@deepkit/type-compiler](https://deepkit.io/en/documentation/runtime-types/getting-started) reflection to obtain the actual schema definition before extraction.
 *
 * @example
 * ```ts
@@ -650,8 +1044,8 @@ async function extractTSType(input, options = {}) {
 * const schema4 = await extract(context, zodSchema);
 * // Resolve a schema definition from a Valibot schema
 * const schema5 = await extract(context, valibotSchema);
-* // Resolve a schema definition from an untyped schema
-* const schema6 = await extract(context, untypedSchema);
+* // Resolve a schema definition from a reflected Deepkit Type object
+* const schema6 = await extract(context, reflectionType);
 * ```
 *
 * @see https://zod.dev/
@@ -659,7 +1053,7 @@ async function extractTSType(input, options = {}) {
 * @see https://standardschema.dev/json-schema#what-schema-libraries-support-this-spec
 * @see https://json-schema.org/
 * @see https://ajv.js.org/json-type-definition.html
-* @see https://github.com/vega/ts-json-schema-generator
+* @see https://deepkit.io/en/documentation/runtime-types/reflection
 * @see https://github.com/unjs/untyped
 * @see https://www.typescriptlang.org/docs/handbook/2/types-from-types.html
 *
@@ -690,13 +1084,22 @@ async function extractSchemaWithSource(input, options = {}) {
 		let fs;
 		if (options.storage) fs = mapStorageToFileSystem(options.storage);
 		let resolved = await loadSafe(unwrappedConfig, {
-			...options,
-			fs
+			...omit(options, [
+				"storage",
+				"logger",
+				"tsconfig"
+			]),
+			fs,
+			cwd: options.cwd ?? void 0
 		});
 		resolved ??= await extractTSType(unwrappedConfig, {
 			...options,
 			fs
 		});
+		try {
+			const type = reflect(resolved);
+			if (isType(type)) resolved = type;
+		} catch {}
 		const resolvedConfig = unwrapSchemaConfig(resolved);
 		if (isSchemaWithSource(resolvedConfig)) source = resolvedConfig.source;
 		else if (isSchema(resolvedConfig)) source = {
@@ -722,7 +1125,7 @@ async function extractSchemaWithSource(input, options = {}) {
 	};
 }
 /**
-* Extracts a JSON Schema from a given schema definition input, which can be a Zod schema, a Valibot schema, any Standard JSON Schema type, a plain JSON Schema object, an untyped schema, or a {@link FileReferenceInput} to an exported TypeScript type definition or any of the previous options. If the input is a {@link FileReferenceInput} (e.g. a file path with an export), the source code will be bundled with [esbuild](esbuild.github.io) using [ts-json-schema-generator](https://github.com/vega/ts-json-schema-generator) to obtain the actual schema definition before extraction.
+* Extracts a JSON Schema from a given schema definition input, which can be a Zod schema, a Valibot schema, any Standard JSON Schema type, a plain JSON Schema object, an untyped schema, a Deepkit Type object, or a {@link FileReferenceInput} to an exported TypeScript type definition or any of the previous options. If the input is a {@link FileReferenceInput} (e.g. a file path with an export), the source code will be bundled with [esbuild](https://esbuild.github.io) using [@deepkit/type-compiler](https://deepkit.io/en/documentation/runtime-types/getting-started) reflection to obtain the actual schema definition before extraction.
 *
 * @example
 * ```ts
@@ -736,8 +1139,8 @@ async function extractSchemaWithSource(input, options = {}) {
 * const schema4 = await extract(context, zodSchema);
 * // Resolve a schema definition from a Valibot schema
 * const schema5 = await extract(context, valibotSchema);
-* // Resolve a schema definition from an untyped schema
-* const schema6 = await extract(context, untypedSchema);
+* // Resolve a schema definition from a reflected Deepkit Type object
+* const schema6 = await extract(context, reflectionType);
 * ```
 *
 * @see https://zod.dev/
@@ -745,7 +1148,7 @@ async function extractSchemaWithSource(input, options = {}) {
 * @see https://standardschema.dev/json-schema#what-schema-libraries-support-this-spec
 * @see https://json-schema.org/
 * @see https://ajv.js.org/json-type-definition.html
-* @see https://github.com/vega/ts-json-schema-generator
+* @see https://deepkit.io/en/documentation/runtime-types/reflection
 * @see https://github.com/unjs/untyped
 * @see https://www.typescriptlang.org/docs/handbook/2/types-from-types.html
 *
@@ -763,5 +1166,5 @@ async function extract(input, options = {}) {
 }
 
 //#endregion
-export { JSON_SCHEMA_METADATA_KEYS, JSON_SCHEMA_PRIMITIVE_TYPES, JSON_SCHEMA_TYPES, JsonSchemaTypeNames, SCHEMA_ARRAY_CONCAT_KEYWORDS, SCHEMA_RECORD_KEYWORDS, SCHEMA_SINGLE_KEYWORDS, addProperty, applyJsonSchemaMetadata, assertSchemasDoNotContradict, bundleReferences, createStoragePromises, extract, extractHash, extractJsonSchema, extractResolvedVariant, extractSchema, extractSchemaWithSource, extractSource, extractTSType, extractVariant, findSchemaContradictions, getJsonSchema, getJsonSchemaObject, getPrimarySchemaType, getProperties, getPropertiesList, getProperty, isFileReference, isJsonSchema, isJsonSchemaAllOf, isJsonSchemaAny, isJsonSchemaAnyOf, isJsonSchemaArray, isJsonSchemaBigint, isJsonSchemaBoolean, isJsonSchemaDate, isJsonSchemaDecimal, isJsonSchemaEnum, isJsonSchemaInteger, isJsonSchemaKeywords, isJsonSchemaLiteral, isJsonSchemaMap, isJsonSchemaNativeEnum, isJsonSchemaNever, isJsonSchemaNull, isJsonSchemaNullable, isJsonSchemaNumber, isJsonSchemaObject, isJsonSchemaPrimitiveType, isJsonSchemaPrimitiveUnion, isJsonSchemaRecord, isJsonSchemaRef, isJsonSchemaSet, isJsonSchemaString, isJsonSchemaTuple, isJsonSchemaType, isJsonSchemaUndefined, isJsonSchemaUnion, isJsonSchemaUnknown, isNullOnlyJsonSchema, isPropertyOptional, isSchema, isSchemaNullable, isSchemaObject, isSchemaOf, isSchemaWithSource, isStandardSchema, isUntypedConfig, isUntypedConfigStrict, isUntypedInput, isUntypedInputStrict, isUntypedSchema, isUntypedSchemaStrict, isValibotSchema, isValidSchemaConfigFile, isValidSchemaInputFile, mapStorageToFileSystem, merge, mergeMetadata, normalizeKey, readSchemaTypes, traverseSchema };
+export { JSON_SCHEMA_CONSTRUCTOR_KEY, JSON_SCHEMA_METADATA_KEYS, JSON_SCHEMA_PRIMITIVE_TYPES, JSON_SCHEMA_TYPES, JsonSchemaTypeNames, SCHEMA_ARRAY_CONCAT_KEYWORDS, SCHEMA_RECORD_KEYWORDS, SCHEMA_SINGLE_KEYWORDS, addProperty, applyJsonSchemaMetadata, assertSchemasDoNotContradict, bundleReferences, createStoragePromises, extract, extractHash, extractJsonSchema, extractReflection, extractResolvedVariant, extractSchema, extractSchemaWithSource, extractSource, extractTSType, extractVariant, findSchemaContradictions, getJsonSchema, getJsonSchemaObject, getPrimarySchemaType, getProperties, getPropertiesList, getProperty, hasJsonSchemaConstructorFlag, isFileReference, isJsonSchema, isJsonSchemaAllOf, isJsonSchemaAny, isJsonSchemaAnyOf, isJsonSchemaArray, isJsonSchemaBigint, isJsonSchemaBoolean, isJsonSchemaDate, isJsonSchemaDecimal, isJsonSchemaEnum, isJsonSchemaInteger, isJsonSchemaKeywords, isJsonSchemaLiteral, isJsonSchemaMap, isJsonSchemaNativeEnum, isJsonSchemaNever, isJsonSchemaNull, isJsonSchemaNullable, isJsonSchemaNumber, isJsonSchemaObject, isJsonSchemaPrimitiveType, isJsonSchemaPrimitiveUnion, isJsonSchemaRecord, isJsonSchemaRef, isJsonSchemaSet, isJsonSchemaString, isJsonSchemaTuple, isJsonSchemaType, isJsonSchemaUndefined, isJsonSchemaUnion, isJsonSchemaUnknown, isNullOnlyJsonSchema, isPropertyOptional, isSchema, isSchemaNullable, isSchemaObject, isSchemaOf, isSchemaWithSource, isStandardSchema, isUntypedConfig, isUntypedConfigStrict, isUntypedInput, isUntypedInputStrict, isUntypedSchema, isUntypedSchemaStrict, isValibotSchema, isValidSchemaConfigFile, isValidSchemaInputFile, mapStorageToFileSystem, merge, mergeMetadata, normalizeKey, readSchemaTypes, traverseSchema };
 //# sourceMappingURL=index.mjs.map