zod-to-x 2.2.0 → 2.3.0

package/README.md

@@ -28,29 +28,35 @@
   <img src="https://img.shields.io/badge/TypeScript-3178C6?style=for-the-badge&logo=typescript&logoColor=white" alt="TypeScript">
   <img src="https://img.shields.io/badge/Python-3776AB?style=for-the-badge&logo=python&logoColor=white" alt="Python">
   <img src="https://img.shields.io/badge/C++-00599C?style=for-the-badge&logo=cplusplus&logoColor=white" alt="C++">
+  <img src="https://img.shields.io/badge/Go-00ADD8?style=for-the-badge&logo=go&logoColor=white" alt="Go">
   <img src="https://img.shields.io/badge/Protobuf-4285F4?style=for-the-badge&logo=google&logoColor=white" alt="Protobuf">
 </p>
 
 
 
 ## Table of contents
-- [Why use `@zod-to-x`](#why-use-zod-to-x)
+- [Table of contents](#table-of-contents)
+- [Why Use `@zod-to-x`?](#why-use-zod-to-x)
 - [Installation](#installation)
+  - [1) Install `@zod-to-x` and `@zod(*)` dependency.](#1-install-zod-to-x-and-zod-dependency)
+  - [2) Extend Zod using the `extendZod` method after the first `@zod` import:](#2-extend-zod-using-the-extendzod-method-after-the-first-zod-import)
 - [Quick start](#quick-start)
 - [Intersections and Unions](#intersections-and-unions)
   - [Expected outputs](#expected-outputs)
   - [Tips for discriminated unions](#tips-for-discriminated-unions)
 - [Layered modeling](#layered-modeling)
   - [Usage example](#usage-example)
-  - [Custom layers](#custom-layers)
+  - [Custom Layers](#custom-layers)
   - [Generic types](#generic-types)
 - [Currently supported output languages](#currently-supported-output-languages)
-  - [Typescript](#1-typescript)
-  - [Python](#2-python) <sup>*(new)*</sup>
-  - [C++](#3-c)
+  - [0) ASTNode](#0-astnode)
+  - [1) Typescript](#1-typescript)
+  - [2) Python](#2-python)
+  - [3) C++](#3-c)
+  - [4) Go](#4-go)
 - [Additional utils](#additional-utils)
-  - [Protobuf V3 generation](#2-zod2protov3)
-- [Mapping of supported Zod Types by Language](#mapping-of-supported-zod-types-by-langauge)
+  - [1) `zod2ProtoV3`](#1-zod2protov3)
+- [Mapping of supported Zod Types by Langauge](#mapping-of-supported-zod-types-by-langauge)
 - [Considerations](#considerations)
 
 
@@ -62,7 +68,7 @@ Managing data consistency across multiple layers and languages is a common chall
 Define your data structures in one place using the powerful [`@zod`](https://github.com/colinhacks/zod) library. This eliminates redundancy, reduces inconsistencies, and simplifies maintenance across your entire codebase, all while allowing you to continue leveraging any npm package in the [`@zod`](https://github.com/colinhacks/zod) ecosystem.
 
 2. **Multi-Language Compatibility**  
-Generate data models for TypeScript, Python (Pydantic), C++, and Protobuf V3 (with languages like Golang on the roadmap). No more manually rewriting models for different platforms.
+Generate data models for TypeScript, Python (Pydantic), C++, Go, and Protobuf V3. No more manually rewriting models for different platforms.
 
 3. **Enhanced Productivity**  
 Automate the transpilation of data models to save time, reduce errors, and let your team focus on business logic instead of boilerplate code.
@@ -628,7 +634,13 @@ Common options:
   - **keepKeys**: Specifies whether property names should follow the C++ naming convention (false) or remain as originally defined (true). The default is `false`.
 - [Examples](https://github.com/rroumenov/zod-to-x/blob/main/test/test_zod2cpp)
 
-
+### 4) Go
+Generates idiomatic Go structs with `encoding/json` struct tags. Requires Go 1.18+ for generic type support.
+- Options:
+  - **packageName**: The Go package name for the generated file. Defaults to `"models"`.
+  - **keepKeys**: Specifies whether field names should remain as originally defined (true) or be converted to exported PascalCase with the original name used in the JSON tag (false). The default is `false`.
+  - **useJsonTags**: Whether to emit `json:"fieldName"` struct tags. Defaults to `true`.
+- [Examples](https://github.com/rroumenov/zod-to-x/blob/main/test/test_zod2go)
 
 ## Additional utils
 Additional useful tools to convert Zod Schemas into different formats.

package/dist/converters/protobuf_v3/runner.js

@@ -255,6 +255,6 @@ class Zod2ProtoV3 extends core_1.Zod2X {
  */
 function zod2ProtoV3(schema, // TODO: fix any to force only ZodObjects
 opt = {}) {
-    const astNode = new core_1.Zod2Ast({ strict: opt.strict }).build(schema);
+    const astNode = new core_1.Zod2Ast({ strict: opt.strict, skipBasicTypes: true }).build(schema);
     return new Zod2ProtoV3(opt).transpile(astNode);
 }

package/dist/core/ast_node.d.ts

@@ -12,6 +12,13 @@ export interface IZod2AstOpt {
      * the schema.
      */
     layer?: IZod2xLayerMetadata;
+    /**
+     * If true, aliased basic types (string, number, boolean, etc.) from layered modeling
+     * will not be extracted as named AST nodes. Instead, they will be inlined as their
+     * underlying type. Useful for targets like Protobuf that don't support type aliases.
+     * Default is false.
+     */
+    skipBasicTypes?: boolean;
 }
 /**
  * This class creates AST nodes used to transpile Zod Schemas to other languages.
@@ -75,7 +82,7 @@ export declare class Zod2Ast {
     private _intersectAstNodes;
     /**
      * Merges multiple AST definitions into a single AST object containing combined properties.
-     * - Equal properties mush have the same type and array dimension.
+     * - Equal properties must have the same type and array dimension.
      * - If a property is optional in one definition and required in another, it will be considered
      *      optional in the merged object.
      * - If a property is nullable in one definition and non-nullable in another, it will be

package/dist/core/ast_node.js

@@ -151,6 +151,7 @@ class Zod2Ast {
         for (const schema of [left, right]) {
             const shape = schema.def.shape;
             for (const key in shape) {
+                const prevWasRequired = properties[key] !== undefined && !properties[key].isOptional;
                 if (zod_helpers_1.ZodHelpers.isZodPromise(shape[key]) &&
                     zod_helpers_1.ZodHelpers.isZod2XGeneric(shape[key])) {
                     const templateKey = shape[key].unwrap().def.values[0];
@@ -159,13 +160,18 @@ class Zod2Ast {
                 else {
                     properties[key] = this._zodToAST(shape[key]);
                 }
+                if (prevWasRequired && properties[key].isOptional) {
+                    // In intersection, if a property is required in one schema and optional in
+                    // another, it should be considered required.
+                    properties[key].isOptional = false;
+                }
             }
         }
         return { properties };
     }
     /**
      * Merges multiple AST definitions into a single AST object containing combined properties.
-     * - Equal properties mush have the same type and array dimension.
+     * - Equal properties must have the same type and array dimension.
      * - If a property is optional in one definition and required in another, it will be considered
      *      optional in the merged object.
      * - If a property is nullable in one definition and non-nullable in another, it will be
@@ -178,42 +184,49 @@ class Zod2Ast {
     _unionAstNodes(options) {
         let typeA, typeB;
         const data = options.map((i) => this.nodes.get(i.name));
-        return {
-            properties: data.reduce((acc, i, j) => {
-                var _a, _b;
-                for (const key in i.properties) {
-                    if (acc[key]) {
-                        acc[key] = structuredClone(acc[key]);
-                        typeA = acc[key].constructor.name;
-                        typeB = i.properties[key].constructor.name;
-                        if (typeA !== typeB) {
-                            this.warnings.push(`Merging properties with different types: ${typeA} ` +
-                                `(from ${(_a = data[j - 1]) === null || _a === void 0 ? void 0 : _a.name}) and ${typeB} ` +
-                                `(from ${i.name})`);
-                        }
-                        if (acc[key].arrayDimension !== i.properties[key].arrayDimension) {
-                            this.warnings.push(`Merging properties with different array dimensions: ` +
-                                `${acc[key].arrayDimension} (from ${(_b = data[j - 1]) === null || _b === void 0 ? void 0 : _b.name}) and ` +
-                                `${i.properties[key].arrayDimension} (from ${i.name})`);
-                            acc[key].arrayDimension = Math.max(acc[key].arrayDimension || 0, i.properties[key].arrayDimension || 0);
-                        }
-                        if (acc[key].isNullable !== i.properties[key].isNullable) {
-                            acc[key].isNullable = true;
-                        }
-                        if (acc[key].isOptional !== i.properties[key].isOptional) {
-                            acc[key].isOptional = true;
-                        }
-                        if (i.properties[key].description) {
-                            acc[key].description = i.properties[key].description;
-                        }
+        const properties = data.reduce((acc, i, j) => {
+            for (const key in i.properties) {
+                if (acc[key]) {
+                    acc[key] = Object.assign(Object.create(Object.getPrototypeOf(acc[key])), acc[key]);
+                    typeA = acc[key].constructor.name;
+                    typeB = i.properties[key].constructor.name;
+                    if (typeA !== typeB) {
+                        this.warnings.push(`Merging properties with different types: ${typeA} ` +
+                            `(from a previous variant) and ${typeB} ` +
+                            `(from ${i.name})`);
+                    }
+                    if (acc[key].arrayDimension !== i.properties[key].arrayDimension) {
+                        this.warnings.push(`Merging properties with different array dimensions: ` +
+                            `${acc[key].arrayDimension} (from a previous variant) and ` +
+                            `${i.properties[key].arrayDimension} (from ${i.name})`);
+                        acc[key].arrayDimension = Math.max(acc[key].arrayDimension || 0, i.properties[key].arrayDimension || 0);
                     }
-                    else {
-                        acc[key] = i.properties[key];
+                    if (acc[key].isNullable !== i.properties[key].isNullable) {
+                        acc[key].isNullable = true;
+                    }
+                    if (acc[key].isOptional !== i.properties[key].isOptional) {
+                        acc[key].isOptional = true;
+                    }
+                    if (i.properties[key].description) {
+                        acc[key].description = i.properties[key].description;
                     }
                 }
-                return acc;
-            }, {}),
-        };
+                else {
+                    acc[key] = i.properties[key]; // New property, just add it
+                }
+            }
+            return acc;
+        }, {});
+        for (const key in properties) {
+            if (!data.every((variant) => key in variant.properties)) {
+                // In Union, if a property is not present in all variants, it should be considered
+                // optional. Shallow-clone preserving prototype before mutating, to avoid corrupting
+                // the original cached AST node.
+                properties[key] = Object.assign(Object.create(Object.getPrototypeOf(properties[key])), properties[key]);
+                properties[key].isOptional = true;
+            }
+        }
+        return { properties };
     }
     /**
      * Retrieves the name and associated transpilerable file information for a given Zod schema.
@@ -481,7 +494,7 @@ class Zod2Ast {
     }
     _getAliasAst(schema, item) {
         var _a;
-        if (((_a = schema._zod2x) === null || _a === void 0 ? void 0 : _a.typeName) === undefined) {
+        if (((_a = schema._zod2x) === null || _a === void 0 ? void 0 : _a.typeName) === undefined || this.opt.skipBasicTypes === true) {
             return item;
         }
         const { name, parentFile, parentNamespace, aliasOf } = this._getNames(schema);

package/dist/layered-modeling/layer.js

@@ -99,7 +99,9 @@ function Layer(opt) {
                                 layer: opt,
                                 typeName: name,
                                 // Generics associated to parent, but related to current type.
-                                genericTypes: metadata.genericTypes,
+                                genericTypes: metadata.isGenericChild === false
+                                    ? metadata.genericTypes
+                                    : undefined,
                                 isGenericChild: true,
                             };
                         }

package/dist/layered-modeling/model.d.ts

@@ -44,5 +44,6 @@ export declare class Zod2XModel {
     transpile(target: Target<"Zod2Cpp17">, opt?: TargetOpt<"Zod2Cpp17">, astOpt?: AstOpt): string;
     transpile(target: Target<"Zod2Ts">, opt?: TargetOpt<"Zod2Ts">, astOpt?: AstOpt): string;
     transpile(target: Target<"Zod2Py">, opt?: TargetOpt<"Zod2Py">, astOpt?: AstOpt): string;
+    transpile(target: Target<"Zod2Go">, opt?: TargetOpt<"Zod2Go">, astOpt?: AstOpt): string;
 }
 export {};

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

@@ -28,8 +28,15 @@ export declare class Zod2Cpp extends Zod2X<IZod2CppOpt> {
         type?: "union" | "alias";
         isInternal?: boolean;
         templates?: string;
+        templateDefinition?: string;
+        templateList?: string;
     }): void;
     protected getGenericTemplatesTranslation(data: ASTNode): string | undefined;
+    /**
+     * Emits an alias/extension declaration early for layered references.
+     * It keeps concrete template translations and falls back to declared templates (e.g. <T>)
+     * for aliases of generic templates.
+     */
     protected checkExtendedTypeInclusion(data: ASTNode, type?: "union" | "alias"): boolean;
     protected runAfter(): void;
     protected getDateType: () => string;
@@ -60,8 +67,14 @@ export declare class Zod2Cpp extends Zod2X<IZod2CppOpt> {
     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 _addExtendedTypeSerializer(typeName: string, parentNamespace: string, opt?: {
+        templateDefinition?: string;
+        templateList?: string;
+    }): void;
+    protected _addExtendedTypeDeserializer(typeName: string, parentNamespace: string, opt?: {
+        templateDefinition?: string;
+        templateList?: string;
+    }): void;
     protected transpileAliasedType(data: ASTAliasedTypes): void;
     /** Ex:
      *  enum class EnumA: int {

package/dist/transpilers/cpp/runner.js

@@ -100,6 +100,9 @@ class Zod2Cpp extends core_1.Zod2X {
             ? 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.templateDefinition) {
+            this.push0(opt.templateDefinition);
+        }
         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}${templates};\n`);
         }
@@ -112,8 +115,14 @@ class Zod2Cpp extends core_1.Zod2X {
             }
         }
         if ((opt === null || opt === void 0 ? void 0 : opt.type) !== "alias" && parentNamespace !== undefined) {
-            this._addExtendedTypeSerializer(name, parentNamespace);
-            this._addExtendedTypeDeserializer(name, parentNamespace);
+            this._addExtendedTypeSerializer(name, parentNamespace, {
+                templateDefinition: opt === null || opt === void 0 ? void 0 : opt.templateDefinition,
+                templateList: opt === null || opt === void 0 ? void 0 : opt.templateList,
+            });
+            this._addExtendedTypeDeserializer(name, parentNamespace, {
+                templateDefinition: opt === null || opt === void 0 ? void 0 : opt.templateDefinition,
+                templateList: opt === null || opt === void 0 ? void 0 : opt.templateList,
+            });
         }
     }
     getGenericTemplatesTranslation(data) {
@@ -134,12 +143,28 @@ class Zod2Cpp extends core_1.Zod2X {
                 ">");
         }
     }
+    /**
+     * Emits an alias/extension declaration early for layered references.
+     * It keeps concrete template translations and falls back to declared templates (e.g. <T>)
+     * for aliases of generic templates.
+     */
     checkExtendedTypeInclusion(data, type) {
+        const templatesMeta = data instanceof core_1.ASTObject && data.templates.size > 0
+            ? this._getTemplates(data.templates)
+            : undefined;
+        const translatedTemplates = this.getGenericTemplatesTranslation(data);
+        const templates = translatedTemplates || (templatesMeta === null || templatesMeta === void 0 ? void 0 : templatesMeta.templateList);
+        const templateList = translatedTemplates ? undefined : templatesMeta === null || templatesMeta === void 0 ? void 0 : templatesMeta.templateList;
+        const templateDefinition = translatedTemplates
+            ? undefined
+            : templatesMeta === null || templatesMeta === void 0 ? void 0 : templatesMeta.templateDefinition;
         if (this.isExternalTypeImport(data)) {
             if (data.aliasOf) {
                 this.addExtendedType(data.name, data.parentNamespace, data.aliasOf, {
                     type,
-                    templates: this.getGenericTemplatesTranslation(data),
+                    templates,
+                    templateDefinition,
+                    templateList,
                 });
                 this.addExternalTypeImport(data);
             }
@@ -149,7 +174,9 @@ class Zod2Cpp extends core_1.Zod2X {
             this.addExtendedType(data.name, data.parentNamespace, data.aliasOf, {
                 type,
                 isInternal: true,
-                templates: this.getGenericTemplatesTranslation(data),
+                templates,
+                templateDefinition,
+                templateList,
             });
             return true;
         }
@@ -205,13 +232,23 @@ 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) {`);
+    _addExtendedTypeSerializer(typeName, parentNamespace, opt) {
+        var _a;
+        if (opt === null || opt === void 0 ? void 0 : opt.templateDefinition) {
+            this._push0(this.serializers, opt.templateDefinition);
+        }
+        const typeNameWithTemplates = `${typeName}${(_a = opt === null || opt === void 0 ? void 0 : opt.templateList) !== null && _a !== void 0 ? _a : ""}`;
+        this._push0(this.serializers, `inline void to_json(${nlohmann_1.NLOHMANN}& j, const ${typeNameWithTemplates}& 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) {`);
+    _addExtendedTypeDeserializer(typeName, parentNamespace, opt) {
+        var _a;
+        if (opt === null || opt === void 0 ? void 0 : opt.templateDefinition) {
+            this._push0(this.serializers, opt.templateDefinition);
+        }
+        const typeNameWithTemplates = `${typeName}${(_a = opt === null || opt === void 0 ? void 0 : opt.templateList) !== null && _a !== void 0 ? _a : ""}`;
+        this._push0(this.serializers, `inline void from_json(const ${nlohmann_1.NLOHMANN}& j, ${typeNameWithTemplates}& x) {`);
         this._push1(this.serializers, `${parentNamespace}::from_json(j, x);`);
         this._push0(this.serializers, "}\n");
     }

package/dist/transpilers/go/libs.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Go standard library and common package import strings.
+ */
+export declare function getLibs(): {
+    timePackage: string;
+    jsonPackage: string;
+    fmtPackage: string;
+};

package/dist/transpilers/go/libs.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLibs = getLibs;
+/**
+ * Go standard library and common package import strings.
+ */
+function getLibs() {
+    return {
+        timePackage: `"time"`,
+        jsonPackage: `"encoding/json"`,
+        fmtPackage: `"fmt"`,
+    };
+}

package/dist/transpilers/go/options.d.ts

@@ -0,0 +1,17 @@
+import { IZodToXOpt } from "../../core";
+export interface IZod2GoOpt extends IZodToXOpt {
+    /**
+     * The Go package name for the generated file. Default: "models"
+     */
+    packageName?: string;
+    /**
+     * By default (false), struct field names are exported (PascalCase) and JSON tags use the
+     * original property name. If set to true, original property names are preserved as-is.
+     */
+    keepKeys?: boolean;
+    /**
+     * Whether to emit `json:"fieldName"` struct tags. Default: true
+     */
+    useJsonTags?: boolean;
+}
+export declare const defaultOpts: IZod2GoOpt;

package/dist/transpilers/go/options.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultOpts = void 0;
+exports.defaultOpts = {
+    includeComments: true,
+    indent: 4,
+    useImports: true,
+    packageName: "models",
+    keepKeys: false,
+    useJsonTags: true,
+};

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

@@ -0,0 +1,100 @@
+import { ASTAliasedTypes, ASTEnum, ASTIntersection, ASTNode, ASTObject, ASTUnion, Zod2X } from "../../core";
+import { IZod2GoOpt } from "./options";
+/**
+ * Transpiler for Zod schemas to Go structs and types.
+ */
+export declare class Zod2Go extends Zod2X<IZod2GoOpt> {
+    protected readonly commentKey = "//";
+    protected lib: {
+        timePackage: string;
+        jsonPackage: string;
+        fmtPackage: string;
+    };
+    constructor(opt?: IZod2GoOpt);
+    protected runBefore(): void;
+    protected runAfter(): void;
+    /**
+     * Consolidates all collected imports into a proper Go import block.
+     * Single import → `import "pkg"`, multiple → `import (\n\t"pkg"\n)`.
+     */
+    private _consolidateImports;
+    protected addImportFromFile(filename: string, namespace: string): string;
+    protected getTypeFromExternalNamespace(namespace: string, typeName: string): string;
+    protected addExtendedType(name: string, parentNamespace: string, aliasOf: string, opt?: {
+        type?: "union" | "alias";
+        isInternal?: boolean;
+        templates?: string;
+        declaredTemplates?: string;
+    }): void;
+    protected getGenericTemplatesTranslation(data: ASTNode): string | undefined;
+    /**
+     * Emits an alias/extension declaration early when a node references another layered type.
+     */
+    protected checkExtendedTypeInclusion(data: ASTNode, type?: "union" | "alias"): boolean;
+    protected getStringType: () => string;
+    protected getBooleanType: () => string;
+    protected getAnyType: () => string;
+    protected getDateType: () => string;
+    protected getNumberType: (isInt: boolean, range: {
+        min?: number;
+        max?: number;
+    }) => string;
+    protected getLiteralStringType(value: string | number | boolean, parentEnumNameKey?: [string, string]): string | number;
+    /** Ex: []TypeA, [][]TypeA */
+    protected getArrayType(arrayType: string, arrayDeep: number): string;
+    /** Ex: map[TypeA]struct{} */
+    protected getSetType: (itemType: string) => string;
+    /** Ex: map[KeyType]ValueType */
+    protected getMapType: (keyType: string, valueType: string) => string;
+    /** Ex: map[KeyType]ValueType */
+    protected getRecordType: (keyType: string, valueType: string) => string;
+    /** Go has no native tuple; use []any */
+    protected getTupleType: (_itemsType: string[]) => string;
+    /** Go has no native union; use any */
+    protected getUnionType: (_itemsType: string[]) => string;
+    /** Handled entirely in transpileIntersection via struct embedding */
+    protected getIntersectionType: () => string;
+    protected transpileAliasedType(data: ASTAliasedTypes): void;
+    /**
+     * Emit a Go enum using a typed string or int alias + const block.
+     *
+     * All-string values:
+     *   type EnumItem string
+     *   const (
+     *       EnumItemEnum1 EnumItem = "Enum1"
+     *   )
+     *
+     * All-int values:
+     *   type EnumItem int
+     *   const (
+     *       EnumItemNativeEnum1 EnumItem = 1
+     *   )
+     *
+     * Mixed (int + string): untyped constants with warning comment.
+     */
+    protected transpileEnum(data: ASTEnum): void;
+    /**
+     * Go union: emit `type Name any` with a comment listing possible types.
+     *
+     * For discriminated unions: emit a marker interface + marker stubs on each
+     * member type + an `UnmarshalXxx` helper that dispatches on the discriminant
+     * key using a `json.RawMessage` probe (uniform for string, bool, and number
+     * discriminant values).
+     */
+    protected transpileUnion(data: ASTUnion): void;
+    /**
+     * Go intersection: struct embedding.
+     *
+     * type IntersectionItem struct {
+     *     ObjectItem
+     *     OtherObjectItem
+     * }
+     */
+    protected transpileIntersection(data: ASTIntersection): void;
+    protected transpileStruct(data: ASTObject): void;
+    /** Render a Go struct body for an ASTObject. */
+    private _transpileStructBody;
+    /** Render a single struct field: `FieldName Type \`json:"key"\`` */
+    private _transpileMember;
+    private _buildJsonTag;
+}

package/dist/transpilers/go/runner.js

@@ -0,0 +1,399 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Zod2Go = void 0;
+const case_1 = __importDefault(require("case"));
+const core_1 = require("../../core");
+const number_limits_1 = require("../../utils/number_limits");
+const libs_1 = require("./libs");
+const options_1 = require("./options");
+/**
+ * Transpiler for Zod schemas to Go structs and types.
+ */
+class Zod2Go extends core_1.Zod2X {
+    constructor(opt = {}) {
+        super(Object.assign(Object.assign({}, options_1.defaultOpts), opt));
+        this.commentKey = "//";
+        // ── Primitive type methods ──────────────────────────────────────────────
+        this.getStringType = () => "string";
+        this.getBooleanType = () => "bool";
+        this.getAnyType = () => "any";
+        this.getDateType = () => {
+            this.imports.add(this.lib.timePackage);
+            return "time.Time";
+        };
+        this.getNumberType = (isInt, range) => {
+            if (!isInt)
+                return "float64";
+            const min = range.min;
+            const max = range.max;
+            if (min !== undefined &&
+                max !== undefined &&
+                min >= number_limits_1.INT32_RANGES[0] &&
+                max <= number_limits_1.INT32_RANGES[1]) {
+                return "int32";
+            }
+            return "int64";
+        };
+        /** Ex: map[TypeA]struct{} */
+        this.getSetType = (itemType) => `map[${itemType}]struct{}`;
+        /** Ex: map[KeyType]ValueType */
+        this.getMapType = (keyType, valueType) => `map[${keyType}]${valueType}`;
+        /** Ex: map[KeyType]ValueType */
+        this.getRecordType = (keyType, valueType) => `map[${keyType}]${valueType}`;
+        /** Go has no native tuple; use []any */
+        this.getTupleType = (_itemsType) => "[]any";
+        /** Go has no native union; use any */
+        this.getUnionType = (_itemsType) => "any";
+        /** Handled entirely in transpileIntersection via struct embedding */
+        this.getIntersectionType = () => "";
+        this.lib = (0, libs_1.getLibs)();
+    }
+    runBefore() {
+        var _a;
+        this.preImports.add(`package ${(_a = this.opt.packageName) !== null && _a !== void 0 ? _a : "models"}`);
+    }
+    runAfter() {
+        this._consolidateImports();
+    }
+    /**
+     * Consolidates all collected imports into a proper Go import block.
+     * Single import → `import "pkg"`, multiple → `import (\n\t"pkg"\n)`.
+     */
+    _consolidateImports() {
+        if (this.imports.size === 0)
+            return;
+        const sorted = Array.from(this.imports).sort();
+        let block;
+        if (sorted.length === 1) {
+            block = `import ${sorted[0]}`;
+        }
+        else {
+            block = `import (\n${sorted.map((s) => `\t${s}`).join("\n")}\n)`;
+        }
+        // Replace the individual entries with the consolidated block
+        this.imports.clear();
+        this.imports.add(block);
+    }
+    addImportFromFile(filename, namespace) {
+        const base = filename.endsWith(".go") ? filename.slice(0, -3) : filename;
+        return `${namespace} "./${base}"`;
+    }
+    getTypeFromExternalNamespace(namespace, typeName) {
+        return `${namespace}.${typeName}`;
+    }
+    addExtendedType(name, parentNamespace, aliasOf, opt) {
+        var _a, _b;
+        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 : "";
+        const declaredTemplates = (_b = opt === null || opt === void 0 ? void 0 : opt.declaredTemplates) !== null && _b !== void 0 ? _b : "";
+        if ((opt === null || opt === void 0 ? void 0 : opt.type) === "alias" || (opt === null || opt === void 0 ? void 0 : opt.type) === "union") {
+            this.push0(`type ${name}${declaredTemplates} = ${extendedType}${templates}\n`);
+        }
+        else {
+            // Struct embedding: type ChildName struct { ParentType }
+            this.push0(`type ${name}${declaredTemplates} struct {`);
+            this.push1(`${extendedType}${templates}`);
+            this.push0(`}\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(", ") +
+                "]");
+        }
+    }
+    /**
+     * Emits an alias/extension declaration early when a node references another layered type.
+     */
+    checkExtendedTypeInclusion(data, type) {
+        const isStruct = data instanceof core_1.ASTObject ||
+            (data instanceof core_1.ASTIntersection && data.newObject !== undefined);
+        const translatedTemplates = this.getGenericTemplatesTranslation(data);
+        const templates = translatedTemplates || undefined;
+        // For declared-template fallback on the declared (definition) side
+        const declaredTemplates = !translatedTemplates && data instanceof core_1.ASTObject && data.templates.size > 0
+            ? `[${[...data.templates].map((t) => `${t} any`).join(", ")}]`
+            : undefined;
+        if (this.isExternalTypeImport(data)) {
+            if (data.aliasOf) {
+                this.addExtendedType(data.name, data.parentNamespace, data.aliasOf, {
+                    type: isStruct ? undefined : type,
+                    templates,
+                    declaredTemplates,
+                });
+                this.addExternalTypeImport(data);
+            }
+            return true;
+        }
+        else if (data.aliasOf) {
+            this.addExtendedType(data.name, data.parentNamespace, data.aliasOf, {
+                type: isStruct ? undefined : type,
+                isInternal: true,
+                templates,
+                declaredTemplates,
+            });
+            return true;
+        }
+        return false;
+    }
+    getLiteralStringType(value, parentEnumNameKey) {
+        if (parentEnumNameKey) {
+            // Go constants cannot be used as types; use the parent enum type name
+            return parentEnumNameKey[0];
+        }
+        // Go has no literal types; return the underlying primitive type
+        if (typeof value === "boolean")
+            return "bool";
+        if (typeof value === "number")
+            return isNaN(value) ? "float64" : Number.isInteger(value) ? "int64" : "float64";
+        return "string";
+    }
+    // ── Composite type methods ──────────────────────────────────────────────
+    /** Ex: []TypeA, [][]TypeA */
+    getArrayType(arrayType, arrayDeep) {
+        let output = `[]${arrayType}`;
+        for (let i = 0; i < arrayDeep - 1; i++) {
+            output = `[]${output}`;
+        }
+        return output;
+    }
+    // ── Transpile methods ───────────────────────────────────────────────────
+    transpileAliasedType(data) {
+        if (this.checkExtendedTypeInclusion(data, "alias")) {
+            return;
+        }
+        this.addComment(data.description);
+        let extendedType;
+        if (data instanceof core_1.ASTArray) {
+            extendedType = this.getAttributeType(data.item);
+        }
+        else {
+            extendedType = this.getAttributeType(data);
+        }
+        this.push0(`type ${data.name} = ${extendedType}\n`);
+    }
+    /**
+     * Emit a Go enum using a typed string or int alias + const block.
+     *
+     * All-string values:
+     *   type EnumItem string
+     *   const (
+     *       EnumItemEnum1 EnumItem = "Enum1"
+     *   )
+     *
+     * All-int values:
+     *   type EnumItem int
+     *   const (
+     *       EnumItemNativeEnum1 EnumItem = 1
+     *   )
+     *
+     * Mixed (int + string): untyped constants with warning comment.
+     */
+    transpileEnum(data) {
+        if (this.checkExtendedTypeInclusion(data, "alias")) {
+            return;
+        }
+        this.addComment(data.description);
+        const allStrings = data.values.every(([, v]) => typeof v === "string");
+        const allInts = data.values.every(([, v]) => typeof v === "number");
+        if (allStrings) {
+            this.push0(`type ${data.name} string\n`);
+            this.push0(`const (`);
+            data.values.forEach(([key, value]) => {
+                const constName = `${data.name}${case_1.default.pascal(key)}`;
+                this.push1(`${constName} ${data.name} = "${value}"`);
+            });
+            this.push0(`)\n`);
+        }
+        else if (allInts) {
+            this.push0(`type ${data.name} int\n`);
+            this.push0(`const (`);
+            data.values.forEach(([key, value]) => {
+                const constName = `${data.name}${case_1.default.pascal(key)}`;
+                this.push1(`${constName} ${data.name} = ${value}`);
+            });
+            this.push0(`)\n`);
+        }
+        else {
+            // Mixed types — Go cannot express this as a single typed enum.
+            // Declare as `any` so struct fields can reference the type name.
+            this.push0(`type ${data.name} = any\n`);
+            this.output.push(`// ${data.name}: mixed-type enum — no single Go base type available`);
+            this.push0(`const (`);
+            data.values.forEach(([key, value]) => {
+                const constName = `${data.name}${case_1.default.pascal(key)}`;
+                const v = typeof value === "string" ? `"${value}"` : `${value}`;
+                this.push1(`${constName} = ${v}`);
+            });
+            this.push0(`)\n`);
+        }
+    }
+    /**
+     * Go union: emit `type Name any` with a comment listing possible types.
+     *
+     * For discriminated unions: emit a marker interface + marker stubs on each
+     * member type + an `UnmarshalXxx` helper that dispatches on the discriminant
+     * key using a `json.RawMessage` probe (uniform for string, bool, and number
+     * discriminant values).
+     */
+    transpileUnion(data) {
+        if (this.checkExtendedTypeInclusion(data, "union")) {
+            return;
+        }
+        this.addComment(data.description);
+        const optionNames = data.options.map(this.getAttributeType.bind(this));
+        if (data.discriminantKey) {
+            const methodName = `is${data.name}`;
+            this.push0(`// ${data.name} is a discriminated union on "${data.discriminantKey}".`);
+            this.push0(`// Possible types: ${optionNames.join(", ")}`);
+            this.push0(`type ${data.name} interface {`);
+            this.push1(`${methodName}()`);
+            this.push0(`}\n`);
+            // Marker stubs: one no-op method per member type so each satisfies the interface.
+            // For generic instantiations (e.g. "HttpSuccessfulResponse[SomeDtoResult]") we emit
+            // a generic receiver "func (t Base[T]) isXxx() {}" using the base type name only.
+            for (const name of optionNames) {
+                const bracketIdx = name.indexOf("[");
+                const receiver = bracketIdx !== -1 ? `${name.slice(0, bracketIdx)}[T]` : name;
+                this.push0(`func (t ${receiver}) ${methodName}() {}\n`);
+            }
+            // UnmarshalXxx helper — only when every member has a discriminant value in the AST.
+            const optionsData = data.options.map((opt, i) => {
+                var _a;
+                return ({
+                    typeName: optionNames[i],
+                    discriminantValue: (_a = opt.constraints) === null || _a === void 0 ? void 0 : _a.discriminantValue,
+                });
+            });
+            const allHaveDiscriminantValue = optionsData.every((o) => o.discriminantValue !== undefined);
+            if (allHaveDiscriminantValue) {
+                this.imports.add(this.lib.jsonPackage);
+                this.imports.add(this.lib.fmtPackage);
+                const probeField = data.discriminantKey.charAt(0).toUpperCase() + data.discriminantKey.slice(1);
+                this.push0(`// Unmarshal${data.name} deserializes JSON into the correct ${data.name} concrete type`);
+                this.push0(`// by probing the "${data.discriminantKey}" discriminant field.`);
+                this.push0(`func Unmarshal${data.name}(data []byte) (${data.name}, error) {`);
+                this.push1(`var probe struct {`);
+                this.push2(`${probeField} json.RawMessage \`json:"${data.discriminantKey}"\``);
+                this.push1(`}`);
+                this.push1(`if err := json.Unmarshal(data, &probe); err != nil {`);
+                this.push2(`return nil, err`);
+                this.push1(`}`);
+                this.push1(`switch string(probe.${probeField}) {`);
+                for (const opt of optionsData) {
+                    const dv = opt.discriminantValue;
+                    // Determine raw JSON representation of the case value.
+                    // String literals appear in JSON with surrounding quotes ("Enum1" → "Enum1").
+                    // Bool and number literals appear without quotes (true → true, 42 → 42).
+                    const isStringLiteral = isNaN(Number(dv)) && dv !== "true" && dv !== "false";
+                    const caseVal = isStringLiteral ? `\`"${dv}"\`` : `"${dv}"`;
+                    this.push1(`case ${caseVal}:`);
+                    this.push2(`var v ${opt.typeName}`);
+                    this.push2(`if err := json.Unmarshal(data, &v); err != nil {`);
+                    this.push3(`return nil, err`);
+                    this.push2(`}`);
+                    this.push2(`return v, nil`);
+                }
+                this.push1(`}`);
+                this.push1(`return nil, fmt.Errorf("failed to deserialize ${data.name}: unknown discriminator %s", string(probe.${probeField}))`);
+                this.push0(`}\n`);
+            }
+        }
+        else {
+            this.push0(`// ${data.name} is a union of: ${optionNames.join(", ")}`);
+            this.push0(`type ${data.name} = any\n`);
+        }
+    }
+    /**
+     * Go intersection: struct embedding.
+     *
+     * type IntersectionItem struct {
+     *     ObjectItem
+     *     OtherObjectItem
+     * }
+     */
+    transpileIntersection(data) {
+        if (this.checkExtendedTypeInclusion(data)) {
+            return;
+        }
+        this.addComment(data.description);
+        if (data.newObject) {
+            // Flatten the merged object into a plain struct
+            this._transpileStructBody(data.newObject);
+        }
+        else {
+            // Embed both sides
+            const leftType = this.getAttributeType(data.left);
+            const rightType = this.getAttributeType(data.right);
+            this.push0(`type ${data.name} struct {`);
+            this.push1(leftType);
+            this.push1(rightType);
+            this.push0(`}\n`);
+        }
+    }
+    transpileStruct(data) {
+        if (this.checkExtendedTypeInclusion(data)) {
+            return;
+        }
+        this.addComment(data.description);
+        this._transpileStructBody(data);
+    }
+    /** Render a Go struct body for an ASTObject. */
+    _transpileStructBody(data) {
+        const templateParams = data.templates.size > 0
+            ? `[${[...data.templates].map((t) => `${t} any`).join(", ")}]`
+            : "";
+        this.push0(`type ${data.name}${templateParams} struct {`);
+        const hasProperties = Object.keys(data.properties).length > 0;
+        if (!hasProperties) {
+            this.push0(`}\n`);
+            return;
+        }
+        for (const [key, value] of Object.entries(data.properties)) {
+            const fieldName = this.opt.keepKeys === true ? key : case_1.default.pascal(key);
+            this._transpileMember(fieldName, key, value);
+        }
+        this.push0(`}\n`);
+    }
+    /** Render a single struct field: `FieldName Type \`json:"key"\`` */
+    _transpileMember(fieldName, originalKey, memberNode) {
+        const isOptionalOrNullable = memberNode.isOptional || memberNode.isNullable;
+        let varType = this.getAttributeType(memberNode);
+        // Optional/nullable fields use pointer types
+        if (isOptionalOrNullable) {
+            // Avoid double-pointer for types already expressed as pointers/interfaces
+            if (!varType.startsWith("*") && varType !== "any") {
+                varType = `*${varType}`;
+            }
+        }
+        if (memberNode.description && !memberNode.name && !this.isTranspilerable(memberNode)) {
+            this.addComment(memberNode.description, `\n${this.indent[1]}`);
+        }
+        const tag = this._buildJsonTag(originalKey, isOptionalOrNullable !== null && isOptionalOrNullable !== void 0 ? isOptionalOrNullable : false);
+        this.push1(`${fieldName} ${varType}${tag}`);
+    }
+    _buildJsonTag(originalKey, omitempty) {
+        if (this.opt.useJsonTags === false)
+            return "";
+        const flags = omitempty ? `,omitempty` : "";
+        return ` \`json:"${originalKey}${flags}"\``;
+    }
+}
+exports.Zod2Go = Zod2Go;

package/dist/transpilers/index.d.ts

@@ -1,3 +1,4 @@
 export { Zod2Ts } from "./typescript/runner";
 export { Zod2Cpp, Zod2Cpp17 } from "./cpp/runner";
 export { Zod2Py } from "./python/runner";
+export { Zod2Go } from "./go/runner";

package/dist/transpilers/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Zod2Py = exports.Zod2Cpp17 = exports.Zod2Cpp = exports.Zod2Ts = void 0;
+exports.Zod2Go = exports.Zod2Py = exports.Zod2Cpp17 = exports.Zod2Cpp = exports.Zod2Ts = void 0;
 var runner_1 = require("./typescript/runner");
 Object.defineProperty(exports, "Zod2Ts", { enumerable: true, get: function () { return runner_1.Zod2Ts; } });
 var runner_2 = require("./cpp/runner");
@@ -8,3 +8,5 @@ Object.defineProperty(exports, "Zod2Cpp", { enumerable: true, get: function () {
 Object.defineProperty(exports, "Zod2Cpp17", { enumerable: true, get: function () { return runner_2.Zod2Cpp17; } });
 var runner_3 = require("./python/runner");
 Object.defineProperty(exports, "Zod2Py", { enumerable: true, get: function () { return runner_3.Zod2Py; } });
+var runner_4 = require("./go/runner");
+Object.defineProperty(exports, "Zod2Go", { enumerable: true, get: function () { return runner_4.Zod2Go; } });

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

@@ -23,6 +23,7 @@ export declare class Zod2Py extends Zod2X<IZod2PyOpt> {
     };
     private baseSchemaAdded;
     private typeVars;
+    private pendingTypeVars;
     constructor(opt?: IZod2PyOpt);
     protected runAfter(): void;
     protected runBefore(): void;
@@ -31,6 +32,7 @@ export declare class Zod2Py extends Zod2X<IZod2PyOpt> {
      * This is the base class for all Pydantic models with shared configuration.
      */
     private _addBaseSchema;
+    private _flushPendingTypeVars;
     /**
      * Declares TypeVars that haven't been declared yet.
      * Adds them right before their first usage.
@@ -51,6 +53,11 @@ export declare class Zod2Py extends Zod2X<IZod2PyOpt> {
         isClass?: boolean;
     }): void;
     protected getGenericTemplatesTranslation(data: ASTNode): string | undefined;
+    /**
+     * Emits an alias/extension declaration early for layered references.
+     * It keeps concrete template translations and falls back to declared templates (e.g. [T])
+     * for aliases of generic templates.
+     */
     protected checkExtendedTypeInclusion(data: ASTNode, type?: "alias" | "union" | "d-union"): boolean;
     protected getAnyType: () => string;
     protected getBooleanType: () => string;

package/dist/transpilers/python/runner.js

@@ -14,6 +14,7 @@ class Zod2Py extends core_1.Zod2X {
         this.commentKey = "#";
         this.baseSchemaAdded = false;
         this.typeVars = new Set();
+        this.pendingTypeVars = new Set();
         this.getAnyType = () => {
             this.imports.add(this.lib.anyType);
             return "Any";
@@ -51,6 +52,9 @@ class Zod2Py extends core_1.Zod2X {
         this.lib = (0, libs_1.getLibs)();
     }
     runAfter() {
+        if (!this.baseSchemaAdded) {
+            this._flushPendingTypeVars(true);
+        }
         this._consolidateImports();
     }
     runBefore() { }
@@ -76,6 +80,22 @@ class Zod2Py extends core_1.Zod2X {
         this.push2("use_enum_values=True");
         this.push1(")");
         this.push0("");
+        this._flushPendingTypeVars(false);
+    }
+    _flushPendingTypeVars(prepend) {
+        if (this.pendingTypeVars.size === 0)
+            return;
+        const pending = Array.from(this.pendingTypeVars);
+        const lines = pending.map((typeVar) => `${typeVar} = TypeVar('${typeVar}')`);
+        if (prepend) {
+            this.output = [...lines, "", ...this.output];
+        }
+        else {
+            lines.forEach((line) => this.push0(line));
+            this.push0("");
+        }
+        pending.forEach((typeVar) => this.typeVars.add(typeVar));
+        this.pendingTypeVars.clear();
     }
     /**
      * Declares TypeVars that haven't been declared yet.
@@ -83,10 +103,14 @@ class Zod2Py extends core_1.Zod2X {
      * Ex: T = TypeVar('T')
      */
     _declareNewTypeVars(templates) {
-        const newTypeVars = Array.from(templates).filter((t) => !this.typeVars.has(t));
+        const newTypeVars = Array.from(templates).filter((t) => !this.typeVars.has(t) && !this.pendingTypeVars.has(t));
         if (newTypeVars.length === 0)
             return;
         this.imports.add(this.lib.typeVarType);
+        if (!this.baseSchemaAdded) {
+            newTypeVars.forEach((typeVar) => this.pendingTypeVars.add(typeVar));
+            return;
+        }
         newTypeVars.forEach((typeVar) => {
             this.push0(`${typeVar} = TypeVar('${typeVar}')`);
             this.typeVars.add(typeVar);
@@ -183,15 +207,28 @@ class Zod2Py extends core_1.Zod2X {
                 "]");
         }
     }
+    /**
+     * Emits an alias/extension declaration early for layered references.
+     * It keeps concrete template translations and falls back to declared templates (e.g. [T])
+     * for aliases of generic templates.
+     */
     checkExtendedTypeInclusion(data, type) {
         // Determine if the aliased type is a class (ASTObject or ASTIntersection with newObject)
         const isClass = data instanceof core_1.ASTObject ||
             (data instanceof core_1.ASTIntersection && data.newObject !== undefined);
+        const declaredTemplatesFallback = data instanceof core_1.ASTObject && data.templates.size > 0 && this.isExternalTypeImport(data)
+            ? `[${[...data.templates].join(", ")}]`
+            : undefined;
+        const translatedTemplates = this.getGenericTemplatesTranslation(data);
+        const templates = translatedTemplates || declaredTemplatesFallback;
+        if (!translatedTemplates && data instanceof core_1.ASTObject && data.templates.size > 0) {
+            this._declareNewTypeVars(data.templates);
+        }
         if (this.isExternalTypeImport(data)) {
             if (data.aliasOf) {
                 this.addExtendedType(data.name, data.parentNamespace, data.aliasOf, {
                     type,
-                    templates: this.getGenericTemplatesTranslation(data),
+                    templates,
                     isClass,
                 });
                 this.addExternalTypeImport(data);
@@ -202,7 +239,7 @@ class Zod2Py extends core_1.Zod2X {
             this.addExtendedType(data.name, data.parentNamespace, data.aliasOf, {
                 type,
                 isInternal: true,
-                templates: this.getGenericTemplatesTranslation(data),
+                templates,
                 isClass,
             });
             return true;

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

@@ -11,8 +11,14 @@ export declare class Zod2Ts extends Zod2X<IZod2TsOpt> {
         type?: "union" | "d-union" | "alias";
         isInternal?: boolean;
         templates?: string;
+        declaredTemplates?: string;
     }): void;
     protected getGenericTemplatesTranslation(data: ASTNode): string | undefined;
+    /**
+     * Emits an alias/extension declaration early when a node references another layered type.
+     * It preserves concrete template translations and falls back to declared templates (e.g. <T>)
+     * for aliases of generic templates.
+     */
     protected checkExtendedTypeInclusion(data: ASTNode, type?: "alias" | "union" | "d-union"): boolean;
     protected getAnyType: () => string;
     protected getBooleanType: () => string;

package/dist/transpilers/typescript/runner.js

@@ -37,28 +37,29 @@ class Zod2Ts extends core_1.Zod2X {
         return `${namespace}.${typeName}`;
     }
     addExtendedType(name, parentNamespace, aliasOf, opt) {
-        var _a;
+        var _a, _b;
         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 : "";
+        const declaredName = `${name}${(_b = opt === null || opt === void 0 ? void 0 : opt.declaredTemplates) !== null && _b !== void 0 ? _b : ""}`;
         if ((opt === null || opt === void 0 ? void 0 : opt.type) === "alias") {
-            this.push0(`export type ${name} = ${extendedType}${templates};\n`);
+            this.push0(`export type ${declaredName} = ${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}${templates};\n`);
+                this.push0(`export type ${declaredName} = ${extendedType}${templates};\n`);
             }
             else {
-                this.push0(`export class ${name} extends ${extendedType}${templates} {}\n`);
+                this.push0(`export class ${declaredName} 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}${templates};\n`);
+                this.push0(`export type ${declaredName} = ${extendedType}${templates};\n`);
             }
             else {
-                this.push0(`export interface ${name} extends ${extendedType}${templates} {}\n`);
+                this.push0(`export interface ${declaredName} extends ${extendedType}${templates} {}\n`);
             }
         }
     }
@@ -80,12 +81,24 @@ class Zod2Ts extends core_1.Zod2X {
                 ">");
         }
     }
+    /**
+     * Emits an alias/extension declaration early when a node references another layered type.
+     * It preserves concrete template translations and falls back to declared templates (e.g. <T>)
+     * for aliases of generic templates.
+     */
     checkExtendedTypeInclusion(data, type) {
+        const declaredTemplatesFallback = data instanceof core_1.ASTObject && data.templates.size > 0
+            ? `<${[...data.templates].join(", ")}>`
+            : undefined;
+        const translatedTemplates = this.getGenericTemplatesTranslation(data);
+        const templates = translatedTemplates || declaredTemplatesFallback;
+        const declaredTemplates = translatedTemplates ? undefined : declaredTemplatesFallback;
         if (this.isExternalTypeImport(data)) {
             if (data.aliasOf) {
                 this.addExtendedType(data.name, data.parentNamespace, data.aliasOf, {
                     type,
-                    templates: this.getGenericTemplatesTranslation(data),
+                    templates,
+                    declaredTemplates,
                 });
                 this.addExternalTypeImport(data);
             }
@@ -95,7 +108,8 @@ class Zod2Ts extends core_1.Zod2X {
             this.addExtendedType(data.name, data.parentNamespace, data.aliasOf, {
                 type,
                 isInternal: true,
-                templates: this.getGenericTemplatesTranslation(data),
+                templates,
+                declaredTemplates,
             });
             return true;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod-to-x",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "Multi language types generation from Zod schemas.",
   "main": "dist/index.js",
   "files": [
@@ -11,10 +11,12 @@
     "build": "npm run clear_dist && tsc && tsc-alias",
     "build:debug": "npm run clear_dist && tsc --project tsconfig.dev.json && tsc-alias",
     "format:check": "prettier --check .",
+    "swap": "npm install && npm run build",
     "test": "find ./test -name \"err-*\" -delete && vitest --run",
     "test:cpp": "bash ./test/test_zod2cpp/test_cpp.sh",
     "test:py": "bash ./test/test_zod2py/test_py.sh",
-    "test:all": "npm run test:cpp && npm run test:py",
+    "test:go": "bash ./test/test_zod2go/test_go.sh",
+    "test:all": "npm run test:cpp && npm run test:py && npm run test:go",
     "ts-run": "ts-node -r tsconfig-paths/register",
     "prepare": "husky"
   },
@@ -29,7 +31,7 @@
     "type",
     "generator",
     "zod-to-cpp",
-    "zpd-to-c++",
+    "zod-to-c++",
     "zod-to-ts",
     "zod-to-typescript",
     "typescript",
@@ -59,7 +61,7 @@
     "husky": "^9.1.7",
     "lint-staged": "^15.2.11",
     "prettier": "^3.4.2",
-    "protobufjs": "7.4.0",
+    "protobufjs": "7.5.5",
     "ts-node": "^10.9.2",
     "tsc-alias": "^1.8.10",
     "tsconfig-paths": "4.2.0",