typia 9.7.1 → 9.7.2

package/src/notations.ts

@@ -18,27 +18,26 @@ import { TypeGuardError } from "./TypeGuardError";
 /**
  * Convert to camel case.
  *
- * Convert every property names of nested objects to follow the camel case convention.
+ * Convert every property names of nested objects to follow the camel case
+ * convention.
  *
- * For reference, this `typia.notations.camel()` function 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 them below:
+ * For reference, this `typia.notations.camel()` function 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 them below:
  *
  * - {@link assertCamel}
  * - {@link isCamel}
  * - {@link validateCamel}
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Type of the input value
  * @param input Target object
  * @returns Camel case object
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function camel<T>(input: T): CamelCase<T>;
 
-/**
- * @internal
- */
+/** @internal */
 export function camel(): never {
   return NoTransformConfigurationError("notations.camel");
 }
@@ -46,15 +45,15 @@ export function camel(): never {
 /**
  * Converts to camel case with type assertion.
  *
- * Convert every property names of nested objects to follow the camel case convention.
- * If the input value does not follow the type `T`, it throws {@link TypeGuardError}.
+ * Convert every property names of nested objects to follow the camel case
+ * convention. If the input value does not follow the type `T`, it throws
+ * {@link TypeGuardError}.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Type of the input value
  * @param input Target object
  * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns Camel case object
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function assertCamel<T>(
   input: T,
@@ -64,24 +63,22 @@ export function assertCamel<T>(
 /**
  * Converts to camel case with type assertion.
  *
- * Convert every property names of nested objects to follow the camel case convention.
- * If the input value does not follow the type `T`, it throws {@link TypeGuardError}.
+ * Convert every property names of nested objects to follow the camel case
+ * convention. If the input value does not follow the type `T`, it throws
+ * {@link TypeGuardError}.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Type of the input value
  * @param input Target object
  * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns Camel case object
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function assertCamel<T>(
   input: unknown,
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
 ): CamelCase<T>;
 
-/**
- * @internal
- */
+/** @internal */
 export function assertCamel(): never {
   return NoTransformConfigurationError("notations.assertCamel");
 }
@@ -89,34 +86,32 @@ export function assertCamel(): never {
 /**
  * Converts to camel case with type checking.
  *
- * Convert every property names of nested objects to follow the camel case convention.
- * If the input value does not follow the type `T`, it returns `null` value instead.
+ * Convert every property names of nested objects to follow the camel case
+ * convention. If the input value does not follow the type `T`, it returns
+ * `null` value instead.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Type of the input value
  * @param input Target object
  * @returns Camel case object when exact type, otherwise null
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function isCamel<T>(input: T): CamelCase<T> | null;
 
 /**
  * Converts to camel case with type checking.
  *
- * Convert every property names of nested objects to follow the camel case convention.
- * If the input value does not follow the type `T`, it returns `null` value instead.
+ * Convert every property names of nested objects to follow the camel case
+ * convention. If the input value does not follow the type `T`, it returns
+ * `null` value instead.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Type of the input value
  * @param input Target object
  * @returns Camel case object when exact type, otherwise null
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function isCamel<T>(input: unknown): CamelCase<T> | null;
 
-/**
- * @internal
- */
+/** @internal */
 export function isCamel(): never {
   return NoTransformConfigurationError("notations.isCamel");
 }
@@ -124,38 +119,36 @@ export function isCamel(): never {
 /**
  * Converts to camel case with type validation.
  *
- * Convert every property names of nested objects to follow the camel case convention.
- * If the input value does not follow the type `T`, it returns {@link IValidation.Failure}
- * object. Otherwise, there's no problem on the input value, camel cased converted data
- * would be stored in the `data` property of the output {@link IValidation.Success} object.
+ * Convert every property names of nested objects to follow the camel case
+ * convention. If the input value does not follow the type `T`, it returns
+ * {@link IValidation.Failure} object. Otherwise, there's no problem on the input
+ * value, camel cased converted data would be stored in the `data` property of
+ * the output {@link IValidation.Success} object.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Type of the input value
  * @param input Target object
  * @returns Validation result with camel case object
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function validateCamel<T>(input: T): IValidation<CamelCase<T>>;
 
 /**
  * Converts to camel case with type validation.
  *
- * Convert every property names of nested objects to follow the camel case convention.
- * If the input value does not follow the type `T`, it returns {@link IValidation.Failure}
- * object. Otherwise, there's no problem on the input value, camel cased converted data
- * would be stored in the `data` property of the output {@link IValidation.Success} object.
+ * Convert every property names of nested objects to follow the camel case
+ * convention. If the input value does not follow the type `T`, it returns
+ * {@link IValidation.Failure} object. Otherwise, there's no problem on the input
+ * value, camel cased converted data would be stored in the `data` property of
+ * the output {@link IValidation.Success} object.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Type of the input value
  * @param input Target object
  * @returns Validation result with camel case object
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function validateCamel<T>(input: unknown): IValidation<CamelCase<T>>;
 
-/**
- * @internal
- */
+/** @internal */
 export function validateCamel(): never {
   return NoTransformConfigurationError("notations.validateCamel");
 }
@@ -166,27 +159,26 @@ export function validateCamel(): never {
 /**
  * Convert to pascal case.
  *
- * Convert every property names of nested objects to follow the pascal case convention.
+ * Convert every property names of nested objects to follow the pascal case
+ * convention.
  *
- * For reference, this `typia.notations.pascal()` function 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 them below:
+ * For reference, this `typia.notations.pascal()` function 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 them below:
  *
  * - {@link assertPascal}
  * - {@link isPascal}
  * - {@link validatePascal}
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Type of the input value
  * @param input Target object
  * @returns Pascal case object
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function pascal<T>(input: T): PascalCase<T>;
 
-/**
- * @internal
- */
+/** @internal */
 export function pascal(): never {
   return NoTransformConfigurationError("notations.pascal");
 }
@@ -194,15 +186,15 @@ export function pascal(): never {
 /**
  * Converts to pascal case with type assertion.
  *
- * Convert every property names of nested objects to follow the pascal case convention.
- * If the input value does not follow the type `T`, it throws {@link TypeGuardError}.
+ * Convert every property names of nested objects to follow the pascal case
+ * convention. If the input value does not follow the type `T`, it throws
+ * {@link TypeGuardError}.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Type of the input value
  * @param input Target object
  * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns Pascal case object
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function assertPascal<T>(
   input: T,
@@ -212,24 +204,22 @@ export function assertPascal<T>(
 /**
  * Converts to pascal case with type assertion.
  *
- * Convert every property names of nested objects to follow the pascal case convention.
- * If the input value does not follow the type `T`, it throws {@link TypeGuardError}.
+ * Convert every property names of nested objects to follow the pascal case
+ * convention. If the input value does not follow the type `T`, it throws
+ * {@link TypeGuardError}.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Type of the input value
  * @param input Target object
  * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns Pascal case object
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function assertPascal<T>(
   input: unknown,
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
 ): PascalCase<T>;
 
-/**
- * @internal
- */
+/** @internal */
 export function assertPascal(): never {
   return NoTransformConfigurationError("notations.assertPascal");
 }
@@ -237,34 +227,32 @@ export function assertPascal(): never {
 /**
  * Converts to pascal case with type checking.
  *
- * Convert every property names of nested objects to follow the pascal case convention.
- * If the input value does not follow the type `T`, it returns `null` value instead.
+ * Convert every property names of nested objects to follow the pascal case
+ * convention. If the input value does not follow the type `T`, it returns
+ * `null` value instead.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Type of the input value
  * @param input Target object
  * @returns Pascal case object when exact type, otherwise null
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function isPascal<T>(input: T): PascalCase<T> | null;
 
 /**
  * Converts to pascal case with type checking.
  *
- * Convert every property names of nested objects to follow the pascal case convention.
- * If the input value does not follow the type `T`, it returns `null` value instead.
+ * Convert every property names of nested objects to follow the pascal case
+ * convention. If the input value does not follow the type `T`, it returns
+ * `null` value instead.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Type of the input value
  * @param input Target object
  * @returns Pascal case object when exact type, otherwise null
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function isPascal<T>(input: unknown): PascalCase<T> | null;
 
-/**
- * @internal
- */
+/** @internal */
 export function isPascal(): never {
   return NoTransformConfigurationError("notations.isPascal");
 }
@@ -272,38 +260,36 @@ export function isPascal(): never {
 /**
  * Converts to pascal case with type validation.
  *
- * Convert every property names of nested objects to follow the pascal case convention.
- * If the input value does not follow the type `T`, it returns {@link IValidation.Failure}
- * object. Otherwise, there's no problem on the input value, pascal cased converted data
- * would be stored in the `data` property of the output {@link IValidation.Success} object.
+ * Convert every property names of nested objects to follow the pascal case
+ * convention. If the input value does not follow the type `T`, it returns
+ * {@link IValidation.Failure} object. Otherwise, there's no problem on the input
+ * value, pascal cased converted data would be stored in the `data` property of
+ * the output {@link IValidation.Success} object.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Type of the input value
  * @param input Target object
  * @returns Validation result with pascal case object
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function validatePascal<T>(input: T): IValidation<PascalCase<T>>;
 
 /**
  * Converts to pascal case with type validation.
  *
- * Convert every property names of nested objects to follow the pascal case convention.
- * If the input value does not follow the type `T`, it returns {@link IValidation.Failure}
- * object. Otherwise, there's no problem on the input value, pascal cased converted data
- * would be stored in the `data` property of the output {@link IValidation.Success} object.
+ * Convert every property names of nested objects to follow the pascal case
+ * convention. If the input value does not follow the type `T`, it returns
+ * {@link IValidation.Failure} object. Otherwise, there's no problem on the input
+ * value, pascal cased converted data would be stored in the `data` property of
+ * the output {@link IValidation.Success} object.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Type of the input value
  * @param input Target object
  * @returns Validation result with pascal case object
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function validatePascal<T>(input: unknown): IValidation<PascalCase<T>>;
 
-/**
- * @internal
- */
+/** @internal */
 export function validatePascal(): never {
   return NoTransformConfigurationError("notations.validatePascal");
 }
@@ -314,27 +300,26 @@ export function validatePascal(): never {
 /**
  * Convert to snake case.
  *
- * Convert every property names of nested objects to follow the snake case convention.
+ * Convert every property names of nested objects to follow the snake case
+ * convention.
  *
- * For reference, this `typia.notations.snake()` function 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 them below:
+ * For reference, this `typia.notations.snake()` function 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 them below:
  *
  * - {@link assertSnake}
  * - {@link isSnake}
  * - {@link validateSnake}
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Type of the input value
  * @param input Target object
  * @returns Snake case object
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function snake<T>(input: T): SnakeCase<T>;
 
-/**
- * @internal
- */
+/** @internal */
 export function snake(): never {
   return NoTransformConfigurationError("notations.snake");
 }
@@ -342,15 +327,15 @@ export function snake(): never {
 /**
  * Converts to snake case with type assertion.
  *
- * Convert every property names of nested objects to follow the snake case convention.
- * If the input value does not follow the type `T`, it throws {@link TypeGuardError}.
+ * Convert every property names of nested objects to follow the snake case
+ * convention. If the input value does not follow the type `T`, it throws
+ * {@link TypeGuardError}.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Type of the input value
  * @param input Target object
  * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns Snake case object
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function assertSnake<T>(
   input: T,
@@ -360,24 +345,22 @@ export function assertSnake<T>(
 /**
  * Converts to snake case with type assertion.
  *
- * Convert every property names of nested objects to follow the snake case convention.
- * If the input value does not follow the type `T`, it throws {@link TypeGuardError}.
+ * Convert every property names of nested objects to follow the snake case
+ * convention. If the input value does not follow the type `T`, it throws
+ * {@link TypeGuardError}.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Type of the input value
  * @param input Target object
  * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns Snake case object
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function assertSnake<T>(
   input: unknown,
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
 ): SnakeCase<T>;
 
-/**
- * @internal
- */
+/** @internal */
 export function assertSnake(): never {
   return NoTransformConfigurationError("notations.assertSnake");
 }
@@ -385,34 +368,32 @@ export function assertSnake(): never {
 /**
  * Converts to snake case with type checking.
  *
- * Convert every property names of nested objects to follow the snake case convention.
- * If the input value does not follow the type `T`, it returns `null` value instead.
+ * Convert every property names of nested objects to follow the snake case
+ * convention. If the input value does not follow the type `T`, it returns
+ * `null` value instead.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Type of the input value
  * @param input Target object
  * @returns Snake case object when exact type, otherwise null
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function isSnake<T>(input: T): SnakeCase<T> | null;
 
 /**
  * Converts to snake case with type checking.
  *
- * Convert every property names of nested objects to follow the snake case convention.
- * If the input value does not follow the type `T`, it returns `null` value instead.
+ * Convert every property names of nested objects to follow the snake case
+ * convention. If the input value does not follow the type `T`, it returns
+ * `null` value instead.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Type of the input value
  * @param input Target object
  * @returns Snake case object when exact type, otherwise null
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function isSnake<T>(input: unknown): SnakeCase<T> | null;
 
-/**
- * @internal
- */
+/** @internal */
 export function isSnake(): never {
   return NoTransformConfigurationError("notations.isSnake");
 }
@@ -420,38 +401,36 @@ export function isSnake(): never {
 /**
  * Converts to snake case with type validation.
  *
- * Convert every property names of nested objects to follow the snake case convention.
- * If the input value does not follow the type `T`, it returns {@link IValidation.Failure}
- * object. Otherwise, there's no problem on the input value, snake cased converted data
- * would be stored in the `data` property of the output {@link IValidation.Success} object.
+ * Convert every property names of nested objects to follow the snake case
+ * convention. If the input value does not follow the type `T`, it returns
+ * {@link IValidation.Failure} object. Otherwise, there's no problem on the input
+ * value, snake cased converted data would be stored in the `data` property of
+ * the output {@link IValidation.Success} object.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Type of the input value
  * @param input Target object
  * @returns Validation result with snake case object
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function validateSnake<T>(input: T): IValidation<SnakeCase<T>>;
 
 /**
  * Converts to snake case with type validation.
  *
- * Convert every property names of nested objects to follow the snake case convention.
- * If the input value does not follow the type `T`, it returns {@link IValidation.Failure}
- * object. Otherwise, there's no problem on the input value, snake cased converted data
- * would be stored in the `data` property of the output {@link IValidation.Success} object.
+ * Convert every property names of nested objects to follow the snake case
+ * convention. If the input value does not follow the type `T`, it returns
+ * {@link IValidation.Failure} object. Otherwise, there's no problem on the input
+ * value, snake cased converted data would be stored in the `data` property of
+ * the output {@link IValidation.Success} object.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Type of the input value
  * @param input Target object
  * @returns Validation result with snake case object
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function validateSnake<T>(input: unknown): IValidation<SnakeCase<T>>;
 
-/**
- * @internal
- */
+/** @internal */
 export function validateSnake(): never {
   return NoTransformConfigurationError("notations.validateSnake");
 }
@@ -462,27 +441,23 @@ export function validateSnake(): never {
 /**
  * Creates a reusable {@link camel} function.
  *
- * @danger You must configure the generic argument `T`
- * @returns Nothing until be configure the generic argument `T`
- * @throws compile error
- *
  * @author Jeongho Nam - https://github.com/samchon
+ * @returns Nothing until be configure the generic argument `T`
+ * @throws Compile error
+ * @danger You must configure the generic argument `T`
  */
 export function createCamel(): never;
 
 /**
  * Creates a reusable {@link camel} function.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Type of the input value
  * @returns A reusable `camel` function
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function createCamel<T>(): (input: T) => CamelCase<T>;
 
-/**
- * @internal
- */
+/** @internal */
 export function createCamel(): never {
   NoTransformConfigurationError("notations.createCamel");
 }
@@ -490,12 +465,11 @@ export function createCamel(): never {
 /**
  * Creates a reusable {@link assertCamel} function.
  *
- * @danger You must configure the generic argument `T`
+ * @author Jeongho Nam - https://github.com/samchon
  * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns Nothing until be configure the generic argument `T`
- * @throws compile error
- *
- * @author Jeongho Nam - https://github.com/samchon
+ * @throws Compile error
+ * @danger You must configure the generic argument `T`
  */
 export function createAssertCamel(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
@@ -504,19 +478,16 @@ export function createAssertCamel(
 /**
  * Creates a reusable {@link assertCamel} function.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Type of the input value
  * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns A reusable `assertCamel` function
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function createAssertCamel<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
 ): (input: T) => CamelCase<T>;
 
-/**
- * @internal
- */
+/** @internal */
 export function createAssertCamel(): never {
   NoTransformConfigurationError("notations.createAssertCamel");
 }
@@ -524,27 +495,23 @@ export function createAssertCamel(): never {
 /**
  * Creates a reusable {@link isCamel} function.
  *
- * @danger You must configure the generic argument `T`
- * @returns Nothing until be configure the generic argument `T`
- * @throws compile error
- *
  * @author Jeongho Nam - https://github.com/samchon
+ * @returns Nothing until be configure the generic argument `T`
+ * @throws Compile error
+ * @danger You must configure the generic argument `T`
  */
 export function createIsCamel(): never;
 
 /**
  * Creates a reusable {@link isCamel} function.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Type of the input value
  * @returns A reusable `isCamel` function
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function createIsCamel<T>(): (input: T) => CamelCase<T> | null;
 
-/**
- * @internal
- */
+/** @internal */
 export function createIsCamel(): never {
   NoTransformConfigurationError("notations.createIsCamel");
 }
@@ -552,29 +519,25 @@ export function createIsCamel(): never {
 /**
  * Creates a reusable {@link validateCamel} function.
  *
- * @danger You must configure the generic argument `T`
- * @returns Nothing until be configure the generic argument `T`
- * @throws compile error
- *
  * @author Jeongho Nam - https://github.com/samchon
+ * @returns Nothing until be configure the generic argument `T`
+ * @throws Compile error
+ * @danger You must configure the generic argument `T`
  */
 export function createValidateCamel(): never;
 
 /**
  * Creates a reusable {@link validateCamel} function.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Type of the input value
  * @returns A reusable `validateCamel` function
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function createValidateCamel<T>(): (
   input: T,
 ) => IValidation<CamelCase<T>>;
 
-/**
- * @internal
- */
+/** @internal */
 export function createValidateCamel(): never {
   NoTransformConfigurationError("notations.createValidateCamel");
 }
@@ -582,27 +545,23 @@ export function createValidateCamel(): never {
 /**
  * Creates a reusable {@link pascal} function.
  *
- * @danger You must configure the generic argument `T`
- * @returns Nothing until be configure the generic argument `T`
- * @throws compile error
- *
  * @author Jeongho Nam - https://github.com/samchon
+ * @returns Nothing until be configure the generic argument `T`
+ * @throws Compile error
+ * @danger You must configure the generic argument `T`
  */
 export function createPascal(): never;
 
 /**
  * Creates a reusable {@link pascal} function.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Type of the input value
  * @returns A reusable `pascal` function
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function createPascal<T>(): (input: T) => PascalCase<T>;
 
-/**
- * @internal
- */
+/** @internal */
 export function createPascal(): never {
   NoTransformConfigurationError("notations.createPascal");
 }
@@ -610,12 +569,11 @@ export function createPascal(): never {
 /**
  * Creates a reusable {@link assertPascal} function.
  *
- * @danger You must configure the generic argument `T`
+ * @author Jeongho Nam - https://github.com/samchon
  * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns Nothing until be configure the generic argument `T`
- * @throws compile error
- *
- * @author Jeongho Nam - https://github.com/samchon
+ * @throws Compile error
+ * @danger You must configure the generic argument `T`
  */
 export function createAssertPascal(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
@@ -624,19 +582,16 @@ export function createAssertPascal(
 /**
  * Creates a reusable {@link assertPascal} function.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Type of the input value
  * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns A reusable `assertPascal` function
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function createAssertPascal<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
 ): (input: T) => PascalCase<T>;
 
-/**
- * @internal
- */
+/** @internal */
 export function createAssertPascal(): never {
   NoTransformConfigurationError("notations.createAssertPascal");
 }
@@ -644,27 +599,23 @@ export function createAssertPascal(): never {
 /**
  * Creates a reusable {@link isPascal} function.
  *
- * @danger You must configure the generic argument `T`
- * @returns Nothing until be configure the generic argument `T`
- * @throws compile error
- *
  * @author Jeongho Nam - https://github.com/samchon
+ * @returns Nothing until be configure the generic argument `T`
+ * @throws Compile error
+ * @danger You must configure the generic argument `T`
  */
 export function createIsPascal(): never;
 
 /**
  * Creates a reusable {@link isPascal} function.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Type of the input value
  * @returns A reusable `isPascal` function
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function createIsPascal<T>(): (input: T) => PascalCase<T> | null;
 
-/**
- * @internal
- */
+/** @internal */
 export function createIsPascal(): never {
   NoTransformConfigurationError("notations.createIsPascal");
 }
@@ -672,29 +623,25 @@ export function createIsPascal(): never {
 /**
  * Creates a reusable {@link validatePascal} function.
  *
- * @danger You must configure the generic argument `T`
- * @returns Nothing until be configure the generic argument `T`
- * @throws compile error
- *
  * @author Jeongho Nam - https://github.com/samchon
+ * @returns Nothing until be configure the generic argument `T`
+ * @throws Compile error
+ * @danger You must configure the generic argument `T`
  */
 export function createValidatePascal(): never;
 
 /**
  * Creates a reusable {@link validatePascal} function.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Type of the input value
  * @returns A reusable `validatePascal` function
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function createValidatePascal<T>(): (
   input: T,
 ) => IValidation<PascalCase<T>>;
 
-/**
- * @internal
- */
+/** @internal */
 export function createValidatePascal(): never {
   NoTransformConfigurationError("notations.createValidatePascal");
 }
@@ -702,27 +649,23 @@ export function createValidatePascal(): never {
 /**
  * Creates a reusable {@link snake} function.
  *
- * @danger You must configure the generic argument `T`
- * @returns Nothing until be configure the generic argument `T`
- * @throws compile error
- *
  * @author Jeongho Nam - https://github.com/samchon
+ * @returns Nothing until be configure the generic argument `T`
+ * @throws Compile error
+ * @danger You must configure the generic argument `T`
  */
 export function createSnake(): never;
 
 /**
  * Creates a reusable {@link snake} function.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Type of the input value
  * @returns A reusable `snake` function
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function createSnake<T>(): (input: T) => SnakeCase<T>;
 
-/**
- * @internal
- */
+/** @internal */
 export function createSnake(): never {
   NoTransformConfigurationError("notations.createSnake");
 }
@@ -730,12 +673,11 @@ export function createSnake(): never {
 /**
  * Creates a reusable {@link assertSnake} function.
  *
- * @danger You must configure the generic argument `T`
+ * @author Jeongho Nam - https://github.com/samchon
  * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns Nothing until be configure the generic argument `T`
- * @throws compile error
- *
- * @author Jeongho Nam - https://github.com/samchon
+ * @throws Compile error
+ * @danger You must configure the generic argument `T`
  */
 export function createAssertSnake(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
@@ -744,19 +686,16 @@ export function createAssertSnake(
 /**
  * Creates a reusable {@link assertSnake} function.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Type of the input value
  * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns A reusable `assertSnake` function
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function createAssertSnake<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
 ): (input: T) => SnakeCase<T>;
 
-/**
- * @internal
- */
+/** @internal */
 export function createAssertSnake(): never {
   NoTransformConfigurationError("notations.createAssertSnake");
 }
@@ -764,27 +703,23 @@ export function createAssertSnake(): never {
 /**
  * Creates a reusable {@link isSnake} function.
  *
- * @danger You must configure the generic argument `T`
- * @returns Nothing until be configure the generic argument `T`
- * @throws compile error
- *
  * @author Jeongho Nam - https://github.com/samchon
+ * @returns Nothing until be configure the generic argument `T`
+ * @throws Compile error
+ * @danger You must configure the generic argument `T`
  */
 export function createIsSnake(): never;
 
 /**
  * Creates a reusable {@link isSnake} function.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Type of the input value
  * @returns A reusable `isSnake` function
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function createIsSnake<T>(): (input: T) => SnakeCase<T> | null;
 
-/**
- * @internal
- */
+/** @internal */
 export function createIsSnake(): never {
   NoTransformConfigurationError("notations.createIsSnake");
 }
@@ -792,29 +727,25 @@ export function createIsSnake(): never {
 /**
  * Creates a reusable {@link validateSnake} function.
  *
- * @danger You must configure the generic argument `T`
- * @returns Nothing until be configure the generic argument `T`
- * @throws compile error
- *
  * @author Jeongho Nam - https://github.com/samchon
+ * @returns Nothing until be configure the generic argument `T`
+ * @throws Compile error
+ * @danger You must configure the generic argument `T`
  */
 export function createValidateSnake(): never;
 
 /**
  * Creates a reusable {@link validateSnake} function.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Type of the input value
  * @returns A reusable `validateSnake` function
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function createValidateSnake<T>(): (
   input: T,
 ) => IValidation<SnakeCase<T>>;
 
-/**
- * @internal
- */
+/** @internal */
 export function createValidateSnake(): never {
   NoTransformConfigurationError("notations.createValidateSnake");
 }