@oscarpalmer/jhunal 0.9.0 → 0.11.0

package/dist/constants.js

@@ -1,22 +1,36 @@
+const ERROR_NAME = "SchematicError";
 const EXPRESSION_HAS_NUMBER = /\d+/;
 const EXPRESSION_INDEX = /\.\d+$/;
-const EXPRESSION_PROPERTY = /\.\$(required|type)(\.|$)/;
+const EXPRESSION_PROPERTY = /\.\$(required|type|validators)(\.|$)/;
+const MESSAGE_CONSTRUCTOR = "Expected a constructor function";
+const MESSAGE_SCHEMA_INVALID_EMPTY = "Schema must have at least one property";
+const MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED = "'<>.$required' property must be a boolean";
+const MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE = "'<>' property must be of a valid type";
+const MESSAGE_SCHEMA_INVALID_TYPE = "Schema must be an object";
+const MESSAGE_VALIDATOR_INVALID_KEY = "Validator '<>' does not exist";
+const MESSAGE_VALIDATOR_INVALID_TYPE = "Validators must be an object";
+const MESSAGE_VALIDATOR_INVALID_VALUE = "Validator '<>' must be a function or an array of functions";
 const PROPERTY_REQUIRED = "$required";
 const PROPERTY_TYPE = "$type";
+const PROPERTY_VALIDATORS = "$validators";
 const SCHEMATIC_NAME = "$schematic";
+const TEMPLATE_PATTERN = "<>";
 const TYPE_OBJECT = "object";
 const TYPE_UNDEFINED = "undefined";
-const TYPE_ALL = new Set([
+const VALIDATABLE_TYPES = new Set([
 	"array",
 	"bigint",
 	"boolean",
 	"date",
 	"function",
-	"null",
 	"number",
 	"string",
 	"symbol",
-	TYPE_OBJECT,
+	TYPE_OBJECT
+]);
+const TYPE_ALL = new Set([
+	...VALIDATABLE_TYPES,
+	"null",
 	TYPE_UNDEFINED
 ]);
-export { EXPRESSION_HAS_NUMBER, EXPRESSION_INDEX, EXPRESSION_PROPERTY, PROPERTY_REQUIRED, PROPERTY_TYPE, SCHEMATIC_NAME, TYPE_ALL, TYPE_OBJECT, TYPE_UNDEFINED };
+export { ERROR_NAME, EXPRESSION_HAS_NUMBER, EXPRESSION_INDEX, EXPRESSION_PROPERTY, MESSAGE_CONSTRUCTOR, MESSAGE_SCHEMA_INVALID_EMPTY, MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED, MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE, MESSAGE_SCHEMA_INVALID_TYPE, MESSAGE_VALIDATOR_INVALID_KEY, MESSAGE_VALIDATOR_INVALID_TYPE, MESSAGE_VALIDATOR_INVALID_VALUE, PROPERTY_REQUIRED, PROPERTY_TYPE, PROPERTY_VALIDATORS, SCHEMATIC_NAME, TEMPLATE_PATTERN, TYPE_ALL, TYPE_OBJECT, TYPE_UNDEFINED, VALIDATABLE_TYPES };

package/dist/index.js

@@ -1,3 +1,4 @@
 import { isInstance } from "./is.js";
+import { SchematicError } from "./models.js";
 import { schematic } from "./schematic.js";
-export { isInstance, schematic };
+export { SchematicError, isInstance, schematic };

package/dist/is.js

@@ -1,7 +1,7 @@
-import "./constants.js";
+import { MESSAGE_CONSTRUCTOR } from "./constants.js";
 import { isConstructor } from "@oscarpalmer/atoms/is";
 function isInstance(constructor) {
-	if (!isConstructor(constructor)) throw new TypeError("Expected a constructor function");
+	if (!isConstructor(constructor)) throw new TypeError(MESSAGE_CONSTRUCTOR);
 	return (value) => {
 		return value instanceof constructor;
 	};

package/dist/jhunal.full.js

@@ -58,29 +58,43 @@ function getString(value) {
 function join(value, delimiter) {
 	return compact(value).map(getString).join(typeof delimiter === "string" ? delimiter : "");
 }
+const ERROR_NAME = "SchematicError";
 const EXPRESSION_HAS_NUMBER = /\d+/;
 const EXPRESSION_INDEX = /\.\d+$/;
-const EXPRESSION_PROPERTY = /\.\$(required|type)(\.|$)/;
+const EXPRESSION_PROPERTY = /\.\$(required|type|validators)(\.|$)/;
+const MESSAGE_CONSTRUCTOR = "Expected a constructor function";
+const MESSAGE_SCHEMA_INVALID_EMPTY = "Schema must have at least one property";
+const MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED = "'<>.$required' property must be a boolean";
+const MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE = "'<>' property must be of a valid type";
+const MESSAGE_SCHEMA_INVALID_TYPE = "Schema must be an object";
+const MESSAGE_VALIDATOR_INVALID_KEY = "Validator '<>' does not exist";
+const MESSAGE_VALIDATOR_INVALID_TYPE = "Validators must be an object";
+const MESSAGE_VALIDATOR_INVALID_VALUE = "Validator '<>' must be a function or an array of functions";
 const PROPERTY_REQUIRED = "$required";
 const PROPERTY_TYPE = "$type";
+const PROPERTY_VALIDATORS = "$validators";
 const SCHEMATIC_NAME = "$schematic";
+const TEMPLATE_PATTERN = "<>";
 const TYPE_OBJECT = "object";
 const TYPE_UNDEFINED = "undefined";
-const TYPE_ALL = new Set([
+const VALIDATABLE_TYPES = new Set([
 	"array",
 	"bigint",
 	"boolean",
 	"date",
 	"function",
-	"null",
 	"number",
 	"string",
 	"symbol",
-	TYPE_OBJECT,
+	TYPE_OBJECT
+]);
+const TYPE_ALL = new Set([
+	...VALIDATABLE_TYPES,
+	"null",
 	TYPE_UNDEFINED
 ]);
 function isInstance(constructor) {
-	if (!isConstructor(constructor)) throw new TypeError("Expected a constructor function");
+	if (!isConstructor(constructor)) throw new TypeError(MESSAGE_CONSTRUCTOR);
 	return (value) => {
 		return value instanceof constructor;
 	};
@@ -88,6 +102,12 @@ function isInstance(constructor) {
 function isSchematic(value) {
 	return typeof value === "object" && value !== null && SCHEMATIC_NAME in value && value[SCHEMATIC_NAME] === true;
 }
+var SchematicError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = ERROR_NAME;
+	}
+};
 function flattenObject(value, depth, smushed, prefix) {
 	if (depth >= MAX_DEPTH) return {};
 	if (smushed.has(value)) return smushed.get(value);
@@ -121,30 +141,30 @@ function smush(value) {
 	return typeof value === "object" && value !== null ? flattenObject(value, 0, /* @__PURE__ */ new WeakMap()) : {};
 }
 var MAX_DEPTH = 100;
-function addPropertyType(to, key, values, required) {
+function addPropertyType(to, key, values, validators, required) {
 	if (to.keys.set.has(key)) {
 		const property = to.properties[key];
-		for (const type of values) if (!property.types.includes(type)) property.types.push(type);
+		for (const type of values) property.types.push(type);
 	} else {
 		to.keys.array.push(key);
 		to.keys.set.add(key);
 		to.properties[key] = {
 			required,
-			types: values
+			types: values,
+			validators: {}
 		};
 	}
 	if (!required && !to.properties[key].types.includes(TYPE_UNDEFINED)) to.properties[key].types.push(TYPE_UNDEFINED);
+	to.properties[key].validators = validators;
 }
 function getSchema(schema) {
-	const validated = {
-		enabled: false,
+	return getValidatedSchema(schema, {
 		keys: {
 			array: [],
 			set: /* @__PURE__ */ new Set()
 		},
 		properties: {}
-	};
-	return typeof schema === "object" && schema !== null ? getValidatedSchema(schema, validated) : validated;
+	});
 }
 function getTypes(value, validated, prefix) {
 	const propertyTypes = [];
@@ -152,23 +172,24 @@ function getTypes(value, validated, prefix) {
 	const { length } = values;
 	for (let index = 0; index < length; index += 1) {
 		const type = values[index];
-		const typeOfType = typeof type;
-		if (isSchematic(type) || typeOfType === "string" && TYPE_ALL.has(type)) {
+		if (isSchematic(type) || TYPE_ALL.has(type)) {
 			propertyTypes.push(type);
 			continue;
 		}
-		if (typeOfType === "function") {
+		if (typeof type === "function") {
 			propertyTypes.push(isConstructor(type) ? isInstance(type) : type);
 			continue;
 		}
-		if (typeOfType !== "object" || type === null) continue;
+		if (!isPlainObject(type)) throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace(TEMPLATE_PATTERN, prefix));
 		if (PROPERTY_TYPE in type) {
 			propertyTypes.push(...getTypes(type[PROPERTY_TYPE], validated, prefix));
 			continue;
 		}
-		addPropertyType(validated, prefix, [TYPE_OBJECT], type[PROPERTY_REQUIRED] !== false);
+		const { [PROPERTY_REQUIRED]: required, ...nested } = type;
+		if (PROPERTY_REQUIRED in type && typeof required !== "boolean") throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED.replace(TEMPLATE_PATTERN, prefix));
+		addPropertyType(validated, prefix, [TYPE_OBJECT], {}, required !== false);
 		propertyTypes.push(TYPE_OBJECT);
-		getValidatedSchema(type, validated, prefix);
+		getValidatedSchema(nested, validated, prefix);
 	}
 	return propertyTypes;
 }
@@ -186,18 +207,43 @@ function getValidatedSchema(schema, validated, prefix) {
 		if (EXPRESSION_PROPERTY.test(key)) continue;
 		if (EXPRESSION_HAS_NUMBER.test(key) && arrayKeys.has(key.replace(EXPRESSION_INDEX, ""))) continue;
 		let required = true;
-		if (typeof value === "object" && value !== null && PROPERTY_REQUIRED in value) required = typeof value[PROPERTY_REQUIRED] === "boolean" ? value[PROPERTY_REQUIRED] : true;
+		let validators = {};
+		const isObject = isPlainObject(value);
+		if (isObject && PROPERTY_REQUIRED in value) {
+			if (typeof value[PROPERTY_REQUIRED] !== "boolean") throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED.replace(TEMPLATE_PATTERN, key));
+			required = value[PROPERTY_REQUIRED] === true;
+		}
+		if (isObject && PROPERTY_VALIDATORS in value) validators = getValidators(value[PROPERTY_VALIDATORS]);
 		const prefixedKey = `${prefix}${key}`;
 		const types = getTypes(value, validated, prefixedKey);
-		if (types.length > 0) addPropertyType(validated, prefixedKey, types, required);
+		if (types.length === 0) throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace(TEMPLATE_PATTERN, key));
+		addPropertyType(validated, prefixedKey, types, validators, required);
 	}
 	if (noPrefix) validated.keys.array.sort();
+	if (noPrefix && validated.keys.array.length === 0) throw new SchematicError(MESSAGE_SCHEMA_INVALID_EMPTY);
 	return validated;
 }
-function validateType(type, value) {
+function getValidators(original) {
+	const validators = {};
+	if (original == null) return validators;
+	if (!isPlainObject(original)) throw new TypeError(MESSAGE_VALIDATOR_INVALID_TYPE);
+	const keys = Object.keys(original);
+	const { length } = keys;
+	for (let index = 0; index < length; index += 1) {
+		const key = keys[index];
+		if (!VALIDATABLE_TYPES.has(key)) throw new TypeError(MESSAGE_VALIDATOR_INVALID_KEY.replace(TEMPLATE_PATTERN, key));
+		const value = original[key];
+		validators[key] = (Array.isArray(value) ? value : [value]).filter((item) => {
+			if (typeof item !== "function") throw new TypeError(MESSAGE_VALIDATOR_INVALID_VALUE.replace(TEMPLATE_PATTERN, key));
+			return true;
+		});
+	}
+	return validators;
+}
+function validateType(type, property, value) {
 	switch (true) {
 		case typeof type === "function": return type(value);
-		case typeof type === "string": return validators[type](value);
+		case typeof type === "string": return validators[type](value) && (property.validators[type]?.every((validator) => validator(value)) ?? true);
 		default: return type.is(value);
 	}
 }
@@ -216,12 +262,12 @@ function validateValue(validated, obj) {
 		if (value === void 0 && property.required && !property.types.includes(TYPE_UNDEFINED)) return false;
 		const typesLength = property.types.length;
 		if (typesLength === 1) {
-			if (!validateType(property.types[0], value)) return false;
+			if (!validateType(property.types[0], property, value)) return false;
 			continue;
 		}
 		for (let typeIndex = 0; typeIndex < typesLength; typeIndex += 1) {
 			const type = property.types[typeIndex];
-			if (validateType(type, value)) {
+			if (validateType(type, property, value)) {
 				if (type !== "object") ignore.add(key);
 				continue outer;
 			}
@@ -249,22 +295,19 @@ const validators = {
 */
 var Schematic = class {
 	#schema;
-	get enabled() {
-		return this.#schema.enabled;
-	}
 	constructor(schema) {
 		Object.defineProperty(this, SCHEMATIC_NAME, { value: true });
-		this.#schema = getSchema(schema);
-		this.#schema.enabled = this.#schema.keys.array.length > 0;
+		this.#schema = schema;
 	}
 	/**
 	* Does the value match the schema?
 	*/
 	is(value) {
-		return this.#schema.enabled && validateValue(this.#schema, value);
+		return validateValue(this.#schema, value);
 	}
 };
 function schematic(schema) {
-	return new Schematic(schema);
+	if (!isPlainObject(schema)) throw new SchematicError(MESSAGE_SCHEMA_INVALID_TYPE);
+	return new Schematic(getSchema(schema));
 }
-export { isInstance, schematic };
+export { SchematicError, isInstance, schematic };

package/dist/models.js

@@ -0,0 +1,8 @@
+import { ERROR_NAME } from "./constants.js";
+var SchematicError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = ERROR_NAME;
+	}
+};
+export { SchematicError };

package/dist/schematic.js

@@ -1,27 +1,26 @@
-import { SCHEMATIC_NAME } from "./constants.js";
+import { MESSAGE_SCHEMA_INVALID_TYPE, SCHEMATIC_NAME } from "./constants.js";
+import { SchematicError } from "./models.js";
 import { getSchema } from "./validation/schema.validation.js";
 import { validateValue } from "./validation/value.validation.js";
+import { isPlainObject } from "@oscarpalmer/atoms/is";
 /**
 * A schematic for validating objects
 */
 var Schematic = class {
 	#schema;
-	get enabled() {
-		return this.#schema.enabled;
-	}
 	constructor(schema) {
 		Object.defineProperty(this, SCHEMATIC_NAME, { value: true });
-		this.#schema = getSchema(schema);
-		this.#schema.enabled = this.#schema.keys.array.length > 0;
+		this.#schema = schema;
 	}
 	/**
 	* Does the value match the schema?
 	*/
 	is(value) {
-		return this.#schema.enabled && validateValue(this.#schema, value);
+		return validateValue(this.#schema, value);
 	}
 };
 function schematic(schema) {
-	return new Schematic(schema);
+	if (!isPlainObject(schema)) throw new SchematicError(MESSAGE_SCHEMA_INVALID_TYPE);
+	return new Schematic(getSchema(schema));
 }
 export { Schematic, schematic };

package/dist/validation/schema.validation.js

@@ -1,31 +1,32 @@
-import { EXPRESSION_HAS_NUMBER, EXPRESSION_INDEX, EXPRESSION_PROPERTY, PROPERTY_REQUIRED, PROPERTY_TYPE, TYPE_ALL, TYPE_OBJECT, TYPE_UNDEFINED } from "../constants.js";
+import { EXPRESSION_HAS_NUMBER, EXPRESSION_INDEX, EXPRESSION_PROPERTY, MESSAGE_SCHEMA_INVALID_EMPTY, MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED, MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE, MESSAGE_VALIDATOR_INVALID_KEY, MESSAGE_VALIDATOR_INVALID_TYPE, MESSAGE_VALIDATOR_INVALID_VALUE, PROPERTY_REQUIRED, PROPERTY_TYPE, PROPERTY_VALIDATORS, TYPE_ALL, TYPE_OBJECT, TYPE_UNDEFINED, VALIDATABLE_TYPES } from "../constants.js";
 import { isInstance, isSchematic } from "../is.js";
-import { isConstructor } from "@oscarpalmer/atoms/is";
-import { smush } from "@oscarpalmer/atoms/value";
-function addPropertyType(to, key, values, required) {
+import { SchematicError } from "../models.js";
+import { isConstructor, isPlainObject } from "@oscarpalmer/atoms/is";
+import { smush } from "@oscarpalmer/atoms/value/misc";
+function addPropertyType(to, key, values, validators, required) {
 	if (to.keys.set.has(key)) {
 		const property = to.properties[key];
-		for (const type of values) if (!property.types.includes(type)) property.types.push(type);
+		for (const type of values) property.types.push(type);
 	} else {
 		to.keys.array.push(key);
 		to.keys.set.add(key);
 		to.properties[key] = {
 			required,
-			types: values
+			types: values,
+			validators: {}
 		};
 	}
 	if (!required && !to.properties[key].types.includes("undefined")) to.properties[key].types.push(TYPE_UNDEFINED);
+	to.properties[key].validators = validators;
 }
 function getSchema(schema) {
-	const validated = {
-		enabled: false,
+	return getValidatedSchema(schema, {
 		keys: {
 			array: [],
 			set: /* @__PURE__ */ new Set()
 		},
 		properties: {}
-	};
-	return typeof schema === "object" && schema !== null ? getValidatedSchema(schema, validated) : validated;
+	});
 }
 function getTypes(value, validated, prefix) {
 	const propertyTypes = [];
@@ -33,23 +34,24 @@ function getTypes(value, validated, prefix) {
 	const { length } = values;
 	for (let index = 0; index < length; index += 1) {
 		const type = values[index];
-		const typeOfType = typeof type;
-		if (isSchematic(type) || typeOfType === "string" && TYPE_ALL.has(type)) {
+		if (isSchematic(type) || TYPE_ALL.has(type)) {
 			propertyTypes.push(type);
 			continue;
 		}
-		if (typeOfType === "function") {
+		if (typeof type === "function") {
 			propertyTypes.push(isConstructor(type) ? isInstance(type) : type);
 			continue;
 		}
-		if (typeOfType !== "object" || type === null) continue;
+		if (!isPlainObject(type)) throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace("<>", prefix));
 		if ("$type" in type) {
 			propertyTypes.push(...getTypes(type[PROPERTY_TYPE], validated, prefix));
 			continue;
 		}
-		addPropertyType(validated, prefix, [TYPE_OBJECT], type[PROPERTY_REQUIRED] !== false);
+		const { [PROPERTY_REQUIRED]: required, ...nested } = type;
+		if ("$required" in type && typeof required !== "boolean") throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED.replace("<>", prefix));
+		addPropertyType(validated, prefix, [TYPE_OBJECT], {}, required !== false);
 		propertyTypes.push(TYPE_OBJECT);
-		getValidatedSchema(type, validated, prefix);
+		getValidatedSchema(nested, validated, prefix);
 	}
 	return propertyTypes;
 }
@@ -67,12 +69,37 @@ function getValidatedSchema(schema, validated, prefix) {
 		if (EXPRESSION_PROPERTY.test(key)) continue;
 		if (EXPRESSION_HAS_NUMBER.test(key) && arrayKeys.has(key.replace(EXPRESSION_INDEX, ""))) continue;
 		let required = true;
-		if (typeof value === "object" && value !== null && "$required" in value) required = typeof value["$required"] === "boolean" ? value[PROPERTY_REQUIRED] : true;
+		let validators = {};
+		const isObject = isPlainObject(value);
+		if (isObject && "$required" in value) {
+			if (typeof value["$required"] !== "boolean") throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED.replace("<>", key));
+			required = value[PROPERTY_REQUIRED] === true;
+		}
+		if (isObject && "$validators" in value) validators = getValidators(value[PROPERTY_VALIDATORS]);
 		const prefixedKey = `${prefix}${key}`;
 		const types = getTypes(value, validated, prefixedKey);
-		if (types.length > 0) addPropertyType(validated, prefixedKey, types, required);
+		if (types.length === 0) throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace("<>", key));
+		addPropertyType(validated, prefixedKey, types, validators, required);
 	}
 	if (noPrefix) validated.keys.array.sort();
+	if (noPrefix && validated.keys.array.length === 0) throw new SchematicError(MESSAGE_SCHEMA_INVALID_EMPTY);
 	return validated;
 }
+function getValidators(original) {
+	const validators = {};
+	if (original == null) return validators;
+	if (!isPlainObject(original)) throw new TypeError(MESSAGE_VALIDATOR_INVALID_TYPE);
+	const keys = Object.keys(original);
+	const { length } = keys;
+	for (let index = 0; index < length; index += 1) {
+		const key = keys[index];
+		if (!VALIDATABLE_TYPES.has(key)) throw new TypeError(MESSAGE_VALIDATOR_INVALID_KEY.replace("<>", key));
+		const value = original[key];
+		validators[key] = (Array.isArray(value) ? value : [value]).filter((item) => {
+			if (typeof item !== "function") throw new TypeError(MESSAGE_VALIDATOR_INVALID_VALUE.replace("<>", key));
+			return true;
+		});
+	}
+	return validators;
+}
 export { getSchema };

package/dist/validation/value.validation.js

@@ -1,9 +1,9 @@
 import "../constants.js";
-import { smush } from "@oscarpalmer/atoms/value";
-function validateType(type, value) {
+import { smush } from "@oscarpalmer/atoms/value/misc";
+function validateType(type, property, value) {
 	switch (true) {
 		case typeof type === "function": return type(value);
-		case typeof type === "string": return validators[type](value);
+		case typeof type === "string": return validators[type](value) && (property.validators[type]?.every((validator) => validator(value)) ?? true);
 		default: return type.is(value);
 	}
 }
@@ -22,12 +22,12 @@ function validateValue(validated, obj) {
 		if (value === void 0 && property.required && !property.types.includes("undefined")) return false;
 		const typesLength = property.types.length;
 		if (typesLength === 1) {
-			if (!validateType(property.types[0], value)) return false;
+			if (!validateType(property.types[0], property, value)) return false;
 			continue;
 		}
 		for (let typeIndex = 0; typeIndex < typesLength; typeIndex += 1) {
 			const type = property.types[typeIndex];
-			if (validateType(type, value)) {
+			if (validateType(type, property, value)) {
 				if (type !== "object") ignore.add(key);
 				continue outer;
 			}

package/package.json

@@ -4,15 +4,15 @@
 		"url": "https://oscarpalmer.se"
 	},
 	"dependencies": {
-		"@oscarpalmer/atoms": "^0.139"
+		"@oscarpalmer/atoms": "^0.141.2"
 	},
 	"description": "Flies free beneath the glistening moons…",
 	"devDependencies": {
 		"@types/node": "^25.3",
 		"@vitest/coverage-istanbul": "^4",
 		"jsdom": "^28.1",
-		"oxfmt": "^0.34",
-		"oxlint": "^1.49",
+		"oxfmt": "^0.35",
+		"oxlint": "^1.50",
 		"rolldown": "1.0.0-rc.5",
 		"tslib": "^2.8",
 		"typescript": "^5.9",
@@ -45,5 +45,5 @@
 	},
 	"type": "module",
 	"types": "./types/index.d.ts",
-	"version": "0.9.0"
+	"version": "0.11.0"
 }

package/src/constants.ts

@@ -1,31 +1,54 @@
-import type {Values} from './models';
+import type {ValueName} from './models';
+
+export const ERROR_NAME = 'SchematicError';
 
 export const EXPRESSION_HAS_NUMBER = /\d+/;
 
 export const EXPRESSION_INDEX = /\.\d+$/;
 
-export const EXPRESSION_PROPERTY = /\.\$(required|type)(\.|$)/;
+export const EXPRESSION_PROPERTY = /\.\$(required|type|validators)(\.|$)/;
+
+export const MESSAGE_CONSTRUCTOR = 'Expected a constructor function';
+
+export const MESSAGE_SCHEMA_INVALID_EMPTY = 'Schema must have at least one property';
+
+export const MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED = "'<>.$required' property must be a boolean";
+
+export const MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE = "'<>' property must be of a valid type";
+
+export const MESSAGE_SCHEMA_INVALID_TYPE = 'Schema must be an object';
+
+export const MESSAGE_VALIDATOR_INVALID_KEY = "Validator '<>' does not exist";
+
+export const MESSAGE_VALIDATOR_INVALID_TYPE = 'Validators must be an object';
+
+export const MESSAGE_VALIDATOR_INVALID_VALUE =
+	"Validator '<>' must be a function or an array of functions";
 
 export const PROPERTY_REQUIRED = '$required';
 
 export const PROPERTY_TYPE = '$type';
 
+export const PROPERTY_VALIDATORS = '$validators';
+
 export const SCHEMATIC_NAME = '$schematic';
 
+export const TEMPLATE_PATTERN = '<>';
+
 export const TYPE_OBJECT = 'object';
 
 export const TYPE_UNDEFINED = 'undefined';
 
-export const TYPE_ALL = new Set<keyof Values>([
+export const VALIDATABLE_TYPES = new Set<ValueName>([
 	'array',
 	'bigint',
 	'boolean',
 	'date',
 	'function',
-	'null',
 	'number',
 	'string',
 	'symbol',
 	TYPE_OBJECT,
-	TYPE_UNDEFINED,
 ]);
+
+export const TYPE_ALL = new Set<ValueName>([...VALIDATABLE_TYPES, 'null', TYPE_UNDEFINED]);

package/src/index.ts

@@ -1,3 +1,3 @@
 export {isInstance} from './is';
-export type {Schema, TypedSchema} from './models';
+export {SchematicError, type Schema, type TypedSchema} from './models';
 export {schematic, type Schematic} from './schematic';

package/src/is.ts

@@ -1,5 +1,5 @@
 import {isConstructor} from '@oscarpalmer/atoms/is';
-import {SCHEMATIC_NAME} from './constants';
+import {MESSAGE_CONSTRUCTOR, SCHEMATIC_NAME} from './constants';
 import type {Constructor} from './models';
 import type {Schematic} from './schematic';
 
@@ -7,7 +7,7 @@ export function isInstance<Instance>(
 	constructor: Constructor<Instance>,
 ): (value: unknown) => value is Instance {
 	if (!isConstructor(constructor)) {
-		throw new TypeError('Expected a constructor function');
+		throw new TypeError(MESSAGE_CONSTRUCTOR);
 	}
 
 	return (value: unknown): value is Instance => {

package/src/models.ts

@@ -1,4 +1,5 @@
 import type {PlainObject, Simplify} from '@oscarpalmer/atoms/models';
+import {ERROR_NAME} from './constants';
 import type {Schematic} from './schematic';
 
 export type Constructor<Instance = any> = new (...args: any[]) => Instance;
@@ -12,6 +13,14 @@ type DeduplicateTuple<Value extends unknown[], Seen extends unknown[] = []> = Va
 		: DeduplicateTuple<Tail, [...Seen, Head]>
 	: Seen;
 
+type ExtractValueNames<Value> = Value extends ValueName
+	? Value
+	: Value extends (infer Item)[]
+		? ExtractValueNames<Item>
+		: Value extends readonly (infer Item)[]
+			? ExtractValueNames<Item>
+			: never;
+
 /**
  * Infer the TypeScript type from a schema definition
  */
@@ -57,17 +66,23 @@ type InferSchemaEntryValue<Value> =
 			? Model
 			: Value extends SchemaProperty
 				? InferPropertyType<Value['$type']>
-				: Value extends ValueName
-					? Values[Value & ValueName]
-					: Value extends Schema
-						? Infer<Value>
-						: never;
+				: Value extends NestedSchema
+					? Infer<Omit<Value, '$required'>>
+					: Value extends ValueName
+						? Values[Value & ValueName]
+						: Value extends Schema
+							? Infer<Value>
+							: never;
 
 type IsOptionalProperty<Value> = Value extends SchemaProperty
 	? Value['$required'] extends false
 		? true
 		: false
-	: false;
+	: Value extends {$required?: boolean}
+		? Value extends {$required: false}
+			? true
+			: false
+		: false;
 
 type LastOfUnion<Value> =
 	UnionToIntersection<Value extends unknown ? () => Value : never> extends () => infer Item
@@ -87,12 +102,19 @@ type MapToSchemaPropertyTypes<Value extends unknown[]> = Value extends [infer He
  */
 export type NestedSchema = {
 	$required?: boolean;
-} & Schema;
+	[key: string]: any;
+};
 
 type OptionalKeys<Value> = {
 	[Key in keyof Value]-?: {} extends Pick<Value, Key> ? Key : never;
 }[keyof Value];
 
+type PropertyValidators<Value> = {
+	[Key in ExtractValueNames<Value>]?:
+		| ((value: Values[Key]) => boolean)
+		| Array<(value: Values[Key]) => boolean>;
+};
+
 type RequiredKeys<Value> = Exclude<keyof Value, OptionalKeys<Value>>;
 
 /**
@@ -100,7 +122,7 @@ type RequiredKeys<Value> = Exclude<keyof Value, OptionalKeys<Value>>;
  */
 export type Schema = SchemaIndex;
 
-type SchemaEntry = Constructor | NestedSchema | SchemaProperty | Schematic<unknown> | ValueName;
+type SchemaEntry = Constructor | SchemaProperty | Schematic<unknown> | ValueName | NestedSchema;
 
 interface SchemaIndex {
 	[key: string]: SchemaEntry | SchemaEntry[];
@@ -112,17 +134,28 @@ interface SchemaIndex {
 export type SchemaProperty = {
 	$required?: boolean;
 	$type: SchemaPropertyType | SchemaPropertyType[];
+	$validators?: PropertyValidators<SchemaPropertyType | SchemaPropertyType[]>;
 };
 
 type SchemaPropertyType = Constructor | Schema | Schematic<unknown> | ValueName;
 
+export class SchematicError extends Error {
+	constructor(message: string) {
+		super(message);
+
+		this.name = ERROR_NAME;
+	}
+}
+
 type ToSchemaPropertyType<Value> = UnwrapSingle<
 	DeduplicateTuple<MapToSchemaPropertyTypes<UnionToTuple<Value>>>
 >;
 
-type ToSchemaPropertyTypeEach<Value> = Value extends PlainObject
-	? TypedSchema<Value>
-	: ToValueType<Value>;
+type ToSchemaPropertyTypeEach<Value> = Value extends NestedSchema
+	? Omit<Value, '$required'>
+	: Value extends PlainObject
+		? TypedSchema<Value>
+		: ToValueType<Value>;
 
 type ToSchemaType<Value> = UnwrapSingle<DeduplicateTuple<MapToValueTypes<UnionToTuple<Value>>>>;
 
@@ -134,21 +167,23 @@ type ToValueType<Value> = Value extends unknown[]
 			? 'boolean'
 			: Value extends Date
 				? 'date'
-				: Value extends Function
-					? 'function'
-					: Value extends null
-						? 'null'
-						: Value extends number
-							? 'number'
-							: Value extends object
-								? 'object' | ((value: unknown) => value is Value)
-								: Value extends string
-									? 'string'
-									: Value extends symbol
-										? 'symbol'
-										: Value extends undefined
-											? 'undefined'
-											: (value: unknown) => value is Value;
+				: Value extends Schematic<any>
+					? Value
+					: Value extends Function
+						? 'function'
+						: Value extends null
+							? 'null'
+							: Value extends number
+								? 'number'
+								: Value extends object
+									? 'object' | ((value: unknown) => value is Value)
+									: Value extends string
+										? 'string'
+										: Value extends symbol
+											? 'symbol'
+											: Value extends undefined
+												? 'undefined'
+												: (value: unknown) => value is Value;
 
 type TuplePermutations<
 	Tuple extends unknown[],
@@ -173,13 +208,33 @@ type TupleRemoveAt<
 	: Prefix;
 
 export type TypedPropertyOptional<Value> = {
+	/**
+	 * The property is not required
+	 */
 	$required: false;
+	/**
+	 * The type(s) of the property
+	 */
 	$type: ToSchemaPropertyType<Exclude<Value, undefined>>;
+	/**
+	 * Custom validators for the property and its types
+	 */
+	$validators?: PropertyValidators<ToSchemaPropertyType<Exclude<Value, undefined>>>;
 };
 
 export type TypedPropertyRequired<Value> = {
+	/**
+	 * The property is required _(defaults to `true`)_
+	 */
 	$required?: true;
+	/**
+	 * The type(s) of the property
+	 */
 	$type: ToSchemaPropertyType<Value>;
+	/**
+	 * Custom validators for the property and its types
+	 */
+	$validators?: PropertyValidators<ToSchemaPropertyType<Value>>;
 };
 
 /**
@@ -188,11 +243,13 @@ export type TypedPropertyRequired<Value> = {
 export type TypedSchema<Model extends PlainObject> = Simplify<
 	{
 		[Key in RequiredKeys<Model>]: Model[Key] extends PlainObject
-			? TypedSchemaRequired<Model[Key]>
+			? TypedSchemaRequired<Model[Key]> | Schematic<Model[Key]>
 			: ToSchemaType<Model[Key]> | TypedPropertyRequired<Model[Key]>;
 	} & {
 		[Key in OptionalKeys<Model>]: Exclude<Model[Key], undefined> extends PlainObject
-			? TypedSchemaOptional<Exclude<Model[Key], undefined>>
+			?
+					| TypedSchemaOptional<Exclude<Model[Key], undefined>>
+					| Schematic<Exclude<Model[Key], undefined>>
 			: TypedPropertyOptional<Model[Key]>;
 	}
 >;
@@ -224,12 +281,16 @@ type UnwrapSingle<Value extends unknown[]> = Value extends [infer Only]
 export type ValidatedProperty = {
 	required: boolean;
 	types: ValidatedPropertyType[];
+	validators: ValidatedPropertyValidators;
 };
 
 export type ValidatedPropertyType = Schematic<unknown> | ValueName;
 
+export type ValidatedPropertyValidators = {
+	[Key in ValueName]?: Array<(value: unknown) => boolean>;
+};
+
 export type ValidatedSchema = {
-	enabled: boolean;
 	keys: {
 		array: string[];
 		set: Set<string>;

package/src/schematic.ts

@@ -1,6 +1,13 @@
+import {isPlainObject} from '@oscarpalmer/atoms/is';
 import type {PlainObject} from '@oscarpalmer/atoms/models';
-import {SCHEMATIC_NAME} from './constants';
-import type {Infer, Schema, TypedSchema, ValidatedSchema} from './models';
+import {MESSAGE_SCHEMA_INVALID_TYPE, SCHEMATIC_NAME} from './constants';
+import {
+	SchematicError,
+	type Infer,
+	type Schema,
+	type TypedSchema,
+	type ValidatedSchema,
+} from './models';
 import {getSchema} from './validation/schema.validation';
 import {validateValue} from './validation/value.validation';
 
@@ -12,25 +19,19 @@ export class Schematic<Model> {
 
 	#schema: ValidatedSchema;
 
-	get enabled(): boolean {
-		return this.#schema.enabled;
-	}
-
-	constructor(schema: Model) {
+	constructor(schema: ValidatedSchema) {
 		Object.defineProperty(this, SCHEMATIC_NAME, {
 			value: true,
 		});
 
-		this.#schema = getSchema(schema);
-
-		this.#schema.enabled = this.#schema.keys.array.length > 0;
+		this.#schema = schema;
 	}
 
 	/**
 	 * Does the value match the schema?
 	 */
 	is(value: unknown): value is Model {
-		return this.#schema.enabled && validateValue(this.#schema, value);
+		return validateValue(this.#schema, value);
 	}
 }
 
@@ -45,5 +46,11 @@ export function schematic<Model extends Schema>(schema: Model): Schematic<Infer<
 export function schematic<Model extends PlainObject>(schema: TypedSchema<Model>): Schematic<Model>;
 
 export function schematic<Model extends Schema>(schema: Model): Schematic<Model> {
-	return new Schematic<Model>(schema);
+	if (!isPlainObject(schema)) {
+		throw new SchematicError(MESSAGE_SCHEMA_INVALID_TYPE);
+	}
+
+	const validated = getSchema(schema);
+
+	return new Schematic<Model>(validated);
 }

package/src/validation/schema.validation.ts

@@ -1,32 +1,47 @@
-import {isConstructor} from '@oscarpalmer/atoms/is';
+import {isConstructor, isPlainObject} from '@oscarpalmer/atoms/is';
 import type {PlainObject} from '@oscarpalmer/atoms/models';
-import {smush} from '@oscarpalmer/atoms/value';
+import {smush} from '@oscarpalmer/atoms/value/misc';
 import {
 	EXPRESSION_HAS_NUMBER,
 	EXPRESSION_INDEX,
 	EXPRESSION_PROPERTY,
+	MESSAGE_SCHEMA_INVALID_EMPTY,
+	MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED,
+	MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE,
+	MESSAGE_VALIDATOR_INVALID_KEY,
+	MESSAGE_VALIDATOR_INVALID_TYPE,
+	MESSAGE_VALIDATOR_INVALID_VALUE,
 	PROPERTY_REQUIRED,
 	PROPERTY_TYPE,
+	PROPERTY_VALIDATORS,
+	TEMPLATE_PATTERN,
 	TYPE_ALL,
 	TYPE_OBJECT,
 	TYPE_UNDEFINED,
+	VALIDATABLE_TYPES,
 } from '../constants';
 import {isInstance, isSchematic} from '../is';
-import type {Schema, ValidatedPropertyType, ValidatedSchema} from '../models';
+import {
+	SchematicError,
+	type Schema,
+	type ValidatedPropertyType,
+	type ValidatedPropertyValidators,
+	type ValidatedSchema,
+	type ValueName,
+} from '../models';
 
 function addPropertyType(
 	to: ValidatedSchema,
 	key: string,
 	values: ValidatedPropertyType[],
+	validators: ValidatedPropertyValidators,
 	required: boolean,
 ): void {
 	if (to.keys.set.has(key)) {
 		const property = to.properties[key];
 
 		for (const type of values) {
-			if (!property.types.includes(type)) {
-				property.types.push(type);
-			}
+			property.types.push(type);
 		}
 	} else {
 		to.keys.array.push(key);
@@ -35,27 +50,25 @@ function addPropertyType(
 		to.properties[key] = {
 			required,
 			types: values,
+			validators: {},
 		};
 	}
 
 	if (!required && !to.properties[key].types.includes(TYPE_UNDEFINED)) {
 		to.properties[key].types.push(TYPE_UNDEFINED);
 	}
+
+	to.properties[key].validators = validators;
 }
 
-export function getSchema(schema: unknown): ValidatedSchema {
-	const validated: ValidatedSchema = {
-		enabled: false,
+export function getSchema(schema: Schema): ValidatedSchema {
+	return getValidatedSchema(schema, {
 		keys: {
 			array: [],
 			set: new Set<string>(),
 		},
 		properties: {},
-	};
-
-	return typeof schema === 'object' && schema !== null
-		? getValidatedSchema(schema as Schema, validated)
-		: validated;
+	});
 }
 
 function getTypes(
@@ -70,22 +83,23 @@ function getTypes(
 
 	for (let index = 0; index < length; index += 1) {
 		const type = values[index];
-		const typeOfType = typeof type;
 
-		if (isSchematic(type) || (typeOfType === 'string' && TYPE_ALL.has(type as never))) {
-			propertyTypes.push(type as never);
+		if (isSchematic(type) || TYPE_ALL.has(type as never)) {
+			propertyTypes.push(type);
 
 			continue;
 		}
 
-		if (typeOfType === 'function') {
+		if (typeof type === 'function') {
 			propertyTypes.push(isConstructor(type) ? isInstance(type) : type);
 
 			continue;
 		}
 
-		if (typeOfType !== 'object' || type === null) {
-			continue;
+		if (!isPlainObject(type)) {
+			throw new SchematicError(
+				MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace(TEMPLATE_PATTERN, prefix),
+			);
 		}
 
 		if (PROPERTY_TYPE in type) {
@@ -94,11 +108,19 @@ function getTypes(
 			continue;
 		}
 
-		addPropertyType(validated, prefix, [TYPE_OBJECT], type[PROPERTY_REQUIRED] !== false);
+		const {[PROPERTY_REQUIRED]: required, ...nested} = type;
+
+		if (PROPERTY_REQUIRED in type && typeof required !== 'boolean') {
+			throw new SchematicError(
+				MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED.replace(TEMPLATE_PATTERN, prefix),
+			);
+		}
+
+		addPropertyType(validated, prefix, [TYPE_OBJECT], {}, required !== false);
 
 		propertyTypes.push(TYPE_OBJECT);
 
-		getValidatedSchema(type as Schema, validated, prefix);
+		getValidatedSchema(nested as Schema, validated, prefix);
 	}
 
 	return propertyTypes;
@@ -135,23 +157,77 @@ function getValidatedSchema(
 		}
 
 		let required = true;
+		let validators: ValidatedPropertyValidators = {};
+
+		const isObject = isPlainObject(value);
 
-		if (typeof value === 'object' && value !== null && PROPERTY_REQUIRED in value) {
-			required = typeof value[PROPERTY_REQUIRED] === 'boolean' ? value[PROPERTY_REQUIRED] : true;
+		if (isObject && PROPERTY_REQUIRED in value) {
+			if (typeof value[PROPERTY_REQUIRED] !== 'boolean') {
+				throw new SchematicError(
+					MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED.replace(TEMPLATE_PATTERN, key),
+				);
+			}
+
+			required = value[PROPERTY_REQUIRED] === true;
+		}
+
+		if (isObject && PROPERTY_VALIDATORS in value) {
+			validators = getValidators(value[PROPERTY_VALIDATORS]);
 		}
 
 		const prefixedKey = `${prefix}${key}`;
 
 		const types = getTypes(value, validated, prefixedKey);
 
-		if (types.length > 0) {
-			addPropertyType(validated, prefixedKey, types, required);
+		if (types.length === 0) {
+			throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace(TEMPLATE_PATTERN, key));
 		}
+
+		addPropertyType(validated, prefixedKey, types, validators, required);
 	}
 
 	if (noPrefix) {
 		validated.keys.array.sort();
 	}
 
+	if (noPrefix && validated.keys.array.length === 0) {
+		throw new SchematicError(MESSAGE_SCHEMA_INVALID_EMPTY);
+	}
+
 	return validated;
 }
+
+function getValidators(original: unknown): ValidatedPropertyValidators {
+	const validators: ValidatedPropertyValidators = {};
+
+	if (original == null) {
+		return validators;
+	}
+
+	if (!isPlainObject(original)) {
+		throw new TypeError(MESSAGE_VALIDATOR_INVALID_TYPE);
+	}
+
+	const keys = Object.keys(original);
+	const {length} = keys;
+
+	for (let index = 0; index < length; index += 1) {
+		const key = keys[index];
+
+		if (!VALIDATABLE_TYPES.has(key as never)) {
+			throw new TypeError(MESSAGE_VALIDATOR_INVALID_KEY.replace(TEMPLATE_PATTERN, key));
+		}
+
+		const value = (original as PlainObject)[key];
+
+		validators[key as ValueName] = (Array.isArray(value) ? value : [value]).filter(item => {
+			if (typeof item !== 'function') {
+				throw new TypeError(MESSAGE_VALIDATOR_INVALID_VALUE.replace(TEMPLATE_PATTERN, key));
+			}
+
+			return true;
+		});
+	}
+
+	return validators;
+}

package/src/validation/value.validation.ts

@@ -1,15 +1,22 @@
 import type {PlainObject} from '@oscarpalmer/atoms/models';
-import {smush} from '@oscarpalmer/atoms/value';
+import {smush} from '@oscarpalmer/atoms/value/misc';
 import {TYPE_UNDEFINED} from '../constants';
-import type {ValidatedPropertyType, ValidatedSchema, Values} from '../models';
+import type {ValidatedProperty, ValidatedPropertyType, ValidatedSchema, Values} from '../models';
 
-export function validateType(type: ValidatedPropertyType, value: unknown): boolean {
+export function validateType(
+	type: ValidatedPropertyType,
+	property: ValidatedProperty,
+	value: unknown,
+): boolean {
 	switch (true) {
 		case typeof type === 'function':
 			return (type as any)(value);
 
 		case typeof type === 'string':
-			return validators[type](value);
+			return (
+				validators[type](value) &&
+				(property.validators[type]?.every(validator => validator(value)) ?? true)
+			);
 
 		default:
 			return type.is(value);
@@ -47,7 +54,7 @@ export function validateValue(validated: ValidatedSchema, obj: unknown): boolean
 		const typesLength = property.types.length;
 
 		if (typesLength === 1) {
-			if (!validateType(property.types[0], value)) {
+			if (!validateType(property.types[0], property, value)) {
 				return false;
 			}
 
@@ -57,7 +64,7 @@ export function validateValue(validated: ValidatedSchema, obj: unknown): boolean
 		for (let typeIndex = 0; typeIndex < typesLength; typeIndex += 1) {
 			const type = property.types[typeIndex];
 
-			if (validateType(type, value)) {
+			if (validateType(type, property, value)) {
 				if ((type as never) !== 'object') {
 					ignore.add(key);
 				}

package/types/constants.d.ts

@@ -1,10 +1,21 @@
-import type { Values } from './models';
+export declare const ERROR_NAME = "SchematicError";
 export declare const EXPRESSION_HAS_NUMBER: RegExp;
 export declare const EXPRESSION_INDEX: RegExp;
 export declare const EXPRESSION_PROPERTY: RegExp;
+export declare const MESSAGE_CONSTRUCTOR = "Expected a constructor function";
+export declare const MESSAGE_SCHEMA_INVALID_EMPTY = "Schema must have at least one property";
+export declare const MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED = "'<>.$required' property must be a boolean";
+export declare const MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE = "'<>' property must be of a valid type";
+export declare const MESSAGE_SCHEMA_INVALID_TYPE = "Schema must be an object";
+export declare const MESSAGE_VALIDATOR_INVALID_KEY = "Validator '<>' does not exist";
+export declare const MESSAGE_VALIDATOR_INVALID_TYPE = "Validators must be an object";
+export declare const MESSAGE_VALIDATOR_INVALID_VALUE = "Validator '<>' must be a function or an array of functions";
 export declare const PROPERTY_REQUIRED = "$required";
 export declare const PROPERTY_TYPE = "$type";
+export declare const PROPERTY_VALIDATORS = "$validators";
 export declare const SCHEMATIC_NAME = "$schematic";
+export declare const TEMPLATE_PATTERN = "<>";
 export declare const TYPE_OBJECT = "object";
 export declare const TYPE_UNDEFINED = "undefined";
-export declare const TYPE_ALL: Set<keyof Values>;
+export declare const VALIDATABLE_TYPES: Set<keyof import("./models").Values>;
+export declare const TYPE_ALL: Set<keyof import("./models").Values>;

package/types/index.d.ts

@@ -1,3 +1,3 @@
 export { isInstance } from './is';
-export type { Schema, TypedSchema } from './models';
+export { SchematicError, type Schema, type TypedSchema } from './models';
 export { schematic, type Schematic } from './schematic';

package/types/models.d.ts

@@ -5,6 +5,7 @@ type DeduplicateTuple<Value extends unknown[], Seen extends unknown[] = []> = Va
     infer Head,
     ...infer Tail
 ] ? Head extends Seen[number] ? DeduplicateTuple<Tail, Seen> : DeduplicateTuple<Tail, [...Seen, Head]> : Seen;
+type ExtractValueNames<Value> = Value extends ValueName ? Value : Value extends (infer Item)[] ? ExtractValueNames<Item> : Value extends readonly (infer Item)[] ? ExtractValueNames<Item> : never;
 /**
  * Infer the TypeScript type from a schema definition
  */
@@ -22,8 +23,12 @@ type InferRequiredKeys<Model extends Schema> = keyof {
     [Key in keyof Model as IsOptionalProperty<Model[Key]> extends true ? never : Key]: never;
 };
 type InferSchemaEntry<Value> = Value extends (infer Item)[] ? InferSchemaEntryValue<Item> : InferSchemaEntryValue<Value>;
-type InferSchemaEntryValue<Value> = Value extends Constructor<infer Instance> ? Instance : Value extends Schematic<infer Model> ? Model : Value extends SchemaProperty ? InferPropertyType<Value['$type']> : Value extends ValueName ? Values[Value & ValueName] : Value extends Schema ? Infer<Value> : never;
-type IsOptionalProperty<Value> = Value extends SchemaProperty ? Value['$required'] extends false ? true : false : false;
+type InferSchemaEntryValue<Value> = Value extends Constructor<infer Instance> ? Instance : Value extends Schematic<infer Model> ? Model : Value extends SchemaProperty ? InferPropertyType<Value['$type']> : Value extends NestedSchema ? Infer<Omit<Value, '$required'>> : Value extends ValueName ? Values[Value & ValueName] : Value extends Schema ? Infer<Value> : never;
+type IsOptionalProperty<Value> = Value extends SchemaProperty ? Value['$required'] extends false ? true : false : Value extends {
+    $required?: boolean;
+} ? Value extends {
+    $required: false;
+} ? true : false : false;
 type LastOfUnion<Value> = UnionToIntersection<Value extends unknown ? () => Value : never> extends () => infer Item ? Item : never;
 type MapToValueTypes<Value extends unknown[]> = Value extends [infer Head, ...infer Tail] ? [ToValueType<Head>, ...MapToValueTypes<Tail>] : [];
 type MapToSchemaPropertyTypes<Value extends unknown[]> = Value extends [infer Head, ...infer Tail] ? [ToSchemaPropertyTypeEach<Head>, ...MapToSchemaPropertyTypes<Tail>] : [];
@@ -32,16 +37,20 @@ type MapToSchemaPropertyTypes<Value extends unknown[]> = Value extends [infer He
  */
 export type NestedSchema = {
     $required?: boolean;
-} & Schema;
+    [key: string]: any;
+};
 type OptionalKeys<Value> = {
     [Key in keyof Value]-?: {} extends Pick<Value, Key> ? Key : never;
 }[keyof Value];
+type PropertyValidators<Value> = {
+    [Key in ExtractValueNames<Value>]?: ((value: Values[Key]) => boolean) | Array<(value: Values[Key]) => boolean>;
+};
 type RequiredKeys<Value> = Exclude<keyof Value, OptionalKeys<Value>>;
 /**
  * A schema for validating objects
  */
 export type Schema = SchemaIndex;
-type SchemaEntry = Constructor | NestedSchema | SchemaProperty | Schematic<unknown> | ValueName;
+type SchemaEntry = Constructor | SchemaProperty | Schematic<unknown> | ValueName | NestedSchema;
 interface SchemaIndex {
     [key: string]: SchemaEntry | SchemaEntry[];
 }
@@ -51,12 +60,16 @@ interface SchemaIndex {
 export type SchemaProperty = {
     $required?: boolean;
     $type: SchemaPropertyType | SchemaPropertyType[];
+    $validators?: PropertyValidators<SchemaPropertyType | SchemaPropertyType[]>;
 };
 type SchemaPropertyType = Constructor | Schema | Schematic<unknown> | ValueName;
+export declare class SchematicError extends Error {
+    constructor(message: string);
+}
 type ToSchemaPropertyType<Value> = UnwrapSingle<DeduplicateTuple<MapToSchemaPropertyTypes<UnionToTuple<Value>>>>;
-type ToSchemaPropertyTypeEach<Value> = Value extends PlainObject ? TypedSchema<Value> : ToValueType<Value>;
+type ToSchemaPropertyTypeEach<Value> = Value extends NestedSchema ? Omit<Value, '$required'> : Value extends PlainObject ? TypedSchema<Value> : ToValueType<Value>;
 type ToSchemaType<Value> = UnwrapSingle<DeduplicateTuple<MapToValueTypes<UnionToTuple<Value>>>>;
-type ToValueType<Value> = Value extends unknown[] ? 'array' : Value extends bigint ? 'bigint' : Value extends boolean ? 'boolean' : Value extends Date ? 'date' : Value extends Function ? 'function' : Value extends null ? 'null' : Value extends number ? 'number' : Value extends object ? 'object' | ((value: unknown) => value is Value) : Value extends string ? 'string' : Value extends symbol ? 'symbol' : Value extends undefined ? 'undefined' : (value: unknown) => value is Value;
+type ToValueType<Value> = Value extends unknown[] ? 'array' : Value extends bigint ? 'bigint' : Value extends boolean ? 'boolean' : Value extends Date ? 'date' : Value extends Schematic<any> ? Value : Value extends Function ? 'function' : Value extends null ? 'null' : Value extends number ? 'number' : Value extends object ? 'object' | ((value: unknown) => value is Value) : Value extends string ? 'string' : Value extends symbol ? 'symbol' : Value extends undefined ? 'undefined' : (value: unknown) => value is Value;
 type TuplePermutations<Tuple extends unknown[], Elput extends unknown[] = []> = Tuple['length'] extends 0 ? Elput : {
     [Key in keyof Tuple]: TuplePermutations<TupleRemoveAt<Tuple, Key & `${number}`>, [
         ...Elput,
@@ -65,20 +78,40 @@ type TuplePermutations<Tuple extends unknown[], Elput extends unknown[] = []> =
 }[keyof Tuple & `${number}`];
 type TupleRemoveAt<Items extends unknown[], Item extends string, Prefix extends unknown[] = []> = Items extends [infer Head, ...infer Tail] ? `${Prefix['length']}` extends Item ? [...Prefix, ...Tail] : TupleRemoveAt<Tail, Item, [...Prefix, Head]> : Prefix;
 export type TypedPropertyOptional<Value> = {
+    /**
+     * The property is not required
+     */
     $required: false;
+    /**
+     * The type(s) of the property
+     */
     $type: ToSchemaPropertyType<Exclude<Value, undefined>>;
+    /**
+     * Custom validators for the property and its types
+     */
+    $validators?: PropertyValidators<ToSchemaPropertyType<Exclude<Value, undefined>>>;
 };
 export type TypedPropertyRequired<Value> = {
+    /**
+     * The property is required _(defaults to `true`)_
+     */
     $required?: true;
+    /**
+     * The type(s) of the property
+     */
     $type: ToSchemaPropertyType<Value>;
+    /**
+     * Custom validators for the property and its types
+     */
+    $validators?: PropertyValidators<ToSchemaPropertyType<Value>>;
 };
 /**
  * Create a schema type constrained to match a TypeScript type
  */
 export type TypedSchema<Model extends PlainObject> = Simplify<{
-    [Key in RequiredKeys<Model>]: Model[Key] extends PlainObject ? TypedSchemaRequired<Model[Key]> : ToSchemaType<Model[Key]> | TypedPropertyRequired<Model[Key]>;
+    [Key in RequiredKeys<Model>]: Model[Key] extends PlainObject ? TypedSchemaRequired<Model[Key]> | Schematic<Model[Key]> : ToSchemaType<Model[Key]> | TypedPropertyRequired<Model[Key]>;
 } & {
-    [Key in OptionalKeys<Model>]: Exclude<Model[Key], undefined> extends PlainObject ? TypedSchemaOptional<Exclude<Model[Key], undefined>> : TypedPropertyOptional<Model[Key]>;
+    [Key in OptionalKeys<Model>]: Exclude<Model[Key], undefined> extends PlainObject ? TypedSchemaOptional<Exclude<Model[Key], undefined>> | Schematic<Exclude<Model[Key], undefined>> : TypedPropertyOptional<Model[Key]>;
 }>;
 type TypedSchemaOptional<Model extends PlainObject> = {
     $required: false;
@@ -92,10 +125,13 @@ type UnwrapSingle<Value extends unknown[]> = Value extends [infer Only] ? Only :
 export type ValidatedProperty = {
     required: boolean;
     types: ValidatedPropertyType[];
+    validators: ValidatedPropertyValidators;
 };
 export type ValidatedPropertyType = Schematic<unknown> | ValueName;
+export type ValidatedPropertyValidators = {
+    [Key in ValueName]?: Array<(value: unknown) => boolean>;
+};
 export type ValidatedSchema = {
-    enabled: boolean;
     keys: {
         array: string[];
         set: Set<string>;

package/types/schematic.d.ts

@@ -1,13 +1,12 @@
 import type { PlainObject } from '@oscarpalmer/atoms/models';
-import type { Infer, Schema, TypedSchema } from './models';
+import { type Infer, type Schema, type TypedSchema, type ValidatedSchema } from './models';
 /**
  * A schematic for validating objects
  */
 export declare class Schematic<Model> {
     #private;
     private readonly $schematic;
-    get enabled(): boolean;
-    constructor(schema: Model);
+    constructor(schema: ValidatedSchema);
     /**
      * Does the value match the schema?
      */

package/types/validation/schema.validation.d.ts

@@ -1,2 +1,2 @@
-import type { ValidatedSchema } from '../models';
-export declare function getSchema(schema: unknown): ValidatedSchema;
+import { type Schema, type ValidatedSchema } from '../models';
+export declare function getSchema(schema: Schema): ValidatedSchema;

package/types/validation/value.validation.d.ts

@@ -1,3 +1,3 @@
-import type { ValidatedPropertyType, ValidatedSchema } from '../models';
-export declare function validateType(type: ValidatedPropertyType, value: unknown): boolean;
+import type { ValidatedProperty, ValidatedPropertyType, ValidatedSchema } from '../models';
+export declare function validateType(type: ValidatedPropertyType, property: ValidatedProperty, value: unknown): boolean;
 export declare function validateValue(validated: ValidatedSchema, obj: unknown): boolean;