typia 8.0.3 → 8.1.0

package/lib/factories/internal/metadata/emend_metadata_atomics.d.mts

@@ -0,0 +1,2 @@
+import { Metadata } from "../../../schemas/metadata/Metadata";
+export declare const emend_metadata_atomics: (meta: Metadata) => void;

package/lib/factories/internal/metadata/emplace_metadata_alias.d.mts

@@ -0,0 +1,3 @@
+import { MetadataAliasType } from "../../../schemas/metadata/MetadataAliasType";
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
+export declare const emplace_metadata_alias: (props: IMetadataIteratorProps) => MetadataAliasType;

package/lib/factories/internal/metadata/emplace_metadata_array_type.d.mts

@@ -0,0 +1,8 @@
+import ts from "typescript";
+import { MetadataArrayType } from "../../../schemas/metadata/MetadataArrayType";
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
+interface IProps extends IMetadataIteratorProps {
+    array: ts.Type;
+}
+export declare const emplace_metadata_array_type: (props: IProps) => MetadataArrayType;
+export {};

package/lib/factories/internal/metadata/emplace_metadata_object.d.mts

@@ -0,0 +1,3 @@
+import { MetadataObjectType } from "../../../schemas/metadata/MetadataObjectType";
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
+export declare const emplace_metadata_object: (props: IMetadataIteratorProps) => MetadataObjectType;

package/lib/factories/internal/metadata/emplace_metadata_tuple.d.mts

@@ -0,0 +1,4 @@
+import ts from "typescript";
+import { MetadataTupleType } from "../../../schemas/metadata/MetadataTupleType";
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
+export declare const emplace_metadata_tuple: (props: IMetadataIteratorProps<ts.TupleType>) => MetadataTupleType;

package/lib/factories/internal/metadata/explore_metadata.d.mts

@@ -0,0 +1,8 @@
+import ts from "typescript";
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
+export declare const explore_metadata: (props: Required<IProps>) => Metadata;
+interface IProps extends Omit<IMetadataIteratorProps, "metadata" | "type"> {
+    type: ts.Type | null;
+}
+export {};

package/lib/factories/internal/metadata/iterate_metadata.d.mts

@@ -0,0 +1,2 @@
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
+export declare const iterate_metadata: (props: IMetadataIteratorProps) => void;

package/lib/factories/internal/metadata/iterate_metadata_alias.d.mts

@@ -0,0 +1,2 @@
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
+export declare const iterate_metadata_alias: (props: IMetadataIteratorProps) => boolean;

package/lib/factories/internal/metadata/iterate_metadata_array.d.mts

@@ -0,0 +1,2 @@
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
+export declare const iterate_metadata_array: (props: IMetadataIteratorProps) => boolean;

package/lib/factories/internal/metadata/iterate_metadata_atomic.d.mts

@@ -0,0 +1,6 @@
+import ts from "typescript";
+import { Metadata } from "../../../schemas/metadata/Metadata";
+export declare const iterate_metadata_atomic: (props: {
+    metadata: Metadata;
+    type: ts.Type;
+}) => boolean;

package/lib/factories/internal/metadata/iterate_metadata_coalesce.d.mts

@@ -0,0 +1,6 @@
+import ts from "typescript";
+import { Metadata } from "../../../schemas/metadata/Metadata";
+export declare const iterate_metadata_coalesce: (props: {
+    metadata: Metadata;
+    type: ts.Type;
+}) => boolean;

package/lib/factories/internal/metadata/iterate_metadata_collection.d.mts

@@ -0,0 +1,6 @@
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+export declare const iterate_metadata_collection: (props: {
+    errors: MetadataFactory.IError[];
+    collection: MetadataCollection;
+}) => void;

package/lib/factories/internal/metadata/iterate_metadata_comment_tags.d.mts

@@ -0,0 +1,6 @@
+import { MetadataObjectType } from "../../../schemas/metadata/MetadataObjectType";
+import { MetadataFactory } from "../../MetadataFactory";
+export declare const iterate_metadata_comment_tags: (props: {
+    errors: MetadataFactory.IError[];
+    object: MetadataObjectType;
+}) => void;

package/lib/factories/internal/metadata/iterate_metadata_constant.d.mts

@@ -0,0 +1,2 @@
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
+export declare const iterate_metadata_constant: (props: IMetadataIteratorProps) => boolean;

package/lib/factories/internal/metadata/iterate_metadata_escape.d.mts

@@ -0,0 +1,2 @@
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
+export declare const iterate_metadata_escape: (props: IMetadataIteratorProps) => boolean;

package/lib/factories/internal/metadata/iterate_metadata_function.d.mts

@@ -0,0 +1,2 @@
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
+export declare const iterate_metadata_function: (props: IMetadataIteratorProps) => boolean;

package/lib/factories/internal/metadata/iterate_metadata_intersection.d.mts

@@ -0,0 +1,2 @@
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
+export declare const iterate_metadata_intersection: (props: IMetadataIteratorProps) => boolean;

package/lib/factories/internal/metadata/iterate_metadata_map.d.mts

@@ -0,0 +1,2 @@
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
+export declare const iterate_metadata_map: (props: IMetadataIteratorProps) => boolean;

package/lib/factories/internal/metadata/iterate_metadata_native.d.mts

@@ -0,0 +1,2 @@
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
+export declare const iterate_metadata_native: (props: IMetadataIteratorProps) => boolean;

package/lib/factories/internal/metadata/iterate_metadata_object.d.mts

@@ -0,0 +1,2 @@
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
+export declare const iterate_metadata_object: (props: IMetadataIteratorProps, ensure?: boolean) => boolean;

package/lib/factories/internal/metadata/iterate_metadata_set.d.mts

@@ -0,0 +1,2 @@
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
+export declare const iterate_metadata_set: (props: IMetadataIteratorProps) => boolean;

package/lib/factories/internal/metadata/iterate_metadata_sort.d.mts

@@ -0,0 +1,6 @@
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataCollection } from "../../MetadataCollection";
+export declare const iterate_metadata_sort: (props: {
+    collection: MetadataCollection;
+    metadata: Metadata;
+}) => void;

package/lib/factories/internal/metadata/iterate_metadata_template.d.mts

@@ -0,0 +1,2 @@
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
+export declare const iterate_metadata_template: (props: IMetadataIteratorProps) => boolean;

package/lib/factories/internal/metadata/iterate_metadata_tuple.d.mts

@@ -0,0 +1,3 @@
+import ts from "typescript";
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
+export declare const iterate_metadata_tuple: (props: IMetadataIteratorProps<ts.TupleType>) => boolean;

package/lib/factories/internal/metadata/iterate_metadata_union.d.mts

@@ -0,0 +1,2 @@
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
+export declare const iterate_metadata_union: (props: IMetadataIteratorProps) => boolean;

package/lib/functional.d.mts

@@ -0,0 +1,490 @@
+import { IValidation } from "./IValidation";
+import { TypeGuardError } from "./TypeGuardError";
+/**
+ * Asserts a function.
+ *
+ * Asserts a function, by wrapping the function and checking its parameters and
+ * return value through {@link assert} function. If some parameter or return value
+ * does not match the expected type, it throws an {@link TypeGuardError} or a custom
+ * error generated by the *errorFactory* parameter.
+ *
+ * For reference, {@link TypeGuardError.path} would be a little bit different with
+ * individual {@link assert} function. If the {@link TypeGuardError} occurs from
+ * some parameter, the path would start from `$input.parameters[number]`. Otherwise
+ * the path would start from `$input.return`.
+ *
+ * - `$input.parameters[0].~`
+ * - `$input.return.~`
+ *
+ * By the way, if what you want is not just finding the 1st type error through
+ * assertion, but also finding every type errors, then use {@link validateFunction}
+ * instead. Otherwise, what you want is just asserting parameters or return value
+ * only, you can use {@link assertParameters} or {@link assertReturn} instead.
+ *
+ * On the other hand, if don't want to allow any superfluous properties, utilize
+ * {@link assertEqualsFunction} or {@link validateEqualsFunction} instead.
+ *
+ * @template T Target function type
+ * @param func Target function to assert
+ * @param errorFactory Custom error factory. Default is `TypeGuardError`
+ * @returns The wrapper function with type assertions
+ * @throws A {@link TypeGuardError} or a custom error generated by *errorFactory*
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function assertFunction<T extends (...args: any[]) => any>(func: T, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): T;
+/**
+ * Asserts parameters.
+ *
+ * Asserts a function, by wrapping the function and checking its parameters through
+ * {@link assert} function. If some parameter does not match the expected type, it
+ * throws an {@link TypeGuardError} or a custom error generated by the *errorFactory*
+ * parameter.
+ *
+ * For reference, {@link TypeGuardError.path} would be a little bit different with
+ * individual {@link assert} function. If the {@link TypeGuardError} occurs from
+ * some parameter, the path would start from `$input.parameters[number]`.
+ *
+ * By the way, if what you want is not just finding the 1st type error through
+ * assertion, but also finding every type errors, then use {@link validateParameters}
+ * instead. Otherwise, what you want is not only asserting parameters, but also
+ * asserting return value, you can use {@link assertFunction} instead.
+ *
+ * On the other hand, if don't want to allow any superfluous properties, utilize
+ * {@link assertEqualsParameters} or {@link validateEqualsParameters} instead.
+ *
+ * @template T Target function type
+ * @param func Target function to assert
+ * @param errorFactory Custom error factory. Default is `TypeGuardError`
+ * @returns The wrapper function with type assertions
+ * @throws A {@link TypeGuardError} or a custom error generated by *errorFactory*
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function assertParameters<T extends (...args: any[]) => any>(func: T, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): T;
+/**
+ * Asserts return value.
+ *
+ * Asserts a function, by wrapping the function and checking its return value through
+ * {@link assert} function. If the return value does not match the expected type, it
+ * throws an {@link TypeGuardError} or a custom error generated by the *errorFactory*
+ * parameter.
+ *
+ * For reference, {@link TypeGuardError.path} would be a little bit different with
+ * individual {@link assert} function. If the {@link TypeGuardError} occurs from
+ * the return value, the path would start from `$input.return`.
+ *
+ * By the way, if what you want is not just finding the 1st type error through
+ * assertion, but also finding every type errors, then use {@link validateReturn}
+ * instead. Otherwise, what you want is not only asserting return value, but also
+ * asserting parameters, you can use {@link assertFunction} instead.
+ *
+ * On the other hand, if don't want to allow any superfluous properties, utilize
+ * {@link assertEqualsReturn} or {@link validateEqualsReturn} instead.
+ *
+ * @template T Target function type
+ * @param func Target function to assert
+ * @param errorFactory Custom error factory. Default is `TypeGuardError`
+ * @returns The wrapper function with type assertions
+ * @throws A {@link TypeGuardError} or a custom error generated by *errorFactory*
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function assertReturn<T extends (...args: any[]) => any>(func: T, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): T;
+/**
+ * Asserts a function with strict equality.
+ *
+ * Asserts a function with strict equality, by wrapping the function and checking
+ * its parameters and return value through {@link assertEquals} function. If some
+ * parameter or return value does not match the expected type, it throws an
+ * {@link TypeGuardError} or a custom error generated by the *errorFactory* parameter.
+ *
+ * For reference, {@link TypeGuardError.path} would be a little bit different with
+ * individual {@link assertEquals} function. If the {@link TypeGuardError} occurs from
+ * some parameter, the path would start from `$input.parameters[number]`. Otherwise
+ * the path would start from `$input.return`.
+ *
+ * - `$input.parameters[0].~`
+ * - `$input.return.~`
+ *
+ * By the way, if what you want is not just finding the 1st type error through
+ * assertion, but also finding every type errors, then use
+ * {@link validateEqualsFunction} instead. Otherwise, what you want is just asserting
+ * parameters or return value only, you can use {@link assertEqualsParameters} or
+ * {@link assertEqualsReturn} instead.
+ *
+ * On the other hand, if you want to allow any superfluous properties, utilize
+ * {@link assertFunction} or {@link validateFunction} instead.
+ *
+ * @template T Target function type
+ * @param func Target function to assert
+ * @param errorFactory Custom error factory. Default is `TypeGuardError`
+ * @returns The wrapper function with type assertions
+ * @throws A {@link TypeGuardError} or a custom error generated by *errorFactory*
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function assertEqualsFunction<T extends (...args: any[]) => any>(func: T, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): T;
+/**
+ * Asserts parameters with strict equality.
+ *
+ * Asserts a function, by wrapping the function and checking its parameters through
+ * {@link assertEquals} function. If some parameter does not match the expected type,
+ * it throws an {@link TypeGuardError} or a custom error generated by the *errorFactory*
+ * parameter.
+ *
+ * For reference, {@link TypeGuardError.path} would be a little bit different with
+ * individual {@link assertEquals} function. If the {@link TypeGuardError} occurs from
+ * some parameter, the path would start from `$input.parameters[number]`.
+ *
+ * By the way, if what you want is not just finding the 1st type error through
+ * assertion, but also finding every type errors, then use
+ * {@link validateEqualsParameters} instead. Otherwise, what you want is not only
+ * asserting parameters, but also asserting return value, you can use
+ * {@link assertEqualsFunction} instead.
+ *
+ * On the other hand, if you want to allow any superfluous properties, utilize
+ * {@link assertParameters} or {@link validateParameters} instead.
+ *
+ * @template T Target function type
+ * @param func Target function to assert
+ * @param errorFactory Custom error factory. Default is `TypeGuardError`
+ * @returns The wrapper function with type assertions
+ * @throws A {@link TypeGuardError} or a custom error generated by *errorFactory*
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function assertEqualsParameters<T extends (...args: any[]) => any>(func: T, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): T;
+/**
+ * Asserts return value with strict equality.
+ *
+ * Asserts a function, by wrapping the function and checking its return value through
+ * {@link assertEquals} function. If the return value does not match the expected type,
+ * it throws an {@link TypeGuardError} or a custom error generated by the *errorFactory*
+ * parameter.
+ *
+ * For reference, {@link TypeGuardError.path} would be a little bit different with
+ * individual {@link assertEquals} function. If the {@link TypeGuardError} occurs from
+ * the return value, the path would start from `$input.return`.
+ *
+ * By the way, if what you want is not just finding the 1st type error through
+ * assertion, but also finding every type errors, then use {@link validateEqualsReturn}
+ * instead. Otherwise, what you want is not only asserting return value, but also
+ * asserting parameters, you can use {@link assertEqualsFunction} instead.
+ *
+ * On the other hand, if you want to allow any superfluous properties, utilize
+ * {@link assertReturn} or {@link validateReturn} instead.
+ *
+ * @template T Target function type
+ * @param func Target function to assert
+ * @param errorFactory Custom error factory. Default is `TypeGuardError`
+ * @returns The wrapper function with type assertions
+ * @throws A {@link TypeGuardError} or a custom error generated by *errorFactory*
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function assertEqualsReturn<T extends (...args: any[]) => any>(func: T, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): T;
+/**
+ * Tests a function.
+ *
+ * Tests a function, by wrapping the function and checking its parameters and
+ * return value through {@link is} function. If some parameter or return value
+ * does not match the expected type, it returns `null`. Otherwise there's no
+ * type error, it returns the result of the function.
+ *
+ * By the way, if you want is not just testing type checking, but also finding
+ * detailed type error reason(s), then use {@link assertFunction} or
+ * {@link validateFunction} instead.
+ *
+ * On the other hand, if you don't want to allow any superfluous properties,
+ * utilize {@link equalsFunction}, {@link assertEqualsFunction} or
+ * {@link validateEqualsFunction} instead.
+ *
+ * @template T Target function type
+ * @param func Target function to test
+ * @returns The wrapper function with type tests
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function isFunction<T extends (...args: any[]) => any>(func: T): T extends (...args: infer Arguments) => infer Output ? Output extends Promise<infer R> ? (...args: Arguments) => Promise<R | null> : (...args: Arguments) => Output | null : never;
+/**
+ * Tests parameters.
+ *
+ * Tests a function, by wrapping the function and checking its parameters through
+ * {@link is} function. If some parameter does not match the expected type, it
+ * returns `null`. Otherwise there's no type error, it returns the result of the
+ * function.
+ *
+ * By the way, if you want is not just testing type checking, but also finding
+ * detailed type error reason(s), then use {@link assertParameters} or
+ * {@link validateParameters} instead.
+ *
+ * On the other hand, if you don't want to allow any superfluous properties,
+ * utilize {@link equalsParameters}, {@link assertEqualsParameters} or
+ * {@link validateEqualsParameters} instead.
+ *
+ * @template T Target function type
+ * @param func Target function to test
+ * @returns The wrapper function with type tests
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function isParameters<T extends (...args: any[]) => any>(func: T): T extends (...args: infer Arguments) => infer Output ? Output extends Promise<infer R> ? (...args: Arguments) => Promise<R | null> : (...args: Arguments) => Output | null : never;
+/**
+ * Tests return value.
+ *
+ * Tests a function, by wrapping the function and checking its return value through
+ * {@link is} function. If the return value does not match the expected type, it
+ * returns `null`. Otherwise there's no type error, it returns the result of the
+ * function.
+ *
+ * By the way, if you want is not just testing type checking, but also finding
+ * detailed type error reason(s), then use {@link assertReturn} or
+ * {@link validateReturn} instead.
+ *
+ * On the other hand, if you don't want to allow any superfluous properties,
+ * utilize {@link equalsReturn}, {@link assertEqualsReturn} or
+ * {@link validateEqualsReturn} instead.
+ *
+ * @template T Target function type
+ * @param func Target function to test
+ * @returns The wrapper function with type tests
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function isReturn<T extends (...args: any[]) => any>(func: T): T extends (...args: infer Arguments) => infer Output ? Output extends Promise<infer R> ? (...args: Arguments) => Promise<R | null> : (...args: Arguments) => Output | null : never;
+/**
+ * Tests a function with strict equality.
+ *
+ * Tests a function with strict equality, by wrapping the function and checking its
+ * parameters and return value through {@link isEquals} function. If some parameter
+ * or return value does not match the expected type, it returns `null`. Otherwise
+ * there's no type error, it returns the result of the function.
+ *
+ * By the way, if you want is not just testing type checking, but also finding
+ * detailed type error reason(s), then use {@link assertEqualsFunction} or
+ * {@link validateEqualsFunction} instead.
+ *
+ * On the other hand, if you want to allow any superfluous properties, utilize
+ * {@link isFunction}, {@link assertFunction} or {@link validateFunction} instead.
+ *
+ * @template T Target function type
+ * @param func Target function to test
+ * @returns The wrapper function with type tests
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function equalsFunction<T extends (...args: any[]) => any>(func: T): T extends (...args: infer Arguments) => infer Output ? Output extends Promise<infer R> ? (...args: Arguments) => Promise<R | null> : (...args: Arguments) => Output | null : never;
+/**
+ * Tests parameters with strict equality.
+ *
+ * Tests a function, by wrapping the function and checking its parameters through
+ * {@link isEquals} function. If some parameter does not match the expected type,
+ * it returns `null`. Otherwise there's no type error, it returns the result of the
+ * function.
+ *
+ * By the way, if you want is not just testing type checking, but also finding
+ * detailed type error reason(s), then use {@link assertEqualsParameters} or
+ * {@link validateEqualsParameters} instead.
+ *
+ * @template T Target function type
+ * @param func Target function to test
+ * @returns The wrapper function with type tests
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function equalsParameters<T extends (...args: any[]) => any>(func: T): T extends (...args: infer Arguments) => infer Output ? Output extends Promise<infer R> ? (...args: Arguments) => Promise<R | null> : (...args: Arguments) => Output | null : never;
+/**
+ * Tests return value with strict equality.
+ *
+ * Tests a function, by wrapping the function and checking its return value through
+ * {@link isEquals} function. If the return value does not match the expected type,
+ * it returns `null`. Otherwise there's no type error, it returns the result of the
+ * function.
+ *
+ * By the way, if you want is not just testing type checking, but also finding
+ * detailed type error reason(s), then use {@link assertEqualsReturn} or
+ * {@link validateEqualsReturn} instead.
+ *
+ * On the other hand, if you want to allow any superfluous properties, utilize
+ * {@link isReturn}, {@link assertReturn} or {@link validateReturn} instead.
+ *
+ * @template T Target function type
+ * @param func Target function to test
+ * @returns The wrapper function with type tests
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function equalsReturn<T extends (...args: any[]) => any>(func: T): T extends (...args: infer Arguments) => infer Output ? Output extends Promise<infer R> ? (...args: Arguments) => Promise<R | null> : (...args: Arguments) => Output | null : never;
+/**
+ * Validates a function.
+ *
+ * Validates a function, by wrapping the function and checking its parameters and
+ * return value through {@link validate} function. If some parameter or return value
+ * does not match the expected type, it returns {@link IValidation.IError} typed
+ * object. Otherwise there's no type error, it returns {@link IValidation.ISuccess}
+ * typed object instead.
+ *
+ * For reference, {@link IValidation.IError.path} would be a little bit different with
+ * individual {@link validate} function. If the {@link IValidation.IError} occurs from
+ * some parameter, the path would start from `$input.parameters[number]`. Otherwise
+ * the path would start from `$input.return`.
+ *
+ * - `$input.parameters[0].~`
+ * - `$input.return.~`
+ *
+ * By the way, if what you want is not finding every type errors, but just finding
+ * the 1st type error, then use {@link assertFunction} instead. Otherwise, what you
+ * want is just validating parameters or return value only, you can use
+ * {@link validateParameters} or {@link validateReturn} instead.
+ *
+ * On the other hand, if you don't want to allow any superfluous properties, utilize
+ * {@link validateEqualsFunction} or {@link assertEqualsFunction} instead.
+ *
+ * @template T Target function type
+ * @param func Target function to validate
+ * @returns The wrapper function with type validations
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function validateFunction<T extends (...args: any[]) => any>(func: T): T extends (...args: infer Arguments) => infer Output ? Output extends Promise<infer R> ? (...args: Arguments) => Promise<IValidation<R>> : (...args: Arguments) => IValidation<Output> : never;
+/**
+ * Validates parameters.
+ *
+ * Validates a function, by wrapping the function and checking its parameters through
+ * {@link validate} function. If some parameter does not match the expected type, it
+ * returns {@link IValidation.IError} typed object. Otherwise there's no type error,
+ * it returns {@link IValidation.ISuccess} typed object instead.
+ *
+ * For reference, {@link IValidation.IError.path} would be a little bit different with
+ * individual {@link validate} function. If the {@link IValidation.IError} occurs from
+ * some parameter, the path would start from `$input.parameters[number]`.
+ *
+ * By the way, if what you want is not finding every type errors, but just finding
+ * the 1st type error, then use {@link assertParameters} instead. Otherwise, what you
+ * want is not only validating parameters, but also validating return value, you can
+ * use {@link validateFunction} instead.
+ *
+ * On the other hand, if you don't want to allow any superfluous properties, utilize
+ * {@link validateEqualsParameters} or {@link assertEqualsParameters} instead.
+ *
+ * @template T Target function type
+ * @param func Target function to validate
+ * @returns The wrapper function with type validations
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function validateParameters<T extends (...args: any[]) => any>(func: T): T extends (...args: infer Arguments) => infer Output ? Output extends Promise<infer R> ? (...args: Arguments) => Promise<IValidation<R>> : (...args: Arguments) => IValidation<Output> : never;
+/**
+ * Validates return value.
+ *
+ * Validates a function, by wrapping the function and checking its return value through
+ * {@link validate} function. If the return value does not match the expected type, it
+ * returns {@link IValidation.IError} typed object. Otherwise there's no type error,
+ * it returns {@link IValidation.ISuccess} typed object instead.
+ *
+ * For reference, {@link IValidation.IError.path} would be a little bit different with
+ * individual {@link validate} function. If the {@link IValidation.IError} occurs from
+ * the return value, the path would start from `$input.return`.
+ *
+ * By the way, if what you want is not finding every type errors, but just finding
+ * the 1st type error, then use {@link assertReturn} instead. Otherwise, what you want
+ * is not only validating return value, but also validating parameters, you can use
+ * {@link validateFunction} instead.
+ *
+ * On the other hand, if you don't want to allow any superfluous properties, utilize
+ * {@link validateEqualsReturn} or {@link assertEqualsReturn} instead.
+ *
+ * @template T Target function type
+ * @param func Target function to validate
+ * @returns The wrapper function with type validations
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function validateReturn<T extends (...args: any[]) => any>(func: T): T extends (...args: infer Arguments) => infer Output ? Output extends Promise<infer R> ? (...args: Arguments) => Promise<IValidation<R>> : (...args: Arguments) => IValidation<Output> : never;
+/**
+ * Validates a function with strict equality.
+ *
+ * Validates a function with strict equality, by wrapping the function and checking
+ * its parameters and return value through {@link validateEquals} function. If some
+ * parameter or return value does not match the expected type, it returns
+ * {@link IValidation.IError} typed object. Otherwise there's no type error, it
+ * returns {@link IValidation.ISuccess} typed object instead.
+ *
+ * For reference, {@link IValidation.IError.path} would be a little bit different with
+ * individual {@link validateEquals} function. If the {@link IValidation.IError} occurs
+ * from some parameter, the path would start from `$input.parameters[number]`. Otherwise
+ * the path would start from `$input.return`.
+ *
+ * - `$input.parameters[0].~`
+ * - `$input.return.~`
+ *
+ * By the way, if what you want is not finding every type errors, but just finding
+ * the 1st type error, then use {@link assertEqualsFunction} instead. Otherwise, what
+ * you want is just validating parameters or return value only, you can use
+ * {@link validateEqualsParameters} or {@link validateEqualsReturn} instead.
+ *
+ * On the other hand, if you want to allow any superfluous properties, utilize
+ * {@link validateFunction} or {@link assertFunction} instead.
+ *
+ * @template T Target function type
+ * @param func Target function to validate
+ * @returns The wrapper function with type validations
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function validateEqualsFunction<T extends (...args: any[]) => any>(func: T): T extends (...args: infer Arguments) => infer Output ? Output extends Promise<infer R> ? (...args: Arguments) => Promise<IValidation<R>> : (...args: Arguments) => IValidation<Output> : never;
+/**
+ * Validates parameters with strict equality.
+ *
+ * Validates a function, by wrapping the function and checking its parameters through
+ * {@link validateEquals} function. If some parameter does not match the expected type,
+ * it returns {@link IValidation.IError} typed object. Otherwise there's no type error,
+ * it returns {@link IValidation.ISuccess} typed object instead.
+ *
+ * For reference, {@link IValidation.IError.path} would be a little bit different with
+ * individual {@link validateEquals} function. If the {@link IValidation.IError} occurs
+ * from some parameter, the path would start from `$input.parameters[number]`.
+ *
+ * By the way, if what you want is not finding every type errors, but just finding
+ * the 1st type error, then use {@link assertEqualsParameters} instead. Otherwise,
+ * what you want is not only validating parameters, but also validating return value,
+ * you can use {@link validateEqualsFunction} instead.
+ *
+ * On the other hand, if you want to allow any superfluous properties, utilize
+ * {@link validateParameters} or {@link assertParameters} instead.
+ *
+ * @template T Target function type
+ * @param func Target function to validate
+ * @returns The wrapper function with type validations
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function validateEqualsParameters<T extends (...args: any[]) => any>(func: T): T extends (...args: infer Arguments) => infer Output ? Output extends Promise<infer R> ? (...args: Arguments) => Promise<IValidation<R>> : (...args: Arguments) => IValidation<Output> : never;
+/**
+ * Validates return value with strict equality.
+ *
+ * Validates a function, by wrapping the function and checking its return value through
+ * {@link validateEquals} function. If the return value does not match the expected type,
+ * it returns {@link IValidation.IError} typed object. Otherwise there's no type error,
+ * it returns {@link IValidation.ISuccess} typed object instead.
+ *
+ * For reference, {@link IValidation.IError.path} would be a little bit different with
+ * individual {@link validateEquals} function. If the {@link IValidation.IError} occurs
+ * from the return value, the path would start from `$input.return`.
+ *
+ * By the way, if what you want is not finding every type errors, but just finding
+ * the 1st type error, then use {@link assertEqualsReturn} instead. Otherwise, what you
+ * want is not only validating return value, but also validating parameters, you can use
+ * {@link validateEqualsFunction} instead.
+ *
+ * On the other hand, if you want to allow any superfluous properties, utilize
+ * {@link validateReturn} or {@link assertReturn} instead.
+ *
+ * @template T Target function type
+ * @param func Target function to validate
+ * @returns The wrapper function with type validations
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function validateEqualsReturn<T extends (...args: any[]) => any>(func: T): T extends (...args: infer Arguments) => infer Output ? Output extends Promise<infer R> ? (...args: Arguments) => Promise<IValidation<R>> : (...args: Arguments) => IValidation<Output> : never;