zod-to-x 2.0.2-dev.2 → 2.1.0-dev.2

package/README.md

@@ -29,9 +29,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)
@@ -483,6 +484,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.
@@ -597,7 +698,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

@@ -1,6 +1,5 @@
-import { ZodDiscriminatedUnion, ZodUnion } from "zod";
 import { IZod2AstOpt } from "../../core";
-import { ZodObject } from "../../lib/zod_helpers";
+import { ZodObject, ZodDiscriminatedUnion, ZodUnion } from "../../lib/zod_helpers";
 import { IZod2ProtoV3Opt } from "./options";
 /**
  * Converts a Zod schema into a Protocol Buffers v3 definition.
@@ -17,5 +16,5 @@ import { IZod2ProtoV3Opt } from "./options";
  *                              definition.
  * @returns The Protocol Buffers v3 definition as a string.
  */
-export declare function zod2ProtoV3(schema: ZodObject<any> | ZodDiscriminatedUnion<string, any> | ZodUnion<any>, // TODO: fix any to force only ZodObjects
-opt?: Pick<IZod2AstOpt, "strict"> & Pick<IZod2ProtoV3Opt, "packageName" | "keepKeys" | "header" | "indent" | "includeComments" | "encodeDoubleAsInt">): string;
+export declare function zod2ProtoV3(schema: ZodObject<any> | ZodDiscriminatedUnion | ZodUnion<any>, // TODO: fix any to force only ZodObjects
+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;
@@ -160,11 +164,17 @@ class Zod2ProtoV3 extends core_1.Zod2X {
         this.addComment(data.description);
         this.push0(`message ${data.name} {`);
         Object.entries(data.properties).forEach(([key, value], index) => {
-            if (value.description && !this.isTranspilerable(value)) {
+            if (this.opt.includeComments &&
+                value.description &&
+                !value.name &&
+                !this.isTranspilerable(value)) {
                 // 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,
         });
@@ -261,13 +284,25 @@ class Zod2Ast {
      */
     _getObjectAst(schema, opt) {
         var _a;
-        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].unwrap().def.values[0];
+                    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
@@ -279,6 +314,8 @@ class Zod2Ast {
                 parentFile,
                 parentNamespace,
                 aliasOf,
+                templates,
+                templatesTranslation: templatesTranslation || [],
             }));
         }
         const item = this.nodes.get(name);
@@ -295,7 +332,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.
@@ -315,7 +352,7 @@ class Zod2Ast {
         var _a, _b, _c;
         const def = schema.def;
         const discriminator = zod_helpers_1.ZodHelpers.isZodDiscriminatedUnion(schema)
-            ? schema.def.discriminator
+            ? schema._zod.def.discriminator
             : undefined;
         const { name, parentFile, parentNamespace, aliasOf } = this._getNames(schema);
         const item = new core_1.ASTUnion({
@@ -340,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: (((_b = schema.meta()) === null || _b === void 0 ? void 0 : _b.description) ? `${(_c = schema.meta()) === null || _c === void 0 ? void 0 : _c.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)) {
@@ -383,13 +425,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: (((_b = schema.meta()) === null || _b === void 0 ? void 0 : _b.description) ? `${(_c = schema.meta()) === null || _c === void 0 ? void 0 : _c.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);
+                        }
                     });
                 }
             },