typia 3.3.12 → 3.4.0-dev.20221212

package/lib/module.d.ts

@@ -3,6 +3,7 @@ import { IValidation } from "./IValidation";
 export * from "./schemas/IJsonApplication";
 export * from "./schemas/IJsonComponents";
 export * from "./schemas/IJsonSchema";
+export * from "./Primitive";
 export * from "./TypeGuardError";
 export * from "./IValidation";
 /**
@@ -26,7 +27,7 @@ export * from "./IValidation";
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function assertType<T>(input: T): T;
+export declare function assert<T>(input: T): T;
 /**
  * Asserts a value type.
  *
@@ -36,7 +37,7 @@ export declare function assertType<T>(input: T): T;
  *
  * If what you want is not asserting but just knowing whether the parametric value is
  * following the type `T` or not, you can choose the {@link is} function instead.
- * Otherwise you want to know all the errors, {@link validate} is the way to go.
+ * Otherwise, you want to know all the errors, {@link validate} is the way to go.
  *
  * On the other and, if you don't want to allow any superfluous property that is not
  * enrolled to the type `T`, you can use {@link assertEquals} function instead.
@@ -48,6 +49,34 @@ export declare function assertType<T>(input: T): T;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
+export declare function assert<T>(input: unknown): T;
+/**
+ * Asserts a value type.
+ *
+ * Duplicated function of {@link assert} for `typescript-is` users.
+ *
+ * @template T Type of the input value
+ * @param input A value to be asserted
+ * @returns Parametric input value
+ * @throws A {@link TypeGuardError} instance with detailed reason
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @deprecated
+ */
+export declare function assertType<T>(input: T): T;
+/**
+ * Asserts a value type.
+ *
+ * Duplicated function of {@link assert} for `typescript-is` users.
+ *
+ * @template T Type of the input value
+ * @param input A value to be asserted
+ * @returns Parametric input value
+ * @throws A {@link TypeGuardError} instance with detailed reason
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @deprecated
+ */
 export declare function assertType<T>(input: unknown): T;
 /**
  * Tests a value type.
@@ -59,7 +88,7 @@ export declare function assertType<T>(input: unknown): T;
  *
  * If what you want is not just knowing whether the parametric value is following the
  * type `T` or not, but throwing an exception with detailed reason, you can choose
- * {@link assertType} function instead. Also, if you want to know all the errors with
+ * {@link assert} function instead. Also, if you want to know all the errors with
  * detailed reasons, {@link validate} function would be useful.
  *
  * On the other and, if you don't want to allow any superfluous property that is not
@@ -82,7 +111,7 @@ export declare function is<T>(input: T): input is T;
  *
  * If what you want is not just knowing whether the parametric value is following the
  * type `T` or not, but throwing an exception with detailed reason, you can choose
- * {@link assertType} function instead. Also, if you want to know all the errors with
+ * {@link assert} function instead. Also, if you want to know all the errors with
  * detailed reasons, {@link validate} function would be useful.
  *
  * On the other and, if you don't want to allow any superfluous property that is not
@@ -105,7 +134,7 @@ export declare function is<T>(input: unknown): input is T;
  * would have the `true` value.
  *
  * If what you want is not finding all the error, but asserting the parametric value
- * type with exception throwing, you can choose {@link assertType} function instead.
+ * type with exception throwing, you can choose {@link assert} function instead.
  * Otherwise, you just want to know whether the parametric value is matched with the
  * type `T`, {@link is} function is the way to go.
  *
@@ -115,8 +144,10 @@ export declare function is<T>(input: unknown): input is T;
  * @template Type of the input value
  * @param input A value to be validated
  * @returns Validation result
+ *
+ * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function validate<T>(input: T): IValidation;
+export declare function validate<T>(input: T): IValidation<T>;
 /**
  * Validates a value type.
  *
@@ -127,7 +158,7 @@ export declare function validate<T>(input: T): IValidation;
  * would have the `true` value.
  *
  * If what you want is not finding all the error, but asserting the parametric value
- * type with exception throwing, you can choose {@link assertType} function instead.
+ * type with exception throwing, you can choose {@link assert} function instead.
  * Otherwise, you just want to know whether the parametric value is matched with the
  * type `T`, {@link is} function is the way to go.
  *
@@ -137,8 +168,10 @@ export declare function validate<T>(input: T): IValidation;
  * @template Type of the input value
  * @param input A value to be validated
  * @returns Validation result
+ *
+ * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function validate<T>(input: unknown): IValidation;
+export declare function validate<T>(input: unknown): IValidation<T>;
 /**
  * Asserts equality between a value and its type.
  *
@@ -150,10 +183,10 @@ export declare function validate<T>(input: unknown): IValidation;
  *
  * If what you want is not asserting but just knowing whether the parametric value is
  * following the type `T` or not, you can choose the {@link equals} function instead.
- * Otherwise you want to know all the errors, {@link validateEquals} is the way to go.
+ * Otherwise, you want to know all the errors, {@link validateEquals} is the way to go.
  *
  * On the other hand, if you want to allow superfluous property that is not enrolled
- * to the type `T`, you can use {@link assertType} function instead.
+ * to the type `T`, you can use {@link assert} function instead.
  *
  * @template T Type of the input value
  * @param input A value to be asserted
@@ -174,10 +207,10 @@ export declare function assertEquals<T>(input: T): T;
  *
  * If what you want is not asserting but just knowing whether the parametric value is
  * following the type `T` or not, you can choose the {@link equals} function instead.
- * Otherwise you want to know all the errors, {@link validateEquals} is the way to go.
+ * Otherwise, you want to know all the errors, {@link validateEquals} is the way to go.
  *
  * On the other hand, if you want to allow superfluous property that is not enrolled
- * to the type `T`, you can use {@link assertType} function instead.
+ * to the type `T`, you can use {@link assert} function instead.
  *
  * @template T Type of the input value
  * @param input A value to be asserted
@@ -236,7 +269,7 @@ export declare function equals<T>(input: T): input is T;
  */
 export declare function equals<T>(input: unknown): input is T;
 /**
- * Validates equaility between a value and itstype.
+ * Validates equality between a value and its type.
  *
  * Validates a parametric value type and archives all the type errors into an
  * {@link IValidation.errors} array, if the parametric value is not following the
@@ -246,7 +279,7 @@ export declare function equals<T>(input: unknown): input is T;
  * and {@link IValidation.success} would have the `true` value.
  *
  * If what you want is not finding all the error, but asserting the parametric value
- * type with exception throwing, you can choose {@link assertType} function instead.
+ * type with exception throwing, you can choose {@link assert} function instead.
  * Otherwise, you just want to know whether the parametric value is matched with the
  * type `T`, {@link is} function is the way to go.
  *
@@ -256,10 +289,12 @@ export declare function equals<T>(input: unknown): input is T;
  * @template Type of the input value
  * @param input A value to be validated
  * @returns Validation result
+ *
+ * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function validateEquals<T>(input: T): IValidation;
+export declare function validateEquals<T>(input: T): IValidation<T>;
 /**
- * Validates equaility between a value and itstype.
+ * Validates equality between a value and its type.
  *
  * Validates a parametric value type and archives all the type errors into an
  * {@link IValidation.errors} array, if the parametric value is not following the
@@ -269,7 +304,7 @@ export declare function validateEquals<T>(input: T): IValidation;
  * and {@link IValidation.success} would have the `true` value.
  *
  * If what you want is not finding all the error, but asserting the parametric value
- * type with exception throwing, you can choose {@link assertType} function instead.
+ * type with exception throwing, you can choose {@link assert} function instead.
  * Otherwise, you just want to know whether the parametric value is matched with the
  * type `T`, {@link is} function is the way to go.
  *
@@ -279,59 +314,10 @@ export declare function validateEquals<T>(input: T): IValidation;
  * @template Type of the input value
  * @param input A value to be validated
  * @returns Validation result
- */
-export declare function validateEquals<T>(input: unknown): IValidation;
-/**
- * 5x faster `JSON.stringify()` function.
- *
- * Converts an input value to a JSON (JavaSript Object Noation) string, about 5x faster
- * than the native `JSON.stringify()` function. The 5x faster principle is because
- * it writes an optmized JSON conversion plan, only for the type `T`.
- *
- * If you want to create a stringify function which is reusable, just assign this function
- * to a (constant) variable like below, with the generic argument `T`. Then the variable
- * would be a stringify fuction reusable.
- *
- * ```typescript
- * const stringify = TSON.stringify<MyType>;
- * stringify(x);
- * stringify(y);
- * stringify(z);
- * ```
- *
- * For reference, this `TSON.stringify()` does not validate the input value type. It
- * just believes that the input value is following the type `T`. Therefore, if you
- * can't ensure the input value type, it would better to call {@link assertType} or
- * {@link is} function before.
- *
- * @template T Type of the input value
- * @param input A value to be converted
- * @return JSON string value
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function stringify<T>(input: T): string;
-/**
- * 2x faster constant object creator.
- *
- * You know what? `JSON.parse()` is faster than literal object construction, when the
- * object would be constructed only one time.
- *
- * - [Faster apps with JSON.parse (Chrome Dev Summit 2019)](https://www.youtube.com/watch?v=ff4fgQxPaO0)
- * - [The cost of parsing JSON](https://v8.dev/blog/cost-of-javascript-2019#json)
- *
- * `TSON.create()` is a transformer function which converts a literal object construction
- * to a `JSON.parse()` function call expression with JSON string argument. Therefore, if
- * you construct a literal object via this `TSON.create()`, you can get benefit from both
- * type safe and performance tuning at the same time.
- *
- * @template T Type of the input value
- * @param input A value to be converted
- * @return Same with the parametric value
- *
- * @author Jeongho Nam - https://github.com/samchon
- */
-export declare function create<T>(input: T): T;
+export declare function validateEquals<T>(input: unknown): IValidation<T>;
 /**
  * > You must configure the generic argument `T`.
  *
@@ -341,16 +327,16 @@ export declare function create<T>(input: T): T;
  * Note that, all of the object types are stored in the {@link IJsonApplication.components}
  * property for the `$ref` referencing.
  *
- * Also, `TSON.application()` has additional generic arguments, *Purpose*.
+ * Also, `typia.application()` has additional generic arguments, *Purpose*.
  * As JSON schema definitions used by `swagger` and `ajv` are different a little bit,
- * you should configure the *Purpose* apprpriately.
+ * you should configure the *Purpose* appropriately.
  *
  * For an example, `ajv` has an extra property "$recursiveRef" that are not exists
  * in the standard JSON schema definition spec. Otherwise, `swagger` can't identify
  * the tuple definition.
  *
  * @template Types Tuple of target types
- * @template Purpose Purpose of the JSON schema
+ * @template Purpose Purpose of the JSON schema`
  * @template Prefix Prefix of the JSON components referenced by `$ref` tag
  * @return JSON schema application
  *
@@ -364,9 +350,9 @@ export declare function application(): never;
  * Note that, all of the object types are stored in the {@link IJsonApplication.components}
  * property for the `$ref` referencing.
  *
- * Also, `TSON.application()` has additional generic arguments, *Purpose*.
+ * Also, `typia.application()` has additional generic arguments, *Purpose*.
  * As JSON schema definitions used by `swagger` and `ajv` are different a little bit,
- * you should configure the *Purpose* apprpriately.
+ * you should configure the *Purpose* appropriately.
  *
  * For an example, `ajv` has an extra property "$recursiveRef" that are not exists
  * in the standard JSON schema definition spec. Otherwise, `swagger` can't identify
@@ -380,3 +366,548 @@ export declare function application(): never;
  * @author Jeongho Nam - https://github.com/samchon
  */
 export declare function application<Types extends unknown[], Purpose extends "swagger" | "ajv" = "swagger", Prefix extends string = Purpose extends "swagger" ? "#/components/schemas" : "components#/schemas">(): IJsonApplication;
+/**
+ * > You must configure the generic argument `T`.
+ *
+ * Safe `JSON.parse()` function with type assertion.
+ *
+ * `typia.assertParse()` is a combination function of `JSON.parse()` and {@link assert}.
+ * Therefore, it convers a JSON (JavaScript Object Notation) string to a `T` typed
+ * instance with type assertion.
+ *
+ * In such reason, when parsed JSON string value is not matched with the type `T`, it
+ * throws {@link TypeGuardError}. Otherwise, there's no problem on the parsed value,
+ * the parsed value would be returned.
+ *
+ * @template T Expected type of parsed value
+ * @param input JSON string
+ * @returns Parsed value
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function assertParse(input: string): never;
+/**
+ * Safe `JSON.parse()` function with type assertion.
+ *
+ * `typia.assertParse()` is a combination function of `JSON.parse()` and {@link assert}.
+ * Therefore, it convers a JSON (JavaScript Object Notation) string to a `T` typed
+ * instance with type assertion.
+ *
+ * In such reason, when parsed JSON string value is not matched with the type `T`, it
+ * throws {@link TypeGuardError}. Otherwise, there's no problem on the parsed value,
+ * the parsed value would be returned.
+ *
+ * @template T Expected type of parsed value
+ * @param input JSON string
+ * @returns Parsed value
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function assertParse<T>(input: string): T;
+/**
+ * > You must configure the generic argument `T`.
+ *
+ * Safe `JSON.parse()` function with type checking.
+ *
+ * `typia.isParse()` is a combination function of `JSON.parse()` and {@link is}.
+ * Therefore, it convers a JSON (JavaScript Object Notation) string to a `T` typed
+ * instance with type checking.
+ *
+ * In such reason, when parsed JSON string value is not matched with the type `T`, it
+ * returns `null` value. Otherwise, there's no problem on the parsed value, the parsed
+ * value would be returned.
+ *
+ * @template T Expected type of parsed value
+ * @param input JSON string
+ * @returns Parsed value when exact type, otherwise `null`
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function isParse(input: string): never;
+/**
+ * Safe `JSON.parse()` function with type checking.
+ *
+ * `typia.isParse()` is a combination function of `JSON.parse()` and {@link is}.
+ * Therefore, it convers a JSON (JavaScript Object Notation) string to a `T` typed
+ * instance with type checking.
+ *
+ * In such reason, when parsed JSON string value is not matched with the type `T`, it
+ * returns `null` value. Otherwise, there's no problem on the parsed value, the parsed
+ * value would be returned.
+ *
+ * @template T Expected type of parsed value
+ * @param input JSON string
+ * @returns Parsed value when exact type, otherwise `null`
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function isParse<T>(input: string): T | null;
+/**
+ * > You must configure the generic argument `T`.
+ *
+ * Safe `JSON.parse()` function with detailed type validation.
+ *
+ * `typia.validateParse()` is a combination function of `JSON.parse()` and
+ * {@link validate}. Therefore, it convers a JSON (JavaScript Object Notation) string
+ * to a `T` typed instance with detailed type validation.
+ *
+ * In such reason, when parsed JSON string value is not matched with the type `T`, it
+ * returns {@link IValidation.IFailure} value with detailed error reasons. Otherwise,
+ * there's no problem on the parsed value, the parsed value would be stored in `data`
+ * property of the output {@link IValidation.ISuccess} instance.
+ *
+ * @template T Expected type of parsed value
+ * @param input JSON string
+ * @returns Validation result with JSON parsed value
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function validateParse(input: string): never;
+/**
+ * Safe `JSON.parse()` function with detailed type validation.
+ *
+ * `typia.validateParse()` is a combination function of `JSON.parse()` and
+ * {@link validate}. Therefore, it convers a JSON (JavaScript Object Notation) string
+ * to a `T` typed instance with detailed type validation.
+ *
+ * In such reason, when parsed JSON string value is not matched with the type `T`, it
+ * returns {@link IValidation.IFailure} value with detailed error reasons. Otherwise,
+ * there's no problem on the parsed value, the parsed value would be stored in `data`
+ * property of the output {@link IValidation.ISuccess} instance.
+ *
+ * @template T Expected type of parsed value
+ * @param input JSON string
+ * @returns Validation result with JSON parsed value
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function validateParse<T>(input: string): IValidation<T>;
+/**
+ * 8x faster `JSON.stringify()` function.
+ *
+ * Converts an input value to a JSON (JavaScript Object Notation) string, about 8x faster
+ * than the native `JSON.stringify()` function. The 5x faster principle is because
+ * it writes an optimized JSON conversion plan, only for the type `T`.
+ *
+ * For reference, this `typia.stringify()` does not validate the input value type. It
+ * just believes that the input value is following the type `T`. Therefore, if you
+ * can't ensure the input value type, it would be better to call one of below functions
+ * instead.
+ *
+ *  - {@link assertStringify}
+ *  - {@link isStringify}
+ *  - {@link validateStringify}
+ *
+ * @template T Type of the input value
+ * @param input A value to be converted
+ * @return JSON string value
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function stringify<T>(input: T): string;
+/**
+ * 5x faster `JSON.stringify()` function with type assertion.
+ *
+ * `typia.assertStringify()` is a combination function of {@link assert} and
+ * {@link stringify}. Therefore, it converts an input value to JSON (JavaScript Object
+ * Notation) string, with type assertion.
+ *
+ * In such reason, when `input` value is not matched with the type `T`, it throws an
+ * {@link TypeGuardError}. Otherwise, there's no problem on the `input` value, JSON
+ * string would be returned.
+ *
+ * For reference, with type assertion, it is even 5x times faster than the native
+ * `JSON.stringify()` function. So, just enjoy the safe and fast JSON conversion
+ * with confidence.
+ *
+ * @template T Type of the input value
+ * @param input A value to be asserted and converted
+ * @return JSON string value
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function assertStringify<T>(input: T): string;
+/**
+ * 5x faster `JSON.stringify()` function with type assertion.
+ *
+ * `typia.assertStringify()` is a combination function of {@link assert} and
+ * {@link stringify}. Therefore, it converts an input value to JSON (JavaScript Object
+ * Notation) string, with type assertion.
+ *
+ * In such reason, when `input` value is not matched with the type `T`, it throws an
+ * {@link TypeGuardError}. Otherwise, there's no problem on the `input` value, JSON
+ * string would be returned.
+ *
+ * For reference, with type assertion, it is even 5x times faster than the native
+ * `JSON.stringify()` function. So, just enjoy the safe and fast JSON conversion
+ * with confidence.
+ *
+ * @template T Type of the input value
+ * @param input A value to be asserted and converted
+ * @return JSON string value
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function assertStringify<T>(input: T): unknown;
+/**
+ * 7x faster `JSON.stringify()` function with type checking.
+ *
+ * `typia.stringify()` is a combination function of {@link is} and
+ * {@link stringify}. Therefore, it converts an input value to JSON
+ * (JavaScript Object Notation) string, with type checking.
+ *
+ * In such reason, when `input` value is not matched with the type `T`, it returns
+ * `null` value. Otherwise, there's no problem on the `input` value, JSON string would
+ * be returned.
+ *
+ * For reference, with type checking, it is even 7x times faster than the native
+ * `JSON.stringify()` function. So, just enjoy the safe and fast JSON conversion
+ * with confidence.
+ *
+ * @template T Type of the input value
+ * @param input A value to be checked and converted
+ * @return JSON string value when exact type, otherwise null
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function isStringify<T>(input: T): string | null;
+/**
+ * 7x faster `JSON.stringify()` function with type checking.
+ *
+ * `typia.isStringify()` is a combination function of {@link is} and
+ * {@link stringify}. Therefore, it converts an input value to JSON
+ * (JavaScript Object Notation) string, with type checking.
+ *
+ * In such reason, when `input` value is not matched with the type `T`, it returns
+ * `null` value. Otherwise, there's no problem on the `input` value, JSON string would
+ * be returned.
+ *
+ * For reference, with type checking, it is even 7x times faster than the native
+ * `JSON.stringify()` function. So, just enjoy the safe and fast JSON conversion
+ * with confidence.
+ *
+ * @template T Type of the input value
+ * @param input A value to be checked and converted
+ * @return JSON string value when exact type, otherwise null
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function isStringify<T>(input: unknown): string | null;
+/**
+ * 5x faster `JSON.stringify()` function with detailed type validation.
+ *
+ * `typia.validateStringify()` is a combination function of {@link validate} and
+ * {@link stringify}. Therefore, it converts an input value to JSON (JavaScript Object
+ * Notation) string, with detailed type validation.
+ *
+ * In such reason, when `input` value is not matched with the type `T`, it returns
+ * {@link IValidation.IFailure} value with detailed error reasons. Otherwise, there's no
+ * problem on the `input` value, JSON string would be stored in `data` property of
+ * the output {@link IValidation.ISuccess} instance.
+ *
+ * For reference, with detailed type validation, it is even 5x times faster than the
+ * native `JSON.stringify()` function. So, just enjoy the safe and fast JSON conversion
+ * with confidence.
+ *
+ * @template T Type of the input value
+ * @param input A value to be checked and converted
+ * @returns Validation result with JSON string value
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function validateStringify<T>(input: T): IValidation<string>;
+/**
+ * 5x faster `JSON.stringify()` function with detailed type validation.
+ *
+ * `typia.validateStringify()` is a combination function of {@link validate} and
+ * {@link stringify}. Therefore, it converts an input value to JSON (JavaScript Object
+ * Notation) string, with detailed type validation.
+ *
+ * In such reason, when `input` value is not matched with the type `T`, it returns
+ * {@link IValidation.IFailure} value with detailed error reasons. Otherwise, there's no
+ * problem on the `input` value, JSON string would be stored in `data` property of
+ * the output {@link IValidation.ISuccess} instance.
+ *
+ * For reference, with detailed type validation, it is even 5x times faster than the
+ * native `JSON.stringify()` function. So, just enjoy the safe and fast JSON conversion
+ * with confidence.
+ *
+ * @template T Type of the input value
+ * @param input A value to be checked and converted
+ * @returns Validation result with JSON string value
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function validateStringify<T>(input: unknown): IValidation<string>;
+/**
+ * Creates a reusable {@link assert} function.
+ *
+ * @danger You have to specify the generic argument `T`
+ * @return Nothing until specifying the generic argument `T`
+ * @throws compile error
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function createAssert(): never;
+/**
+ * Creates a reusable {@link assert} function.
+ *
+ * @template T Type of the input value
+ * @returns A reusable `assert` function
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function createAssert<T>(): (input: unknown) => T;
+/**
+ * Creates a reusable {@link assertType} function.
+ *
+ * Duplicated function of {@link createAssert} for `typescript-is` users.
+ *
+ * @danger You have to specify the generic argument `T`
+ * @return Nothing until specifying the generic argument `T`
+ * @throws compile error
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @deprecated
+ */
+export declare function createAssertType(): never;
+/**
+ * Creates a reusable {@link assertType} function.
+ *
+ * Duplicated function of {@link createAssert} for `typescript-is` users.
+ *
+ * @template T Type of the input value
+ * @returns A reusable `assert` function
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @deprecated
+ */
+export declare function createAssertType<T>(): (input: unknown) => T;
+/**
+ * Creates a reusable {@link is} function.
+ *
+ * @danger You have to specify the generic argument `T`
+ * @return Nothing until specifying the generic argument `T`
+ * @throws compile error
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function createIs(): never;
+/**
+ * Creates a reusable {@link is} function.
+ *
+ * @template T Type of the input value
+ * @returns A reusable `is` function
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function createIs<T>(): (input: unknown) => input is T;
+/**
+ * Creates a reusable {@link validate} function.
+ *
+ * @danger You have to specify the generic argument `T`
+ * @return Nothing until specifying the generic argument `T`
+ * @throws compile error
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function createValidate(): never;
+/**
+ * Creates a reusable {@link validate} function.
+ *
+ * @template T Type of the input value
+ * @returns A reusable `validate` function
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function createValidate<T>(): (input: unknown) => IValidation<T>;
+/**
+ * Creates a reusable {@link assertEquals} function.
+ *
+ * @danger You have to specify the generic argument `T`
+ * @return Nothing until specifying the generic argument `T`
+ * @throws compile error
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function createAssertEquals(): never;
+/**
+ * Creates a reusable {@link assertEquals} function.
+ *
+ * @template T Type of the input value
+ * @returns A reusable `assertEquals` function
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function createAssertEquals<T>(): (input: unknown) => T;
+/**
+ * Creates a reusable {@link equals} function.
+ *
+ * @danger You have to specify the generic argument `T`
+ * @return Nothing until specifying the generic argument `T`
+ * @throws compile error
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function createEquals(): never;
+/**
+ * Creates a reusable {@link equals} function.
+ *
+ * @template T Type of the input value
+ * @returns A reusable `equals` function
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function createEquals<T>(): (input: unknown) => input is T;
+/**
+ * Creates a reusable {@link validateEquals} function.
+ *
+ * @danger You have to specify the generic argument `T`
+ * @return Nothing until specifying the generic argument `T`
+ * @throws compile error
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function createValidateEquals(): never;
+/**
+ * Creates a reusable {@link validateEquals} function.
+ *
+ * @template T Type of the input value
+ * @returns A reusable `validateEquals` function
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function createValidateEquals<T>(): (input: unknown) => IValidation;
+/**
+ * Creates a reusable {@link isParse} function.
+ *
+ * @danger You have to specify the generic argument `T`
+ * @return Nothing until specifying the generic argument `T`
+ * @throws compile error
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function createIsParse(): never;
+/**
+ * Creates a reusable {@link isParse} function.
+ *
+ * @template T Expected type of parsed value
+ * @returns A reusable `isParse` function
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function createIsParse<T>(): (input: string) => T | null;
+/**
+ * Creates a reusable {@link assertParse} function.
+ *
+ * @danger You have to specify the generic argument `T`
+ * @return Nothing until specifying the generic argument `T`
+ * @throws compile error
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function createAssertParse(): never;
+/**
+ * Creates a reusable {@link assertParse} function.
+ *
+ * @template T Expected type of parsed value
+ * @returns A reusable `assertParse` function
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function createAssertParse<T>(): (input: string) => T;
+/**
+ * Creates a reusable {@link validateParse} function.
+ *
+ * @danger You have to specify the generic argument `T`
+ * @return Nothing until specifying the generic argument `T`
+ * @throws compile error
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function createValidateParse(): never;
+/**
+ * Creates a reusable {@link validateParse} function.
+ *
+ * @template T Expected type of parsed value
+ * @returns A reusable `validateParse` function
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function createValidateParse<T>(): (input: string) => IValidation<T>;
+/**
+ * Creates a reusable {@link stringify} function.
+ *
+ * @danger You have to specify the generic argument `T`
+ * @return Nothing until specifying the generic argument `T`
+ * @throws compile error
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function createStringify(): never;
+/**
+ * Creates a reusable {@link stringify} function.
+ *
+ * @template T Type of the input value
+ * @returns A reusable `stringify` function
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function createStringify<T>(): (input: T) => string;
+/**
+ * Creates a reusable {@link assertStringify} function.
+ *
+ * @danger You have to specify the generic argument `T`
+ * @return Nothing until specifying the generic argument `T`
+ * @throws compile error
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function createAssertStringify(): never;
+/**
+ * Creates a reusable {@link assertStringify} function.
+ *
+ * @template T Type of the input value
+ * @returns A reusable `assertStringify` function
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function createAssertStringify<T>(): (input: unknown) => string;
+/**
+ * Creates a reusable {@link isStringify} function.
+ *
+ * @danger You have to specify the generic argument `T`
+ * @return Nothing until specifying the generic argument `T`
+ * @throws compile error
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function createIsStringify(): never;
+/**
+ * Creates a reusable {@link isStringify} function.
+ *
+ * @template T Type of the input value
+ * @returns A reusable `isStringify` function
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function createIsStringify<T>(): (input: unknown) => string | null;
+/**
+ * Creates a reusable {@link validateStringify} function.
+ *
+ * @danger You have to specify the generic argument `T`
+ * @return Nothing until specifying the generic argument `T`
+ * @throws compile error
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function createValidateStringify(): never;
+/**
+ * Creates a reusable {@link validateStringify} function.
+ *
+ * @template T Type of the input value
+ * @returns A reusable `validateStringify` function
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare function createValidateStringify<T>(): (input: unknown) => IValidation<string>;