typia 5.1.0-dev.20230922 → 5.1.0-dev.20230924

package/src/protobuf.ts

@@ -24,7 +24,7 @@ import { Resolved } from "./Resolved";
  * For reference, Protocol Buffer has lots of restrictions, so that expression power
  * of Protocol Buffer is not enough strong to fully meet the TypeScript type specs.
  * In such reason, if you put a TypeScript type that is not compatible with Protocol
- * Buffer, this function would throw a compilation error.
+ * Buffer, this function would throw compilation errors.
  *
  *  - [Restrictions of Protocol Buffer](https://typia.io/docs/protobuf/message/#restrictions)
  *
@@ -45,7 +45,7 @@ export function message(): never;
  * For reference, Protocol Buffer has lots of restrictions, so that expression power
  * of Protocol Buffer is not enough strong to fully meet the TypeScript type specs.
  * In such reason, if you put a TypeScript type that is not compatible with Protocol
- * Buffer, this function would throw a compilation error.
+ * Buffer, this function would throw compilation errors.
  *
  * @template T Target type
  * @returns Protocol Buffer Message Schema.
@@ -88,7 +88,7 @@ export function message(): never {
  * [custom tags](https://typia.io/docs/validators/tags). Thus, I repeat that,
  * you've to ensure the type safety when using decoder functions.
  *
- * @tempate Expected type of decoded value
+ * @template T Expected type of decoded value
  * @param input Protobuf Buffer binary data
  * @returns Decoded value
  *
@@ -118,7 +118,7 @@ export function decode(input: Uint8Array): never;
  * [custom tags](https://typia.io/docs/validators/tags). Thus, I repeat that,
  * you've to ensure the type safety when using decoder functions.
  *
- * @tempate Expected type of decoded value
+ * @template T Expected type of decoded value
  * @param input Protobuf Buffer binary data
  * @returns Decoded value
  *
@@ -157,7 +157,7 @@ Object.assign(decode, Namespace.protobuf.decode("decode"));
  *  - {@link isEncode}
  *  - {@link validateEncode}
  *
- * @tempate Expected type of decoded value
+ * @template T Expected type of decoded value
  * @param input Protobuf Buffer binary data
  * @returns Decoded value
  *
@@ -186,7 +186,7 @@ export function assertDecode(input: Uint8Array): never;
  *  - {@link isEncode}
  *  - {@link validateEncode}
  *
- * @tempate Expected type of decoded value
+ * @template T Expected type of decoded value
  * @param input Protobuf Buffer binary data
  * @returns Decoded value
  *
@@ -200,7 +200,7 @@ export function assertDecode<T>(input: Uint8Array): Resolved<T>;
 export function assertDecode(): never {
     halt("assertDecode");
 }
-Object.assign(assertDecode, Namespace.assert("assertDecode"));
+Object.assign(assertDecode, Namespace.assert("protobuf.assertDecode"));
 Object.assign(assertDecode, Namespace.protobuf.decode("assertDecode"));
 
 /**
@@ -226,7 +226,7 @@ Object.assign(assertDecode, Namespace.protobuf.decode("assertDecode"));
  *  - {@link isEncode}
  *  - {@link validateEncode}
  *
- * @tempate Expected type of decoded value
+ * @template T Expected type of decoded value
  * @param input Protobuf Buffer binary data
  * @returns Decoded value
  *
@@ -255,7 +255,7 @@ export function isDecode(input: Uint8Array): never;
  *  - {@link isEncode}
  *  - {@link validateEncode}
  *
- * @tempate Expected type of decoded value
+ * @template T Expected type of decoded value
  * @param input Protobuf Buffer binary data
  * @returns Decoded value
  *
@@ -296,7 +296,7 @@ Object.assign(isDecode, Namespace.protobuf.decode("isDecode"));
  *  - {@link isEncode}
  *  - {@link validateEncode}
  *
- * @tempate Expected type of decoded value
+ * @template T Expected type of decoded value
  * @param input Protobuf Buffer binary data
  * @returns Decoded value
  *
@@ -326,7 +326,7 @@ export function validateDecode(input: Uint8Array): never;
  *  - {@link isEncode}
  *  - {@link validateEncode}
  *
- * @tempate Expected type of decoded value
+ * @template T Expected type of decoded value
  * @param input Protobuf Buffer binary data
  * @returns Decoded value
  *
@@ -362,8 +362,8 @@ Object.assign(validateDecode, Namespace.protobuf.decode("validateDecode"));
  *
  * By the way, you know what? Expression power of Protocol Buffer is not enough strong
  * to fully meet the TypeScript type specs. In such reason, if you put a TypeScript
- * type that is not compatible with Protocol Buffer, this function would throw a
- * compilation error.
+ * type that is not compatible with Protocol Buffer, this function would throw
+ * compilation errors.
  *
  *  - [Restrictions of Protocol Buffer](https://typia.io/docs/protobuf/message/#restrictions)
  *
@@ -403,8 +403,8 @@ Object.assign(encode, Namespace.protobuf.encode("encode"));
  *
  * By the way, you know what? Expression power of Protocol Buffer is not enough strong
  * to fully meet the TypeScript type specs. In such reason, if you put a TypeScript
- * type that is not compatible with Protocol Buffer, this function would throw a
- * compilation error.
+ * type that is not compatible with Protocol Buffer, this function would throw
+ * compilation errors.
  *
  *  - [Restrictions of Protocol Buffer](https://typia.io/docs/protobuf/message/#restrictions)
  *
@@ -436,8 +436,8 @@ export function assertEncode<T>(input: T): Uint8Array;
  *
  * By the way, you know what? Expression power of Protocol Buffer is not enough strong
  * to fully meet the TypeScript type specs. In such reason, if you put a TypeScript
- * type that is not compatible with Protocol Buffer, this function would throw a
- * compilation error.
+ * type that is not compatible with Protocol Buffer, this function would throw
+ * compilation errors.
  *
  *  - [Restrictions of Protocol Buffer](https://typia.io/docs/protobuf/message/#restrictions)
  *
@@ -455,7 +455,7 @@ export function assertEncode<T>(input: unknown): Uint8Array;
 export function assertEncode(): never {
     halt("assertEncode");
 }
-Object.assign(assertEncode, Namespace.assert("assertEncode"));
+Object.assign(assertEncode, Namespace.assert("protobuf.assertEncode"));
 Object.assign(assertEncode, Namespace.protobuf.encode("assertEncode"));
 
 /**
@@ -478,8 +478,8 @@ Object.assign(assertEncode, Namespace.protobuf.encode("assertEncode"));
  *
  * By the way, you know what? Expression power of Protocol Buffer is not enough strong
  * to fully meet the TypeScript type specs. In such reason, if you put a TypeScript
- * type that is not compatible with Protocol Buffer, this function would throw a
- * compilation error.
+ * type that is not compatible with Protocol Buffer, this function would throw
+ * compilation errors.
  *
  *  - [Restrictions of Protocol Buffer](https://typia.io/docs/protobuf/message/#restrictions)
  *
@@ -511,8 +511,8 @@ export function isEncode<T>(input: T): Uint8Array | null;
  *
  * By the way, you know what? Expression power of Protocol Buffer is not enough strong
  * to fully meet the TypeScript type specs. In such reason, if you put a TypeScript
- * type that is not compatible with Protocol Buffer, this function would throw a
- * compilation error.
+ * type that is not compatible with Protocol Buffer, this function would throw
+ * compilation errors.
  *
  *  - [Restrictions of Protocol Buffer](https://typia.io/docs/protobuf/message/#restrictions)
  *
@@ -554,8 +554,8 @@ Object.assign(isEncode, Namespace.protobuf.encode("isEncode"));
  *
  * By the way, you know what? Expression power of Protocol Buffer is not enough strong
  * to fully meet the TypeScript type specs. In such reason, if you put a TypeScript
- * type that is not compatible with Protocol Buffer, this function would throw a
- * compilation error.
+ * type that is not compatible with Protocol Buffer, this function would throw
+ * compilation errors.
  *
  *  - [Restrictions of Protocol Buffer](https://typia.io/docs/protobuf/message/#restrictions)
  *
@@ -588,8 +588,8 @@ export function validateEncode<T>(input: T): IValidation<Uint8Array>;
  *
  * By the way, you know what? Expression power of Protocol Buffer is not enough strong
  * to fully meet the TypeScript type specs. In such reason, if you put a TypeScript
- * type that is not compatible with Protocol Buffer, this function would throw a
- * compilation error.
+ * type that is not compatible with Protocol Buffer, this function would throw
+ * compilation errors.
  *
  *  - [Restrictions of Protocol Buffer](https://typia.io/docs/protobuf/message/#restrictions)
  *
@@ -699,7 +699,10 @@ export function createAssertDecode<T>(): (input: Uint8Array) => Resolved<T>;
 export function createAssertDecode<T>(): (input: Uint8Array) => Resolved<T> {
     halt("createAssertDecode");
 }
-Object.assign(createAssertDecode, Namespace.assert("createAssertDecode"));
+Object.assign(
+    createAssertDecode,
+    Namespace.assert("protobuf.createAssertDecode"),
+);
 Object.assign(
     createAssertDecode,
     Namespace.protobuf.decode("createAssertDecode"),
@@ -828,7 +831,10 @@ export function createAssertEncode<T>(): (input: T) => Uint8Array;
 export function createAssertEncode<T>(): (input: T) => Uint8Array {
     halt("createAssertEncode");
 }
-Object.assign(createAssertEncode, Namespace.assert("createAssertEncode"));
+Object.assign(
+    createAssertEncode,
+    Namespace.assert("protobuf.createAssertEncode"),
+);
 Object.assign(
     createAssertEncode,
     Namespace.protobuf.encode("createAssertEncode"),

package/src/transformers/CallExpressionTransformer.ts

@@ -10,6 +10,24 @@ import { CreateValidateTransformer } from "./features/CreateValidateTransformer"
 import { IsTransformer } from "./features/IsTransformer";
 import { RandomTransformer } from "./features/RandomTransformer";
 import { ValidateTransformer } from "./features/ValidateTransformer";
+import { CreateHttpAssertHeadersTransformer } from "./features/http/CreateHttpAssertHeadersTransformer";
+import { CreateHttpAssertQueryTransformer } from "./features/http/CreateHttpAssertQueryTransformer";
+import { CreateHttpHeadersTransformer } from "./features/http/CreateHttpHeadersTransformer";
+import { CreateHttpIsHeadersTransformer } from "./features/http/CreateHttpIsHeadersTransformer";
+import { CreateHttpIsQueryTransformer } from "./features/http/CreateHttpIsQueryTransformer";
+import { CreateHttpParameterTransformer } from "./features/http/CreateHttpParameterTransformer";
+import { CreateHttpQueryTransformer } from "./features/http/CreateHttpQueryTransformer";
+import { CreateHttpValidateHeadersTransformer } from "./features/http/CreateHttpValidateHeadersTransformer copy";
+import { CreateHttpValidateQueryTransformer } from "./features/http/CreateHttpValidateQueryTransformer";
+import { HttpAssertHeadersTransformer } from "./features/http/HttpAssertHeadersTransformer";
+import { HttpAssertQueryTransformer } from "./features/http/HttpAssertQueryTransformer";
+import { HttpHeadersTransformer } from "./features/http/HttpHeadersTransformer";
+import { HttpIsHeadersTransformer } from "./features/http/HttpIsHeadersTransformer";
+import { HttpIsQueryTransformer } from "./features/http/HttpIsQueryTransformer";
+import { HttpParameterTransformer } from "./features/http/HttpParameterTransformer";
+import { HttpQueryTransformer } from "./features/http/HttpQueryTransformer";
+import { HttpValidateHeadersTransformer } from "./features/http/HttpValidateHeadersTransformer";
+import { HttpValidateQueryTransformer } from "./features/http/HttpValidateQueryTransformer";
 import { JsonApplicationTransformer } from "./features/json/JsonApplicationTransformer";
 import { JsonAssertParseTransformer } from "./features/json/JsonAssertParseTransformer";
 import { JsonAssertStringifyTransformer } from "./features/json/JsonAssertStringifyTransformer";
@@ -158,6 +176,34 @@ const FUNCTORS: Record<string, Record<string, () => Task>> = {
         createValidateEquals: () => CreateValidateTransformer.transform(true),
         createRandom: () => CreateRandomTransformer.transform,
     },
+    http: {
+        // HEADERS
+        headers: () => HttpHeadersTransformer.transform,
+        isHeaders: () => HttpIsHeadersTransformer.transform,
+        assertHeaders: () => HttpAssertHeadersTransformer.transform,
+        validateHeaders: () => HttpValidateHeadersTransformer.transform,
+
+        // PARAMETER
+        parameter: () => HttpParameterTransformer.transform,
+
+        // QUERY
+        query: () => HttpQueryTransformer.transform,
+        isQuery: () => HttpIsQueryTransformer.transform,
+        assertQuery: () => HttpAssertQueryTransformer.transform,
+        validateQuery: () => HttpValidateQueryTransformer.transform,
+
+        // FACTORIES
+        createHeaders: () => CreateHttpHeadersTransformer.transform,
+        createIsHeaders: () => CreateHttpIsHeadersTransformer.transform,
+        createAssertHeaders: () => CreateHttpAssertHeadersTransformer.transform,
+        createValidateHeaders: () =>
+            CreateHttpValidateHeadersTransformer.transform,
+        createParameter: () => CreateHttpParameterTransformer.transform,
+        createQuery: () => CreateHttpQueryTransformer.transform,
+        createIsQuery: () => CreateHttpIsQueryTransformer.transform,
+        createAssertQuery: () => CreateHttpAssertQueryTransformer.transform,
+        createValidateQuery: () => CreateHttpValidateQueryTransformer.transform,
+    },
     json: {
         // SCHEMA
         application: () => (P) => () => JsonApplicationTransformer.transform(P),

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

@@ -0,0 +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),
+    );
+}

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

@@ -0,0 +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),
+    );
+}

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

@@ -0,0 +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),
+    );
+}

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

@@ -0,0 +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),
+    );
+}

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

@@ -0,0 +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),
+    );
+}

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

@@ -0,0 +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),
+    );
+}

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

@@ -0,0 +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),
+    );
+}

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

@@ -0,0 +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),
+    );
+}

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

@@ -0,0 +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),
+    );
+}

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

@@ -0,0 +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),
+    );
+}

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

@@ -0,0 +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),
+    );
+}

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

@@ -0,0 +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),
+    );
+}

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

@@ -0,0 +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),
+    );
+}

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

@@ -0,0 +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),
+    );
+}

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

@@ -0,0 +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),
+    );
+}

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

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

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

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

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

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