@oscarpalmer/jhunal 0.10.0 → 0.12.0

package/types/constants.d.ts

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

package/types/index.d.ts

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

package/types/is.d.ts

@@ -1,4 +1,4 @@
 import type { Constructor } from './models';
 import type { Schematic } from './schematic';
-export declare function isInstance<Instance>(constructor: Constructor<Instance>): (value: unknown) => value is Instance;
+export declare function instanceOf<Instance>(constructor: Constructor<Instance>): (value: unknown) => value is Instance;
 export declare function isSchematic(value: unknown): value is Schematic<never>;

package/types/models.d.ts

@@ -1,4 +1,4 @@
-import type { PlainObject, Simplify } from '@oscarpalmer/atoms/models';
+import type { GenericCallback, PlainObject, Simplify } from '@oscarpalmer/atoms/models';
 import type { Schematic } from './schematic';
 export type Constructor<Instance = any> = new (...args: any[]) => Instance;
 type DeduplicateTuple<Value extends unknown[], Seen extends unknown[] = []> = Value extends [
@@ -23,8 +23,12 @@ type InferRequiredKeys<Model extends Schema> = keyof {
     [Key in keyof Model as IsOptionalProperty<Model[Key]> extends true ? never : Key]: never;
 };
 type InferSchemaEntry<Value> = Value extends (infer Item)[] ? InferSchemaEntryValue<Item> : InferSchemaEntryValue<Value>;
-type InferSchemaEntryValue<Value> = Value extends Constructor<infer Instance> ? Instance : Value extends Schematic<infer Model> ? Model : Value extends SchemaProperty ? InferPropertyType<Value['$type']> : Value extends ValueName ? Values[Value & ValueName] : Value extends Schema ? Infer<Value> : never;
-type IsOptionalProperty<Value> = Value extends SchemaProperty ? Value['$required'] extends false ? true : false : false;
+type InferSchemaEntryValue<Value> = Value extends Constructor<infer Instance> ? Instance : Value extends Schematic<infer Model> ? Model : Value extends SchemaProperty ? InferPropertyType<Value['$type']> : Value extends NestedSchema ? Infer<Omit<Value, '$required'>> : Value extends ValueName ? Values[Value & ValueName] : Value extends Schema ? Infer<Value> : never;
+type IsOptionalProperty<Value> = Value extends SchemaProperty ? Value['$required'] extends false ? true : false : Value extends {
+    $required?: boolean;
+} ? Value extends {
+    $required: false;
+} ? true : false : false;
 type LastOfUnion<Value> = UnionToIntersection<Value extends unknown ? () => Value : never> extends () => infer Item ? Item : never;
 type MapToValueTypes<Value extends unknown[]> = Value extends [infer Head, ...infer Tail] ? [ToValueType<Head>, ...MapToValueTypes<Tail>] : [];
 type MapToSchemaPropertyTypes<Value extends unknown[]> = Value extends [infer Head, ...infer Tail] ? [ToSchemaPropertyTypeEach<Head>, ...MapToSchemaPropertyTypes<Tail>] : [];
@@ -33,7 +37,8 @@ type MapToSchemaPropertyTypes<Value extends unknown[]> = Value extends [infer He
  */
 export type NestedSchema = {
     $required?: boolean;
-} & Schema;
+    [key: string]: any;
+};
 type OptionalKeys<Value> = {
     [Key in keyof Value]-?: {} extends Pick<Value, Key> ? Key : never;
 }[keyof Value];
@@ -45,9 +50,9 @@ type RequiredKeys<Value> = Exclude<keyof Value, OptionalKeys<Value>>;
  * A schema for validating objects
  */
 export type Schema = SchemaIndex;
-type SchemaEntry = Constructor | NestedSchema | SchemaProperty | Schematic<unknown> | ValueName;
+type SchemaEntry = Constructor | Schema | SchemaProperty | Schematic<unknown> | ValueName | ((value: unknown) => boolean);
 interface SchemaIndex {
-    [key: string]: SchemaEntry | SchemaEntry[];
+    [key: string]: NestedSchema | SchemaEntry | SchemaEntry[];
 }
 /**
  * A property definition with explicit type(s) and optional requirement flag
@@ -57,11 +62,14 @@ export type SchemaProperty = {
     $type: SchemaPropertyType | SchemaPropertyType[];
     $validators?: PropertyValidators<SchemaPropertyType | SchemaPropertyType[]>;
 };
-type SchemaPropertyType = Constructor | Schema | Schematic<unknown> | ValueName;
+type SchemaPropertyType = Constructor | Schema | Schematic<unknown> | ValueName | ((value: unknown) => boolean);
+export declare class SchematicError extends Error {
+    constructor(message: string);
+}
 type ToSchemaPropertyType<Value> = UnwrapSingle<DeduplicateTuple<MapToSchemaPropertyTypes<UnionToTuple<Value>>>>;
-type ToSchemaPropertyTypeEach<Value> = Value extends PlainObject ? TypedSchema<Value> : ToValueType<Value>;
+type ToSchemaPropertyTypeEach<Value> = Value extends NestedSchema ? Omit<Value, '$required'> : Value extends PlainObject ? TypedSchema<Value> : ToValueType<Value>;
 type ToSchemaType<Value> = UnwrapSingle<DeduplicateTuple<MapToValueTypes<UnionToTuple<Value>>>>;
-type ToValueType<Value> = Value extends unknown[] ? 'array' : Value extends bigint ? 'bigint' : Value extends boolean ? 'boolean' : Value extends Date ? 'date' : Value extends Function ? 'function' : Value extends null ? 'null' : Value extends number ? 'number' : Value extends object ? 'object' | ((value: unknown) => value is Value) : Value extends string ? 'string' : Value extends symbol ? 'symbol' : Value extends undefined ? 'undefined' : (value: unknown) => value is Value;
+type ToValueType<Value> = Value extends unknown[] ? 'array' : Value extends bigint ? 'bigint' : Value extends boolean ? 'boolean' : Value extends Date ? 'date' : Value extends Schematic<any> ? Value : Value extends Function ? 'function' : Value extends null ? 'null' : Value extends number ? 'number' : Value extends object ? 'object' | ((value: unknown) => value is Value) : Value extends string ? 'string' : Value extends symbol ? 'symbol' : Value extends undefined ? 'undefined' : (value: unknown) => value is Value;
 type TuplePermutations<Tuple extends unknown[], Elput extends unknown[] = []> = Tuple['length'] extends 0 ? Elput : {
     [Key in keyof Tuple]: TuplePermutations<TupleRemoveAt<Tuple, Key & `${number}`>, [
         ...Elput,
@@ -101,9 +109,9 @@ export type TypedPropertyRequired<Value> = {
  * Create a schema type constrained to match a TypeScript type
  */
 export type TypedSchema<Model extends PlainObject> = Simplify<{
-    [Key in RequiredKeys<Model>]: Model[Key] extends PlainObject ? TypedSchemaRequired<Model[Key]> : ToSchemaType<Model[Key]> | TypedPropertyRequired<Model[Key]>;
+    [Key in RequiredKeys<Model>]: Model[Key] extends PlainObject ? TypedSchemaRequired<Model[Key]> | Schematic<Model[Key]> : ToSchemaType<Model[Key]> | TypedPropertyRequired<Model[Key]>;
 } & {
-    [Key in OptionalKeys<Model>]: Exclude<Model[Key], undefined> extends PlainObject ? TypedSchemaOptional<Exclude<Model[Key], undefined>> : TypedPropertyOptional<Model[Key]>;
+    [Key in OptionalKeys<Model>]: Exclude<Model[Key], undefined> extends PlainObject ? TypedSchemaOptional<Exclude<Model[Key], undefined>> | Schematic<Exclude<Model[Key], undefined>> : TypedPropertyOptional<Model[Key]>;
 }>;
 type TypedSchemaOptional<Model extends PlainObject> = {
     $required: false;
@@ -115,22 +123,20 @@ type UnionToIntersection<Value> = (Value extends unknown ? (value: Value) => voi
 type UnionToTuple<Value, Items extends unknown[] = []> = [Value] extends [never] ? Items : UnionToTuple<Exclude<Value, LastOfUnion<Value>>, [LastOfUnion<Value>, ...Items]>;
 type UnwrapSingle<Value extends unknown[]> = Value extends [infer Only] ? Only : Value['length'] extends 1 | 2 | 3 | 4 | 5 ? TuplePermutations<Value> : Value;
 export type ValidatedProperty = {
+    key: ValidatedPropertyKey;
     required: boolean;
     types: ValidatedPropertyType[];
     validators: ValidatedPropertyValidators;
 };
-export type ValidatedPropertyType = Schematic<unknown> | ValueName;
+export type ValidatedPropertyKey = {
+    full: string;
+    prefix: string | undefined;
+    value: string;
+};
+export type ValidatedPropertyType = GenericCallback | Schematic<unknown> | ValueName;
 export type ValidatedPropertyValidators = {
     [Key in ValueName]?: Array<(value: unknown) => boolean>;
 };
-export type ValidatedSchema = {
-    enabled: boolean;
-    keys: {
-        array: string[];
-        set: Set<string>;
-    };
-    properties: Record<string, ValidatedProperty>;
-};
 /**
  * Valid type name strings
  */

package/types/schematic.d.ts

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

package/types/validation/property.validation.d.ts

@@ -0,0 +1,3 @@
+import type { PlainObject } from '@oscarpalmer/atoms/models';
+import { type ValidatedProperty } from '../models';
+export declare function getProperties(original: PlainObject): ValidatedProperty[];

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

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

package/dist/node_modules/@oscarpalmer/atoms/dist/internal/array/compact.js

@@ -1,12 +0,0 @@
-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;
-}
-export { compact };

package/dist/node_modules/@oscarpalmer/atoms/dist/internal/is.js

@@ -1,20 +0,0 @@
-/**
-* Is the value an array or a record?
-* @param value Value to check
-* @returns `true` if the value is an array or a record, otherwise `false`
-*/
-function isArrayOrPlainObject(value) {
-	return Array.isArray(value) || isPlainObject(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;
-}
-export { isArrayOrPlainObject };

package/dist/node_modules/@oscarpalmer/atoms/dist/internal/string.js

@@ -1,24 +0,0 @@
-import { compact } from "./array/compact.js";
-/**
-* 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 : "");
-}
-export { join };

package/dist/node_modules/@oscarpalmer/atoms/dist/value/smush.js

@@ -1,36 +0,0 @@
-import { isArrayOrPlainObject } from "../internal/is.js";
-import { join } from "../internal/string.js";
-function flattenObject(value, depth, smushed, prefix) {
-	if (depth >= MAX_DEPTH) return {};
-	if (smushed.has(value)) return smushed.get(value);
-	const keys = Object.keys(value);
-	const { length } = keys;
-	const flattened = {};
-	for (let index = 0; index < length; index += 1) {
-		const key = keys[index];
-		const val = value[key];
-		if (isArrayOrPlainObject(val)) {
-			const prefixedKey = join([prefix, key], ".");
-			flattened[prefixedKey] = Array.isArray(val) ? [...val] : { ...val };
-			const nested = flattenObject(val, depth + 1, smushed, prefixedKey);
-			const nestedKeys = Object.keys(nested);
-			const nestedLength = nestedKeys.length;
-			for (let nestedIndex = 0; nestedIndex < nestedLength; nestedIndex += 1) {
-				const nestedKey = nestedKeys[nestedIndex];
-				flattened[nestedKey] = nested[nestedKey];
-			}
-		} else flattened[join([prefix, key], ".")] = val;
-	}
-	smushed.set(value, flattened);
-	return flattened;
-}
-/**
-* Smush an object into a flat object that uses dot notation keys
-* @param value Object to smush
-* @returns Smushed object with dot notation keys
-*/
-function smush(value) {
-	return typeof value === "object" && value !== null ? flattenObject(value, 0, /* @__PURE__ */ new WeakMap()) : {};
-}
-var MAX_DEPTH = 100;
-export { smush };

package/dist/validation/schema.validation.js

@@ -1,92 +0,0 @@
-import { EXPRESSION_HAS_NUMBER, EXPRESSION_INDEX, EXPRESSION_PROPERTY, PROPERTY_REQUIRED, PROPERTY_TYPE, PROPERTY_VALIDATORS, TYPE_ALL, TYPE_OBJECT, TYPE_UNDEFINED } from "../constants.js";
-import { isInstance, isSchematic } from "../is.js";
-import { smush } from "../node_modules/@oscarpalmer/atoms/dist/value/smush.js";
-import { isConstructor } from "@oscarpalmer/atoms/is";
-function addPropertyType(to, key, values, validators, required) {
-	if (to.keys.set.has(key)) {
-		const property = to.properties[key];
-		for (const type of values) if (!property.types.includes(type)) property.types.push(type);
-	} else {
-		to.keys.array.push(key);
-		to.keys.set.add(key);
-		to.properties[key] = {
-			required,
-			types: values,
-			validators: {}
-		};
-	}
-	if (!required && !to.properties[key].types.includes("undefined")) to.properties[key].types.push(TYPE_UNDEFINED);
-	to.properties[key].validators = validators;
-}
-function getSchema(schema) {
-	const validated = {
-		enabled: false,
-		keys: {
-			array: [],
-			set: /* @__PURE__ */ new Set()
-		},
-		properties: {}
-	};
-	return typeof schema === "object" && schema !== null ? getValidatedSchema(schema, validated) : validated;
-}
-function getTypes(value, validated, prefix) {
-	const propertyTypes = [];
-	const values = Array.isArray(value) ? value : [value];
-	const { length } = values;
-	for (let index = 0; index < length; index += 1) {
-		const type = values[index];
-		const typeOfType = typeof type;
-		if (isSchematic(type) || typeOfType === "string" && TYPE_ALL.has(type)) {
-			propertyTypes.push(type);
-			continue;
-		}
-		if (typeOfType === "function") {
-			propertyTypes.push(isConstructor(type) ? isInstance(type) : type);
-			continue;
-		}
-		if (typeOfType !== "object" || type === null) continue;
-		if ("$type" in type) {
-			propertyTypes.push(...getTypes(type[PROPERTY_TYPE], validated, prefix));
-			continue;
-		}
-		addPropertyType(validated, prefix, [TYPE_OBJECT], {}, type[PROPERTY_REQUIRED] !== false);
-		propertyTypes.push(TYPE_OBJECT);
-		getValidatedSchema(type, validated, prefix);
-	}
-	return propertyTypes;
-}
-function getValidatedSchema(schema, validated, prefix) {
-	const smushed = smush(schema);
-	const keys = Object.keys(smushed);
-	const { length } = keys;
-	const arrayKeys = /* @__PURE__ */ new Set();
-	const noPrefix = prefix == null;
-	prefix = noPrefix ? "" : `${prefix}.`;
-	for (let index = 0; index < length; index += 1) {
-		const key = keys[index];
-		const value = smushed[key];
-		if (Array.isArray(value)) arrayKeys.add(key);
-		if (EXPRESSION_PROPERTY.test(key)) continue;
-		if (EXPRESSION_HAS_NUMBER.test(key) && arrayKeys.has(key.replace(EXPRESSION_INDEX, ""))) continue;
-		let required = true;
-		let validators = {};
-		const isObject = typeof value === "object" && value !== null;
-		if (isObject && "$required" in value) required = typeof value["$required"] === "boolean" ? value[PROPERTY_REQUIRED] : true;
-		if (isObject && "$validators" in value) validators = getValidators(value[PROPERTY_VALIDATORS]);
-		const prefixedKey = `${prefix}${key}`;
-		const types = getTypes(value, validated, prefixedKey);
-		if (types.length > 0) addPropertyType(validated, prefixedKey, types, validators, required);
-	}
-	if (noPrefix) validated.keys.array.sort();
-	return validated;
-}
-function getValidators(original) {
-	const validators = {};
-	if (typeof original !== "object" || original === null) return validators;
-	for (const type of TYPE_ALL) {
-		const value = original[type];
-		validators[type] = (Array.isArray(value) ? value : [value]).filter((validator) => typeof validator === "function");
-	}
-	return validators;
-}
-export { getSchema };

package/src/validation/schema.validation.ts

@@ -1,192 +0,0 @@
-import {isConstructor} from '@oscarpalmer/atoms/is';
-import type {PlainObject} from '@oscarpalmer/atoms/models';
-import {smush} from '@oscarpalmer/atoms/value/misc';
-import {
-	EXPRESSION_HAS_NUMBER,
-	EXPRESSION_INDEX,
-	EXPRESSION_PROPERTY,
-	PROPERTY_REQUIRED,
-	PROPERTY_TYPE,
-	PROPERTY_VALIDATORS,
-	TYPE_ALL,
-	TYPE_OBJECT,
-	TYPE_UNDEFINED,
-} from '../constants';
-import {isInstance, isSchematic} from '../is';
-import type {
-	Schema,
-	ValidatedPropertyType,
-	ValidatedPropertyValidators,
-	ValidatedSchema,
-} from '../models';
-
-function addPropertyType(
-	to: ValidatedSchema,
-	key: string,
-	values: ValidatedPropertyType[],
-	validators: ValidatedPropertyValidators,
-	required: boolean,
-): void {
-	if (to.keys.set.has(key)) {
-		const property = to.properties[key];
-
-		for (const type of values) {
-			if (!property.types.includes(type)) {
-				property.types.push(type);
-			}
-		}
-	} else {
-		to.keys.array.push(key);
-		to.keys.set.add(key);
-
-		to.properties[key] = {
-			required,
-			types: values,
-			validators: {},
-		};
-	}
-
-	if (!required && !to.properties[key].types.includes(TYPE_UNDEFINED)) {
-		to.properties[key].types.push(TYPE_UNDEFINED);
-	}
-
-	to.properties[key].validators = validators;
-}
-
-export function getSchema(schema: unknown): ValidatedSchema {
-	const validated: ValidatedSchema = {
-		enabled: false,
-		keys: {
-			array: [],
-			set: new Set<string>(),
-		},
-		properties: {},
-	};
-
-	return typeof schema === 'object' && schema !== null
-		? getValidatedSchema(schema as Schema, validated)
-		: validated;
-}
-
-function getTypes(
-	value: unknown,
-	validated: ValidatedSchema,
-	prefix: string,
-): ValidatedPropertyType[] {
-	const propertyTypes: ValidatedPropertyType[] = [];
-
-	const values = Array.isArray(value) ? value : [value];
-	const {length} = values;
-
-	for (let index = 0; index < length; index += 1) {
-		const type = values[index];
-		const typeOfType = typeof type;
-
-		if (isSchematic(type) || (typeOfType === 'string' && TYPE_ALL.has(type as never))) {
-			propertyTypes.push(type as never);
-
-			continue;
-		}
-
-		if (typeOfType === 'function') {
-			propertyTypes.push(isConstructor(type) ? isInstance(type) : type);
-
-			continue;
-		}
-
-		if (typeOfType !== 'object' || type === null) {
-			continue;
-		}
-
-		if (PROPERTY_TYPE in type) {
-			propertyTypes.push(...getTypes(type[PROPERTY_TYPE], validated, prefix));
-
-			continue;
-		}
-
-		addPropertyType(validated, prefix, [TYPE_OBJECT], {}, type[PROPERTY_REQUIRED] !== false);
-
-		propertyTypes.push(TYPE_OBJECT);
-
-		getValidatedSchema(type as Schema, validated, prefix);
-	}
-
-	return propertyTypes;
-}
-
-function getValidatedSchema(
-	schema: Schema,
-	validated: ValidatedSchema,
-	prefix?: string,
-): ValidatedSchema {
-	const smushed = smush(schema as PlainObject);
-	const keys = Object.keys(smushed);
-	const {length} = keys;
-
-	const arrayKeys = new Set<string>();
-	const noPrefix = prefix == null;
-
-	prefix = noPrefix ? '' : `${prefix}.`;
-
-	for (let index = 0; index < length; index += 1) {
-		const key = keys[index];
-		const value = smushed[key];
-
-		if (Array.isArray(value)) {
-			arrayKeys.add(key);
-		}
-
-		if (EXPRESSION_PROPERTY.test(key)) {
-			continue;
-		}
-
-		if (EXPRESSION_HAS_NUMBER.test(key) && arrayKeys.has(key.replace(EXPRESSION_INDEX, ''))) {
-			continue;
-		}
-
-		let required = true;
-		let validators: ValidatedPropertyValidators = {};
-
-		const isObject = typeof value === 'object' && value !== null;
-
-		if (isObject && PROPERTY_REQUIRED in value) {
-			required = typeof value[PROPERTY_REQUIRED] === 'boolean' ? value[PROPERTY_REQUIRED] : true;
-		}
-
-		if (isObject && PROPERTY_VALIDATORS in value) {
-			validators = getValidators(value[PROPERTY_VALIDATORS]);
-		}
-
-		const prefixedKey = `${prefix}${key}`;
-
-		const types = getTypes(value, validated, prefixedKey);
-
-		if (types.length > 0) {
-			addPropertyType(validated, prefixedKey, types, validators, required);
-		}
-	}
-
-	if (noPrefix) {
-		validated.keys.array.sort();
-	}
-
-	return validated;
-}
-
-function getValidators(original: unknown): ValidatedPropertyValidators {
-	const validators: ValidatedPropertyValidators = {};
-
-	if (typeof original !== 'object' || original === null) {
-		return validators;
-	}
-
-	for (const type of TYPE_ALL) {
-		const value = (original as PlainObject)[type];
-
-		validators[type] = (Array.isArray(value) ? value : [value]).filter(
-			validator => typeof validator === 'function',
-		);
-	}
-
-	return validators;
-}

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

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