npm - @oscarpalmer/jhunal - Versions diffs - 0.17.0 → 0.19.0 - Mend

@oscarpalmer/jhunal 0.17.0 → 0.19.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (40) hide show

package/dist/constants.d.mts +28 -15
package/dist/constants.mjs +31 -14
package/dist/helpers.d.mts +8 -1
package/dist/helpers.mjs +68 -3
package/dist/index.d.mts +304 -240
package/dist/index.mjs +201 -51
package/dist/models/infer.model.d.mts +66 -0
package/dist/models/infer.model.mjs +1 -0
package/dist/models/misc.model.d.mts +153 -0
package/dist/models/misc.model.mjs +1 -0
package/dist/models/schema.plain.model.d.mts +92 -0
package/dist/models/schema.plain.model.mjs +1 -0
package/dist/models/schema.typed.model.d.mts +96 -0
package/dist/models/schema.typed.model.mjs +1 -0
package/dist/models/transform.model.d.mts +59 -0
package/dist/models/transform.model.mjs +1 -0
package/dist/models/validation.model.d.mts +82 -0
package/dist/models/validation.model.mjs +21 -0
package/dist/schematic.d.mts +34 -1
package/dist/schematic.mjs +11 -12
package/dist/validation/property.validation.d.mts +1 -1
package/dist/validation/property.validation.mjs +21 -17
package/dist/validation/value.validation.d.mts +2 -2
package/dist/validation/value.validation.mjs +73 -12
package/package.json +2 -2
package/src/constants.ts +84 -19
package/src/helpers.ts +162 -4
package/src/index.ts +3 -1
package/src/models/infer.model.ts +105 -0
package/src/models/misc.model.ts +212 -0
package/src/models/schema.plain.model.ts +110 -0
package/src/models/schema.typed.model.ts +109 -0
package/src/models/transform.model.ts +85 -0
package/src/models/validation.model.ts +124 -0
package/src/schematic.ts +55 -10
package/src/validation/property.validation.ts +41 -36
package/src/validation/value.validation.ts +133 -20
package/dist/models.d.mts +0 -484
package/dist/models.mjs +0 -13
package/src/models.ts +0 -665

package/dist/index.d.mts CHANGED Viewed

@@ -1,31 +1,7 @@
 import { Constructor, GenericCallback, PlainObject, Simplify } from "@oscarpalmer/atoms/models";
+import { Result } from "@oscarpalmer/atoms/result/models";
-//#region src/models.d.ts
-/**
- * Removes duplicate types from a tuple, preserving first occurrence order
- *
- * @template Value - Tuple to deduplicate
- * @template Seen - Accumulator for already-seen types _(internal)_
- *
- * @example
- * ```ts
- * // DeduplicateTuple<['string', 'number', 'string']>
- * // => ['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;
-/**
- * Recursively extracts {@link ValueName} strings from a type, unwrapping arrays and readonly arrays
- *
- * @template Value - Type to extract value names from
- *
- * @example
- * ```ts
- * // ExtractValueNames<'string'>         => 'string'
- * // ExtractValueNames<['string', 'number']> => 'string' | 'number'
- * ```
- */
-type ExtractValueNames<Value> = Value extends ValueName ? Value : Value extends (infer Item)[] ? ExtractValueNames<Item> : Value extends readonly (infer Item)[] ? ExtractValueNames<Item> : never;
+//#region src/models/infer.model.d.ts
 /**
  * Infers the TypeScript type from a {@link Schema} definition
  *
@@ -84,20 +60,8 @@ type InferSchemaEntry<Value> = Value extends (infer Item)[] ? InferSchemaEntryVa
  * @template Value - single schema entry
  */
 type InferSchemaEntryValue<Value> = Value extends Constructor<infer Instance> ? Instance : Value extends Schematic<infer Model> ? Model : Value extends SchemaProperty ? InferPropertyType<Value['$type']> : Value extends PlainSchema ? Infer<Value & Schema> : Value extends ValueName ? Values[Value & ValueName] : Value extends Schema ? Infer<Value> : never;
-/**
- * Determines whether a schema entry is optional
- *
- * Returns `true` if the entry is a {@link SchemaProperty} or {@link NestedSchema} with `$required` set to `false`; otherwise returns `false`
- *
- * @template Value - Schema entry to check
- */
-type IsOptionalProperty<Value> = Value extends SchemaProperty ? Value['$required'] extends 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;
+//#endregion
+//#region src/models/transform.model.d.ts
 /**
  * Maps each element of a tuple through {@link ToValueType}
  *
@@ -110,109 +74,6 @@ type MapToValueTypes<Value extends unknown[]> = Value extends [infer Head, ...in
  * @template Value - Tuple of types to map
  */
 type MapToSchemaPropertyTypes<Value extends unknown[]> = Value extends [infer Head, ...infer Tail] ? [ToSchemaPropertyTypeEach<Head>, ...MapToSchemaPropertyTypes<Tail>] : [];
-/**
- * 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];
-/**
- * A generic schema allowing {@link NestedSchema}, {@link SchemaEntry}, or arrays of {@link SchemaEntry} as values
- */
-type PlainSchema = {
-  [key: string]: PlainSchema | SchemaEntry | SchemaEntry[] | undefined;
-} & {
-  $required?: never;
-  $type?: never;
-  $validators?: never;
-};
-/**
- * A map of optional validator functions keyed by {@link ValueName}, used to add custom validation to {@link SchemaProperty} definitions
- *
- * Each key may hold a single validator or an array of validators that receive the typed value
- *
- * @template Value - `$type` value(s) to derive validator keys from
- *
- * @example
- * ```ts
- * const validators: PropertyValidators<'string'> = {
- *   string: (value) => value.length > 0,
- * };
- * ```
- */
-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)_
- *
- * @template Value - Object type to inspect
- */
-type RequiredKeys<Value> = Exclude<keyof Value, OptionalKeys<Value>>;
-/**
- * A schema for validating objects
- *
- * @example
- * ```ts
- * const schema: Schema = {
- *   name: 'string',
- *   age: 'number',
- *   tags: ['string', 'number'],
- * };
- * ```
- */
-type Schema = SchemaIndex;
-/**
- * A union of all valid types for a single schema entry
- *
- * Can be a {@link Constructor}, nested {@link Schema}, {@link SchemaProperty}, {@link Schematic}, {@link ValueName} string, or a custom validator function
- */
-type SchemaEntry = Constructor | PlainSchema | SchemaProperty | Schematic<unknown> | ValueName | ((value: unknown) => boolean);
-/**
- * Index signature interface backing {@link Schema}, allowing string-keyed entries of {@link NestedSchema}, {@link SchemaEntry}, or arrays of {@link SchemaEntry}
- */
-interface SchemaIndex {
-  [key: string]: PlainSchema | SchemaEntry | SchemaEntry[];
-}
-/**
- * A property definition with explicit type(s), an optional requirement flag, and optional validators
- *
- * @example
- * ```ts
- * const prop: SchemaProperty = {
- *   $required: false,
- *   $type: ['string', 'number'],
- *   $validators: {
- *     string: (v) => v.length > 0,
- *     number: (v) => v > 0,
- *   },
- * };
- * ```
- */
-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
- *
- * Can be a {@link Constructor}, {@link PlainSchema}, {@link Schematic}, {@link ValueName} string, or a custom validator function
- */
-type SchemaPropertyType = Constructor | PlainSchema | Schematic<unknown> | ValueName | ((value: unknown) => boolean);
-/**
- * A custom error class for schematic validation failures
- */
-declare class SchematicError extends Error {
-  constructor(message: string);
-}
 /**
  * Converts a type into its corresponding {@link SchemaPropertyType}-representation
  *
@@ -252,31 +113,8 @@ type ToSchemaType<Value> = UnwrapSingle<DeduplicateTuple<MapToValueTypes<UnionTo
  * ```
  */
 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
- *
- * Used by {@link UnwrapSingle} to allow schema types in any order for small tuples _(length ≤ 5)_
- *
- * @template Tuple - Tuple to permute
- * @template Elput - Accumulator for the current permutation _(internal; name is Tuple backwards)_
- *
- * @example
- * ```ts
- * // TuplePermutations<['string', 'number']>
- * // => ['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}`];
-/**
- * Removes the element at a given index from a tuple
- *
- * Used internally by {@link TuplePermutations}
- *
- * @template Items - Tuple to remove from
- * @template Item - Stringified index to remove
- * @template Prefix - Accumulator for elements before the target _(internal)_
- */
-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;
+//#endregion
+//#region src/models/schema.typed.model.d.ts
 /**
  * A typed optional property definition generated by {@link TypedSchema} for optional keys, with `$required` set to `false` and excludes `undefined` from the type
  *
@@ -364,49 +202,14 @@ type TypedSchemaOptional<Model extends PlainObject> = {
 type TypedSchemaRequired<Model extends PlainObject> = {
   $required?: true;
 } & TypedSchema<Model>;
+//#endregion
+//#region src/models/validation.model.d.ts
 /**
- * Converts a union type into an intersection
- *
- * Uses the contravariance of function parameter types to collapse a union into an intersection
- *
- * @template Value - Union type to convert
- *
- * @example
- * ```ts
- * // UnionToIntersection<{ a: 1 } | { b: 2 }>
- * // => { a: 1 } & { b: 2 }
- * ```
- */
-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
- *
- * Repeatedly extracts the {@link LastOfUnion} member and prepends it to the accumulator
- *
- * @template Value - Union type to convert
- * @template Items - Accumulator for the resulting tuple _(internal)_
- *
- * @example
- * ```ts
- * // UnionToTuple<'a' | 'b' | 'c'>
- * // => ['a', 'b', 'c']
- * ```
- */
-type UnionToTuple<Value, Items extends unknown[] = []> = [Value] extends [never] ? Items : UnionToTuple<Exclude<Value, LastOfUnion<Value>>, [LastOfUnion<Value>, ...Items]>;
-/**
- * Unwraps a single-element tuple to its inner type
- *
- * For tuples of length 2–5, returns all {@link TuplePermutations} to allow types in any order. Longer tuples are returned as-is
- *
- * @template Value - Tuple to potentially unwrap
- *
- * @example
- * ```ts
- * // UnwrapSingle<['string']>            => 'string'
- * // UnwrapSingle<['string', 'number']>  => ['string', 'number'] | ['number', 'string']
- * ```
+ * A custom error class for schematic validation failures
  */
-type UnwrapSingle<Value extends unknown[]> = Value extends [infer Only] ? Only : Value['length'] extends 1 | 2 | 3 | 4 | 5 ? TuplePermutations<Value> : Value;
+declare class SchematicError extends Error {
+  constructor(message: string);
+}
 /**
  * The runtime representation of a parsed schema property, used internally during validation
  *
@@ -424,7 +227,7 @@ type ValidatedProperty = {
   /**
    * The property name in the schema
    */
-  key: string;
+  key: ValidatedPropertyKey;
   /**
    * Whether the property is required
    */
@@ -438,47 +241,42 @@ type ValidatedProperty = {
    */
   validators: ValidatedPropertyValidators;
 };
+/**
+ * Property name in schema
+ */
+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;
+};
 /**
  * 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
  */
-type ValidatedPropertyType = GenericCallback | Schematic<unknown> | ValidatedProperty | ValueName;
+type ValidatedPropertyType = GenericCallback | ValidatedProperty[] | Schematic<unknown> | 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`
  */
 type ValidatedPropertyValidators = { [Key in ValueName]?: Array<(value: unknown) => boolean> };
-/**
- * Basic value types
- */
-type ValueName = keyof Values;
-/**
- * Maps type name strings to their TypeScript equivalents
- *
- * Used by the type system to resolve {@link ValueName} strings into actual types
- *
- * @example
- * ```ts
- * // Values['string']  => string
- * // Values['date']    => Date
- * // Values['null']    => null
- * ```
- */
-type Values = {
-  array: unknown[];
-  bigint: bigint;
-  boolean: boolean;
-  date: Date;
-  function: Function;
-  null: null;
-  number: number;
-  object: object;
-  string: string;
-  symbol: symbol;
-  undefined: undefined;
+declare class ValidationError extends Error {
+  readonly information: ValidationInformation[];
+  constructor(information: ValidationInformation[]);
+}
+type ValidationInformation = {
+  key: ValidationInformationKey;
+  message: string;
+  validator?: GenericCallback;
+  value: unknown;
 };
+type ValidationInformationKey = ValidatedPropertyKey;
 //#endregion
 //#region src/schematic.d.ts
 /**
@@ -490,6 +288,35 @@ declare class Schematic<Model> {
   constructor(properties: ValidatedProperty[]);
   /**
    * 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 Throws an error for the first validation failure
+   * @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 errors All
+   * @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 errors First
+   * @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
    * @returns `true` if the value matches the schema, otherwise `false`
    */
@@ -512,6 +339,243 @@ declare function schematic<Model extends Schema>(schema: Model): Schematic<Infer
  */
 declare function schematic<Model extends PlainObject>(schema: TypedSchema<Model>): Schematic<Model>;
 //#endregion
+//#region src/models/schema.plain.model.d.ts
+/**
+ * A generic schema allowing {@link NestedSchema}, {@link SchemaEntry}, or arrays of {@link SchemaEntry} as values
+ */
+type PlainSchema = {
+  [key: string]: PlainSchema | SchemaEntry | SchemaEntry[] | undefined;
+} & {
+  $required?: never;
+  $type?: never;
+  $validators?: never;
+};
+/**
+ * A schema for validating objects
+ *
+ * @example
+ * ```ts
+ * const schema: Schema = {
+ *   name: 'string',
+ *   age: 'number',
+ *   tags: ['string', 'number'],
+ * };
+ * ```
+ */
+type Schema = SchemaIndex;
+/**
+ * A union of all valid types for a single schema entry
+ *
+ * Can be a {@link Constructor}, nested {@link Schema}, {@link SchemaProperty}, {@link Schematic}, {@link ValueName} string, or a custom validator function
+ */
+type SchemaEntry = Constructor | PlainSchema | SchemaProperty | Schematic<unknown> | ValueName | ((value: unknown) => boolean);
+/**
+ * Index signature interface backing {@link Schema}, allowing string-keyed entries of {@link NestedSchema}, {@link SchemaEntry}, or arrays of {@link SchemaEntry}
+ */
+interface SchemaIndex {
+  [key: string]: PlainSchema | SchemaEntry | SchemaEntry[];
+}
+/**
+ * A property definition with explicit type(s), an optional requirement flag, and optional validators
+ *
+ * @example
+ * ```ts
+ * const prop: SchemaProperty = {
+ *   $required: false,
+ *   $type: ['string', 'number'],
+ *   $validators: {
+ *     string: (v) => v.length > 0,
+ *     number: (v) => v > 0,
+ *   },
+ * };
+ * ```
+ */
+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
+ *
+ * Can be a {@link Constructor}, {@link PlainSchema}, {@link Schematic}, {@link ValueName} string, or a custom validator function
+ */
+type SchemaPropertyType = Constructor | PlainSchema | Schematic<unknown> | ValueName | ((value: unknown) => boolean);
+/**
+ * A map of optional validator functions keyed by {@link ValueName}, used to add custom validation to {@link SchemaProperty} definitions
+ *
+ * Each key may hold a single validator or an array of validators that receive the typed value
+ *
+ * @template Value - `$type` value(s) to derive validator keys from
+ *
+ * @example
+ * ```ts
+ * const validators: PropertyValidators<'string'> = {
+ *   string: (value) => value.length > 0,
+ * };
+ * ```
+ */
+type PropertyValidators<Value> = { [Key in ExtractValueNames<Value>]?: ((value: Values[Key]) => boolean) | Array<(value: Values[Key]) => boolean> };
+//#endregion
+//#region src/models/misc.model.d.ts
+/**
+ * Removes duplicate types from a tuple, preserving first occurrence order
+ *
+ * @template Value - Tuple to deduplicate
+ * @template Seen - Accumulator for already-seen types _(internal)_
+ *
+ * @example
+ * ```ts
+ * // DeduplicateTuple<['string', 'number', 'string']>
+ * // => ['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;
+/**
+ * Recursively extracts {@link ValueName} strings from a type, unwrapping arrays and readonly arrays
+ *
+ * @template Value - Type to extract value names from
+ *
+ * @example
+ * ```ts
+ * // ExtractValueNames<'string'>         => 'string'
+ * // ExtractValueNames<['string', 'number']> => 'string' | 'number'
+ * ```
+ */
+type ExtractValueNames<Value> = Value extends ValueName ? Value : Value extends (infer Item)[] ? ExtractValueNames<Item> : Value extends readonly (infer Item)[] ? ExtractValueNames<Item> : never;
+/**
+ * Determines whether a schema entry is optional
+ *
+ * Returns `true` if the entry is a {@link SchemaProperty} or {@link NestedSchema} with `$required` set to `false`; otherwise returns `false`
+ *
+ * @template Value - Schema entry to check
+ */
+type IsOptionalProperty<Value> = Value extends SchemaProperty ? Value['$required'] extends 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;
+/**
+ * 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];
+/**
+ * Extracts keys from an object type that are required _(i.e., not optional)_
+ *
+ * @template Value - Object type to inspect
+ */
+type RequiredKeys<Value> = Exclude<keyof Value, OptionalKeys<Value>>;
+/**
+ * Generates all permutations of a tuple type
+ *
+ * Used by {@link UnwrapSingle} to allow schema types in any order for small tuples _(length ≤ 5)_
+ *
+ * @template Tuple - Tuple to permute
+ * @template Elput - Accumulator for the current permutation _(internal; name is Tuple backwards)_
+ *
+ * @example
+ * ```ts
+ * // TuplePermutations<['string', 'number']>
+ * // => ['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}`];
+/**
+ * Removes the element at a given index from a tuple
+ *
+ * Used internally by {@link TuplePermutations}
+ *
+ * @template Items - Tuple to remove from
+ * @template Item - Stringified index to remove
+ * @template Prefix - Accumulator for elements before the target _(internal)_
+ */
+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;
+/**
+ * Converts a union type into an intersection
+ *
+ * Uses the contravariance of function parameter types to collapse a union into an intersection
+ *
+ * @template Value - Union type to convert
+ *
+ * @example
+ * ```ts
+ * // UnionToIntersection<{ a: 1 } | { b: 2 }>
+ * // => { a: 1 } & { b: 2 }
+ * ```
+ */
+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
+ *
+ * Repeatedly extracts the {@link LastOfUnion} member and prepends it to the accumulator
+ *
+ * @template Value - Union type to convert
+ * @template Items - Accumulator for the resulting tuple _(internal)_
+ *
+ * @example
+ * ```ts
+ * // UnionToTuple<'a' | 'b' | 'c'>
+ * // => ['a', 'b', 'c']
+ * ```
+ */
+type UnionToTuple<Value, Items extends unknown[] = []> = [Value] extends [never] ? Items : UnionToTuple<Exclude<Value, LastOfUnion<Value>>, [LastOfUnion<Value>, ...Items]>;
+/**
+ * Unwraps a single-element tuple to its inner type
+ *
+ * For tuples of length 2–5, returns all {@link TuplePermutations} to allow types in any order. Longer tuples are returned as-is
+ *
+ * @template Value - Tuple to potentially unwrap
+ *
+ * @example
+ * ```ts
+ * // UnwrapSingle<['string']>            => 'string'
+ * // UnwrapSingle<['string', 'number']>  => ['string', 'number'] | ['number', 'string']
+ * ```
+ */
+type UnwrapSingle<Value extends unknown[]> = Value extends [infer Only] ? Only : Value['length'] extends 1 | 2 | 3 | 4 | 5 ? TuplePermutations<Value> : Value;
+/**
+ * Basic value types
+ */
+type ValueName = keyof Values;
+/**
+ * Maps type name strings to their TypeScript equivalents
+ *
+ * Used by the type system to resolve {@link ValueName} strings into actual types
+ *
+ * @example
+ * ```ts
+ * // Values['string']  => string
+ * // Values['date']    => Date
+ * // Values['null']    => null
+ * ```
+ */
+type Values = {
+  array: unknown[];
+  bigint: bigint;
+  boolean: boolean;
+  date: Date;
+  function: Function;
+  null: null;
+  number: number;
+  object: object;
+  string: string;
+  symbol: symbol;
+  undefined: undefined;
+};
+//#endregion
 //#region src/helpers.d.ts
 /**
  * Creates a validator function for a given constructor
@@ -527,4 +591,4 @@ declare function instanceOf<Instance>(constructor: Constructor<Instance>): (valu
  */
 declare function isSchematic(value: unknown): value is Schematic<never>;
 //#endregion
-export { type Schema, type Schematic, SchematicError, type TypedSchema, instanceOf, isSchematic, schematic };
+export { type Schema, type Schematic, SchematicError, type TypedSchema, ValidationError, instanceOf, isSchematic, schematic };