typia 6.0.0-dev.20240122 → 6.0.0

package/src/notations.ts

@@ -1,7 +1,10 @@
+import * as Namespace from "./functional/Namespace";
+
 import { CamelCase } from "./CamelCase";
 import { IValidation } from "./IValidation";
 import { PascalCase } from "./PascalCase";
 import { SnakeCase } from "./SnakeCase";
+import { TypeGuardError } from "./TypeGuardError";
 
 /* ===========================================================
     NOTATIONS (NAMING CONVENTIONS)
@@ -31,14 +34,19 @@ import { SnakeCase } from "./SnakeCase";
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function camel<T>(input: T): CamelCase<T>;
+function camel<T>(input: T): CamelCase<T>;
 
 /**
  * @internal
  */
-export function camel(): never {
+function camel(): never {
   return halt("camel");
 }
+const camelPure = /** @__PURE__ */ Object.assign<typeof camel, {}>(
+  camel,
+  /** @__PURE__ */ Namespace.notations.camel("camel"),
+);
+export { camelPure as camel };
 
 /**
  * Converts to camel case with type assertion.
@@ -48,11 +56,15 @@ export function camel(): never {
  *
  * @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): CamelCase<T>;
+function assertCamel<T>(
+  input: T,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): CamelCase<T>;
 
 /**
  * Converts to camel case with type assertion.
@@ -62,18 +74,32 @@ export function assertCamel<T>(input: T): CamelCase<T>;
  *
  * @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): CamelCase<T>;
+function assertCamel<T>(
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): CamelCase<T>;
 
 /**
  * @internal
  */
-export function assertCamel(): never {
+function assertCamel(): never {
   return halt("assertCamel");
 }
+const assertCamelPure = /** @__PURE__ */ Object.assign<
+  typeof assertCamel,
+  {},
+  {}
+>(
+  assertCamel,
+  /** @__PURE__ */ Namespace.notations.camel("assertCamel"),
+  /** @__PURE__ */ Namespace.assert("notations.assertCamel"),
+);
+export { assertCamelPure as assertCamel };
 
 /**
  * Converts to camel case with type checking.
@@ -87,7 +113,7 @@ export function assertCamel(): never {
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function isCamel<T>(input: T): CamelCase<T> | null;
+function isCamel<T>(input: T): CamelCase<T> | null;
 
 /**
  * Converts to camel case with type checking.
@@ -101,14 +127,20 @@ export function isCamel<T>(input: T): CamelCase<T> | null;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function isCamel<T>(input: unknown): CamelCase<T> | null;
+function isCamel<T>(input: unknown): CamelCase<T> | null;
 
 /**
  * @internal
  */
-export function isCamel(): never {
+function isCamel(): never {
   return halt("isCamel");
 }
+const isCamelPure = /** @__PURE__ */ Object.assign<typeof isCamel, {}, {}>(
+  isCamel,
+  /** @__PURE__ */ Namespace.notations.camel("isCamel"),
+  /** @__PURE__ */ Namespace.is(),
+);
+export { isCamelPure as isCamel };
 
 /**
  * Converts to camel case with type validation.
@@ -124,7 +156,7 @@ export function isCamel(): never {
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function validateCamel<T>(input: T): IValidation<CamelCase<T>>;
+function validateCamel<T>(input: T): IValidation<CamelCase<T>>;
 
 /**
  * Converts to camel case with type validation.
@@ -140,14 +172,24 @@ export function validateCamel<T>(input: T): IValidation<CamelCase<T>>;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function validateCamel<T>(input: unknown): IValidation<CamelCase<T>>;
+function validateCamel<T>(input: unknown): IValidation<CamelCase<T>>;
 
 /**
  * @internal
  */
-export function validateCamel(): never {
+function validateCamel(): never {
   return halt("validateCamel");
 }
+const validateCamelPure = /** @__PURE__ */ Object.assign<
+  typeof validateCamel,
+  {},
+  {}
+>(
+  validateCamel,
+  /** @__PURE__ */ Namespace.notations.camel("validateCamel"),
+  /** @__PURE__ */ Namespace.validate(),
+);
+export { validateCamelPure as validateCamel };
 
 /* -----------------------------------------------------------
     PASCAL CASE
@@ -171,14 +213,19 @@ export function validateCamel(): never {
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function pascal<T>(input: T): PascalCase<T>;
+function pascal<T>(input: T): PascalCase<T>;
 
 /**
  * @internal
  */
-export function pascal(): never {
+function pascal(): never {
   return halt("pascal");
 }
+const pascalPure = /** @__PURE__ */ Object.assign<typeof pascal, {}>(
+  pascal,
+  /** @__PURE__ */ Namespace.notations.pascal("pascal"),
+);
+export { pascalPure as pascal };
 
 /**
  * Converts to pascal case with type assertion.
@@ -188,11 +235,15 @@ export function pascal(): never {
  *
  * @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): PascalCase<T>;
+function assertPascal<T>(
+  input: T,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): PascalCase<T>;
 
 /**
  * Converts to pascal case with type assertion.
@@ -202,18 +253,32 @@ export function assertPascal<T>(input: T): PascalCase<T>;
  *
  * @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): PascalCase<T>;
+function assertPascal<T>(
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): PascalCase<T>;
 
 /**
  * @internal
  */
-export function assertPascal(): never {
+function assertPascal(): never {
   return halt("assertPascal");
 }
+const assertPascalPure = /** @__PURE__ */ Object.assign<
+  typeof assertPascal,
+  {},
+  {}
+>(
+  assertPascal,
+  /** @__PURE__ */ Namespace.notations.pascal("assertPascal"),
+  /** @__PURE__ */ Namespace.assert("notations.assertPascal"),
+);
+export { assertPascalPure as assertPascal };
 
 /**
  * Converts to pascal case with type checking.
@@ -227,7 +292,7 @@ export function assertPascal(): never {
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function isPascal<T>(input: T): PascalCase<T> | null;
+function isPascal<T>(input: T): PascalCase<T> | null;
 
 /**
  * Converts to pascal case with type checking.
@@ -241,14 +306,20 @@ export function isPascal<T>(input: T): PascalCase<T> | null;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function isPascal<T>(input: unknown): PascalCase<T> | null;
+function isPascal<T>(input: unknown): PascalCase<T> | null;
 
 /**
  * @internal
  */
-export function isPascal(): never {
+function isPascal(): never {
   return halt("isPascal");
 }
+const isPascalPure = /** @__PURE__ */ Object.assign<typeof isPascal, {}, {}>(
+  isPascal,
+  /** @__PURE__ */ Namespace.notations.pascal("isPascal"),
+  /** @__PURE__ */ Namespace.is(),
+);
+export { isPascalPure as isPascal };
 
 /**
  * Converts to pascal case with type validation.
@@ -264,7 +335,7 @@ export function isPascal(): never {
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function validatePascal<T>(input: T): IValidation<PascalCase<T>>;
+function validatePascal<T>(input: T): IValidation<PascalCase<T>>;
 
 /**
  * Converts to pascal case with type validation.
@@ -280,14 +351,24 @@ export function validatePascal<T>(input: T): IValidation<PascalCase<T>>;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function validatePascal<T>(input: unknown): IValidation<PascalCase<T>>;
+function validatePascal<T>(input: unknown): IValidation<PascalCase<T>>;
 
 /**
  * @internal
  */
-export function validatePascal(): never {
+function validatePascal(): never {
   return halt("validatePascal");
 }
+const validatePascalPure = /** @__PURE__ */ Object.assign<
+  typeof validatePascal,
+  {},
+  {}
+>(
+  validatePascal,
+  /** @__PURE__ */ Namespace.notations.pascal("validatePascal"),
+  /** @__PURE__ */ Namespace.validate(),
+);
+export { validatePascalPure as validatePascal };
 
 /* -----------------------------------------------------------
     SNAKE CASE
@@ -311,14 +392,19 @@ export function validatePascal(): never {
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function snake<T>(input: T): SnakeCase<T>;
+function snake<T>(input: T): SnakeCase<T>;
 
 /**
  * @internal
  */
-export function snake(): never {
+function snake(): never {
   return halt("snake");
 }
+const snakePure = /** @__PURE__ */ Object.assign<typeof snake, {}>(
+  snake,
+  /** @__PURE__ */ Namespace.notations.snake("snake"),
+);
+export { snakePure as snake };
 
 /**
  * Converts to snake case with type assertion.
@@ -328,11 +414,15 @@ export function snake(): never {
  *
  * @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): SnakeCase<T>;
+function assertSnake<T>(
+  input: T,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): SnakeCase<T>;
 
 /**
  * Converts to snake case with type assertion.
@@ -342,18 +432,32 @@ export function assertSnake<T>(input: T): SnakeCase<T>;
  *
  * @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): SnakeCase<T>;
+function assertSnake<T>(
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): SnakeCase<T>;
 
 /**
  * @internal
  */
-export function assertSnake(): never {
+function assertSnake(): never {
   return halt("assertSnake");
 }
+const assertSnakePure = /** @__PURE__ */ Object.assign<
+  typeof assertSnake,
+  {},
+  {}
+>(
+  assertSnake,
+  /** @__PURE__ */ Namespace.notations.snake("assertSnake"),
+  /** @__PURE__ */ Namespace.assert("notations.assertSnake"),
+);
+export { assertSnakePure as assertSnake };
 
 /**
  * Converts to snake case with type checking.
@@ -367,7 +471,7 @@ export function assertSnake(): never {
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function isSnake<T>(input: T): SnakeCase<T> | null;
+function isSnake<T>(input: T): SnakeCase<T> | null;
 
 /**
  * Converts to snake case with type checking.
@@ -381,14 +485,20 @@ export function isSnake<T>(input: T): SnakeCase<T> | null;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function isSnake<T>(input: unknown): SnakeCase<T> | null;
+function isSnake<T>(input: unknown): SnakeCase<T> | null;
 
 /**
  * @internal
  */
-export function isSnake(): never {
+function isSnake(): never {
   return halt("isSnake");
 }
+const isSnakePure = /** @__PURE__ */ Object.assign<typeof isSnake, {}, {}>(
+  isSnake,
+  /** @__PURE__ */ Namespace.notations.snake("isSnake"),
+  /** @__PURE__ */ Namespace.is(),
+);
+export { isSnakePure as isSnake };
 
 /**
  * Converts to snake case with type validation.
@@ -404,7 +514,7 @@ export function isSnake(): never {
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function validateSnake<T>(input: T): IValidation<SnakeCase<T>>;
+function validateSnake<T>(input: T): IValidation<SnakeCase<T>>;
 
 /**
  * Converts to snake case with type validation.
@@ -420,15 +530,24 @@ export function validateSnake<T>(input: T): IValidation<SnakeCase<T>>;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function validateSnake<T>(input: unknown): IValidation<SnakeCase<T>>;
+function validateSnake<T>(input: unknown): IValidation<SnakeCase<T>>;
 
 /**
  * @internal
  */
-export function validateSnake(): never {
+function validateSnake(): never {
   return halt("validateSnake");
 }
-
+const validateSnakePure = /** @__PURE__ */ Object.assign<
+  typeof validateSnake,
+  {},
+  {}
+>(
+  validateSnake,
+  /** @__PURE__ */ Namespace.notations.snake("validateSnake"),
+  /** @__PURE__ */ Namespace.validate(),
+);
+export { validateSnakePure as validateSnake };
 /* -----------------------------------------------------------
     FACTORY FUNCTIONS
 ----------------------------------------------------------- */
@@ -441,7 +560,7 @@ export function validateSnake(): never {
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createCamel(): never;
+function createCamel(): never;
 
 /**
  * Creates a reusable {@link camel} function.
@@ -451,42 +570,63 @@ export function createCamel(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createCamel<T>(): (input: T) => CamelCase<T>;
+function createCamel<T>(): (input: T) => CamelCase<T>;
 
 /**
  * @internal
  */
-export function createCamel(): never {
+function createCamel(): never {
   halt("createCamel");
 }
+const createCamelPure = /** @__PURE__ */ Object.assign<typeof createCamel, {}>(
+  createCamel,
+  /** @__PURE__ */ Namespace.notations.camel("createCamel"),
+);
+export { createCamelPure as createCamel };
 
 /**
  * Creates a reusable {@link assertCamel} function.
  *
  * @danger You must configure the generic argument `T`
+ * @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
  */
-export function createAssertCamel(): never;
+function createAssertCamel(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): never;
 
 /**
  * Creates a reusable {@link assertCamel} function.
  *
  * @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>(): (input: T) => CamelCase<T>;
+function createAssertCamel<T>(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): (input: T) => CamelCase<T>;
 
 /**
  * @internal
  */
-export function createAssertCamel(): never {
+function createAssertCamel(): never {
   halt("createAssertCamel");
 }
+const createAssertCamelPure = /** @__PURE__ */ Object.assign<
+  typeof createAssertCamel,
+  {},
+  {}
+>(
+  createAssertCamel,
+  /** @__PURE__ */ Namespace.notations.camel("createAssertCamel"),
+  /** @__PURE__ */ Namespace.assert("notations.createAssertCamel"),
+);
+export { createAssertCamelPure as createAssertCamel };
 
 /**
  * Creates a reusable {@link isCamel} function.
@@ -497,7 +637,7 @@ export function createAssertCamel(): never {
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createIsCamel(): never;
+function createIsCamel(): never;
 
 /**
  * Creates a reusable {@link isCamel} function.
@@ -507,14 +647,24 @@ export function createIsCamel(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createIsCamel<T>(): (input: T) => CamelCase<T> | null;
+function createIsCamel<T>(): (input: T) => CamelCase<T> | null;
 
 /**
  * @internal
  */
-export function createIsCamel(): never {
+function createIsCamel(): never {
   halt("createIsCamel");
 }
+const createIsCamelPure = /** @__PURE__ */ Object.assign<
+  typeof createIsCamel,
+  {},
+  {}
+>(
+  createIsCamel,
+  /** @__PURE__ */ Namespace.notations.camel("createIsCamel"),
+  /** @__PURE__ */ Namespace.is(),
+);
+export { createIsCamelPure as createIsCamel };
 
 /**
  * Creates a reusable {@link validateCamel} function.
@@ -525,7 +675,7 @@ export function createIsCamel(): never {
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createValidateCamel(): never;
+function createValidateCamel(): never;
 
 /**
  * Creates a reusable {@link validateCamel} function.
@@ -535,16 +685,24 @@ export function createValidateCamel(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createValidateCamel<T>(): (
-  input: T,
-) => IValidation<CamelCase<T>>;
+function createValidateCamel<T>(): (input: T) => IValidation<CamelCase<T>>;
 
 /**
  * @internal
  */
-export function createValidateCamel(): never {
+function createValidateCamel(): never {
   halt("createValidateCamel");
 }
+const createValidateCamelPure = /** @__PURE__ */ Object.assign<
+  typeof createValidateCamel,
+  {},
+  {}
+>(
+  createValidateCamel,
+  /** @__PURE__ */ Namespace.notations.camel("createValidateCamel"),
+  /** @__PURE__ */ Namespace.validate(),
+);
+export { createValidateCamelPure as createValidateCamel };
 
 /**
  * Creates a reusable {@link pascal} function.
@@ -555,7 +713,7 @@ export function createValidateCamel(): never {
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createPascal(): never;
+function createPascal(): never;
 
 /**
  * Creates a reusable {@link pascal} function.
@@ -565,42 +723,63 @@ export function createPascal(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createPascal<T>(): (input: T) => PascalCase<T>;
+function createPascal<T>(): (input: T) => PascalCase<T>;
 
 /**
  * @internal
  */
-export function createPascal(): never {
+function createPascal(): never {
   halt("createPascal");
 }
+const createPascalPure = /** @__PURE__ */ Object.assign<
+  typeof createPascal,
+  {}
+>(createPascal, /** @__PURE__ */ Namespace.notations.pascal("createPascal"));
+export { createPascalPure as createPascal };
 
 /**
  * Creates a reusable {@link assertPascal} function.
  *
  * @danger You must configure the generic argument `T`
+ * @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
  */
-export function createAssertPascal(): never;
+function createAssertPascal(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): never;
 
 /**
  * Creates a reusable {@link assertPascal} function.
  *
  * @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>(): (input: T) => PascalCase<T>;
+function createAssertPascal<T>(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): (input: T) => PascalCase<T>;
 
 /**
  * @internal
  */
-export function createAssertPascal(): never {
+function createAssertPascal(): never {
   halt("createAssertPascal");
 }
+const createAssertPascalPure = /** @__PURE__ */ Object.assign<
+  typeof createAssertPascal,
+  {},
+  {}
+>(
+  createAssertPascal,
+  /** @__PURE__ */ Namespace.notations.pascal("createAssertPascal"),
+  /** @__PURE__ */ Namespace.assert("notations.createAssertPascal"),
+);
+export { createAssertPascalPure as createAssertPascal };
 
 /**
  * Creates a reusable {@link isPascal} function.
@@ -611,7 +790,7 @@ export function createAssertPascal(): never {
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createIsPascal(): never;
+function createIsPascal(): never;
 
 /**
  * Creates a reusable {@link isPascal} function.
@@ -621,14 +800,24 @@ export function createIsPascal(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createIsPascal<T>(): (input: T) => PascalCase<T> | null;
+function createIsPascal<T>(): (input: T) => PascalCase<T> | null;
 
 /**
  * @internal
  */
-export function createIsPascal(): never {
+function createIsPascal(): never {
   halt("createIsPascal");
 }
+const createIsPascalPure = /** @__PURE__ */ Object.assign<
+  typeof createIsPascal,
+  {},
+  {}
+>(
+  createIsPascal,
+  /** @__PURE__ */ Namespace.notations.pascal("createIsPascal"),
+  /** @__PURE__ */ Namespace.is(),
+);
+export { createIsPascalPure as createIsPascal };
 
 /**
  * Creates a reusable {@link validatePascal} function.
@@ -639,7 +828,7 @@ export function createIsPascal(): never {
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createValidatePascal(): never;
+function createValidatePascal(): never;
 
 /**
  * Creates a reusable {@link validatePascal} function.
@@ -649,16 +838,24 @@ export function createValidatePascal(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createValidatePascal<T>(): (
-  input: T,
-) => IValidation<PascalCase<T>>;
+function createValidatePascal<T>(): (input: T) => IValidation<PascalCase<T>>;
 
 /**
  * @internal
  */
-export function createValidatePascal(): never {
+function createValidatePascal(): never {
   halt("createValidatePascal");
 }
+const createValidatePascalPure = /** @__PURE__ */ Object.assign<
+  typeof createValidatePascal,
+  {},
+  {}
+>(
+  createValidatePascal,
+  /** @__PURE__ */ Namespace.notations.pascal("createValidatePascal"),
+  /** @__PURE__ */ Namespace.validate(),
+);
+export { createValidatePascalPure as createValidatePascal };
 
 /**
  * Creates a reusable {@link snake} function.
@@ -669,7 +866,7 @@ export function createValidatePascal(): never {
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createSnake(): never;
+function createSnake(): never;
 
 /**
  * Creates a reusable {@link snake} function.
@@ -679,42 +876,63 @@ export function createSnake(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createSnake<T>(): (input: T) => SnakeCase<T>;
+function createSnake<T>(): (input: T) => SnakeCase<T>;
 
 /**
  * @internal
  */
-export function createSnake(): never {
+function createSnake(): never {
   halt("createSnake");
 }
+const createSnakePure = /** @__PURE__ */ Object.assign<typeof createSnake, {}>(
+  createSnake,
+  /** @__PURE__ */ Namespace.notations.snake("createSnake"),
+);
+export { createSnakePure as createSnake };
 
 /**
  * Creates a reusable {@link assertSnake} function.
  *
  * @danger You must configure the generic argument `T`
+ * @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
  */
-export function createAssertSnake(): never;
+function createAssertSnake(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): never;
 
 /**
  * Creates a reusable {@link assertSnake} function.
  *
  * @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>(): (input: T) => SnakeCase<T>;
+function createAssertSnake<T>(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): (input: T) => SnakeCase<T>;
 
 /**
  * @internal
  */
-export function createAssertSnake(): never {
+function createAssertSnake(): never {
   halt("createAssertSnake");
 }
+const createAssertSnakePure = /** @__PURE__ */ Object.assign<
+  typeof createAssertSnake,
+  {},
+  {}
+>(
+  createAssertSnake,
+  /** @__PURE__ */ Namespace.notations.snake("createAssertSnake"),
+  /** @__PURE__ */ Namespace.assert("notations.createAssertSnake"),
+);
+export { createAssertSnakePure as createAssertSnake };
 
 /**
  * Creates a reusable {@link isSnake} function.
@@ -725,7 +943,7 @@ export function createAssertSnake(): never {
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createIsSnake(): never;
+function createIsSnake(): never;
 
 /**
  * Creates a reusable {@link isSnake} function.
@@ -735,14 +953,24 @@ export function createIsSnake(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createIsSnake<T>(): (input: T) => SnakeCase<T> | null;
+function createIsSnake<T>(): (input: T) => SnakeCase<T> | null;
 
 /**
  * @internal
  */
-export function createIsSnake(): never {
+function createIsSnake(): never {
   halt("createIsSnake");
 }
+const createIsSnakePure = /** @__PURE__ */ Object.assign<
+  typeof createIsSnake,
+  {},
+  {}
+>(
+  createIsSnake,
+  /** @__PURE__ */ Namespace.notations.snake("createIsSnake"),
+  /** @__PURE__ */ Namespace.is(),
+);
+export { createIsSnakePure as createIsSnake };
 
 /**
  * Creates a reusable {@link validateSnake} function.
@@ -753,7 +981,7 @@ export function createIsSnake(): never {
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createValidateSnake(): never;
+function createValidateSnake(): never;
 
 /**
  * Creates a reusable {@link validateSnake} function.
@@ -763,16 +991,24 @@ export function createValidateSnake(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createValidateSnake<T>(): (
-  input: T,
-) => IValidation<SnakeCase<T>>;
+function createValidateSnake<T>(): (input: T) => IValidation<SnakeCase<T>>;
 
 /**
  * @internal
  */
-export function createValidateSnake(): never {
+function createValidateSnake(): never {
   halt("createValidateSnake");
 }
+const createValidateSnakePure = /** @__PURE__ */ Object.assign<
+  typeof createValidateSnake,
+  {},
+  {}
+>(
+  createValidateSnake,
+  /** @__PURE__ */ Namespace.notations.snake("createValidateSnake"),
+  /** @__PURE__ */ Namespace.validate(),
+);
+export { createValidateSnakePure as createValidateSnake };
 
 /**
  * @internal