@powerlines/schema 0.8.67 → 0.9.0

package/dist/reflection.cjs

@@ -4,120 +4,146 @@ let _powerlines_deepkit_vendor_type = require("@powerlines/deepkit/vendor/type")
 
 //#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";
+	}
+}
+/**
+* Attaches a `description` annotation to a JTD form's `metadata` bag.
+*
+* @param form - The JTD form to decorate.
+* @param description - The description text, or `undefined` to skip.
+* @returns The same JTD form, decorated when a description was provided.
+*/
+function attachDescription(form, description) {
+	if (!description) return form;
+	const metadata = form.metadata ?? {};
+	metadata.description = description;
+	form.metadata = metadata;
+	return form;
+}
+/**
+* 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) {
 	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.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 { 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.bigint: return {
-			type: "integer",
-			format: "int64"
-		};
+		case _powerlines_deepkit_vendor_type.ReflectionKind.number: return { type: numberBrandToJtdType(reflection.brand) };
+		case _powerlines_deepkit_vendor_type.ReflectionKind.bigint: return { type: "float64" };
 		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
-			};
-			if (typeof literal === "number") return {
-				type: Number.isInteger(literal) ? "integer" : "number",
-				const: literal
-			};
-			if (typeof literal === "boolean") return {
-				type: "boolean",
-				const: literal
-			};
-			if (typeof literal === "bigint") return {
-				type: "integer",
-				format: "int64"
-			};
-			if (literal instanceof RegExp) return {
-				type: "string",
-				pattern: literal.source
-			};
+			if (typeof literal === "string") return { enum: [literal] };
+			if (typeof literal === "number" || typeof literal === "bigint") return { enum: [String(literal)] };
+			if (typeof literal === "boolean") return { type: "boolean" };
+			if (literal instanceof RegExp) return { type: "string" };
 			return {};
 		}
 		case _powerlines_deepkit_vendor_type.ReflectionKind.templateLiteral: return { 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");
-			return {
-				type: allStrings ? "string" : allNumbers ? "number" : ["string", "number"],
-				enum: values
-			};
+			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 {};
+			return { enum: unique };
 		}
-		case _powerlines_deepkit_vendor_type.ReflectionKind.array: {
-			const items = reflectionToJsonSchema(reflection.type);
-			return items ? {
-				type: "array",
-				items
-			} : { type: "array" };
+		case _powerlines_deepkit_vendor_type.ReflectionKind.array: return { elements: reflectionToJtd(reflection.type) ?? {} };
+		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 { elements: {} };
+			if (items.length === 1) return { elements: items[0] };
+			return { 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 { nullable: true };
+			if (nonNull.length === 1) {
+				const only = nonNull[0];
+				if (nullable) only.nullable = true;
+				return only;
+			}
+			if (nonNull.every(isEnumForm)) {
+				const form = { enum: Array.from(new Set(nonNull.flatMap((b) => b.enum))) };
+				if (nullable) form.nullable = true;
+				return form;
+			}
+			const discriminator = tryReflectionDiscriminator(reflection.types);
+			if (discriminator) {
+				if (nullable) discriminator.nullable = true;
+				return discriminator;
+			}
+			const fallback = {};
+			if (nullable) fallback.nullable = true;
+			return 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 members[0];
+			if (members.every(isPropertiesForm)) return mergePropertiesForms(members);
+			return 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"
-			};
+			case "Date": return { type: "timestamp" };
 			case "RegExp": return { type: "string" };
-			case "URL": return {
-				type: "string",
-				format: "uri"
-			};
+			case "URL": return { 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
-				};
+				return { elements: (itemType ? reflectionToJtd(itemType) : void 0) ?? {} };
 			}
 			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;
+				return { values: (valueType ? reflectionToJtd(valueType) : void 0) ?? {} };
 			}
 			case "Uint8Array":
 			case "Uint8ClampedArray":
@@ -129,12 +155,9 @@ function reflectionToJsonSchema(reflection) {
 			case "Float32Array":
 			case "Float64Array":
 			case "BigInt64Array":
-			case "BigUint64Array": return {
-				type: "string",
-				contentEncoding: "base64"
-			};
+			case "BigUint64Array": return { 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,36 +177,134 @@ 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
+	};
+}
+/**
+* Builds a JTD properties form from a Deepkit class or object literal 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 form describing the type's members.
 */
 function objectReflectionToJsonSchema(type) {
+	return objectReflectionToJtd(type);
+}
+/**
+* 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 JTD properties or values form describing the type's members.
+*/
+function objectReflectionToJtd(type) {
 	const properties = {};
-	const required = [];
-	let additionalProperties;
+	const optionalProperties = {};
+	let indexValueSchema;
 	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 (typeof member.name !== "string") continue;
+		const propertySchema = reflectionToJtd(member.type);
 		if (!propertySchema) continue;
-		if (typeof property.description === "string") propertySchema.description = property.description;
-		properties[property.name] = propertySchema;
-		if (!property.optional) required.push(property.name);
+		if (typeof member.description === "string") attachDescription(propertySchema, member.description);
+		if (member.optional) optionalProperties[member.name] = propertySchema;
+		else properties[member.name] = propertySchema;
 	} else if (member.kind === _powerlines_deepkit_vendor_type.ReflectionKind.indexSignature) {
-		const valueSchema = reflectionToJsonSchema(member.type);
-		if (valueSchema) additionalProperties = valueSchema;
+		const valueSchema = reflectionToJtd(member.type);
+		if (valueSchema) indexValueSchema = valueSchema;
 	}
-	const schema = {
-		type: "object",
-		properties
-	};
-	if (required.length > 0) schema.required = required;
-	if (additionalProperties !== void 0) schema.additionalProperties = additionalProperties;
-	if (description) schema.description = description;
-	return schema;
+	const hasProperties = Object.keys(properties).length > 0;
+	const hasOptional = Object.keys(optionalProperties).length > 0;
+	if (!hasProperties && !hasOptional && indexValueSchema) return attachDescription({ values: indexValueSchema }, description);
+	const form = {};
+	if (hasProperties) form.properties = properties;
+	else if (!hasOptional) form.properties = {};
+	if (hasOptional) form.optionalProperties = optionalProperties;
+	if (indexValueSchema) form.additionalProperties = true;
+	return attachDescription(form, description);
 }
 
 //#endregion

package/dist/reflection.d.cts

@@ -1,21 +1,31 @@
 import { Type, TypeClass, TypeObjectLiteral } from "@powerlines/deepkit/vendor/type";
-import { JsonSchema7Type } from "@stryke/json/types";
+import { JTDSchemaType } from "ajv/dist/types/jtd-schema.js";
 
 //#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.
+ *
+ * @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.
  */
-declare function reflectionToJsonSchema(reflection: Type): JsonSchema7Type | undefined;
+declare function reflectionToJsonSchema<T = unknown, D extends Record<string, unknown> = Record<string, unknown>>(reflection: Type): JTDSchemaType<T, D> | undefined;
 /**
- * Builds a JSON Schema object representation from a Deepkit class or object literal type.
+ * Builds a JTD properties form from a Deepkit class or object literal 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 form describing the type's members.
  */
-declare function objectReflectionToJsonSchema(type: TypeObjectLiteral | TypeClass): JsonSchema7Type;
+declare function objectReflectionToJsonSchema<T = unknown, D extends Record<string, unknown> = Record<string, unknown>>(type: TypeObjectLiteral | TypeClass): JTDSchemaType<T, D>;
 //#endregion
 export { objectReflectionToJsonSchema, 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":";;;;;AA0GA;;;;;;;;;;;;;;;iBAAgB,sBAAA,wBAEJ,MAAA,oBAA0B,MAAA,kBAAA,CACpC,UAAA,EAAY,IAAA,GAAO,aAAA,CAAc,CAAA,EAAG,CAAA;;;;;;;iBAwYtB,4BAAA,wBAEJ,MAAA,oBAA0B,MAAA,kBAAA,CACpC,IAAA,EAAM,iBAAA,GAAoB,SAAA,GAAY,aAAA,CAAc,CAAA,EAAG,CAAA"}

package/dist/reflection.d.mts

@@ -1,21 +1,31 @@
 import { Type, TypeClass, TypeObjectLiteral } from "@powerlines/deepkit/vendor/type";
-import { JsonSchema7Type } from "@stryke/json/types";
+import { JTDSchemaType } from "ajv/dist/types/jtd-schema.js";
 
 //#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.
+ *
+ * @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.
  */
-declare function reflectionToJsonSchema(reflection: Type): JsonSchema7Type | undefined;
+declare function reflectionToJsonSchema<T = unknown, D extends Record<string, unknown> = Record<string, unknown>>(reflection: Type): JTDSchemaType<T, D> | undefined;
 /**
- * Builds a JSON Schema object representation from a Deepkit class or object literal type.
+ * Builds a JTD properties form from a Deepkit class or object literal 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 form describing the type's members.
  */
-declare function objectReflectionToJsonSchema(type: TypeObjectLiteral | TypeClass): JsonSchema7Type;
+declare function objectReflectionToJsonSchema<T = unknown, D extends Record<string, unknown> = Record<string, unknown>>(type: TypeObjectLiteral | TypeClass): JTDSchemaType<T, D>;
 //#endregion
 export { objectReflectionToJsonSchema, 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":";;;;;AA0GA;;;;;;;;;;;;;;;iBAAgB,sBAAA,wBAEJ,MAAA,oBAA0B,MAAA,kBAAA,CACpC,UAAA,EAAY,IAAA,GAAO,aAAA,CAAc,CAAA,EAAG,CAAA;;;;;;;iBAwYtB,4BAAA,wBAEJ,MAAA,oBAA0B,MAAA,kBAAA,CACpC,IAAA,EAAM,iBAAA,GAAoB,SAAA,GAAY,aAAA,CAAc,CAAA,EAAG,CAAA"}