npm - @oscarpalmer/jhunal - Versions diffs - 0.16.0 → 0.18.0 - Mend

@oscarpalmer/jhunal 0.16.0 → 0.18.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 +283 -262
package/dist/index.mjs +189 -56
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 +81 -0
package/dist/models/validation.model.mjs +21 -0
package/dist/schematic.d.mts +20 -6
package/dist/schematic.mjs +7 -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 +63 -11
package/package.json +3 -3
package/src/constants.ts +84 -18
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 +123 -0
package/src/schematic.ts +29 -18
package/src/validation/property.validation.ts +46 -36
package/src/validation/value.validation.ts +115 -15
package/dist/models.d.mts +0 -507
package/dist/models.mjs +0 -18
package/src/models.ts +0 -691

package/dist/index.d.mts CHANGED Viewed

@@ -1,31 +1,6 @@
 import { Constructor, GenericCallback, PlainObject, Simplify } from "@oscarpalmer/atoms/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
  *
@@ -83,88 +58,278 @@ 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 NestedSchema ? Infer<Omit<Value, '$required'>> : Value extends ValueName ? Values[Value & ValueName] : Value extends Schema ? Infer<Value> : never;
+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;
+//#endregion
+//#region src/models/transform.model.d.ts
 /**
- * Determines whether a schema entry is optional
+ * Maps each element of a tuple through {@link ToValueType}
  *
- * Returns `true` if the entry is a {@link SchemaProperty} or {@link NestedSchema} with `$required` set to `false`; otherwise returns `false`
+ * @template Value - Tuple of types to map
+ */
+type MapToValueTypes<Value extends unknown[]> = Value extends [infer Head, ...infer Tail] ? [ToValueType<Head>, ...MapToValueTypes<Tail>] : [];
+/**
+ * Maps each element of a tuple through {@link ToSchemaPropertyTypeEach}
  *
- * @template Value - Schema entry to check
+ * @template Value - Tuple of types to map
  */
-type IsOptionalProperty<Value> = Value extends SchemaProperty ? Value['$required'] extends false ? true : false : Value extends {
-  $required?: boolean;
-} ? Value extends {
-  $required: false;
-} ? true : false : false;
+type MapToSchemaPropertyTypes<Value extends unknown[]> = Value extends [infer Head, ...infer Tail] ? [ToSchemaPropertyTypeEach<Head>, ...MapToSchemaPropertyTypes<Tail>] : [];
 /**
- * Extracts the last member from a union type by leveraging intersection of function return types
+ * Converts a type into its corresponding {@link SchemaPropertyType}-representation
  *
- * @template Value - Union type
+ * Deduplicates and unwraps single-element tuples via {@link UnwrapSingle}
+ *
+ * @template Value - type to convert
  */
-type LastOfUnion<Value> = UnionToIntersection<Value extends unknown ? () => Value : never> extends (() => infer Item) ? Item : never;
+type ToSchemaPropertyType<Value> = UnwrapSingle<DeduplicateTuple<MapToSchemaPropertyTypes<UnionToTuple<Value>>>>;
 /**
- * Maps each element of a tuple through {@link ToValueType}
+ * Converts a single type to its schema property equivalent
  *
- * @template Value - Tuple of types to map
+ * {@link NestedSchema} values have `$required` stripped, plain objects become {@link TypedSchema}, and primitives go through {@link ToValueType}
+ *
+ * @template Value - type to convert
  */
-type MapToValueTypes<Value extends unknown[]> = Value extends [infer Head, ...infer Tail] ? [ToValueType<Head>, ...MapToValueTypes<Tail>] : [];
+type ToSchemaPropertyTypeEach<Value> = Value extends PlainObject ? TypedSchema<Value> : ToValueType<Value>;
 /**
- * Maps each element of a tuple through {@link ToSchemaPropertyTypeEach}
+ * Converts a type into its corresponding {@link ValueName}-representation
  *
- * @template Value - Tuple of types to map
+ * Deduplicates and unwraps single-element tuples via {@link UnwrapSingle}
+ *
+ * @template Value - type to convert
  */
-type MapToSchemaPropertyTypes<Value extends unknown[]> = Value extends [infer Head, ...infer Tail] ? [ToSchemaPropertyTypeEach<Head>, ...MapToSchemaPropertyTypes<Tail>] : [];
+type ToSchemaType<Value> = UnwrapSingle<DeduplicateTuple<MapToValueTypes<UnionToTuple<Value>>>>;
 /**
- * A nested schema definition that may include a `$required` flag alongside arbitrary string-keyed properties
+ * Maps a type to its {@link ValueName} string equivalent
+ *
+ * Resolves {@link Schematic} types as-is, then performs a reverse-lookup against {@link Values} _(excluding `'object'`)_ to find a matching key. If no match is found, `object` types resolve to `'object'` or a type-guard function, and all other unrecognised types resolve to a type-guard function
+ *
+ * @template Value - type to map
  *
  * @example
  * ```ts
- * const address: NestedSchema = {
- *   $required: false,
- *   street: 'string',
- *   city: 'string',
- * };
+ * // ToValueType<string>    => 'string'
+ * // ToValueType<number[]>  => 'array'
+ * // 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;
+//#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
+ *
+ * @template Value - Property's type _(including `undefined`)_
+ *
+ * @example
+ * ```ts
+ * // For `{ name?: string }`, the `name` key produces:
+ * // TypedPropertyOptional<string | undefined>
+ * // => { $required: false; $type: 'string'; ... }
  * ```
  */
-type NestedSchema = {
+type TypedPropertyOptional<Value> = {
   /**
-   * Whether the nested schema is required (defaults to `true`)
+   * The property is not required
    */
-  $required?: boolean;
-} & Schema;
+  $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>>>;
+};
 /**
- * Extracts keys from an object type that are optional
+ * A typed required property definition generated by {@link TypedSchema} for required keys, with `$required` defaulting to `true`
  *
- * @template Value - Object type to inspect
+ * @template Value - Property's type
+ *
+ * @example
+ * ```ts
+ * // For `{ name: string }`, the `name` key produces:
+ * // TypedPropertyRequired<string>
+ * // => { $required?: true; $type: 'string'; ... }
+ * ```
  */
-type OptionalKeys<Value> = { [Key in keyof Value]-?: {} extends Pick<Value, Key> ? Key : never }[keyof 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>>;
+};
 /**
- * A generic schema allowing {@link NestedSchema}, {@link SchemaEntry}, or arrays of {@link SchemaEntry} as values
+ * Creates a schema type constrained to match a TypeScript type
+ *
+ * Required keys map to {@link ToSchemaType} or {@link TypedPropertyRequired}; plain object values may also use {@link Schematic}. Optional keys map to {@link TypedPropertyOptional} or, for plain objects, {@link TypedSchemaOptional}
+ *
+ * @template Model - Object type to generate a schema for
+ *
+ * @example
+ * ```ts
+ * type User = { name: string; age: number; bio?: string };
+ *
+ * const schema: TypedSchema<User> = {
+ *   name: 'string',
+ *   age: 'number',
+ *   bio: { $required: false, $type: 'string' },
+ * };
+ * ```
  */
-type PlainSchema = {
-  [key: string]: NestedSchema | SchemaEntry | SchemaEntry[];
-};
+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 map of optional validator functions keyed by {@link ValueName}, used to add custom validation to {@link SchemaProperty} definitions
+ * A {@link TypedSchema} variant for optional nested objects, with `$required` fixed to `false`
  *
- * Each key may hold a single validator or an array of validators that receive the typed value
+ * @template Model - Nested object type
+ */
+type TypedSchemaOptional<Model extends PlainObject> = {
+  $required: false;
+} & TypedSchema<Model>;
+/**
+ * A {@link TypedSchema} variant for required nested objects, with `$required` defaulting to `true`
  *
- * @template Value - `$type` value(s) to derive validator keys from
+ * @template Model - Nested object type
+ */
+type TypedSchemaRequired<Model extends PlainObject> = {
+  $required?: true;
+} & TypedSchema<Model>;
+//#endregion
+//#region src/models/validation.model.d.ts
+/**
+ * A custom error class for schematic validation failures
+ */
+declare class SchematicError extends Error {
+  constructor(message: string);
+}
+/**
+ * The runtime representation of a parsed schema property, used internally during validation
  *
  * @example
  * ```ts
- * const validators: PropertyValidators<'string'> = {
- *   string: (value) => value.length > 0,
+ * const parsed: ValidatedProperty = {
+ *   key: 'age',
+ *   required: true,
+ *   types: ['number'],
+ *   validators: { number: [(v) => v > 0] },
  * };
  * ```
  */
-type PropertyValidators<Value> = { [Key in ExtractValueNames<Value>]?: ((value: Values[Key]) => boolean) | Array<(value: Values[Key]) => boolean> };
+type ValidatedProperty = {
+  /**
+   * The property name in the schema
+   */
+  key: ValidatedPropertyKey;
+  /**
+   * Whether the property is required
+   */
+  required: boolean;
+  /**
+   * The allowed types for this property
+   */
+  types: ValidatedPropertyType[];
+  /**
+   * Custom validators grouped by {@link ValueName}
+   */
+  validators: ValidatedPropertyValidators;
+};
 /**
- * Extracts keys from an object type that are required _(i.e., not optional)_
+ * 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
  *
- * @template Value - Object type to inspect
+ * Can be a callback _(custom validator)_, a {@link Schematic}, a nested {@link ValidatedProperty}, or a {@link ValueName} string
  */
-type RequiredKeys<Value> = Exclude<keyof Value, OptionalKeys<Value>>;
+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> };
+declare class ValidationError extends Error {
+  readonly information: ValidationInformation[];
+  constructor(information: ValidationInformation[]);
+}
+type ValidationInformation = {
+  key: ValidationInformationKey;
+  message: string;
+  validator?: GenericCallback;
+};
+type ValidationInformationKey = ValidatedPropertyKey;
+//#endregion
+//#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?
+   *
+   * 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 `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`
+   */
+  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
+//#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
  *
@@ -183,12 +348,12 @@ type Schema = SchemaIndex;
  *
  * Can be a {@link Constructor}, nested {@link Schema}, {@link SchemaProperty}, {@link Schematic}, {@link ValueName} string, or a custom validator function
  */
-type SchemaEntry = Constructor | Schema | SchemaProperty | Schematic<unknown> | ValueName | ((value: unknown) => boolean);
+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]: NestedSchema | SchemaEntry | SchemaEntry[];
+  [key: string]: PlainSchema | SchemaEntry | SchemaEntry[];
 }
 /**
  * A property definition with explicit type(s), an optional requirement flag, and optional validators
@@ -226,55 +391,73 @@ type SchemaProperty = {
  */
 type SchemaPropertyType = Constructor | PlainSchema | Schematic<unknown> | ValueName | ((value: unknown) => boolean);
 /**
- * A custom error class for schema validation failures, with its `name` set to {@link ERROR_NAME}
+ * 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
- * throw new SchematicError('Expected a string, received a number');
+ * const validators: PropertyValidators<'string'> = {
+ *   string: (value) => value.length > 0,
+ * };
  * ```
  */
-declare class SchematicError extends Error {
-  constructor(message: string);
-}
+type PropertyValidators<Value> = { [Key in ExtractValueNames<Value>]?: ((value: Values[Key]) => boolean) | Array<(value: Values[Key]) => boolean> };
+//#endregion
+//#region src/models/misc.model.d.ts
 /**
- * Converts a type into its corresponding {@link SchemaPropertyType}-representation
+ * Removes duplicate types from a tuple, preserving first occurrence order
  *
- * Deduplicates and unwraps single-element tuples via {@link UnwrapSingle}
+ * @template Value - Tuple to deduplicate
+ * @template Seen - Accumulator for already-seen types _(internal)_
  *
- * @template Value - type to convert
+ * @example
+ * ```ts
+ * // DeduplicateTuple<['string', 'number', 'string']>
+ * // => ['string', 'number']
+ * ```
  */
-type ToSchemaPropertyType<Value> = UnwrapSingle<DeduplicateTuple<MapToSchemaPropertyTypes<UnionToTuple<Value>>>>;
+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;
 /**
- * Converts a single type to its schema property equivalent
+ * Recursively extracts {@link ValueName} strings from a type, unwrapping arrays and readonly arrays
  *
- * {@link NestedSchema} values have `$required` stripped, plain objects become {@link TypedSchema}, and primitives go through {@link ToValueType}
+ * @template Value - Type to extract value names from
  *
- * @template Value - type to convert
+ * @example
+ * ```ts
+ * // ExtractValueNames<'string'>         => 'string'
+ * // ExtractValueNames<['string', 'number']> => 'string' | 'number'
+ * ```
  */
-type ToSchemaPropertyTypeEach<Value> = Value extends NestedSchema ? Omit<Value, '$required'> : Value extends PlainObject ? TypedSchema<Value> : ToValueType<Value>;
+type ExtractValueNames<Value> = Value extends ValueName ? Value : Value extends (infer Item)[] ? ExtractValueNames<Item> : Value extends readonly (infer Item)[] ? ExtractValueNames<Item> : never;
 /**
- * Converts a type into its corresponding {@link ValueName}-representation
+ * Determines whether a schema entry is optional
  *
- * Deduplicates and unwraps single-element tuples via {@link UnwrapSingle}
+ * Returns `true` if the entry is a {@link SchemaProperty} or {@link NestedSchema} with `$required` set to `false`; otherwise returns `false`
  *
- * @template Value - type to convert
+ * @template Value - Schema entry to check
  */
-type ToSchemaType<Value> = UnwrapSingle<DeduplicateTuple<MapToValueTypes<UnionToTuple<Value>>>>;
+type IsOptionalProperty<Value> = Value extends SchemaProperty ? Value['$required'] extends false ? true : false : false;
 /**
- * Maps a type to its {@link ValueName} string equivalent
+ * Extracts the last member from a union type by leveraging intersection of function return types
  *
- * Resolves {@link Schematic} types as-is, then performs a reverse-lookup against {@link Values} _(excluding `'object'`)_ to find a matching key. If no match is found, `object` types resolve to `'object'` or a type-guard function, and all other unrecognised types resolve to a type-guard function
+ * @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 - type to map
+ * @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)_
  *
- * @example
- * ```ts
- * // ToValueType<string>    => 'string'
- * // ToValueType<number[]>  => 'array'
- * // ToValueType<Date>      => 'date'
- * ```
+ * @template Value - Object type to inspect
  */
-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 RequiredKeys<Value> = Exclude<keyof Value, OptionalKeys<Value>>;
 /**
  * Generates all permutations of a tuple type
  *
@@ -300,93 +483,6 @@ type TuplePermutations<Tuple extends unknown[], Elput extends unknown[] = []> =
  * @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;
-/**
- * A typed optional property definition generated by {@link TypedSchema} for optional keys, with `$required` set to `false` and excludes `undefined` from the type
- *
- * @template Value - Property's type _(including `undefined`)_
- *
- * @example
- * ```ts
- * // For `{ name?: string }`, the `name` key produces:
- * // TypedPropertyOptional<string | undefined>
- * // => { $required: false; $type: 'string'; ... }
- * ```
- */
-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`
- *
- * @template Value - Property's type
- *
- * @example
- * ```ts
- * // For `{ name: string }`, the `name` key produces:
- * // TypedPropertyRequired<string>
- * // => { $required?: true; $type: 'string'; ... }
- * ```
- */
-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
- *
- * Required keys map to {@link ToSchemaType} or {@link TypedPropertyRequired}; plain object values may also use {@link Schematic}. Optional keys map to {@link TypedPropertyOptional} or, for plain objects, {@link TypedSchemaOptional}
- *
- * @template Model - Object type to generate a schema for
- *
- * @example
- * ```ts
- * type User = { name: string; age: number; bio?: string };
- *
- * const schema: TypedSchema<User> = {
- *   name: 'string',
- *   age: 'number',
- *   bio: { $required: false, $type: 'string' },
- * };
- * ```
- */
-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;
-} & TypedSchema<Model>;
-/**
- * A {@link TypedSchema} variant for required nested objects, with `$required` defaulting to `true`
- *
- * @template Model - Nested object type
- */
-type TypedSchemaRequired<Model extends PlainObject> = {
-  $required?: true;
-} & TypedSchema<Model>;
 /**
  * Converts a union type into an intersection
  *
@@ -430,49 +526,6 @@ type UnionToTuple<Value, Items extends unknown[] = []> = [Value] extends [never]
  * ```
  */
 type UnwrapSingle<Value extends unknown[]> = Value extends [infer Only] ? Only : Value['length'] extends 1 | 2 | 3 | 4 | 5 ? TuplePermutations<Value> : Value;
-/**
- * The runtime representation of a parsed schema property, used internally during validation
- *
- * @example
- * ```ts
- * const parsed: ValidatedProperty = {
- *   key: 'age',
- *   required: true,
- *   types: ['number'],
- *   validators: { number: [(v) => v > 0] },
- * };
- * ```
- */
-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
- */
-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`
- */
-type ValidatedPropertyValidators = { [Key in ValueName]?: Array<(value: unknown) => boolean> };
 /**
  * Basic value types
  */
@@ -503,38 +556,6 @@ type Values = {
   undefined: undefined;
 };
 //#endregion
-//#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
 //#region src/helpers.d.ts
 /**
  * Creates a validator function for a given constructor
@@ -550,4 +571,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 };