@powerlines/schema 0.11.1 → 0.11.2

package/dist/reflection.cjs

@@ -1,123 +1,238 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
 let _powerlines_deepkit_vendor_type = require("@powerlines/deepkit/vendor/type");
+let _stryke_type_checks = require("@stryke/type-checks");
 
 //#region src/reflection.ts
 /**
-* Converts a Deepkit type reflection into a JSON Schema representation.
+* Maps a Deepkit numeric `brand` to the JTD numeric `type` keyword that best preserves the underlying width and signedness.
+*
+* @param brand - The Deepkit `TypeNumberBrand` of a numeric reflection, or `undefined` when no brand is set.
+* @returns The JTD numeric `type` keyword to use.
+*/
+function numberBrandToJtdType(brand) {
+	switch (brand) {
+		case _powerlines_deepkit_vendor_type.TypeNumberBrand.integer: return "int32";
+		case _powerlines_deepkit_vendor_type.TypeNumberBrand.int8: return "int8";
+		case _powerlines_deepkit_vendor_type.TypeNumberBrand.uint8: return "uint8";
+		case _powerlines_deepkit_vendor_type.TypeNumberBrand.int16: return "int16";
+		case _powerlines_deepkit_vendor_type.TypeNumberBrand.uint16: return "uint16";
+		case _powerlines_deepkit_vendor_type.TypeNumberBrand.int32: return "int32";
+		case _powerlines_deepkit_vendor_type.TypeNumberBrand.uint32: return "uint32";
+		case _powerlines_deepkit_vendor_type.TypeNumberBrand.float:
+		case _powerlines_deepkit_vendor_type.TypeNumberBrand.float32: return "float32";
+		case _powerlines_deepkit_vendor_type.TypeNumberBrand.float64: return "float64";
+		case void 0:
+		default: return "float64";
+	}
+}
+/**
+* Converts a Deepkit type reflection into a JSON Type Definition (RFC 8927) form suitable for AJV's JTD validator.
+*
+* @remarks
+* Some TypeScript constructs have no direct JTD equivalent and are handled with the closest available form:
+*
+* - `null` and `undefined` become the empty JTD form with `nullable: true`.
+* - Unions of primitives that cannot be expressed as a JTD enum collapse to the empty form (which validates any value).
+* - String/number/bigint literal unions are emitted as a JTD enum (non-string members are stringified, as JTD requires string enum members).
+* - Tuples are emitted as a JTD elements form whose element schema is the single tuple member type, or the empty schema for mixed tuples.
+* - `Date` is emitted as `{ type: "timestamp" }`.
+* - Discriminated unions of object literals (a shared string-literal tag property) are emitted as a JTD discriminator form.
 *
 * @param reflection - The Deepkit type reflection to convert.
-* @returns The corresponding JSON Schema representation, or `undefined` if the type cannot be represented.
+* @returns The corresponding JTD form, or `undefined` if the type cannot be represented.
 */
 function reflectionToJsonSchema(reflection) {
+	return reflectionToJtd(reflection);
+}
+/**
+* Internal worker that performs the recursive Deepkit reflection → JTD conversion.
+*
+* @param reflection - The Deepkit type reflection to convert.
+* @returns The corresponding JTD form, or `undefined` if the type cannot be represented.
+*/
+function reflectionToJtd(reflection) {
+	const schema = {};
+	if ((0, _stryke_type_checks.isSetObject)(reflection?.tags)) {
+		const tags = reflection.tags;
+		schema.metadata = schema.metadata ?? {};
+		if (tags.readonly === true) schema.metadata.isReadonly = true;
+		if (tags.ignore === true) schema.metadata.isIgnored = true;
+		if (tags.internal === true) schema.metadata.isInternal = true;
+		if (tags.runtime === true) schema.metadata.isRuntime = true;
+		if (tags.hidden === true) schema.metadata.isHidden = true;
+		if ((0, _stryke_type_checks.isSetArray)(tags.alias)) schema.metadata.alias = tags.alias;
+		if ((0, _stryke_type_checks.isSetString)(tags.title)) schema.metadata.title = tags.title;
+	}
 	switch (reflection.kind) {
 		case _powerlines_deepkit_vendor_type.ReflectionKind.any:
 		case _powerlines_deepkit_vendor_type.ReflectionKind.unknown:
 		case _powerlines_deepkit_vendor_type.ReflectionKind.void:
 		case _powerlines_deepkit_vendor_type.ReflectionKind.object: return {};
-		case _powerlines_deepkit_vendor_type.ReflectionKind.never:
-		case _powerlines_deepkit_vendor_type.ReflectionKind.undefined: return { not: {} };
-		case _powerlines_deepkit_vendor_type.ReflectionKind.null: return { type: "null" };
-		case _powerlines_deepkit_vendor_type.ReflectionKind.string: return { type: "string" };
-		case _powerlines_deepkit_vendor_type.ReflectionKind.boolean: return { type: "boolean" };
-		case _powerlines_deepkit_vendor_type.ReflectionKind.number: {
-			const brand = reflection.brand;
-			return { type: brand !== void 0 && brand >= _powerlines_deepkit_vendor_type.TypeNumberBrand.integer && brand <= _powerlines_deepkit_vendor_type.TypeNumberBrand.uint32 ? "integer" : "number" };
-		}
+		case _powerlines_deepkit_vendor_type.ReflectionKind.never: return;
+		case _powerlines_deepkit_vendor_type.ReflectionKind.undefined:
+		case _powerlines_deepkit_vendor_type.ReflectionKind.null: return { nullable: true };
+		case _powerlines_deepkit_vendor_type.ReflectionKind.string: return {
+			...schema,
+			type: "string"
+		};
+		case _powerlines_deepkit_vendor_type.ReflectionKind.boolean: return {
+			...schema,
+			type: "boolean"
+		};
+		case _powerlines_deepkit_vendor_type.ReflectionKind.number: return {
+			...schema,
+			type: numberBrandToJtdType(reflection.brand)
+		};
 		case _powerlines_deepkit_vendor_type.ReflectionKind.bigint: return {
-			type: "integer",
-			format: "int64"
+			...schema,
+			type: "float64"
+		};
+		case _powerlines_deepkit_vendor_type.ReflectionKind.regexp: return {
+			...schema,
+			type: "string"
 		};
-		case _powerlines_deepkit_vendor_type.ReflectionKind.regexp: return { type: "string" };
 		case _powerlines_deepkit_vendor_type.ReflectionKind.literal: {
 			const { literal } = reflection;
 			if (typeof literal === "string") return {
-				type: "string",
-				const: literal
+				...schema,
+				enum: [literal]
 			};
-			if (typeof literal === "number") return {
-				type: Number.isInteger(literal) ? "integer" : "number",
-				const: literal
+			if (typeof literal === "number" || typeof literal === "bigint") return {
+				...schema,
+				enum: [String(literal)]
 			};
 			if (typeof literal === "boolean") return {
-				type: "boolean",
-				const: literal
-			};
-			if (typeof literal === "bigint") return {
-				type: "integer",
-				format: "int64"
+				...schema,
+				type: "boolean"
 			};
 			if (literal instanceof RegExp) return {
-				type: "string",
-				pattern: literal.source
+				...schema,
+				type: "string"
 			};
-			return {};
+			return schema;
 		}
-		case _powerlines_deepkit_vendor_type.ReflectionKind.templateLiteral: return { type: "string" };
+		case _powerlines_deepkit_vendor_type.ReflectionKind.templateLiteral: return {
+			...schema,
+			type: "string"
+		};
 		case _powerlines_deepkit_vendor_type.ReflectionKind.enum: {
-			const values = reflection.values.filter((value) => typeof value === "string" || typeof value === "number");
-			const allStrings = values.every((value) => typeof value === "string");
-			const allNumbers = values.every((value) => typeof value === "number");
+			const values = reflection.values.filter((value) => typeof value === "string" || typeof value === "number").map((value) => String(value));
+			const unique = Array.from(new Set(values));
+			if (unique.length === 0) return schema;
 			return {
-				type: allStrings ? "string" : allNumbers ? "number" : ["string", "number"],
-				enum: values
+				...schema,
+				enum: unique
 			};
 		}
 		case _powerlines_deepkit_vendor_type.ReflectionKind.array: {
-			const items = reflectionToJsonSchema(reflection.type);
-			return items ? {
-				type: "array",
-				items
-			} : { type: "array" };
+			const items = reflectionToJtd(reflection.type);
+			return {
+				...schema,
+				elements: items ?? {}
+			};
+		}
+		case _powerlines_deepkit_vendor_type.ReflectionKind.tuple: {
+			const items = reflection.types.map((member) => reflectionToJtd(member.type)).filter((item) => item !== void 0);
+			if (items.length === 0) return {
+				...schema,
+				elements: {}
+			};
+			if (items.length === 1) return {
+				...schema,
+				elements: items[0]
+			};
+			return {
+				...schema,
+				elements: {}
+			};
 		}
-		case _powerlines_deepkit_vendor_type.ReflectionKind.tuple: return {
-			type: "array",
-			items: reflection.types.map((member) => reflectionToJsonSchema(member.type)).filter((item) => item !== void 0),
-			minItems: reflection.types.filter((member) => !member.optional).length,
-			maxItems: reflection.types.length
-		};
 		case _powerlines_deepkit_vendor_type.ReflectionKind.union: {
-			const anyOf = reflection.types.map((inner) => reflectionToJsonSchema(inner)).filter((item) => item !== void 0);
-			if (anyOf.length === 0) return;
-			if (anyOf.length === 1) return anyOf[0];
-			return { anyOf };
+			const branches = reflection.types.map((inner) => reflectionToJtd(inner)).filter((item) => item !== void 0);
+			const nullable = reflection.types.some((inner) => inner.kind === _powerlines_deepkit_vendor_type.ReflectionKind.null || inner.kind === _powerlines_deepkit_vendor_type.ReflectionKind.undefined);
+			const nonNull = branches.filter((b) => !isPureNullable(b));
+			if (nonNull.length === 0) return {
+				...schema,
+				nullable: true
+			};
+			if (nonNull.length === 1) {
+				const only = nonNull[0];
+				if (nullable) only.nullable = true;
+				return {
+					...schema,
+					...only
+				};
+			}
+			if (nonNull.every(isEnumForm)) {
+				const merged = Array.from(new Set(nonNull.flatMap((b) => b.enum)));
+				const form = {
+					...schema,
+					enum: merged
+				};
+				if (nullable) form.nullable = true;
+				return {
+					...schema,
+					...form
+				};
+			}
+			const discriminator = tryReflectionDiscriminator(reflection.types);
+			if (discriminator) {
+				if (nullable) discriminator.nullable = true;
+				return {
+					...schema,
+					...discriminator
+				};
+			}
+			const fallback = {};
+			if (nullable) fallback.nullable = true;
+			return {
+				...schema,
+				...fallback
+			};
 		}
 		case _powerlines_deepkit_vendor_type.ReflectionKind.intersection: {
-			const allOf = reflection.types.map((inner) => reflectionToJsonSchema(inner)).filter((item) => item !== void 0);
-			if (allOf.length === 0) return;
-			if (allOf.length === 1) return allOf[0];
-			return { allOf };
+			const members = reflection.types.map((inner) => reflectionToJtd(inner)).filter((item) => item !== void 0);
+			if (members.length === 0) return;
+			if (members.length === 1) return {
+				...schema,
+				...members[0]
+			};
+			if (members.every((member) => member && isPropertiesForm(member))) return mergePropertiesForms(members);
+			return {
+				...schema,
+				...members[0]
+			};
 		}
-		case _powerlines_deepkit_vendor_type.ReflectionKind.promise: return reflectionToJsonSchema(reflection.type);
-		case _powerlines_deepkit_vendor_type.ReflectionKind.objectLiteral: return objectReflectionToJsonSchema(reflection);
+		case _powerlines_deepkit_vendor_type.ReflectionKind.promise: return reflectionToJtd(reflection.type);
+		case _powerlines_deepkit_vendor_type.ReflectionKind.objectLiteral: return objectReflectionToJtd(reflection);
 		case _powerlines_deepkit_vendor_type.ReflectionKind.class: switch (reflection.classType?.name) {
 			case "Date": return {
-				type: "string",
-				format: "date-time"
+				...schema,
+				type: "timestamp"
+			};
+			case "RegExp": return {
+				...schema,
+				type: "string"
 			};
-			case "RegExp": return { type: "string" };
 			case "URL": return {
-				type: "string",
-				format: "uri"
+				...schema,
+				type: "string"
 			};
 			case "Set": {
 				const itemType = reflection.arguments?.[0];
-				const items = itemType ? reflectionToJsonSchema(itemType) : void 0;
-				return items ? {
-					type: "array",
-					uniqueItems: true,
-					items
-				} : {
-					type: "array",
-					uniqueItems: true
+				const items = itemType ? reflectionToJtd(itemType) : void 0;
+				return {
+					...schema,
+					elements: items ?? {}
 				};
 			}
 			case "Map": {
 				const valueType = reflection.arguments?.[1];
-				const additionalProperties = valueType ? reflectionToJsonSchema(valueType) : void 0;
-				const schema = { type: "object" };
-				if (additionalProperties) schema.additionalProperties = additionalProperties;
-				return schema;
+				const values = valueType ? reflectionToJtd(valueType) : void 0;
+				return {
+					...schema,
+					values: values ?? {}
+				};
 			}
 			case "Uint8Array":
 			case "Uint8ClampedArray":
@@ -130,11 +245,11 @@ function reflectionToJsonSchema(reflection) {
 			case "Float64Array":
 			case "BigInt64Array":
 			case "BigUint64Array": return {
-				type: "string",
-				contentEncoding: "base64"
+				...schema,
+				type: "string"
 			};
 			case void 0:
-			default: return objectReflectionToJsonSchema(reflection);
+			default: return objectReflectionToJtd(reflection);
 		}
 		case _powerlines_deepkit_vendor_type.ReflectionKind.symbol:
 		case _powerlines_deepkit_vendor_type.ReflectionKind.property:
@@ -154,38 +269,144 @@ function reflectionToJsonSchema(reflection) {
 	}
 }
 /**
-* Builds a JSON Schema object representation from a Deepkit class or object literal type.
+* Tests whether a JTD form is an enum form.
+*
+* @param form - The JTD form to inspect.
+* @returns `true` if the form is a JTD enum form.
+*/
+function isEnumForm(form) {
+	return Array.isArray(form.enum);
+}
+/**
+* Tests whether a JTD form is a properties form (object).
+*
+* @param form - The JTD form to inspect.
+* @returns `true` if the form is a JTD properties form.
+*/
+function isPropertiesForm(form) {
+	return "properties" in form || "optionalProperties" in form;
+}
+/**
+* Tests whether a JTD form is the empty `{ nullable: true }` placeholder.
+*
+* @param form - The JTD form to inspect.
+* @returns `true` if the form has no shape constraints beyond `nullable`.
+*/
+function isPureNullable(form) {
+	return Object.keys(form).filter((k) => k !== "nullable" && k !== "metadata").length === 0 && form.nullable === true;
+}
+/**
+* Shallow-merges two JTD properties forms, unioning their `properties` and `optionalProperties` maps.
+*
+* @param forms - The JTD properties forms to merge.
+* @returns The merged JTD properties form.
+*/
+function mergePropertiesForms(forms) {
+	const merged = {
+		properties: {},
+		optionalProperties: {}
+	};
+	for (const form of forms) {
+		const p = form.properties;
+		const o = form.optionalProperties;
+		if (p) Object.assign(merged.properties, p);
+		if (o) Object.assign(merged.optionalProperties, o);
+		if (form.additionalProperties) merged.additionalProperties = true;
+	}
+	const hasProperties = Object.keys(merged.properties).length > 0;
+	const hasOptional = Object.keys(merged.optionalProperties).length > 0;
+	const result = {};
+	if (hasProperties) result.properties = merged.properties;
+	else if (!hasOptional) result.properties = {};
+	if (hasOptional) result.optionalProperties = merged.optionalProperties;
+	if (merged.additionalProperties) result.additionalProperties = true;
+	return result;
+}
+/**
+* Detects whether a Deepkit union represents a tagged union and, when so, emits the corresponding JTD discriminator form.
+*
+* @param types - The Deepkit reflection types that make up the union branches.
+* @returns A JTD discriminator form if every non-null branch is an object literal that shares a string-literal tag property, otherwise `undefined`.
+*/
+function tryReflectionDiscriminator(types) {
+	const nonNullTypes = types.filter((t) => t.kind !== _powerlines_deepkit_vendor_type.ReflectionKind.null && t.kind !== _powerlines_deepkit_vendor_type.ReflectionKind.undefined);
+	const objectBranches = nonNullTypes.filter((t) => t.kind === _powerlines_deepkit_vendor_type.ReflectionKind.objectLiteral || t.kind === _powerlines_deepkit_vendor_type.ReflectionKind.class);
+	if (objectBranches.length < 2 || objectBranches.length !== nonNullTypes.length) return;
+	let tagKey;
+	const mapping = {};
+	for (const branch of objectBranches) {
+		const literalProps = [];
+		for (const member of branch.types) if ((member.kind === _powerlines_deepkit_vendor_type.ReflectionKind.property || member.kind === _powerlines_deepkit_vendor_type.ReflectionKind.propertySignature) && typeof member.name === "string" && member.type.kind === _powerlines_deepkit_vendor_type.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 = objectReflectionToJtd({
+			...branch,
+			types: branch.types.filter((member) => !((member.kind === _powerlines_deepkit_vendor_type.ReflectionKind.property || member.kind === _powerlines_deepkit_vendor_type.ReflectionKind.propertySignature) && member.name === tagKey))
+		});
+		if (!body || !isPropertiesForm(body)) return;
+		mapping[first.literal] = body;
+	}
+	if (!tagKey) return;
+	return {
+		discriminator: tagKey,
+		mapping
+	};
+}
+/**
+* Internal worker that produces a JTD properties form (or `values` form for index signatures alone) from a Deepkit object-like type.
 *
 * @param type - The class or object literal type whose members should be serialized.
-* @returns A JSON Schema object describing the type's properties.
+* @returns A JTD properties or values form describing the type's members.
 */
-function objectReflectionToJsonSchema(type) {
+function objectReflectionToJtd(type) {
+	const reflection = _powerlines_deepkit_vendor_type.ReflectionClass.from(type);
+	const schema = {};
+	schema.metadata = schema.metadata ?? {};
+	schema.metadata.isReadonly = reflection.isReadonly();
+	schema.metadata.isIgnored = reflection.isIgnored();
+	schema.metadata.isInternal = reflection.isInternal();
+	schema.metadata.isRuntime = reflection.isRuntime();
+	schema.metadata.isHidden = reflection.isHidden();
+	if ((0, _stryke_type_checks.isSetString)(reflection.databaseSchemaName)) schema.metadata.table = reflection.databaseSchemaName;
+	if ((0, _stryke_type_checks.isSetString)(reflection.getDescription())) schema.metadata.description = reflection.getDescription();
+	if ((0, _stryke_type_checks.isSetArray)(reflection.getAlias())) schema.metadata.alias = reflection.getAlias();
+	if ((0, _stryke_type_checks.isSetString)(reflection.getTitle())) schema.metadata.title = reflection.getTitle();
 	const properties = {};
-	const required = [];
-	let additionalProperties;
-	const description = "description" in type && typeof type.description === "string" ? type.description : void 0;
-	for (const member of type.types) if (member.kind === _powerlines_deepkit_vendor_type.ReflectionKind.property || member.kind === _powerlines_deepkit_vendor_type.ReflectionKind.propertySignature) {
-		const property = member;
-		if (typeof property.name !== "string") continue;
-		const propertySchema = reflectionToJsonSchema(property.type);
-		if (!propertySchema) continue;
-		if (typeof property.description === "string") propertySchema.description = property.description;
-		properties[property.name] = propertySchema;
-		if (!property.optional) required.push(property.name);
-	} else if (member.kind === _powerlines_deepkit_vendor_type.ReflectionKind.indexSignature) {
-		const valueSchema = reflectionToJsonSchema(member.type);
-		if (valueSchema) additionalProperties = valueSchema;
+	const optionalProperties = {};
+	for (const propertyReflection of reflection.getProperties()) if (propertyReflection.getKind() === _powerlines_deepkit_vendor_type.ReflectionKind.indexSignature) {
+		const valueSchema = reflectionToJtd(propertyReflection.type);
+		if (valueSchema) return {
+			...schema,
+			values: valueSchema,
+			additionalProperties: true
+		};
+	} else {
+		const property = reflectionToJtd(propertyReflection.type);
+		if (!property) continue;
+		property.metadata = property.metadata ?? {};
+		property.metadata.isReadonly = propertyReflection.isReadonly();
+		property.metadata.isIgnored = propertyReflection.isIgnored();
+		property.metadata.isInternal = propertyReflection.isInternal();
+		property.metadata.isRuntime = propertyReflection.isRuntime();
+		property.metadata.isPrimaryKey = propertyReflection.isPrimaryKey();
+		property.metadata.isHidden = propertyReflection.isHidden();
+		if (propertyReflection.hasDefault()) property.metadata.default = propertyReflection.getDefaultValue();
+		if ((0, _stryke_type_checks.isSetString)(propertyReflection.getDescription())) property.metadata.description = propertyReflection.getDescription();
+		if ((0, _stryke_type_checks.isSetArray)(propertyReflection.getAlias())) property.metadata.alias = propertyReflection.getAlias();
+		if ((0, _stryke_type_checks.isSetString)(propertyReflection.getTitle())) property.metadata.title = propertyReflection.getTitle();
+		if (propertyReflection.isOptional()) optionalProperties[propertyReflection.name] = property;
+		else properties[propertyReflection.name] = property;
 	}
-	const schema = {
-		type: "object",
-		properties
-	};
-	if (required.length > 0) schema.required = required;
-	if (additionalProperties !== void 0) schema.additionalProperties = additionalProperties;
-	if (description) schema.description = description;
+	if (Object.keys(properties).length > 0) schema.properties = properties;
+	else if (Object.keys(optionalProperties).length > 0) schema.optionalProperties = optionalProperties;
+	else schema.properties = {};
 	return schema;
 }
 
 //#endregion
-exports.objectReflectionToJsonSchema = objectReflectionToJsonSchema;
 exports.reflectionToJsonSchema = reflectionToJsonSchema;

package/dist/reflection.d.cts

@@ -1,21 +1,24 @@
-import { Type, TypeClass, TypeObjectLiteral } from "@powerlines/deepkit/vendor/type";
-import { JsonSchema7Type } from "@stryke/json/types";
+import { JTDSchemaType, SchemaMetadata } from "./types.cjs";
+import { Type } from "@powerlines/deepkit/vendor/type";
 
 //#region src/reflection.d.ts
 /**
- * Converts a Deepkit type reflection into a JSON Schema representation.
+ * Converts a Deepkit type reflection into a JSON Type Definition (RFC 8927) form suitable for AJV's JTD validator.
  *
- * @param reflection - The Deepkit type reflection to convert.
- * @returns The corresponding JSON Schema representation, or `undefined` if the type cannot be represented.
- */
-declare function reflectionToJsonSchema(reflection: Type): JsonSchema7Type | undefined;
-/**
- * Builds a JSON Schema object representation from a Deepkit class or object literal type.
+ * @remarks
+ * Some TypeScript constructs have no direct JTD equivalent and are handled with the closest available form:
  *
- * @param type - The class or object literal type whose members should be serialized.
- * @returns A JSON Schema object describing the type's properties.
+ * - `null` and `undefined` become the empty JTD form with `nullable: true`.
+ * - Unions of primitives that cannot be expressed as a JTD enum collapse to the empty form (which validates any value).
+ * - String/number/bigint literal unions are emitted as a JTD enum (non-string members are stringified, as JTD requires string enum members).
+ * - Tuples are emitted as a JTD elements form whose element schema is the single tuple member type, or the empty schema for mixed tuples.
+ * - `Date` is emitted as `{ type: "timestamp" }`.
+ * - Discriminated unions of object literals (a shared string-literal tag property) are emitted as a JTD discriminator form.
+ *
+ * @param reflection - The Deepkit type reflection to convert.
+ * @returns The corresponding JTD form, or `undefined` if the type cannot be represented.
  */
-declare function objectReflectionToJsonSchema(type: TypeObjectLiteral | TypeClass): JsonSchema7Type;
+declare function reflectionToJsonSchema<TMetadata extends Partial<SchemaMetadata> = Partial<SchemaMetadata>>(reflection: Type): JTDSchemaType<TMetadata> | undefined;
 //#endregion
-export { objectReflectionToJsonSchema, reflectionToJsonSchema };
+export { reflectionToJsonSchema };
 //# sourceMappingURL=reflection.d.cts.map

package/dist/reflection.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"reflection.d.cts","names":[],"sources":["../src/reflection.ts"],"mappings":";;;;;AAgCA;;;;;iBAAgB,sBAAA,CACd,UAAA,EAAY,IAAA,GACX,eAAA;;;;AAgMH;;;iBAAgB,4BAAA,CACd,IAAA,EAAM,iBAAA,GAAoB,SAAA,GACzB,eAAA"}
+{"version":3,"file":"reflection.d.cts","names":[],"sources":["../src/reflection.ts"],"mappings":";;;;;;AA2FA;;;;;;;;;;;;;;iBAAgB,sBAAA,mBACI,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,EAAA,CACpD,UAAA,EAAY,IAAA,GAAO,aAAA,CAAc,SAAA"}

package/dist/reflection.d.mts

@@ -1,21 +1,24 @@
-import { Type, TypeClass, TypeObjectLiteral } from "@powerlines/deepkit/vendor/type";
-import { JsonSchema7Type } from "@stryke/json/types";
+import { JTDSchemaType, SchemaMetadata } from "./types.mjs";
+import { Type } from "@powerlines/deepkit/vendor/type";
 
 //#region src/reflection.d.ts
 /**
- * Converts a Deepkit type reflection into a JSON Schema representation.
+ * Converts a Deepkit type reflection into a JSON Type Definition (RFC 8927) form suitable for AJV's JTD validator.
  *
- * @param reflection - The Deepkit type reflection to convert.
- * @returns The corresponding JSON Schema representation, or `undefined` if the type cannot be represented.
- */
-declare function reflectionToJsonSchema(reflection: Type): JsonSchema7Type | undefined;
-/**
- * Builds a JSON Schema object representation from a Deepkit class or object literal type.
+ * @remarks
+ * Some TypeScript constructs have no direct JTD equivalent and are handled with the closest available form:
  *
- * @param type - The class or object literal type whose members should be serialized.
- * @returns A JSON Schema object describing the type's properties.
+ * - `null` and `undefined` become the empty JTD form with `nullable: true`.
+ * - Unions of primitives that cannot be expressed as a JTD enum collapse to the empty form (which validates any value).
+ * - String/number/bigint literal unions are emitted as a JTD enum (non-string members are stringified, as JTD requires string enum members).
+ * - Tuples are emitted as a JTD elements form whose element schema is the single tuple member type, or the empty schema for mixed tuples.
+ * - `Date` is emitted as `{ type: "timestamp" }`.
+ * - Discriminated unions of object literals (a shared string-literal tag property) are emitted as a JTD discriminator form.
+ *
+ * @param reflection - The Deepkit type reflection to convert.
+ * @returns The corresponding JTD form, or `undefined` if the type cannot be represented.
  */
-declare function objectReflectionToJsonSchema(type: TypeObjectLiteral | TypeClass): JsonSchema7Type;
+declare function reflectionToJsonSchema<TMetadata extends Partial<SchemaMetadata> = Partial<SchemaMetadata>>(reflection: Type): JTDSchemaType<TMetadata> | undefined;
 //#endregion
-export { objectReflectionToJsonSchema, reflectionToJsonSchema };
+export { reflectionToJsonSchema };
 //# sourceMappingURL=reflection.d.mts.map

package/dist/reflection.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"reflection.d.mts","names":[],"sources":["../src/reflection.ts"],"mappings":";;;;;AAgCA;;;;;iBAAgB,sBAAA,CACd,UAAA,EAAY,IAAA,GACX,eAAA;;;;AAgMH;;;iBAAgB,4BAAA,CACd,IAAA,EAAM,iBAAA,GAAoB,SAAA,GACzB,eAAA"}
+{"version":3,"file":"reflection.d.mts","names":[],"sources":["../src/reflection.ts"],"mappings":";;;;;;AA2FA;;;;;;;;;;;;;;iBAAgB,sBAAA,mBACI,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,EAAA,CACpD,UAAA,EAAY,IAAA,GAAO,aAAA,CAAc,SAAA"}