typia 5.1.6 → 5.2.0-dev.20231007

package/src/programmers/notations/NotationIsGeneralProgrammer.ts

@@ -0,0 +1,79 @@
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { IProject } from "../../transformers/IProject";
+
+import { IsProgrammer } from "../IsProgrammer";
+import { NotationGeneralProgrammer } from "./NotationGeneralProgrammer";
+
+export namespace NotationIsGeneralProgrammer {
+    export const write =
+        (rename: (str: string) => string) =>
+        (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type, name?: string) =>
+            ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [
+                    IdentifierFactory.parameter(
+                        "input",
+                        TypeFactory.keyword("any"),
+                    ),
+                ],
+                ts.factory.createUnionTypeNode([
+                    ts.factory.createTypeReferenceNode(
+                        NotationGeneralProgrammer.returnType(rename)(
+                            name ??
+                                TypeFactory.getFullName(project.checker)(type),
+                        ),
+                    ),
+                    ts.factory.createLiteralTypeNode(ts.factory.createNull()),
+                ]),
+                undefined,
+                ts.factory.createBlock([
+                    StatementFactory.constant(
+                        "is",
+                        IsProgrammer.write(project)(modulo)(false)(type, name),
+                    ),
+                    StatementFactory.constant(
+                        "general",
+                        NotationGeneralProgrammer.write(rename)({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: false,
+                            },
+                        })(modulo)(type, name),
+                    ),
+                    ts.factory.createIfStatement(
+                        ts.factory.createPrefixUnaryExpression(
+                            ts.SyntaxKind.ExclamationToken,
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("is"),
+                                undefined,
+                                [ts.factory.createIdentifier("input")],
+                            ),
+                        ),
+                        ts.factory.createReturnStatement(
+                            ts.factory.createNull(),
+                        ),
+                    ),
+                    StatementFactory.constant(
+                        "output",
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("general"),
+                            undefined,
+                            [ts.factory.createIdentifier("input")],
+                        ),
+                    ),
+                    ts.factory.createReturnStatement(
+                        ts.factory.createIdentifier("output"),
+                    ),
+                ]),
+            );
+}

package/src/programmers/notations/NotationValidateGeneralProgrammer.ts

@@ -0,0 +1,88 @@
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { IProject } from "../../transformers/IProject";
+
+import { ValidateProgrammer } from "../ValidateProgrammer";
+import { NotationGeneralProgrammer } from "./NotationGeneralProgrammer";
+
+export namespace NotationValidateGeneralProgrammer {
+    export const write =
+        (rename: (str: string) => string) =>
+        (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type, name?: string) =>
+            ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [
+                    IdentifierFactory.parameter(
+                        "input",
+                        TypeFactory.keyword("any"),
+                    ),
+                ],
+                ts.factory.createTypeReferenceNode(
+                    `typia.IValidation<${NotationGeneralProgrammer.returnType(
+                        rename,
+                    )(
+                        name ?? TypeFactory.getFullName(project.checker)(type),
+                    )}>`,
+                ),
+                undefined,
+                ts.factory.createBlock([
+                    StatementFactory.constant(
+                        "validate",
+                        ValidateProgrammer.write({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: true,
+                            },
+                        })(modulo)(false)(type, name),
+                    ),
+                    StatementFactory.constant(
+                        "general",
+                        NotationGeneralProgrammer.write(rename)({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: false,
+                            },
+                        })(modulo)(type, name),
+                    ),
+                    StatementFactory.constant(
+                        "output",
+                        ts.factory.createAsExpression(
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("validate"),
+                                undefined,
+                                [ts.factory.createIdentifier("input")],
+                            ),
+                            TypeFactory.keyword("any"),
+                        ),
+                    ),
+                    ts.factory.createIfStatement(
+                        ts.factory.createIdentifier("output.success"),
+                        ts.factory.createExpressionStatement(
+                            ts.factory.createBinaryExpression(
+                                ts.factory.createIdentifier("output.data"),
+                                ts.SyntaxKind.EqualsToken,
+                                ts.factory.createCallExpression(
+                                    ts.factory.createIdentifier("general"),
+                                    undefined,
+                                    [ts.factory.createIdentifier("input")],
+                                ),
+                            ),
+                        ),
+                    ),
+                    ts.factory.createReturnStatement(
+                        ts.factory.createIdentifier("output"),
+                    ),
+                ]),
+            );
+}

package/src/transformers/CallExpressionTransformer.ts

@@ -1,6 +1,8 @@
 import path from "path";
 import ts from "typescript";
 
+import { NamingConvention } from "../utils/NamingConvention";
+
 import { IProject } from "./IProject";
 import { AssertTransformer } from "./features/AssertTransformer";
 import { CreateAssertTransformer } from "./features/CreateAssertTransformer";
@@ -61,16 +63,24 @@ import { MiscLiteralsTransformer } from "./features/misc/MiscLiteralsTransformer
 import { MiscPruneTransformer } from "./features/misc/MiscPruneTransformer";
 import { MiscValidateCloneTransformer } from "./features/misc/MiscValidateCloneTransformer";
 import { MiscValidatePruneTransformer } from "./features/misc/MiscValidatePruneTransformer";
-import { CreateProtobufAssertDecodeTransformer } from "./features/protobuf/CreateProtobufAssertDecodeTransformer";
-import { CreateProtobufAssertEncodeTransformer } from "./features/protobuf/CreateProtobufAssertEncodeTransformer";
-import { CreateProtobufDecodeTransformer } from "./features/protobuf/CreateProtobufDecodeTransformer";
-import { CreateProtobufEncodeTransformer } from "./features/protobuf/CreateProtobufEncodeTransformer";
-import { CreateProtobufIsDecodeTransformer } from "./features/protobuf/CreateProtobufIsDecodeTransformer";
-import { CreateProtobufIsEncodeTransformer } from "./features/protobuf/CreateProtobufIsEncodeTransformer";
-import { CreateProtobufValidateDecodeTransformer } from "./features/protobuf/CreateProtobufValidateDecodeTransformer";
-import { CreateProtobufValidateEncodeTransformer } from "./features/protobuf/CreateProtobufValidateEncodeTransformer";
+import { NotationAssertGeneralTransformer } from "./features/notations/NotationAssertGeneralTransformer";
+import { NotationCreateAssertGeneralTransformer } from "./features/notations/NotationCreateAssertGeneralTransformer";
+import { NotationCreateGeneralTransformer } from "./features/notations/NotationCreateGeneralTransformer";
+import { NotationCreateIsGeneralTransformer } from "./features/notations/NotationCreateIsGeneralTransformer";
+import { NotationCreateValidateGeneralTransformer } from "./features/notations/NotationCreateValidateGeneralTransformer";
+import { NotationGeneralTransformer } from "./features/notations/NotationGeneralTransformer";
+import { NotationIsGeneralTransformer } from "./features/notations/NotationIsGeneralTransformer";
+import { NotationValidateGeneralTransformer } from "./features/notations/NotationValidateGeneralTransformer";
 import { ProtobufAssertDecodeTransformer } from "./features/protobuf/ProtobufAssertDecodeTransformer";
 import { ProtobufAssertEncodeTransformer } from "./features/protobuf/ProtobufAssertEncodeTransformer";
+import { ProtobufCreateAssertDecodeTransformer } from "./features/protobuf/ProtobufCreateAssertDecodeTransformer";
+import { ProtobufCreateAssertEncodeTransformer } from "./features/protobuf/ProtobufCreateAssertEncodeTransformer";
+import { ProtobufCreateDecodeTransformer } from "./features/protobuf/ProtobufCreateDecodeTransformer";
+import { ProtobufCreateEncodeTransformer } from "./features/protobuf/ProtobufCreateEncodeTransformer";
+import { ProtobufCreateIsDecodeTransformer } from "./features/protobuf/ProtobufCreateIsDecodeTransformer";
+import { ProtobufCreateIsEncodeTransformer } from "./features/protobuf/ProtobufCreateIsEncodeTransformer";
+import { ProtobufCreateValidateDecodeTransformer } from "./features/protobuf/ProtobufCreateValidateDecodeTransformer";
+import { ProtobufCreateValidateEncodeTransformer } from "./features/protobuf/ProtobufCreateValidateEncodeTransformer";
 import { ProtobufDecodeTransformer } from "./features/protobuf/ProtobufDecodeTransformer";
 import { ProtobufEncodeTransformer } from "./features/protobuf/ProtobufEncodeTransformer";
 import { ProtobufIsDecodeTransformer } from "./features/protobuf/ProtobufIsDecodeTransformer";
@@ -247,18 +257,18 @@ const FUNCTORS: Record<string, Record<string, () => Task>> = {
         validateDecode: () => ProtobufValidateDecodeTransformer.transform,
 
         // FACTORIES
-        createEncode: () => CreateProtobufEncodeTransformer.transform,
+        createEncode: () => ProtobufCreateEncodeTransformer.transform,
         createAssertEncode: () =>
-            CreateProtobufAssertEncodeTransformer.transform,
-        createIsEncode: () => CreateProtobufIsEncodeTransformer.transform,
+            ProtobufCreateAssertEncodeTransformer.transform,
+        createIsEncode: () => ProtobufCreateIsEncodeTransformer.transform,
         createValidateEncode: () =>
-            CreateProtobufValidateEncodeTransformer.transform,
-        createDecode: () => CreateProtobufDecodeTransformer.transform,
+            ProtobufCreateValidateEncodeTransformer.transform,
+        createDecode: () => ProtobufCreateDecodeTransformer.transform,
         createAssertDecode: () =>
-            CreateProtobufAssertDecodeTransformer.transform,
-        createIsDecode: () => CreateProtobufIsDecodeTransformer.transform,
+            ProtobufCreateAssertDecodeTransformer.transform,
+        createIsDecode: () => ProtobufCreateIsDecodeTransformer.transform,
         createValidateDecode: () =>
-            CreateProtobufValidateDecodeTransformer.transform,
+            ProtobufCreateValidateDecodeTransformer.transform,
     },
     misc: {
         literals: () => (project) => () =>
@@ -286,4 +296,85 @@ const FUNCTORS: Record<string, Record<string, () => Task>> = {
         createIsPrune: () => MiscCreateIsPruneTransformer.transform,
         createValidatePrune: () => MiscCreateValidatePruneTransformer.transform,
     },
+    notations: {
+        // CAMEL
+        camel: () =>
+            NotationGeneralTransformer.transform(NamingConvention.camel),
+        assertCamel: () =>
+            NotationAssertGeneralTransformer.transform(NamingConvention.camel),
+        isCamel: () =>
+            NotationIsGeneralTransformer.transform(NamingConvention.camel),
+        validateCamel: () =>
+            NotationValidateGeneralTransformer.transform(
+                NamingConvention.camel,
+            ),
+
+        // PASCAL
+        pascal: () =>
+            NotationGeneralTransformer.transform(NamingConvention.pascal),
+        assertPascal: () =>
+            NotationAssertGeneralTransformer.transform(NamingConvention.pascal),
+        isPascal: () =>
+            NotationIsGeneralTransformer.transform(NamingConvention.pascal),
+        validatePascal: () =>
+            NotationValidateGeneralTransformer.transform(
+                NamingConvention.pascal,
+            ),
+
+        // SNAKE
+        snake: () =>
+            NotationGeneralTransformer.transform(NamingConvention.snake),
+        assertSnake: () =>
+            NotationAssertGeneralTransformer.transform(NamingConvention.snake),
+        isSnake: () =>
+            NotationIsGeneralTransformer.transform(NamingConvention.snake),
+        validateSnake: () =>
+            NotationValidateGeneralTransformer.transform(
+                NamingConvention.snake,
+            ),
+
+        // FACTORIES
+        createCamel: () =>
+            NotationCreateGeneralTransformer.transform(NamingConvention.camel),
+        createAssertCamel: () =>
+            NotationCreateAssertGeneralTransformer.transform(
+                NamingConvention.camel,
+            ),
+        createIsCamel: () =>
+            NotationCreateIsGeneralTransformer.transform(
+                NamingConvention.camel,
+            ),
+        createValidateCamel: () =>
+            NotationCreateValidateGeneralTransformer.transform(
+                NamingConvention.camel,
+            ),
+        createPascal: () =>
+            NotationCreateGeneralTransformer.transform(NamingConvention.pascal),
+        createAssertPascal: () =>
+            NotationCreateAssertGeneralTransformer.transform(
+                NamingConvention.pascal,
+            ),
+        createIsPascal: () =>
+            NotationCreateIsGeneralTransformer.transform(
+                NamingConvention.pascal,
+            ),
+        createValidatePascal: () =>
+            NotationCreateValidateGeneralTransformer.transform(
+                NamingConvention.pascal,
+            ),
+        createSnake: () =>
+            NotationCreateGeneralTransformer.transform(NamingConvention.snake),
+        createAssertSnake: () =>
+            NotationCreateAssertGeneralTransformer.transform(
+                NamingConvention.snake,
+            ),
+        createIsSnake: () =>
+            NotationCreateIsGeneralTransformer.transform(
+                NamingConvention.snake,
+            ),
+        createValidateSnake: () =>
+            NotationCreateValidateGeneralTransformer.transform(
+                NamingConvention.snake,
+            ),
+    },
 };

package/src/transformers/features/json/JsonAssertParseTransformer.ts

@@ -3,7 +3,7 @@ import { JsonAssertParseProgrammer } from "../../../programmers/json/JsonAssertP
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace JsonAssertParseTransformer {
-    export const transform = GenericTransformer.scalar("assertParse")(
+    export const transform = GenericTransformer.scalar("json.assertParse")(
         (project) => (modulo) =>
             JsonAssertParseProgrammer.write(project)(modulo),
     );

package/src/transformers/features/json/JsonAssertStringifyTransformer.ts

@@ -3,7 +3,7 @@ import { JsonAssertStringifyProgrammer } from "../../../programmers/json/JsonAss
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace JsonAssertStringifyTransformer {
-    export const transform = GenericTransformer.scalar("assertStringify")(
+    export const transform = GenericTransformer.scalar("json.assertStringify")(
         (project) => (modulo) =>
             JsonAssertStringifyProgrammer.write(project)(modulo),
     );

package/src/transformers/features/json/JsonCreateAssertParseTransformer.ts

@@ -3,7 +3,9 @@ import { JsonAssertParseProgrammer } from "../../../programmers/json/JsonAssertP
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace JsonCreateAssertParseTransformer {
-    export const transform = GenericTransformer.factory("createAssertParse")(
+    export const transform = GenericTransformer.factory(
+        "json.createAssertParse",
+    )(
         (project) => (modulo) =>
             JsonAssertParseProgrammer.write(project)(modulo),
     );

package/src/transformers/features/json/JsonCreateAssertStringifyTransformer.ts

@@ -4,7 +4,7 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace JsonCreateAssertStringifyTransformer {
     export const transform = GenericTransformer.factory(
-        "createAssertStringify",
+        "json.createAssertStringify",
     )(
         (project) => (modulo) =>
             JsonAssertStringifyProgrammer.write(project)(modulo),

package/src/transformers/features/json/JsonCreateIsParseTransformer.ts

@@ -3,7 +3,7 @@ import { JsonIsParseProgrammer } from "../../../programmers/json/JsonIsParseProg
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace JsonCreateIsParseTransformer {
-    export const transform = GenericTransformer.factory("createIsParse")(
+    export const transform = GenericTransformer.factory("json.createIsParse")(
         (project) => (modulo) => JsonIsParseProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/json/JsonCreateIsStringifyTransformer.ts

@@ -3,7 +3,9 @@ import { JsonIsStringifyProgrammer } from "../../../programmers/json/JsonIsStrin
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace JsonCreateIsStringifyTransformer {
-    export const transform = GenericTransformer.factory("createIsStringify")(
+    export const transform = GenericTransformer.factory(
+        "json.createIsStringify",
+    )(
         (project) => (modulo) =>
             JsonIsStringifyProgrammer.write(project)(modulo),
     );

package/src/transformers/features/json/JsonCreateStringifyTransformer.ts

@@ -3,7 +3,7 @@ import { JsonStringifyProgrammer } from "../../../programmers/json/JsonStringify
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace JsonCreateStringifyTransformer {
-    export const transform = GenericTransformer.factory("createStringify")(
+    export const transform = GenericTransformer.factory("json.createStringify")(
         (project) => (modulo) => JsonStringifyProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/json/JsonCreateValidateParseTransformer.ts

@@ -3,7 +3,9 @@ import { JsonValidateParseProgrammer } from "../../../programmers/json/JsonValid
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace JsonCreateValidateParseTransformer {
-    export const transform = GenericTransformer.factory("createValidateParse")(
+    export const transform = GenericTransformer.factory(
+        "json.createValidateParse",
+    )(
         (project) => (modulo) =>
             JsonValidateParseProgrammer.write(project)(modulo),
     );

package/src/transformers/features/json/JsonCreateValidateStringifyProgrammer.ts

@@ -4,7 +4,7 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace JsonCreateValidateStringifyTransformer {
     export const transform = GenericTransformer.factory(
-        "createValidateStringify",
+        "json.createValidateStringify",
     )(
         (project) => (modulo) =>
             JsonValidateStringifyProgrammer.write(project)(modulo),

package/src/transformers/features/json/JsonIsParseTransformer.ts

@@ -3,7 +3,7 @@ import { JsonIsParseProgrammer } from "../../../programmers/json/JsonIsParseProg
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace JsonIsParseTransformer {
-    export const transform = GenericTransformer.scalar("isParse")(
+    export const transform = GenericTransformer.scalar("json.isParse")(
         (project) => (modulo) => JsonIsParseProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/json/JsonIsStringifyTransformer.ts

@@ -3,7 +3,7 @@ import { JsonIsStringifyProgrammer } from "../../../programmers/json/JsonIsStrin
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace JsonIsStringifyTransformer {
-    export const transform = GenericTransformer.scalar("isStringify")(
+    export const transform = GenericTransformer.scalar("json.isStringify")(
         (project) => (modulo) =>
             JsonIsStringifyProgrammer.write(project)(modulo),
     );

package/src/transformers/features/json/JsonStringifyTransformer.ts

@@ -3,7 +3,7 @@ import { JsonStringifyProgrammer } from "../../../programmers/json/JsonStringify
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace JsonStringifyTransformer {
-    export const transform = GenericTransformer.scalar("stringify")(
+    export const transform = GenericTransformer.scalar("json.stringify")(
         (project) => (modulo) => JsonStringifyProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/json/JsonValidateParseTransformer.ts

@@ -3,7 +3,7 @@ import { JsonValidateParseProgrammer } from "../../../programmers/json/JsonValid
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace JsonValidateParseTransformer {
-    export const transform = GenericTransformer.scalar("validatParse")(
+    export const transform = GenericTransformer.scalar("json.validatParse")(
         (project) => (modulo) =>
             JsonValidateParseProgrammer.write(project)(modulo),
     );

package/src/transformers/features/json/JsonValidateStringifyTransformer.ts

@@ -3,7 +3,7 @@ import { JsonValidateStringifyProgrammer } from "../../../programmers/json/JsonV
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace JsonValidateStringifyTransformer {
-    export const transform = GenericTransformer.scalar("validatStringify")(
+    export const transform = GenericTransformer.scalar("json.validatStringify")(
         (project) => (modulo) =>
             JsonValidateStringifyProgrammer.write(project)(modulo),
     );

package/src/transformers/features/misc/MiscAssertCloneTransformer.ts

@@ -3,7 +3,7 @@ import { MiscAssertCloneProgrammer } from "../../../programmers/misc/MiscAssertC
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace MiscAssertCloneTransformer {
-    export const transform = GenericTransformer.scalar("assertClone")(
+    export const transform = GenericTransformer.scalar("misc.assertClone")(
         (project) => (modulo) =>
             MiscAssertCloneProgrammer.write(project)(modulo),
     );

package/src/transformers/features/misc/MiscAssertPruneTransformer.ts

@@ -3,7 +3,7 @@ import { MiscAssertPruneProgrammer } from "../../../programmers/misc/MiscAssertP
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace MiscAssertPruneTransformer {
-    export const transform = GenericTransformer.scalar("assertPrune")(
+    export const transform = GenericTransformer.scalar("misc.assertPrune")(
         (project) => (modulo) =>
             MiscAssertPruneProgrammer.write(project)(modulo),
     );

package/src/transformers/features/misc/MiscCloneTransformer.ts

@@ -3,7 +3,7 @@ import { MiscCloneProgrammer } from "../../../programmers/misc/MiscCloneProgramm
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace MiscCloneTransformer {
-    export const transform = GenericTransformer.scalar("clone")(
+    export const transform = GenericTransformer.scalar("misc.clone")(
         (project) => (modulo) => MiscCloneProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/misc/MiscCreateAssertCloneTransformer.ts

@@ -3,7 +3,9 @@ import { MiscAssertCloneProgrammer } from "../../../programmers/misc/MiscAssertC
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace MiscCreateAssertCloneTransformer {
-    export const transform = GenericTransformer.factory("createAssertClone")(
+    export const transform = GenericTransformer.factory(
+        "misc.createAssertClone",
+    )(
         (project) => (modulo) =>
             MiscAssertCloneProgrammer.write(project)(modulo),
     );

package/src/transformers/features/misc/MiscCreateAssertPruneTransformer.ts

@@ -3,7 +3,9 @@ import { MiscAssertPruneProgrammer } from "../../../programmers/misc/MiscAssertP
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace MiscCreateAssertPruneTransformer {
-    export const transform = GenericTransformer.factory("createAssertPrune")(
+    export const transform = GenericTransformer.factory(
+        "misc.createAssertPrune",
+    )(
         (project) => (modulo) =>
             MiscAssertPruneProgrammer.write(project)(modulo),
     );

package/src/transformers/features/misc/MiscCreateCloneTransformer.ts

@@ -3,7 +3,7 @@ import { MiscCloneProgrammer } from "../../../programmers/misc/MiscCloneProgramm
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace MiscCreateCloneTransformer {
-    export const transform = GenericTransformer.factory("createClone")(
+    export const transform = GenericTransformer.factory("misc.createClone")(
         (project) => (modulo) => MiscCloneProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/misc/MiscCreateIsCloneTransformer.ts

@@ -3,7 +3,7 @@ import { MiscIsCloneProgrammer } from "../../../programmers/misc/MiscIsCloneProg
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace MiscCreateIsCloneTransformer {
-    export const transform = GenericTransformer.factory("createIsClone")(
+    export const transform = GenericTransformer.factory("misc.createIsClone")(
         (project) => (modulo) => MiscIsCloneProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/misc/MiscCreateIsPruneTransformer.ts

@@ -3,7 +3,7 @@ import { MiscIsPruneProgrammer } from "../../../programmers/misc/MiscIsPruneProg
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace MiscCreateIsPruneTransformer {
-    export const transform = GenericTransformer.factory("createIsPrune")(
+    export const transform = GenericTransformer.factory("misc.createIsPrune")(
         (project) => (modulo) => MiscIsPruneProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/misc/MiscCreatePruneTransformer.ts

@@ -3,7 +3,7 @@ import { MiscPruneProgrammer } from "../../../programmers/misc/MiscPruneProgramm
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace MiscCreatePruneTransformer {
-    export const transform = GenericTransformer.factory("createPrune")(
+    export const transform = GenericTransformer.factory("misc.createPrune")(
         (project) => (modulo) => MiscPruneProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/misc/MiscCreateValidateCloneTransformer.ts

@@ -3,7 +3,9 @@ import { MiscValidateCloneProgrammer } from "../../../programmers/misc/MiscValid
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace MiscCreateValidateCloneTransformer {
-    export const transform = GenericTransformer.factory("createValidateClone")(
+    export const transform = GenericTransformer.factory(
+        "misc.createValidateClone",
+    )(
         (project) => (modulo) =>
             MiscValidateCloneProgrammer.write(project)(modulo),
     );

package/src/transformers/features/misc/MiscCreateValidatePruneTransformer.ts

@@ -3,7 +3,9 @@ import { MiscValidatePruneProgrammer } from "../../../programmers/misc/MiscValid
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace MiscCreateValidatePruneTransformer {
-    export const transform = GenericTransformer.factory("createValidatePrune")(
+    export const transform = GenericTransformer.factory(
+        "misc.createValidatePrune",
+    )(
         (project) => (modulo) =>
             MiscValidatePruneProgrammer.write(project)(modulo),
     );

package/src/transformers/features/misc/MiscIsCloneTransformer.ts

@@ -3,7 +3,7 @@ import { MiscIsCloneProgrammer } from "../../../programmers/misc/MiscIsCloneProg
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace MiscIsCloneTransformer {
-    export const transform = GenericTransformer.scalar("isClone")(
+    export const transform = GenericTransformer.scalar("misc.isClone")(
         (project) => (modulo) => MiscIsCloneProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/misc/MiscIsPruneTransformer.ts

@@ -3,7 +3,7 @@ import { MiscIsPruneProgrammer } from "../../../programmers/misc/MiscIsPruneProg
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace MiscIsPruneTransformer {
-    export const transform = GenericTransformer.scalar("isPrune")(
+    export const transform = GenericTransformer.scalar("misc.isPrune")(
         (project) => (modulo) => MiscIsPruneProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/misc/MiscPruneTransformer.ts

@@ -3,7 +3,7 @@ import { MiscPruneProgrammer } from "../../../programmers/misc/MiscPruneProgramm
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace MiscPruneTransformer {
-    export const transform = GenericTransformer.scalar("prune")(
+    export const transform = GenericTransformer.scalar("misc.prune")(
         (project) => (modulo) => MiscPruneProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/misc/MiscValidateCloneTransformer.ts

@@ -3,7 +3,7 @@ import { MiscValidateCloneProgrammer } from "../../../programmers/misc/MiscValid
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace MiscValidateCloneTransformer {
-    export const transform = GenericTransformer.scalar("validatClone")(
+    export const transform = GenericTransformer.scalar("misc.validatClone")(
         (project) => (modulo) =>
             MiscValidateCloneProgrammer.write(project)(modulo),
     );