typia 3.7.3 → 3.7.4-dev.20230410-2

package/src/schemas/IJsonSchema.ts

@@ -1,121 +1,121 @@
-import { IJsDocTagInfo } from "../metadata/IJsDocTagInfo";
-import { IMetadataTag } from "../metadata/IMetadataTag";
-
-import { Atomic } from "../typings/Atomic";
-
-export type IJsonSchema = IJsonSchema.NotUnknown | IJsonSchema.IUnknown;
-export namespace IJsonSchema {
-    export type NotUnknown =
-        | IEnumeration<"boolean">
-        | IEnumeration<"number">
-        | IEnumeration<"string">
-        | IBoolean
-        | IInteger
-        | INumber
-        | IString
-        | IArray
-        | ITuple
-        | IOneOf
-        | IReference
-        | IRecursiveReference
-        | INullOnly;
-
-    /* -----------------------------------------------------------
-        ATOMICS
-    ----------------------------------------------------------- */
-    export interface IEnumeration<
-        Literal extends Exclude<Atomic.Literal, "bigint">,
-    > extends IAtomic<Literal> {
-        enum: Array<Atomic.Mapper[Literal]>;
-    }
-    export interface IAtomic<Literal extends Exclude<Atomic.Literal, "bigint">>
-        extends ISignificant<Literal> {
-        default?: Atomic.Mapper[Literal];
-    }
-    export interface IString extends IAtomic<"string"> {
-        /**
-         * @type uint
-         */
-        minLength?: number;
-        /**
-         * @type uint
-         */
-        maxLength?: number;
-        pattern?: string;
-        format?: string;
-    }
-    export interface INumber extends IAtomic<"number"> {
-        minimum?: number;
-        maximum?: number;
-        exclusiveMinimum?: boolean;
-        exclusiveMaximum?: boolean;
-        multipleOf?: number;
-    }
-    export interface IInteger extends IAtomic<"integer"> {
-        /**
-         * @type int
-         */
-        minimum?: number;
-        /**
-         * @type int
-         */
-        maximum?: number;
-        exclusiveMinimum?: boolean;
-        exclusiveMaximum?: boolean;
-        /**
-         * @type int
-         */
-        multipleOf?: number;
-    }
-    export interface IBoolean extends IAtomic<"boolean"> {}
-
-    /* -----------------------------------------------------------
-        OBJECTS
-    ----------------------------------------------------------- */
-    export interface IArray extends ISignificant<"array"> {
-        items: IJsonSchema;
-        /**
-         * @type uint
-         */
-        minItems?: number;
-        /**
-         * @type uint
-         */
-        maxItems?: number;
-        "x-typia-tuple"?: ITuple;
-    }
-    export interface ITuple extends ISignificant<"array"> {
-        items: IJsonSchema[];
-    }
-    export interface IReference extends IAttribute {
-        $ref: string;
-    }
-    export interface IRecursiveReference extends IAttribute {
-        $recursiveRef: string;
-    }
-    export interface INullOnly extends IAttribute {
-        type: "null";
-    }
-
-    /* -----------------------------------------------------------
-        MISCELLANEOUS
-    ----------------------------------------------------------- */
-    export interface IOneOf extends IAttribute {
-        oneOf: IJsonSchema[];
-    }
-    export interface IUnknown {}
-
-    export interface ISignificant<Literal extends string> extends IAttribute {
-        type: Literal;
-        nullable: boolean;
-    }
-    export interface IAttribute {
-        deprecated?: boolean;
-        title?: string;
-        description?: string;
-        "x-typia-metaTags"?: IMetadataTag[];
-        "x-typia-jsDocTags"?: IJsDocTagInfo[];
-        "x-typia-required"?: boolean;
-        "x-typia-rest"?: boolean;
-    }
-}
+import { IJsDocTagInfo } from "../metadata/IJsDocTagInfo";
+import { IMetadataTag } from "../metadata/IMetadataTag";
+
+import { Atomic } from "../typings/Atomic";
+
+export type IJsonSchema = IJsonSchema.NotUnknown | IJsonSchema.IUnknown;
+export namespace IJsonSchema {
+    export type NotUnknown =
+        | IEnumeration<"boolean">
+        | IEnumeration<"number">
+        | IEnumeration<"string">
+        | IBoolean
+        | IInteger
+        | INumber
+        | IString
+        | IArray
+        | ITuple
+        | IOneOf
+        | IReference
+        | IRecursiveReference
+        | INullOnly;
+
+    /* -----------------------------------------------------------
+        ATOMICS
+    ----------------------------------------------------------- */
+    export interface IEnumeration<
+        Literal extends Exclude<Atomic.Literal, "bigint">,
+    > extends IAtomic<Literal> {
+        enum: Array<Atomic.Mapper[Literal]>;
+    }
+    export interface IAtomic<Literal extends Exclude<Atomic.Literal, "bigint">>
+        extends ISignificant<Literal> {
+        default?: Atomic.Mapper[Literal];
+    }
+    export interface IString extends IAtomic<"string"> {
+        /**
+         * @type uint
+         */
+        minLength?: number;
+        /**
+         * @type uint
+         */
+        maxLength?: number;
+        pattern?: string;
+        format?: string;
+    }
+    export interface INumber extends IAtomic<"number"> {
+        minimum?: number;
+        maximum?: number;
+        exclusiveMinimum?: boolean;
+        exclusiveMaximum?: boolean;
+        multipleOf?: number;
+    }
+    export interface IInteger extends IAtomic<"integer"> {
+        /**
+         * @type int
+         */
+        minimum?: number;
+        /**
+         * @type int
+         */
+        maximum?: number;
+        exclusiveMinimum?: boolean;
+        exclusiveMaximum?: boolean;
+        /**
+         * @type int
+         */
+        multipleOf?: number;
+    }
+    export interface IBoolean extends IAtomic<"boolean"> {}
+
+    /* -----------------------------------------------------------
+        OBJECTS
+    ----------------------------------------------------------- */
+    export interface IArray extends ISignificant<"array"> {
+        items: IJsonSchema;
+        /**
+         * @type uint
+         */
+        minItems?: number;
+        /**
+         * @type uint
+         */
+        maxItems?: number;
+        "x-typia-tuple"?: ITuple;
+    }
+    export interface ITuple extends ISignificant<"array"> {
+        items: IJsonSchema[];
+    }
+    export interface IReference extends IAttribute {
+        $ref: string;
+    }
+    export interface IRecursiveReference extends IAttribute {
+        $recursiveRef: string;
+    }
+    export interface INullOnly extends IAttribute {
+        type: "null";
+    }
+
+    /* -----------------------------------------------------------
+        MISCELLANEOUS
+    ----------------------------------------------------------- */
+    export interface IOneOf extends IAttribute {
+        oneOf: IJsonSchema[];
+    }
+    export interface IUnknown {}
+
+    export interface ISignificant<Literal extends string> extends IAttribute {
+        type: Literal;
+        nullable: boolean;
+    }
+    export interface IAttribute {
+        deprecated?: boolean;
+        title?: string;
+        description?: string;
+        "x-typia-metaTags"?: IMetadataTag[];
+        "x-typia-jsDocTags"?: IJsDocTagInfo[];
+        "x-typia-required"?: boolean;
+        "x-typia-rest"?: boolean;
+    }
+}

package/src/transform.ts

@@ -1,21 +1,21 @@
-import ts from "typescript";
-
-import { FileTransformer } from "./transformers/FileTransformer";
-import { IProject } from "./transformers/IProject";
-import { ITransformOptions } from "./transformers/ITransformOptions";
-
-export function transform(
-    program: ts.Program,
-    options?: ITransformOptions,
-): ts.TransformerFactory<ts.SourceFile> {
-    const project: IProject = {
-        program,
-        compilerOptions: program.getCompilerOptions(),
-        checker: program.getTypeChecker(),
-        printer: ts.createPrinter(),
-        options: options || {},
-    };
-    return (context) => (file) =>
-        FileTransformer.transform(project, context, file);
-}
-export default transform;
+import ts from "typescript";
+
+import { FileTransformer } from "./transformers/FileTransformer";
+import { IProject } from "./transformers/IProject";
+import { ITransformOptions } from "./transformers/ITransformOptions";
+
+export function transform(
+    program: ts.Program,
+    options?: ITransformOptions,
+): ts.TransformerFactory<ts.SourceFile> {
+    const project: IProject = {
+        program,
+        compilerOptions: program.getCompilerOptions(),
+        checker: program.getTypeChecker(),
+        printer: ts.createPrinter(),
+        options: options || {},
+    };
+    return (context) => (file) =>
+        FileTransformer.transform(project, context, file);
+}
+export default transform;

package/src/transformers/CallExpressionTransformer.ts

@@ -1,174 +1,174 @@
-import path from "path";
-import ts from "typescript";
-
-import { IProject } from "./IProject";
-import { ApplicationTransformer } from "./features/miscellaneous/ApplicationTransformer";
-import { AssertCloneTransformer } from "./features/miscellaneous/AssertCloneTransformer";
-import { AssertPruneTransformer } from "./features/miscellaneous/AssertPruneTransformer";
-import { CloneTransformer } from "./features/miscellaneous/CloneTransformer";
-import { CreateAssertCloneTransformer } from "./features/miscellaneous/CreateAssertCloneTransformer";
-import { CreateAssertPruneTransformer } from "./features/miscellaneous/CreateAssertPruneTransformer";
-import { CreateCloneTransformer } from "./features/miscellaneous/CreateCloneTransformer";
-import { CreateIsCloneTransformer } from "./features/miscellaneous/CreateIsCloneTransformer";
-import { CreateIsPruneTransformer } from "./features/miscellaneous/CreateIsPruneTransformer";
-import { CreatePruneTransformer } from "./features/miscellaneous/CreatePruneTransformer";
-import { CreateRandomTransformer } from "./features/miscellaneous/CreateRandomTransformer";
-import { CreateValidateCloneTransformer } from "./features/miscellaneous/CreateValidateCloneTransformer";
-import { CreateValidatePruneTransformer } from "./features/miscellaneous/CreateValidatePruneTransformer";
-import { IsCloneTransformer } from "./features/miscellaneous/IsCloneTransformer";
-import { IsPruneTransformer } from "./features/miscellaneous/IsPruneTransformer";
-import { LiteralsTransformer } from "./features/miscellaneous/LiteralsTransformer";
-import { MetadataTransformer } from "./features/miscellaneous/MetadataTransformer";
-import { PruneTransformer } from "./features/miscellaneous/PruneTransformer";
-import { RandomTransformer } from "./features/miscellaneous/RandomTransformer";
-import { ValidateCloneTransformer } from "./features/miscellaneous/ValidateCloneTransformer";
-import { ValidatePruneTransformer } from "./features/miscellaneous/ValidatePruneTransformer";
-import { AssertParseTransformer } from "./features/parsers/AssertParseTransformer";
-import { CreateAssertParseTransformer } from "./features/parsers/CreateAssertParseTransformer";
-import { CreateIsParseTransformer } from "./features/parsers/CreateIsParseTransformer";
-import { CreateValidateParseTransformer } from "./features/parsers/CreateValidateParseTransformer";
-import { IsParseTransformer } from "./features/parsers/IsParseTransformer";
-import { ValidateParseTransformer } from "./features/parsers/ValidateParseTransformer";
-import { AssertStringifyTransformer } from "./features/stringifiers/AssertStringifyTransformer";
-import { CreateAssertStringifyTransformer } from "./features/stringifiers/CreateAssertStringifyTransformer";
-import { CreateIsStringifyTransformer } from "./features/stringifiers/CreateIsStringifyTransformer";
-import { CreateStringifyTransformer } from "./features/stringifiers/CreateStringifyTransformer";
-import { CreateValidateStringifyTransformer } from "./features/stringifiers/CreateValidateStringifyProgrammer";
-import { IsStringifyTransformer } from "./features/stringifiers/IsStringifyTransformer";
-import { StringifyTransformer } from "./features/stringifiers/StringifyTransformer";
-import { ValidateStringifyTransformer } from "./features/stringifiers/ValidateStringifyTransformer";
-import { AssertTransformer } from "./features/validators/AssertTransformer";
-import { CreateAssertTransformer } from "./features/validators/CreateAssertTransformer";
-import { CreateIsTransformer } from "./features/validators/CreateIsTransformer";
-import { CreateValidateTransformer } from "./features/validators/CreateValidateTransformer";
-import { IsTransformer } from "./features/validators/IsTransformer";
-import { ValidateTransformer } from "./features/validators/ValidateTransformer";
-
-export namespace CallExpressionTransformer {
-    export function transform(
-        project: IProject,
-        expression: ts.CallExpression,
-    ): ts.Expression {
-        //----
-        // VALIDATIONS
-        //----
-        // SIGNATURE DECLARATION
-        const declaration: ts.Declaration | undefined =
-            project.checker.getResolvedSignature(expression)?.declaration;
-        if (!declaration) return expression;
-
-        // FILE PATH
-        const file: string = path.resolve(declaration.getSourceFile().fileName);
-        if (
-            file.indexOf(LIB_PATH) === -1 &&
-            file !== SRC_PATH &&
-            file !== CLI_PATH
-        )
-            return expression;
-
-        //----
-        // TRANSFORMATION
-        //----
-        // FUNCTION NAME
-        const { name } = project.checker.getTypeAtLocation(declaration).symbol;
-
-        // FIND TRANSFORMER
-        const functor: (() => Task) | undefined = FUNCTORS[name];
-        if (functor === undefined) return expression;
-
-        // RETURNS WITH TRANSFORMATION
-        return functor()(project, expression.expression, expression);
-    }
-}
-
-type Task = (
-    project: IProject,
-    modulo: ts.LeftHandSideExpression,
-    expression: ts.CallExpression,
-) => ts.Expression;
-
-const LIB_PATH = path.join("node_modules", "typia", "lib", "module.d.ts");
-const SRC_PATH = path.resolve(path.join(__dirname, "..", "module.ts"));
-const CLI_PATH = path.resolve(
-    path.join(__dirname, "..", "..", "..", "src", "module.ts"),
-);
-
-const FUNCTORS: Record<string, () => Task> = {
-    //----
-    // SINGLE FUNCTIONS
-    //----
-    // BASIC VALIDATORS
-    assert: () => AssertTransformer.transform(false),
-    assertType: () => AssertTransformer.transform(false),
-    is: () => IsTransformer.transform(false),
-    validate: () => ValidateTransformer.transform(false),
-
-    // STRICT VALIDATORS
-    assertEquals: () => AssertTransformer.transform(true),
-    equals: () => IsTransformer.transform(true),
-    validateEquals: () => ValidateTransformer.transform(true),
-
-    // PARSE FUNCTIONS
-    isParse: () => IsParseTransformer.transform,
-    assertParse: () => AssertParseTransformer.transform,
-    validateParse: () => ValidateParseTransformer.transform,
-
-    // STRINGIFY FUNCTIONS
-    application: () => ApplicationTransformer.transform,
-    stringify: () => StringifyTransformer.transform,
-    assertStringify: () => AssertStringifyTransformer.transform,
-    isStringify: () => IsStringifyTransformer.transform,
-    validateStringify: () => ValidateStringifyTransformer.transform,
-
-    // MISC
-    metadata: () => MetadataTransformer.transform,
-    random: () => RandomTransformer.transform,
-    literals: () => LiteralsTransformer.transform,
-
-    clone: () => CloneTransformer.transform,
-    assertClone: () => AssertCloneTransformer.transform,
-    isClone: () => IsCloneTransformer.transform,
-    validateClone: () => ValidateCloneTransformer.transform,
-
-    prune: () => PruneTransformer.transform,
-    assertPrune: () => AssertPruneTransformer.transform,
-    isPrune: () => IsPruneTransformer.transform,
-    validatePrune: () => ValidatePruneTransformer.transform,
-
-    //----
-    // FACTORY FUNCTIONS
-    //----
-    // BASIC VALIDATORS
-    createAssert: () => CreateAssertTransformer.transform(false),
-    createAssertType: () => CreateAssertTransformer.transform(false),
-    createIs: () => CreateIsTransformer.transform(false),
-    createValidate: () => CreateValidateTransformer.transform(false),
-
-    // STRICT VALIDATORS
-    createAssertEquals: () => CreateAssertTransformer.transform(true),
-    createEquals: () => CreateIsTransformer.transform(true),
-    createValidateEquals: () => CreateValidateTransformer.transform(true),
-
-    // PARSE FUNCTIONS
-    createIsParse: () => CreateIsParseTransformer.transform,
-    createAssertParse: () => CreateAssertParseTransformer.transform,
-    createValidateParse: () => CreateValidateParseTransformer.transform,
-
-    // STRINGIFY FUNCTIONS
-    createStringify: () => CreateStringifyTransformer.transform,
-    createAssertStringify: () => CreateAssertStringifyTransformer.transform,
-    createIsStringify: () => CreateIsStringifyTransformer.transform,
-    createValidateStringify: () => CreateValidateStringifyTransformer.transform,
-
-    // MISC
-    createRandom: () => CreateRandomTransformer.transform,
-    createClone: () => CreateCloneTransformer.transform,
-    createAssertClone: () => CreateAssertCloneTransformer.transform,
-    createIsClone: () => CreateIsCloneTransformer.transform,
-    createValidateClone: () => CreateValidateCloneTransformer.transform,
-
-    createPrune: () => CreatePruneTransformer.transform,
-    createAssertPrune: () => CreateAssertPruneTransformer.transform,
-    createIsPrune: () => CreateIsPruneTransformer.transform,
-    createValidatePrune: () => CreateValidatePruneTransformer.transform,
-};
+import path from "path";
+import ts from "typescript";
+
+import { IProject } from "./IProject";
+import { ApplicationTransformer } from "./features/miscellaneous/ApplicationTransformer";
+import { AssertCloneTransformer } from "./features/miscellaneous/AssertCloneTransformer";
+import { AssertPruneTransformer } from "./features/miscellaneous/AssertPruneTransformer";
+import { CloneTransformer } from "./features/miscellaneous/CloneTransformer";
+import { CreateAssertCloneTransformer } from "./features/miscellaneous/CreateAssertCloneTransformer";
+import { CreateAssertPruneTransformer } from "./features/miscellaneous/CreateAssertPruneTransformer";
+import { CreateCloneTransformer } from "./features/miscellaneous/CreateCloneTransformer";
+import { CreateIsCloneTransformer } from "./features/miscellaneous/CreateIsCloneTransformer";
+import { CreateIsPruneTransformer } from "./features/miscellaneous/CreateIsPruneTransformer";
+import { CreatePruneTransformer } from "./features/miscellaneous/CreatePruneTransformer";
+import { CreateRandomTransformer } from "./features/miscellaneous/CreateRandomTransformer";
+import { CreateValidateCloneTransformer } from "./features/miscellaneous/CreateValidateCloneTransformer";
+import { CreateValidatePruneTransformer } from "./features/miscellaneous/CreateValidatePruneTransformer";
+import { IsCloneTransformer } from "./features/miscellaneous/IsCloneTransformer";
+import { IsPruneTransformer } from "./features/miscellaneous/IsPruneTransformer";
+import { LiteralsTransformer } from "./features/miscellaneous/LiteralsTransformer";
+import { MetadataTransformer } from "./features/miscellaneous/MetadataTransformer";
+import { PruneTransformer } from "./features/miscellaneous/PruneTransformer";
+import { RandomTransformer } from "./features/miscellaneous/RandomTransformer";
+import { ValidateCloneTransformer } from "./features/miscellaneous/ValidateCloneTransformer";
+import { ValidatePruneTransformer } from "./features/miscellaneous/ValidatePruneTransformer";
+import { AssertParseTransformer } from "./features/parsers/AssertParseTransformer";
+import { CreateAssertParseTransformer } from "./features/parsers/CreateAssertParseTransformer";
+import { CreateIsParseTransformer } from "./features/parsers/CreateIsParseTransformer";
+import { CreateValidateParseTransformer } from "./features/parsers/CreateValidateParseTransformer";
+import { IsParseTransformer } from "./features/parsers/IsParseTransformer";
+import { ValidateParseTransformer } from "./features/parsers/ValidateParseTransformer";
+import { AssertStringifyTransformer } from "./features/stringifiers/AssertStringifyTransformer";
+import { CreateAssertStringifyTransformer } from "./features/stringifiers/CreateAssertStringifyTransformer";
+import { CreateIsStringifyTransformer } from "./features/stringifiers/CreateIsStringifyTransformer";
+import { CreateStringifyTransformer } from "./features/stringifiers/CreateStringifyTransformer";
+import { CreateValidateStringifyTransformer } from "./features/stringifiers/CreateValidateStringifyProgrammer";
+import { IsStringifyTransformer } from "./features/stringifiers/IsStringifyTransformer";
+import { StringifyTransformer } from "./features/stringifiers/StringifyTransformer";
+import { ValidateStringifyTransformer } from "./features/stringifiers/ValidateStringifyTransformer";
+import { AssertTransformer } from "./features/validators/AssertTransformer";
+import { CreateAssertTransformer } from "./features/validators/CreateAssertTransformer";
+import { CreateIsTransformer } from "./features/validators/CreateIsTransformer";
+import { CreateValidateTransformer } from "./features/validators/CreateValidateTransformer";
+import { IsTransformer } from "./features/validators/IsTransformer";
+import { ValidateTransformer } from "./features/validators/ValidateTransformer";
+
+export namespace CallExpressionTransformer {
+    export function transform(
+        project: IProject,
+        expression: ts.CallExpression,
+    ): ts.Expression {
+        //----
+        // VALIDATIONS
+        //----
+        // SIGNATURE DECLARATION
+        const declaration: ts.Declaration | undefined =
+            project.checker.getResolvedSignature(expression)?.declaration;
+        if (!declaration) return expression;
+
+        // FILE PATH
+        const file: string = path.resolve(declaration.getSourceFile().fileName);
+        if (
+            file.indexOf(LIB_PATH) === -1 &&
+            file !== SRC_PATH &&
+            file !== CLI_PATH
+        )
+            return expression;
+
+        //----
+        // TRANSFORMATION
+        //----
+        // FUNCTION NAME
+        const { name } = project.checker.getTypeAtLocation(declaration).symbol;
+
+        // FIND TRANSFORMER
+        const functor: (() => Task) | undefined = FUNCTORS[name];
+        if (functor === undefined) return expression;
+
+        // RETURNS WITH TRANSFORMATION
+        return functor()(project, expression.expression, expression);
+    }
+}
+
+type Task = (
+    project: IProject,
+    modulo: ts.LeftHandSideExpression,
+    expression: ts.CallExpression,
+) => ts.Expression;
+
+const LIB_PATH = path.join("node_modules", "typia", "lib", "module.d.ts");
+const SRC_PATH = path.resolve(path.join(__dirname, "..", "module.ts"));
+const CLI_PATH = path.resolve(
+    path.join(__dirname, "..", "..", "..", "src", "module.ts"),
+);
+
+const FUNCTORS: Record<string, () => Task> = {
+    //----
+    // SINGLE FUNCTIONS
+    //----
+    // BASIC VALIDATORS
+    assert: () => AssertTransformer.transform(false),
+    assertType: () => AssertTransformer.transform(false),
+    is: () => IsTransformer.transform(false),
+    validate: () => ValidateTransformer.transform(false),
+
+    // STRICT VALIDATORS
+    assertEquals: () => AssertTransformer.transform(true),
+    equals: () => IsTransformer.transform(true),
+    validateEquals: () => ValidateTransformer.transform(true),
+
+    // PARSE FUNCTIONS
+    isParse: () => IsParseTransformer.transform,
+    assertParse: () => AssertParseTransformer.transform,
+    validateParse: () => ValidateParseTransformer.transform,
+
+    // STRINGIFY FUNCTIONS
+    application: () => ApplicationTransformer.transform,
+    stringify: () => StringifyTransformer.transform,
+    assertStringify: () => AssertStringifyTransformer.transform,
+    isStringify: () => IsStringifyTransformer.transform,
+    validateStringify: () => ValidateStringifyTransformer.transform,
+
+    // MISC
+    metadata: () => MetadataTransformer.transform,
+    random: () => RandomTransformer.transform,
+    literals: () => LiteralsTransformer.transform,
+
+    clone: () => CloneTransformer.transform,
+    assertClone: () => AssertCloneTransformer.transform,
+    isClone: () => IsCloneTransformer.transform,
+    validateClone: () => ValidateCloneTransformer.transform,
+
+    prune: () => PruneTransformer.transform,
+    assertPrune: () => AssertPruneTransformer.transform,
+    isPrune: () => IsPruneTransformer.transform,
+    validatePrune: () => ValidatePruneTransformer.transform,
+
+    //----
+    // FACTORY FUNCTIONS
+    //----
+    // BASIC VALIDATORS
+    createAssert: () => CreateAssertTransformer.transform(false),
+    createAssertType: () => CreateAssertTransformer.transform(false),
+    createIs: () => CreateIsTransformer.transform(false),
+    createValidate: () => CreateValidateTransformer.transform(false),
+
+    // STRICT VALIDATORS
+    createAssertEquals: () => CreateAssertTransformer.transform(true),
+    createEquals: () => CreateIsTransformer.transform(true),
+    createValidateEquals: () => CreateValidateTransformer.transform(true),
+
+    // PARSE FUNCTIONS
+    createIsParse: () => CreateIsParseTransformer.transform,
+    createAssertParse: () => CreateAssertParseTransformer.transform,
+    createValidateParse: () => CreateValidateParseTransformer.transform,
+
+    // STRINGIFY FUNCTIONS
+    createStringify: () => CreateStringifyTransformer.transform,
+    createAssertStringify: () => CreateAssertStringifyTransformer.transform,
+    createIsStringify: () => CreateIsStringifyTransformer.transform,
+    createValidateStringify: () => CreateValidateStringifyTransformer.transform,
+
+    // MISC
+    createRandom: () => CreateRandomTransformer.transform,
+    createClone: () => CreateCloneTransformer.transform,
+    createAssertClone: () => CreateAssertCloneTransformer.transform,
+    createIsClone: () => CreateIsCloneTransformer.transform,
+    createValidateClone: () => CreateValidateCloneTransformer.transform,
+
+    createPrune: () => CreatePruneTransformer.transform,
+    createAssertPrune: () => CreateAssertPruneTransformer.transform,
+    createIsPrune: () => CreateIsPruneTransformer.transform,
+    createValidatePrune: () => CreateValidatePruneTransformer.transform,
+};