@miroir-framework/jzod-ts 0.5.2 → 0.5.3

package/dist/bundle.d.ts

@@ -9,10 +9,10 @@ declare const jzodRootSchema: z.ZodObject<{
     optional?: boolean | undefined;
 }>;
 type JzodRoot = z.infer<typeof jzodRootSchema>;
-declare const jzodEnumAttributeTypesSchema: z.ZodEnum<["any", "bigint", "boolean", "date", "never", "null", "number", "string", "uuid", "undefined", "unknown", "void"]>;
-type JzodEnumTypes = z.infer<typeof jzodEnumAttributeTypesSchema>;
-declare const jzodEnumElementTypesSchema: z.ZodEnum<["array", "enum", "function", "lazy", "literal", "intersection", "map", "object", "promise", "record", "schemaReference", "set", "simpleType", "tuple", "union"]>;
-type JzodEnumElementTypes = z.infer<typeof jzodEnumElementTypesSchema>;
+declare const jzodEnumAttributeTypes: z.ZodEnum<["any", "bigint", "boolean", "date", "never", "null", "number", "string", "uuid", "undefined", "unknown", "void"]>;
+type JzodEnumTypes = z.infer<typeof jzodEnumAttributeTypes>;
+declare const jzodEnumElementTypes: z.ZodEnum<["array", "enum", "function", "lazy", "literal", "intersection", "map", "object", "promise", "record", "schemaReference", "set", "simpleType", "tuple", "union"]>;
+type JzodEnumElementTypes = z.infer<typeof jzodEnumElementTypes>;
 interface JzodArray extends JzodRoot {
     optional?: boolean;
     nullable?: boolean;
@@ -22,8 +22,8 @@ interface JzodArray extends JzodRoot {
     type: 'array';
     definition: JzodElement;
 }
-declare const jzodArraySchema: z.ZodType<JzodArray>;
-declare const jzodAttributeDateValidationsSchema: z.ZodObject<{
+declare const jzodArray: z.ZodType<JzodArray>;
+declare const jzodAttributeDateValidations: z.ZodObject<{
     extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
     type: z.ZodEnum<["min", "max"]>;
     parameter: z.ZodAny;
@@ -36,8 +36,8 @@ declare const jzodAttributeDateValidationsSchema: z.ZodObject<{
     extra?: Record<string, any> | undefined;
     parameter?: any;
 }>;
-type JzodAttributeDateValidations = z.infer<typeof jzodAttributeDateValidationsSchema>;
-declare const jzodAttributeNumberValidationsSchema: z.ZodObject<{
+type JzodAttributeDateValidations = z.infer<typeof jzodAttributeDateValidations>;
+declare const jzodAttributeNumberValidations: z.ZodObject<{
     extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
     type: z.ZodEnum<["gt", "gte", "lt", "lte", "int", "positive", "nonpositive", "negative", "nonnegative", "multipleOf", "finite", "safe"]>;
     parameter: z.ZodAny;
@@ -50,8 +50,8 @@ declare const jzodAttributeNumberValidationsSchema: z.ZodObject<{
     extra?: Record<string, any> | undefined;
     parameter?: any;
 }>;
-type JzodAttributeNumberValidations = z.infer<typeof jzodAttributeNumberValidationsSchema>;
-declare const jzodAttributeStringValidationsSchema: z.ZodObject<{
+type JzodAttributeNumberValidations = z.infer<typeof jzodAttributeNumberValidations>;
+declare const jzodAttributeStringValidations: z.ZodObject<{
     extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
     type: z.ZodEnum<["max", "min", "length", "email", "url", "emoji", "uuid", "cuid", "cuid2", "ulid", "regex", "includes", "startsWith", "endsWith", "datetime", "ip"]>;
     parameter: z.ZodAny;
@@ -64,8 +64,8 @@ declare const jzodAttributeStringValidationsSchema: z.ZodObject<{
     extra?: Record<string, any> | undefined;
     parameter?: any;
 }>;
-type JzodAttributeStringValidations = z.infer<typeof jzodAttributeStringValidationsSchema>;
-declare const jzodAttributeDateWithValidationsSchema: z.ZodObject<{
+type JzodAttributeStringValidations = z.infer<typeof jzodAttributeStringValidations>;
+declare const jzodAttributeDateWithValidations: z.ZodObject<{
     optional: z.ZodOptional<z.ZodBoolean>;
     nullable: z.ZodOptional<z.ZodBoolean>;
     extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
@@ -110,8 +110,8 @@ declare const jzodAttributeDateWithValidationsSchema: z.ZodObject<{
     extra?: Record<string, any> | undefined;
     coerce?: boolean | undefined;
 }>;
-type JzodAttributeDateWithValidations = z.infer<typeof jzodAttributeDateWithValidationsSchema>;
-declare const jzodAttributeNumberWithValidationsSchema: z.ZodObject<{
+type JzodAttributeDateWithValidations = z.infer<typeof jzodAttributeDateWithValidations>;
+declare const jzodAttributeNumberWithValidations: z.ZodObject<{
     optional: z.ZodOptional<z.ZodBoolean>;
     nullable: z.ZodOptional<z.ZodBoolean>;
     extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
@@ -156,8 +156,8 @@ declare const jzodAttributeNumberWithValidationsSchema: z.ZodObject<{
     extra?: Record<string, any> | undefined;
     coerce?: boolean | undefined;
 }>;
-type JzodAttributeNumberWithValidations = z.infer<typeof jzodAttributeNumberWithValidationsSchema>;
-declare const jzodAttributeStringWithValidationsSchema: z.ZodObject<{
+type JzodAttributeNumberWithValidations = z.infer<typeof jzodAttributeNumberWithValidations>;
+declare const jzodAttributeStringWithValidations: z.ZodObject<{
     optional: z.ZodOptional<z.ZodBoolean>;
     nullable: z.ZodOptional<z.ZodBoolean>;
     extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
@@ -202,8 +202,8 @@ declare const jzodAttributeStringWithValidationsSchema: z.ZodObject<{
     extra?: Record<string, any> | undefined;
     coerce?: boolean | undefined;
 }>;
-type JzodAttributeStringWithValidations = z.infer<typeof jzodAttributeStringWithValidationsSchema>;
-declare const jzodAttributeSchema: z.ZodObject<{
+type JzodAttributeStringWithValidations = z.infer<typeof jzodAttributeStringWithValidations>;
+declare const jzodAttribute: z.ZodObject<{
     optional: z.ZodOptional<z.ZodBoolean>;
     nullable: z.ZodOptional<z.ZodBoolean>;
     extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
@@ -225,10 +225,10 @@ declare const jzodAttributeSchema: z.ZodObject<{
     extra?: Record<string, any> | undefined;
     coerce?: boolean | undefined;
 }>;
-type JzodAttribute = z.infer<typeof jzodAttributeSchema>;
+type JzodAttribute = z.infer<typeof jzodAttribute>;
 type JzodElement = JzodArray | JzodAttribute | JzodAttributeDateWithValidations | JzodAttributeNumberWithValidations | JzodAttributeStringWithValidations | JzodEnum | JzodFunction | JzodLazy | JzodLiteral | JzodIntersection | JzodMap | JzodRecord | JzodObject | JzodPromise | JzodReference | JzodSet | JzodTuple | JzodUnion;
-declare const jzodElementSchema: z.ZodType<JzodElement>;
-declare const jzodEnumSchema: z.ZodObject<{
+declare const jzodElement: z.ZodType<JzodElement>;
+declare const jzodEnum: z.ZodObject<{
     optional: z.ZodOptional<z.ZodBoolean>;
     nullable: z.ZodOptional<z.ZodBoolean>;
     extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
@@ -247,7 +247,7 @@ declare const jzodEnumSchema: z.ZodObject<{
     nullable?: boolean | undefined;
     extra?: Record<string, any> | undefined;
 }>;
-type JzodEnum = z.infer<typeof jzodEnumSchema>;
+type JzodEnum = z.infer<typeof jzodEnum>;
 interface JzodFunction {
     extra?: {
         [k: string]: any;
@@ -258,8 +258,8 @@ interface JzodFunction {
         returns?: JzodElement;
     };
 }
-declare const jzodFunctionSchema: ZodType<JzodFunction>;
-declare const jzodLazySchema: z.ZodObject<{
+declare const jzodFunction: ZodType<JzodFunction>;
+declare const jzodLazy: z.ZodObject<{
     type: z.ZodLiteral<"lazy">;
     extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
     definition: ZodType<JzodFunction, z.ZodTypeDef, JzodFunction>;
@@ -272,8 +272,8 @@ declare const jzodLazySchema: z.ZodObject<{
     definition: JzodFunction;
     extra?: Record<string, any> | undefined;
 }>;
-type JzodLazy = z.infer<typeof jzodLazySchema>;
-declare const jzodLiteralSchema: z.ZodObject<{
+type JzodLazy = z.infer<typeof jzodLazy>;
+declare const jzodLiteral: z.ZodObject<{
     optional: z.ZodOptional<z.ZodBoolean>;
     nullable: z.ZodOptional<z.ZodBoolean>;
     extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
@@ -292,7 +292,7 @@ declare const jzodLiteralSchema: z.ZodObject<{
     nullable?: boolean | undefined;
     extra?: Record<string, any> | undefined;
 }>;
-type JzodLiteral = z.infer<typeof jzodLiteralSchema>;
+type JzodLiteral = z.infer<typeof jzodLiteral>;
 interface JzodIntersection {
     optional?: boolean;
     nullable?: boolean;
@@ -305,7 +305,7 @@ interface JzodIntersection {
         right: JzodElement;
     };
 }
-declare const jzodIntersectionSchema: z.ZodType<JzodIntersection>;
+declare const jzodIntersection: z.ZodType<JzodIntersection>;
 interface JzodMap extends JzodRoot {
     optional?: boolean;
     nullable?: boolean;
@@ -329,7 +329,7 @@ interface JzodObject extends JzodRoot {
         [attributeName: string]: JzodElement;
     };
 }
-declare const jzodObjectSchema: z.ZodType<JzodObject>;
+declare const jzodObject: z.ZodType<JzodObject>;
 interface JzodPromise extends JzodRoot {
     extra?: {
         [k: string]: any;
@@ -337,7 +337,7 @@ interface JzodPromise extends JzodRoot {
     type: 'promise';
     definition: JzodElement;
 }
-declare const jzodPromiseSchema: z.ZodType<JzodPromise>;
+declare const jzodPromise: z.ZodType<JzodPromise>;
 interface JzodRecord {
     optional?: boolean;
     nullable?: boolean;
@@ -347,7 +347,7 @@ interface JzodRecord {
     type: 'record';
     definition: JzodElement;
 }
-declare const jzodRecordSchema: z.ZodType<JzodRecord>;
+declare const jzodRecord: z.ZodType<JzodRecord>;
 interface JzodReference {
     optional?: boolean;
     nullable?: boolean;
@@ -364,7 +364,7 @@ interface JzodReference {
         absolutePath?: string;
     };
 }
-declare const jzodReferenceSchema: ZodType<JzodReference>;
+declare const jzodReference: ZodType<JzodReference>;
 interface JzodSet extends JzodRoot {
     optional?: boolean;
     nullable?: boolean;
@@ -374,7 +374,7 @@ interface JzodSet extends JzodRoot {
     type: 'set';
     definition: JzodElement;
 }
-declare const jzodSetSchema: z.ZodType<JzodSet>;
+declare const jzodSet: z.ZodType<JzodSet>;
 interface JzodTuple {
     optional?: boolean;
     nullable?: boolean;
@@ -384,7 +384,7 @@ interface JzodTuple {
     type: 'tuple';
     definition: JzodElement[];
 }
-declare const jzodTupleSchema: z.ZodType<JzodTuple>;
+declare const jzodTuple: z.ZodType<JzodTuple>;
 interface JzodUnion {
     optional?: boolean;
     nullable?: boolean;
@@ -395,7 +395,7 @@ interface JzodUnion {
     discriminator?: string;
     definition: JzodElement[];
 }
-declare const jzodUnionSchema: z.ZodType<JzodUnion>;
+declare const jzodUnion: z.ZodType<JzodUnion>;
 
 type TsTypeAliases = {
     [k: string]: ts.TypeAliasDeclaration;
@@ -416,4 +416,4 @@ declare function jzodToTsCode(jzodElement: JzodElement, exportPrefix?: boolean,
 declare function printTsTypeAlias(typeAlias: ts.TypeAliasDeclaration, exportPrefix?: boolean): string;
 declare function printTsTypeAliases(typeAliases: TsTypeAliases, exportPrefix?: boolean): string;
 
-export { JzodArray, JzodAttribute, JzodAttributeDateValidations, JzodAttributeDateWithValidations, JzodAttributeNumberValidations, JzodAttributeNumberWithValidations, JzodAttributeStringValidations, JzodAttributeStringWithValidations, JzodElement, JzodEnum, JzodEnumElementTypes, JzodEnumTypes, JzodFunction, JzodIntersection, JzodLazy, JzodLiteral, JzodMap, JzodObject, JzodPromise, JzodRecord, JzodReference, JzodSet, JzodTuple, TsTypeAliasesAndZodText as JzodTypeAliasesAndZodText, JzodUnion, TsTypeAliases, jzodArraySchema, jzodAttributeDateValidationsSchema, jzodAttributeDateWithValidationsSchema, jzodAttributeNumberValidationsSchema, jzodAttributeNumberWithValidationsSchema, jzodAttributeSchema, jzodAttributeStringValidationsSchema, jzodAttributeStringWithValidationsSchema, jzodElementSchema, jzodEnumAttributeTypesSchema, jzodEnumElementTypesSchema, jzodEnumSchema, jzodFunctionSchema, jzodIntersectionSchema, jzodLazySchema, jzodLiteralSchema, jzodMapSchema, jzodObjectSchema, jzodPromiseSchema, jzodRecordSchema, jzodReferenceSchema, jzodSetSchema, jzodToTsCode, jzodToTsTypeAliasesAndZodText, jzodTupleSchema, jzodUnionSchema, printTsTypeAlias, printTsTypeAliases };
+export { JzodArray, JzodAttribute, JzodAttributeDateValidations, JzodAttributeDateWithValidations, JzodAttributeNumberValidations, JzodAttributeNumberWithValidations, JzodAttributeStringValidations, JzodAttributeStringWithValidations, JzodElement, JzodEnum, JzodEnumElementTypes, JzodEnumTypes, JzodFunction, JzodIntersection, JzodLazy, JzodLiteral, JzodMap, JzodObject, JzodPromise, JzodRecord, JzodReference, JzodSet, JzodTuple, TsTypeAliasesAndZodText as JzodTypeAliasesAndZodText, JzodUnion, TsTypeAliases, jzodArray, jzodAttribute, jzodAttributeDateValidations, jzodAttributeDateWithValidations, jzodAttributeNumberValidations, jzodAttributeNumberWithValidations, jzodAttributeStringValidations, jzodAttributeStringWithValidations, jzodElement, jzodEnum, jzodEnumAttributeTypes, jzodEnumElementTypes, jzodFunction, jzodIntersection, jzodLazy, jzodLiteral, jzodMapSchema, jzodObject, jzodPromise, jzodRecord, jzodReference, jzodSet, jzodToTsCode, jzodToTsTypeAliasesAndZodText, jzodTuple, jzodUnion, printTsTypeAlias, printTsTypeAliases };

package/dist/bundle.js

@@ -16,11 +16,13 @@ ${printTsTypeAlias(curr[1], exportPrefix)}`;
 function jzodToTsTypeAliasesAndZodText(element, typeName) {
     var _a, _b;
     const elementZodSchemaAndDescription = jzodElementSchemaToZodSchemaAndDescription(element, () => ({}), () => ({}), (innerReference, relativeReference) => withGetType(innerReference, (ts) => {
-        return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(relativeReference ? relativeReference : "RELATIVEPATH_NOT_DEFINED"));
+        const actualTypeName = relativeReference ? relativeReference.replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c) : "";
+        return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(actualTypeName ? actualTypeName : "RELATIVEPATH_NOT_DEFINED"));
     }));
     const contextTsTypesString = Object.fromEntries(Object.entries((_a = elementZodSchemaAndDescription.contextZodSchema) !== null && _a !== void 0 ? _a : {}).map((curr) => {
+        const actualTypeName = curr[0] ? curr[0].replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c) : "";
         const tsNode = zodToTs(curr[1], typeName).node;
-        const typeAlias = createTypeAlias(tsNode, curr[0]);
+        const typeAlias = createTypeAlias(tsNode, actualTypeName);
         return [curr[0], typeAlias];
     }));
     const tsTypeStringNode = zodToTs(elementZodSchemaAndDescription.zodSchema, typeName).node;
@@ -34,14 +36,16 @@ function jzodToTsTypeAliasesAndZodText(element, typeName) {
 }
 function jzodToTsCode(jzodElement, exportPrefix = true, typeName) {
     const schemaName = typeName ? typeName.replace(/^(.)(.*)$/, (a, b, c) => b.toLowerCase() + c) : "";
+    const actualTypeName = typeName ? typeName.replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c) : "";
     const header = `import { ZodType, ZodTypeAny, z } from "zod";`;
-    const typeAliasesAndZodText = jzodToTsTypeAliasesAndZodText(jzodElement, typeName);
-    const bodyJsCode = `export const ${schemaName}: z.ZodType<${schemaName}> = ${typeAliasesAndZodText.mainZodText};`;
+    const typeAliasesAndZodText = jzodToTsTypeAliasesAndZodText(jzodElement, actualTypeName);
+    const bodyJsCode = `export const ${schemaName}: z.ZodType<${actualTypeName}> = ${typeAliasesAndZodText.mainZodText};`;
     const contextTsTypesString = printTsTypeAliases(typeAliasesAndZodText.contextTsTypeAliases, exportPrefix);
     const contextJsCode = typeAliasesAndZodText.contextZodText
         ? Object.entries(typeAliasesAndZodText.contextZodText).reduce((acc, curr) => {
+            const contextTypeName = curr[0] ? curr[0].replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c) : "";
             return `${acc}
-export const ${curr[0]}:z.ZodType<${curr[0]}> = ${curr[1]};`;
+export const ${curr[0]}:z.ZodType<${contextTypeName}> = ${curr[1]};`;
         }, "")
         : "";
     const tsTypesString = (exportPrefix ? "export " : "") + printNode(typeAliasesAndZodText.mainTsTypeAlias);
@@ -56,7 +60,7 @@ ${bodyJsCode}
 z.object({
     optional: z.boolean().optional(),
 }).strict();
-const jzodEnumAttributeTypesSchema = z.enum([
+const jzodEnumAttributeTypes = z.enum([
     "any",
     "bigint",
     "boolean",
@@ -70,7 +74,7 @@ const jzodEnumAttributeTypesSchema = z.enum([
     "unknown",
     "void",
 ]);
-const jzodEnumElementTypesSchema = z.enum([
+const jzodEnumElementTypes = z.enum([
     "array",
     "enum",
     "function",
@@ -87,14 +91,14 @@ const jzodEnumElementTypesSchema = z.enum([
     "tuple",
     "union",
 ]);
-const jzodArraySchema = z.object({
+const jzodArray = z.object({
     optional: z.boolean().optional(),
     nullable: z.boolean().optional(),
     extra: z.record(z.string(), z.any()).optional(),
     type: z.literal('array'),
-    definition: z.lazy(() => jzodElementSchema)
+    definition: z.lazy(() => jzodElement)
 }).strict();
-const jzodAttributeDateValidationsSchema = z
+const jzodAttributeDateValidations = z
     .object({
     extra: z.record(z.string(), z.any()).optional(),
     type: z.enum([
@@ -104,7 +108,7 @@ const jzodAttributeDateValidationsSchema = z
     parameter: z.any(),
 })
     .strict();
-const jzodAttributeNumberValidationsSchema = z
+const jzodAttributeNumberValidations = z
     .object({
     extra: z.record(z.string(), z.any()).optional(),
     type: z.enum([
@@ -124,7 +128,7 @@ const jzodAttributeNumberValidationsSchema = z
     parameter: z.any(),
 })
     .strict();
-const jzodAttributeStringValidationsSchema = z
+const jzodAttributeStringValidations = z
     .object({
     extra: z.record(z.string(), z.any()).optional(),
     type: z.enum([
@@ -148,156 +152,156 @@ const jzodAttributeStringValidationsSchema = z
     parameter: z.any(),
 })
     .strict();
-const jzodAttributeDateWithValidationsSchema = z.object({
+const jzodAttributeDateWithValidations = z.object({
     optional: z.boolean().optional(),
     nullable: z.boolean().optional(),
     extra: z.record(z.string(), z.any()).optional(),
     coerce: z.boolean().optional(),
-    type: z.literal(jzodEnumElementTypesSchema.enum.simpleType),
-    definition: z.literal(jzodEnumAttributeTypesSchema.enum.date),
-    validations: z.array(jzodAttributeDateValidationsSchema),
+    type: z.literal(jzodEnumElementTypes.enum.simpleType),
+    definition: z.literal(jzodEnumAttributeTypes.enum.date),
+    validations: z.array(jzodAttributeDateValidations),
 }).strict();
-const jzodAttributeNumberWithValidationsSchema = z.object({
+const jzodAttributeNumberWithValidations = z.object({
     optional: z.boolean().optional(),
     nullable: z.boolean().optional(),
     extra: z.record(z.string(), z.any()).optional(),
     coerce: z.boolean().optional(),
-    type: z.literal(jzodEnumElementTypesSchema.enum.simpleType),
-    definition: z.literal(jzodEnumAttributeTypesSchema.enum.number),
-    validations: z.array(jzodAttributeNumberValidationsSchema),
+    type: z.literal(jzodEnumElementTypes.enum.simpleType),
+    definition: z.literal(jzodEnumAttributeTypes.enum.number),
+    validations: z.array(jzodAttributeNumberValidations),
 }).strict();
-const jzodAttributeStringWithValidationsSchema = z.object({
+const jzodAttributeStringWithValidations = z.object({
     optional: z.boolean().optional(),
     nullable: z.boolean().optional(),
     extra: z.record(z.string(), z.any()).optional(),
     coerce: z.boolean().optional(),
-    type: z.literal(jzodEnumElementTypesSchema.enum.simpleType),
-    definition: z.literal(jzodEnumAttributeTypesSchema.enum.string),
-    validations: z.array(jzodAttributeStringValidationsSchema),
+    type: z.literal(jzodEnumElementTypes.enum.simpleType),
+    definition: z.literal(jzodEnumAttributeTypes.enum.string),
+    validations: z.array(jzodAttributeStringValidations),
 }).strict();
-const jzodAttributeSchema = z.object({
+const jzodAttribute = z.object({
     optional: z.boolean().optional(),
     nullable: z.boolean().optional(),
     extra: z.record(z.string(), z.any()).optional(),
     coerce: z.boolean().optional(),
-    type: z.literal(jzodEnumElementTypesSchema.enum.simpleType),
-    definition: z.lazy(() => jzodEnumAttributeTypesSchema),
+    type: z.literal(jzodEnumElementTypes.enum.simpleType),
+    definition: z.lazy(() => jzodEnumAttributeTypes),
 }).strict();
-const jzodElementSchema = z.union([
-    z.lazy(() => jzodArraySchema),
-    z.lazy(() => jzodAttributeSchema),
-    z.lazy(() => jzodAttributeDateWithValidationsSchema),
-    z.lazy(() => jzodAttributeNumberWithValidationsSchema),
-    z.lazy(() => jzodAttributeStringWithValidationsSchema),
-    z.lazy(() => jzodEnumSchema),
-    z.lazy(() => jzodFunctionSchema),
-    z.lazy(() => jzodLazySchema),
-    z.lazy(() => jzodLiteralSchema),
-    z.lazy(() => jzodIntersectionSchema),
+const jzodElement = z.union([
+    z.lazy(() => jzodArray),
+    z.lazy(() => jzodAttribute),
+    z.lazy(() => jzodAttributeDateWithValidations),
+    z.lazy(() => jzodAttributeNumberWithValidations),
+    z.lazy(() => jzodAttributeStringWithValidations),
+    z.lazy(() => jzodEnum),
+    z.lazy(() => jzodFunction),
+    z.lazy(() => jzodLazy),
+    z.lazy(() => jzodLiteral),
+    z.lazy(() => jzodIntersection),
     z.lazy(() => jzodMapSchema),
-    z.lazy(() => jzodObjectSchema),
-    z.lazy(() => jzodPromiseSchema),
-    z.lazy(() => jzodRecordSchema),
-    z.lazy(() => jzodReferenceSchema),
-    z.lazy(() => jzodSetSchema),
-    z.lazy(() => jzodTupleSchema),
-    z.lazy(() => jzodUnionSchema),
+    z.lazy(() => jzodObject),
+    z.lazy(() => jzodPromise),
+    z.lazy(() => jzodRecord),
+    z.lazy(() => jzodReference),
+    z.lazy(() => jzodSet),
+    z.lazy(() => jzodTuple),
+    z.lazy(() => jzodUnion),
 ]);
-const jzodEnumSchema = z.object({
+const jzodEnum = z.object({
     optional: z.boolean().optional(),
     nullable: z.boolean().optional(),
     extra: z.record(z.string(), z.any()).optional(),
-    type: z.literal(jzodEnumElementTypesSchema.enum.enum),
+    type: z.literal(jzodEnumElementTypes.enum.enum),
     definition: z.array(z.string()),
 }).strict();
-const jzodFunctionSchema = z.object({
-    type: z.literal(jzodEnumElementTypesSchema.enum.function),
+const jzodFunction = z.object({
+    type: z.literal(jzodEnumElementTypes.enum.function),
     extra: z.record(z.string(), z.any()).optional(),
     definition: z.object({
-        args: z.array(jzodElementSchema),
-        returns: jzodElementSchema.optional(),
+        args: z.array(jzodElement),
+        returns: jzodElement.optional(),
     })
 }).strict();
-const jzodLazySchema = z.object({
-    type: z.literal(jzodEnumElementTypesSchema.enum.lazy),
+const jzodLazy = z.object({
+    type: z.literal(jzodEnumElementTypes.enum.lazy),
     extra: z.record(z.string(), z.any()).optional(),
-    definition: jzodFunctionSchema,
+    definition: jzodFunction,
 }).strict();
-const jzodLiteralSchema = z.object({
+const jzodLiteral = z.object({
     optional: z.boolean().optional(),
     nullable: z.boolean().optional(),
     extra: z.record(z.string(), z.any()).optional(),
-    type: z.literal(jzodEnumElementTypesSchema.enum.literal),
+    type: z.literal(jzodEnumElementTypes.enum.literal),
     definition: z.string(),
 }).strict();
-const jzodIntersectionSchema = z.object({
+const jzodIntersection = z.object({
     optional: z.boolean().optional(),
     nullable: z.boolean().optional(),
     extra: z.record(z.string(), z.any()).optional(),
-    type: z.literal(jzodEnumElementTypesSchema.enum.intersection),
-    definition: z.lazy(() => z.object({ left: jzodElementSchema, right: jzodElementSchema }))
+    type: z.literal(jzodEnumElementTypes.enum.intersection),
+    definition: z.lazy(() => z.object({ left: jzodElement, right: jzodElement }))
 }).strict();
 const jzodMapSchema = z.object({
     optional: z.boolean().optional(),
     nullable: z.boolean().optional(),
     extra: z.record(z.string(), z.any()).optional(),
     type: z.literal('map'),
-    definition: z.lazy(() => z.tuple([jzodElementSchema, jzodElementSchema]))
+    definition: z.lazy(() => z.tuple([jzodElement, jzodElement]))
 }).strict();
-const jzodObjectSchema = z.object({
+const jzodObject = z.object({
     optional: z.boolean().optional(),
     nullable: z.boolean().optional(),
-    extend: z.lazy(() => z.union([jzodReferenceSchema, jzodObjectSchema])).optional(),
+    extend: z.lazy(() => z.union([jzodReference, jzodObject])).optional(),
     extra: z.record(z.string(), z.any()).optional(),
-    type: z.literal(jzodEnumElementTypesSchema.enum.object),
+    type: z.literal(jzodEnumElementTypes.enum.object),
     nonStrict: z.boolean().optional(),
-    definition: z.lazy(() => z.record(z.string(), jzodElementSchema)),
+    definition: z.lazy(() => z.record(z.string(), jzodElement)),
 }).strict();
-const jzodPromiseSchema = z.object({
+const jzodPromise = z.object({
     extra: z.record(z.string(), z.any()).optional(),
     type: z.literal('promise'),
-    definition: z.lazy(() => jzodElementSchema)
+    definition: z.lazy(() => jzodElement)
 }).strict();
-const jzodRecordSchema = z.object({
+const jzodRecord = z.object({
     optional: z.boolean().optional(),
     nullable: z.boolean().optional(),
     extra: z.record(z.string(), z.any()).optional(),
-    type: z.literal(jzodEnumElementTypesSchema.enum.record),
-    definition: z.lazy(() => jzodElementSchema)
+    type: z.literal(jzodEnumElementTypes.enum.record),
+    definition: z.lazy(() => jzodElement)
 }).strict();
-const jzodReferenceSchema = z.object({
+const jzodReference = z.object({
     optional: z.boolean().optional(),
     nullable: z.boolean().optional(),
     extra: z.record(z.string(), z.any()).optional(),
-    type: z.literal(jzodEnumElementTypesSchema.enum.schemaReference),
-    context: z.lazy(() => z.record(z.string(), jzodElementSchema)).optional(),
+    type: z.literal(jzodEnumElementTypes.enum.schemaReference),
+    context: z.lazy(() => z.record(z.string(), jzodElement)).optional(),
     definition: z.object({
         eager: z.boolean().optional(),
         relativePath: z.string().optional(),
         absolutePath: z.string().optional(),
     })
 }).strict();
-const jzodSetSchema = z.object({
+const jzodSet = z.object({
     optional: z.boolean().optional(),
     nullable: z.boolean().optional(),
     extra: z.record(z.string(), z.any()).optional(),
     type: z.literal('set'),
-    definition: z.lazy(() => jzodElementSchema)
+    definition: z.lazy(() => jzodElement)
 }).strict();
-const jzodTupleSchema = z.object({
+const jzodTuple = z.object({
     optional: z.boolean().optional(),
     nullable: z.boolean().optional(),
     extra: z.record(z.string(), z.any()).optional(),
-    type: z.literal(jzodEnumElementTypesSchema.enum.tuple),
-    definition: z.array(jzodElementSchema),
+    type: z.literal(jzodEnumElementTypes.enum.tuple),
+    definition: z.array(jzodElement),
 }).strict();
-const jzodUnionSchema = z.object({
+const jzodUnion = z.object({
     optional: z.boolean().optional(),
     nullable: z.boolean().optional(),
     extra: z.record(z.string(), z.any()).optional(),
-    type: z.literal(jzodEnumElementTypesSchema.enum.union),
+    type: z.literal(jzodEnumElementTypes.enum.union),
     discriminator: z.string().optional(),
-    definition: z.lazy(() => z.array(jzodElementSchema))
+    definition: z.lazy(() => z.array(jzodElement))
 }).strict();
 
-export { jzodArraySchema, jzodAttributeDateValidationsSchema, jzodAttributeDateWithValidationsSchema, jzodAttributeNumberValidationsSchema, jzodAttributeNumberWithValidationsSchema, jzodAttributeSchema, jzodAttributeStringValidationsSchema, jzodAttributeStringWithValidationsSchema, jzodElementSchema, jzodEnumAttributeTypesSchema, jzodEnumElementTypesSchema, jzodEnumSchema, jzodFunctionSchema, jzodIntersectionSchema, jzodLazySchema, jzodLiteralSchema, jzodMapSchema, jzodObjectSchema, jzodPromiseSchema, jzodRecordSchema, jzodReferenceSchema, jzodSetSchema, jzodToTsCode, jzodToTsTypeAliasesAndZodText, jzodTupleSchema, jzodUnionSchema, printTsTypeAlias, printTsTypeAliases };
+export { jzodArray, jzodAttribute, jzodAttributeDateValidations, jzodAttributeDateWithValidations, jzodAttributeNumberValidations, jzodAttributeNumberWithValidations, jzodAttributeStringValidations, jzodAttributeStringWithValidations, jzodElement, jzodEnum, jzodEnumAttributeTypes, jzodEnumElementTypes, jzodFunction, jzodIntersection, jzodLazy, jzodLiteral, jzodMapSchema, jzodObject, jzodPromise, jzodRecord, jzodReference, jzodSet, jzodToTsCode, jzodToTsTypeAliasesAndZodText, jzodTuple, jzodUnion, printTsTypeAlias, printTsTypeAliases };