zod-to-x 2.2.1-dev.0 → 2.4.0

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,5 @@
 export { Zod2Ts } from "./typescript/runner";
 export { Zod2Cpp, Zod2Cpp17 } from "./cpp/runner";
 export { Zod2Py } from "./python/runner";
+export { Zod2Go } from "./go/runner";
+export { Zod2Dart } from "./dart/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.Zod2Dart = 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,7 @@ 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; } });
+var runner_5 = require("./dart/runner");
+Object.defineProperty(exports, "Zod2Dart", { enumerable: true, get: function () { return runner_5.Zod2Dart; } });

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;