@miroir-framework/jzod-ts 0.5.1 → 0.5.3

package/dist/bundle.d.ts

@@ -1,419 +1,419 @@
 import ts from 'typescript';
 import { z, ZodType } from 'zod';
 
-declare const jzodRootSchema: z.ZodObject<{
-    optional: z.ZodOptional<z.ZodBoolean>;
-}, "strict", z.ZodTypeAny, {
-    optional?: boolean | undefined;
-}, {
-    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>;
-interface JzodArray extends JzodRoot {
-    optional?: boolean;
-    nullable?: boolean;
-    extra?: {
-        [k: string]: any;
-    };
-    type: 'array';
-    definition: JzodElement;
-}
-declare const jzodArraySchema: z.ZodType<JzodArray>;
-declare const jzodAttributeDateValidationsSchema: z.ZodObject<{
-    extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-    type: z.ZodEnum<["min", "max"]>;
-    parameter: z.ZodAny;
-}, "strict", z.ZodTypeAny, {
-    type: "min" | "max";
-    extra?: Record<string, any> | undefined;
-    parameter?: any;
-}, {
-    type: "min" | "max";
-    extra?: Record<string, any> | undefined;
-    parameter?: any;
-}>;
-type JzodAttributeDateValidations = z.infer<typeof jzodAttributeDateValidationsSchema>;
-declare const jzodAttributeNumberValidationsSchema: 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;
-}, "strict", z.ZodTypeAny, {
-    type: "multipleOf" | "gt" | "gte" | "lt" | "lte" | "int" | "positive" | "nonpositive" | "negative" | "nonnegative" | "finite" | "safe";
-    extra?: Record<string, any> | undefined;
-    parameter?: any;
-}, {
-    type: "multipleOf" | "gt" | "gte" | "lt" | "lte" | "int" | "positive" | "nonpositive" | "negative" | "nonnegative" | "finite" | "safe";
-    extra?: Record<string, any> | undefined;
-    parameter?: any;
-}>;
-type JzodAttributeNumberValidations = z.infer<typeof jzodAttributeNumberValidationsSchema>;
-declare const jzodAttributeStringValidationsSchema: 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;
-}, "strict", z.ZodTypeAny, {
-    type: "length" | "includes" | "uuid" | "min" | "max" | "email" | "url" | "emoji" | "cuid" | "cuid2" | "ulid" | "regex" | "startsWith" | "endsWith" | "datetime" | "ip";
-    extra?: Record<string, any> | undefined;
-    parameter?: any;
-}, {
-    type: "length" | "includes" | "uuid" | "min" | "max" | "email" | "url" | "emoji" | "cuid" | "cuid2" | "ulid" | "regex" | "startsWith" | "endsWith" | "datetime" | "ip";
-    extra?: Record<string, any> | undefined;
-    parameter?: any;
-}>;
-type JzodAttributeStringValidations = z.infer<typeof jzodAttributeStringValidationsSchema>;
-declare const jzodAttributeDateWithValidationsSchema: z.ZodObject<{
-    optional: z.ZodOptional<z.ZodBoolean>;
-    nullable: z.ZodOptional<z.ZodBoolean>;
-    extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-    coerce: z.ZodOptional<z.ZodBoolean>;
-    type: z.ZodLiteral<"simpleType">;
-    definition: z.ZodLiteral<"date">;
-    validations: z.ZodArray<z.ZodObject<{
-        extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-        type: z.ZodEnum<["min", "max"]>;
-        parameter: z.ZodAny;
-    }, "strict", z.ZodTypeAny, {
-        type: "min" | "max";
-        extra?: Record<string, any> | undefined;
-        parameter?: any;
-    }, {
-        type: "min" | "max";
-        extra?: Record<string, any> | undefined;
-        parameter?: any;
-    }>, "many">;
-}, "strict", z.ZodTypeAny, {
-    type: "simpleType";
-    definition: "date";
-    validations: {
-        type: "min" | "max";
-        extra?: Record<string, any> | undefined;
-        parameter?: any;
-    }[];
-    optional?: boolean | undefined;
-    nullable?: boolean | undefined;
-    extra?: Record<string, any> | undefined;
-    coerce?: boolean | undefined;
-}, {
-    type: "simpleType";
-    definition: "date";
-    validations: {
-        type: "min" | "max";
-        extra?: Record<string, any> | undefined;
-        parameter?: any;
-    }[];
-    optional?: boolean | undefined;
-    nullable?: boolean | undefined;
-    extra?: Record<string, any> | undefined;
-    coerce?: boolean | undefined;
-}>;
-type JzodAttributeDateWithValidations = z.infer<typeof jzodAttributeDateWithValidationsSchema>;
-declare const jzodAttributeNumberWithValidationsSchema: z.ZodObject<{
-    optional: z.ZodOptional<z.ZodBoolean>;
-    nullable: z.ZodOptional<z.ZodBoolean>;
-    extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-    coerce: z.ZodOptional<z.ZodBoolean>;
-    type: z.ZodLiteral<"simpleType">;
-    definition: z.ZodLiteral<"number">;
-    validations: z.ZodArray<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;
-    }, "strict", z.ZodTypeAny, {
-        type: "multipleOf" | "gt" | "gte" | "lt" | "lte" | "int" | "positive" | "nonpositive" | "negative" | "nonnegative" | "finite" | "safe";
-        extra?: Record<string, any> | undefined;
-        parameter?: any;
-    }, {
-        type: "multipleOf" | "gt" | "gte" | "lt" | "lte" | "int" | "positive" | "nonpositive" | "negative" | "nonnegative" | "finite" | "safe";
-        extra?: Record<string, any> | undefined;
-        parameter?: any;
-    }>, "many">;
-}, "strict", z.ZodTypeAny, {
-    type: "simpleType";
-    definition: "number";
-    validations: {
-        type: "multipleOf" | "gt" | "gte" | "lt" | "lte" | "int" | "positive" | "nonpositive" | "negative" | "nonnegative" | "finite" | "safe";
-        extra?: Record<string, any> | undefined;
-        parameter?: any;
-    }[];
-    optional?: boolean | undefined;
-    nullable?: boolean | undefined;
-    extra?: Record<string, any> | undefined;
-    coerce?: boolean | undefined;
-}, {
-    type: "simpleType";
-    definition: "number";
-    validations: {
-        type: "multipleOf" | "gt" | "gte" | "lt" | "lte" | "int" | "positive" | "nonpositive" | "negative" | "nonnegative" | "finite" | "safe";
-        extra?: Record<string, any> | undefined;
-        parameter?: any;
-    }[];
-    optional?: boolean | undefined;
-    nullable?: boolean | undefined;
-    extra?: Record<string, any> | undefined;
-    coerce?: boolean | undefined;
-}>;
-type JzodAttributeNumberWithValidations = z.infer<typeof jzodAttributeNumberWithValidationsSchema>;
-declare const jzodAttributeStringWithValidationsSchema: z.ZodObject<{
-    optional: z.ZodOptional<z.ZodBoolean>;
-    nullable: z.ZodOptional<z.ZodBoolean>;
-    extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-    coerce: z.ZodOptional<z.ZodBoolean>;
-    type: z.ZodLiteral<"simpleType">;
-    definition: z.ZodLiteral<"string">;
-    validations: z.ZodArray<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;
-    }, "strict", z.ZodTypeAny, {
-        type: "length" | "includes" | "uuid" | "min" | "max" | "email" | "url" | "emoji" | "cuid" | "cuid2" | "ulid" | "regex" | "startsWith" | "endsWith" | "datetime" | "ip";
-        extra?: Record<string, any> | undefined;
-        parameter?: any;
-    }, {
-        type: "length" | "includes" | "uuid" | "min" | "max" | "email" | "url" | "emoji" | "cuid" | "cuid2" | "ulid" | "regex" | "startsWith" | "endsWith" | "datetime" | "ip";
-        extra?: Record<string, any> | undefined;
-        parameter?: any;
-    }>, "many">;
-}, "strict", z.ZodTypeAny, {
-    type: "simpleType";
-    definition: "string";
-    validations: {
-        type: "length" | "includes" | "uuid" | "min" | "max" | "email" | "url" | "emoji" | "cuid" | "cuid2" | "ulid" | "regex" | "startsWith" | "endsWith" | "datetime" | "ip";
-        extra?: Record<string, any> | undefined;
-        parameter?: any;
-    }[];
-    optional?: boolean | undefined;
-    nullable?: boolean | undefined;
-    extra?: Record<string, any> | undefined;
-    coerce?: boolean | undefined;
-}, {
-    type: "simpleType";
-    definition: "string";
-    validations: {
-        type: "length" | "includes" | "uuid" | "min" | "max" | "email" | "url" | "emoji" | "cuid" | "cuid2" | "ulid" | "regex" | "startsWith" | "endsWith" | "datetime" | "ip";
-        extra?: Record<string, any> | undefined;
-        parameter?: any;
-    }[];
-    optional?: boolean | undefined;
-    nullable?: boolean | undefined;
-    extra?: Record<string, any> | undefined;
-    coerce?: boolean | undefined;
-}>;
-type JzodAttributeStringWithValidations = z.infer<typeof jzodAttributeStringWithValidationsSchema>;
-declare const jzodAttributeSchema: z.ZodObject<{
-    optional: z.ZodOptional<z.ZodBoolean>;
-    nullable: z.ZodOptional<z.ZodBoolean>;
-    extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-    coerce: z.ZodOptional<z.ZodBoolean>;
-    type: z.ZodLiteral<"simpleType">;
-    definition: z.ZodLazy<z.ZodEnum<["any", "bigint", "boolean", "date", "never", "null", "number", "string", "uuid", "undefined", "unknown", "void"]>>;
-}, "strict", z.ZodTypeAny, {
-    type: "simpleType";
-    definition: "string" | "number" | "bigint" | "boolean" | "undefined" | "any" | "date" | "never" | "null" | "uuid" | "unknown" | "void";
-    optional?: boolean | undefined;
-    nullable?: boolean | undefined;
-    extra?: Record<string, any> | undefined;
-    coerce?: boolean | undefined;
-}, {
-    type: "simpleType";
-    definition: "string" | "number" | "bigint" | "boolean" | "undefined" | "any" | "date" | "never" | "null" | "uuid" | "unknown" | "void";
-    optional?: boolean | undefined;
-    nullable?: boolean | undefined;
-    extra?: Record<string, any> | undefined;
-    coerce?: boolean | undefined;
-}>;
-type JzodAttribute = z.infer<typeof jzodAttributeSchema>;
-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<{
-    optional: z.ZodOptional<z.ZodBoolean>;
-    nullable: z.ZodOptional<z.ZodBoolean>;
-    extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-    type: z.ZodLiteral<"enum">;
-    definition: z.ZodArray<z.ZodString, "many">;
-}, "strict", z.ZodTypeAny, {
-    type: "enum";
-    definition: string[];
-    optional?: boolean | undefined;
-    nullable?: boolean | undefined;
-    extra?: Record<string, any> | undefined;
-}, {
-    type: "enum";
-    definition: string[];
-    optional?: boolean | undefined;
-    nullable?: boolean | undefined;
-    extra?: Record<string, any> | undefined;
-}>;
-type JzodEnum = z.infer<typeof jzodEnumSchema>;
-interface JzodFunction {
-    extra?: {
-        [k: string]: any;
-    };
-    type: 'function';
-    definition: {
-        args: JzodElement[];
-        returns?: JzodElement;
-    };
-}
-declare const jzodFunctionSchema: ZodType<JzodFunction>;
-declare const jzodLazySchema: z.ZodObject<{
-    type: z.ZodLiteral<"lazy">;
-    extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-    definition: ZodType<JzodFunction, z.ZodTypeDef, JzodFunction>;
-}, "strict", z.ZodTypeAny, {
-    type: "lazy";
-    definition: JzodFunction;
-    extra?: Record<string, any> | undefined;
-}, {
-    type: "lazy";
-    definition: JzodFunction;
-    extra?: Record<string, any> | undefined;
-}>;
-type JzodLazy = z.infer<typeof jzodLazySchema>;
-declare const jzodLiteralSchema: z.ZodObject<{
-    optional: z.ZodOptional<z.ZodBoolean>;
-    nullable: z.ZodOptional<z.ZodBoolean>;
-    extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-    type: z.ZodLiteral<"literal">;
-    definition: z.ZodString;
-}, "strict", z.ZodTypeAny, {
-    type: "literal";
-    definition: string;
-    optional?: boolean | undefined;
-    nullable?: boolean | undefined;
-    extra?: Record<string, any> | undefined;
-}, {
-    type: "literal";
-    definition: string;
-    optional?: boolean | undefined;
-    nullable?: boolean | undefined;
-    extra?: Record<string, any> | undefined;
-}>;
-type JzodLiteral = z.infer<typeof jzodLiteralSchema>;
-interface JzodIntersection {
-    optional?: boolean;
-    nullable?: boolean;
-    extra?: {
-        [k: string]: any;
-    };
-    type: 'intersection';
-    definition: {
-        left: JzodElement;
-        right: JzodElement;
-    };
-}
-declare const jzodIntersectionSchema: z.ZodType<JzodIntersection>;
-interface JzodMap extends JzodRoot {
-    optional?: boolean;
-    nullable?: boolean;
-    extra?: {
-        [k: string]: any;
-    };
-    type: 'map';
-    definition: [JzodElement, JzodElement];
-}
-declare const jzodMapSchema: z.ZodType<JzodMap>;
-interface JzodObject extends JzodRoot {
-    optional?: boolean;
-    nullable?: boolean;
-    extend?: JzodReference | JzodObject;
-    extra?: {
-        [k: string]: any;
-    };
-    type: "object";
-    nonStrict?: boolean;
-    definition: {
-        [attributeName: string]: JzodElement;
-    };
-}
-declare const jzodObjectSchema: z.ZodType<JzodObject>;
-interface JzodPromise extends JzodRoot {
-    extra?: {
-        [k: string]: any;
-    };
-    type: 'promise';
-    definition: JzodElement;
-}
-declare const jzodPromiseSchema: z.ZodType<JzodPromise>;
-interface JzodRecord {
-    optional?: boolean;
-    nullable?: boolean;
-    extra?: {
-        [k: string]: any;
-    };
-    type: 'record';
-    definition: JzodElement;
-}
-declare const jzodRecordSchema: z.ZodType<JzodRecord>;
-interface JzodReference {
-    optional?: boolean;
-    nullable?: boolean;
-    extra?: {
-        [k: string]: any;
-    };
-    context?: {
-        [attributeName: string]: JzodElement;
-    };
-    type: 'schemaReference';
-    definition: {
-        eager?: boolean;
-        relativePath?: string;
-        absolutePath?: string;
-    };
-}
-declare const jzodReferenceSchema: ZodType<JzodReference>;
-interface JzodSet extends JzodRoot {
-    optional?: boolean;
-    nullable?: boolean;
-    extra?: {
-        [k: string]: any;
-    };
-    type: 'set';
-    definition: JzodElement;
-}
-declare const jzodSetSchema: z.ZodType<JzodSet>;
-interface JzodTuple {
-    optional?: boolean;
-    nullable?: boolean;
-    extra?: {
-        [k: string]: any;
-    };
-    type: 'tuple';
-    definition: JzodElement[];
-}
-declare const jzodTupleSchema: z.ZodType<JzodTuple>;
-interface JzodUnion {
-    optional?: boolean;
-    nullable?: boolean;
-    extra?: {
-        [k: string]: any;
-    };
-    type: "union";
-    discriminator?: string;
-    definition: JzodElement[];
-}
-declare const jzodUnionSchema: z.ZodType<JzodUnion>;
+declare const jzodRootSchema: z.ZodObject<{
+    optional: z.ZodOptional<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    optional?: boolean | undefined;
+}, {
+    optional?: boolean | undefined;
+}>;
+type JzodRoot = z.infer<typeof jzodRootSchema>;
+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;
+    extra?: {
+        [k: string]: any;
+    };
+    type: 'array';
+    definition: JzodElement;
+}
+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;
+}, "strict", z.ZodTypeAny, {
+    type: "min" | "max";
+    extra?: Record<string, any> | undefined;
+    parameter?: any;
+}, {
+    type: "min" | "max";
+    extra?: Record<string, any> | undefined;
+    parameter?: any;
+}>;
+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;
+}, "strict", z.ZodTypeAny, {
+    type: "multipleOf" | "gt" | "gte" | "lt" | "lte" | "int" | "positive" | "nonpositive" | "negative" | "nonnegative" | "finite" | "safe";
+    extra?: Record<string, any> | undefined;
+    parameter?: any;
+}, {
+    type: "multipleOf" | "gt" | "gte" | "lt" | "lte" | "int" | "positive" | "nonpositive" | "negative" | "nonnegative" | "finite" | "safe";
+    extra?: Record<string, any> | undefined;
+    parameter?: any;
+}>;
+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;
+}, "strict", z.ZodTypeAny, {
+    type: "length" | "includes" | "uuid" | "min" | "max" | "email" | "url" | "emoji" | "cuid" | "cuid2" | "ulid" | "regex" | "startsWith" | "endsWith" | "datetime" | "ip";
+    extra?: Record<string, any> | undefined;
+    parameter?: any;
+}, {
+    type: "length" | "includes" | "uuid" | "min" | "max" | "email" | "url" | "emoji" | "cuid" | "cuid2" | "ulid" | "regex" | "startsWith" | "endsWith" | "datetime" | "ip";
+    extra?: Record<string, any> | undefined;
+    parameter?: any;
+}>;
+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>>;
+    coerce: z.ZodOptional<z.ZodBoolean>;
+    type: z.ZodLiteral<"simpleType">;
+    definition: z.ZodLiteral<"date">;
+    validations: z.ZodArray<z.ZodObject<{
+        extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        type: z.ZodEnum<["min", "max"]>;
+        parameter: z.ZodAny;
+    }, "strict", z.ZodTypeAny, {
+        type: "min" | "max";
+        extra?: Record<string, any> | undefined;
+        parameter?: any;
+    }, {
+        type: "min" | "max";
+        extra?: Record<string, any> | undefined;
+        parameter?: any;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    type: "simpleType";
+    definition: "date";
+    validations: {
+        type: "min" | "max";
+        extra?: Record<string, any> | undefined;
+        parameter?: any;
+    }[];
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: Record<string, any> | undefined;
+    coerce?: boolean | undefined;
+}, {
+    type: "simpleType";
+    definition: "date";
+    validations: {
+        type: "min" | "max";
+        extra?: Record<string, any> | undefined;
+        parameter?: any;
+    }[];
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: Record<string, any> | undefined;
+    coerce?: boolean | undefined;
+}>;
+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>>;
+    coerce: z.ZodOptional<z.ZodBoolean>;
+    type: z.ZodLiteral<"simpleType">;
+    definition: z.ZodLiteral<"number">;
+    validations: z.ZodArray<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;
+    }, "strict", z.ZodTypeAny, {
+        type: "multipleOf" | "gt" | "gte" | "lt" | "lte" | "int" | "positive" | "nonpositive" | "negative" | "nonnegative" | "finite" | "safe";
+        extra?: Record<string, any> | undefined;
+        parameter?: any;
+    }, {
+        type: "multipleOf" | "gt" | "gte" | "lt" | "lte" | "int" | "positive" | "nonpositive" | "negative" | "nonnegative" | "finite" | "safe";
+        extra?: Record<string, any> | undefined;
+        parameter?: any;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    type: "simpleType";
+    definition: "number";
+    validations: {
+        type: "multipleOf" | "gt" | "gte" | "lt" | "lte" | "int" | "positive" | "nonpositive" | "negative" | "nonnegative" | "finite" | "safe";
+        extra?: Record<string, any> | undefined;
+        parameter?: any;
+    }[];
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: Record<string, any> | undefined;
+    coerce?: boolean | undefined;
+}, {
+    type: "simpleType";
+    definition: "number";
+    validations: {
+        type: "multipleOf" | "gt" | "gte" | "lt" | "lte" | "int" | "positive" | "nonpositive" | "negative" | "nonnegative" | "finite" | "safe";
+        extra?: Record<string, any> | undefined;
+        parameter?: any;
+    }[];
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: Record<string, any> | undefined;
+    coerce?: boolean | undefined;
+}>;
+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>>;
+    coerce: z.ZodOptional<z.ZodBoolean>;
+    type: z.ZodLiteral<"simpleType">;
+    definition: z.ZodLiteral<"string">;
+    validations: z.ZodArray<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;
+    }, "strict", z.ZodTypeAny, {
+        type: "length" | "includes" | "uuid" | "min" | "max" | "email" | "url" | "emoji" | "cuid" | "cuid2" | "ulid" | "regex" | "startsWith" | "endsWith" | "datetime" | "ip";
+        extra?: Record<string, any> | undefined;
+        parameter?: any;
+    }, {
+        type: "length" | "includes" | "uuid" | "min" | "max" | "email" | "url" | "emoji" | "cuid" | "cuid2" | "ulid" | "regex" | "startsWith" | "endsWith" | "datetime" | "ip";
+        extra?: Record<string, any> | undefined;
+        parameter?: any;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    type: "simpleType";
+    definition: "string";
+    validations: {
+        type: "length" | "includes" | "uuid" | "min" | "max" | "email" | "url" | "emoji" | "cuid" | "cuid2" | "ulid" | "regex" | "startsWith" | "endsWith" | "datetime" | "ip";
+        extra?: Record<string, any> | undefined;
+        parameter?: any;
+    }[];
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: Record<string, any> | undefined;
+    coerce?: boolean | undefined;
+}, {
+    type: "simpleType";
+    definition: "string";
+    validations: {
+        type: "length" | "includes" | "uuid" | "min" | "max" | "email" | "url" | "emoji" | "cuid" | "cuid2" | "ulid" | "regex" | "startsWith" | "endsWith" | "datetime" | "ip";
+        extra?: Record<string, any> | undefined;
+        parameter?: any;
+    }[];
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: Record<string, any> | undefined;
+    coerce?: boolean | undefined;
+}>;
+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>>;
+    coerce: z.ZodOptional<z.ZodBoolean>;
+    type: z.ZodLiteral<"simpleType">;
+    definition: z.ZodLazy<z.ZodEnum<["any", "bigint", "boolean", "date", "never", "null", "number", "string", "uuid", "undefined", "unknown", "void"]>>;
+}, "strict", z.ZodTypeAny, {
+    type: "simpleType";
+    definition: "string" | "number" | "bigint" | "boolean" | "undefined" | "any" | "date" | "never" | "null" | "uuid" | "unknown" | "void";
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: Record<string, any> | undefined;
+    coerce?: boolean | undefined;
+}, {
+    type: "simpleType";
+    definition: "string" | "number" | "bigint" | "boolean" | "undefined" | "any" | "date" | "never" | "null" | "uuid" | "unknown" | "void";
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: Record<string, any> | undefined;
+    coerce?: boolean | undefined;
+}>;
+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 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>>;
+    type: z.ZodLiteral<"enum">;
+    definition: z.ZodArray<z.ZodString, "many">;
+}, "strict", z.ZodTypeAny, {
+    type: "enum";
+    definition: string[];
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: Record<string, any> | undefined;
+}, {
+    type: "enum";
+    definition: string[];
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: Record<string, any> | undefined;
+}>;
+type JzodEnum = z.infer<typeof jzodEnum>;
+interface JzodFunction {
+    extra?: {
+        [k: string]: any;
+    };
+    type: 'function';
+    definition: {
+        args: JzodElement[];
+        returns?: JzodElement;
+    };
+}
+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>;
+}, "strict", z.ZodTypeAny, {
+    type: "lazy";
+    definition: JzodFunction;
+    extra?: Record<string, any> | undefined;
+}, {
+    type: "lazy";
+    definition: JzodFunction;
+    extra?: Record<string, any> | undefined;
+}>;
+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>>;
+    type: z.ZodLiteral<"literal">;
+    definition: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    type: "literal";
+    definition: string;
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: Record<string, any> | undefined;
+}, {
+    type: "literal";
+    definition: string;
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: Record<string, any> | undefined;
+}>;
+type JzodLiteral = z.infer<typeof jzodLiteral>;
+interface JzodIntersection {
+    optional?: boolean;
+    nullable?: boolean;
+    extra?: {
+        [k: string]: any;
+    };
+    type: 'intersection';
+    definition: {
+        left: JzodElement;
+        right: JzodElement;
+    };
+}
+declare const jzodIntersection: z.ZodType<JzodIntersection>;
+interface JzodMap extends JzodRoot {
+    optional?: boolean;
+    nullable?: boolean;
+    extra?: {
+        [k: string]: any;
+    };
+    type: 'map';
+    definition: [JzodElement, JzodElement];
+}
+declare const jzodMapSchema: z.ZodType<JzodMap>;
+interface JzodObject extends JzodRoot {
+    optional?: boolean;
+    nullable?: boolean;
+    extend?: JzodReference | JzodObject;
+    extra?: {
+        [k: string]: any;
+    };
+    type: "object";
+    nonStrict?: boolean;
+    definition: {
+        [attributeName: string]: JzodElement;
+    };
+}
+declare const jzodObject: z.ZodType<JzodObject>;
+interface JzodPromise extends JzodRoot {
+    extra?: {
+        [k: string]: any;
+    };
+    type: 'promise';
+    definition: JzodElement;
+}
+declare const jzodPromise: z.ZodType<JzodPromise>;
+interface JzodRecord {
+    optional?: boolean;
+    nullable?: boolean;
+    extra?: {
+        [k: string]: any;
+    };
+    type: 'record';
+    definition: JzodElement;
+}
+declare const jzodRecord: z.ZodType<JzodRecord>;
+interface JzodReference {
+    optional?: boolean;
+    nullable?: boolean;
+    extra?: {
+        [k: string]: any;
+    };
+    context?: {
+        [attributeName: string]: JzodElement;
+    };
+    type: 'schemaReference';
+    definition: {
+        eager?: boolean;
+        relativePath?: string;
+        absolutePath?: string;
+    };
+}
+declare const jzodReference: ZodType<JzodReference>;
+interface JzodSet extends JzodRoot {
+    optional?: boolean;
+    nullable?: boolean;
+    extra?: {
+        [k: string]: any;
+    };
+    type: 'set';
+    definition: JzodElement;
+}
+declare const jzodSet: z.ZodType<JzodSet>;
+interface JzodTuple {
+    optional?: boolean;
+    nullable?: boolean;
+    extra?: {
+        [k: string]: any;
+    };
+    type: 'tuple';
+    definition: JzodElement[];
+}
+declare const jzodTuple: z.ZodType<JzodTuple>;
+interface JzodUnion {
+    optional?: boolean;
+    nullable?: boolean;
+    extra?: {
+        [k: string]: any;
+    };
+    type: "union";
+    discriminator?: string;
+    definition: JzodElement[];
+}
+declare const jzodUnion: z.ZodType<JzodUnion>;
 
-type TsTypeAliases = {
-    [k: string]: ts.TypeAliasDeclaration;
-};
-interface TsTypeAliasesAndZodText {
-    contextTsTypeAliases: {
-        [k: string]: ts.TypeAliasDeclaration;
-    };
-    contextZodText: {
-        [k: string]: string;
-    };
-    mainTsTypeAlias: ts.TypeAliasDeclaration;
-    mainZodText: string;
-}
-declare function jzodToTsTypeAliasesAndZodText(element: JzodElement, typeName?: string): TsTypeAliasesAndZodText;
+type TsTypeAliases = {
+    [k: string]: ts.TypeAliasDeclaration;
+};
+interface TsTypeAliasesAndZodText {
+    contextTsTypeAliases: {
+        [k: string]: ts.TypeAliasDeclaration;
+    };
+    contextZodText: {
+        [k: string]: string;
+    };
+    mainTsTypeAlias: ts.TypeAliasDeclaration;
+    mainZodText: string;
+}
+declare function jzodToTsTypeAliasesAndZodText(element: JzodElement, typeName?: string): TsTypeAliasesAndZodText;
 declare function jzodToTsCode(jzodElement: JzodElement, exportPrefix?: boolean, typeName?: string): string;
 
-declare function printTsTypeAlias(typeAlias: ts.TypeAliasDeclaration, exportPrefix?: boolean): string;
+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 };