zod-to-x 1.6.1-dev.0 → 1.8.0

package/README.md

@@ -26,30 +26,38 @@
   <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/Dart-0175C2?style=for-the-badge&logo=dart&logoColor=white" alt="Dart">
   <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)
+  - [5) Dart](#5-dart)
 - [Additional utils](#additional-utils)
-  - [JSON Schema definitions](#1-zod2jsonschemadefinitions)
-  - [Protobuf V3 generation](#2-zod2protov3)
-- [Mapping of supported Zod Types by Language](#mapping-of-supported-zod-types-by-langauge)
+  - [1) `zod2JsonSchemaDefinitions`](#1-zod2jsonschemadefinitions)
+  - [2) `zod2ProtoV3`](#2-zod2protov3)
+- [Mapping of supported Zod Types by Langauge](#mapping-of-supported-zod-types-by-langauge)
 - [Considerations](#considerations)
 
 
@@ -61,7 +69,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 like [`@zod-to-json-schema`](https://github.com/StefanTerdell/zod-to-json-schema)
 
 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.
@@ -647,6 +655,22 @@ 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)
+
+### 5) Dart
+`json_annotation` + `json_serializable` are used for JSON serialization/deserialization. The `.g.dart` part file is generated externally by `dart run build_runner build`.
+- Options:
+  - **keepKeys**: Specifies whether property names should follow the Dart naming convention (false) or remain as originally defined (true). The default is `false`.
+  - **useJsonSerialization**: When true (default), emits `@JsonSerializable()`, `@JsonEnum`, `@JsonKey` annotations and `fromJson`/`toJson` stubs. Requires `package:json_annotation`.
+  - **partFile**: Filename (without extension) for the `part '${partFile}.g.dart'` directive. Automatically set when using layered modeling. If omitted, no `part` directive is emitted.
+- [Examples](https://github.com/rroumenov/zod-to-x/blob/main/test/test_zod2dart)
+
 
 
 ## Additional utils

package/dist/core/ast_node.d.ts

@@ -82,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

@@ -160,19 +160,25 @@ 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])) {
                     properties[key] = new core_1.ASTGenericType(shape[key]._def.type.value);
                 }
                 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
@@ -185,42 +191,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.

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,7 @@ 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;
+    transpile(target: Target<"Zod2Dart">, opt?: TargetOpt<"Zod2Dart">, astOpt?: AstOpt): string;
 }
 export {};

package/dist/layered-modeling/model.js

@@ -59,7 +59,7 @@ class Zod2XModel {
         return this.astNodes;
     }
     transpile(target, opt = {}, astOpt) {
-        const transpilerInstance = new target(Object.assign(Object.assign({}, opt), { namespace: this.getLayerMetadata().namespace }));
+        const transpilerInstance = new target(Object.assign(Object.assign({}, opt), { namespace: this.getLayerMetadata().namespace, partFile: this.getLayerMetadata().file }));
         return transpilerInstance.transpile(this.getAstNode(astOpt));
     }
 }

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/dart/libs.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Dart package imports for json_annotation / json_serializable.
+ */
+export declare function getLibs(): {
+    jsonAnnotation: string;
+};

package/dist/transpilers/dart/libs.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLibs = getLibs;
+/**
+ * Dart package imports for json_annotation / json_serializable.
+ */
+function getLibs() {
+    return {
+        jsonAnnotation: "import 'package:json_annotation/json_annotation.dart';",
+    };
+}

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

@@ -0,0 +1,21 @@
+import { IZodToXOpt } from "../../core";
+export interface IZod2DartOpt extends IZodToXOpt {
+    /**
+     * By default (false), class property names are converted to camelCase following Dart
+     * conventions. If set to true, the original property names are preserved as-is.
+     */
+    keepKeys?: boolean;
+    /**
+     * When true (default), emits `@JsonSerializable()` annotations, `@JsonEnum`, `@JsonKey`,
+     * and `fromJson`/`toJson` delegation stubs. Requires `package:json_annotation`.
+     * The `.g.dart` part file is generated externally by `dart run build_runner build`.
+     */
+    useJsonSerialization?: boolean;
+    /**
+     * Filename (without extension) used for the `part '${partFile}.g.dart';` directive.
+     * When using layered modeling, this is automatically set to the layer's `file` metadata.
+     * If omitted, no `part` directive is emitted.
+     */
+    partFile?: string;
+}
+export declare const defaultOpts: IZod2DartOpt;

package/dist/transpilers/dart/options.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultOpts = void 0;
+exports.defaultOpts = {
+    indent: 2,
+    includeComments: true,
+    useImports: true,
+    keepKeys: false,
+    useJsonSerialization: true,
+};

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

@@ -0,0 +1,149 @@
+import { ASTAliasedTypes, ASTEnum, ASTIntersection, ASTNode, ASTNodes, ASTObject, ASTUnion, Zod2X } from "../../core";
+import { IZod2DartOpt } from "./options";
+/**
+ * Transpiler for Zod schemas to Dart classes using package:json_annotation.
+ *
+ * The `.g.dart` part file is NOT generated by this transpiler — it must be produced
+ * externally via `dart run build_runner build`.
+ */
+export declare class Zod2Dart extends Zod2X<IZod2DartOpt> {
+    protected readonly commentKey = "//";
+    protected lib: {
+        jsonAnnotation: string;
+    };
+    /**
+     * Maps a local struct/class name to the discriminated union names it participates in.
+     * Populated by a pre-scan of the AST before the normal transpile pass.
+     */
+    private _unionMembers;
+    /**
+     * Names of locally-defined discriminated union abstract classes.
+     * Used to emit @JsonKey(fromJson/toJson) when such a type appears as a field.
+     */
+    private _discriminatedUnionTypes;
+    /**
+     * Names of typedef-emitted types (alias, union typedef, struct extends).
+     * When these appear as field types in @JsonSerializable classes, we emit
+     * @JsonKey(fromJson: TypeName.fromJson) to prevent json_serializable from
+     * following the typedef chain and referencing transitive imports.
+     */
+    private _typedefNames;
+    /**
+     * Maps a disc union typedef name (e.g. "NewDiscriminatedUnionItem") to the
+     * fromJson function name of the underlying entity-level union
+     * (e.g. "discriminatedUnionItemFromJson").
+     * Populated during pre-scan when an ASTUnion node has aliasOf set.
+     */
+    private _discriminatedUnionDelegateFromJson;
+    /**
+     * Unified set of type names needing custom @JsonKey annotations.
+     * - Discriminated union types: fromJson = <camelName>FromJson (local function)
+     * - Typedef types: fromJson = _<camelName>FromJson (standalone wrapper)
+     * - TypedefList: list fromJson/toJson helpers
+     * _toJson helpers are emitted in runAfter() for all entries.
+     */
+    private _usedCustomFromJsonTypes;
+    /**
+     * Maps a type name (e.g. "GenericUserEntity") to its full Dart type with
+     * template args (e.g. "GenericUserEntity<SomeDtoResult>"). Used in runAfter()
+     * to generate helpers with correct generic return types and factory calls.
+     */
+    private _usedCustomFromJsonFullTypes;
+    /**
+     * Maps a typedef name to its full extended type (the right-hand side of the
+     * typedef). E.g. "AdminUserEntity" → "GenericUserEntity<AdminUserMetadata>".
+     * Populated in addExtendedType() when the extended type has generic args.
+     * Used in runAfter() to generate 2-arg fromJson calls for generic classes.
+     */
+    private _typedefToExtendedType;
+    constructor(opt?: IZod2DartOpt);
+    /**
+     * Overrides transpile() to pre-scan discriminated union memberships before the normal pass.
+     * This allows transpileStruct() to emit `implements UnionName` on member classes.
+     */
+    transpile(transpilerQueue: ASTNodes): string;
+    protected runBefore(): void;
+    protected runAfter(): void;
+    protected addImportFromFile(filename: string, _namespace: string): string;
+    protected getTypeFromExternalNamespace(_namespace: string, typeName: string): string;
+    protected getGenericTemplatesTranslation(data: ASTNode): string | undefined;
+    /**
+     * Emits an alias/extension declaration for cross-layer references.
+     */
+    protected checkExtendedTypeInclusion(data: ASTNode, type?: "union" | "alias"): boolean;
+    protected addExtendedType(name: string, parentNamespace: string, aliasOf: string, opt?: {
+        type?: "union" | "alias";
+        isInternal?: boolean;
+        templates?: string;
+        declaredTemplates?: string;
+    }): void;
+    protected getStringType: () => string;
+    protected getBooleanType: () => string;
+    protected getAnyType: () => string;
+    protected getDateType: () => string;
+    protected getNumberType(isInt: boolean, _range: {
+        min?: number;
+        max?: number;
+    }): string;
+    /**
+     * Returns the Dart type for a literal value.
+     * Dart has no structural literal types, so we return the underlying primitive type.
+     * When a parent enum is provided, returns the enum type name (not a member expression),
+     * since Dart enum members cannot be used as types.
+     */
+    protected getLiteralStringType(value: string | number | boolean, parentEnumNameKey?: [string, string]): string | number;
+    /** Ex: List<List<T>> for 2D array */
+    protected getArrayType(arrayType: string, arrayDeep: number): string;
+    /** Ex: Set<T> */
+    protected getSetType: (itemType: string) => string;
+    /** Ex: Map<K, V> */
+    protected getMapType: (keyType: string, valueType: string) => string;
+    /** Ex: Map<String, V> (record key is always String) */
+    protected getRecordType: (keyType: string, valueType: string) => string;
+    /** Ex: (T1, T2, T3) — Dart 3 positional record type */
+    protected getTupleType: (itemsType: string[]) => string;
+    /** Dart has no native union type; use Object */
+    protected getUnionType: (_itemsType: string[]) => string;
+    /** Dart has no native intersection type; use Object */
+    protected getIntersectionType: (_itemsType: string[]) => string;
+    protected transpileAliasedType(data: ASTAliasedTypes): void;
+    /**
+     * Emits a Dart enhanced enum with a typed `value` field and `@JsonEnum` annotation.
+     *
+     * All-string values:
+     *   @JsonEnum(valueField: 'value')
+     *   enum EnumItem {
+     *     enum1('Enum1'),
+     *     enum2('Enum2');
+     *
+     *     const EnumItem(this.value);
+     *     final String value;
+     *   }
+     *
+     * Mixed (int + string): typedef alias with comment.
+     */
+    protected transpileEnum(data: ASTEnum): void;
+    protected transpileStruct(data: ASTObject): void;
+    /**
+     * Dart intersection:
+     * - If the AST produced a merged `newObject`, emit it as a flat class.
+     * - Otherwise emit a typedef alias to Object with a comment.
+     */
+    protected transpileIntersection(data: ASTIntersection): void;
+    /**
+     * Dart union:
+     * - Non-discriminated: typedef alias to Object with a comment listing member types.
+     * - Discriminated: abstract base class + factory unmarshal function using Dart 3 switch.
+     */
+    protected transpileUnion(data: ASTUnion): void;
+    /** Renders the full body of a Dart class for an ASTObject. */
+    private _transpileStructBody;
+    /** Renders a single class field declaration with optional `@JsonKey` annotation. */
+    private _transpileMember;
+    /**
+     * Emits `fromJson` factory and `toJson` method delegation stubs.
+     * For generic classes, extra `fromJsonT` / `toJsonT` function parameters are added
+     * as required by `json_serializable` with `genericArgumentFactories: true`.
+     */
+    private _emitFromToJson;
+}