zod-to-x 1.4.8-dev.4 → 1.5.0-dev.2

package/README.md

@@ -27,9 +27,10 @@
 - [Intersections and Unions](#intersections-and-unions)
   - [Expected outputs](#expected-outputs)
   - [Tips for discriminated unions](#tips-for-discriminated-unions)
-- [Layered modeling](#layered-modeling) <sup>*(new)*</sup>
+- [Layered modeling](#layered-modeling)
   - [Usage example](#usage-example)
   - [Custom layers](#custom-layers)
+  - [Generic types](#generic-types) <sup>*(new)*</sup>
 - [Currently supported output languages](#currently-supported-output-languages)
   - [Typescript](#1-typescript)
   - [C++](#2-c)
@@ -502,6 +503,106 @@ class MyEntityModels extends Zod2XModel {
 }
 ```
 
+### Generic types
+Since `v1.5.0`, basic generic types can be generated using layered modeling. A few key points should be kept in mind when working with them:
+1) Generic types can only be created for `ZodObject` properties. The new `createGenericType` method should be used to indicate the generic property.
+```ts
+@Infrastructure({
+  namespace: "GENERICS_INFRA",
+  file: "layered_generics.infra",
+})
+class GenericsInfrastructure extends Zod2XModel {
+  readonly HttpSuccessfulResponse = z.object({
+    success: z.literal(true),
+    data: createGenericType("T"),
+  });
+
+  readonly HttpUnsuccessfulResponse = z.object({
+    success: z.literal(false),
+    message: z.string(),
+    details: z.record(z.any()).optional(),
+  });
+}
+// Output:
+// export interface HttpSuccessfulResponse<T> {
+//   success: true;
+//   data: T;
+// }
+//
+// export interface HttpUnsuccessfulResponse {
+//   success: false;
+//   message: string;
+//   details?: Record<string, any>;
+// }
+```
+2) To create a type based on a generic type definition, the `useGenericType` method should be used to indicate the parent generic type and the value that the generic will take, which should be a previously defined type.
+```ts
+// inside GenericsInfrastructure class
+readonly SomeDtoResult = z.object({
+  id: z.string(),
+  name: z.string(),
+  age: z.number().int().nonnegative(),
+});
+
+readonly ResponseItem = useGenericType(this.HttpSuccessfulResponse, {
+  data: this.SomeDtoResult, // Indicate the generic property and the value it takes
+  // ... other generic properties, if exist.
+});
+
+// Output:
+// export interface SomeDtoResult {
+//   id: string;
+//   name: string;
+//   age: number;
+// }
+//
+// export interface ResponseItem extends HttpSuccessfulResponse<SomeDtoResult> {}
+
+```
+3) New types based on generics, due to how TypeScript and Decorators work, should be used with Zod's `z.lazy()` operator. This is **required** to ensure metadata existence. It is applied to the used type, **except when dealing with `ZodIntersect`, `ZodUnion` or `ZodDiscriminatedUnion`**, where it should be applied to these methods instead of the type. Additionally, they support only inline generics usage:
+```ts
+// inside GenericsInfrastructure class
+readonly ObjectWithGeneric = z.object({
+  // Property with reference to a generic based type: requires lazy operator
+  directGenericUse: z.lazy(() => this.ResponseItem),
+
+  // Property with inline generic usage: `useGenericType` is lazy by default
+  indirectGenericUse: useGenericType(this.HttpSuccessfulResponse, {
+    data: this.SomeDtoResult
+  }),
+});
+
+// Case of ZodUnion, ZodDiscriminatedUnion or ZodIntersection.
+readonly DiscriminantDataRetrieve = z.lazy(() =>  // Lazy the zod type itself
+  z.discriminatedUnion(
+    "success",
+    [
+      // Inline generic usage
+      useGenericType(
+        this.HttpSuccessfulResponse,
+        { data: this.SomeDtoResult },
+        true  // Disable default lazy wrapper
+      ),
+
+      // Non generic types: normal references
+      this.HttpUnsuccessfulResponse,
+    ]
+  )
+);
+
+// Output
+// export interface ObjectWithGeneric {
+//   directGenericUse: ResponseItem;
+//   indirectGenericUse: HttpSuccessfulResponse<SomeDtoResult>;
+// }
+//
+// export type DiscriminantDataRetrieve =
+//   | HttpSuccessfulResponse<SomeDtoResult>
+//   | HttpUnsuccessfulResponse;
+```
+
+Complete definition examples can be found [here](https://github.com/rroumenov/zod-to-x/blob/main/test/common/layered_generics.ts).
+
 ## Currently supported output languages
 Common options:
 - **header**: Text to add as a comment at the beginning of the output.
@@ -645,7 +746,7 @@ class UserDtos extends Zod2XModel {
     createUserUseCaseResultDtoV2 = this.createUserUseCaseResultDto;
 
     // OK, but avoid it - Redeclaration of an alias. It will wait until
-    // "createUserUseCaseResultDto" is aliased and then will becosa an alias
+    // "createUserUseCaseResultDto" is aliased and then will become an alias
     // of "createUserUseCaseResultDto"
     createUserUseCaseResultDtoV3 = z.lazy(() => this.createUserUseCaseResultDto),
 }

package/dist/converters/protobuf_v3/options.d.ts

@@ -15,5 +15,10 @@ export interface IZod2ProtoV3Opt extends IZodToXOpt {
      * output will be more compact. Default is false.
      */
     encodeDoubleAsInt?: boolean;
+    /**
+     * ProtoV3 fields are optional by default, but this setting makes the "optional" keyword
+     * explicit improving compatibility with ProtoV2. Default is false.
+     */
+    useExplicitOptional?: boolean;
 }
 export declare const defaultOpts: IZod2ProtoV3Opt;

package/dist/converters/protobuf_v3/options.js

@@ -6,5 +6,6 @@ exports.defaultOpts = {
     indent: 4,
     keepKeys: false,
     encodeDoubleAsInt: false,
+    useExplicitOptional: false,
     useImports: false, // Not required for protobuf files
 };

package/dist/converters/protobuf_v3/runner.d.ts

@@ -17,4 +17,4 @@ import { IZod2ProtoV3Opt } from "./options";
  *                              definition.
  * @returns The Protocol Buffers v3 definition as a string.
  */
-export declare function zod2ProtoV3(schema: ZodObject<any> | ZodDiscriminatedUnion<string, ZodObject<any>[]> | ZodUnion<[ZodObject<any>, ...ZodObject<any>[]]>, opt?: Pick<IZod2AstOpt, "strict"> & Pick<IZod2ProtoV3Opt, "packageName" | "keepKeys" | "header" | "indent" | "includeComments" | "encodeDoubleAsInt">): string;
+export declare function zod2ProtoV3(schema: ZodObject<any> | ZodDiscriminatedUnion<string, ZodObject<any>[]> | ZodUnion<[ZodObject<any>, ...ZodObject<any>[]]>, opt?: Pick<IZod2AstOpt, "strict"> & Pick<IZod2ProtoV3Opt, "packageName" | "keepKeys" | "header" | "indent" | "includeComments" | "encodeDoubleAsInt" | "useExplicitOptional">): string;

package/dist/converters/protobuf_v3/runner.js

@@ -26,11 +26,11 @@ const allowedKeyTypes = [
 class Zod2ProtoV3 extends core_1.Zod2X {
     constructor(opt = {}) {
         super(Object.assign(Object.assign({}, options_1.defaultOpts), opt));
+        this.commentKey = "//";
         this.getUnionType = () => {
             /** Covered by "transpileUnion" method */
             return "";
         };
-        this.getComment = (data, indent = "") => `${indent}// ${data}`;
         this.getBooleanType = () => "bool";
         this.getStringType = () => "string";
         this.getNumberType = (isInt, range) => {
@@ -101,6 +101,10 @@ class Zod2ProtoV3 extends core_1.Zod2X {
         // Zod2ProtoV3 does not support layered modeling.
         return "";
     }
+    getGenericTemplatesTranslation(data) {
+        // Zod2ProtoV3 does not support layered modeling nor generics.
+        return "";
+    }
     addExtendedType(name, parentNamespace, aliasOf) {
         // Zod2ProtoV3 does not support layered modeling.
         return;
@@ -167,7 +171,10 @@ class Zod2ProtoV3 extends core_1.Zod2X {
                 // Avoid duplicated descriptions for transpiled items.
                 this.addComment(value.description, `\n${this.indent[1]}`);
             }
-            this.push1(`${this.getAttributeType(value)} ${this._adaptField(key)} = ${index + 1};`);
+            const fieldType = value.isOptional && this.opt.useExplicitOptional
+                ? `optional ${this.getAttributeType(value)}`
+                : this.getAttributeType(value);
+            this.push1(`${fieldType} ${this._adaptField(key)} = ${index + 1};`);
         });
         this.push0("}\n");
     }

package/dist/core/ast-types/ast_common.d.ts

@@ -32,14 +32,19 @@ export type ASTAliasedTypes = Simple.ASTString | Simple.ASTNumber | Simple.ASTBo
 /**
  * Represents a usage of any existing ASTNode. Used to reduce node size.
  */
-export declare class ASTDefintion extends ASTCommon {
+export declare class ASTDefinition extends ASTCommon {
     name: string;
     instanceType: string;
     constraints?: Record<string, any>;
-    constructor(data: ASTDefintion & ASTCommon);
+    templatesTranslation: Pick<ASTCommon, "parentFile" | "parentNamespace" | "aliasOf">[];
+    constructor(data: ASTDefinition & ASTCommon);
 }
-export type ASTType = ASTNode | ASTDefintion;
+export type ASTType = ASTNode | ASTDefinition;
 export type ASTNodes = {
     nodes: Map<string, ASTNode>;
     warnings: string[];
 };
+export declare class ASTGenericType {
+    name: string;
+    constructor(name: string);
+}

package/dist/core/ast-types/ast_common.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ASTDefintion = exports.ASTCommon = void 0;
+exports.ASTGenericType = exports.ASTDefinition = exports.ASTCommon = void 0;
 /**
  * Shared properties for all AST node types.
  */
@@ -19,12 +19,19 @@ exports.ASTCommon = ASTCommon;
 /**
  * Represents a usage of any existing ASTNode. Used to reduce node size.
  */
-class ASTDefintion extends ASTCommon {
+class ASTDefinition extends ASTCommon {
     constructor(data) {
         super(data);
         this.name = data.name;
         this.instanceType = data.instanceType;
         this.constraints = data.constraints;
+        this.templatesTranslation = data.templatesTranslation;
     }
 }
-exports.ASTDefintion = ASTDefintion;
+exports.ASTDefinition = ASTDefinition;
+class ASTGenericType {
+    constructor(name) {
+        this.name = name;
+    }
+}
+exports.ASTGenericType = ASTGenericType;

package/dist/core/ast-types/ast_complex.d.ts

@@ -17,6 +17,8 @@ export declare class ASTEnum extends ASTCommon {
 export declare class ASTObject extends ASTCommon {
     name: string;
     properties: Record<string, ASTType>;
+    templates: Set<string>;
+    templatesTranslation: Pick<ASTCommon, "parentFile" | "parentNamespace" | "aliasOf">[];
     constructor(data: ASTObject & ASTCommon);
 }
 /**

package/dist/core/ast-types/ast_complex.js

@@ -22,6 +22,8 @@ class ASTObject extends ast_common_1.ASTCommon {
         super(data);
         this.name = data.name;
         this.properties = data.properties;
+        this.templates = data.templates;
+        this.templatesTranslation = data.templatesTranslation;
     }
 }
 exports.ASTObject = ASTObject;

package/dist/core/ast-types/ast_simple.d.ts

@@ -1,4 +1,4 @@
-import { ASTCommon, ASTDefintion } from "./ast_common";
+import { ASTCommon, ASTDefinition } from "./ast_common";
 /**
  * Handle ZodString
  */
@@ -28,8 +28,8 @@ export declare class ASTNumber extends ASTCommon {
  */
 export declare class ASTLiteral extends ASTCommon {
     name?: string;
-    value: any;
-    parentEnum?: ASTDefintion;
+    value: string | number | boolean;
+    parentEnum?: ASTDefinition;
     parentEnumKey?: string;
     constructor(data: ASTLiteral & ASTCommon);
 }

package/dist/core/ast_node.js

@@ -39,14 +39,30 @@ class Zod2Ast {
      * @returns
      */
     _getTranspilerableFile(itemName, metadata) {
-        var _a;
+        var _a, _b;
         let layer;
         if (this.opt.layer !== undefined && (metadata === null || metadata === void 0 ? void 0 : metadata.layer) !== undefined) {
+            if (Array.isArray(metadata.genericTypes)) {
+                // Check that all templates used with a generic type follows the layering rules
+                if (metadata.genericTypes.some((i) => this.opt.layer.index < i.layer.index)) {
+                    throw new errors_1.BadLayerDefinitionError(`${itemName}: Layer with number ${this.opt.layer.index} can only use models` +
+                        `from the same or lower layer. Review templates used for generic ` +
+                        `type ${metadata.typeName}.`);
+                }
+            }
+            const templatesTranslation = (_a = metadata === null || metadata === void 0 ? void 0 : metadata.genericTypes) === null || _a === void 0 ? void 0 : _a.map((i) => {
+                var _a, _b;
+                return ({
+                    parentFile: ((_a = this.opt.layer) === null || _a === void 0 ? void 0 : _a.file) !== i.layer.file ? i.layer.file : undefined,
+                    parentNamespace: ((_b = this.opt.layer) === null || _b === void 0 ? void 0 : _b.file) !== i.layer.file ? i.layer.namespace : undefined,
+                    aliasOf: i.typeName,
+                });
+            });
             if (metadata.layer.file === this.opt.layer.file) {
                 // Case 1: Only layer exists and belongs to the same file
                 // Case 2: Layer (belongs to same file) and parentLayer exist
                 // Behaviour: New type is created extending the parent layer (if any)
-                layer = (_a = metadata.parentLayer) !== null && _a !== void 0 ? _a : metadata.layer;
+                layer = (_b = metadata.parentLayer) !== null && _b !== void 0 ? _b : metadata.layer;
                 if (this.opt.layer.index < layer.index) {
                     throw new errors_1.BadLayerDefinitionError(`${itemName}: Layer with number ${this.opt.layer.index} can only use models` +
                         `from the same or lower layer. Found layer with number ${layer.index}`);
@@ -56,11 +72,15 @@ class Zod2Ast {
                         parentFile: layer.file,
                         parentNamespace: layer.namespace,
                         aliasOf: metadata === null || metadata === void 0 ? void 0 : metadata.aliasOf,
+                        templatesTranslation,
+                        isGenericChild: metadata === null || metadata === void 0 ? void 0 : metadata.isGenericChild,
                     };
                 }
                 else {
                     return {
                         aliasOf: metadata === null || metadata === void 0 ? void 0 : metadata.aliasOf,
+                        templatesTranslation,
+                        isGenericChild: metadata === null || metadata === void 0 ? void 0 : metadata.isGenericChild,
                     };
                 }
             }
@@ -77,6 +97,8 @@ class Zod2Ast {
                     parentFile: layer.file,
                     parentNamespace: layer.namespace,
                     aliasOf: undefined,
+                    templatesTranslation,
+                    isGenericChild: metadata === null || metadata === void 0 ? void 0 : metadata.isGenericChild,
                 };
             }
         }
@@ -88,13 +110,14 @@ class Zod2Ast {
      * @param constraints - Constraints to be added to the definition
      * @returns
      */
-    _createDefinition(node, constraints = {}) {
-        return new core_1.ASTDefintion({
+    _createDefinition(node, constraints = {}, templatesTranslation = []) {
+        return new core_1.ASTDefinition({
             name: node.name,
             instanceType: node.constructor.name,
             parentFile: node.parentFile,
             parentNamespace: node.parentNamespace,
             aliasOf: node.aliasOf,
+            templatesTranslation,
             constraints: "constraints" in node
                 ? Object.assign(Object.assign({}, node.constraints), constraints) : constraints,
         });
@@ -263,13 +286,24 @@ class Zod2Ast {
      * @returns The AST definition for the provided Zod object schema.
      */
     _getObjectAst(schema, opt) {
-        const { name, parentFile, parentNamespace, aliasOf } = this._getNames(schema);
+        const { name, parentFile, parentNamespace, aliasOf, templatesTranslation, isGenericChild } = this._getNames(schema);
         let discriminantValue = undefined;
         const shape = schema._def.shape();
         if (!this.nodes.has(name)) {
             const properties = {};
+            const templates = new Set();
             for (const key in shape) {
-                properties[key] = this._zodToAST(shape[key]);
+                if (zod_helpers_1.ZodHelpers.isZodPromise(shape[key]) && zod_helpers_1.ZodHelpers.isZod2XGeneric(shape[key])) {
+                    const templateKey = shape[key]._def.type.value;
+                    properties[key] = new core_1.ASTGenericType(templateKey);
+                    if (templates.has(templateKey)) {
+                        throw new errors_1.AstTypeNameDefinitionError(`Duplicate template key found for model ${name}: ${templateKey}`);
+                    }
+                    templates.add(templateKey);
+                }
+                else {
+                    properties[key] = this._zodToAST(shape[key]);
+                }
             }
             if (opt === null || opt === void 0 ? void 0 : opt.skipLayerClass) {
                 return {}; // Layer classes are not transpilerable
@@ -281,6 +315,8 @@ class Zod2Ast {
                 parentFile,
                 parentNamespace,
                 aliasOf,
+                templates,
+                templatesTranslation: templatesTranslation || [],
             }));
         }
         const item = this.nodes.get(name);
@@ -297,7 +333,7 @@ class Zod2Ast {
                 }
             }
         }
-        return this._createDefinition(this.nodes.get(name), { discriminantValue });
+        return this._createDefinition(this.nodes.get(name), { discriminantValue }, isGenericChild ? undefined : templatesTranslation);
     }
     /**
      * Generates an Abstract Syntax Tree (AST) definition for a Zod union schema.
@@ -341,12 +377,17 @@ class Zod2Ast {
                 this.warnings.push(`[affected type: ${name}] Using ZodUnion is a bad data modeling practice. ` +
                     "Use ZodDiscriminatedUnion instead, or disable strict mode if not possible.");
             }
+            const unifiedProperties = this._unionAstNodes(item.options);
             item.newObject = new core_1.ASTObject({
                 name,
-                properties: this._unionAstNodes(item.options).properties,
+                properties: unifiedProperties.properties,
                 description: (schema.description ? `${schema.description} - ` : "") +
                     `Built from union of ` +
                     `${item.options.map((i) => i.name).join(", ")}`,
+                templates: new Set(Object.values(unifiedProperties.properties)
+                    .filter((i) => i instanceof core_1.ASTGenericType)
+                    .map((i) => i.name)),
+                templatesTranslation: [],
             });
         }
         if (name && !this.nodes.has(name)) {
@@ -382,13 +423,18 @@ class Zod2Ast {
             }
         }
         else {
+            const intersectedProperties = this._intersectAstNodes(item.left, item.right);
             item.newObject = new core_1.ASTObject({
                 name,
-                properties: this._intersectAstNodes(item.left, item.right).properties,
+                properties: intersectedProperties.properties,
                 description: (schema.description ? `${schema.description} - ` : "") +
                     `Built from intersection of ` +
                     `${item.left.name} and ` +
                     `${item.right.name}`,
+                templates: new Set(Object.values(intersectedProperties.properties)
+                    .filter((i) => i instanceof core_1.ASTGenericType)
+                    .map((i) => i.name)),
+                templatesTranslation: [],
             });
         }
         if (name && !this.nodes.has(name)) {

package/dist/core/transpiler.d.ts

@@ -35,6 +35,7 @@ export declare abstract class Zod2X<T extends IZodToXOpt> {
     protected preImports: Set<string>;
     protected imports: Set<string>;
     protected postImports: Set<string>;
+    protected abstract readonly commentKey: string;
     protected opt: Partial<T>;
     protected constructor(opt: Partial<T>);
     /**
@@ -55,6 +56,10 @@ export declare abstract class Zod2X<T extends IZodToXOpt> {
      * @param typeName
      */
     protected abstract getTypeFromExternalNamespace(namespace: string, typeName: string): string;
+    /**
+     * Returns the translation of generic templates for a given AST node.
+     */
+    protected abstract getGenericTemplatesTranslation(data: ASTNode): string | undefined;
     /**
      * For Layered Modeling.
      * If a property type is an imported type, without any modification, the transpiled type will be
@@ -64,10 +69,6 @@ export declare abstract class Zod2X<T extends IZodToXOpt> {
      * @param aliasOf
      */
     protected abstract addExtendedType(name: string, parentNamespace: string, aliasOf: string): void;
-    /**
-     * Returns a comment.
-     */
-    protected abstract getComment(data: string, indent?: string): string;
     /**
      * Returns the keyword representing a string type in the target language.
      */
@@ -90,7 +91,7 @@ export declare abstract class Zod2X<T extends IZodToXOpt> {
      * @param value - The literal value to represent.
      * @param parentEnumNameKey - Optional tuple containing the parent enum name and key reference.
      */
-    protected abstract getLiteralStringType(value: string | number, parentEnumNameKey?: [string, string]): string | number;
+    protected abstract getLiteralStringType(value: string | number | boolean, parentEnumNameKey?: [string, string]): string | number;
     /**
      * Returns the keyword representing a generic 'any' type in the target language.
      */
@@ -170,6 +171,10 @@ export declare abstract class Zod2X<T extends IZodToXOpt> {
      * @param data - The AST node representing the aliased type.
      */
     protected abstract transpileAliasedType(data: ASTAliasedTypes): void;
+    /**
+     * Returns a comment.
+     */
+    protected getComment: (data: string, indent?: string) => string;
     /**
      * Determines if the given type token can be transpiled into the target language.
      * @param token - The type token to check.

package/dist/core/transpiler.js

@@ -13,6 +13,15 @@ const string_utils_1 = __importDefault(require("../utils/string_utils"));
  */
 class Zod2X {
     constructor(opt) {
+        /**
+         * Returns a comment.
+         */
+        this.getComment = (data, indent = "") => {
+            return data
+                .split("\n")
+                .map((line) => `${indent}${this.commentKey} ${line}`)
+                .join("\n");
+        };
         // Push with indentation helpers
         this.push0 = (data) => this.output.push(`${this.indent[0]}${data}`);
         this.push1 = (data) => this.output.push(`${this.indent[1]}${data}`);
@@ -71,7 +80,8 @@ class Zod2X {
     getAttributeType(token) {
         var _a, _b, _c;
         let varType = "";
-        if (token instanceof core_1.ASTDefintion) {
+        if (token instanceof core_1.ASTDefinition) {
+            const template = this.getGenericTemplatesTranslation(token) || "";
             if (this.opt.useImports === true && token.parentNamespace) {
                 this.addExternalTypeImport({
                     parentNamespace: token.parentNamespace,
@@ -87,6 +97,7 @@ class Zod2X {
             else {
                 varType = token.name;
             }
+            varType += template;
         }
         else if (this.isTranspilerable(token)) {
             varType = token.name;
@@ -131,6 +142,9 @@ class Zod2X {
                 varType = this.getRecordType(key, value);
             }
         }
+        else if (token instanceof core_1.ASTGenericType) {
+            varType = token.name;
+        }
         else {
             console.log("  # Unknown attribute equivalent for ---> ", token.constructor.name);
         }
@@ -203,7 +217,7 @@ class Zod2X {
     _getHeader() {
         const header = [];
         if (this.opt.header) {
-            header.push(...this.opt.header.split("\n").map((i) => this.getComment(i)));
+            header.push(this.getComment(this.opt.header));
             header.push("");
         }
         if (this.preImports.size > 0) {

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export { extendZod, IZod2xLayerMetadata } from "./lib/zod_ext";
+export { createGenericType, useGenericType } from "./lib/zod_helpers";
 export * as Zod2XTypes from "./core/ast-types";
 export { Zod2Ast } from "./core/ast_node";
 export { Zod2X } from "./core/transpiler";

package/dist/index.js

@@ -36,10 +36,13 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Zod2XConverters = exports.Zod2XTranspilers = exports.Zod2X = exports.Zod2Ast = exports.Zod2XTypes = exports.extendZod = void 0;
+exports.Zod2XConverters = exports.Zod2XTranspilers = exports.Zod2X = exports.Zod2Ast = exports.Zod2XTypes = exports.useGenericType = exports.createGenericType = exports.extendZod = void 0;
 // Core
 var zod_ext_1 = require("./lib/zod_ext");
 Object.defineProperty(exports, "extendZod", { enumerable: true, get: function () { return zod_ext_1.extendZod; } });
+var zod_helpers_1 = require("./lib/zod_helpers");
+Object.defineProperty(exports, "createGenericType", { enumerable: true, get: function () { return zod_helpers_1.createGenericType; } });
+Object.defineProperty(exports, "useGenericType", { enumerable: true, get: function () { return zod_helpers_1.useGenericType; } });
 exports.Zod2XTypes = __importStar(require("./core/ast-types"));
 var ast_node_1 = require("./core/ast_node");
 Object.defineProperty(exports, "Zod2Ast", { enumerable: true, get: function () { return ast_node_1.Zod2Ast; } });

package/dist/layered-modeling/layer.js

@@ -98,16 +98,31 @@ function Layer(opt) {
                                 aliasOf: metadata.typeName,
                                 layer: opt,
                                 typeName: name,
+                                // Generics associated to parent, but related to current type.
+                                genericTypes: metadata.genericTypes,
+                                isGenericChild: true,
                             };
                         }
                         return zodItem;
                     };
+                    const lazyProperties = [];
                     Object.getOwnPropertyNames(this).forEach((prop) => {
                         const item = this[prop];
                         if (zod_helpers_1.ZodHelpers.isTranspilerableZodType(item) ||
                             zod_helpers_1.ZodHelpers.isTranspilerableAliasedZodType(item, opt.basicTypes === false)) {
                             this[prop] = setMetadata(case_1.default.pascal(prop), item, opt);
                         }
+                        else if (zod_helpers_1.ZodHelpers.isZodLazy(item)) {
+                            lazyProperties.push(prop);
+                        }
+                    });
+                    // Process lazy properties after initial pass to ensure proper metadata assignment.
+                    lazyProperties.forEach((i) => {
+                        const lazyItem = this[i]._def.getter();
+                        if (zod_helpers_1.ZodHelpers.isTranspilerableZodType(lazyItem) ||
+                            zod_helpers_1.ZodHelpers.isTranspilerableAliasedZodType(lazyItem, opt.basicTypes === false)) {
+                            this[i] = setMetadata(case_1.default.pascal(i), lazyItem, opt);
+                        }
                     });
                 }
             },

package/dist/lib/zod_ext.d.ts

@@ -88,6 +88,22 @@ export interface IZod2xMetadata {
      */
     aliasOf?: string;
     parentLayer?: IZod2xLayerMetadata;
+    /**
+     * For Layered Modeling defining generics.
+     * When a generic type is used with `useGenericType`, it stores the templates translation for
+     * the associated key.
+     */
+    genericTypes?: {
+        typeName: string;
+        layer: IZod2xLayerMetadata;
+    }[];
+    /**
+     * For Layered Modeling defining generics.
+     * Indicates when useGenericType was used to create a definition (set to true during Layer
+     * decorator) or if it is used inline as part of another definition (set to false).
+     * Defaults to false.
+     */
+    isGenericChild?: boolean;
 }
 declare module "zod" {
     interface ZodType {

package/dist/lib/zod_helpers.d.ts

@@ -34,6 +34,7 @@ export declare class ZodHelpers {
     static isZodOptional(i: ZodTypeAny): i is z.ZodOptional<any>;
     static isZodNullable(i: ZodTypeAny): i is z.ZodNullable<any>;
     static isZodDefault(i: ZodTypeAny): i is z.ZodDefault<any>;
+    static isZodPromise(i: ZodTypeAny): i is z.ZodPromise<any>;
     static isZodAnyUnionType(i: ZodTypeAny): i is z.ZodUnion<any> | z.ZodDiscriminatedUnion<any, any>;
     static isZodAnyEnumType(i: ZodTypeAny): i is z.ZodEnum<any> | z.ZodNativeEnum<any>;
     static isZodAnyNumberType(i: ZodTypeAny): i is z.ZodNumber | z.ZodBigInt;
@@ -53,7 +54,23 @@ export declare class ZodHelpers {
      * @returns
      */
     static isTranspilerableAliasedZodType(zodType: string | ZodTypeAny, onlyArray?: boolean): boolean;
+    /**
+     * Zod2X generics are represented as Promise<"TypeName">.
+     * Ex: z.promise(z.literal("K")) will be transpiled to Template<K>
+     */
+    static isZod2XGeneric(i: ZodTypeAny): boolean;
     static cloneZod(i: ZodTypeAny): any;
     static createZodObject(properties: Map<string, ZodTypeAny>): ZodObject<any>;
     static getZodNumberConstraints(i: ZodNumber | z.ZodBigInt): ZodNumberConstraints;
 }
+export declare function createGenericType(name: string): any;
+/**
+ * Use generic types defined in a generic ZodObject by replacing them with the actual child types.
+ * It preserves the zod2x metadata including the genericTypes array which will be moved to the
+ * new type during layer modeling metadata assignment.
+ * @param genObj ZodObject with generic types.
+ * @param childrens Record of child types to replace generics.
+ * @returns The extended ZodObject with replaced generic types.
+ */
+export declare function useGenericType(genObj: ZodObject<any>, childrens: Record<string, ZodTypeAny>, skipLazy: true): ZodObject<any>;
+export declare function useGenericType(genObj: ZodObject<any>, childrens: Record<string, ZodTypeAny>, skipLazy?: false): z.ZodLazy<ZodObject<any>>;

package/dist/lib/zod_helpers.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZodHelpers = void 0;
+exports.createGenericType = createGenericType;
+exports.useGenericType = useGenericType;
 const zod_1 = require("zod");
 const zod_ext_1 = require("./zod_ext");
 /**
@@ -100,6 +102,10 @@ class ZodHelpers {
         var _a;
         return ((_a = i === null || i === void 0 ? void 0 : i._def) === null || _a === void 0 ? void 0 : _a.typeName) === zod_1.ZodFirstPartyTypeKind.ZodDefault;
     }
+    static isZodPromise(i) {
+        var _a;
+        return ((_a = i === null || i === void 0 ? void 0 : i._def) === null || _a === void 0 ? void 0 : _a.typeName) === zod_1.ZodFirstPartyTypeKind.ZodPromise;
+    }
     static isZodAnyUnionType(i) {
         return this.isZodUnion(i) || this.isZodDiscriminatedUnion(i);
     }
@@ -153,6 +159,15 @@ class ZodHelpers {
             type === zod_1.ZodFirstPartyTypeKind.ZodTuple ||
             type === zod_1.ZodFirstPartyTypeKind.ZodArray);
     }
+    /**
+     * Zod2X generics are represented as Promise<"TypeName">.
+     * Ex: z.promise(z.literal("K")) will be transpiled to Template<K>
+     */
+    static isZod2XGeneric(i) {
+        return (this.isZodPromise(i) &&
+            this.isZodLiteral(i._def.type) &&
+            typeof i._def.type._def.value === "string");
+    }
     static cloneZod(i) {
         const zodType = i._def.typeName;
         return new (zod_ext_1.Extended.getZ()[zodType])(Object.assign({}, i._def));
@@ -179,3 +194,34 @@ class ZodHelpers {
     }
 }
 exports.ZodHelpers = ZodHelpers;
+function createGenericType(name) {
+    return zod_ext_1.Extended.getZ().promise(zod_ext_1.Extended.getZ().literal(name));
+}
+function useGenericType(genObj, childrens, skipLazy) {
+    const builder = () => {
+        let extended = genObj;
+        for (const [key, property] of Object.entries(genObj.shape)) {
+            if (ZodHelpers.isZod2XGeneric(property)) {
+                const childType = childrens[key];
+                if (!childType) {
+                    throw new Error(`Missing child type for generic property ${key} in ${genObj._zod2x.typeName}.`);
+                }
+                const zod2xMeta = structuredClone(extended._zod2x);
+                extended = extended.extend({ [key]: childType });
+                extended._zod2x = zod2xMeta;
+                extended._zod2x.isGenericChild = false;
+                if (!Array.isArray(extended._zod2x.genericTypes)) {
+                    extended._zod2x.genericTypes = [];
+                }
+                if (childType._zod2x !== undefined) {
+                    extended._zod2x.genericTypes.push({
+                        typeName: childType._zod2x.typeName,
+                        layer: childType._zod2x.layer,
+                    });
+                }
+            }
+        }
+        return extended;
+    };
+    return skipLazy ? builder() : zod_1.z.lazy(builder);
+}

package/dist/transpilers/cpp/runner.d.ts

@@ -4,6 +4,7 @@ import { IZod2CppOpt } from "./options";
  * @description Transpiler for Zod schemas to C++11 code.
  */
 export declare class Zod2Cpp extends Zod2X<IZod2CppOpt> {
+    protected readonly commentKey = "//";
     protected serializers: string[];
     protected useBoost: boolean;
     protected lib: {
@@ -26,10 +27,11 @@ export declare class Zod2Cpp extends Zod2X<IZod2CppOpt> {
     protected addExtendedType(name: string, parentNamespace: string, aliasOf: string, opt?: {
         type?: "union" | "alias";
         isInternal?: boolean;
+        templates?: string;
     }): void;
+    protected getGenericTemplatesTranslation(data: ASTNode): string | undefined;
     protected checkExtendedTypeInclusion(data: ASTNode, type?: "union" | "alias"): boolean;
     protected runAfter(): void;
-    protected getComment: (data: string, indent?: string) => string;
     protected getDateType: () => string;
     protected getBooleanType: () => string;
     protected getStringType: () => string;
@@ -53,11 +55,13 @@ export declare class Zod2Cpp extends Zod2X<IZod2CppOpt> {
     }) => string;
     /** Ex: std::vector<std::vector<TypeA>> */
     protected getArrayType(arrayType: string, arrayDeep: number): string;
-    protected getLiteralStringType(value: string | number, parentEnumNameKey?: [string, string]): string;
+    protected getLiteralStringType(value: string | number | boolean, parentEnumNameKey?: [string, string]): string;
     /** Ex: std::unordered_map<TypeA> */
     protected getMapType(keyType: string, valueType: string): string;
     protected getRecordType(keyType: string, valueType: string): string;
     protected _getOptional(type: string): string;
+    protected _addExtendedTypeSerializer(typeName: string, parentNamespace: string): void;
+    protected _addExtendedTypeDeserializer(typeName: string, parentNamespace: string): void;
     protected transpileAliasedType(data: ASTAliasedTypes): void;
     /** Ex:
      *  enum class EnumA: int {
@@ -83,6 +87,7 @@ export declare class Zod2Cpp extends Zod2X<IZod2CppOpt> {
     /** Ex: using TypeC = boost::variant<TypeA, TypeB> */
     protected transpileUnion(data: ASTUnion): void;
     protected transpileStruct(data: ASTObject): void;
+    private _getTemplates;
     /** Ex:
      *  struct MyStruct {
      *      TypeA attribute1;
@@ -139,6 +144,7 @@ export declare class Zod2Cpp extends Zod2X<IZod2CppOpt> {
      *      }
      * @param parent - Name of the serialized structure
      * @param childs - Structure attributes data.
+     * @param templates - Generic templates string (if any)
      */
     private _createStructSerializer;
     /**
@@ -151,6 +157,7 @@ export declare class Zod2Cpp extends Zod2X<IZod2CppOpt> {
      *      }
      * @param parent - Name of the deserialized structure
      * @param childs - Structure attributes data.
+     * @param templates - Generic templates string (if any)
      */
     private _createStructDeserializer;
     /**
@@ -166,6 +173,7 @@ export declare class Zod2Cpp extends Zod2X<IZod2CppOpt> {
      *      }
      * @param parent - Name of the serialized structure
      * @param childs - Structure attributes data.
+     * @param templates - Generic templates string (if any)
      */
     private _createClassSerializer;
     /**
@@ -178,6 +186,7 @@ export declare class Zod2Cpp extends Zod2X<IZod2CppOpt> {
      *      }
      * @param parent - Name of the deserialized structure
      * @param childs - Structure attributes data.
+     * @param templates - Generic templates string (if any)
      */
     private _createClassDeserializer;
     /**

package/dist/transpilers/cpp/runner.js

@@ -16,11 +16,11 @@ const options_1 = require("./options");
 class Zod2Cpp extends core_1.Zod2X {
     constructor(opt = {}) {
         super(Object.assign(Object.assign({}, options_1.defaultOpts), opt));
+        this.commentKey = "//";
         this.getIntersectionType = () => {
             /** Covered by "transpileIntersection" method */
             return "";
         };
-        this.getComment = (data, indent = "") => `${indent}// ${data}`;
         this.getDateType = () => this.getStringType(); // Representing ISO date as a string
         this.getBooleanType = () => "bool";
         this.getStringType = () => {
@@ -95,26 +95,51 @@ class Zod2Cpp extends core_1.Zod2X {
         return `${namespace}::${typeName}`;
     }
     addExtendedType(name, parentNamespace, aliasOf, opt) {
+        var _a;
         const extendedType = (opt === null || opt === void 0 ? void 0 : opt.isInternal)
             ? aliasOf
             : this.getTypeFromExternalNamespace(parentNamespace, aliasOf);
+        const templates = (_a = opt === null || opt === void 0 ? void 0 : opt.templates) !== null && _a !== void 0 ? _a : "";
         if ((opt === null || opt === void 0 ? void 0 : opt.type) === "union" || (opt === null || opt === void 0 ? void 0 : opt.type) === "alias") {
-            this.push0(`using ${name} = ${extendedType};\n`);
+            this.push0(`using ${name} = ${extendedType}${templates};\n`);
         }
         else {
             if (this.opt.outType === "class") {
-                this.push0(`class ${name} : public ${extendedType} {};\n`);
+                this.push0(`class ${name} : public ${extendedType}${templates} {};\n`);
             }
             else {
-                this.push0(`struct ${name} : public ${extendedType} {};\n`);
+                this.push0(`struct ${name} : public ${extendedType}${templates} {};\n`);
             }
         }
+        if ((opt === null || opt === void 0 ? void 0 : opt.type) !== "alias" && parentNamespace !== undefined) {
+            this._addExtendedTypeSerializer(name, parentNamespace);
+            this._addExtendedTypeDeserializer(name, parentNamespace);
+        }
+    }
+    getGenericTemplatesTranslation(data) {
+        if ((data instanceof core_1.ASTObject || data instanceof core_1.ASTDefinition) &&
+            data.templatesTranslation.length > 0) {
+            return ("<" +
+                data.templatesTranslation
+                    .map((t) => {
+                    if (this.isExternalTypeImport(t)) {
+                        this.addExternalTypeImport(t);
+                        return this.getTypeFromExternalNamespace(t.parentNamespace, t.aliasOf);
+                    }
+                    else {
+                        return t.aliasOf;
+                    }
+                })
+                    .join(", ") +
+                ">");
+        }
     }
     checkExtendedTypeInclusion(data, type) {
         if (this.isExternalTypeImport(data)) {
             if (data.aliasOf) {
                 this.addExtendedType(data.name, data.parentNamespace, data.aliasOf, {
                     type,
+                    templates: this.getGenericTemplatesTranslation(data),
                 });
                 this.addExternalTypeImport(data);
             }
@@ -124,6 +149,7 @@ class Zod2Cpp extends core_1.Zod2X {
             this.addExtendedType(data.name, data.parentNamespace, data.aliasOf, {
                 type,
                 isInternal: true,
+                templates: this.getGenericTemplatesTranslation(data),
             });
             return true;
         }
@@ -158,12 +184,14 @@ class Zod2Cpp extends core_1.Zod2X {
     }
     getLiteralStringType(value, parentEnumNameKey) {
         var _a;
-        return ((_a = parentEnumNameKey === null || parentEnumNameKey === void 0 ? void 0 : parentEnumNameKey[0]) !== null && _a !== void 0 ? _a : (isNaN(Number(value))
-            ? this.getStringType()
-            : this.getNumberType(Number.isInteger(value), {
-                min: value,
-                max: value,
-            })));
+        return ((_a = parentEnumNameKey === null || parentEnumNameKey === void 0 ? void 0 : parentEnumNameKey[0]) !== null && _a !== void 0 ? _a : (typeof value === "boolean"
+            ? this.getBooleanType()
+            : isNaN(Number(value))
+                ? this.getStringType()
+                : this.getNumberType(Number.isInteger(value), {
+                    min: value,
+                    max: value,
+                })));
     }
     /** Ex: std::unordered_map<TypeA> */
     getMapType(keyType, valueType) {
@@ -177,6 +205,16 @@ class Zod2Cpp extends core_1.Zod2X {
         this.imports.add(this.lib.optional);
         return `boost::optional<${type}>`;
     }
+    _addExtendedTypeSerializer(typeName, parentNamespace) {
+        this._push0(this.serializers, `inline void to_json(${nlohmann_1.NLOHMANN}& j, const ${typeName}& x) {`);
+        this._push1(this.serializers, `${parentNamespace}::to_json(j, x);`);
+        this._push0(this.serializers, "}\n");
+    }
+    _addExtendedTypeDeserializer(typeName, parentNamespace) {
+        this._push0(this.serializers, `inline void from_json(const ${nlohmann_1.NLOHMANN}& j, ${typeName}& x) {`);
+        this._push1(this.serializers, `${parentNamespace}::from_json(j, x);`);
+        this._push0(this.serializers, "}\n");
+    }
     transpileAliasedType(data) {
         if (this.checkExtendedTypeInclusion(data, "alias")) {
             return;
@@ -269,6 +307,7 @@ class Zod2Cpp extends core_1.Zod2X {
             return {
                 type: this.getAttributeType(i),
                 discriminantValue: (_a = i.constraints) === null || _a === void 0 ? void 0 : _a.discriminantValue,
+                templates: this.getGenericTemplatesTranslation(i),
             };
         });
         const attributesTypes = attributesData.map((i) => i.type);
@@ -288,6 +327,14 @@ class Zod2Cpp extends core_1.Zod2X {
             this._transpileStructAsStruct(data);
         }
     }
+    _getTemplates(templates) {
+        return {
+            templateDefinition: templates.size > 0
+                ? `template<${[...templates].map((i) => "typename " + i).join(", ")}>`
+                : "",
+            templateList: templates.size > 0 ? `<${[...templates].join(", ")}>` : "",
+        };
+    }
     /** Ex:
      *  struct MyStruct {
      *      TypeA attribute1;
@@ -295,6 +342,10 @@ class Zod2Cpp extends core_1.Zod2X {
      *  }
      */
     _transpileStructAsStruct(data) {
+        const { templateDefinition } = this._getTemplates(data.templates);
+        if (templateDefinition) {
+            this.push0(templateDefinition);
+        }
         this.push0(`struct ${data.name} {`);
         const serializeData = [];
         Object.entries(data.properties).forEach(([key, value]) => {
@@ -308,8 +359,8 @@ class Zod2Cpp extends core_1.Zod2X {
             });
         });
         this.push0("};\n");
-        this._createStructSerializer(data.name, serializeData);
-        this._createStructDeserializer(data.name, serializeData);
+        this._createStructSerializer(data.name, serializeData, data.templates);
+        this._createStructDeserializer(data.name, serializeData, data.templates);
     }
     /** Ex:
      *  class MyClass {
@@ -328,6 +379,10 @@ class Zod2Cpp extends core_1.Zod2X {
      *  }
      */
     _transpileStructAsClass(data) {
+        const { templateDefinition } = this._getTemplates(data.templates);
+        if (templateDefinition) {
+            this.push0(templateDefinition);
+        }
         this.push0(`class ${data.name} {`);
         this.push0(`private:`);
         const setterGetter = [];
@@ -349,8 +404,8 @@ class Zod2Cpp extends core_1.Zod2X {
         this.push1(`virtual ~${data.name}() = default;`);
         setterGetter.forEach((i) => this.push1(i));
         this.push0("};\n");
-        this._createClassSerializer(data.name, serializeData);
-        this._createClassDeserializer(data.name, serializeData);
+        this._createClassSerializer(data.name, serializeData, data.templates);
+        this._createClassDeserializer(data.name, serializeData, data.templates);
     }
     /**
      * @description Transpiles an individual member of a C++ class based on the provided ASTNode.
@@ -414,10 +469,15 @@ class Zod2Cpp extends core_1.Zod2X {
      *      }
      * @param parent - Name of the serialized structure
      * @param childs - Structure attributes data.
+     * @param templates - Generic templates string (if any)
      */
-    _createStructSerializer(parent, childs) {
+    _createStructSerializer(parent, childs, templates) {
         const prefix = this.opt.namespace ? `${this.opt.namespace}::` : "";
-        this._push0(this.serializers, `inline void to_json(${nlohmann_1.NLOHMANN}& j, const ${parent}& x) {`);
+        const { templateDefinition, templateList } = this._getTemplates(templates);
+        if (templateDefinition) {
+            this._push0(this.serializers, templateDefinition);
+        }
+        this._push0(this.serializers, `inline void to_json(${nlohmann_1.NLOHMANN}& j, const ${parent}${templateList}& x) {`);
         childs.forEach((i) => {
             if (i.required) {
                 this._push1(this.serializers, `j["${i.origName}"] = x.${i.snakeName};`);
@@ -438,10 +498,15 @@ class Zod2Cpp extends core_1.Zod2X {
      *      }
      * @param parent - Name of the deserialized structure
      * @param childs - Structure attributes data.
+     * @param templates - Generic templates string (if any)
      */
-    _createStructDeserializer(parent, childs) {
+    _createStructDeserializer(parent, childs, templates) {
         const prefix = this.opt.namespace ? `${this.opt.namespace}::` : "";
-        this._push0(this.serializers, `inline void from_json(const ${nlohmann_1.NLOHMANN}& j, ${parent}& x) {`);
+        const { templateDefinition, templateList } = this._getTemplates(templates);
+        if (templateDefinition) {
+            this._push0(this.serializers, templateDefinition);
+        }
+        this._push0(this.serializers, `inline void from_json(const ${nlohmann_1.NLOHMANN}& j, ${parent}${templateList}& x) {`);
         childs.forEach((i) => {
             if (i.required) {
                 this._push1(this.serializers, `x.${i.snakeName} = j.at("${i.origName}").get<${i.typeName}>();`);
@@ -465,10 +530,15 @@ class Zod2Cpp extends core_1.Zod2X {
      *      }
      * @param parent - Name of the serialized structure
      * @param childs - Structure attributes data.
+     * @param templates - Generic templates string (if any)
      */
-    _createClassSerializer(parent, childs) {
+    _createClassSerializer(parent, childs, templates) {
         const prefix = this.opt.namespace ? `${this.opt.namespace}::` : "";
-        this._push0(this.serializers, `inline void to_json(${nlohmann_1.NLOHMANN}& j, const ${parent}& x) {`);
+        const { templateDefinition, templateList } = this._getTemplates(templates);
+        if (templateDefinition) {
+            this._push0(this.serializers, templateDefinition);
+        }
+        this._push0(this.serializers, `inline void to_json(${nlohmann_1.NLOHMANN}& j, const ${parent}${templateList}& x) {`);
         childs.forEach((i) => {
             if (i.required) {
                 this._push1(this.serializers, `j["${i.origName}"] = x.get_${i.snakeName}();`);
@@ -489,10 +559,15 @@ class Zod2Cpp extends core_1.Zod2X {
      *      }
      * @param parent - Name of the deserialized structure
      * @param childs - Structure attributes data.
+     * @param templates - Generic templates string (if any)
      */
-    _createClassDeserializer(parent, childs) {
+    _createClassDeserializer(parent, childs, templates) {
         const prefix = this.opt.namespace ? `${this.opt.namespace}::` : "";
-        this._push0(this.serializers, `inline void from_json(const ${nlohmann_1.NLOHMANN}& j, ${parent}& x) {`);
+        const { templateDefinition, templateList } = this._getTemplates(templates);
+        if (templateDefinition) {
+            this._push0(this.serializers, templateDefinition);
+        }
+        this._push0(this.serializers, `inline void from_json(const ${nlohmann_1.NLOHMANN}& j, ${parent}${templateList}& x) {`);
         childs.forEach((i) => {
             if (i.required) {
                 this._push1(this.serializers, `x.set_${i.snakeName}(j.at("${i.origName}").get<${i.typeName}>());`);

package/dist/transpilers/typescript/runner.d.ts

@@ -1,6 +1,7 @@
 import { ASTAliasedTypes, ASTEnum, ASTIntersection, ASTNode, ASTObject, ASTUnion, Zod2X } from "../../core";
 import { IZod2TsOpt } from "./options";
 export declare class Zod2Ts extends Zod2X<IZod2TsOpt> {
+    protected readonly commentKey = "//";
     constructor(opt?: IZod2TsOpt);
     protected runAfter(): void;
     protected runBefore(): void;
@@ -9,9 +10,10 @@ export declare class Zod2Ts extends Zod2X<IZod2TsOpt> {
     protected addExtendedType(name: string, parentNamespace: string, aliasOf: string, opt?: {
         type?: "union" | "d-union" | "alias";
         isInternal?: boolean;
+        templates?: string;
     }): void;
+    protected getGenericTemplatesTranslation(data: ASTNode): string | undefined;
     protected checkExtendedTypeInclusion(data: ASTNode, type?: "alias" | "union" | "d-union"): boolean;
-    protected getComment: (data: string, indent?: string) => string;
     protected getAnyType: () => string;
     protected getBooleanType: () => string;
     protected getDateType: () => string;

package/dist/transpilers/typescript/runner.js

@@ -10,7 +10,7 @@ const options_1 = require("./options");
 class Zod2Ts extends core_1.Zod2X {
     constructor(opt = {}) {
         super(Object.assign(Object.assign({}, options_1.defaultOpts), opt));
-        this.getComment = (data, indent = "") => `${indent}// ${data}`;
+        this.commentKey = "//";
         this.getAnyType = () => "any";
         this.getBooleanType = () => "boolean";
         this.getDateType = () => "Date";
@@ -37,34 +37,55 @@ class Zod2Ts extends core_1.Zod2X {
         return `${namespace}.${typeName}`;
     }
     addExtendedType(name, parentNamespace, aliasOf, opt) {
+        var _a;
         const extendedType = (opt === null || opt === void 0 ? void 0 : opt.isInternal)
             ? aliasOf
             : this.getTypeFromExternalNamespace(parentNamespace, aliasOf);
+        const templates = (_a = opt === null || opt === void 0 ? void 0 : opt.templates) !== null && _a !== void 0 ? _a : "";
         if ((opt === null || opt === void 0 ? void 0 : opt.type) === "alias") {
-            this.push0(`export type ${name} = ${extendedType};\n`);
+            this.push0(`export type ${name} = ${extendedType}${templates};\n`);
         }
         else if (this.opt.outType === "class") {
             if ((opt === null || opt === void 0 ? void 0 : opt.type) === "d-union") {
-                this.push0(`export type ${name} = ${extendedType};\n`);
+                this.push0(`export type ${name} = ${extendedType}${templates};\n`);
             }
             else {
-                this.push0(`export class ${name} extends ${extendedType} {}\n`);
+                this.push0(`export class ${name} extends ${extendedType}${templates} {}\n`);
             }
         }
         else {
             if ((opt === null || opt === void 0 ? void 0 : opt.type) === "union" || (opt === null || opt === void 0 ? void 0 : opt.type) === "d-union") {
-                this.push0(`export type ${name} = ${extendedType};\n`);
+                this.push0(`export type ${name} = ${extendedType}${templates};\n`);
             }
             else {
-                this.push0(`export interface ${name} extends ${extendedType} {}\n`);
+                this.push0(`export interface ${name} extends ${extendedType}${templates} {}\n`);
             }
         }
     }
+    getGenericTemplatesTranslation(data) {
+        if ((data instanceof core_1.ASTObject || data instanceof core_1.ASTDefinition) &&
+            data.templatesTranslation.length > 0) {
+            return ("<" +
+                data.templatesTranslation
+                    .map((t) => {
+                    if (this.isExternalTypeImport(t)) {
+                        this.addExternalTypeImport(t);
+                        return this.getTypeFromExternalNamespace(t.parentNamespace, t.aliasOf);
+                    }
+                    else {
+                        return t.aliasOf;
+                    }
+                })
+                    .join(", ") +
+                ">");
+        }
+    }
     checkExtendedTypeInclusion(data, type) {
         if (this.isExternalTypeImport(data)) {
             if (data.aliasOf) {
                 this.addExtendedType(data.name, data.parentNamespace, data.aliasOf, {
                     type,
+                    templates: this.getGenericTemplatesTranslation(data),
                 });
                 this.addExternalTypeImport(data);
             }
@@ -74,6 +95,7 @@ class Zod2Ts extends core_1.Zod2X {
             this.addExtendedType(data.name, data.parentNamespace, data.aliasOf, {
                 type,
                 isInternal: true,
+                templates: this.getGenericTemplatesTranslation(data),
             });
             return true;
         }
@@ -221,7 +243,8 @@ class Zod2Ts extends core_1.Zod2X {
      *  }
      * */
     _transpileStructuAsInterface(data) {
-        this.push0(`export interface ${data.name} {`);
+        const templates = data.templates.size > 0 ? `<${[...data.templates].join(", ")}>` : "";
+        this.push0(`export interface ${data.name}${templates} {`);
         for (const [key, value] of Object.entries(data.properties)) {
             this._transpileMember(this.opt.keepKeys === true ? key : case_1.default.camel(key), value);
         }
@@ -239,7 +262,8 @@ class Zod2Ts extends core_1.Zod2X {
      *  }
      * */
     _transpileStructAsClass(data) {
-        this.push0(`export class ${data.name} {`);
+        const templates = data.templates.size > 0 ? `<${[...data.templates].join(", ")}>` : "";
+        this.push0(`export class ${data.name}${templates} {`);
         const constructorBody = [];
         for (const [key, value] of Object.entries(data.properties)) {
             const keyName = this.opt.keepKeys === true ? key : case_1.default.camel(key);
@@ -247,7 +271,7 @@ class Zod2Ts extends core_1.Zod2X {
             constructorBody.push(`this.${keyName} = data.${keyName};`);
         }
         this.push0("");
-        this.push1(`constructor(data: ${data.name}) {`);
+        this.push1(`constructor(data: ${data.name}${templates}) {`);
         constructorBody.forEach((i) => this.push2(i));
         this.push1("}");
         this.push0("}\n");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod-to-x",
-  "version": "1.4.8-dev.4",
+  "version": "1.5.0-dev.2",
   "description": "Multi language types generation from Zod schemas.",
   "main": "dist/index.js",
   "files": [