typia 5.3.11 → 5.3.12-dev.20240118

package/lib/notations.d.ts

@@ -21,7 +21,14 @@ import { SnakeCase } from "./SnakeCase";
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function camel<T>(input: T): CamelCase<T>;
+declare function camel<T>(input: T): CamelCase<T>;
+declare const camelPure: typeof camel & {
+    any: (input: any) => any;
+    throws: (props: Pick<import("./TypeGuardError").TypeGuardError.IProps, "expected" | "value">) => never;
+    is_between: (value: number, minimum: number, maximum: number) => boolean;
+    is_bigint_string: (str: string) => boolean;
+};
+export { camelPure as camel };
 /**
  * Converts to camel case with type assertion.
  *
@@ -34,7 +41,7 @@ export declare function camel<T>(input: T): CamelCase<T>;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function assertCamel<T>(input: T): CamelCase<T>;
+declare function assertCamel<T>(input: T): CamelCase<T>;
 /**
  * Converts to camel case with type assertion.
  *
@@ -47,7 +54,21 @@ export declare function assertCamel<T>(input: T): CamelCase<T>;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function assertCamel<T>(input: unknown): CamelCase<T>;
+declare function assertCamel<T>(input: unknown): CamelCase<T>;
+declare const assertCamelPure: typeof assertCamel & {
+    any: (input: any) => any;
+    throws: (props: Pick<import("./TypeGuardError").TypeGuardError.IProps, "expected" | "value">) => never;
+    is_between: (value: number, minimum: number, maximum: number) => boolean;
+    is_bigint_string: (str: string) => boolean;
+} & {
+    join: (str: string) => string;
+    every: <T>(array: T[], pred: (value: T, i: number) => Omit<import("./TypeGuardError").TypeGuardError.IProps, "method"> | null) => Omit<import("./TypeGuardError").TypeGuardError.IProps, "method"> | null;
+    guard: (exceptionable: boolean, props: Omit<import("./TypeGuardError").TypeGuardError.IProps, "method">) => boolean;
+    predicate: (matched: boolean, exceptionable: boolean, closure: () => Omit<import("./TypeGuardError").TypeGuardError.IProps, "method">) => boolean;
+    is_between: (value: number, minimum: number, maximum: number) => boolean;
+    is_bigint_string: (str: string) => boolean;
+};
+export { assertCamelPure as assertCamel };
 /**
  * Converts to camel case with type checking.
  *
@@ -60,7 +81,7 @@ export declare function assertCamel<T>(input: unknown): CamelCase<T>;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function isCamel<T>(input: T): CamelCase<T> | null;
+declare function isCamel<T>(input: T): CamelCase<T> | null;
 /**
  * Converts to camel case with type checking.
  *
@@ -73,7 +94,17 @@ export declare function isCamel<T>(input: T): CamelCase<T> | null;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function isCamel<T>(input: unknown): CamelCase<T> | null;
+declare function isCamel<T>(input: unknown): CamelCase<T> | null;
+declare const isCamelPure: typeof isCamel & {
+    any: (input: any) => any;
+    throws: (props: Pick<import("./TypeGuardError").TypeGuardError.IProps, "expected" | "value">) => never;
+    is_between: (value: number, minimum: number, maximum: number) => boolean;
+    is_bigint_string: (str: string) => boolean;
+} & {
+    is_between: (value: number, minimum: number, maximum: number) => boolean;
+    is_bigint_string: (str: string) => boolean;
+};
+export { isCamelPure as isCamel };
 /**
  * Converts to camel case with type validation.
  *
@@ -88,7 +119,7 @@ export declare function isCamel<T>(input: unknown): CamelCase<T> | null;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function validateCamel<T>(input: T): IValidation<CamelCase<T>>;
+declare function validateCamel<T>(input: T): IValidation<CamelCase<T>>;
 /**
  * Converts to camel case with type validation.
  *
@@ -103,7 +134,20 @@ export declare function validateCamel<T>(input: T): IValidation<CamelCase<T>>;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function validateCamel<T>(input: unknown): IValidation<CamelCase<T>>;
+declare function validateCamel<T>(input: unknown): IValidation<CamelCase<T>>;
+declare const validateCamelPure: typeof validateCamel & {
+    any: (input: any) => any;
+    throws: (props: Pick<import("./TypeGuardError").TypeGuardError.IProps, "expected" | "value">) => never;
+    is_between: (value: number, minimum: number, maximum: number) => boolean;
+    is_bigint_string: (str: string) => boolean;
+} & {
+    join: (str: string) => string;
+    report: (array: IValidation.IError[]) => (exceptable: boolean, error: IValidation.IError) => false;
+    predicate: (res: IValidation) => (matched: boolean, exceptionable: boolean, closure: () => IValidation.IError) => boolean;
+    is_between: (value: number, minimum: number, maximum: number) => boolean;
+    is_bigint_string: (str: string) => boolean;
+};
+export { validateCamelPure as validateCamel };
 /**
  * Convert to pascal case.
  *
@@ -123,7 +167,14 @@ export declare function validateCamel<T>(input: unknown): IValidation<CamelCase<
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function pascal<T>(input: T): PascalCase<T>;
+declare function pascal<T>(input: T): PascalCase<T>;
+declare const pascalPure: typeof pascal & {
+    any: (input: any) => any;
+    throws: (props: Pick<import("./TypeGuardError").TypeGuardError.IProps, "expected" | "value">) => never;
+    is_between: (value: number, minimum: number, maximum: number) => boolean;
+    is_bigint_string: (str: string) => boolean;
+};
+export { pascalPure as pascal };
 /**
  * Converts to pascal case with type assertion.
  *
@@ -136,7 +187,7 @@ export declare function pascal<T>(input: T): PascalCase<T>;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function assertPascal<T>(input: T): PascalCase<T>;
+declare function assertPascal<T>(input: T): PascalCase<T>;
 /**
  * Converts to pascal case with type assertion.
  *
@@ -149,7 +200,21 @@ export declare function assertPascal<T>(input: T): PascalCase<T>;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function assertPascal<T>(input: unknown): PascalCase<T>;
+declare function assertPascal<T>(input: unknown): PascalCase<T>;
+declare const assertPascalPure: typeof assertPascal & {
+    any: (input: any) => any;
+    throws: (props: Pick<import("./TypeGuardError").TypeGuardError.IProps, "expected" | "value">) => never;
+    is_between: (value: number, minimum: number, maximum: number) => boolean;
+    is_bigint_string: (str: string) => boolean;
+} & {
+    join: (str: string) => string;
+    every: <T>(array: T[], pred: (value: T, i: number) => Omit<import("./TypeGuardError").TypeGuardError.IProps, "method"> | null) => Omit<import("./TypeGuardError").TypeGuardError.IProps, "method"> | null;
+    guard: (exceptionable: boolean, props: Omit<import("./TypeGuardError").TypeGuardError.IProps, "method">) => boolean;
+    predicate: (matched: boolean, exceptionable: boolean, closure: () => Omit<import("./TypeGuardError").TypeGuardError.IProps, "method">) => boolean;
+    is_between: (value: number, minimum: number, maximum: number) => boolean;
+    is_bigint_string: (str: string) => boolean;
+};
+export { assertPascalPure as assertPascal };
 /**
  * Converts to pascal case with type checking.
  *
@@ -162,7 +227,7 @@ export declare function assertPascal<T>(input: unknown): PascalCase<T>;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function isPascal<T>(input: T): PascalCase<T> | null;
+declare function isPascal<T>(input: T): PascalCase<T> | null;
 /**
  * Converts to pascal case with type checking.
  *
@@ -175,7 +240,17 @@ export declare function isPascal<T>(input: T): PascalCase<T> | null;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function isPascal<T>(input: unknown): PascalCase<T> | null;
+declare function isPascal<T>(input: unknown): PascalCase<T> | null;
+declare const isPascalPure: typeof isPascal & {
+    any: (input: any) => any;
+    throws: (props: Pick<import("./TypeGuardError").TypeGuardError.IProps, "expected" | "value">) => never;
+    is_between: (value: number, minimum: number, maximum: number) => boolean;
+    is_bigint_string: (str: string) => boolean;
+} & {
+    is_between: (value: number, minimum: number, maximum: number) => boolean;
+    is_bigint_string: (str: string) => boolean;
+};
+export { isPascalPure as isPascal };
 /**
  * Converts to pascal case with type validation.
  *
@@ -190,7 +265,7 @@ export declare function isPascal<T>(input: unknown): PascalCase<T> | null;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function validatePascal<T>(input: T): IValidation<PascalCase<T>>;
+declare function validatePascal<T>(input: T): IValidation<PascalCase<T>>;
 /**
  * Converts to pascal case with type validation.
  *
@@ -205,7 +280,20 @@ export declare function validatePascal<T>(input: T): IValidation<PascalCase<T>>;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function validatePascal<T>(input: unknown): IValidation<PascalCase<T>>;
+declare function validatePascal<T>(input: unknown): IValidation<PascalCase<T>>;
+declare const validatePascalPure: typeof validatePascal & {
+    any: (input: any) => any;
+    throws: (props: Pick<import("./TypeGuardError").TypeGuardError.IProps, "expected" | "value">) => never;
+    is_between: (value: number, minimum: number, maximum: number) => boolean;
+    is_bigint_string: (str: string) => boolean;
+} & {
+    join: (str: string) => string;
+    report: (array: IValidation.IError[]) => (exceptable: boolean, error: IValidation.IError) => false;
+    predicate: (res: IValidation) => (matched: boolean, exceptionable: boolean, closure: () => IValidation.IError) => boolean;
+    is_between: (value: number, minimum: number, maximum: number) => boolean;
+    is_bigint_string: (str: string) => boolean;
+};
+export { validatePascalPure as validatePascal };
 /**
  * Convert to snake case.
  *
@@ -225,7 +313,14 @@ export declare function validatePascal<T>(input: unknown): IValidation<PascalCas
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function snake<T>(input: T): SnakeCase<T>;
+declare function snake<T>(input: T): SnakeCase<T>;
+declare const snakePure: typeof snake & {
+    any: (input: any) => any;
+    throws: (props: Pick<import("./TypeGuardError").TypeGuardError.IProps, "expected" | "value">) => never;
+    is_between: (value: number, minimum: number, maximum: number) => boolean;
+    is_bigint_string: (str: string) => boolean;
+};
+export { snakePure as snake };
 /**
  * Converts to snake case with type assertion.
  *
@@ -238,7 +333,7 @@ export declare function snake<T>(input: T): SnakeCase<T>;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function assertSnake<T>(input: T): SnakeCase<T>;
+declare function assertSnake<T>(input: T): SnakeCase<T>;
 /**
  * Converts to snake case with type assertion.
  *
@@ -251,7 +346,21 @@ export declare function assertSnake<T>(input: T): SnakeCase<T>;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function assertSnake<T>(input: unknown): SnakeCase<T>;
+declare function assertSnake<T>(input: unknown): SnakeCase<T>;
+declare const assertSnakePure: typeof assertSnake & {
+    any: (input: any) => any;
+    throws: (props: Pick<import("./TypeGuardError").TypeGuardError.IProps, "expected" | "value">) => never;
+    is_between: (value: number, minimum: number, maximum: number) => boolean;
+    is_bigint_string: (str: string) => boolean;
+} & {
+    join: (str: string) => string;
+    every: <T>(array: T[], pred: (value: T, i: number) => Omit<import("./TypeGuardError").TypeGuardError.IProps, "method"> | null) => Omit<import("./TypeGuardError").TypeGuardError.IProps, "method"> | null;
+    guard: (exceptionable: boolean, props: Omit<import("./TypeGuardError").TypeGuardError.IProps, "method">) => boolean;
+    predicate: (matched: boolean, exceptionable: boolean, closure: () => Omit<import("./TypeGuardError").TypeGuardError.IProps, "method">) => boolean;
+    is_between: (value: number, minimum: number, maximum: number) => boolean;
+    is_bigint_string: (str: string) => boolean;
+};
+export { assertSnakePure as assertSnake };
 /**
  * Converts to snake case with type checking.
  *
@@ -264,7 +373,7 @@ export declare function assertSnake<T>(input: unknown): SnakeCase<T>;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function isSnake<T>(input: T): SnakeCase<T> | null;
+declare function isSnake<T>(input: T): SnakeCase<T> | null;
 /**
  * Converts to snake case with type checking.
  *
@@ -277,7 +386,17 @@ export declare function isSnake<T>(input: T): SnakeCase<T> | null;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function isSnake<T>(input: unknown): SnakeCase<T> | null;
+declare function isSnake<T>(input: unknown): SnakeCase<T> | null;
+declare const isSnakePure: typeof isSnake & {
+    any: (input: any) => any;
+    throws: (props: Pick<import("./TypeGuardError").TypeGuardError.IProps, "expected" | "value">) => never;
+    is_between: (value: number, minimum: number, maximum: number) => boolean;
+    is_bigint_string: (str: string) => boolean;
+} & {
+    is_between: (value: number, minimum: number, maximum: number) => boolean;
+    is_bigint_string: (str: string) => boolean;
+};
+export { isSnakePure as isSnake };
 /**
  * Converts to snake case with type validation.
  *
@@ -292,7 +411,7 @@ export declare function isSnake<T>(input: unknown): SnakeCase<T> | null;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function validateSnake<T>(input: T): IValidation<SnakeCase<T>>;
+declare function validateSnake<T>(input: T): IValidation<SnakeCase<T>>;
 /**
  * Converts to snake case with type validation.
  *
@@ -307,7 +426,20 @@ export declare function validateSnake<T>(input: T): IValidation<SnakeCase<T>>;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function validateSnake<T>(input: unknown): IValidation<SnakeCase<T>>;
+declare function validateSnake<T>(input: unknown): IValidation<SnakeCase<T>>;
+declare const validateSnakePure: typeof validateSnake & {
+    any: (input: any) => any;
+    throws: (props: Pick<import("./TypeGuardError").TypeGuardError.IProps, "expected" | "value">) => never;
+    is_between: (value: number, minimum: number, maximum: number) => boolean;
+    is_bigint_string: (str: string) => boolean;
+} & {
+    join: (str: string) => string;
+    report: (array: IValidation.IError[]) => (exceptable: boolean, error: IValidation.IError) => false;
+    predicate: (res: IValidation) => (matched: boolean, exceptionable: boolean, closure: () => IValidation.IError) => boolean;
+    is_between: (value: number, minimum: number, maximum: number) => boolean;
+    is_bigint_string: (str: string) => boolean;
+};
+export { validateSnakePure as validateSnake };
 /**
  * Creates a reusable {@link camel} function.
  *
@@ -317,7 +449,7 @@ export declare function validateSnake<T>(input: unknown): IValidation<SnakeCase<
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function createCamel(): never;
+declare function createCamel(): never;
 /**
  * Creates a reusable {@link camel} function.
  *
@@ -326,7 +458,14 @@ export declare function createCamel(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function createCamel<T>(): (input: T) => CamelCase<T>;
+declare function createCamel<T>(): (input: T) => CamelCase<T>;
+declare const createCamelPure: typeof createCamel & {
+    any: (input: any) => any;
+    throws: (props: Pick<import("./TypeGuardError").TypeGuardError.IProps, "expected" | "value">) => never;
+    is_between: (value: number, minimum: number, maximum: number) => boolean;
+    is_bigint_string: (str: string) => boolean;
+};
+export { createCamelPure as createCamel };
 /**
  * Creates a reusable {@link assertCamel} function.
  *
@@ -336,7 +475,7 @@ export declare function createCamel<T>(): (input: T) => CamelCase<T>;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function createAssertCamel(): never;
+declare function createAssertCamel(): never;
 /**
  * Creates a reusable {@link assertCamel} function.
  *
@@ -345,7 +484,21 @@ export declare function createAssertCamel(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function createAssertCamel<T>(): (input: T) => CamelCase<T>;
+declare function createAssertCamel<T>(): (input: T) => CamelCase<T>;
+declare const createAssertCamelPure: typeof createAssertCamel & {
+    any: (input: any) => any;
+    throws: (props: Pick<import("./TypeGuardError").TypeGuardError.IProps, "expected" | "value">) => never;
+    is_between: (value: number, minimum: number, maximum: number) => boolean;
+    is_bigint_string: (str: string) => boolean;
+} & {
+    join: (str: string) => string;
+    every: <T>(array: T[], pred: (value: T, i: number) => Omit<import("./TypeGuardError").TypeGuardError.IProps, "method"> | null) => Omit<import("./TypeGuardError").TypeGuardError.IProps, "method"> | null;
+    guard: (exceptionable: boolean, props: Omit<import("./TypeGuardError").TypeGuardError.IProps, "method">) => boolean;
+    predicate: (matched: boolean, exceptionable: boolean, closure: () => Omit<import("./TypeGuardError").TypeGuardError.IProps, "method">) => boolean;
+    is_between: (value: number, minimum: number, maximum: number) => boolean;
+    is_bigint_string: (str: string) => boolean;
+};
+export { createAssertCamelPure as createAssertCamel };
 /**
  * Creates a reusable {@link isCamel} function.
  *
@@ -355,7 +508,7 @@ export declare function createAssertCamel<T>(): (input: T) => CamelCase<T>;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function createIsCamel(): never;
+declare function createIsCamel(): never;
 /**
  * Creates a reusable {@link isCamel} function.
  *
@@ -364,7 +517,17 @@ export declare function createIsCamel(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function createIsCamel<T>(): (input: T) => CamelCase<T> | null;
+declare function createIsCamel<T>(): (input: T) => CamelCase<T> | null;
+declare const createIsCamelPure: typeof createIsCamel & {
+    any: (input: any) => any;
+    throws: (props: Pick<import("./TypeGuardError").TypeGuardError.IProps, "expected" | "value">) => never;
+    is_between: (value: number, minimum: number, maximum: number) => boolean;
+    is_bigint_string: (str: string) => boolean;
+} & {
+    is_between: (value: number, minimum: number, maximum: number) => boolean;
+    is_bigint_string: (str: string) => boolean;
+};
+export { createIsCamelPure as createIsCamel };
 /**
  * Creates a reusable {@link validateCamel} function.
  *
@@ -374,7 +537,7 @@ export declare function createIsCamel<T>(): (input: T) => CamelCase<T> | null;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function createValidateCamel(): never;
+declare function createValidateCamel(): never;
 /**
  * Creates a reusable {@link validateCamel} function.
  *
@@ -383,7 +546,20 @@ export declare function createValidateCamel(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function createValidateCamel<T>(): (input: T) => IValidation<CamelCase<T>>;
+declare function createValidateCamel<T>(): (input: T) => IValidation<CamelCase<T>>;
+declare const createValidateCamelPure: typeof createValidateCamel & {
+    any: (input: any) => any;
+    throws: (props: Pick<import("./TypeGuardError").TypeGuardError.IProps, "expected" | "value">) => never;
+    is_between: (value: number, minimum: number, maximum: number) => boolean;
+    is_bigint_string: (str: string) => boolean;
+} & {
+    join: (str: string) => string;
+    report: (array: IValidation.IError[]) => (exceptable: boolean, error: IValidation.IError) => false;
+    predicate: (res: IValidation) => (matched: boolean, exceptionable: boolean, closure: () => IValidation.IError) => boolean;
+    is_between: (value: number, minimum: number, maximum: number) => boolean;
+    is_bigint_string: (str: string) => boolean;
+};
+export { createValidateCamelPure as createValidateCamel };
 /**
  * Creates a reusable {@link pascal} function.
  *
@@ -393,7 +569,7 @@ export declare function createValidateCamel<T>(): (input: T) => IValidation<Came
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function createPascal(): never;
+declare function createPascal(): never;
 /**
  * Creates a reusable {@link pascal} function.
  *
@@ -402,7 +578,14 @@ export declare function createPascal(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function createPascal<T>(): (input: T) => PascalCase<T>;
+declare function createPascal<T>(): (input: T) => PascalCase<T>;
+declare const createPascalPure: typeof createPascal & {
+    any: (input: any) => any;
+    throws: (props: Pick<import("./TypeGuardError").TypeGuardError.IProps, "expected" | "value">) => never;
+    is_between: (value: number, minimum: number, maximum: number) => boolean;
+    is_bigint_string: (str: string) => boolean;
+};
+export { createPascalPure as createPascal };
 /**
  * Creates a reusable {@link assertPascal} function.
  *
@@ -412,7 +595,7 @@ export declare function createPascal<T>(): (input: T) => PascalCase<T>;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function createAssertPascal(): never;
+declare function createAssertPascal(): never;
 /**
  * Creates a reusable {@link assertPascal} function.
  *
@@ -421,7 +604,21 @@ export declare function createAssertPascal(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function createAssertPascal<T>(): (input: T) => PascalCase<T>;
+declare function createAssertPascal<T>(): (input: T) => PascalCase<T>;
+declare const createAssertPascalPure: typeof createAssertPascal & {
+    any: (input: any) => any;
+    throws: (props: Pick<import("./TypeGuardError").TypeGuardError.IProps, "expected" | "value">) => never;
+    is_between: (value: number, minimum: number, maximum: number) => boolean;
+    is_bigint_string: (str: string) => boolean;
+} & {
+    join: (str: string) => string;
+    every: <T>(array: T[], pred: (value: T, i: number) => Omit<import("./TypeGuardError").TypeGuardError.IProps, "method"> | null) => Omit<import("./TypeGuardError").TypeGuardError.IProps, "method"> | null;
+    guard: (exceptionable: boolean, props: Omit<import("./TypeGuardError").TypeGuardError.IProps, "method">) => boolean;
+    predicate: (matched: boolean, exceptionable: boolean, closure: () => Omit<import("./TypeGuardError").TypeGuardError.IProps, "method">) => boolean;
+    is_between: (value: number, minimum: number, maximum: number) => boolean;
+    is_bigint_string: (str: string) => boolean;
+};
+export { createAssertPascalPure as createAssertPascal };
 /**
  * Creates a reusable {@link isPascal} function.
  *
@@ -431,7 +628,7 @@ export declare function createAssertPascal<T>(): (input: T) => PascalCase<T>;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function createIsPascal(): never;
+declare function createIsPascal(): never;
 /**
  * Creates a reusable {@link isPascal} function.
  *
@@ -440,7 +637,17 @@ export declare function createIsPascal(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function createIsPascal<T>(): (input: T) => PascalCase<T> | null;
+declare function createIsPascal<T>(): (input: T) => PascalCase<T> | null;
+declare const createIsPascalPure: typeof createIsPascal & {
+    any: (input: any) => any;
+    throws: (props: Pick<import("./TypeGuardError").TypeGuardError.IProps, "expected" | "value">) => never;
+    is_between: (value: number, minimum: number, maximum: number) => boolean;
+    is_bigint_string: (str: string) => boolean;
+} & {
+    is_between: (value: number, minimum: number, maximum: number) => boolean;
+    is_bigint_string: (str: string) => boolean;
+};
+export { createIsPascalPure as createIsPascal };
 /**
  * Creates a reusable {@link validatePascal} function.
  *
@@ -450,7 +657,7 @@ export declare function createIsPascal<T>(): (input: T) => PascalCase<T> | null;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function createValidatePascal(): never;
+declare function createValidatePascal(): never;
 /**
  * Creates a reusable {@link validatePascal} function.
  *
@@ -459,7 +666,20 @@ export declare function createValidatePascal(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function createValidatePascal<T>(): (input: T) => IValidation<PascalCase<T>>;
+declare function createValidatePascal<T>(): (input: T) => IValidation<PascalCase<T>>;
+declare const createValidatePascalPure: typeof createValidatePascal & {
+    any: (input: any) => any;
+    throws: (props: Pick<import("./TypeGuardError").TypeGuardError.IProps, "expected" | "value">) => never;
+    is_between: (value: number, minimum: number, maximum: number) => boolean;
+    is_bigint_string: (str: string) => boolean;
+} & {
+    join: (str: string) => string;
+    report: (array: IValidation.IError[]) => (exceptable: boolean, error: IValidation.IError) => false;
+    predicate: (res: IValidation) => (matched: boolean, exceptionable: boolean, closure: () => IValidation.IError) => boolean;
+    is_between: (value: number, minimum: number, maximum: number) => boolean;
+    is_bigint_string: (str: string) => boolean;
+};
+export { createValidatePascalPure as createValidatePascal };
 /**
  * Creates a reusable {@link snake} function.
  *
@@ -469,7 +689,7 @@ export declare function createValidatePascal<T>(): (input: T) => IValidation<Pas
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function createSnake(): never;
+declare function createSnake(): never;
 /**
  * Creates a reusable {@link snake} function.
  *
@@ -478,7 +698,14 @@ export declare function createSnake(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function createSnake<T>(): (input: T) => SnakeCase<T>;
+declare function createSnake<T>(): (input: T) => SnakeCase<T>;
+declare const createSnakePure: typeof createSnake & {
+    any: (input: any) => any;
+    throws: (props: Pick<import("./TypeGuardError").TypeGuardError.IProps, "expected" | "value">) => never;
+    is_between: (value: number, minimum: number, maximum: number) => boolean;
+    is_bigint_string: (str: string) => boolean;
+};
+export { createSnakePure as createSnake };
 /**
  * Creates a reusable {@link assertSnake} function.
  *
@@ -488,7 +715,7 @@ export declare function createSnake<T>(): (input: T) => SnakeCase<T>;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function createAssertSnake(): never;
+declare function createAssertSnake(): never;
 /**
  * Creates a reusable {@link assertSnake} function.
  *
@@ -497,7 +724,21 @@ export declare function createAssertSnake(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function createAssertSnake<T>(): (input: T) => SnakeCase<T>;
+declare function createAssertSnake<T>(): (input: T) => SnakeCase<T>;
+declare const createAssertSnakePure: typeof createAssertSnake & {
+    any: (input: any) => any;
+    throws: (props: Pick<import("./TypeGuardError").TypeGuardError.IProps, "expected" | "value">) => never;
+    is_between: (value: number, minimum: number, maximum: number) => boolean;
+    is_bigint_string: (str: string) => boolean;
+} & {
+    join: (str: string) => string;
+    every: <T>(array: T[], pred: (value: T, i: number) => Omit<import("./TypeGuardError").TypeGuardError.IProps, "method"> | null) => Omit<import("./TypeGuardError").TypeGuardError.IProps, "method"> | null;
+    guard: (exceptionable: boolean, props: Omit<import("./TypeGuardError").TypeGuardError.IProps, "method">) => boolean;
+    predicate: (matched: boolean, exceptionable: boolean, closure: () => Omit<import("./TypeGuardError").TypeGuardError.IProps, "method">) => boolean;
+    is_between: (value: number, minimum: number, maximum: number) => boolean;
+    is_bigint_string: (str: string) => boolean;
+};
+export { createAssertSnakePure as createAssertSnake };
 /**
  * Creates a reusable {@link isSnake} function.
  *
@@ -507,7 +748,7 @@ export declare function createAssertSnake<T>(): (input: T) => SnakeCase<T>;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function createIsSnake(): never;
+declare function createIsSnake(): never;
 /**
  * Creates a reusable {@link isSnake} function.
  *
@@ -516,7 +757,17 @@ export declare function createIsSnake(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function createIsSnake<T>(): (input: T) => SnakeCase<T> | null;
+declare function createIsSnake<T>(): (input: T) => SnakeCase<T> | null;
+declare const createIsSnakePure: typeof createIsSnake & {
+    any: (input: any) => any;
+    throws: (props: Pick<import("./TypeGuardError").TypeGuardError.IProps, "expected" | "value">) => never;
+    is_between: (value: number, minimum: number, maximum: number) => boolean;
+    is_bigint_string: (str: string) => boolean;
+} & {
+    is_between: (value: number, minimum: number, maximum: number) => boolean;
+    is_bigint_string: (str: string) => boolean;
+};
+export { createIsSnakePure as createIsSnake };
 /**
  * Creates a reusable {@link validateSnake} function.
  *
@@ -526,7 +777,7 @@ export declare function createIsSnake<T>(): (input: T) => SnakeCase<T> | null;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function createValidateSnake(): never;
+declare function createValidateSnake(): never;
 /**
  * Creates a reusable {@link validateSnake} function.
  *
@@ -535,4 +786,17 @@ export declare function createValidateSnake(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare function createValidateSnake<T>(): (input: T) => IValidation<SnakeCase<T>>;
+declare function createValidateSnake<T>(): (input: T) => IValidation<SnakeCase<T>>;
+declare const createValidateSnakePure: typeof createValidateSnake & {
+    any: (input: any) => any;
+    throws: (props: Pick<import("./TypeGuardError").TypeGuardError.IProps, "expected" | "value">) => never;
+    is_between: (value: number, minimum: number, maximum: number) => boolean;
+    is_bigint_string: (str: string) => boolean;
+} & {
+    join: (str: string) => string;
+    report: (array: IValidation.IError[]) => (exceptable: boolean, error: IValidation.IError) => false;
+    predicate: (res: IValidation) => (matched: boolean, exceptionable: boolean, closure: () => IValidation.IError) => boolean;
+    is_between: (value: number, minimum: number, maximum: number) => boolean;
+    is_bigint_string: (str: string) => boolean;
+};
+export { createValidateSnakePure as createValidateSnake };