zod-to-x 1.4.7-dev.7 → 2.0.1-dev.3

package/README.md

@@ -16,7 +16,9 @@
 
 
 
-[`@zod-to-x`](https://github.com/rroumenov/zod-to-x) is a Zod-based library designed to establish a centralized methodology for defining data structures. It allows you to transpile these definitions into various programming languages in a clear and straightforward way. This tool addresses a fundamental requirement of any software: having a clear understanding of the data it handles.
+[`@zod-to-x`](https://github.com/rroumenov/zod-to-x`) is a Zod-based library designed to establish a centralized methodology for defining data structures. It allows you to transpile these definitions into various programming languages in a clear and straightforward way. This tool addresses a fundamental requirement of any software: having a clear understanding of the data it handles.
+
+<span style="color: red;">**Important Announcement:**</span> `zod-to-x@2.0.0` has been released, introducing migration to Zod V4. At this stage, only the existent behavior has been migrated, while new features like Literal Templates are still under analysis. Additionally, `zod-to-x@1.X.Y` will continue to be maintained for Zod V3, and any new transpilation languages will also be supported in version 1.
 
 
 
@@ -34,7 +36,6 @@
   - [Typescript](#1-typescript)
   - [C++](#2-c)
 - [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)
 - [Considerations](#considerations)
@@ -45,7 +46,7 @@
 Managing data consistency across multiple layers and languages is a common challenge in modern software development. [`@zod-to-x`](https://github.com/rroumenov/zod-to-x) solves this by allowing you to define your data models once and effortlessly transpile them into multiple programming languages. Here’s why it stands out:
 
 1. **Centralized Data Definition**  
-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)
+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, Protobuf V3 and C++ (with languages like Golang on the roadmap). No more manually rewriting models for different platforms.
@@ -59,18 +60,17 @@ Automate the transpilation of data models to save time, reduce errors, and let y
 ```bash
 npm install zod-to-x zod
 ```
-(*) [`zod@3.22.3`](https://www.npmjs.com/package/zod/v/3.22.0) version or greather is required.
+(*) [`zod@3.25.28`](https://www.npmjs.com/package/zod/v/3.25.0) version or greather is required.
 
 ### 2) Extend Zod using the `extendZod` method after the first [`@zod`](https://github.com/colinhacks/zod) import:
 ```ts
-import { z } from "zod";
+import { z } from "zod/v4";
 import { extendZod } from "zod-to-x";
 extendZod(z);
 ```
 
 This extension appends a `zod2x` method to:
 - ZodEnum
-- ZodNativeEnum
 - ZodObject
 - ZodUnion
 - ZodDiscriminatedUnion
@@ -79,7 +79,7 @@ This extension appends a `zod2x` method to:
 
 ## Quick start
 ```ts
-import { z } from "zod";
+import { z } from "zod/v4";
 import { extendZod, Zod2Ast, Zod2XTranspilers } from "zod-to-x";
 extendZod(z); // The extend step can be skipped if it has already been done.
 
@@ -87,9 +87,9 @@ extendZod(z); // The extend step can be skipped if it has already been done.
  * 1) Define a data model using Zod schemas
  */
 const VisitorSchema = z.object({
-  id: z.string().uuid(),
+  id: z.uuid(),
   name: z.string(),
-  email: z.string().email(),
+  email: z.email(),
   visitDate: z.date(),
   comments: z.string().optional(),
 }).zod2x("Visitor"); // Add your expected output type name using the 'zod2x' method.
@@ -185,7 +185,7 @@ const Intersection = z.intersection(DataA, DataB).zod2x("Intersection");
 
 ### Tips for discriminated unions
 To enhance data modeling and the serialization/deserialization of a discriminated union type, two key steps should be considered:
-- Using `ZodEnum` or `ZodNativeEnum` the define the discriminator key options.
+- Using `ZodEnum` the define the discriminator key options.
 - Using `ZodLiteral` to define the specific value of the discriminator key.
 
 Example of discriminant definition:
@@ -265,6 +265,7 @@ To achieve this, new components are included:
   - **file**: Specifies the expected output file where the transpiled types will be saved.
   - **externalInheritance**: When a type from one layer is imported into another layer without modifications, it is transpiled as a new type inheriting from the imported type. This ensures type consistency across layers while maintaining reusability. See example (4) below. The default value is `true`.
   - **basicTypes**: Since `v1.4.6`, primitive data types and arrays are also transpiled when using Layered modeling **if they are declared as property inside the layer class**. They are output as aliases of the types they represent. Setting it to `false` will disable this behavior (except for arrays, which are always transpiled). Default is `true`.
+  - **skipLayerInterface**: Before `v2.0.0`, a global interface was transpiled with all layer properties. With `externalInheritance` and `basicType`, this behavior has started to become obsolete, so it is not included by default. If needed, set to `false`.
 - **Zod2XMixin**: A function that enables the creation of layers by extending multiple data models, thereby simplifying their definition and organization.
 
 ### Usage example
@@ -275,13 +276,13 @@ class UserModels extends Zod2XModel {
 
     userRole = z.enum(["Admin", "User"]).zod2x("UserRole"); // (*)
 
-    userEmail = z.string().email(); // This will be transpiled as an alias.
+    userEmail = z.email(); // This will be transpiled as an alias.
 
     userEntity = z.object({
-        id: z.string().uuid(),
+        id: z.uuid(),
         name: z.string().min(1),
         email: this.userEmail,
-        age: z.number().int().nonnegative().optional(),
+        age: z.int().nonnegative().optional(),
         role: this.userRole,
     }); // (*)
 }
@@ -304,11 +305,6 @@ console.log(userModels.transpile(Zod2XTranspilers.Zod2Ts));
 //     role: UserRole;
 // }
 
-// export interface UserModels {
-//     userRole: UserRole;
-//     userEntity: UserEntity;
-// }
-
 ```
 **(*)** Thanks to the Layer decorator, the use of `zod2x` for type naming can now be omitted, simplifying and clarifying the process of model definition. By default, it will take the property name and apply a Pascal case convention (example: *myProperty* -> *MyProperty*).  
 You can still use it if you want to enforce a different type name.
@@ -350,11 +346,6 @@ console.log(userDtos.transpile(Zod2XTranspilers.Zod2Ts))
 //     updatedAt: Date;
 // }
 
-// export interface UserDtos {
-//     createUserUseCaseDto: CreateUserUseCaseDto;
-//     createUserUseCaseResultDto: CreateUserUseCaseResultDto;
-// }
-
 ```
 **(*)** Any modification of an existing model (in this case, `userEntity`) will lose the relation with that model, but not its children. In the case of the `CreateUserUseCaseDto` type, the `role` field will remain linked to the existing one in the `user.entity` file.
 
@@ -407,11 +398,6 @@ console.log(userDtos.transpile(Zod2XTranspilers.Zod2Ts))
 //     createdAt: Date;
 //     updatedAt: Date;
 // }
-
-// export interface UserDtos {
-//     createUserUseCaseDto: CreateUserUseCaseDto;
-//     createUserUseCaseResultDto: CreateUserUseCaseResultDto;
-// }
 ```
 
 4 - Difference of using **externalInheritance** (defaults) or not.  
@@ -437,11 +423,6 @@ class UserDtos extends Zod2XModel {
 
 // export interface CreateUserUseCaseResultDto extends USER.UserEntity {}
 
-// export interface UserDtos {
-//     createUserUseCaseDto: CreateUserUseCaseDto;
-//     createUserUseCaseResultDto: CreateUserUseCaseResultDto;
-// }
-
 // ---------------
 // If `USER.UserEntity` were a Union or a Discriminated Union, the output would be a Type equivalent to `USER.UserEntity` rather than an Interface that extends it.  
 
@@ -449,7 +430,7 @@ class UserDtos extends Zod2XModel {
 
 ```ts
 // Output without externalInheritance
-@Application({ namespace: "USER_DTOS", file: "user.dtos",  externalInheritance: false})
+@Application({ namespace: "USER_DTOS", file: "user.dtos",  externalInheritance: false, skipLayerInterface: false})
 class UserDtos extends Zod2XModel {
 
     createUserUseCaseDto = userModels.userEntity.omit({ id: true });
@@ -473,7 +454,7 @@ class UserDtos extends Zod2XModel {
 // }
 
 // ---------------
-// In this case, the type of `createUserUseCaseResultDto` is inferred from the parent model (`UserDtos`), but there is no explicit definition of the type itself.
+// In this case, the type of `createUserUseCaseResultDto` is inferred from the parent model (`UserDtos`, only if skipLayerInterface = false), but there is no explicit definition of the type itself.
 ```
 
 ### Custom Layers
@@ -533,35 +514,7 @@ Common options:
 ## Additional utils
 Additional useful tools to convert Zod Schemas into different formats.
 
-### 1) `zod2JsonSchemaDefinitions`  
-In case of use of libraries like [`@zod-to-json-schema`](https://github.com/StefanTerdell/zod-to-json-schema), the provided zod extension can also be used as a JSON Schema definitions mapper. Check out this [input example](https://github.com/rroumenov/zod-to-x/blob/main/test/test_zod2jschema_def/user_schema.ts) and its [output](https://github.com/rroumenov/zod-to-x/blob/main/test/test_zod2jschema_def/user_schema.json) (\*).
-
-<sup>*(\*) Output is generated using definitions from `zod2JsonSchemaDefinitions` and [`@zod-to-json-schema`](https://github.com/StefanTerdell/zod-to-json-schema) to create the schema with them.*</sup>
-
-```ts
-import { z } from 'zod';
-import { extendZod, Zod2XConverters } from 'zod-to-x';
-import { zodToJsonSchema } from 'zod-to-json-schema';
-extendZod(z);
-
-// Example using model from `Quick-start` section
-const visitorDefinitions = Zod2XConverters.zod2JsonSchemaDefinitions(VisitorSchema);
-const visitorJsonSchema = zodToJsonSchema(
-  VisitorSchema,
-  {definitions: visitorDefinitions}
-);
-console.log(visitorJsonSchema); // JSON Schema with definitions
-
-// Example using model from `Layer modeling` section
-const createUserDtoDefinitions = Zod2XConverters.zod2JsonSchemaDefinitions(userDtos.createUserUseCaseDto);
-const createUserDtoJsonSchema = zodToJsonSchema(
-  userDtos.createUserUseCaseDto,
-  {definitions: createUserDtoDefinitions}
-);
-console.log(createUserDtoJsonSchema); // JSON Schema with definitions
-```
-
-### 2) `zod2ProtoV3`
+### 1) `zod2ProtoV3`
 In case of use of Google protobuf to improve communication performance, you can automatically generate `proto` files directly from your models. Check out this [input example](https://github.com/rroumenov/zod-to-x/blob/main/test/test_zod2proto3/proto3_supported_schemas.ts) and its [output](https://github.com/rroumenov/zod-to-x/blob/main/test/test_zod2proto3/proto3_supported_schemas.expect.proto)
 
 - Options:
@@ -575,9 +528,8 @@ In case of use of Google protobuf to improve communication performance, you can
   - ZodTuple is supported only for items of the same type.
 
 ```ts
-import { z } from 'zod';
+import { z } from "zod/v4";
 import { extendZod, Zod2XConverters } from 'zod-to-x';
-import { zodToJsonSchema } from 'zod-to-json-schema';
 extendZod(z);
 
 // Example using model from `Quick-start` section
@@ -602,13 +554,13 @@ For a detailed mapping of supported Zod types across supported targets, please r
 - In Layered modeling, the transpilation of primitive types can be completely disabled or combined by defining them outside the layer class:
 ```ts
 // External primitive
-const stringUUID = z.string().uuid();
+const stringUUID = z.uuid();
 
 @Domain({ namespace: "USER", file: "user.entity" })
 class UserModels extends Zod2XModel {
 
     // Internal primitive
-    userEmail = z.string().email(); // This will be transpiled as an alias. It is a layer property.
+    userEmail = z.email(); // This will be transpiled as an alias. It is a layer property.
 
     userEntity = z.object({
         id: stringUUID, // "stringUUID" will not be transpiled as an alias. It is not a layer property.
@@ -623,7 +575,7 @@ export const userModels = new UserModels();
 ```ts
 // Consider the previous UserModels
 
-import { z } from "zod";
+import { z } from "zod/v4";
 
 @Application({ namespace: "USER_DTOS", file: "user.dtos",  externalInheritance: false})
 class UserDtos extends Zod2XModel {

package/dist/converters/index.d.ts

@@ -1,2 +1 @@
 export { zod2ProtoV3 } from "./protobuf_v3/runner";
-export { zod2JsonSchemaDefinitions } from "./json_schema_definitions";

package/dist/converters/index.js

@@ -1,7 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.zod2JsonSchemaDefinitions = exports.zod2ProtoV3 = void 0;
+exports.zod2ProtoV3 = void 0;
 var runner_1 = require("./protobuf_v3/runner");
 Object.defineProperty(exports, "zod2ProtoV3", { enumerable: true, get: function () { return runner_1.zod2ProtoV3; } });
-var json_schema_definitions_1 = require("./json_schema_definitions");
-Object.defineProperty(exports, "zod2JsonSchemaDefinitions", { enumerable: true, get: function () { return json_schema_definitions_1.zod2JsonSchemaDefinitions; } });

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

@@ -1,6 +1,6 @@
 import { ASTCommon, ASTType } from "./ast_common";
 /**
- * Handle ZodEnum and ZodNativeEnum
+ * Handle ZodEnum
  */
 export declare class ASTEnum extends ASTCommon {
     name: string;

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

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ASTArray = exports.ASTTuple = exports.ASTSet = exports.ASTMap = exports.ASTIntersection = exports.ASTUnion = exports.ASTObject = exports.ASTEnum = void 0;
 const ast_common_1 = require("./ast_common");
 /**
- * Handle ZodEnum and ZodNativeEnum
+ * Handle ZodEnum
  */
 class ASTEnum extends ast_common_1.ASTCommon {
     constructor(data) {

package/dist/core/ast_node.js

@@ -106,22 +106,13 @@ class Zod2Ast {
      *          is either a string or a number.
      */
     _getEnumValues(schema) {
-        if (zod_helpers_1.ZodHelpers.isZodEnum(schema)) {
-            return Object.entries(schema.Enum).map(([key, value]) => {
-                // Creates a string key if it starts with number.
-                key = isNaN(Number(key.at(0))) ? key : `"${key}"`;
-                return [key, value];
-            });
-        }
-        else {
-            return Object.entries(schema.enum)
-                .filter(([key, _value]) => isNaN(Number(key)))
-                .map(([key, value]) => {
-                // Creates a string key if it starts with number.
-                key = isNaN(Number(key.at(0))) ? key : `"${key}"`;
-                return [key, value];
-            });
-        }
+        return Object.entries(schema.enum)
+            .filter(([key, _value]) => isNaN(Number(key)))
+            .map(([key, value]) => {
+            // Creates a string key if it starts with number.
+            key = isNaN(Number(key.at(0))) ? key : `"${key}"`;
+            return [key, value];
+        });
     }
     /**
      * Intersects the properties of two AST nodes and returns the combined properties.
@@ -208,21 +199,26 @@ class Zod2Ast {
         if (!name) {
             let itemProperties = ["Unknown type"];
             if (zod_helpers_1.ZodHelpers.isZodObject(schema)) {
-                itemProperties = Object.keys(schema._def.shape());
+                itemProperties = Object.keys(schema.def.shape);
             }
             else if (zod_helpers_1.ZodHelpers.isZodAnyUnionType(schema)) {
-                itemProperties = schema._def.options.map((i) => { var _a; return ((_a = i._zod2x) === null || _a === void 0 ? void 0 : _a.typeName) || i._def.typeName; });
+                itemProperties = schema.def.options.map((i) => {
+                    var _a;
+                    return ((_a = i._zod2x) === null || _a === void 0 ? void 0 : _a.typeName) || i.def.type;
+                });
             }
             else if (zod_helpers_1.ZodHelpers.isZodIntersection(schema)) {
+                const left = schema.def.left;
+                const right = schema.def.right;
                 itemProperties = [
-                    ((_b = schema._def.left._zod2x) === null || _b === void 0 ? void 0 : _b.typeName) || schema._def.left._def.typeName,
-                    ((_c = schema._def.right._zod2x) === null || _c === void 0 ? void 0 : _c.typeName) || schema._def.right._def.typeName,
+                    ((_b = left._zod2x) === null || _b === void 0 ? void 0 : _b.typeName) || left.def.type,
+                    ((_c = right._zod2x) === null || _c === void 0 ? void 0 : _c.typeName) || right.def.type,
                 ];
             }
-            else if (zod_helpers_1.ZodHelpers.isZodAnyEnumType(schema)) {
+            else if (zod_helpers_1.ZodHelpers.isZodEnum(schema)) {
                 itemProperties = this._getEnumValues(schema).map((i) => i[0]);
             }
-            throw new errors_1.AstTypeNameDefinitionError(`${schema._def.typeName} type must have a typeName. If Layered modeling is used, ` +
+            throw new errors_1.AstTypeNameDefinitionError(`${schema.def.type} type must have a typeName. If Layered modeling is used, ` +
                 `avoid nesting schemas definitions. Otherwise, use zod2x method to provide one. ` +
                 `Affected type properties: ${itemProperties.join(", ")}`);
         }
@@ -238,11 +234,12 @@ class Zod2Ast {
      * @returns The AST definition for the provided enum schema.
      */
     _getEnumAst(schema, opt) {
+        var _a;
         const { name, parentFile, parentNamespace, aliasOf } = this._getNames(schema);
         const item = new core_1.ASTEnum({
             name,
             values: this._getEnumValues(schema),
-            description: schema._def.description,
+            description: (_a = schema.meta()) === null || _a === void 0 ? void 0 : _a.description,
             parentFile,
             parentNamespace,
             aliasOf,
@@ -263,9 +260,10 @@ class Zod2Ast {
      * @returns The AST definition for the provided Zod object schema.
      */
     _getObjectAst(schema, opt) {
+        var _a;
         const { name, parentFile, parentNamespace, aliasOf } = this._getNames(schema);
         let discriminantValue = undefined;
-        const shape = schema._def.shape();
+        const shape = schema.def.shape;
         if (!this.nodes.has(name)) {
             const properties = {};
             for (const key in shape) {
@@ -277,7 +275,7 @@ class Zod2Ast {
             this.nodes.set(name, new core_1.ASTObject({
                 name,
                 properties,
-                description: schema.description,
+                description: (_a = schema.meta()) === null || _a === void 0 ? void 0 : _a.description,
                 parentFile,
                 parentNamespace,
                 aliasOf,
@@ -314,16 +312,17 @@ class Zod2Ast {
      * @returns The AST definition for the given Zod union schema.
      */
     _getUnionAst(schema) {
-        const def = schema._def;
+        var _a, _b, _c;
+        const def = schema.def;
         const discriminator = zod_helpers_1.ZodHelpers.isZodDiscriminatedUnion(schema)
-            ? schema._def.discriminator
+            ? schema.def.discriminator
             : undefined;
         const { name, parentFile, parentNamespace, aliasOf } = this._getNames(schema);
         const item = new core_1.ASTUnion({
             name,
             options: def.options.map((i) => this._zodToAST(i, { discriminantKey: discriminator })),
             areAllObjects: def.options.every((i) => zod_helpers_1.ZodHelpers.isZodObject(i)),
-            description: schema.description,
+            description: (_a = schema.meta()) === null || _a === void 0 ? void 0 : _a.description,
             discriminantKey: discriminator,
             parentFile,
             parentNamespace,
@@ -344,7 +343,7 @@ class Zod2Ast {
             item.newObject = new core_1.ASTObject({
                 name,
                 properties: this._unionAstNodes(item.options).properties,
-                description: (schema.description ? `${schema.description} - ` : "") +
+                description: (((_b = schema.meta()) === null || _b === void 0 ? void 0 : _b.description) ? `${(_c = schema.meta()) === null || _c === void 0 ? void 0 : _c.description} - ` : "") +
                     `Built from union of ` +
                     `${item.options.map((i) => i.name).join(", ")}`,
             });
@@ -362,14 +361,16 @@ class Zod2Ast {
      * @returns An ASTDefinition representing the intersection of the two Zod types.
      */
     _getIntersectionAst(schema) {
-        const def = schema._def;
+        var _a, _b, _c;
+        const def = schema.def;
         const { name, parentFile, parentNamespace, aliasOf } = this._getNames(schema);
         const item = new core_1.ASTIntersection({
             name,
             left: this._zodToAST(def.left),
             right: this._zodToAST(def.right),
-            areAllObjects: zod_helpers_1.ZodHelpers.isZodObject(def.left) && zod_helpers_1.ZodHelpers.isZodObject(def.right),
-            description: schema.description,
+            areAllObjects: zod_helpers_1.ZodHelpers.isZodObject(def.left) &&
+                zod_helpers_1.ZodHelpers.isZodObject(def.right),
+            description: (_a = schema.meta()) === null || _a === void 0 ? void 0 : _a.description,
             parentFile,
             parentNamespace,
             aliasOf,
@@ -385,7 +386,7 @@ class Zod2Ast {
             item.newObject = new core_1.ASTObject({
                 name,
                 properties: this._intersectAstNodes(item.left, item.right).properties,
-                description: (schema.description ? `${schema.description} - ` : "") +
+                description: (((_b = schema.meta()) === null || _b === void 0 ? void 0 : _b.description) ? `${(_c = schema.meta()) === null || _c === void 0 ? void 0 : _c.description} - ` : "") +
                     `Built from intersection of ` +
                     `${item.left.name} and ` +
                     `${item.right.name}`,
@@ -404,11 +405,12 @@ class Zod2Ast {
      * @returns The AST definition for the array schema.
      */
     _getArrayAst(schema, innerSchema) {
+        var _a;
         const { name, parentFile, parentNamespace, aliasOf } = this._getNames(schema);
         const item = new core_1.ASTArray({
             name,
             item: innerSchema,
-            description: schema.description,
+            description: (_a = schema.meta()) === null || _a === void 0 ? void 0 : _a.description,
             parentFile,
             parentNamespace,
             aliasOf,
@@ -439,51 +441,50 @@ class Zod2Ast {
      * @returns
      */
     _zodToAST(schema, opt) {
-        var _a, _b, _c, _d, _e;
-        const def = schema._def;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;
         if (zod_helpers_1.ZodHelpers.isZodString(schema)) {
-            return this._getAliasAst(schema, new core_1.ASTString({ description: schema.description }));
+            return this._getAliasAst(schema, new core_1.ASTString({ description: (_a = schema.meta()) === null || _a === void 0 ? void 0 : _a.description }));
         }
         else if (zod_helpers_1.ZodHelpers.isZodAnyNumberType(schema)) {
             return this._getAliasAst(schema, new core_1.ASTNumber({
-                description: schema.description,
+                description: (_b = schema.meta()) === null || _b === void 0 ? void 0 : _b.description,
                 constraints: zod_helpers_1.ZodHelpers.getZodNumberConstraints(schema),
             }));
         }
         else if (zod_helpers_1.ZodHelpers.isZodBoolean(schema)) {
-            return this._getAliasAst(schema, new core_1.ASTBoolean({ description: schema.description }));
+            return this._getAliasAst(schema, new core_1.ASTBoolean({ description: (_c = schema.meta()) === null || _c === void 0 ? void 0 : _c.description }));
         }
         else if (zod_helpers_1.ZodHelpers.isZodDate(schema)) {
-            return this._getAliasAst(schema, new core_1.ASTDate({ description: schema.description }));
+            return this._getAliasAst(schema, new core_1.ASTDate({ description: (_d = schema.meta()) === null || _d === void 0 ? void 0 : _d.description }));
         }
         else if (zod_helpers_1.ZodHelpers.isZodAny(schema)) {
-            return this._getAliasAst(schema, new core_1.ASTAny({ description: schema.description }));
+            return this._getAliasAst(schema, new core_1.ASTAny({ description: (_e = schema.meta()) === null || _e === void 0 ? void 0 : _e.description }));
         }
         else if (zod_helpers_1.ZodHelpers.isZodNullable(schema)) {
             const subSchema = this._zodToAST(schema.unwrap());
             subSchema.isNullable = true;
-            subSchema.description = schema.description || subSchema.description;
+            subSchema.description = ((_f = schema.meta()) === null || _f === void 0 ? void 0 : _f.description) || subSchema.description;
             return subSchema;
         }
         else if (zod_helpers_1.ZodHelpers.isZodOptional(schema)) {
             const subSchema = this._zodToAST(schema.unwrap());
             subSchema.isOptional = true;
-            subSchema.description = schema.description || subSchema.description;
+            subSchema.description = ((_g = schema.meta()) === null || _g === void 0 ? void 0 : _g.description) || subSchema.description;
             return subSchema;
         }
         else if (zod_helpers_1.ZodHelpers.isZodDefault(schema)) {
-            const subSchema = this._zodToAST(def.innerType);
-            subSchema.description = schema.description || subSchema.description;
+            const subSchema = this._zodToAST(schema.def.defaultValue());
+            subSchema.description = ((_h = schema.meta()) === null || _h === void 0 ? void 0 : _h.description) || subSchema.description;
             return subSchema;
         }
         else if (zod_helpers_1.ZodHelpers.isZodArray(schema)) {
             const isParentArray = (opt === null || opt === void 0 ? void 0 : opt.calledFromArray) !== true;
-            const subSchema = this._zodToAST(def.type, { calledFromArray: true });
-            subSchema.description = schema.description || subSchema.description;
+            const subSchema = this._zodToAST(schema.element, { calledFromArray: true });
+            subSchema.description = ((_j = schema.meta()) === null || _j === void 0 ? void 0 : _j.description) || subSchema.description;
             subSchema.arrayDimension = Number.isInteger(subSchema.arrayDimension)
                 ? ++subSchema.arrayDimension
                 : 1;
-            if (isParentArray && ((_a = schema._zod2x) === null || _a === void 0 ? void 0 : _a.typeName)) {
+            if (isParentArray && ((_k = schema._zod2x) === null || _k === void 0 ? void 0 : _k.typeName)) {
                 return this._getArrayAst(schema, subSchema);
             }
             else {
@@ -492,22 +493,23 @@ class Zod2Ast {
         }
         else if (zod_helpers_1.ZodHelpers.isZodSet(schema)) {
             return this._getAliasAst(schema, new core_1.ASTSet({
-                value: this._zodToAST(def.valueType),
-                description: schema.description,
+                value: this._zodToAST(schema.def.valueType),
+                description: (_l = schema.meta()) === null || _l === void 0 ? void 0 : _l.description,
             }));
         }
         else if (zod_helpers_1.ZodHelpers.isZodLiteral(schema)) {
             let parentEnum = undefined;
             let parentEnumKey = undefined;
-            if ((_b = schema._zod2x) === null || _b === void 0 ? void 0 : _b.parentEnum) {
-                parentEnumKey = (_d = this._getEnumValues((_c = schema._zod2x) === null || _c === void 0 ? void 0 : _c.parentEnum).find((i) => i[1] === def.value)) === null || _d === void 0 ? void 0 : _d[0];
-                parentEnum = this._zodToAST((_e = schema._zod2x) === null || _e === void 0 ? void 0 : _e.parentEnum, {
+            // TODO: Support multiple values
+            if ((_m = schema._zod2x) === null || _m === void 0 ? void 0 : _m.parentEnum) {
+                parentEnumKey = (_p = this._getEnumValues((_o = schema._zod2x) === null || _o === void 0 ? void 0 : _o.parentEnum).find((i) => i[1] === schema.def.values.at(0))) === null || _p === void 0 ? void 0 : _p[0];
+                parentEnum = this._zodToAST((_q = schema._zod2x) === null || _q === void 0 ? void 0 : _q.parentEnum, {
                     isInjectedEnum: true,
                 });
             }
             return new core_1.ASTLiteral({
-                value: def.value,
-                description: schema.description,
+                value: schema.def.values.at(0), // TODO: Support multiple values
+                description: (_r = schema.meta()) === null || _r === void 0 ? void 0 : _r.description,
                 parentEnum: parentEnum,
                 parentEnumKey,
             });
@@ -515,23 +517,23 @@ class Zod2Ast {
         else if (zod_helpers_1.ZodHelpers.isZodAnyMapType(schema)) {
             return this._getAliasAst(schema, new core_1.ASTMap({
                 type: zod_helpers_1.ZodHelpers.isZodRecord(schema) ? "record" : "map",
-                key: this._zodToAST(def.keyType),
-                value: this._zodToAST(def.valueType),
-                description: schema.description,
+                key: this._zodToAST(schema.keyType),
+                value: this._zodToAST(schema.valueType),
+                description: (_s = schema.meta()) === null || _s === void 0 ? void 0 : _s.description,
             }));
         }
         else if (zod_helpers_1.ZodHelpers.isZodLazy(schema)) {
             /** Lazy items use to be recursive schemas of its own, so the are trated as another
              *  definition */
-            const lazySchema = def.getter();
+            const lazySchema = schema.def.getter();
             const lazyPointer = this._createDefinition({ name: "pending" });
             this.lazyPointers.push([lazyPointer, lazySchema]);
             return lazyPointer;
         }
         else if (zod_helpers_1.ZodHelpers.isZodTuple(schema)) {
             return this._getAliasAst(schema, new core_1.ASTTuple({
-                items: def.items.map(this._zodToAST.bind(this)),
-                description: schema.description,
+                items: schema.def.items.map(this._zodToAST.bind(this)),
+                description: (_t = schema.meta()) === null || _t === void 0 ? void 0 : _t.description,
             }));
             /**
              *
@@ -541,7 +543,7 @@ class Zod2Ast {
              *
              * */
         }
-        else if (zod_helpers_1.ZodHelpers.isZodAnyEnumType(schema)) {
+        else if (zod_helpers_1.ZodHelpers.isZodEnum(schema)) {
             return this._getEnumAst(schema, opt);
         }
         else if (zod_helpers_1.ZodHelpers.isZodObject(schema)) {
@@ -556,7 +558,7 @@ class Zod2Ast {
         else {
             logger_1.log.warn(`Unsupported Zod type: ${JSON.stringify(schema)}`);
             return new core_1.ASTAny({
-                description: `Unsupported Zod type: ${schema._def.typeName}`,
+                description: `Unsupported Zod type: ${schema.def.type}`,
             });
         }
     }