@oscarpalmer/jhunal 0.15.0 → 0.16.0

package/dist/{jhunal.full.js → index.mjs}

@@ -1,55 +1,6 @@
-/**
-* Is the value a constructor function?
-* @param value Value to check
-* @returns `true` if the value is a constructor function, otherwise `false`
-*/
-function isConstructor(value) {
-	return typeof value === "function" && value.prototype?.constructor === value;
-}
-/**
-* Is the value a plain object?
-* @param value Value to check
-* @returns `true` if the value is a plain object, otherwise `false`
-*/
-function isPlainObject(value) {
-	if (value === null || typeof value !== "object") return false;
-	if (Symbol.toStringTag in value || Symbol.iterator in value) return false;
-	const prototype = Object.getPrototypeOf(value);
-	return prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null;
-}
-function compact(array, strict) {
-	if (!Array.isArray(array)) return [];
-	if (strict === true) return array.filter(Boolean);
-	const { length } = array;
-	const compacted = [];
-	for (let index = 0; index < length; index += 1) {
-		const item = array[index];
-		if (item != null) compacted.push(item);
-	}
-	return compacted;
-}
-/**
-* Get the string value from any value
-* @param value Original value
-* @returns String representation of the value
-*/
-function getString(value) {
-	if (typeof value === "string") return value;
-	if (value == null) return "";
-	if (typeof value === "function") return getString(value());
-	if (typeof value !== "object") return String(value);
-	const asString = String(value.valueOf?.() ?? value);
-	return asString.startsWith("[object ") ? JSON.stringify(value) : asString;
-}
-/**
-* Join an array of values into a string
-* @param value Array of values
-* @param delimiter Delimiter to use between values
-* @returns Joined string
-*/
-function join(value, delimiter) {
-	return compact(value).map(getString).join(typeof delimiter === "string" ? delimiter : "");
-}
+import { isConstructor, isPlainObject } from "@oscarpalmer/atoms/is";
+import { join } from "@oscarpalmer/atoms/string";
+//#region src/constants.ts
 const ERROR_NAME = "SchematicError";
 const EXPRESSION_PROPERTY = /(^|\.)\$(required|type|validators)(\.|$)/;
 const MESSAGE_CONSTRUCTOR = "Expected a constructor function";
@@ -65,7 +16,6 @@ const PROPERTY_REQUIRED = "$required";
 const PROPERTY_TYPE = "$type";
 const PROPERTY_VALIDATORS = "$validators";
 const SCHEMATIC_NAME = "$schematic";
-const TEMPLATE_PATTERN = "<>";
 const TEMPLATE_PATTERN_KEY = "<key>";
 const TEMPLATE_PATTERN_PROPERTY = "<property>";
 const TYPE_OBJECT = "object";
@@ -86,6 +36,8 @@ const TYPE_ALL = new Set([
 	"null",
 	TYPE_UNDEFINED
 ]);
+//#endregion
+//#region src/helpers.ts
 /**
 * Creates a validator function for a given constructor
 * @param constructor - Constructor to check against
@@ -104,8 +56,10 @@ function instanceOf(constructor) {
 * @returns `true` if the value is a schematic, `false` otherwise
 */
 function isSchematic(value) {
-	return typeof value === "object" && value !== null && SCHEMATIC_NAME in value && value[SCHEMATIC_NAME] === true;
+	return typeof value === "object" && value !== null && "$schematic" in value && value["$schematic"] === true;
 }
+//#endregion
+//#region src/models.ts
 /**
 * A custom error class for schema validation failures, with its `name` set to {@link ERROR_NAME}
 *
@@ -120,10 +74,12 @@ var SchematicError = class extends Error {
 		this.name = ERROR_NAME;
 	}
 };
+//#endregion
+//#region src/validation/property.validation.ts
 function getDisallowedProperty(obj) {
-	if (PROPERTY_REQUIRED in obj) return PROPERTY_REQUIRED;
-	if (PROPERTY_TYPE in obj) return PROPERTY_TYPE;
-	if (PROPERTY_VALIDATORS in obj) return PROPERTY_VALIDATORS;
+	if ("$required" in obj) return PROPERTY_REQUIRED;
+	if ("$type" in obj) return PROPERTY_TYPE;
+	if ("$validators" in obj) return PROPERTY_VALIDATORS;
 }
 function getProperties(original, prefix, fromType) {
 	if (Object.keys(original).length === 0) throw new SchematicError(MESSAGE_SCHEMA_INVALID_EMPTY);
@@ -144,22 +100,22 @@ function getProperties(original, prefix, fromType) {
 		if (isPlainObject(value)) {
 			required = getRequired(key, value) ?? required;
 			validators = getValidators(value[PROPERTY_VALIDATORS]);
-			if (PROPERTY_TYPE in value) types.push(TYPE_OBJECT, ...getTypes(key, value[PROPERTY_TYPE], prefix, true));
+			if ("$type" in value) types.push(TYPE_OBJECT, ...getTypes(key, value[PROPERTY_TYPE], prefix, true));
 			else types.push(TYPE_OBJECT, ...getTypes(key, value, prefix));
 		} else types.push(...getTypes(key, value, prefix));
-		if (!required && !types.includes(TYPE_UNDEFINED)) types.push(TYPE_UNDEFINED);
+		if (!required && !types.includes("undefined")) types.push(TYPE_UNDEFINED);
 		properties.push({
 			key,
 			types,
 			validators,
-			required: required && !types.includes(TYPE_UNDEFINED)
+			required: required && !types.includes("undefined")
 		});
 	}
 	return properties;
 }
 function getRequired(key, obj) {
-	if (!(PROPERTY_REQUIRED in obj)) return;
-	if (typeof obj[PROPERTY_REQUIRED] !== "boolean") throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED.replace(TEMPLATE_PATTERN, key));
+	if (!("$required" in obj)) return;
+	if (typeof obj["$required"] !== "boolean") throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED.replace("<>", key));
 	return obj[PROPERTY_REQUIRED];
 }
 function getTypes(key, original, prefix, fromType) {
@@ -181,10 +137,10 @@ function getTypes(key, original, prefix, fromType) {
 			case TYPE_ALL.has(value):
 				types.push(value);
 				break;
-			default: throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace(TEMPLATE_PATTERN, join([prefix, key], ".")));
+			default: throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace("<>", join([prefix, key], ".")));
 		}
 	}
-	if (types.length === 0) throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace(TEMPLATE_PATTERN, join([prefix, key], ".")));
+	if (types.length === 0) throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace("<>", join([prefix, key], ".")));
 	return types;
 }
 function getValidators(original) {
@@ -195,15 +151,17 @@ function getValidators(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));
+		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(TEMPLATE_PATTERN, key));
+			if (typeof item !== "function") throw new TypeError(MESSAGE_VALIDATOR_INVALID_VALUE.replace("<>", key));
 			return true;
 		});
 	}
 	return validators;
 }
+//#endregion
+//#region src/validation/value.validation.ts
 function validateObject(obj, properties) {
 	if (!isPlainObject(obj)) return false;
 	const propertiesLength = properties.length;
@@ -242,6 +200,8 @@ const validators = {
 	symbol: (value) => typeof value === "symbol",
 	undefined: (value) => value === void 0
 };
+//#endregion
+//#region src/schematic.ts
 /**
 * A schematic for validating objects
 */
@@ -265,4 +225,5 @@ function schematic(schema) {
 	if (!isPlainObject(schema)) throw new SchematicError(MESSAGE_SCHEMA_INVALID_TYPE);
 	return new Schematic(getProperties(schema));
 }
+//#endregion
 export { SchematicError, instanceOf, isSchematic, schematic };

package/{types/models.d.ts → dist/models.d.mts}

@@ -1,5 +1,7 @@
-import type { Constructor, GenericCallback, PlainObject, Simplify } from '@oscarpalmer/atoms/models';
-import type { Schematic } from './schematic';
+import { Schematic } from "./schematic.mjs";
+import { Constructor, GenericCallback, PlainObject, Simplify } from "@oscarpalmer/atoms/models";
+
+//#region src/models.d.ts
 /**
  * Removes duplicate types from a tuple, preserving first occurrence order
  *
@@ -12,10 +14,7 @@ import type { Schematic } from './schematic';
  * // => ['string', 'number']
  * ```
  */
-type DeduplicateTuple<Value extends unknown[], Seen extends unknown[] = []> = Value extends [
-    infer Head,
-    ...infer Tail
-] ? Head extends Seen[number] ? DeduplicateTuple<Tail, Seen> : DeduplicateTuple<Tail, [...Seen, Head]> : Seen;
+type DeduplicateTuple<Value extends unknown[], Seen extends unknown[] = []> = Value extends [infer Head, ...infer Tail] ? Head extends Seen[number] ? DeduplicateTuple<Tail, Seen> : DeduplicateTuple<Tail, [...Seen, Head]> : Seen;
 /**
  * Recursively extracts {@link ValueName} strings from a type, unwrapping arrays and readonly arrays
  *
@@ -45,19 +44,13 @@ type ExtractValueNames<Value> = Value extends ValueName ? Value : Value extends
  * // { name: string; age: number; address?: string }
  * ```
  */
-export type Infer<Model extends Schema> = Simplify<{
-    [Key in InferRequiredKeys<Model>]: InferSchemaEntry<Model[Key]>;
-} & {
-    [Key in InferOptionalKeys<Model>]?: InferSchemaEntry<Model[Key]>;
-}>;
+type Infer<Model extends Schema> = Simplify<{ [Key in InferRequiredKeys<Model>]: InferSchemaEntry<Model[Key]> } & { [Key in InferOptionalKeys<Model>]?: InferSchemaEntry<Model[Key]> }>;
 /**
  * Extracts keys from a {@link Schema} whose entries are optional _(i.e., `$required` is `false`)_
  *
  * @template Model - {@link Schema} to extract optional keys from
  */
-type InferOptionalKeys<Model extends Schema> = keyof {
-    [Key in keyof Model as IsOptionalProperty<Model[Key]> extends true ? Key : never]: never;
-};
+type InferOptionalKeys<Model extends Schema> = keyof { [Key in keyof Model as IsOptionalProperty<Model[Key]> extends true ? Key : never]: never };
 /**
  * Infers the TypeScript type of a {@link SchemaProperty}'s `$type` field, unwrapping arrays to infer their item type
  *
@@ -77,9 +70,7 @@ type InferPropertyValue<Value> = Value extends Constructor<infer Instance> ? Ins
  *
  * @template Model - Schema to extract required keys from
  */
-type InferRequiredKeys<Model extends Schema> = keyof {
-    [Key in keyof Model as IsOptionalProperty<Model[Key]> extends true ? never : Key]: never;
-};
+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
  *
@@ -102,16 +93,16 @@ type InferSchemaEntryValue<Value> = Value extends Constructor<infer Instance> ?
  * @template Value - Schema entry to check
  */
 type IsOptionalProperty<Value> = Value extends SchemaProperty ? Value['$required'] extends false ? true : false : Value extends {
-    $required?: boolean;
+  $required?: boolean;
 } ? Value extends {
-    $required: false;
+  $required: false;
 } ? true : false : false;
 /**
  * Extracts the last member from a union type by leveraging intersection of function return types
  *
  * @template Value - Union type
  */
-type LastOfUnion<Value> = UnionToIntersection<Value extends unknown ? () => Value : never> extends () => infer Item ? Item : never;
+type LastOfUnion<Value> = UnionToIntersection<Value extends unknown ? () => Value : never> extends (() => infer Item) ? Item : never;
 /**
  * Maps each element of a tuple through {@link ToValueType}
  *
@@ -136,25 +127,23 @@ type MapToSchemaPropertyTypes<Value extends unknown[]> = Value extends [infer He
  * };
  * ```
  */
-export type NestedSchema = {
-    /**
-     * Whether the nested schema is required (defaults to `true`)
-     */
-    $required?: boolean;
+type NestedSchema = {
+  /**
+   * Whether the nested schema is required (defaults to `true`)
+   */
+  $required?: boolean;
 } & Schema;
 /**
  * Extracts keys from an object type that are optional
  *
  * @template Value - Object type to inspect
  */
-type OptionalKeys<Value> = {
-    [Key in keyof Value]-?: {} extends Pick<Value, Key> ? Key : never;
-}[keyof Value];
+type OptionalKeys<Value> = { [Key in keyof Value]-?: {} extends Pick<Value, Key> ? Key : never }[keyof Value];
 /**
  * A generic schema allowing {@link NestedSchema}, {@link SchemaEntry}, or arrays of {@link SchemaEntry} as values
  */
 type PlainSchema = {
-    [key: string]: NestedSchema | SchemaEntry | SchemaEntry[];
+  [key: string]: NestedSchema | SchemaEntry | SchemaEntry[];
 };
 /**
  * A map of optional validator functions keyed by {@link ValueName}, used to add custom validation to {@link SchemaProperty} definitions
@@ -170,9 +159,7 @@ type PlainSchema = {
  * };
  * ```
  */
-type PropertyValidators<Value> = {
-    [Key in ExtractValueNames<Value>]?: ((value: Values[Key]) => boolean) | Array<(value: Values[Key]) => boolean>;
-};
+type PropertyValidators<Value> = { [Key in ExtractValueNames<Value>]?: ((value: Values[Key]) => boolean) | Array<(value: Values[Key]) => boolean> };
 /**
  * Extracts keys from an object type that are required _(i.e., not optional)_
  *
@@ -191,7 +178,7 @@ type RequiredKeys<Value> = Exclude<keyof Value, OptionalKeys<Value>>;
  * };
  * ```
  */
-export type Schema = SchemaIndex;
+type Schema = SchemaIndex;
 /**
  * A union of all valid types for a single schema entry
  *
@@ -202,7 +189,7 @@ type SchemaEntry = Constructor | Schema | SchemaProperty | Schematic<unknown> |
  * Index signature interface backing {@link Schema}, allowing string-keyed entries of {@link NestedSchema}, {@link SchemaEntry}, or arrays of {@link SchemaEntry}
  */
 interface SchemaIndex {
-    [key: string]: NestedSchema | SchemaEntry | SchemaEntry[];
+  [key: string]: NestedSchema | SchemaEntry | SchemaEntry[];
 }
 /**
  * A property definition with explicit type(s), an optional requirement flag, and optional validators
@@ -219,19 +206,19 @@ interface SchemaIndex {
  * };
  * ```
  */
-export type SchemaProperty = {
-    /**
-     * Whether the property is required _(defaults to `true`)_
-     */
-    $required?: boolean;
-    /**
-     * The type(s) the property value must match; a single {@link SchemaPropertyType} or an array
-     */
-    $type: SchemaPropertyType | SchemaPropertyType[];
-    /**
-     * Optional validators keyed by {@link ValueName}, applied during validation
-     */
-    $validators?: PropertyValidators<SchemaPropertyType | SchemaPropertyType[]>;
+type SchemaProperty = {
+  /**
+   * Whether the property is required _(defaults to `true`)_
+   */
+  $required?: boolean;
+  /**
+   * The type(s) the property value must match; a single {@link SchemaPropertyType} or an array
+   */
+  $type: SchemaPropertyType | SchemaPropertyType[];
+  /**
+   * Optional validators keyed by {@link ValueName}, applied during validation
+   */
+  $validators?: PropertyValidators<SchemaPropertyType | SchemaPropertyType[]>;
 };
 /**
  * A union of valid types for a {@link SchemaProperty}'s `$type` field
@@ -247,8 +234,8 @@ type SchemaPropertyType = Constructor | PlainSchema | Schematic<unknown> | Value
  * throw new SchematicError('Expected a string, received a number');
  * ```
  */
-export declare class SchematicError extends Error {
-    constructor(message: string);
+declare class SchematicError extends Error {
+  constructor(message: string);
 }
 /**
  * Converts a type into its corresponding {@link SchemaPropertyType}-representation
@@ -288,9 +275,7 @@ type ToSchemaType<Value> = UnwrapSingle<DeduplicateTuple<MapToValueTypes<UnionTo
  * // ToValueType<Date>      => 'date'
  * ```
  */
-type ToValueType<Value> = Value extends Schematic<any> ? Value : {
-    [Key in keyof Omit<Values, 'object'>]: Value extends Values[Key] ? Key : never;
-}[keyof Omit<Values, 'object'>] extends infer Match ? [Match] extends [never] ? Value extends object ? 'object' | ((value: unknown) => value is Value) : (value: unknown) => value is Value : Match : never;
+type ToValueType<Value> = Value extends Schematic<any> ? Value : { [Key in keyof Omit<Values, 'object'>]: Value extends Values[Key] ? Key : never }[keyof Omit<Values, 'object'>] extends infer Match ? [Match] extends [never] ? Value extends object ? 'object' | ((value: unknown) => value is Value) : (value: unknown) => value is Value : Match : never;
 /**
  * Generates all permutations of a tuple type
  *
@@ -305,12 +290,7 @@ type ToValueType<Value> = Value extends Schematic<any> ? Value : {
  * // => ['string', 'number'] | ['number', 'string']
  * ```
  */
-type TuplePermutations<Tuple extends unknown[], Elput extends unknown[] = []> = Tuple['length'] extends 0 ? Elput : {
-    [Key in keyof Tuple]: TuplePermutations<TupleRemoveAt<Tuple, Key & `${number}`>, [
-        ...Elput,
-        Tuple[Key]
-    ]>;
-}[keyof Tuple & `${number}`];
+type TuplePermutations<Tuple extends unknown[], Elput extends unknown[] = []> = Tuple['length'] extends 0 ? Elput : { [Key in keyof Tuple]: TuplePermutations<TupleRemoveAt<Tuple, Key & `${number}`>, [...Elput, Tuple[Key]]> }[keyof Tuple & `${number}`];
 /**
  * Removes the element at a given index from a tuple
  *
@@ -333,19 +313,19 @@ type TupleRemoveAt<Items extends unknown[], Item extends string, Prefix extends
  * // => { $required: false; $type: 'string'; ... }
  * ```
  */
-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>>>;
+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>>>;
 };
 /**
  * A typed required property definition generated by {@link TypedSchema} for required keys, with `$required` defaulting to `true`
@@ -359,19 +339,19 @@ export type TypedPropertyOptional<Value> = {
  * // => { $required?: true; $type: 'string'; ... }
  * ```
  */
-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>>;
+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>>;
 };
 /**
  * Creates a schema type constrained to match a TypeScript type
@@ -391,18 +371,14 @@ export type TypedPropertyRequired<Value> = {
  * };
  * ```
  */
-export type TypedSchema<Model extends PlainObject> = Simplify<{
-    [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>> | Schematic<Exclude<Model[Key], undefined>> : TypedPropertyOptional<Model[Key]>;
-}>;
+type TypedSchema<Model extends PlainObject> = Simplify<{ [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>> | Schematic<Exclude<Model[Key], undefined>> : TypedPropertyOptional<Model[Key]> }>;
 /**
  * A {@link TypedSchema} variant for optional nested objects, with `$required` fixed to `false`
  *
  * @template Model - Nested object type
  */
 type TypedSchemaOptional<Model extends PlainObject> = {
-    $required: false;
+  $required: false;
 } & TypedSchema<Model>;
 /**
  * A {@link TypedSchema} variant for required nested objects, with `$required` defaulting to `true`
@@ -410,7 +386,7 @@ type TypedSchemaOptional<Model extends PlainObject> = {
  * @template Model - Nested object type
  */
 type TypedSchemaRequired<Model extends PlainObject> = {
-    $required?: true;
+  $required?: true;
 } & TypedSchema<Model>;
 /**
  * Converts a union type into an intersection
@@ -425,7 +401,7 @@ type TypedSchemaRequired<Model extends PlainObject> = {
  * // => { a: 1 } & { b: 2 }
  * ```
  */
-type UnionToIntersection<Value> = (Value extends unknown ? (value: Value) => void : never) extends (value: infer Item) => void ? Item : never;
+type UnionToIntersection<Value> = (Value extends unknown ? (value: Value) => void : never) extends ((value: infer Item) => void) ? Item : never;
 /**
  * Converts a union type into an ordered tuple
  *
@@ -468,42 +444,40 @@ type UnwrapSingle<Value extends unknown[]> = Value extends [infer Only] ? Only :
  * };
  * ```
  */
-export type ValidatedProperty = {
-    /**
-     * The property name in the schema
-     */
-    key: string;
-    /**
-     * Whether the property is required
-     */
-    required: boolean;
-    /**
-     * The allowed types for this property
-     */
-    types: ValidatedPropertyType[];
-    /**
-     * Custom validators grouped by {@link ValueName}
-     */
-    validators: ValidatedPropertyValidators;
+type ValidatedProperty = {
+  /**
+   * The property name in the schema
+   */
+  key: string;
+  /**
+   * Whether the property is required
+   */
+  required: boolean;
+  /**
+   * The allowed types for this property
+   */
+  types: ValidatedPropertyType[];
+  /**
+   * Custom validators grouped by {@link ValueName}
+   */
+  validators: ValidatedPropertyValidators;
 };
 /**
  * A union of valid types for a {@link ValidatedProperty}'s `types` array
  *
  * Can be a callback _(custom validator)_, a {@link Schematic}, a nested {@link ValidatedProperty}, or a {@link ValueName} string
  */
-export type ValidatedPropertyType = GenericCallback | Schematic<unknown> | ValidatedProperty | ValueName;
+type ValidatedPropertyType = GenericCallback | Schematic<unknown> | ValidatedProperty | ValueName;
 /**
  * A map of validator functions keyed by {@link ValueName}, used at runtime in {@link ValidatedProperty}
  *
  * Each key holds an array of validator functions that receive an `unknown` value and return a `boolean`
  */
-export type ValidatedPropertyValidators = {
-    [Key in ValueName]?: Array<(value: unknown) => boolean>;
-};
+type ValidatedPropertyValidators = { [Key in ValueName]?: Array<(value: unknown) => boolean> };
 /**
  * Basic value types
  */
-export type ValueName = keyof Values;
+type ValueName = keyof Values;
 /**
  * Maps type name strings to their TypeScript equivalents
  *
@@ -516,17 +490,18 @@ export type ValueName = keyof Values;
  * // Values['null']    => null
  * ```
  */
-export type Values = {
-    array: unknown[];
-    bigint: bigint;
-    boolean: boolean;
-    date: Date;
-    function: Function;
-    null: null;
-    number: number;
-    object: object;
-    string: string;
-    symbol: symbol;
-    undefined: undefined;
+type Values = {
+  array: unknown[];
+  bigint: bigint;
+  boolean: boolean;
+  date: Date;
+  function: Function;
+  null: null;
+  number: number;
+  object: object;
+  string: string;
+  symbol: symbol;
+  undefined: undefined;
 };
-export {};
+//#endregion
+export { Infer, NestedSchema, Schema, SchemaProperty, SchematicError, TypedPropertyOptional, TypedPropertyRequired, TypedSchema, ValidatedProperty, ValidatedPropertyType, ValidatedPropertyValidators, ValueName, Values };

package/dist/{models.js → models.mjs}

@@ -1,4 +1,5 @@
-import { ERROR_NAME } from "./constants.js";
+import { ERROR_NAME } from "./constants.mjs";
+//#region src/models.ts
 /**
 * A custom error class for schema validation failures, with its `name` set to {@link ERROR_NAME}
 *
@@ -13,4 +14,5 @@ var SchematicError = class extends Error {
 		this.name = ERROR_NAME;
 	}
 };
+//#endregion
 export { SchematicError };

package/dist/schematic.d.mts

@@ -0,0 +1,36 @@
+import { Infer, Schema, TypedSchema, ValidatedProperty } from "./models.mjs";
+import { PlainObject } from "@oscarpalmer/atoms/models";
+
+//#region src/schematic.d.ts
+/**
+ * A schematic for validating objects
+ */
+declare class Schematic<Model> {
+  #private;
+  private readonly $schematic;
+  constructor(properties: ValidatedProperty[]);
+  /**
+   * Does the value match the schema?
+   * @param value - Value to validate
+   * @returns `true` if the value matches the schema, otherwise `false`
+   */
+  is(value: unknown): value is Model;
+}
+/**
+ * Create a schematic from a schema
+ * @template Model - Schema type
+ * @param schema - Schema to create the schematic from
+ * @throws Throws {@link SchematicError} if the schema can not be converted into a schematic
+ * @returns A schematic for the given schema
+ */
+declare function schematic<Model extends Schema>(schema: Model): Schematic<Infer<Model>>;
+/**
+ * Create a schematic from a typed schema
+ * @template Model - Existing type
+ * @param schema - Typed schema to create the schematic from
+ * @throws Throws {@link SchematicError} if the schema can not be converted into a schematic
+ * @returns A schematic for the given typed schema
+ */
+declare function schematic<Model extends PlainObject>(schema: TypedSchema<Model>): Schematic<Model>;
+//#endregion
+export { Schematic, schematic };

package/dist/{schematic.js → schematic.mjs}

@@ -1,9 +1,10 @@
-import { MESSAGE_SCHEMA_INVALID_TYPE, SCHEMATIC_NAME } from "./constants.js";
-import { isSchematic } from "./helpers.js";
-import { SchematicError } from "./models.js";
-import { getProperties } from "./validation/property.validation.js";
-import { validateObject } from "./validation/value.validation.js";
+import { MESSAGE_SCHEMA_INVALID_TYPE, SCHEMATIC_NAME } from "./constants.mjs";
+import { isSchematic } from "./helpers.mjs";
+import { SchematicError } from "./models.mjs";
+import { getProperties } from "./validation/property.validation.mjs";
+import { validateObject } from "./validation/value.validation.mjs";
 import { isPlainObject } from "@oscarpalmer/atoms/is";
+//#region src/schematic.ts
 /**
 * A schematic for validating objects
 */
@@ -27,4 +28,5 @@ function schematic(schema) {
 	if (!isPlainObject(schema)) throw new SchematicError(MESSAGE_SCHEMA_INVALID_TYPE);
 	return new Schematic(getProperties(schema));
 }
+//#endregion
 export { Schematic, schematic };

package/dist/validation/property.validation.d.mts

@@ -0,0 +1,7 @@
+import { ValidatedProperty } from "../models.mjs";
+import { PlainObject } from "@oscarpalmer/atoms/models";
+
+//#region src/validation/property.validation.d.ts
+declare function getProperties(original: PlainObject, prefix?: string, fromType?: boolean): ValidatedProperty[];
+//#endregion
+export { getProperties };