typia 8.0.0 → 8.0.1

package/lib/transformers/features/notations/NotationAssertGeneralTransformer.mjs

@@ -0,0 +1,18 @@
+import { NotationAssertGeneralProgrammer } from '../../../programmers/notations/NotationAssertGeneralProgrammer.mjs';
+import { StringUtil } from '../../../utils/StringUtil.mjs';
+import { GenericTransformer } from '../../internal/GenericTransformer.mjs';
+
+var NotationAssertGeneralTransformer;
+(function (NotationAssertGeneralTransformer) {
+    NotationAssertGeneralTransformer.transform = (rename) => (props) => GenericTransformer.scalar({
+        ...props,
+        method: `notations.assert${StringUtil.capitalize(rename.name)}`,
+        write: (x) => NotationAssertGeneralProgrammer.write({
+            ...x,
+            rename,
+        }),
+    });
+})(NotationAssertGeneralTransformer || (NotationAssertGeneralTransformer = {}));
+
+export { NotationAssertGeneralTransformer };
+//# sourceMappingURL=NotationAssertGeneralTransformer.mjs.map

package/lib/transformers/features/notations/NotationAssertGeneralTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"NotationAssertGeneralTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/notations/NotationCreateAssertGeneralTransformer.mjs

@@ -0,0 +1,18 @@
+import { NotationAssertGeneralProgrammer } from '../../../programmers/notations/NotationAssertGeneralProgrammer.mjs';
+import { StringUtil } from '../../../utils/StringUtil.mjs';
+import { GenericTransformer } from '../../internal/GenericTransformer.mjs';
+
+var NotationCreateAssertGeneralTransformer;
+(function (NotationCreateAssertGeneralTransformer) {
+    NotationCreateAssertGeneralTransformer.transform = (rename) => (props) => GenericTransformer.factory({
+        ...props,
+        method: `notations.createAssert${StringUtil.capitalize(rename.name)}`,
+        write: (x) => NotationAssertGeneralProgrammer.write({
+            ...x,
+            rename,
+        }),
+    });
+})(NotationCreateAssertGeneralTransformer || (NotationCreateAssertGeneralTransformer = {}));
+
+export { NotationCreateAssertGeneralTransformer };
+//# sourceMappingURL=NotationCreateAssertGeneralTransformer.mjs.map

package/lib/transformers/features/notations/NotationCreateAssertGeneralTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"NotationCreateAssertGeneralTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/notations/NotationCreateGeneralTransformer.mjs

@@ -0,0 +1,18 @@
+import { NotationGeneralProgrammer } from '../../../programmers/notations/NotationGeneralProgrammer.mjs';
+import { StringUtil } from '../../../utils/StringUtil.mjs';
+import { GenericTransformer } from '../../internal/GenericTransformer.mjs';
+
+var NotationCreateGeneralTransformer;
+(function (NotationCreateGeneralTransformer) {
+    NotationCreateGeneralTransformer.transform = (rename) => (props) => GenericTransformer.factory({
+        ...props,
+        method: `notations.create${StringUtil.capitalize(rename.name)}`,
+        write: (x) => NotationGeneralProgrammer.write({
+            ...x,
+            rename,
+        }),
+    });
+})(NotationCreateGeneralTransformer || (NotationCreateGeneralTransformer = {}));
+
+export { NotationCreateGeneralTransformer };
+//# sourceMappingURL=NotationCreateGeneralTransformer.mjs.map

package/lib/transformers/features/notations/NotationCreateGeneralTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"NotationCreateGeneralTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/notations/NotationCreateIsGeneralTransformer.mjs

@@ -0,0 +1,18 @@
+import { NotationIsGeneralProgrammer } from '../../../programmers/notations/NotationIsGeneralProgrammer.mjs';
+import { StringUtil } from '../../../utils/StringUtil.mjs';
+import { GenericTransformer } from '../../internal/GenericTransformer.mjs';
+
+var NotationCreateIsGeneralTransformer;
+(function (NotationCreateIsGeneralTransformer) {
+    NotationCreateIsGeneralTransformer.transform = (rename) => (props) => GenericTransformer.factory({
+        ...props,
+        method: `notations.createIs${StringUtil.capitalize(rename.name)}`,
+        write: (x) => NotationIsGeneralProgrammer.write({
+            ...x,
+            rename,
+        }),
+    });
+})(NotationCreateIsGeneralTransformer || (NotationCreateIsGeneralTransformer = {}));
+
+export { NotationCreateIsGeneralTransformer };
+//# sourceMappingURL=NotationCreateIsGeneralTransformer.mjs.map

package/lib/transformers/features/notations/NotationCreateIsGeneralTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"NotationCreateIsGeneralTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/notations/NotationCreateValidateGeneralTransformer.mjs

@@ -0,0 +1,18 @@
+import { NotationValidateGeneralProgrammer } from '../../../programmers/notations/NotationValidateGeneralProgrammer.mjs';
+import { StringUtil } from '../../../utils/StringUtil.mjs';
+import { GenericTransformer } from '../../internal/GenericTransformer.mjs';
+
+var NotationCreateValidateGeneralTransformer;
+(function (NotationCreateValidateGeneralTransformer) {
+    NotationCreateValidateGeneralTransformer.transform = (rename) => (props) => GenericTransformer.factory({
+        ...props,
+        method: `notations.createValidate${StringUtil.capitalize(rename.name)}`,
+        write: (x) => NotationValidateGeneralProgrammer.write({
+            ...x,
+            rename,
+        }),
+    });
+})(NotationCreateValidateGeneralTransformer || (NotationCreateValidateGeneralTransformer = {}));
+
+export { NotationCreateValidateGeneralTransformer };
+//# sourceMappingURL=NotationCreateValidateGeneralTransformer.mjs.map

package/lib/transformers/features/notations/NotationCreateValidateGeneralTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"NotationCreateValidateGeneralTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/notations/NotationGeneralTransformer.mjs

@@ -0,0 +1,17 @@
+import { NotationGeneralProgrammer } from '../../../programmers/notations/NotationGeneralProgrammer.mjs';
+import { GenericTransformer } from '../../internal/GenericTransformer.mjs';
+
+var NotationGeneralTransformer;
+(function (NotationGeneralTransformer) {
+    NotationGeneralTransformer.transform = (rename) => (props) => GenericTransformer.scalar({
+        ...props,
+        method: `notations.${rename.name}`,
+        write: (x) => NotationGeneralProgrammer.write({
+            ...x,
+            rename,
+        }),
+    });
+})(NotationGeneralTransformer || (NotationGeneralTransformer = {}));
+
+export { NotationGeneralTransformer };
+//# sourceMappingURL=NotationGeneralTransformer.mjs.map

package/lib/transformers/features/notations/NotationGeneralTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"NotationGeneralTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/notations/NotationIsGeneralTransformer.mjs

@@ -0,0 +1,18 @@
+import { NotationIsGeneralProgrammer } from '../../../programmers/notations/NotationIsGeneralProgrammer.mjs';
+import { StringUtil } from '../../../utils/StringUtil.mjs';
+import { GenericTransformer } from '../../internal/GenericTransformer.mjs';
+
+var NotationIsGeneralTransformer;
+(function (NotationIsGeneralTransformer) {
+    NotationIsGeneralTransformer.transform = (rename) => (props) => GenericTransformer.scalar({
+        ...props,
+        method: `notations.is${StringUtil.capitalize(rename.name)}`,
+        write: (x) => NotationIsGeneralProgrammer.write({
+            ...x,
+            rename,
+        }),
+    });
+})(NotationIsGeneralTransformer || (NotationIsGeneralTransformer = {}));
+
+export { NotationIsGeneralTransformer };
+//# sourceMappingURL=NotationIsGeneralTransformer.mjs.map

package/lib/transformers/features/notations/NotationIsGeneralTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"NotationIsGeneralTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/notations/NotationValidateGeneralTransformer.mjs

@@ -0,0 +1,18 @@
+import { NotationValidateGeneralProgrammer } from '../../../programmers/notations/NotationValidateGeneralProgrammer.mjs';
+import { StringUtil } from '../../../utils/StringUtil.mjs';
+import { GenericTransformer } from '../../internal/GenericTransformer.mjs';
+
+var NotationValidateGeneralTransformer;
+(function (NotationValidateGeneralTransformer) {
+    NotationValidateGeneralTransformer.transform = (rename) => (props) => GenericTransformer.scalar({
+        ...props,
+        method: `notations.validate${StringUtil.capitalize(rename.name)}`,
+        write: (x) => NotationValidateGeneralProgrammer.write({
+            ...x,
+            rename,
+        }),
+    });
+})(NotationValidateGeneralTransformer || (NotationValidateGeneralTransformer = {}));
+
+export { NotationValidateGeneralTransformer };
+//# sourceMappingURL=NotationValidateGeneralTransformer.mjs.map

package/lib/transformers/features/notations/NotationValidateGeneralTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"NotationValidateGeneralTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/protobuf/ProtobufAssertDecodeTransformer.mjs

@@ -0,0 +1,14 @@
+import { ProtobufAssertDecodeProgrammer } from '../../../programmers/protobuf/ProtobufAssertDecodeProgrammer.mjs';
+import { GenericTransformer } from '../../internal/GenericTransformer.mjs';
+
+var ProtobufAssertDecodeTransformer;
+(function (ProtobufAssertDecodeTransformer) {
+    ProtobufAssertDecodeTransformer.transform = (props) => GenericTransformer.scalar({
+        ...props,
+        method: "protobuf.assertDecode",
+        write: ProtobufAssertDecodeProgrammer.write,
+    });
+})(ProtobufAssertDecodeTransformer || (ProtobufAssertDecodeTransformer = {}));
+
+export { ProtobufAssertDecodeTransformer };
+//# sourceMappingURL=ProtobufAssertDecodeTransformer.mjs.map

package/lib/transformers/features/protobuf/ProtobufAssertDecodeTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtobufAssertDecodeTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/protobuf/ProtobufAssertEncodeTransformer.mjs

@@ -0,0 +1,14 @@
+import { ProtobufAssertEncodeProgrammer } from '../../../programmers/protobuf/ProtobufAssertEncodeProgrammer.mjs';
+import { GenericTransformer } from '../../internal/GenericTransformer.mjs';
+
+var ProtobufAssertEncodeTransformer;
+(function (ProtobufAssertEncodeTransformer) {
+    ProtobufAssertEncodeTransformer.transform = (props) => GenericTransformer.scalar({
+        ...props,
+        method: "protobuf.assertEncode",
+        write: ProtobufAssertEncodeProgrammer.write,
+    });
+})(ProtobufAssertEncodeTransformer || (ProtobufAssertEncodeTransformer = {}));
+
+export { ProtobufAssertEncodeTransformer };
+//# sourceMappingURL=ProtobufAssertEncodeTransformer.mjs.map

package/lib/transformers/features/protobuf/ProtobufAssertEncodeTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtobufAssertEncodeTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/protobuf/ProtobufCreateAssertDecodeTransformer.mjs

@@ -0,0 +1,14 @@
+import { ProtobufAssertDecodeProgrammer } from '../../../programmers/protobuf/ProtobufAssertDecodeProgrammer.mjs';
+import { GenericTransformer } from '../../internal/GenericTransformer.mjs';
+
+var ProtobufCreateAssertDecodeTransformer;
+(function (ProtobufCreateAssertDecodeTransformer) {
+    ProtobufCreateAssertDecodeTransformer.transform = (props) => GenericTransformer.factory({
+        ...props,
+        method: "protobuf.createAssertDecode",
+        write: ProtobufAssertDecodeProgrammer.write,
+    });
+})(ProtobufCreateAssertDecodeTransformer || (ProtobufCreateAssertDecodeTransformer = {}));
+
+export { ProtobufCreateAssertDecodeTransformer };
+//# sourceMappingURL=ProtobufCreateAssertDecodeTransformer.mjs.map

package/lib/transformers/features/protobuf/ProtobufCreateAssertDecodeTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtobufCreateAssertDecodeTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/protobuf/ProtobufCreateAssertEncodeTransformer.mjs

@@ -0,0 +1,14 @@
+import { ProtobufAssertEncodeProgrammer } from '../../../programmers/protobuf/ProtobufAssertEncodeProgrammer.mjs';
+import { GenericTransformer } from '../../internal/GenericTransformer.mjs';
+
+var ProtobufCreateAssertEncodeTransformer;
+(function (ProtobufCreateAssertEncodeTransformer) {
+    ProtobufCreateAssertEncodeTransformer.transform = (props) => GenericTransformer.factory({
+        ...props,
+        method: "protobuf.createAssertEncode",
+        write: ProtobufAssertEncodeProgrammer.write,
+    });
+})(ProtobufCreateAssertEncodeTransformer || (ProtobufCreateAssertEncodeTransformer = {}));
+
+export { ProtobufCreateAssertEncodeTransformer };
+//# sourceMappingURL=ProtobufCreateAssertEncodeTransformer.mjs.map

package/lib/transformers/features/protobuf/ProtobufCreateAssertEncodeTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtobufCreateAssertEncodeTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/protobuf/ProtobufCreateDecodeTransformer.mjs

@@ -0,0 +1,14 @@
+import { ProtobufDecodeProgrammer } from '../../../programmers/protobuf/ProtobufDecodeProgrammer.mjs';
+import { GenericTransformer } from '../../internal/GenericTransformer.mjs';
+
+var ProtobufCreateDecodeTransformer;
+(function (ProtobufCreateDecodeTransformer) {
+    ProtobufCreateDecodeTransformer.transform = (props) => GenericTransformer.factory({
+        ...props,
+        method: "protobuf.createDecode",
+        write: ProtobufDecodeProgrammer.write,
+    });
+})(ProtobufCreateDecodeTransformer || (ProtobufCreateDecodeTransformer = {}));
+
+export { ProtobufCreateDecodeTransformer };
+//# sourceMappingURL=ProtobufCreateDecodeTransformer.mjs.map

package/lib/transformers/features/protobuf/ProtobufCreateDecodeTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtobufCreateDecodeTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/protobuf/ProtobufCreateEncodeTransformer.mjs

@@ -0,0 +1,14 @@
+import { ProtobufEncodeProgrammer } from '../../../programmers/protobuf/ProtobufEncodeProgrammer.mjs';
+import { GenericTransformer } from '../../internal/GenericTransformer.mjs';
+
+var ProtobufCreateEncodeTransformer;
+(function (ProtobufCreateEncodeTransformer) {
+    ProtobufCreateEncodeTransformer.transform = (props) => GenericTransformer.factory({
+        ...props,
+        method: "protobuf.createEncode",
+        write: ProtobufEncodeProgrammer.write,
+    });
+})(ProtobufCreateEncodeTransformer || (ProtobufCreateEncodeTransformer = {}));
+
+export { ProtobufCreateEncodeTransformer };
+//# sourceMappingURL=ProtobufCreateEncodeTransformer.mjs.map

package/lib/transformers/features/protobuf/ProtobufCreateEncodeTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtobufCreateEncodeTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/protobuf/ProtobufCreateIsDecodeTransformer.mjs

@@ -0,0 +1,14 @@
+import { ProtobufIsDecodeProgrammer } from '../../../programmers/protobuf/ProtobufIsDecodeProgrammer.mjs';
+import { GenericTransformer } from '../../internal/GenericTransformer.mjs';
+
+var ProtobufCreateIsDecodeTransformer;
+(function (ProtobufCreateIsDecodeTransformer) {
+    ProtobufCreateIsDecodeTransformer.transform = (props) => GenericTransformer.factory({
+        ...props,
+        method: "protobuf.createIsDecode",
+        write: ProtobufIsDecodeProgrammer.write,
+    });
+})(ProtobufCreateIsDecodeTransformer || (ProtobufCreateIsDecodeTransformer = {}));
+
+export { ProtobufCreateIsDecodeTransformer };
+//# sourceMappingURL=ProtobufCreateIsDecodeTransformer.mjs.map

package/lib/transformers/features/protobuf/ProtobufCreateIsDecodeTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtobufCreateIsDecodeTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/protobuf/ProtobufCreateIsEncodeTransformer.mjs

@@ -0,0 +1,14 @@
+import { ProtobufIsEncodeProgrammer } from '../../../programmers/protobuf/ProtobufIsEncodeProgrammer.mjs';
+import { GenericTransformer } from '../../internal/GenericTransformer.mjs';
+
+var ProtobufCreateIsEncodeTransformer;
+(function (ProtobufCreateIsEncodeTransformer) {
+    ProtobufCreateIsEncodeTransformer.transform = (props) => GenericTransformer.factory({
+        ...props,
+        method: "protobuf.createIsEncode",
+        write: ProtobufIsEncodeProgrammer.write,
+    });
+})(ProtobufCreateIsEncodeTransformer || (ProtobufCreateIsEncodeTransformer = {}));
+
+export { ProtobufCreateIsEncodeTransformer };
+//# sourceMappingURL=ProtobufCreateIsEncodeTransformer.mjs.map

package/lib/transformers/features/protobuf/ProtobufCreateIsEncodeTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtobufCreateIsEncodeTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/protobuf/ProtobufCreateValidateDecodeTransformer.mjs

@@ -0,0 +1,14 @@
+import { ProtobufValidateDecodeProgrammer } from '../../../programmers/protobuf/ProtobufValidateDecodeProgrammer.mjs';
+import { GenericTransformer } from '../../internal/GenericTransformer.mjs';
+
+var ProtobufCreateValidateDecodeTransformer;
+(function (ProtobufCreateValidateDecodeTransformer) {
+    ProtobufCreateValidateDecodeTransformer.transform = (props) => GenericTransformer.factory({
+        ...props,
+        method: "protobuf.createValidateDecode",
+        write: ProtobufValidateDecodeProgrammer.write,
+    });
+})(ProtobufCreateValidateDecodeTransformer || (ProtobufCreateValidateDecodeTransformer = {}));
+
+export { ProtobufCreateValidateDecodeTransformer };
+//# sourceMappingURL=ProtobufCreateValidateDecodeTransformer.mjs.map

package/lib/transformers/features/protobuf/ProtobufCreateValidateDecodeTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtobufCreateValidateDecodeTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/protobuf/ProtobufCreateValidateEncodeTransformer.mjs

@@ -0,0 +1,14 @@
+import { ProtobufValidateEncodeProgrammer } from '../../../programmers/protobuf/ProtobufValidateEncodeProgrammer.mjs';
+import { GenericTransformer } from '../../internal/GenericTransformer.mjs';
+
+var ProtobufCreateValidateEncodeTransformer;
+(function (ProtobufCreateValidateEncodeTransformer) {
+    ProtobufCreateValidateEncodeTransformer.transform = (props) => GenericTransformer.factory({
+        ...props,
+        method: "protobuf.createValidateEncode",
+        write: ProtobufValidateEncodeProgrammer.write,
+    });
+})(ProtobufCreateValidateEncodeTransformer || (ProtobufCreateValidateEncodeTransformer = {}));
+
+export { ProtobufCreateValidateEncodeTransformer };
+//# sourceMappingURL=ProtobufCreateValidateEncodeTransformer.mjs.map

package/lib/transformers/features/protobuf/ProtobufCreateValidateEncodeTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtobufCreateValidateEncodeTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/protobuf/ProtobufDecodeTransformer.mjs

@@ -0,0 +1,14 @@
+import { ProtobufDecodeProgrammer } from '../../../programmers/protobuf/ProtobufDecodeProgrammer.mjs';
+import { GenericTransformer } from '../../internal/GenericTransformer.mjs';
+
+var ProtobufDecodeTransformer;
+(function (ProtobufDecodeTransformer) {
+    ProtobufDecodeTransformer.transform = (props) => GenericTransformer.scalar({
+        ...props,
+        method: "protobuf.decode",
+        write: ProtobufDecodeProgrammer.write,
+    });
+})(ProtobufDecodeTransformer || (ProtobufDecodeTransformer = {}));
+
+export { ProtobufDecodeTransformer };
+//# sourceMappingURL=ProtobufDecodeTransformer.mjs.map

package/lib/transformers/features/protobuf/ProtobufDecodeTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtobufDecodeTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/protobuf/ProtobufEncodeTransformer.mjs

@@ -0,0 +1,14 @@
+import { ProtobufEncodeProgrammer } from '../../../programmers/protobuf/ProtobufEncodeProgrammer.mjs';
+import { GenericTransformer } from '../../internal/GenericTransformer.mjs';
+
+var ProtobufEncodeTransformer;
+(function (ProtobufEncodeTransformer) {
+    ProtobufEncodeTransformer.transform = (props) => GenericTransformer.scalar({
+        ...props,
+        method: "protobuf.encode",
+        write: ProtobufEncodeProgrammer.write,
+    });
+})(ProtobufEncodeTransformer || (ProtobufEncodeTransformer = {}));
+
+export { ProtobufEncodeTransformer };
+//# sourceMappingURL=ProtobufEncodeTransformer.mjs.map

package/lib/transformers/features/protobuf/ProtobufEncodeTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtobufEncodeTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/protobuf/ProtobufIsDecodeTransformer.mjs

@@ -0,0 +1,14 @@
+import { ProtobufIsDecodeProgrammer } from '../../../programmers/protobuf/ProtobufIsDecodeProgrammer.mjs';
+import { GenericTransformer } from '../../internal/GenericTransformer.mjs';
+
+var ProtobufIsDecodeTransformer;
+(function (ProtobufIsDecodeTransformer) {
+    ProtobufIsDecodeTransformer.transform = (props) => GenericTransformer.scalar({
+        ...props,
+        method: "protobuf.isDecode",
+        write: ProtobufIsDecodeProgrammer.write,
+    });
+})(ProtobufIsDecodeTransformer || (ProtobufIsDecodeTransformer = {}));
+
+export { ProtobufIsDecodeTransformer };
+//# sourceMappingURL=ProtobufIsDecodeTransformer.mjs.map

package/lib/transformers/features/protobuf/ProtobufIsDecodeTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtobufIsDecodeTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/protobuf/ProtobufIsEncodeTransformer.mjs

@@ -0,0 +1,14 @@
+import { ProtobufIsEncodeProgrammer } from '../../../programmers/protobuf/ProtobufIsEncodeProgrammer.mjs';
+import { GenericTransformer } from '../../internal/GenericTransformer.mjs';
+
+var ProtobufIsEncodeTransformer;
+(function (ProtobufIsEncodeTransformer) {
+    ProtobufIsEncodeTransformer.transform = (props) => GenericTransformer.scalar({
+        ...props,
+        method: "protobuf.isEncode",
+        write: ProtobufIsEncodeProgrammer.write,
+    });
+})(ProtobufIsEncodeTransformer || (ProtobufIsEncodeTransformer = {}));
+
+export { ProtobufIsEncodeTransformer };
+//# sourceMappingURL=ProtobufIsEncodeTransformer.mjs.map

package/lib/transformers/features/protobuf/ProtobufIsEncodeTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtobufIsEncodeTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/protobuf/ProtobufMessageTransformer.mjs

@@ -0,0 +1,29 @@
+import { ProtobufMessageProgrammer } from '../../../programmers/protobuf/ProtobufMessageProgrammer.mjs';
+import { TransformerError } from '../../TransformerError.mjs';
+
+var ProtobufMessageTransformer;
+(function (ProtobufMessageTransformer) {
+    ProtobufMessageTransformer.transform = (props) => {
+        // CHECK GENERIC ARGUMENT EXISTENCE
+        if (!props.expression.typeArguments || !props.expression.typeArguments[0])
+            throw new TransformerError({
+                code: "typia.protobuf.message",
+                message: "generic argument is not specified.",
+            });
+        // GET TYPE INFO
+        const type = props.context.checker.getTypeFromTypeNode(props.expression.typeArguments[0]);
+        if (type.isTypeParameter())
+            throw new TransformerError({
+                code: "tyipa.protobuf.message",
+                message: "non-specified generic argument.",
+            });
+        // DO TRANSFORM
+        return ProtobufMessageProgrammer.write({
+            context: props.context,
+            type,
+        });
+    };
+})(ProtobufMessageTransformer || (ProtobufMessageTransformer = {}));
+
+export { ProtobufMessageTransformer };
+//# sourceMappingURL=ProtobufMessageTransformer.mjs.map

package/lib/transformers/features/protobuf/ProtobufMessageTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtobufMessageTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/protobuf/ProtobufValidateDecodeTransformer.mjs

@@ -0,0 +1,14 @@
+import { ProtobufValidateDecodeProgrammer } from '../../../programmers/protobuf/ProtobufValidateDecodeProgrammer.mjs';
+import { GenericTransformer } from '../../internal/GenericTransformer.mjs';
+
+var ProtobufValidateDecodeTransformer;
+(function (ProtobufValidateDecodeTransformer) {
+    ProtobufValidateDecodeTransformer.transform = (props) => GenericTransformer.scalar({
+        ...props,
+        method: "protobuf.validateDecode",
+        write: ProtobufValidateDecodeProgrammer.write,
+    });
+})(ProtobufValidateDecodeTransformer || (ProtobufValidateDecodeTransformer = {}));
+
+export { ProtobufValidateDecodeTransformer };
+//# sourceMappingURL=ProtobufValidateDecodeTransformer.mjs.map

package/lib/transformers/features/protobuf/ProtobufValidateDecodeTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtobufValidateDecodeTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/protobuf/ProtobufValidateEncodeTransformer.mjs

@@ -0,0 +1,14 @@
+import { ProtobufValidateEncodeProgrammer } from '../../../programmers/protobuf/ProtobufValidateEncodeProgrammer.mjs';
+import { GenericTransformer } from '../../internal/GenericTransformer.mjs';
+
+var ProtobufValidateEncodeTransformer;
+(function (ProtobufValidateEncodeTransformer) {
+    ProtobufValidateEncodeTransformer.transform = (props) => GenericTransformer.scalar({
+        ...props,
+        method: "protobuf.validateEncode",
+        write: ProtobufValidateEncodeProgrammer.write,
+    });
+})(ProtobufValidateEncodeTransformer || (ProtobufValidateEncodeTransformer = {}));
+
+export { ProtobufValidateEncodeTransformer };
+//# sourceMappingURL=ProtobufValidateEncodeTransformer.mjs.map

package/lib/transformers/features/protobuf/ProtobufValidateEncodeTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtobufValidateEncodeTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/features/reflect/ReflectMetadataTransformer.mjs

@@ -0,0 +1,60 @@
+import ts from 'typescript';
+import { LiteralFactory } from '../../../factories/LiteralFactory.mjs';
+import { MetadataCollection } from '../../../factories/MetadataCollection.mjs';
+import { MetadataFactory } from '../../../factories/MetadataFactory.mjs';
+import { TransformerError } from '../../TransformerError.mjs';
+
+var ReflectMetadataTransformer;
+(function (ReflectMetadataTransformer) {
+    ReflectMetadataTransformer.transform = (props) => {
+        if (!props.expression.typeArguments?.length)
+            throw new TransformerError({
+                code: "typia.reflect.metadata",
+                message: "no generic argument.",
+            });
+        // VALIDATE TUPLE ARGUMENTS
+        const top = props.expression.typeArguments[0];
+        if (!ts.isTupleTypeNode(top))
+            return props.expression;
+        else if (top.elements.some((child) => !ts.isTypeNode(child)))
+            return props.expression;
+        // GET TYPES
+        const types = top.elements.map((child) => props.context.checker.getTypeFromTypeNode(child));
+        if (types.some((t) => t.isTypeParameter()))
+            throw new TransformerError({
+                code: "typia.reflect.metadata",
+                message: "non-specified generic argument(s).",
+            });
+        // METADATA
+        const collection = new MetadataCollection();
+        const metadatas = types.map((type) => {
+            const result = MetadataFactory.analyze({
+                checker: props.context.checker,
+                transformer: props.context.transformer,
+                options: {
+                    escape: true,
+                    constant: true,
+                    absorb: true,
+                    functional: true,
+                },
+                collection,
+                type,
+            });
+            if (result.success === false)
+                throw TransformerError.from({
+                    code: "typia.reflect.metadata",
+                    errors: result.errors,
+                });
+            return result.data;
+        });
+        // CONVERT TO PRIMITIVE TYPE
+        const app = {
+            metadatas: metadatas.map((metadata) => metadata.toJSON()),
+            components: collection.toJSON(),
+        };
+        return LiteralFactory.write(app);
+    };
+})(ReflectMetadataTransformer || (ReflectMetadataTransformer = {}));
+
+export { ReflectMetadataTransformer };
+//# sourceMappingURL=ReflectMetadataTransformer.mjs.map

package/lib/transformers/features/reflect/ReflectMetadataTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReflectMetadataTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}