@oscarpalmer/jhunal 0.20.0 → 0.21.0

package/dist/helpers.d.mts

@@ -1,17 +1,14 @@
-import { ReportingInformation, ValidatedProperty } from "./models/validation.model.mjs";
+import { ReportingInformation, ValidatedPropertyType, ValidationParameters } from "./models/validation.model.mjs";
 import { Schematic } from "./schematic.mjs";
 import { ValueName } from "./models/misc.model.mjs";
 import { Constructor } from "@oscarpalmer/atoms/models";
 
 //#region src/helpers.d.ts
 declare function getInvalidInputMessage(actual: unknown): string;
-declare function getInvalidMissingMessage(property: ValidatedProperty): string;
-declare function getInvalidTypeMessage(property: ValidatedProperty, actual: unknown): string;
-declare function getInvalidValidatorMessage(property: ValidatedProperty, type: ValueName, index: number, length: number): string;
-declare function getOptions(input: unknown): {
-  reporting: ReportingInformation;
-  strict: boolean;
-};
+declare function getInvalidMissingMessage(key: string, types: ValidatedPropertyType[]): string;
+declare function getInvalidTypeMessage(key: string, types: ValidatedPropertyType[], actual: unknown): string;
+declare function getInvalidValidatorMessage(key: string, type: ValueName, index: number, length: number): string;
+declare function getParameters(input?: unknown): ValidationParameters;
 declare function getReporting(value: unknown): ReportingInformation;
 declare function getUnknownKeysMessage(keys: string[]): string;
 /**
@@ -28,4 +25,4 @@ declare function instanceOf<Instance>(constructor: Constructor<Instance>): (valu
  */
 declare function isSchematic(value: unknown): value is Schematic<never>;
 //#endregion
-export { getInvalidInputMessage, getInvalidMissingMessage, getInvalidTypeMessage, getInvalidValidatorMessage, getOptions, getReporting, getUnknownKeysMessage, instanceOf, isSchematic };
+export { getInvalidInputMessage, getInvalidMissingMessage, getInvalidTypeMessage, getInvalidValidatorMessage, getParameters, getReporting, getUnknownKeysMessage, instanceOf, isSchematic };

package/dist/helpers.mjs

@@ -4,34 +4,37 @@ import { isConstructor, isPlainObject } from "@oscarpalmer/atoms/is";
 function getInvalidInputMessage(actual) {
 	return VALIDATION_MESSAGE_INVALID_INPUT.replace("<>", getValueType(actual));
 }
-function getInvalidMissingMessage(property) {
-	let message = VALIDATION_MESSAGE_INVALID_REQUIRED.replace("<>", renderTypes(property.types));
-	message = message.replace("<>", property.key.full);
+function getInvalidMissingMessage(key, types) {
+	let message = VALIDATION_MESSAGE_INVALID_REQUIRED.replace("<>", renderTypes(types));
+	message = message.replace("<>", key);
 	return message;
 }
-function getInvalidTypeMessage(property, actual) {
-	let message = VALIDATION_MESSAGE_INVALID_TYPE.replace("<>", renderTypes(property.types));
-	message = message.replace("<>", property.key.full);
+function getInvalidTypeMessage(key, types, actual) {
+	let message = VALIDATION_MESSAGE_INVALID_TYPE.replace("<>", renderTypes(types));
+	message = message.replace("<>", key);
 	message = message.replace("<>", getValueType(actual));
 	return message;
 }
-function getInvalidValidatorMessage(property, type, index, length) {
-	let message = VALIDATION_MESSAGE_INVALID_VALUE.replace("<>", property.key.full);
+function getInvalidValidatorMessage(key, type, index, length) {
+	let message = VALIDATION_MESSAGE_INVALID_VALUE.replace("<>", key);
 	message = message.replace("<>", type);
 	if (length > 1) message += VALIDATION_MESSAGE_INVALID_VALUE_SUFFIX.replace("<>", String(index));
 	return message;
 }
-function getOptions(input) {
+function getParameters(input) {
 	if (typeof input === "boolean") return {
+		output: {},
 		reporting: getReporting(REPORTING_NONE),
 		strict: input
 	};
 	if (REPORTING_TYPES.has(input)) return {
+		output: {},
 		reporting: getReporting(input),
 		strict: false
 	};
 	const options = isPlainObject(input) ? input : {};
 	return {
+		output: {},
 		reporting: getReporting(options.errors),
 		strict: typeof options.strict === "boolean" ? options.strict : false
 	};
@@ -113,4 +116,4 @@ function renderTypes(types) {
 	return renderParts(parts, CONJUNCTION_OR, CONJUNCTION_OR_COMMA);
 }
 //#endregion
-export { getInvalidInputMessage, getInvalidMissingMessage, getInvalidTypeMessage, getInvalidValidatorMessage, getOptions, getReporting, getUnknownKeysMessage, instanceOf, isSchematic };
+export { getInvalidInputMessage, getInvalidMissingMessage, getInvalidTypeMessage, getInvalidValidatorMessage, getParameters, getReporting, getUnknownKeysMessage, instanceOf, isSchematic };

package/dist/index.d.mts

@@ -214,7 +214,7 @@ type ValidatedProperty = {
   /**
    * The property name in the schema
    */
-  key: ValidatedPropertyKey;
+  key: string;
   /**
    * Whether the property is required
    */
@@ -228,15 +228,6 @@ type ValidatedProperty = {
    */
   validators: ValidatedPropertyValidators;
 };
-/**
- * The full and short forms of a property's key path
- *
- * For a nested property `address.street`: `full` is `'address.street'`, `short` is `'street'`
- */
-type ValidatedPropertyKey = {
-  full: string;
-  short: string;
-};
 /**
  * A union of valid types for a {@link ValidatedProperty}'s `types` array
  *
@@ -266,9 +257,12 @@ type ValidationInformation = {
   value: unknown;
 };
 /**
- * Same shape as {@link ValidatedPropertyKey}; the key path of a failed property
+ *
  */
-type ValidationInformationKey = ValidatedPropertyKey;
+type ValidationInformationKey = {
+  full: string;
+  short: string;
+};
 /**
  * Options for validation
  */
@@ -291,10 +285,73 @@ declare class Schematic<Model> {
   #private;
   private readonly $schematic;
   constructor(properties: ValidatedProperty[]);
+  /**
+   * Parse a value according to the schema
+   *
+   * Returns a deeply cloned version of the value or throws an error for the first property that fails validation
+   * @param value Value to parse
+   * @param options Validation options
+   * @returns Deeply cloned version of the value if it matches the schema, otherwise throws an error
+   */
+  get(value: unknown, options: ValidationOptions<'throw'>): Model;
+  /**
+   * Parse a value according to the schema
+   *
+   * Returns a deeply cloned version of the value or throws an error for the first property that fails validation
+   * @param value Value to parse
+   * @param errors Reporting type
+   * @returns Deeply cloned version of the value if it matches the schema, otherwise throws an error
+   */
+  get(value: unknown, errors: 'throw'): Model;
+  /**
+   * Parse a value according to the schema
+   *
+   * Returns a result of a deeply cloned version of the value or all validation information for validation failures from the same depth in the value
+   * @param value Value to parse
+   * @param options Validation options
+   * @returns Result holding deeply cloned value or all validation information
+   */
+  get(value: unknown, options: ValidationOptions<'all'>): Result<Model, ValidationInformation[]>;
+  /**
+   * Parse a value according to the schema
+   *
+   * Returns a result of a deeply cloned version of the value or all validation information for validation failures from the same depth in the value
+   * @param value Value to parse
+   * @param errors Reporting type
+   * @returns Result holding deeply cloned value or all validation information
+   */
+  get(value: unknown, errors: 'all'): Result<Model, ValidationInformation[]>;
+  /**
+   * Parse a value according to the schema
+   *
+   * Returns a deeply cloned version of the value or all validation information for the first failing property
+   * @param value Value to parse
+   * @param options Validation options
+   * @returns Result holding deeply cloned value or all validation information
+   */
+  get(value: unknown, options: ValidationOptions<'first'>): Result<Model, ValidationInformation>;
+  /**
+   * Parse a value according to the schema
+   *
+   * Returns a deeply cloned version of the value or all validation information for the first failing property
+   * @param value Value to parse
+   * @param errors Reporting type
+   * @returns Result holding deeply cloned value or all validation information
+   */
+  get(value: unknown, errors: 'first'): Result<Model, ValidationInformation>;
+  /**
+   * Parse a value according to the schema
+   *
+   * Returns a deeply cloned version of the value or `undefined` if the value does not match the schema
+   * @param value Value to parse
+   * @param strict Validate if unknown keys are present in the object? _(defaults to `false`)_
+   * @returns Deeply cloned value, or `undefined` if it's invalid
+   */
+  get(value: unknown, strict?: true): Model | undefined;
   /**
    * 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.
+   * 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 options Validation options
    * @returns `true` if the value matches the schema, otherwise throws an error
@@ -303,7 +360,7 @@ declare class Schematic<Model> {
   /**
    * Does the value match the schema?
    *
-   * Will assert that the values matches the schema and throw an error if it does not. The error will contain all validation information for the first property that fails validation.
+   * Will assert that the values matches the schema and throw an error if it does not. The error will contain all validation information for the first property that fails validation
    * @param value Value to validate
    * @param errors Reporting type
    * @returns `true` if the value matches the schema, otherwise throws an error
@@ -312,25 +369,25 @@ declare class Schematic<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.
+   * 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 value
    * @param value Value to validate
    * @param options Validation options
-   * @returns `true` if the value matches the schema, otherwise `false`
+   * @returns Result holding `true` or all validation information
    */
   is(value: unknown, options: ValidationOptions<'all'>): Result<true, ValidationInformation[]>;
   /**
    * Does the value match the schema?
    *
-   * Will validate that the value matches the schema and return a result of `true` or all validation information for validation failures from the same depth in the object.
+   * 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 value
    * @param value Value to validate
    * @param errors Reporting type
-   * @returns `true` if the value matches the schema, otherwise `false`
+   * @returns Result holding `true` or all validation information
    */
   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.
+   * Will validate that the value matches the schema and return a result of `true` or all validation information for the first failing property
    * @param value Value to validate
    * @param options Validation options
    * @returns `true` if the value matches the schema, otherwise `false`
@@ -339,7 +396,7 @@ declare class Schematic<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 the failing property.
+   * Will validate that the value matches the schema and return a result of `true` or all validation information for the first failing property
    * @param value Value to validate
    * @param errors Reporting type
    * @returns `true` if the value matches the schema, otherwise `false`
@@ -348,7 +405,7 @@ declare class Schematic<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.
+   * Will validate that the value matches the schema and return `true` or `false`, without any validation information for validation failures
    * @param value Value to validate
    * @param strict Validate if unknown keys are present in the object? _(defaults to `false`)_
    * @returns `true` if the value matches the schema, otherwise `false`

package/dist/index.mjs

@@ -1,6 +1,7 @@
 import { isConstructor, isPlainObject } from "@oscarpalmer/atoms/is";
 import { join } from "@oscarpalmer/atoms/string";
-import { error } from "@oscarpalmer/atoms/result/misc";
+import { error, ok } from "@oscarpalmer/atoms/result/misc";
+import { clone } from "@oscarpalmer/atoms/value/clone";
 //#region src/constants.ts
 const CONJUNCTION_OR = " or ";
 const CONJUNCTION_OR_COMMA = ", or ";
@@ -63,34 +64,37 @@ const TYPE_ALL = new Set([
 function getInvalidInputMessage(actual) {
 	return VALIDATION_MESSAGE_INVALID_INPUT.replace("<>", getValueType(actual));
 }
-function getInvalidMissingMessage(property) {
-	let message = VALIDATION_MESSAGE_INVALID_REQUIRED.replace("<>", renderTypes(property.types));
-	message = message.replace("<>", property.key.full);
+function getInvalidMissingMessage(key, types) {
+	let message = VALIDATION_MESSAGE_INVALID_REQUIRED.replace("<>", renderTypes(types));
+	message = message.replace("<>", key);
 	return message;
 }
-function getInvalidTypeMessage(property, actual) {
-	let message = VALIDATION_MESSAGE_INVALID_TYPE.replace("<>", renderTypes(property.types));
-	message = message.replace("<>", property.key.full);
+function getInvalidTypeMessage(key, types, actual) {
+	let message = VALIDATION_MESSAGE_INVALID_TYPE.replace("<>", renderTypes(types));
+	message = message.replace("<>", key);
 	message = message.replace("<>", getValueType(actual));
 	return message;
 }
-function getInvalidValidatorMessage(property, type, index, length) {
-	let message = VALIDATION_MESSAGE_INVALID_VALUE.replace("<>", property.key.full);
+function getInvalidValidatorMessage(key, type, index, length) {
+	let message = VALIDATION_MESSAGE_INVALID_VALUE.replace("<>", key);
 	message = message.replace("<>", type);
 	if (length > 1) message += VALIDATION_MESSAGE_INVALID_VALUE_SUFFIX.replace("<>", String(index));
 	return message;
 }
-function getOptions(input) {
+function getParameters(input) {
 	if (typeof input === "boolean") return {
+		output: {},
 		reporting: getReporting(REPORTING_NONE),
 		strict: input
 	};
 	if (REPORTING_TYPES.has(input)) return {
+		output: {},
 		reporting: getReporting(input),
 		strict: false
 	};
 	const options = isPlainObject(input) ? input : {};
 	return {
+		output: {},
 		reporting: getReporting(options.errors),
 		strict: typeof options.strict === "boolean" ? options.strict : false
 	};
@@ -210,9 +214,8 @@ function getProperties(original, prefix, fromType) {
 	const properties = [];
 	for (let keyIndex = 0; keyIndex < keysLength; keyIndex += 1) {
 		const key = keys[keyIndex];
-		const prefixed = join([prefix, key], ".");
 		const value = original[key];
-		if (value == null) throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_NULLABLE.replace("<>", prefixed));
+		if (value == null) throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_NULLABLE.replace("<>", join([prefix, key], ".")));
 		const types = [];
 		let required = true;
 		let validators = {};
@@ -224,12 +227,9 @@ function getProperties(original, prefix, fromType) {
 		} else types.push(...getTypes(key, value, prefix));
 		if (!required && !types.includes("undefined")) types.push(TYPE_UNDEFINED);
 		properties.push({
+			key,
 			types,
 			validators,
-			key: {
-				full: prefixed,
-				short: key
-			},
 			required: required && !types.includes("undefined")
 		});
 	}
@@ -284,18 +284,21 @@ function getValidators(original) {
 }
 //#endregion
 //#region src/validation/value.validation.ts
-function validateNamed(property, name, value, validation) {
+function validateNamed(name, value, parameters) {
 	if (!validators[name](value)) return false;
-	const propertyValidators = property.validators[name];
+	const propertyValidators = parameters.origin.validators[name];
 	if (propertyValidators == null || propertyValidators.length === 0) return true;
 	const { length } = propertyValidators;
 	for (let index = 0; index < length; index += 1) {
 		const validator = propertyValidators[index];
 		if (!validator(value)) {
-			validation.push({
+			parameters.information.push({
 				value,
-				key: { ...property.key },
-				message: getInvalidValidatorMessage(property, name, index, length),
+				key: {
+					full: parameters.prefix,
+					short: parameters.origin.key
+				},
+				message: getInvalidValidatorMessage(parameters.prefix, name, index, length),
 				validator
 			});
 			return false;
@@ -303,103 +306,121 @@ function validateNamed(property, name, value, validation) {
 	}
 	return true;
 }
-function validateObject(obj, properties, options, origin, validation) {
+function validateObject(obj, properties, parameters, get) {
 	if (!isPlainObject(obj)) {
-		const key = origin == null ? {
+		const key = parameters?.origin == null ? {
 			full: "",
 			short: ""
-		} : { ...origin.key };
+		} : {
+			full: parameters.prefix,
+			short: parameters.origin.key
+		};
 		const information = {
 			key,
-			message: origin == null ? getInvalidInputMessage(obj) : getInvalidTypeMessage({
-				...origin,
-				key
-			}, obj),
+			message: parameters?.origin == null ? getInvalidInputMessage(obj) : getInvalidTypeMessage(key.full, parameters.origin.types, obj),
 			value: obj
 		};
-		if (options.reporting.throw) throw new ValidationError([information]);
-		validation?.push(information);
-		return options.reporting.none ? false : [information];
+		if (parameters.reporting.throw) throw new ValidationError([information]);
+		parameters?.information?.push(information);
+		return parameters.reporting.none ? void 0 : [information];
 	}
-	if (options.strict) {
+	if (parameters.strict) {
 		const objKeys = Object.keys(obj);
-		const propertiesKeys = new Set(properties.map((property) => property.key.short));
+		const propertiesKeys = new Set(properties.map((property) => property.key));
 		const unknownKeys = objKeys.filter((key) => !propertiesKeys.has(key));
 		if (unknownKeys.length > 0) {
 			const information = {
-				key: origin == null ? {
+				key: parameters?.origin == null ? {
 					full: "",
 					short: ""
-				} : { ...origin.key },
-				message: getUnknownKeysMessage(unknownKeys.map((key) => join([origin?.key.full, key], "."))),
+				} : {
+					full: join([parameters.prefix, parameters.origin?.key], "."),
+					short: parameters.origin.key
+				},
+				message: getUnknownKeysMessage(unknownKeys.map((key) => join([parameters?.prefix, key], "."))),
 				value: obj
 			};
-			if (options.reporting.throw) throw new ValidationError([information]);
-			validation?.push(information);
-			return options.reporting.none ? false : [information];
+			if (parameters.reporting.throw) throw new ValidationError([information]);
+			parameters?.information?.push(information);
+			return parameters.reporting.none ? void 0 : [information];
 		}
 	}
 	const allInformation = [];
+	const output = {};
 	const propertiesLength = properties.length;
 	outer: for (let propertyIndex = 0; propertyIndex < propertiesLength; propertyIndex += 1) {
-		let property = properties[propertyIndex];
-		property = {
-			...property,
-			key: {
-				full: join([origin?.key.full, property.key.short], "."),
-				short: property.key.short
-			}
-		};
+		const property = properties[propertyIndex];
 		const { key, required, types } = property;
-		const value = obj[key.short];
+		const value = obj[key];
+		if (get && value === void 0 && !required) continue;
 		if (value === void 0 && required) {
+			const prefixedKey = join([parameters.prefix, key], ".");
 			const information = {
 				value,
-				key: { ...key },
-				message: getInvalidMissingMessage(property)
+				key: {
+					full: prefixedKey,
+					short: key
+				},
+				message: getInvalidMissingMessage(prefixedKey, property.types)
 			};
-			if (options.reporting.throw && validation == null) throw new ValidationError([information]);
-			if (validation != null) validation.push(information);
-			if (options.reporting.all) {
+			if (parameters.reporting.throw) throw new ValidationError([information]);
+			parameters?.information?.push(information);
+			if (parameters.reporting.all) {
 				allInformation.push(information);
 				continue;
 			}
-			return options.reporting.none ? false : [information];
+			return parameters.reporting.none ? void 0 : [information];
 		}
+		const prefixedKey = join([parameters.prefix, key], ".");
 		const typesLength = types.length;
 		const information = [];
 		for (let typeIndex = 0; typeIndex < typesLength; typeIndex += 1) {
 			const type = types[typeIndex];
-			if (validateValue(type, property, value, options, information)) continue outer;
+			if (validateValue(type, value, {
+				information,
+				output,
+				origin: property,
+				prefix: prefixedKey,
+				reporting: parameters.reporting,
+				strict: parameters.strict
+			}, get)) {
+				if (get) output[key] = clone(value);
+				continue outer;
+			}
 		}
 		if (information.length === 0) information.push({
 			value,
-			key: { ...key },
-			message: getInvalidTypeMessage(property, value)
+			key: {
+				full: prefixedKey,
+				short: key
+			},
+			message: getInvalidTypeMessage(prefixedKey, property.types, value)
 		});
-		if (options.reporting.throw && validation == null) throw new ValidationError(information);
-		validation?.push(...information);
-		if (options.reporting.all) {
+		if (parameters.reporting.throw) throw new ValidationError(information);
+		parameters?.information?.push(...information);
+		if (parameters.reporting.all) {
 			allInformation.push(...information);
 			continue;
 		}
-		return options.reporting.none ? false : information;
+		return parameters.reporting.none ? void 0 : information;
 	}
-	return options.reporting.none || allInformation.length === 0 ? true : allInformation;
+	if (get) if (parameters.origin == null) parameters.output = output;
+	else parameters.output[parameters.origin.key] = output;
+	return parameters.reporting.none || allInformation.length === 0 ? parameters.output : allInformation;
 }
-function validateSchematic(property, schematic, value, options, validation) {
-	const result = validateObject(value, schematicProperties.get(schematic), options, property, validation);
-	return typeof result === "boolean" ? result : result.length === 0;
+function validateSchematic(schematic, value, parameters, get) {
+	const result = validateObject(value, schematicProperties.get(schematic), parameters, get);
+	return result == null || Array.isArray(result) ? false : true;
 }
-function validateValue(type, property, value, options, validation) {
+function validateValue(type, value, parameters, get) {
 	switch (true) {
 		case typeof type === "function": return type(value);
 		case Array.isArray(type): {
-			const validated = validateObject(value, type, options, property, validation);
-			return typeof validated === "boolean" ? validated : false;
+			const result = validateObject(value, type, parameters, get);
+			return result == null || Array.isArray(result) ? false : true;
 		}
-		case isSchematic(type): return validateSchematic(property, type, value, options, validation);
-		default: return validateNamed(property, type, value, validation);
+		case isSchematic(type): return validateSchematic(type, value, parameters, get);
+		default: return validateNamed(type, value, parameters);
 	}
 }
 const validators = {
@@ -427,14 +448,19 @@ var Schematic = class {
 		this.#properties = properties;
 		schematicProperties.set(this, properties);
 	}
+	get(value, options) {
+		const parameters = getParameters(options);
+		const result = validateObject(value, this.#properties, parameters, true);
+		if (result == null) return;
+		if (!Array.isArray(result)) return parameters.reporting.none ? result : ok(result);
+		return error(parameters.reporting.all ? result : result[0]);
+	}
 	is(value, options) {
-		const { reporting, strict } = getOptions(options);
-		const result = validateObject(value, this.#properties, {
-			reporting,
-			strict
-		});
-		if (typeof result === "boolean") return result;
-		return error(reporting.all ? result : result[0]);
+		const parameters = getParameters(options);
+		const result = validateObject(value, this.#properties, parameters, false);
+		if (result == null) return false;
+		if (!Array.isArray(result)) return parameters.reporting.none ? true : ok(true);
+		return error(parameters.reporting.all ? result : result[0]);
 	}
 };
 function schematic(schema) {

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

@@ -1,6 +1,6 @@
 import { Schematic } from "../schematic.mjs";
 import { ValueName } from "./misc.model.mjs";
-import { GenericCallback } from "@oscarpalmer/atoms/models";
+import { GenericCallback, PlainObject } from "@oscarpalmer/atoms/models";
 
 //#region src/models/validation.model.d.ts
 /**
@@ -41,7 +41,7 @@ type ValidatedProperty = {
   /**
    * The property name in the schema
    */
-  key: ValidatedPropertyKey;
+  key: string;
   /**
    * Whether the property is required
    */
@@ -55,15 +55,6 @@ type ValidatedProperty = {
    */
   validators: ValidatedPropertyValidators;
 };
-/**
- * The full and short forms of a property's key path
- *
- * For a nested property `address.street`: `full` is `'address.street'`, `short` is `'street'`
- */
-type ValidatedPropertyKey = {
-  full: string;
-  short: string;
-};
 /**
  * A union of valid types for a {@link ValidatedProperty}'s `types` array
  *
@@ -93,9 +84,12 @@ type ValidationInformation = {
   value: unknown;
 };
 /**
- * Same shape as {@link ValidatedPropertyKey}; the key path of a failed property
+ *
  */
-type ValidationInformationKey = ValidatedPropertyKey;
+type ValidationInformationKey = {
+  full: string;
+  short: string;
+};
 /**
  * Options for validation
  */
@@ -109,9 +103,13 @@ type ValidationOptions<Errors extends ReportingType> = {
    */
   strict?: boolean;
 };
-type ValidationOptionsExtended = {
+type ValidationParameters = {
+  information?: ValidationInformation[];
+  origin?: ValidatedProperty;
+  output: PlainObject;
+  prefix?: string;
   reporting: ReportingInformation;
   strict: boolean;
 };
 //#endregion
-export { ReportingInformation, ReportingType, SchematicError, ValidatedProperty, ValidatedPropertyKey, ValidatedPropertyType, ValidatedPropertyValidators, ValidationError, ValidationInformation, ValidationInformationKey, ValidationOptions, ValidationOptionsExtended };
+export { ReportingInformation, ReportingType, SchematicError, ValidatedProperty, ValidatedPropertyType, ValidatedPropertyValidators, ValidationError, ValidationInformation, ValidationInformationKey, ValidationOptions, ValidationParameters };