@miroir-framework/jzod-ts 0.5.1 → 0.5.3

package/dist/bundle.js

@@ -2,302 +2,306 @@ import { printNode, withGetType, zodToTs, createTypeAlias } from 'zod-to-ts';
 import { jzodElementSchemaToZodSchemaAndDescription } from '@miroir-framework/jzod';
 import { z } from 'zod';
 
-function printTsTypeAlias(typeAlias, exportPrefix = true) {
-    return (exportPrefix ? "export " : "") + printNode(typeAlias);
-}
-function printTsTypeAliases(typeAliases, exportPrefix = true) {
-    const result = Object.entries(typeAliases).reduce((acc, curr) => {
-        return `${acc}
-${printTsTypeAlias(curr[1], exportPrefix)}`;
-    }, "");
-    return result;
+function printTsTypeAlias(typeAlias, exportPrefix = true) {
+    return (exportPrefix ? "export " : "") + printNode(typeAlias);
+}
+function printTsTypeAliases(typeAliases, exportPrefix = true) {
+    const result = Object.entries(typeAliases).reduce((acc, curr) => {
+        return `${acc}
+${printTsTypeAlias(curr[1], exportPrefix)}`;
+    }, "");
+    return result;
 }
 
-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 contextTsTypesString = Object.fromEntries(Object.entries((_a = elementZodSchemaAndDescription.contextZodSchema) !== null && _a !== void 0 ? _a : {}).map((curr) => {
-        const tsNode = zodToTs(curr[1], typeName).node;
-        const typeAlias = createTypeAlias(tsNode, curr[0]);
-        return [curr[0], typeAlias];
-    }));
-    const tsTypeStringNode = zodToTs(elementZodSchemaAndDescription.zodSchema, typeName).node;
-    const tsTypeStringTypeAlias = createTypeAlias(tsTypeStringNode, typeName !== null && typeName !== void 0 ? typeName : "");
-    return {
-        contextTsTypeAliases: contextTsTypesString,
-        contextZodText: (_b = elementZodSchemaAndDescription.contextZodText) !== null && _b !== void 0 ? _b : {},
-        mainZodText: elementZodSchemaAndDescription.zodText,
-        mainTsTypeAlias: tsTypeStringTypeAlias,
-    };
-}
-function jzodToTsCode(jzodElement, exportPrefix = true, typeName) {
-    const schemaName = typeName ? typeName.replace(/^(.)(.*)$/, (a, b, c) => b.toLowerCase() + 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 contextTsTypesString = printTsTypeAliases(typeAliasesAndZodText.contextTsTypeAliases, exportPrefix);
-    const contextJsCode = typeAliasesAndZodText.contextZodText
-        ? Object.entries(typeAliasesAndZodText.contextZodText).reduce((acc, curr) => {
-            return `${acc}
-export const ${curr[0]}=${curr[1]};`;
-        }, "")
-        : "";
-    const tsTypesString = (exportPrefix ? "export " : "") + printNode(typeAliasesAndZodText.mainTsTypeAlias);
-    return `${header}
-${contextTsTypesString}
-${tsTypesString}
-${contextJsCode}
-${bodyJsCode}
-`;
+function jzodToTsTypeAliasesAndZodText(element, typeName) {
+    var _a, _b;
+    const elementZodSchemaAndDescription = jzodElementSchemaToZodSchemaAndDescription(element, () => ({}), () => ({}), (innerReference, relativeReference) => withGetType(innerReference, (ts) => {
+        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, actualTypeName);
+        return [curr[0], typeAlias];
+    }));
+    const tsTypeStringNode = zodToTs(elementZodSchemaAndDescription.zodSchema, typeName).node;
+    const tsTypeStringTypeAlias = createTypeAlias(tsTypeStringNode, typeName !== null && typeName !== void 0 ? typeName : "");
+    return {
+        contextTsTypeAliases: contextTsTypesString,
+        contextZodText: (_b = elementZodSchemaAndDescription.contextZodText) !== null && _b !== void 0 ? _b : {},
+        mainZodText: elementZodSchemaAndDescription.zodText,
+        mainTsTypeAlias: tsTypeStringTypeAlias,
+    };
+}
+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, 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<${contextTypeName}> = ${curr[1]};`;
+        }, "")
+        : "";
+    const tsTypesString = (exportPrefix ? "export " : "") + printNode(typeAliasesAndZodText.mainTsTypeAlias);
+    return `${header}
+${contextTsTypesString}
+${tsTypesString}
+${contextJsCode}
+${bodyJsCode}
+`;
 }
 
-z.object({
-    optional: z.boolean().optional(),
-}).strict();
-const jzodEnumAttributeTypesSchema = z.enum([
-    "any",
-    "bigint",
-    "boolean",
-    "date",
-    "never",
-    "null",
-    "number",
-    "string",
-    "uuid",
-    "undefined",
-    "unknown",
-    "void",
-]);
-const jzodEnumElementTypesSchema = z.enum([
-    "array",
-    "enum",
-    "function",
-    "lazy",
-    "literal",
-    "intersection",
-    "map",
-    "object",
-    "promise",
-    "record",
-    "schemaReference",
-    "set",
-    "simpleType",
-    "tuple",
-    "union",
-]);
-const jzodArraySchema = 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)
-}).strict();
-const jzodAttributeDateValidationsSchema = z
-    .object({
-    extra: z.record(z.string(), z.any()).optional(),
-    type: z.enum([
-        "min",
-        "max",
-    ]),
-    parameter: z.any(),
-})
-    .strict();
-const jzodAttributeNumberValidationsSchema = z
-    .object({
-    extra: z.record(z.string(), z.any()).optional(),
-    type: z.enum([
-        "gt",
-        "gte",
-        "lt",
-        "lte",
-        "int",
-        "positive",
-        "nonpositive",
-        "negative",
-        "nonnegative",
-        "multipleOf",
-        "finite",
-        "safe",
-    ]),
-    parameter: z.any(),
-})
-    .strict();
-const jzodAttributeStringValidationsSchema = z
-    .object({
-    extra: z.record(z.string(), z.any()).optional(),
-    type: z.enum([
-        "max",
-        "min",
-        "length",
-        "email",
-        "url",
-        "emoji",
-        "uuid",
-        "cuid",
-        "cuid2",
-        "ulid",
-        "regex",
-        "includes",
-        "startsWith",
-        "endsWith",
-        "datetime",
-        "ip",
-    ]),
-    parameter: z.any(),
-})
-    .strict();
-const jzodAttributeDateWithValidationsSchema = 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),
-}).strict();
-const jzodAttributeNumberWithValidationsSchema = 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),
-}).strict();
-const jzodAttributeStringWithValidationsSchema = 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),
-}).strict();
-const jzodAttributeSchema = 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),
-}).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),
-    z.lazy(() => jzodMapSchema),
-    z.lazy(() => jzodObjectSchema),
-    z.lazy(() => jzodPromiseSchema),
-    z.lazy(() => jzodRecordSchema),
-    z.lazy(() => jzodReferenceSchema),
-    z.lazy(() => jzodSetSchema),
-    z.lazy(() => jzodTupleSchema),
-    z.lazy(() => jzodUnionSchema),
-]);
-const jzodEnumSchema = z.object({
-    optional: z.boolean().optional(),
-    nullable: z.boolean().optional(),
-    extra: z.record(z.string(), z.any()).optional(),
-    type: z.literal(jzodEnumElementTypesSchema.enum.enum),
-    definition: z.array(z.string()),
-}).strict();
-const jzodFunctionSchema = z.object({
-    type: z.literal(jzodEnumElementTypesSchema.enum.function),
-    extra: z.record(z.string(), z.any()).optional(),
-    definition: z.object({
-        args: z.array(jzodElementSchema),
-        returns: jzodElementSchema.optional(),
-    })
-}).strict();
-const jzodLazySchema = z.object({
-    type: z.literal(jzodEnumElementTypesSchema.enum.lazy),
-    extra: z.record(z.string(), z.any()).optional(),
-    definition: jzodFunctionSchema,
-}).strict();
-const jzodLiteralSchema = z.object({
-    optional: z.boolean().optional(),
-    nullable: z.boolean().optional(),
-    extra: z.record(z.string(), z.any()).optional(),
-    type: z.literal(jzodEnumElementTypesSchema.enum.literal),
-    definition: z.string(),
-}).strict();
-const jzodIntersectionSchema = 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 }))
-}).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]))
-}).strict();
-const jzodObjectSchema = z.object({
-    optional: z.boolean().optional(),
-    nullable: z.boolean().optional(),
-    extend: z.lazy(() => z.union([jzodReferenceSchema, jzodObjectSchema])).optional(),
-    extra: z.record(z.string(), z.any()).optional(),
-    type: z.literal(jzodEnumElementTypesSchema.enum.object),
-    nonStrict: z.boolean().optional(),
-    definition: z.lazy(() => z.record(z.string(), jzodElementSchema)),
-}).strict();
-const jzodPromiseSchema = z.object({
-    extra: z.record(z.string(), z.any()).optional(),
-    type: z.literal('promise'),
-    definition: z.lazy(() => jzodElementSchema)
-}).strict();
-const jzodRecordSchema = 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)
-}).strict();
-const jzodReferenceSchema = 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(),
-    definition: z.object({
-        eager: z.boolean().optional(),
-        relativePath: z.string().optional(),
-        absolutePath: z.string().optional(),
-    })
-}).strict();
-const jzodSetSchema = 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)
-}).strict();
-const jzodTupleSchema = 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),
-}).strict();
-const jzodUnionSchema = z.object({
-    optional: z.boolean().optional(),
-    nullable: z.boolean().optional(),
-    extra: z.record(z.string(), z.any()).optional(),
-    type: z.literal(jzodEnumElementTypesSchema.enum.union),
-    discriminator: z.string().optional(),
-    definition: z.lazy(() => z.array(jzodElementSchema))
+z.object({
+    optional: z.boolean().optional(),
+}).strict();
+const jzodEnumAttributeTypes = z.enum([
+    "any",
+    "bigint",
+    "boolean",
+    "date",
+    "never",
+    "null",
+    "number",
+    "string",
+    "uuid",
+    "undefined",
+    "unknown",
+    "void",
+]);
+const jzodEnumElementTypes = z.enum([
+    "array",
+    "enum",
+    "function",
+    "lazy",
+    "literal",
+    "intersection",
+    "map",
+    "object",
+    "promise",
+    "record",
+    "schemaReference",
+    "set",
+    "simpleType",
+    "tuple",
+    "union",
+]);
+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(() => jzodElement)
+}).strict();
+const jzodAttributeDateValidations = z
+    .object({
+    extra: z.record(z.string(), z.any()).optional(),
+    type: z.enum([
+        "min",
+        "max",
+    ]),
+    parameter: z.any(),
+})
+    .strict();
+const jzodAttributeNumberValidations = z
+    .object({
+    extra: z.record(z.string(), z.any()).optional(),
+    type: z.enum([
+        "gt",
+        "gte",
+        "lt",
+        "lte",
+        "int",
+        "positive",
+        "nonpositive",
+        "negative",
+        "nonnegative",
+        "multipleOf",
+        "finite",
+        "safe",
+    ]),
+    parameter: z.any(),
+})
+    .strict();
+const jzodAttributeStringValidations = z
+    .object({
+    extra: z.record(z.string(), z.any()).optional(),
+    type: z.enum([
+        "max",
+        "min",
+        "length",
+        "email",
+        "url",
+        "emoji",
+        "uuid",
+        "cuid",
+        "cuid2",
+        "ulid",
+        "regex",
+        "includes",
+        "startsWith",
+        "endsWith",
+        "datetime",
+        "ip",
+    ]),
+    parameter: z.any(),
+})
+    .strict();
+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(jzodEnumElementTypes.enum.simpleType),
+    definition: z.literal(jzodEnumAttributeTypes.enum.date),
+    validations: z.array(jzodAttributeDateValidations),
+}).strict();
+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(jzodEnumElementTypes.enum.simpleType),
+    definition: z.literal(jzodEnumAttributeTypes.enum.number),
+    validations: z.array(jzodAttributeNumberValidations),
+}).strict();
+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(jzodEnumElementTypes.enum.simpleType),
+    definition: z.literal(jzodEnumAttributeTypes.enum.string),
+    validations: z.array(jzodAttributeStringValidations),
+}).strict();
+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(jzodEnumElementTypes.enum.simpleType),
+    definition: z.lazy(() => jzodEnumAttributeTypes),
+}).strict();
+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(() => jzodObject),
+    z.lazy(() => jzodPromise),
+    z.lazy(() => jzodRecord),
+    z.lazy(() => jzodReference),
+    z.lazy(() => jzodSet),
+    z.lazy(() => jzodTuple),
+    z.lazy(() => jzodUnion),
+]);
+const jzodEnum = z.object({
+    optional: z.boolean().optional(),
+    nullable: z.boolean().optional(),
+    extra: z.record(z.string(), z.any()).optional(),
+    type: z.literal(jzodEnumElementTypes.enum.enum),
+    definition: z.array(z.string()),
+}).strict();
+const jzodFunction = z.object({
+    type: z.literal(jzodEnumElementTypes.enum.function),
+    extra: z.record(z.string(), z.any()).optional(),
+    definition: z.object({
+        args: z.array(jzodElement),
+        returns: jzodElement.optional(),
+    })
+}).strict();
+const jzodLazy = z.object({
+    type: z.literal(jzodEnumElementTypes.enum.lazy),
+    extra: z.record(z.string(), z.any()).optional(),
+    definition: jzodFunction,
+}).strict();
+const jzodLiteral = z.object({
+    optional: z.boolean().optional(),
+    nullable: z.boolean().optional(),
+    extra: z.record(z.string(), z.any()).optional(),
+    type: z.literal(jzodEnumElementTypes.enum.literal),
+    definition: z.string(),
+}).strict();
+const jzodIntersection = z.object({
+    optional: z.boolean().optional(),
+    nullable: z.boolean().optional(),
+    extra: z.record(z.string(), z.any()).optional(),
+    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([jzodElement, jzodElement]))
+}).strict();
+const jzodObject = z.object({
+    optional: z.boolean().optional(),
+    nullable: z.boolean().optional(),
+    extend: z.lazy(() => z.union([jzodReference, jzodObject])).optional(),
+    extra: z.record(z.string(), z.any()).optional(),
+    type: z.literal(jzodEnumElementTypes.enum.object),
+    nonStrict: z.boolean().optional(),
+    definition: z.lazy(() => z.record(z.string(), jzodElement)),
+}).strict();
+const jzodPromise = z.object({
+    extra: z.record(z.string(), z.any()).optional(),
+    type: z.literal('promise'),
+    definition: z.lazy(() => jzodElement)
+}).strict();
+const jzodRecord = z.object({
+    optional: z.boolean().optional(),
+    nullable: z.boolean().optional(),
+    extra: z.record(z.string(), z.any()).optional(),
+    type: z.literal(jzodEnumElementTypes.enum.record),
+    definition: z.lazy(() => jzodElement)
+}).strict();
+const jzodReference = z.object({
+    optional: z.boolean().optional(),
+    nullable: z.boolean().optional(),
+    extra: z.record(z.string(), z.any()).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 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(() => jzodElement)
+}).strict();
+const jzodTuple = z.object({
+    optional: z.boolean().optional(),
+    nullable: z.boolean().optional(),
+    extra: z.record(z.string(), z.any()).optional(),
+    type: z.literal(jzodEnumElementTypes.enum.tuple),
+    definition: z.array(jzodElement),
+}).strict();
+const jzodUnion = z.object({
+    optional: z.boolean().optional(),
+    nullable: z.boolean().optional(),
+    extra: z.record(z.string(), z.any()).optional(),
+    type: z.literal(jzodEnumElementTypes.enum.union),
+    discriminator: z.string().optional(),
+    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 };

package/dist/src/JzodToTs.d.ts

@@ -1,17 +1,17 @@
-import ts from "typescript";
-import { JzodElement } from "./JzodTsInterface";
-export type TsTypeAliases = {
-    [k: string]: ts.TypeAliasDeclaration;
-};
-export interface TsTypeAliasesAndZodText {
-    contextTsTypeAliases: {
-        [k: string]: ts.TypeAliasDeclaration;
-    };
-    contextZodText: {
-        [k: string]: string;
-    };
-    mainTsTypeAlias: ts.TypeAliasDeclaration;
-    mainZodText: string;
-}
-export declare function jzodToTsTypeAliasesAndZodText(element: JzodElement, typeName?: string): TsTypeAliasesAndZodText;
-export declare function jzodToTsCode(jzodElement: JzodElement, exportPrefix?: boolean, typeName?: string): string;
+import ts from "typescript";
+import { JzodElement } from "./JzodTsInterface";
+export type TsTypeAliases = {
+    [k: string]: ts.TypeAliasDeclaration;
+};
+export interface TsTypeAliasesAndZodText {
+    contextTsTypeAliases: {
+        [k: string]: ts.TypeAliasDeclaration;
+    };
+    contextZodText: {
+        [k: string]: string;
+    };
+    mainTsTypeAlias: ts.TypeAliasDeclaration;
+    mainZodText: string;
+}
+export declare function jzodToTsTypeAliasesAndZodText(element: JzodElement, typeName?: string): TsTypeAliasesAndZodText;
+export declare function jzodToTsCode(jzodElement: JzodElement, exportPrefix?: boolean, typeName?: string): string;