typia 5.1.0-dev.20230924 → 5.1.0-dev.20230925

package/src/programmers/http/HttpValidateHeadersProgrammer.ts

@@ -1,77 +1,77 @@
-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 { HttpHeadersProgrammer } from "./HttpHeadersProgrammer";
-
-export namespace HttpValidateHeadersProgrammer {
-    export const write =
-        (project: IProject) =>
-        (modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type, name?: string): ts.ArrowFunction =>
-            ts.factory.createArrowFunction(
-                undefined,
-                undefined,
-                [
-                    IdentifierFactory.parameter(
-                        "input",
-                        ts.factory.createTypeReferenceNode(
-                            HttpHeadersProgrammer.INPUT_TYPE,
-                        ),
-                    ),
-                ],
-                ts.factory.createTypeReferenceNode(
-                    `typia.IValidation<typia.Resolved<${
-                        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(
-                        "headers",
-                        HttpHeadersProgrammer.write({
-                            ...project,
-                            options: {
-                                ...project.options,
-                                functional: false,
-                                numeric: false,
-                            },
-                        })(modulo)(type, name),
-                    ),
-                    StatementFactory.constant(
-                        "output",
-                        ts.factory.createCallExpression(
-                            ts.factory.createIdentifier("headers"),
-                            undefined,
-                            [ts.factory.createIdentifier("input")],
-                        ),
-                    ),
-                    ts.factory.createReturnStatement(
-                        ts.factory.createAsExpression(
-                            ts.factory.createCallExpression(
-                                ts.factory.createIdentifier("validate"),
-                                undefined,
-                                [ts.factory.createIdentifier("output")],
-                            ),
-                            ts.factory.createTypeReferenceNode("any"),
-                        ),
-                    ),
-                ]),
-            );
-}
+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 { HttpHeadersProgrammer } from "./HttpHeadersProgrammer";
+
+export namespace HttpValidateHeadersProgrammer {
+    export const write =
+        (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type, name?: string): ts.ArrowFunction =>
+            ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [
+                    IdentifierFactory.parameter(
+                        "input",
+                        ts.factory.createTypeReferenceNode(
+                            HttpHeadersProgrammer.INPUT_TYPE,
+                        ),
+                    ),
+                ],
+                ts.factory.createTypeReferenceNode(
+                    `typia.IValidation<typia.Resolved<${
+                        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(
+                        "headers",
+                        HttpHeadersProgrammer.write({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: false,
+                            },
+                        })(modulo)(type, name),
+                    ),
+                    StatementFactory.constant(
+                        "output",
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("headers"),
+                            undefined,
+                            [ts.factory.createIdentifier("input")],
+                        ),
+                    ),
+                    ts.factory.createReturnStatement(
+                        ts.factory.createAsExpression(
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("validate"),
+                                undefined,
+                                [ts.factory.createIdentifier("output")],
+                            ),
+                            ts.factory.createTypeReferenceNode("any"),
+                        ),
+                    ),
+                ]),
+            );
+}

package/src/programmers/http/HttpValidateQueryProgrammer.ts

@@ -1,77 +1,77 @@
-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 { HttpQueryProgrammer } from "./HttpQueryProgrammer";
-
-export namespace HttpValidateQueryProgrammer {
-    export const write =
-        (project: IProject) =>
-        (modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type, name?: string): ts.ArrowFunction =>
-            ts.factory.createArrowFunction(
-                undefined,
-                undefined,
-                [
-                    IdentifierFactory.parameter(
-                        "input",
-                        ts.factory.createTypeReferenceNode(
-                            HttpQueryProgrammer.INPUT_TYPE,
-                        ),
-                    ),
-                ],
-                ts.factory.createTypeReferenceNode(
-                    `typia.IValidation<typia.Resolved<${
-                        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(
-                        "query",
-                        HttpQueryProgrammer.write({
-                            ...project,
-                            options: {
-                                ...project.options,
-                                functional: false,
-                                numeric: false,
-                            },
-                        })(modulo)(type, name),
-                    ),
-                    StatementFactory.constant(
-                        "output",
-                        ts.factory.createCallExpression(
-                            ts.factory.createIdentifier("query"),
-                            undefined,
-                            [ts.factory.createIdentifier("input")],
-                        ),
-                    ),
-                    ts.factory.createReturnStatement(
-                        ts.factory.createAsExpression(
-                            ts.factory.createCallExpression(
-                                ts.factory.createIdentifier("validate"),
-                                undefined,
-                                [ts.factory.createIdentifier("output")],
-                            ),
-                            ts.factory.createTypeReferenceNode("any"),
-                        ),
-                    ),
-                ]),
-            );
-}
+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 { HttpQueryProgrammer } from "./HttpQueryProgrammer";
+
+export namespace HttpValidateQueryProgrammer {
+    export const write =
+        (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type, name?: string): ts.ArrowFunction =>
+            ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [
+                    IdentifierFactory.parameter(
+                        "input",
+                        ts.factory.createTypeReferenceNode(
+                            HttpQueryProgrammer.INPUT_TYPE,
+                        ),
+                    ),
+                ],
+                ts.factory.createTypeReferenceNode(
+                    `typia.IValidation<typia.Resolved<${
+                        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(
+                        "query",
+                        HttpQueryProgrammer.write({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: false,
+                            },
+                        })(modulo)(type, name),
+                    ),
+                    StatementFactory.constant(
+                        "output",
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("query"),
+                            undefined,
+                            [ts.factory.createIdentifier("input")],
+                        ),
+                    ),
+                    ts.factory.createReturnStatement(
+                        ts.factory.createAsExpression(
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("validate"),
+                                undefined,
+                                [ts.factory.createIdentifier("output")],
+                            ),
+                            ts.factory.createTypeReferenceNode("any"),
+                        ),
+                    ),
+                ]),
+            );
+}

package/src/transformers/features/http/CreateHttpAssertHeadersTransformer.ts

@@ -1,12 +1,12 @@
-import { HttpAssertHeadersProgrammer } from "../../../programmers/http/HttpAssertHeadersProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateHttpAssertHeadersTransformer {
-    export const transform = GenericTransformer.factory(
-        "http.createAssertHeaders",
-    )(
-        (project) => (modulo) =>
-            HttpAssertHeadersProgrammer.write(project)(modulo),
-    );
-}
+import { HttpAssertHeadersProgrammer } from "../../../programmers/http/HttpAssertHeadersProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateHttpAssertHeadersTransformer {
+    export const transform = GenericTransformer.factory(
+        "http.createAssertHeaders",
+    )(
+        (project) => (modulo) =>
+            HttpAssertHeadersProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/http/CreateHttpAssertQueryTransformer.ts

@@ -1,12 +1,12 @@
-import { HttpAssertQueryProgrammer } from "../../../programmers/http/HttpAssertQueryProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateHttpAssertQueryTransformer {
-    export const transform = GenericTransformer.factory(
-        "http.createAssertQuery",
-    )(
-        (project) => (modulo) =>
-            HttpAssertQueryProgrammer.write(project)(modulo),
-    );
-}
+import { HttpAssertQueryProgrammer } from "../../../programmers/http/HttpAssertQueryProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateHttpAssertQueryTransformer {
+    export const transform = GenericTransformer.factory(
+        "http.createAssertQuery",
+    )(
+        (project) => (modulo) =>
+            HttpAssertQueryProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/http/CreateHttpHeadersTransformer.ts

@@ -1,9 +1,9 @@
-import { HttpHeadersProgrammer } from "../../../programmers/http/HttpHeadersProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateHttpHeadersTransformer {
-    export const transform = GenericTransformer.factory("http.createHeaders")(
-        (project) => (modulo) => HttpHeadersProgrammer.write(project)(modulo),
-    );
-}
+import { HttpHeadersProgrammer } from "../../../programmers/http/HttpHeadersProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateHttpHeadersTransformer {
+    export const transform = GenericTransformer.factory("http.createHeaders")(
+        (project) => (modulo) => HttpHeadersProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/http/CreateHttpIsHeadersTransformer.ts

@@ -1,9 +1,9 @@
-import { HttpIsHeadersProgrammer } from "../../../programmers/http/HttpIsHeadersProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateHttpIsHeadersTransformer {
-    export const transform = GenericTransformer.factory("http.createIsHeaders")(
-        (project) => (modulo) => HttpIsHeadersProgrammer.write(project)(modulo),
-    );
-}
+import { HttpIsHeadersProgrammer } from "../../../programmers/http/HttpIsHeadersProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateHttpIsHeadersTransformer {
+    export const transform = GenericTransformer.factory("http.createIsHeaders")(
+        (project) => (modulo) => HttpIsHeadersProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/http/CreateHttpIsQueryTransformer.ts

@@ -1,9 +1,9 @@
-import { HttpIsQueryProgrammer } from "../../../programmers/http/HttpIsQueryProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateHttpIsQueryTransformer {
-    export const transform = GenericTransformer.factory("http.createIsQuery")(
-        (project) => (modulo) => HttpIsQueryProgrammer.write(project)(modulo),
-    );
-}
+import { HttpIsQueryProgrammer } from "../../../programmers/http/HttpIsQueryProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateHttpIsQueryTransformer {
+    export const transform = GenericTransformer.factory("http.createIsQuery")(
+        (project) => (modulo) => HttpIsQueryProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/http/CreateHttpParameterTransformer.ts

@@ -1,9 +1,9 @@
-import { HttpParameterProgrammer } from "../../../programmers/http/HttpParameterProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateHttpParameterTransformer {
-    export const transform = GenericTransformer.factory("http.createParameter")(
-        (project) => (modulo) => HttpParameterProgrammer.write(project)(modulo),
-    );
-}
+import { HttpParameterProgrammer } from "../../../programmers/http/HttpParameterProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateHttpParameterTransformer {
+    export const transform = GenericTransformer.factory("http.createParameter")(
+        (project) => (modulo) => HttpParameterProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/http/CreateHttpQueryTransformer.ts

@@ -1,9 +1,9 @@
-import { HttpQueryProgrammer } from "../../../programmers/http/HttpQueryProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateHttpQueryTransformer {
-    export const transform = GenericTransformer.factory("http.createQuery")(
-        (project) => (modulo) => HttpQueryProgrammer.write(project)(modulo),
-    );
-}
+import { HttpQueryProgrammer } from "../../../programmers/http/HttpQueryProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateHttpQueryTransformer {
+    export const transform = GenericTransformer.factory("http.createQuery")(
+        (project) => (modulo) => HttpQueryProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/http/CreateHttpValidateHeadersTransformer copy.ts

@@ -1,12 +1,12 @@
-import { HttpValidateHeadersProgrammer } from "../../../programmers/http/HttpValidateHeadersProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateHttpValidateHeadersTransformer {
-    export const transform = GenericTransformer.factory(
-        "http.createValidateHeaders",
-    )(
-        (project) => (modulo) =>
-            HttpValidateHeadersProgrammer.write(project)(modulo),
-    );
-}
+import { HttpValidateHeadersProgrammer } from "../../../programmers/http/HttpValidateHeadersProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateHttpValidateHeadersTransformer {
+    export const transform = GenericTransformer.factory(
+        "http.createValidateHeaders",
+    )(
+        (project) => (modulo) =>
+            HttpValidateHeadersProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/http/CreateHttpValidateQueryTransformer.ts

@@ -1,12 +1,12 @@
-import { HttpValidateQueryProgrammer } from "../../../programmers/http/HttpValidateQueryProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateHttpValidateQueryTransformer {
-    export const transform = GenericTransformer.factory(
-        "http.createValidateQuery",
-    )(
-        (project) => (modulo) =>
-            HttpValidateQueryProgrammer.write(project)(modulo),
-    );
-}
+import { HttpValidateQueryProgrammer } from "../../../programmers/http/HttpValidateQueryProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateHttpValidateQueryTransformer {
+    export const transform = GenericTransformer.factory(
+        "http.createValidateQuery",
+    )(
+        (project) => (modulo) =>
+            HttpValidateQueryProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/http/HttpAssertHeadersTransformer.ts

@@ -1,10 +1,10 @@
-import { HttpAssertHeadersProgrammer } from "../../../programmers/http/HttpAssertHeadersProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace HttpAssertHeadersTransformer {
-    export const transform = GenericTransformer.scalar("http.assertHeaders")(
-        (project) => (modulo) =>
-            HttpAssertHeadersProgrammer.write(project)(modulo),
-    );
-}
+import { HttpAssertHeadersProgrammer } from "../../../programmers/http/HttpAssertHeadersProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace HttpAssertHeadersTransformer {
+    export const transform = GenericTransformer.scalar("http.assertHeaders")(
+        (project) => (modulo) =>
+            HttpAssertHeadersProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/http/HttpAssertQueryTransformer.ts

@@ -1,10 +1,10 @@
-import { HttpAssertQueryProgrammer } from "../../../programmers/http/HttpAssertQueryProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace HttpAssertQueryTransformer {
-    export const transform = GenericTransformer.scalar("http.assertQuery")(
-        (project) => (modulo) =>
-            HttpAssertQueryProgrammer.write(project)(modulo),
-    );
-}
+import { HttpAssertQueryProgrammer } from "../../../programmers/http/HttpAssertQueryProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace HttpAssertQueryTransformer {
+    export const transform = GenericTransformer.scalar("http.assertQuery")(
+        (project) => (modulo) =>
+            HttpAssertQueryProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/http/HttpHeadersTransformer.ts

@@ -1,9 +1,9 @@
-import { HttpHeadersProgrammer } from "../../../programmers/http/HttpHeadersProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace HttpHeadersTransformer {
-    export const transform = GenericTransformer.scalar("http.headers")(
-        (project) => (modulo) => HttpHeadersProgrammer.write(project)(modulo),
-    );
-}
+import { HttpHeadersProgrammer } from "../../../programmers/http/HttpHeadersProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace HttpHeadersTransformer {
+    export const transform = GenericTransformer.scalar("http.headers")(
+        (project) => (modulo) => HttpHeadersProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/http/HttpIsHeadersTransformer.ts

@@ -1,9 +1,9 @@
-import { HttpIsHeadersProgrammer } from "../../../programmers/http/HttpIsHeadersProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace HttpIsHeadersTransformer {
-    export const transform = GenericTransformer.scalar("http.isHeaders")(
-        (project) => (modulo) => HttpIsHeadersProgrammer.write(project)(modulo),
-    );
-}
+import { HttpIsHeadersProgrammer } from "../../../programmers/http/HttpIsHeadersProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace HttpIsHeadersTransformer {
+    export const transform = GenericTransformer.scalar("http.isHeaders")(
+        (project) => (modulo) => HttpIsHeadersProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/http/HttpIsQueryTransformer.ts

@@ -1,9 +1,9 @@
-import { HttpIsQueryProgrammer } from "../../../programmers/http/HttpIsQueryProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace HttpIsQueryTransformer {
-    export const transform = GenericTransformer.scalar("http.isQuery")(
-        (project) => (modulo) => HttpIsQueryProgrammer.write(project)(modulo),
-    );
-}
+import { HttpIsQueryProgrammer } from "../../../programmers/http/HttpIsQueryProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace HttpIsQueryTransformer {
+    export const transform = GenericTransformer.scalar("http.isQuery")(
+        (project) => (modulo) => HttpIsQueryProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/http/HttpParameterTransformer.ts

@@ -1,9 +1,9 @@
-import { HttpParameterProgrammer } from "../../../programmers/http/HttpParameterProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace HttpParameterTransformer {
-    export const transform = GenericTransformer.scalar("http.parameter")(
-        (project) => (modulo) => HttpParameterProgrammer.write(project)(modulo),
-    );
-}
+import { HttpParameterProgrammer } from "../../../programmers/http/HttpParameterProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace HttpParameterTransformer {
+    export const transform = GenericTransformer.scalar("http.parameter")(
+        (project) => (modulo) => HttpParameterProgrammer.write(project)(modulo),
+    );
+}