@typia/transform 12.0.0-dev.20260225

package/lib/features/misc/MiscValidatePruneTransformer.mjs

@@ -0,0 +1,14 @@
+import { MiscValidatePruneProgrammer } from '@typia/core';
+import { GenericTransformer } from '../../internal/GenericTransformer.mjs';
+
+var MiscValidatePruneTransformer;
+(function (MiscValidatePruneTransformer) {
+    MiscValidatePruneTransformer.transform = (props) => GenericTransformer.scalar({
+        ...props,
+        method: "misc.validatePrune",
+        write: MiscValidatePruneProgrammer.write,
+    });
+})(MiscValidatePruneTransformer || (MiscValidatePruneTransformer = {}));
+
+export { MiscValidatePruneTransformer };
+//# sourceMappingURL=MiscValidatePruneTransformer.mjs.map

package/lib/features/misc/MiscValidatePruneTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"MiscValidatePruneTransformer.mjs","sources":["../../../src/features/misc/MiscValidatePruneTransformer.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAKM,IAAW;AAAjB,CAAA,UAAiB,4BAA4B,EAAA;IAC9B,4BAAA,CAAA,SAAS,GAAG,CAAC,KAAsB,KAC9C,kBAAkB,CAAC,MAAM,CAAC;AACxB,QAAA,GAAG,KAAK;AACR,QAAA,MAAM,EAAE,oBAAoB;QAC5B,KAAK,EAAE,2BAA2B,CAAC,KAAK;AACzC,KAAA,CAAC;AACN,CAAC,EAPgB,4BAA4B,KAA5B,4BAA4B,GAAA,EAAA,CAAA,CAAA;;;;"}

package/lib/features/notations/NotationAssertGeneralTransformer.d.ts

@@ -0,0 +1,4 @@
+import { ITransformProps } from "../../ITransformProps";
+export declare namespace NotationAssertGeneralTransformer {
+    const transform: (rename: (str: string) => string) => (props: ITransformProps) => import("typescript").CallExpression;
+}

package/lib/features/notations/NotationAssertGeneralTransformer.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotationAssertGeneralTransformer = void 0;
+const core_1 = require("@typia/core");
+const utils_1 = require("@typia/utils");
+const GenericTransformer_1 = require("../../internal/GenericTransformer");
+var NotationAssertGeneralTransformer;
+(function (NotationAssertGeneralTransformer) {
+    NotationAssertGeneralTransformer.transform = (rename) => (props) => GenericTransformer_1.GenericTransformer.scalar(Object.assign(Object.assign({}, props), { method: `notations.assert${utils_1.NamingConvention.capitalize(rename.name)}`, write: (x) => core_1.NotationAssertGeneralProgrammer.write(Object.assign(Object.assign({}, x), { rename })) }));
+})(NotationAssertGeneralTransformer || (exports.NotationAssertGeneralTransformer = NotationAssertGeneralTransformer = {}));
+//# sourceMappingURL=NotationAssertGeneralTransformer.js.map

package/lib/features/notations/NotationAssertGeneralTransformer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NotationAssertGeneralTransformer.js","sourceRoot":"","sources":["../../../src/features/notations/NotationAssertGeneralTransformer.ts"],"names":[],"mappings":";;;AAAA,sCAA8D;AAC9D,wCAAgD;AAGhD,0EAAuE;AAEvE,IAAiB,gCAAgC,CAYhD;AAZD,WAAiB,gCAAgC;IAClC,0CAAS,GACpB,CAAC,MAA+B,EAAE,EAAE,CAAC,CAAC,KAAsB,EAAE,EAAE,CAC9D,uCAAkB,CAAC,MAAM,iCACpB,KAAK,KACR,MAAM,EAAE,mBAAmB,wBAAgB,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,EACrE,KAAK,EAAE,CAAC,CAAC,EAAE,EAAE,CACX,sCAA+B,CAAC,KAAK,iCAChC,CAAC,KACJ,MAAM,IACN,IACJ,CAAC;AACT,CAAC,EAZgB,gCAAgC,gDAAhC,gCAAgC,QAYhD"}

package/lib/features/notations/NotationAssertGeneralTransformer.mjs

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"NotationAssertGeneralTransformer.mjs","sources":["../../../src/features/notations/NotationAssertGeneralTransformer.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAMM,IAAW;AAAjB,CAAA,UAAiB,gCAAgC,EAAA;AAClC,IAAA,gCAAA,CAAA,SAAS,GACpB,CAAC,MAA+B,KAAK,CAAC,KAAsB,KAC1D,kBAAkB,CAAC,MAAM,CAAC;AACxB,QAAA,GAAG,KAAK;QACR,MAAM,EAAE,CAAA,gBAAA,EAAmB,gBAAgB,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA,CAAE;QACrE,KAAK,EAAE,CAAC,CAAC,KACP,+BAA+B,CAAC,KAAK,CAAC;AACpC,YAAA,GAAG,CAAC;YACJ,MAAM;SACP,CAAC;AACL,KAAA,CAAC;AACR,CAAC,EAZgB,gCAAgC,KAAhC,gCAAgC,GAAA,EAAA,CAAA,CAAA;;;;"}

package/lib/features/notations/NotationCreateAssertGeneralTransformer.d.ts

@@ -0,0 +1,4 @@
+import { ITransformProps } from "../../ITransformProps";
+export declare namespace NotationCreateAssertGeneralTransformer {
+    const transform: (rename: (str: string) => string) => (props: ITransformProps) => import("typescript").Expression | import("typescript").ArrowFunction;
+}

package/lib/features/notations/NotationCreateAssertGeneralTransformer.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotationCreateAssertGeneralTransformer = void 0;
+const core_1 = require("@typia/core");
+const utils_1 = require("@typia/utils");
+const GenericTransformer_1 = require("../../internal/GenericTransformer");
+var NotationCreateAssertGeneralTransformer;
+(function (NotationCreateAssertGeneralTransformer) {
+    NotationCreateAssertGeneralTransformer.transform = (rename) => (props) => GenericTransformer_1.GenericTransformer.factory(Object.assign(Object.assign({}, props), { method: `notations.createAssert${utils_1.NamingConvention.capitalize(rename.name)}`, write: (x) => core_1.NotationAssertGeneralProgrammer.write(Object.assign(Object.assign({}, x), { rename })) }));
+})(NotationCreateAssertGeneralTransformer || (exports.NotationCreateAssertGeneralTransformer = NotationCreateAssertGeneralTransformer = {}));
+//# sourceMappingURL=NotationCreateAssertGeneralTransformer.js.map

package/lib/features/notations/NotationCreateAssertGeneralTransformer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NotationCreateAssertGeneralTransformer.js","sourceRoot":"","sources":["../../../src/features/notations/NotationCreateAssertGeneralTransformer.ts"],"names":[],"mappings":";;;AAAA,sCAA8D;AAC9D,wCAAgD;AAGhD,0EAAuE;AAEvE,IAAiB,sCAAsC,CAYtD;AAZD,WAAiB,sCAAsC;IACxC,gDAAS,GACpB,CAAC,MAA+B,EAAE,EAAE,CAAC,CAAC,KAAsB,EAAE,EAAE,CAC9D,uCAAkB,CAAC,OAAO,iCACrB,KAAK,KACR,MAAM,EAAE,yBAAyB,wBAAgB,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,EAC3E,KAAK,EAAE,CAAC,CAAC,EAAE,EAAE,CACX,sCAA+B,CAAC,KAAK,iCAChC,CAAC,KACJ,MAAM,IACN,IACJ,CAAC;AACT,CAAC,EAZgB,sCAAsC,sDAAtC,sCAAsC,QAYtD"}

package/lib/features/notations/NotationCreateAssertGeneralTransformer.mjs

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"NotationCreateAssertGeneralTransformer.mjs","sources":["../../../src/features/notations/NotationCreateAssertGeneralTransformer.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAMM,IAAW;AAAjB,CAAA,UAAiB,sCAAsC,EAAA;AACxC,IAAA,sCAAA,CAAA,SAAS,GACpB,CAAC,MAA+B,KAAK,CAAC,KAAsB,KAC1D,kBAAkB,CAAC,OAAO,CAAC;AACzB,QAAA,GAAG,KAAK;QACR,MAAM,EAAE,CAAA,sBAAA,EAAyB,gBAAgB,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA,CAAE;QAC3E,KAAK,EAAE,CAAC,CAAC,KACP,+BAA+B,CAAC,KAAK,CAAC;AACpC,YAAA,GAAG,CAAC;YACJ,MAAM;SACP,CAAC;AACL,KAAA,CAAC;AACR,CAAC,EAZgB,sCAAsC,KAAtC,sCAAsC,GAAA,EAAA,CAAA,CAAA;;;;"}

package/lib/features/notations/NotationCreateGeneralTransformer.d.ts

@@ -0,0 +1,4 @@
+import { ITransformProps } from "../../ITransformProps";
+export declare namespace NotationCreateGeneralTransformer {
+    const transform: (rename: (str: string) => string) => (props: ITransformProps) => import("typescript").Expression | import("typescript").ArrowFunction;
+}

package/lib/features/notations/NotationCreateGeneralTransformer.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotationCreateGeneralTransformer = void 0;
+const core_1 = require("@typia/core");
+const utils_1 = require("@typia/utils");
+const GenericTransformer_1 = require("../../internal/GenericTransformer");
+var NotationCreateGeneralTransformer;
+(function (NotationCreateGeneralTransformer) {
+    NotationCreateGeneralTransformer.transform = (rename) => (props) => GenericTransformer_1.GenericTransformer.factory(Object.assign(Object.assign({}, props), { method: `notations.create${utils_1.NamingConvention.capitalize(rename.name)}`, write: (x) => core_1.NotationGeneralProgrammer.write(Object.assign(Object.assign({}, x), { rename })) }));
+})(NotationCreateGeneralTransformer || (exports.NotationCreateGeneralTransformer = NotationCreateGeneralTransformer = {}));
+//# sourceMappingURL=NotationCreateGeneralTransformer.js.map

package/lib/features/notations/NotationCreateGeneralTransformer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NotationCreateGeneralTransformer.js","sourceRoot":"","sources":["../../../src/features/notations/NotationCreateGeneralTransformer.ts"],"names":[],"mappings":";;;AAAA,sCAAwD;AACxD,wCAAgD;AAGhD,0EAAuE;AAEvE,IAAiB,gCAAgC,CAYhD;AAZD,WAAiB,gCAAgC;IAClC,0CAAS,GACpB,CAAC,MAA+B,EAAE,EAAE,CAAC,CAAC,KAAsB,EAAE,EAAE,CAC9D,uCAAkB,CAAC,OAAO,iCACrB,KAAK,KACR,MAAM,EAAE,mBAAmB,wBAAgB,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,EACrE,KAAK,EAAE,CAAC,CAAC,EAAE,EAAE,CACX,gCAAyB,CAAC,KAAK,iCAC1B,CAAC,KACJ,MAAM,IACN,IACJ,CAAC;AACT,CAAC,EAZgB,gCAAgC,gDAAhC,gCAAgC,QAYhD"}

package/lib/features/notations/NotationCreateGeneralTransformer.mjs

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"NotationCreateGeneralTransformer.mjs","sources":["../../../src/features/notations/NotationCreateGeneralTransformer.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAMM,IAAW;AAAjB,CAAA,UAAiB,gCAAgC,EAAA;AAClC,IAAA,gCAAA,CAAA,SAAS,GACpB,CAAC,MAA+B,KAAK,CAAC,KAAsB,KAC1D,kBAAkB,CAAC,OAAO,CAAC;AACzB,QAAA,GAAG,KAAK;QACR,MAAM,EAAE,CAAA,gBAAA,EAAmB,gBAAgB,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA,CAAE;QACrE,KAAK,EAAE,CAAC,CAAC,KACP,yBAAyB,CAAC,KAAK,CAAC;AAC9B,YAAA,GAAG,CAAC;YACJ,MAAM;SACP,CAAC;AACL,KAAA,CAAC;AACR,CAAC,EAZgB,gCAAgC,KAAhC,gCAAgC,GAAA,EAAA,CAAA,CAAA;;;;"}

package/lib/features/notations/NotationCreateIsGeneralTransformer.d.ts

@@ -0,0 +1,4 @@
+import { ITransformProps } from "../../ITransformProps";
+export declare namespace NotationCreateIsGeneralTransformer {
+    const transform: (rename: (str: string) => string) => (props: ITransformProps) => import("typescript").Expression | import("typescript").ArrowFunction;
+}

package/lib/features/notations/NotationCreateIsGeneralTransformer.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotationCreateIsGeneralTransformer = void 0;
+const core_1 = require("@typia/core");
+const utils_1 = require("@typia/utils");
+const GenericTransformer_1 = require("../../internal/GenericTransformer");
+var NotationCreateIsGeneralTransformer;
+(function (NotationCreateIsGeneralTransformer) {
+    NotationCreateIsGeneralTransformer.transform = (rename) => (props) => GenericTransformer_1.GenericTransformer.factory(Object.assign(Object.assign({}, props), { method: `notations.createIs${utils_1.NamingConvention.capitalize(rename.name)}`, write: (x) => core_1.NotationIsGeneralProgrammer.write(Object.assign(Object.assign({}, x), { rename })) }));
+})(NotationCreateIsGeneralTransformer || (exports.NotationCreateIsGeneralTransformer = NotationCreateIsGeneralTransformer = {}));
+//# sourceMappingURL=NotationCreateIsGeneralTransformer.js.map

package/lib/features/notations/NotationCreateIsGeneralTransformer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NotationCreateIsGeneralTransformer.js","sourceRoot":"","sources":["../../../src/features/notations/NotationCreateIsGeneralTransformer.ts"],"names":[],"mappings":";;;AAAA,sCAA0D;AAC1D,wCAAgD;AAGhD,0EAAuE;AAEvE,IAAiB,kCAAkC,CAYlD;AAZD,WAAiB,kCAAkC;IACpC,4CAAS,GACpB,CAAC,MAA+B,EAAE,EAAE,CAAC,CAAC,KAAsB,EAAE,EAAE,CAC9D,uCAAkB,CAAC,OAAO,iCACrB,KAAK,KACR,MAAM,EAAE,qBAAqB,wBAAgB,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,EACvE,KAAK,EAAE,CAAC,CAAC,EAAE,EAAE,CACX,kCAA2B,CAAC,KAAK,iCAC5B,CAAC,KACJ,MAAM,IACN,IACJ,CAAC;AACT,CAAC,EAZgB,kCAAkC,kDAAlC,kCAAkC,QAYlD"}

package/lib/features/notations/NotationCreateIsGeneralTransformer.mjs

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"NotationCreateIsGeneralTransformer.mjs","sources":["../../../src/features/notations/NotationCreateIsGeneralTransformer.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAMM,IAAW;AAAjB,CAAA,UAAiB,kCAAkC,EAAA;AACpC,IAAA,kCAAA,CAAA,SAAS,GACpB,CAAC,MAA+B,KAAK,CAAC,KAAsB,KAC1D,kBAAkB,CAAC,OAAO,CAAC;AACzB,QAAA,GAAG,KAAK;QACR,MAAM,EAAE,CAAA,kBAAA,EAAqB,gBAAgB,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA,CAAE;QACvE,KAAK,EAAE,CAAC,CAAC,KACP,2BAA2B,CAAC,KAAK,CAAC;AAChC,YAAA,GAAG,CAAC;YACJ,MAAM;SACP,CAAC;AACL,KAAA,CAAC;AACR,CAAC,EAZgB,kCAAkC,KAAlC,kCAAkC,GAAA,EAAA,CAAA,CAAA;;;;"}

package/lib/features/notations/NotationCreateValidateGeneralTransformer.d.ts

@@ -0,0 +1,4 @@
+import { ITransformProps } from "../../ITransformProps";
+export declare namespace NotationCreateValidateGeneralTransformer {
+    const transform: (rename: (str: string) => string) => (props: ITransformProps) => import("typescript").Expression | import("typescript").ArrowFunction;
+}

package/lib/features/notations/NotationCreateValidateGeneralTransformer.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotationCreateValidateGeneralTransformer = void 0;
+const core_1 = require("@typia/core");
+const utils_1 = require("@typia/utils");
+const GenericTransformer_1 = require("../../internal/GenericTransformer");
+var NotationCreateValidateGeneralTransformer;
+(function (NotationCreateValidateGeneralTransformer) {
+    NotationCreateValidateGeneralTransformer.transform = (rename) => (props) => GenericTransformer_1.GenericTransformer.factory(Object.assign(Object.assign({}, props), { method: `notations.createValidate${utils_1.NamingConvention.capitalize(rename.name)}`, write: (x) => core_1.NotationValidateGeneralProgrammer.write(Object.assign(Object.assign({}, x), { rename })) }));
+})(NotationCreateValidateGeneralTransformer || (exports.NotationCreateValidateGeneralTransformer = NotationCreateValidateGeneralTransformer = {}));
+//# sourceMappingURL=NotationCreateValidateGeneralTransformer.js.map

package/lib/features/notations/NotationCreateValidateGeneralTransformer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NotationCreateValidateGeneralTransformer.js","sourceRoot":"","sources":["../../../src/features/notations/NotationCreateValidateGeneralTransformer.ts"],"names":[],"mappings":";;;AAAA,sCAAgE;AAChE,wCAAgD;AAGhD,0EAAuE;AAEvE,IAAiB,wCAAwC,CAYxD;AAZD,WAAiB,wCAAwC;IAC1C,kDAAS,GACpB,CAAC,MAA+B,EAAE,EAAE,CAAC,CAAC,KAAsB,EAAE,EAAE,CAC9D,uCAAkB,CAAC,OAAO,iCACrB,KAAK,KACR,MAAM,EAAE,2BAA2B,wBAAgB,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,EAC7E,KAAK,EAAE,CAAC,CAAC,EAAE,EAAE,CACX,wCAAiC,CAAC,KAAK,iCAClC,CAAC,KACJ,MAAM,IACN,IACJ,CAAC;AACT,CAAC,EAZgB,wCAAwC,wDAAxC,wCAAwC,QAYxD"}

package/lib/features/notations/NotationCreateValidateGeneralTransformer.mjs

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"NotationCreateValidateGeneralTransformer.mjs","sources":["../../../src/features/notations/NotationCreateValidateGeneralTransformer.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAMM,IAAW;AAAjB,CAAA,UAAiB,wCAAwC,EAAA;AAC1C,IAAA,wCAAA,CAAA,SAAS,GACpB,CAAC,MAA+B,KAAK,CAAC,KAAsB,KAC1D,kBAAkB,CAAC,OAAO,CAAC;AACzB,QAAA,GAAG,KAAK;QACR,MAAM,EAAE,CAAA,wBAAA,EAA2B,gBAAgB,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA,CAAE;QAC7E,KAAK,EAAE,CAAC,CAAC,KACP,iCAAiC,CAAC,KAAK,CAAC;AACtC,YAAA,GAAG,CAAC;YACJ,MAAM;SACP,CAAC;AACL,KAAA,CAAC;AACR,CAAC,EAZgB,wCAAwC,KAAxC,wCAAwC,GAAA,EAAA,CAAA,CAAA;;;;"}

package/lib/features/notations/NotationGeneralTransformer.d.ts

@@ -0,0 +1,4 @@
+import { ITransformProps } from "../../ITransformProps";
+export declare namespace NotationGeneralTransformer {
+    const transform: (rename: (str: string) => string) => (props: ITransformProps) => import("typescript").CallExpression;
+}

package/lib/features/notations/NotationGeneralTransformer.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotationGeneralTransformer = void 0;
+const core_1 = require("@typia/core");
+const GenericTransformer_1 = require("../../internal/GenericTransformer");
+var NotationGeneralTransformer;
+(function (NotationGeneralTransformer) {
+    NotationGeneralTransformer.transform = (rename) => (props) => GenericTransformer_1.GenericTransformer.scalar(Object.assign(Object.assign({}, props), { method: `notations.${rename.name}`, write: (x) => core_1.NotationGeneralProgrammer.write(Object.assign(Object.assign({}, x), { rename })) }));
+})(NotationGeneralTransformer || (exports.NotationGeneralTransformer = NotationGeneralTransformer = {}));
+//# sourceMappingURL=NotationGeneralTransformer.js.map

package/lib/features/notations/NotationGeneralTransformer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NotationGeneralTransformer.js","sourceRoot":"","sources":["../../../src/features/notations/NotationGeneralTransformer.ts"],"names":[],"mappings":";;;AAAA,sCAAwD;AAGxD,0EAAuE;AAEvE,IAAiB,0BAA0B,CAY1C;AAZD,WAAiB,0BAA0B;IAC5B,oCAAS,GACpB,CAAC,MAA+B,EAAE,EAAE,CAAC,CAAC,KAAsB,EAAE,EAAE,CAC9D,uCAAkB,CAAC,MAAM,iCACpB,KAAK,KACR,MAAM,EAAE,aAAa,MAAM,CAAC,IAAI,EAAE,EAClC,KAAK,EAAE,CAAC,CAAC,EAAE,EAAE,CACX,gCAAyB,CAAC,KAAK,iCAC1B,CAAC,KACJ,MAAM,IACN,IACJ,CAAC;AACT,CAAC,EAZgB,0BAA0B,0CAA1B,0BAA0B,QAY1C"}

package/lib/features/notations/NotationGeneralTransformer.mjs

@@ -0,0 +1,17 @@
+import { NotationGeneralProgrammer } from '@typia/core';
+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/features/notations/NotationGeneralTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"NotationGeneralTransformer.mjs","sources":["../../../src/features/notations/NotationGeneralTransformer.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAKM,IAAW;AAAjB,CAAA,UAAiB,0BAA0B,EAAA;AAC5B,IAAA,0BAAA,CAAA,SAAS,GACpB,CAAC,MAA+B,KAAK,CAAC,KAAsB,KAC1D,kBAAkB,CAAC,MAAM,CAAC;AACxB,QAAA,GAAG,KAAK;AACR,QAAA,MAAM,EAAE,CAAA,UAAA,EAAa,MAAM,CAAC,IAAI,CAAA,CAAE;QAClC,KAAK,EAAE,CAAC,CAAC,KACP,yBAAyB,CAAC,KAAK,CAAC;AAC9B,YAAA,GAAG,CAAC;YACJ,MAAM;SACP,CAAC;AACL,KAAA,CAAC;AACR,CAAC,EAZgB,0BAA0B,KAA1B,0BAA0B,GAAA,EAAA,CAAA,CAAA;;;;"}

package/lib/features/notations/NotationIsGeneralTransformer.d.ts

@@ -0,0 +1,4 @@
+import { ITransformProps } from "../../ITransformProps";
+export declare namespace NotationIsGeneralTransformer {
+    const transform: (rename: (str: string) => string) => (props: ITransformProps) => import("typescript").CallExpression;
+}

package/lib/features/notations/NotationIsGeneralTransformer.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotationIsGeneralTransformer = void 0;
+const core_1 = require("@typia/core");
+const utils_1 = require("@typia/utils");
+const GenericTransformer_1 = require("../../internal/GenericTransformer");
+var NotationIsGeneralTransformer;
+(function (NotationIsGeneralTransformer) {
+    NotationIsGeneralTransformer.transform = (rename) => (props) => GenericTransformer_1.GenericTransformer.scalar(Object.assign(Object.assign({}, props), { method: `notations.is${utils_1.NamingConvention.capitalize(rename.name)}`, write: (x) => core_1.NotationIsGeneralProgrammer.write(Object.assign(Object.assign({}, x), { rename })) }));
+})(NotationIsGeneralTransformer || (exports.NotationIsGeneralTransformer = NotationIsGeneralTransformer = {}));
+//# sourceMappingURL=NotationIsGeneralTransformer.js.map

package/lib/features/notations/NotationIsGeneralTransformer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NotationIsGeneralTransformer.js","sourceRoot":"","sources":["../../../src/features/notations/NotationIsGeneralTransformer.ts"],"names":[],"mappings":";;;AAAA,sCAA0D;AAC1D,wCAAgD;AAGhD,0EAAuE;AAEvE,IAAiB,4BAA4B,CAY5C;AAZD,WAAiB,4BAA4B;IAC9B,sCAAS,GACpB,CAAC,MAA+B,EAAE,EAAE,CAAC,CAAC,KAAsB,EAAE,EAAE,CAC9D,uCAAkB,CAAC,MAAM,iCACpB,KAAK,KACR,MAAM,EAAE,eAAe,wBAAgB,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,EACjE,KAAK,EAAE,CAAC,CAAC,EAAE,EAAE,CACX,kCAA2B,CAAC,KAAK,iCAC5B,CAAC,KACJ,MAAM,IACN,IACJ,CAAC;AACT,CAAC,EAZgB,4BAA4B,4CAA5B,4BAA4B,QAY5C"}

package/lib/features/notations/NotationIsGeneralTransformer.mjs

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"NotationIsGeneralTransformer.mjs","sources":["../../../src/features/notations/NotationIsGeneralTransformer.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAMM,IAAW;AAAjB,CAAA,UAAiB,4BAA4B,EAAA;AAC9B,IAAA,4BAAA,CAAA,SAAS,GACpB,CAAC,MAA+B,KAAK,CAAC,KAAsB,KAC1D,kBAAkB,CAAC,MAAM,CAAC;AACxB,QAAA,GAAG,KAAK;QACR,MAAM,EAAE,CAAA,YAAA,EAAe,gBAAgB,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA,CAAE;QACjE,KAAK,EAAE,CAAC,CAAC,KACP,2BAA2B,CAAC,KAAK,CAAC;AAChC,YAAA,GAAG,CAAC;YACJ,MAAM;SACP,CAAC;AACL,KAAA,CAAC;AACR,CAAC,EAZgB,4BAA4B,KAA5B,4BAA4B,GAAA,EAAA,CAAA,CAAA;;;;"}

package/lib/features/notations/NotationValidateGeneralTransformer.d.ts

@@ -0,0 +1,4 @@
+import { ITransformProps } from "../../ITransformProps";
+export declare namespace NotationValidateGeneralTransformer {
+    const transform: (rename: (str: string) => string) => (props: ITransformProps) => import("typescript").CallExpression;
+}

package/lib/features/notations/NotationValidateGeneralTransformer.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotationValidateGeneralTransformer = void 0;
+const core_1 = require("@typia/core");
+const utils_1 = require("@typia/utils");
+const GenericTransformer_1 = require("../../internal/GenericTransformer");
+var NotationValidateGeneralTransformer;
+(function (NotationValidateGeneralTransformer) {
+    NotationValidateGeneralTransformer.transform = (rename) => (props) => GenericTransformer_1.GenericTransformer.scalar(Object.assign(Object.assign({}, props), { method: `notations.validate${utils_1.NamingConvention.capitalize(rename.name)}`, write: (x) => core_1.NotationValidateGeneralProgrammer.write(Object.assign(Object.assign({}, x), { rename })) }));
+})(NotationValidateGeneralTransformer || (exports.NotationValidateGeneralTransformer = NotationValidateGeneralTransformer = {}));
+//# sourceMappingURL=NotationValidateGeneralTransformer.js.map

package/lib/features/notations/NotationValidateGeneralTransformer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NotationValidateGeneralTransformer.js","sourceRoot":"","sources":["../../../src/features/notations/NotationValidateGeneralTransformer.ts"],"names":[],"mappings":";;;AAAA,sCAAgE;AAChE,wCAAgD;AAGhD,0EAAuE;AAEvE,IAAiB,kCAAkC,CAYlD;AAZD,WAAiB,kCAAkC;IACpC,4CAAS,GACpB,CAAC,MAA+B,EAAE,EAAE,CAAC,CAAC,KAAsB,EAAE,EAAE,CAC9D,uCAAkB,CAAC,MAAM,iCACpB,KAAK,KACR,MAAM,EAAE,qBAAqB,wBAAgB,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,EACvE,KAAK,EAAE,CAAC,CAAC,EAAE,EAAE,CACX,wCAAiC,CAAC,KAAK,iCAClC,CAAC,KACJ,MAAM,IACN,IACJ,CAAC;AACT,CAAC,EAZgB,kCAAkC,kDAAlC,kCAAkC,QAYlD"}

package/lib/features/notations/NotationValidateGeneralTransformer.mjs

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"NotationValidateGeneralTransformer.mjs","sources":["../../../src/features/notations/NotationValidateGeneralTransformer.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAMM,IAAW;AAAjB,CAAA,UAAiB,kCAAkC,EAAA;AACpC,IAAA,kCAAA,CAAA,SAAS,GACpB,CAAC,MAA+B,KAAK,CAAC,KAAsB,KAC1D,kBAAkB,CAAC,MAAM,CAAC;AACxB,QAAA,GAAG,KAAK;QACR,MAAM,EAAE,CAAA,kBAAA,EAAqB,gBAAgB,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA,CAAE;QACvE,KAAK,EAAE,CAAC,CAAC,KACP,iCAAiC,CAAC,KAAK,CAAC;AACtC,YAAA,GAAG,CAAC;YACJ,MAAM;SACP,CAAC;AACL,KAAA,CAAC;AACR,CAAC,EAZgB,kCAAkC,KAAlC,kCAAkC,GAAA,EAAA,CAAA,CAAA;;;;"}

package/lib/features/protobuf/ProtobufAssertDecodeTransformer.d.ts

@@ -0,0 +1,4 @@
+import { ITransformProps } from "../../ITransformProps";
+export declare namespace ProtobufAssertDecodeTransformer {
+    const transform: (props: ITransformProps) => import("typescript").CallExpression;
+}

package/lib/features/protobuf/ProtobufAssertDecodeTransformer.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProtobufAssertDecodeTransformer = void 0;
+const core_1 = require("@typia/core");
+const GenericTransformer_1 = require("../../internal/GenericTransformer");
+var ProtobufAssertDecodeTransformer;
+(function (ProtobufAssertDecodeTransformer) {
+    ProtobufAssertDecodeTransformer.transform = (props) => GenericTransformer_1.GenericTransformer.scalar(Object.assign(Object.assign({}, props), { method: "protobuf.assertDecode", write: core_1.ProtobufAssertDecodeProgrammer.write }));
+})(ProtobufAssertDecodeTransformer || (exports.ProtobufAssertDecodeTransformer = ProtobufAssertDecodeTransformer = {}));
+//# sourceMappingURL=ProtobufAssertDecodeTransformer.js.map

package/lib/features/protobuf/ProtobufAssertDecodeTransformer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtobufAssertDecodeTransformer.js","sourceRoot":"","sources":["../../../src/features/protobuf/ProtobufAssertDecodeTransformer.ts"],"names":[],"mappings":";;;AAAA,sCAA6D;AAG7D,0EAAuE;AAEvE,IAAiB,+BAA+B,CAO/C;AAPD,WAAiB,+BAA+B;IACjC,yCAAS,GAAG,CAAC,KAAsB,EAAE,EAAE,CAClD,uCAAkB,CAAC,MAAM,iCACpB,KAAK,KACR,MAAM,EAAE,uBAAuB,EAC/B,KAAK,EAAE,qCAA8B,CAAC,KAAK,IAC3C,CAAC;AACP,CAAC,EAPgB,+BAA+B,+CAA/B,+BAA+B,QAO/C"}

package/lib/features/protobuf/ProtobufAssertDecodeTransformer.mjs

@@ -0,0 +1,14 @@
+import { ProtobufAssertDecodeProgrammer } from '@typia/core';
+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/features/protobuf/ProtobufAssertDecodeTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtobufAssertDecodeTransformer.mjs","sources":["../../../src/features/protobuf/ProtobufAssertDecodeTransformer.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAKM,IAAW;AAAjB,CAAA,UAAiB,+BAA+B,EAAA;IACjC,+BAAA,CAAA,SAAS,GAAG,CAAC,KAAsB,KAC9C,kBAAkB,CAAC,MAAM,CAAC;AACxB,QAAA,GAAG,KAAK;AACR,QAAA,MAAM,EAAE,uBAAuB;QAC/B,KAAK,EAAE,8BAA8B,CAAC,KAAK;AAC5C,KAAA,CAAC;AACN,CAAC,EAPgB,+BAA+B,KAA/B,+BAA+B,GAAA,EAAA,CAAA,CAAA;;;;"}

package/lib/features/protobuf/ProtobufAssertEncodeTransformer.d.ts

@@ -0,0 +1,4 @@
+import { ITransformProps } from "../../ITransformProps";
+export declare namespace ProtobufAssertEncodeTransformer {
+    const transform: (props: ITransformProps) => import("typescript").CallExpression;
+}

package/lib/features/protobuf/ProtobufAssertEncodeTransformer.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProtobufAssertEncodeTransformer = void 0;
+const core_1 = require("@typia/core");
+const GenericTransformer_1 = require("../../internal/GenericTransformer");
+var ProtobufAssertEncodeTransformer;
+(function (ProtobufAssertEncodeTransformer) {
+    ProtobufAssertEncodeTransformer.transform = (props) => GenericTransformer_1.GenericTransformer.scalar(Object.assign(Object.assign({}, props), { method: "protobuf.assertEncode", write: core_1.ProtobufAssertEncodeProgrammer.write }));
+})(ProtobufAssertEncodeTransformer || (exports.ProtobufAssertEncodeTransformer = ProtobufAssertEncodeTransformer = {}));
+//# sourceMappingURL=ProtobufAssertEncodeTransformer.js.map

package/lib/features/protobuf/ProtobufAssertEncodeTransformer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtobufAssertEncodeTransformer.js","sourceRoot":"","sources":["../../../src/features/protobuf/ProtobufAssertEncodeTransformer.ts"],"names":[],"mappings":";;;AAAA,sCAA6D;AAG7D,0EAAuE;AAEvE,IAAiB,+BAA+B,CAO/C;AAPD,WAAiB,+BAA+B;IACjC,yCAAS,GAAG,CAAC,KAAsB,EAAE,EAAE,CAClD,uCAAkB,CAAC,MAAM,iCACpB,KAAK,KACR,MAAM,EAAE,uBAAuB,EAC/B,KAAK,EAAE,qCAA8B,CAAC,KAAK,IAC3C,CAAC;AACP,CAAC,EAPgB,+BAA+B,+CAA/B,+BAA+B,QAO/C"}

package/lib/features/protobuf/ProtobufAssertEncodeTransformer.mjs

@@ -0,0 +1,14 @@
+import { ProtobufAssertEncodeProgrammer } from '@typia/core';
+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/features/protobuf/ProtobufAssertEncodeTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtobufAssertEncodeTransformer.mjs","sources":["../../../src/features/protobuf/ProtobufAssertEncodeTransformer.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAKM,IAAW;AAAjB,CAAA,UAAiB,+BAA+B,EAAA;IACjC,+BAAA,CAAA,SAAS,GAAG,CAAC,KAAsB,KAC9C,kBAAkB,CAAC,MAAM,CAAC;AACxB,QAAA,GAAG,KAAK;AACR,QAAA,MAAM,EAAE,uBAAuB;QAC/B,KAAK,EAAE,8BAA8B,CAAC,KAAK;AAC5C,KAAA,CAAC;AACN,CAAC,EAPgB,+BAA+B,KAA/B,+BAA+B,GAAA,EAAA,CAAA,CAAA;;;;"}

package/lib/features/protobuf/ProtobufCreateAssertDecodeTransformer.d.ts

@@ -0,0 +1,4 @@
+import { ITransformProps } from "../../ITransformProps";
+export declare namespace ProtobufCreateAssertDecodeTransformer {
+    const transform: (props: ITransformProps) => import("typescript").Expression | import("typescript").ArrowFunction;
+}

package/lib/features/protobuf/ProtobufCreateAssertDecodeTransformer.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProtobufCreateAssertDecodeTransformer = void 0;
+const core_1 = require("@typia/core");
+const GenericTransformer_1 = require("../../internal/GenericTransformer");
+var ProtobufCreateAssertDecodeTransformer;
+(function (ProtobufCreateAssertDecodeTransformer) {
+    ProtobufCreateAssertDecodeTransformer.transform = (props) => GenericTransformer_1.GenericTransformer.factory(Object.assign(Object.assign({}, props), { method: "protobuf.createAssertDecode", write: core_1.ProtobufAssertDecodeProgrammer.write }));
+})(ProtobufCreateAssertDecodeTransformer || (exports.ProtobufCreateAssertDecodeTransformer = ProtobufCreateAssertDecodeTransformer = {}));
+//# sourceMappingURL=ProtobufCreateAssertDecodeTransformer.js.map

package/lib/features/protobuf/ProtobufCreateAssertDecodeTransformer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtobufCreateAssertDecodeTransformer.js","sourceRoot":"","sources":["../../../src/features/protobuf/ProtobufCreateAssertDecodeTransformer.ts"],"names":[],"mappings":";;;AAAA,sCAA6D;AAG7D,0EAAuE;AAEvE,IAAiB,qCAAqC,CAOrD;AAPD,WAAiB,qCAAqC;IACvC,+CAAS,GAAG,CAAC,KAAsB,EAAE,EAAE,CAClD,uCAAkB,CAAC,OAAO,iCACrB,KAAK,KACR,MAAM,EAAE,6BAA6B,EACrC,KAAK,EAAE,qCAA8B,CAAC,KAAK,IAC3C,CAAC;AACP,CAAC,EAPgB,qCAAqC,qDAArC,qCAAqC,QAOrD"}

package/lib/features/protobuf/ProtobufCreateAssertDecodeTransformer.mjs

@@ -0,0 +1,14 @@
+import { ProtobufAssertDecodeProgrammer } from '@typia/core';
+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/features/protobuf/ProtobufCreateAssertDecodeTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtobufCreateAssertDecodeTransformer.mjs","sources":["../../../src/features/protobuf/ProtobufCreateAssertDecodeTransformer.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAKM,IAAW;AAAjB,CAAA,UAAiB,qCAAqC,EAAA;IACvC,qCAAA,CAAA,SAAS,GAAG,CAAC,KAAsB,KAC9C,kBAAkB,CAAC,OAAO,CAAC;AACzB,QAAA,GAAG,KAAK;AACR,QAAA,MAAM,EAAE,6BAA6B;QACrC,KAAK,EAAE,8BAA8B,CAAC,KAAK;AAC5C,KAAA,CAAC;AACN,CAAC,EAPgB,qCAAqC,KAArC,qCAAqC,GAAA,EAAA,CAAA,CAAA;;;;"}

package/lib/features/protobuf/ProtobufCreateAssertEncodeTransformer.d.ts

@@ -0,0 +1,4 @@
+import { ITransformProps } from "../../ITransformProps";
+export declare namespace ProtobufCreateAssertEncodeTransformer {
+    const transform: (props: ITransformProps) => import("typescript").Expression | import("typescript").ArrowFunction;
+}

package/lib/features/protobuf/ProtobufCreateAssertEncodeTransformer.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProtobufCreateAssertEncodeTransformer = void 0;
+const core_1 = require("@typia/core");
+const GenericTransformer_1 = require("../../internal/GenericTransformer");
+var ProtobufCreateAssertEncodeTransformer;
+(function (ProtobufCreateAssertEncodeTransformer) {
+    ProtobufCreateAssertEncodeTransformer.transform = (props) => GenericTransformer_1.GenericTransformer.factory(Object.assign(Object.assign({}, props), { method: "protobuf.createAssertEncode", write: core_1.ProtobufAssertEncodeProgrammer.write }));
+})(ProtobufCreateAssertEncodeTransformer || (exports.ProtobufCreateAssertEncodeTransformer = ProtobufCreateAssertEncodeTransformer = {}));
+//# sourceMappingURL=ProtobufCreateAssertEncodeTransformer.js.map

package/lib/features/protobuf/ProtobufCreateAssertEncodeTransformer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtobufCreateAssertEncodeTransformer.js","sourceRoot":"","sources":["../../../src/features/protobuf/ProtobufCreateAssertEncodeTransformer.ts"],"names":[],"mappings":";;;AAAA,sCAA6D;AAG7D,0EAAuE;AAEvE,IAAiB,qCAAqC,CAOrD;AAPD,WAAiB,qCAAqC;IACvC,+CAAS,GAAG,CAAC,KAAsB,EAAE,EAAE,CAClD,uCAAkB,CAAC,OAAO,iCACrB,KAAK,KACR,MAAM,EAAE,6BAA6B,EACrC,KAAK,EAAE,qCAA8B,CAAC,KAAK,IAC3C,CAAC;AACP,CAAC,EAPgB,qCAAqC,qDAArC,qCAAqC,QAOrD"}

package/lib/features/protobuf/ProtobufCreateAssertEncodeTransformer.mjs

@@ -0,0 +1,14 @@
+import { ProtobufAssertEncodeProgrammer } from '@typia/core';
+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/features/protobuf/ProtobufCreateAssertEncodeTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtobufCreateAssertEncodeTransformer.mjs","sources":["../../../src/features/protobuf/ProtobufCreateAssertEncodeTransformer.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAKM,IAAW;AAAjB,CAAA,UAAiB,qCAAqC,EAAA;IACvC,qCAAA,CAAA,SAAS,GAAG,CAAC,KAAsB,KAC9C,kBAAkB,CAAC,OAAO,CAAC;AACzB,QAAA,GAAG,KAAK;AACR,QAAA,MAAM,EAAE,6BAA6B;QACrC,KAAK,EAAE,8BAA8B,CAAC,KAAK;AAC5C,KAAA,CAAC;AACN,CAAC,EAPgB,qCAAqC,KAArC,qCAAqC,GAAA,EAAA,CAAA,CAAA;;;;"}

package/lib/features/protobuf/ProtobufCreateDecodeTransformer.d.ts

@@ -0,0 +1,4 @@
+import { ITransformProps } from "../../ITransformProps";
+export declare namespace ProtobufCreateDecodeTransformer {
+    const transform: (props: ITransformProps) => import("typescript").Expression | import("typescript").ArrowFunction;
+}

package/lib/features/protobuf/ProtobufCreateDecodeTransformer.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProtobufCreateDecodeTransformer = void 0;
+const core_1 = require("@typia/core");
+const GenericTransformer_1 = require("../../internal/GenericTransformer");
+var ProtobufCreateDecodeTransformer;
+(function (ProtobufCreateDecodeTransformer) {
+    ProtobufCreateDecodeTransformer.transform = (props) => GenericTransformer_1.GenericTransformer.factory(Object.assign(Object.assign({}, props), { method: "protobuf.createDecode", write: core_1.ProtobufDecodeProgrammer.write }));
+})(ProtobufCreateDecodeTransformer || (exports.ProtobufCreateDecodeTransformer = ProtobufCreateDecodeTransformer = {}));
+//# sourceMappingURL=ProtobufCreateDecodeTransformer.js.map

package/lib/features/protobuf/ProtobufCreateDecodeTransformer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtobufCreateDecodeTransformer.js","sourceRoot":"","sources":["../../../src/features/protobuf/ProtobufCreateDecodeTransformer.ts"],"names":[],"mappings":";;;AAAA,sCAAuD;AAGvD,0EAAuE;AAEvE,IAAiB,+BAA+B,CAO/C;AAPD,WAAiB,+BAA+B;IACjC,yCAAS,GAAG,CAAC,KAAsB,EAAE,EAAE,CAClD,uCAAkB,CAAC,OAAO,iCACrB,KAAK,KACR,MAAM,EAAE,uBAAuB,EAC/B,KAAK,EAAE,+BAAwB,CAAC,KAAK,IACrC,CAAC;AACP,CAAC,EAPgB,+BAA+B,+CAA/B,+BAA+B,QAO/C"}