@oscarpalmer/jhunal 0.18.0 → 0.20.0

package/dist/models/validation.model.d.mts

@@ -3,10 +3,23 @@ import { ValueName } from "./misc.model.mjs";
 import { GenericCallback } from "@oscarpalmer/atoms/models";
 
 //#region src/models/validation.model.d.ts
-type ReportingInformation = Record<ReportingType, boolean>;
+/**
+ * Maps each {@link ReportingType} to a boolean flag
+ */
+type ReportingInformation = Record<ReportingType, boolean> & {
+  type: ReportingType;
+};
+/**
+ * Controls how validation failures are reported
+ *
+ * - `'none'` — returns a boolean _(default)_
+ * - `'first'` — returns the first failure as a `Result`
+ * - `'all'` — returns all failures as a `Result` _(from same level)_
+ * - `'throw'` — throws a {@link ValidationError} on failure
+ */
 type ReportingType = 'all' | 'first' | 'none' | 'throw';
 /**
- * A custom error class for schematic validation failures
+ * Thrown when a schema definition is invalid
  */
 declare class SchematicError extends Error {
   constructor(message: string);
@@ -43,16 +56,12 @@ type ValidatedProperty = {
   validators: ValidatedPropertyValidators;
 };
 /**
- * Property name in schema
+ * The full and short forms of a property's key path
+ *
+ * For a nested property `address.street`: `full` is `'address.street'`, `short` is `'street'`
  */
 type ValidatedPropertyKey = {
-  /**
-   * Full property key, including parent keys for nested properties _(e.g., `address.street`)_
-   */
   full: string;
-  /**
-   * The last segment of the property key _(e.g., `street` for `address.street`)_
-   */
   short: string;
 };
 /**
@@ -67,15 +76,42 @@ type ValidatedPropertyType = GenericCallback | ValidatedProperty[] | Schematic<u
  * Each key holds an array of validator functions that receive an `unknown` value and return a `boolean`
  */
 type ValidatedPropertyValidators = { [Key in ValueName]?: Array<(value: unknown) => boolean> };
+/**
+ * Thrown in `'throw'` mode when one or more properties fail validation; `information` holds all failures
+ */
 declare class ValidationError extends Error {
   readonly information: ValidationInformation[];
   constructor(information: ValidationInformation[]);
 }
+/**
+ * Describes a single validation failure
+ */
 type ValidationInformation = {
-  key: ValidationInformationKey;
-  message: string;
-  validator?: GenericCallback;
+  /** The key path of the property that failed */key: ValidationInformationKey; /** Human-readable description of the failure */
+  message: string; /** The validator function that failed, if the failure was from a `$validators` entry */
+  validator?: GenericCallback; /** The value that was provided */
+  value: unknown;
 };
+/**
+ * Same shape as {@link ValidatedPropertyKey}; the key path of a failed property
+ */
 type ValidationInformationKey = ValidatedPropertyKey;
+/**
+ * Options for validation
+ */
+type ValidationOptions<Errors extends ReportingType> = {
+  /**
+   * How should validation failures be reported; see {@link ReportingType} _(defaults to `'none'`)_
+   */
+  errors?: Errors;
+  /**
+   * Validate if unknown keys are present in the object? _(defaults to `false`)_
+   */
+  strict?: boolean;
+};
+type ValidationOptionsExtended = {
+  reporting: ReportingInformation;
+  strict: boolean;
+};
 //#endregion
-export { ReportingInformation, ReportingType, SchematicError, ValidatedProperty, ValidatedPropertyKey, ValidatedPropertyType, ValidatedPropertyValidators, ValidationError, ValidationInformation, ValidationInformationKey };
+export { ReportingInformation, ReportingType, SchematicError, ValidatedProperty, ValidatedPropertyKey, ValidatedPropertyType, ValidatedPropertyValidators, ValidationError, ValidationInformation, ValidationInformationKey, ValidationOptions, ValidationOptionsExtended };

package/dist/models/validation.model.mjs

@@ -2,7 +2,7 @@ import { NAME_ERROR_SCHEMATIC, NAME_ERROR_VALIDATION } from "../constants.mjs";
 import { join } from "@oscarpalmer/atoms/string";
 //#region src/models/validation.model.ts
 /**
-* A custom error class for schematic validation failures
+* Thrown when a schema definition is invalid
 */
 var SchematicError = class extends Error {
 	constructor(message) {
@@ -10,6 +10,9 @@ var SchematicError = class extends Error {
 		this.name = NAME_ERROR_SCHEMATIC;
 	}
 };
+/**
+* Thrown in `'throw'` mode when one or more properties fail validation; `information` holds all failures
+*/
 var ValidationError = class extends Error {
 	constructor(information) {
 		super(join(information.map((item) => item.message), "; "));

package/dist/schematic.d.mts

@@ -1,8 +1,9 @@
 import { Infer } from "./models/infer.model.mjs";
 import { TypedSchema } from "./models/schema.typed.model.mjs";
-import { ValidatedProperty } from "./models/validation.model.mjs";
+import { ValidatedProperty, ValidationInformation, ValidationOptions } from "./models/validation.model.mjs";
 import { Schema } from "./models/schema.plain.model.mjs";
 import { PlainObject } from "@oscarpalmer/atoms/models";
+import { Result } from "@oscarpalmer/atoms/result/models";
 
 //#region src/schematic.d.ts
 /**
@@ -17,18 +18,64 @@ declare class Schematic<Model> {
    *
    * Will assert that the values matches the schema and throw an error if it does not. The error will contain all validation information for the first property that fails validation.
    * @param value Value to validate
-   * @param errors Throws an error for the first validation failure
+   * @param options Validation options
+   * @returns `true` if the value matches the schema, otherwise throws an error
+   */
+  is(value: unknown, options: ValidationOptions<'throw'>): asserts value is Model;
+  /**
+   * Does the value match the schema?
+   *
+   * Will assert that the values matches the schema and throw an error if it does not. The error will contain all validation information for the first property that fails validation.
+   * @param value Value to validate
+   * @param errors Reporting type
    * @returns `true` if the value matches the schema, otherwise throws an error
    */
   is(value: unknown, errors: 'throw'): asserts value is Model;
+  /**
+   * Does the value match the schema?
+   *
+   * Will validate that the value matches the schema and return a result of `true` or all validation information for validation failures from the same depth in the object.
+   * @param value Value to validate
+   * @param options Validation options
+   * @returns `true` if the value matches the schema, otherwise `false`
+   */
+  is(value: unknown, options: ValidationOptions<'all'>): Result<true, ValidationInformation[]>;
+  /**
+   * Does the value match the schema?
+   *
+   * Will validate that the value matches the schema and return a result of `true` or all validation information for validation failures from the same depth in the object.
+   * @param value Value to validate
+   * @param errors Reporting type
+   * @returns `true` if the value matches the schema, otherwise `false`
+   */
+  is(value: unknown, errors: 'all'): Result<true, ValidationInformation[]>;
+  /**
+   * Does the value match the schema?
+   *
+   * Will validate that the value matches the schema and return a result of `true` or all validation information for the failing property.
+   * @param value Value to validate
+   * @param options Validation options
+   * @returns `true` if the value matches the schema, otherwise `false`
+   */
+  is(value: unknown, options: ValidationOptions<'first'>): Result<true, ValidationInformation>;
+  /**
+   * Does the value match the schema?
+   *
+   * Will validate that the value matches the schema and return a result of `true` or all validation information for the failing property.
+   * @param value Value to validate
+   * @param errors Reporting type
+   * @returns `true` if the value matches the schema, otherwise `false`
+   */
+  is(value: unknown, errors: 'first'): Result<true, ValidationInformation>;
   /**
    * Does the value match the schema?
    *
    * Will validate that the value matches the schema and return `true` or `false`, without any validation information for validation failures.
    * @param value Value to validate
+   * @param strict Validate if unknown keys are present in the object? _(defaults to `false`)_
    * @returns `true` if the value matches the schema, otherwise `false`
    */
-  is(value: unknown): value is Model;
+  is(value: unknown, strict?: true): value is Model;
 }
 /**
  * Create a schematic from a schema
@@ -46,5 +93,6 @@ declare function schematic<Model extends Schema>(schema: Model): Schematic<Infer
  * @returns A schematic for the given typed schema
  */
 declare function schematic<Model extends PlainObject>(schema: TypedSchema<Model>): Schematic<Model>;
+declare const schematicProperties: WeakMap<Schematic<unknown>, ValidatedProperty[]>;
 //#endregion
-export { Schematic, schematic };
+export { Schematic, schematic, schematicProperties };

package/dist/schematic.mjs

@@ -1,9 +1,10 @@
 import { PROPERTY_SCHEMATIC, SCHEMATIC_MESSAGE_SCHEMA_INVALID_TYPE } from "./constants.mjs";
-import { getReporting, isSchematic } from "./helpers.mjs";
+import { getOptions, isSchematic } from "./helpers.mjs";
 import { SchematicError } from "./models/validation.model.mjs";
 import { getProperties } from "./validation/property.validation.mjs";
 import { validateObject } from "./validation/value.validation.mjs";
 import { isPlainObject } from "@oscarpalmer/atoms/is";
+import { error } from "@oscarpalmer/atoms/result/misc";
 //#region src/schematic.ts
 /**
 * A schematic for validating objects
@@ -13,9 +14,16 @@ var Schematic = class {
 	constructor(properties) {
 		Object.defineProperty(this, PROPERTY_SCHEMATIC, { value: true });
 		this.#properties = properties;
+		schematicProperties.set(this, properties);
 	}
-	is(value, errors) {
-		return validateObject(value, this.#properties, getReporting(errors));
+	is(value, options) {
+		const { reporting, strict } = getOptions(options);
+		const result = validateObject(value, this.#properties, {
+			reporting,
+			strict
+		});
+		if (typeof result === "boolean") return result;
+		return error(reporting.all ? result : result[0]);
 	}
 };
 function schematic(schema) {
@@ -23,5 +31,6 @@ function schematic(schema) {
 	if (!isPlainObject(schema)) throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_TYPE);
 	return new Schematic(getProperties(schema));
 }
+const schematicProperties = /* @__PURE__ */ new WeakMap();
 //#endregion
-export { Schematic, schematic };
+export { Schematic, schematic, schematicProperties };

package/dist/validation/value.validation.d.mts

@@ -1,6 +1,6 @@
-import { ReportingInformation, ValidatedProperty, ValidationInformation } from "../models/validation.model.mjs";
+import { ValidatedProperty, ValidationInformation, ValidationOptionsExtended } from "../models/validation.model.mjs";
 
 //#region src/validation/value.validation.d.ts
-declare function validateObject(obj: unknown, properties: ValidatedProperty[], reporting: ReportingInformation, validation?: ValidationInformation[]): boolean;
+declare function validateObject(obj: unknown, properties: ValidatedProperty[], options: ValidationOptionsExtended, origin?: ValidatedProperty, validation?: ValidationInformation[]): boolean | ValidationInformation[];
 //#endregion
 export { validateObject };

package/dist/validation/value.validation.mjs

@@ -1,6 +1,9 @@
-import { getInvalidInputMessage, getInvalidMissingMessage, getInvalidTypeMessage, getInvalidValidatorMessage, isSchematic } from "../helpers.mjs";
+import "../constants.mjs";
+import { getInvalidInputMessage, getInvalidMissingMessage, getInvalidTypeMessage, getInvalidValidatorMessage, getUnknownKeysMessage, isSchematic } from "../helpers.mjs";
 import { ValidationError } from "../models/validation.model.mjs";
+import { schematicProperties } from "../schematic.mjs";
 import { isPlainObject } from "@oscarpalmer/atoms/is";
+import { join } from "@oscarpalmer/atoms/string";
 //#region src/validation/value.validation.ts
 function validateNamed(property, name, value, validation) {
 	if (!validators[name](value)) return false;
@@ -11,6 +14,7 @@ function validateNamed(property, name, value, validation) {
 		const validator = propertyValidators[index];
 		if (!validator(value)) {
 			validation.push({
+				value,
 				key: { ...property.key },
 				message: getInvalidValidatorMessage(property, name, index, length),
 				validator
@@ -20,63 +24,104 @@ function validateNamed(property, name, value, validation) {
 	}
 	return true;
 }
-function validateObject(obj, properties, reporting, validation) {
+function validateObject(obj, properties, options, origin, validation) {
 	if (!isPlainObject(obj)) {
-		if (reporting.throw && validation == null) throw new ValidationError([{
-			key: {
-				full: "",
-				short: ""
-			},
-			message: getInvalidInputMessage(obj)
-		}]);
-		return false;
+		const key = origin == null ? {
+			full: "",
+			short: ""
+		} : { ...origin.key };
+		const information = {
+			key,
+			message: origin == null ? getInvalidInputMessage(obj) : getInvalidTypeMessage({
+				...origin,
+				key
+			}, obj),
+			value: obj
+		};
+		if (options.reporting.throw) throw new ValidationError([information]);
+		validation?.push(information);
+		return options.reporting.none ? false : [information];
+	}
+	if (options.strict) {
+		const objKeys = Object.keys(obj);
+		const propertiesKeys = new Set(properties.map((property) => property.key.short));
+		const unknownKeys = objKeys.filter((key) => !propertiesKeys.has(key));
+		if (unknownKeys.length > 0) {
+			const information = {
+				key: origin == null ? {
+					full: "",
+					short: ""
+				} : { ...origin.key },
+				message: getUnknownKeysMessage(unknownKeys.map((key) => join([origin?.key.full, key], "."))),
+				value: obj
+			};
+			if (options.reporting.throw) throw new ValidationError([information]);
+			validation?.push(information);
+			return options.reporting.none ? false : [information];
+		}
 	}
+	const allInformation = [];
 	const propertiesLength = properties.length;
 	outer: for (let propertyIndex = 0; propertyIndex < propertiesLength; propertyIndex += 1) {
-		const property = properties[propertyIndex];
+		let property = properties[propertyIndex];
+		property = {
+			...property,
+			key: {
+				full: join([origin?.key.full, property.key.short], "."),
+				short: property.key.short
+			}
+		};
 		const { key, required, types } = property;
 		const value = obj[key.short];
 		if (value === void 0 && required) {
 			const information = {
+				value,
 				key: { ...key },
 				message: getInvalidMissingMessage(property)
 			};
-			if (reporting.throw && validation == null) throw new ValidationError([information]);
+			if (options.reporting.throw && validation == null) throw new ValidationError([information]);
 			if (validation != null) validation.push(information);
-			return false;
+			if (options.reporting.all) {
+				allInformation.push(information);
+				continue;
+			}
+			return options.reporting.none ? false : [information];
 		}
 		const typesLength = types.length;
 		const information = [];
 		for (let typeIndex = 0; typeIndex < typesLength; typeIndex += 1) {
 			const type = types[typeIndex];
-			if (validateValue(type, property, value, reporting, information)) continue outer;
+			if (validateValue(type, property, value, options, information)) continue outer;
 		}
-		if (reporting.throw && validation == null) throw new ValidationError(information.length === 0 ? [{
+		if (information.length === 0) information.push({
+			value,
 			key: { ...key },
 			message: getInvalidTypeMessage(property, value)
-		}] : information);
+		});
+		if (options.reporting.throw && validation == null) throw new ValidationError(information);
 		validation?.push(...information);
-		return false;
+		if (options.reporting.all) {
+			allInformation.push(...information);
+			continue;
+		}
+		return options.reporting.none ? false : information;
 	}
-	return true;
+	return options.reporting.none || allInformation.length === 0 ? true : allInformation;
 }
-function validateValue(type, property, value, reporting, validation) {
-	let result;
+function validateSchematic(property, schematic, value, options, validation) {
+	const result = validateObject(value, schematicProperties.get(schematic), options, property, validation);
+	return typeof result === "boolean" ? result : result.length === 0;
+}
+function validateValue(type, property, value, options, validation) {
 	switch (true) {
-		case typeof type === "function":
-			result = type(value);
-			break;
-		case Array.isArray(type):
-			result = validateObject(value, type, reporting, validation);
-			break;
-		case isSchematic(type):
-			result = type.is(value, reporting);
-			break;
-		default:
-			result = validateNamed(property, type, value, validation);
-			break;
+		case typeof type === "function": return type(value);
+		case Array.isArray(type): {
+			const validated = validateObject(value, type, options, property, validation);
+			return typeof validated === "boolean" ? validated : false;
+		}
+		case isSchematic(type): return validateSchematic(property, type, value, options, validation);
+		default: return validateNamed(property, type, value, validation);
 	}
-	return result;
 }
 const validators = {
 	array: Array.isArray,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oscarpalmer/jhunal",
-  "version": "0.18.0",
+  "version": "0.20.0",
   "description": "Flies free beneath the glistening moons…",
   "keywords": [
     "schema",

package/src/constants.ts

@@ -1,6 +1,20 @@
 import type {ValueName} from './models/misc.model';
 import type {ReportingType} from './models/validation.model';
 
+// #region Grammar
+
+export const COMMA = ', ';
+
+export const CONJUNCTION_OR = ' or ';
+
+export const CONJUNCTION_OR_COMMA = ', or ';
+
+export const CONJUNCTION_AND = ' and ';
+
+export const CONJUNCTION_AND_COMMA = ', and ';
+
+// #endregion
+
 // #region Misc.
 
 export const MESSAGE_CONSTRUCTOR = 'Expected a constructor function';
@@ -42,6 +56,8 @@ export const VALIDATION_MESSAGE_INVALID_VALUE =
 
 export const VALIDATION_MESSAGE_INVALID_VALUE_SUFFIX = ' at index <>';
 
+export const VALIDATION_MESSAGE_UNKNOWN_KEYS = 'Found keys that are not defined in the schema: <>';
+
 // #endregion
 
 // #region Reporting

package/src/helpers.ts

@@ -1,6 +1,11 @@
 import {isConstructor, isPlainObject} from '@oscarpalmer/atoms/is';
 import type {Constructor} from '@oscarpalmer/atoms/models';
 import {
+	COMMA,
+	CONJUNCTION_AND,
+	CONJUNCTION_AND_COMMA,
+	CONJUNCTION_OR,
+	CONJUNCTION_OR_COMMA,
 	MESSAGE_CONSTRUCTOR,
 	NAME_SCHEMATIC,
 	PROPERTY_SCHEMATIC,
@@ -19,6 +24,7 @@ import {
 	VALIDATION_MESSAGE_INVALID_TYPE,
 	VALIDATION_MESSAGE_INVALID_VALUE,
 	VALIDATION_MESSAGE_INVALID_VALUE_SUFFIX,
+	VALIDATION_MESSAGE_UNKNOWN_KEYS,
 } from './constants';
 import type {ValueName} from './models/misc.model';
 import type {
@@ -73,6 +79,29 @@ export function getInvalidValidatorMessage(
 	return message;
 }
 
+export function getOptions(input: unknown) {
+	if (typeof input === 'boolean') {
+		return {
+			reporting: getReporting(REPORTING_NONE),
+			strict: input,
+		};
+	}
+
+	if (REPORTING_TYPES.has(input as ReportingType)) {
+		return {
+			reporting: getReporting(input as ReportingType),
+			strict: false,
+		};
+	}
+
+	const options = isPlainObject(input) ? input : {};
+
+	return {
+		reporting: getReporting(options.errors),
+		strict: typeof options.strict === 'boolean' ? options.strict : false,
+	};
+}
+
 function getPropertyType(original: ValidatedPropertyType): string {
 	if (typeof original === 'function') {
 		return 'a validated value';
@@ -95,6 +124,7 @@ export function getReporting(value: unknown): ReportingInformation {
 		: REPORTING_NONE;
 
 	return {
+		type,
 		[REPORTING_ALL]: type === REPORTING_ALL,
 		[REPORTING_FIRST]: type === REPORTING_FIRST,
 		[REPORTING_NONE]: type === REPORTING_NONE,
@@ -102,6 +132,10 @@ export function getReporting(value: unknown): ReportingInformation {
 	} as ReportingInformation;
 }
 
+export function getUnknownKeysMessage(keys: string[]): string {
+	return VALIDATION_MESSAGE_UNKNOWN_KEYS.replace(TEMPLATE_PATTERN, renderKeys(keys));
+}
+
 function getValueType(value: unknown): string {
 	const valueType = typeof value;
 
@@ -161,34 +195,46 @@ export function isSchematic(value: unknown): value is Schematic<never> {
 	);
 }
 
-function renderTypes(types: ValidatedPropertyType[]): string {
-	const unique = new Set<string>();
-	const parts: string[] = [];
-
-	for (let index = 0; index < types.length; index += 1) {
-		const rendered = getPropertyType(types[index]);
+function renderKeys(keys: string[]): string {
+	return renderParts(keys.map(key => `'${key}'`), CONJUNCTION_AND, CONJUNCTION_AND_COMMA);
+}
 
-		if (unique.has(rendered)) {
-			continue;
-		}
+function renderParts(parts: string[], delimiterShort: string, delimiterLong: string): string {
+	const {length} = parts;
 
-		unique.add(rendered);
-		parts.push(rendered);
+	if (length === 1) {
+		return parts[0];
 	}
 
-	const {length} = parts;
-
 	let rendered = '';
 
 	for (let index = 0; index < length; index += 1) {
 		rendered += parts[index];
 
 		if (index < length - 2) {
-			rendered += ', ';
+			rendered += COMMA;
 		} else if (index === length - 2) {
-			rendered += parts.length > 2 ? ', or ' : ' or ';
+			rendered += parts.length > 2 ? delimiterLong : delimiterShort;
 		}
 	}
 
 	return rendered;
 }
+
+function renderTypes(types: ValidatedPropertyType[]): string {
+	const unique = new Set<string>();
+	const parts: string[] = [];
+
+	for (let index = 0; index < types.length; index += 1) {
+		const rendered = getPropertyType(types[index]);
+
+		if (unique.has(rendered)) {
+			continue;
+		}
+
+		unique.add(rendered);
+		parts.push(rendered);
+	}
+
+	return renderParts(parts, CONJUNCTION_OR, CONJUNCTION_OR_COMMA);
+}

package/src/models/infer.model.ts

@@ -6,7 +6,7 @@ import type {PlainSchema, Schema, SchemaProperty} from './schema.plain.model';
 /**
  * Infers the TypeScript type from a {@link Schema} definition
  *
- * @template Model - Schema to infer types from
+ * @template Model Schema to infer types from
  *
  * @example
  * ```ts
@@ -38,20 +38,20 @@ export type InferOptionalKeys<Model extends Schema> = keyof {
 };
 
 /**
- * Infers the TypeScript type of a {@link SchemaProperty}'s `$type` field, unwrapping arrays to infer their item type
+ * Infers the TypeScript type from a {@link SchemaProperty}'s `$type` field
  *
- * @template Value - `$type` value _(single or array)_
+ * @template Value `$type` value _(single or array)_
  */
 export type InferPropertyType<Value> = Value extends (infer Item)[]
 	? InferPropertyValue<Item>
 	: InferPropertyValue<Value>;
 
 /**
- * Maps a single type definition to its TypeScript equivalent
+ * Maps a single `$type` definition to its TypeScript equivalent
  *
- * Resolves, in order: {@link Constructor} instances, {@link Schematic} models, {@link ValueName} strings, and nested {@link Schema} objects
+ * Resolves, in order: {@link Constructor} instances, {@link Schematic} models, {@link ValueName} strings, and nested {@link PlainSchema} objects
  *
- * @template Value - single type definition
+ * @template Value single type definition
  */
 export type InferPropertyValue<Value> =
 	Value extends Constructor<infer Instance>
@@ -67,27 +67,27 @@ export type InferPropertyValue<Value> =
 /**
  * Extracts keys from a {@link Schema} whose entries are required _(i.e., `$required` is not `false`)_
  *
- * @template Model - Schema to extract required keys from
+ * @template Model Schema to extract required keys from
  */
 export type InferRequiredKeys<Model extends Schema> = keyof {
 	[Key in keyof Model as IsOptionalProperty<Model[Key]> extends true ? never : Key]: never;
 };
 
 /**
- * Infers the type for a top-level {@link Schema} entry, unwrapping arrays to infer their item type
+ * Infers the TypeScript type from a top-level {@link Schema} entry
  *
- * @template Value - Schema entry value _(single or array)_
+ * @template Value Schema entry value _(single or array)_
  */
 export type InferSchemaEntry<Value> = Value extends (infer Item)[]
 	? InferSchemaEntryValue<Item>
 	: InferSchemaEntryValue<Value>;
 
 /**
- * Resolves a single schema entry to its TypeScript type
+ * Maps a single top-level schema entry to its TypeScript type
  *
- * Handles, in order: {@link Constructor} instances, {@link Schematic} models, {@link SchemaProperty} objects, {@link NestedSchema} objects, {@link ValueName} strings, and plain {@link Schema} objects
+ * Resolves, in order: {@link Constructor} instances, {@link Schematic} models, {@link SchemaProperty} objects, {@link PlainSchema} objects, and {@link ValueName} strings
  *
- * @template Value - single schema entry
+ * @template Value single schema entry
  */
 export type InferSchemaEntryValue<Value> =
 	Value extends Constructor<infer Instance>