@miroir-framework/jzod-ts 0.5.1 → 0.5.3

package/dist/src/JzodTsInterface.d.ts

@@ -1,397 +1,397 @@
-import { ZodType, z } 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>;
-export declare const jzodEnumAttributeTypesSchema: z.ZodEnum<["any", "bigint", "boolean", "date", "never", "null", "number", "string", "uuid", "undefined", "unknown", "void"]>;
-export type JzodEnumTypes = z.infer<typeof jzodEnumAttributeTypesSchema>;
-export declare const jzodEnumElementTypesSchema: z.ZodEnum<["array", "enum", "function", "lazy", "literal", "intersection", "map", "object", "promise", "record", "schemaReference", "set", "simpleType", "tuple", "union"]>;
-export type JzodEnumElementTypes = z.infer<typeof jzodEnumElementTypesSchema>;
-export interface JzodArray extends JzodRoot {
-    optional?: boolean;
-    nullable?: boolean;
-    extra?: {
-        [k: string]: any;
-    };
-    type: 'array';
-    definition: JzodElement;
-}
-export declare const jzodArraySchema: z.ZodType<JzodArray>;
-export 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;
-}>;
-export type JzodAttributeDateValidations = z.infer<typeof jzodAttributeDateValidationsSchema>;
-export 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;
-}>;
-export type JzodAttributeNumberValidations = z.infer<typeof jzodAttributeNumberValidationsSchema>;
-export 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;
-}>;
-export type JzodAttributeStringValidations = z.infer<typeof jzodAttributeStringValidationsSchema>;
-export 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;
-}>;
-export type JzodAttributeDateWithValidations = z.infer<typeof jzodAttributeDateWithValidationsSchema>;
-export 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;
-}>;
-export type JzodAttributeNumberWithValidations = z.infer<typeof jzodAttributeNumberWithValidationsSchema>;
-export 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;
-}>;
-export type JzodAttributeStringWithValidations = z.infer<typeof jzodAttributeStringWithValidationsSchema>;
-export 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;
-}>;
-export type JzodAttribute = z.infer<typeof jzodAttributeSchema>;
-export type JzodElement = JzodArray | JzodAttribute | JzodAttributeDateWithValidations | JzodAttributeNumberWithValidations | JzodAttributeStringWithValidations | JzodEnum | JzodFunction | JzodLazy | JzodLiteral | JzodIntersection | JzodMap | JzodRecord | JzodObject | JzodPromise | JzodReference | JzodSet | JzodTuple | JzodUnion;
-export declare const jzodElementSchema: z.ZodType<JzodElement>;
-export 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;
-}>;
-export type JzodEnum = z.infer<typeof jzodEnumSchema>;
-export interface JzodFunction {
-    extra?: {
-        [k: string]: any;
-    };
-    type: 'function';
-    definition: {
-        args: JzodElement[];
-        returns?: JzodElement;
-    };
-}
-export declare const jzodFunctionSchema: ZodType<JzodFunction>;
-export 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;
-}>;
-export type JzodLazy = z.infer<typeof jzodLazySchema>;
-export 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;
-}>;
-export type JzodLiteral = z.infer<typeof jzodLiteralSchema>;
-export interface JzodIntersection {
-    optional?: boolean;
-    nullable?: boolean;
-    extra?: {
-        [k: string]: any;
-    };
-    type: 'intersection';
-    definition: {
-        left: JzodElement;
-        right: JzodElement;
-    };
-}
-export declare const jzodIntersectionSchema: z.ZodType<JzodIntersection>;
-export interface JzodMap extends JzodRoot {
-    optional?: boolean;
-    nullable?: boolean;
-    extra?: {
-        [k: string]: any;
-    };
-    type: 'map';
-    definition: [JzodElement, JzodElement];
-}
-export declare const jzodMapSchema: z.ZodType<JzodMap>;
-export interface JzodObject extends JzodRoot {
-    optional?: boolean;
-    nullable?: boolean;
-    extend?: JzodReference | JzodObject;
-    extra?: {
-        [k: string]: any;
-    };
-    type: "object";
-    nonStrict?: boolean;
-    definition: {
-        [attributeName: string]: JzodElement;
-    };
-}
-export declare const jzodObjectSchema: z.ZodType<JzodObject>;
-export interface JzodPromise extends JzodRoot {
-    extra?: {
-        [k: string]: any;
-    };
-    type: 'promise';
-    definition: JzodElement;
-}
-export declare const jzodPromiseSchema: z.ZodType<JzodPromise>;
-export interface JzodRecord {
-    optional?: boolean;
-    nullable?: boolean;
-    extra?: {
-        [k: string]: any;
-    };
-    type: 'record';
-    definition: JzodElement;
-}
-export declare const jzodRecordSchema: z.ZodType<JzodRecord>;
-export interface JzodReference {
-    optional?: boolean;
-    nullable?: boolean;
-    extra?: {
-        [k: string]: any;
-    };
-    context?: {
-        [attributeName: string]: JzodElement;
-    };
-    type: 'schemaReference';
-    definition: {
-        eager?: boolean;
-        relativePath?: string;
-        absolutePath?: string;
-    };
-}
-export declare const jzodReferenceSchema: ZodType<JzodReference>;
-export interface JzodSet extends JzodRoot {
-    optional?: boolean;
-    nullable?: boolean;
-    extra?: {
-        [k: string]: any;
-    };
-    type: 'set';
-    definition: JzodElement;
-}
-export declare const jzodSetSchema: z.ZodType<JzodSet>;
-export interface JzodTuple {
-    optional?: boolean;
-    nullable?: boolean;
-    extra?: {
-        [k: string]: any;
-    };
-    type: 'tuple';
-    definition: JzodElement[];
-}
-export declare const jzodTupleSchema: z.ZodType<JzodTuple>;
-export interface JzodUnion {
-    optional?: boolean;
-    nullable?: boolean;
-    extra?: {
-        [k: string]: any;
-    };
-    type: "union";
-    discriminator?: string;
-    definition: JzodElement[];
-}
-export declare const jzodUnionSchema: z.ZodType<JzodUnion>;
-export {};
+import { ZodType, z } 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>;
+export declare const jzodEnumAttributeTypes: z.ZodEnum<["any", "bigint", "boolean", "date", "never", "null", "number", "string", "uuid", "undefined", "unknown", "void"]>;
+export type JzodEnumTypes = z.infer<typeof jzodEnumAttributeTypes>;
+export declare const jzodEnumElementTypes: z.ZodEnum<["array", "enum", "function", "lazy", "literal", "intersection", "map", "object", "promise", "record", "schemaReference", "set", "simpleType", "tuple", "union"]>;
+export type JzodEnumElementTypes = z.infer<typeof jzodEnumElementTypes>;
+export interface JzodArray extends JzodRoot {
+    optional?: boolean;
+    nullable?: boolean;
+    extra?: {
+        [k: string]: any;
+    };
+    type: 'array';
+    definition: JzodElement;
+}
+export declare const jzodArray: z.ZodType<JzodArray>;
+export 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;
+}>;
+export type JzodAttributeDateValidations = z.infer<typeof jzodAttributeDateValidations>;
+export 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;
+}>;
+export type JzodAttributeNumberValidations = z.infer<typeof jzodAttributeNumberValidations>;
+export 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;
+}>;
+export type JzodAttributeStringValidations = z.infer<typeof jzodAttributeStringValidations>;
+export 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;
+}>;
+export type JzodAttributeDateWithValidations = z.infer<typeof jzodAttributeDateWithValidations>;
+export 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;
+}>;
+export type JzodAttributeNumberWithValidations = z.infer<typeof jzodAttributeNumberWithValidations>;
+export 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;
+}>;
+export type JzodAttributeStringWithValidations = z.infer<typeof jzodAttributeStringWithValidations>;
+export 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;
+}>;
+export type JzodAttribute = z.infer<typeof jzodAttribute>;
+export type JzodElement = JzodArray | JzodAttribute | JzodAttributeDateWithValidations | JzodAttributeNumberWithValidations | JzodAttributeStringWithValidations | JzodEnum | JzodFunction | JzodLazy | JzodLiteral | JzodIntersection | JzodMap | JzodRecord | JzodObject | JzodPromise | JzodReference | JzodSet | JzodTuple | JzodUnion;
+export declare const jzodElement: z.ZodType<JzodElement>;
+export 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;
+}>;
+export type JzodEnum = z.infer<typeof jzodEnum>;
+export interface JzodFunction {
+    extra?: {
+        [k: string]: any;
+    };
+    type: 'function';
+    definition: {
+        args: JzodElement[];
+        returns?: JzodElement;
+    };
+}
+export declare const jzodFunction: ZodType<JzodFunction>;
+export 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;
+}>;
+export type JzodLazy = z.infer<typeof jzodLazy>;
+export 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;
+}>;
+export type JzodLiteral = z.infer<typeof jzodLiteral>;
+export interface JzodIntersection {
+    optional?: boolean;
+    nullable?: boolean;
+    extra?: {
+        [k: string]: any;
+    };
+    type: 'intersection';
+    definition: {
+        left: JzodElement;
+        right: JzodElement;
+    };
+}
+export declare const jzodIntersection: z.ZodType<JzodIntersection>;
+export interface JzodMap extends JzodRoot {
+    optional?: boolean;
+    nullable?: boolean;
+    extra?: {
+        [k: string]: any;
+    };
+    type: 'map';
+    definition: [JzodElement, JzodElement];
+}
+export declare const jzodMapSchema: z.ZodType<JzodMap>;
+export interface JzodObject extends JzodRoot {
+    optional?: boolean;
+    nullable?: boolean;
+    extend?: JzodReference | JzodObject;
+    extra?: {
+        [k: string]: any;
+    };
+    type: "object";
+    nonStrict?: boolean;
+    definition: {
+        [attributeName: string]: JzodElement;
+    };
+}
+export declare const jzodObject: z.ZodType<JzodObject>;
+export interface JzodPromise extends JzodRoot {
+    extra?: {
+        [k: string]: any;
+    };
+    type: 'promise';
+    definition: JzodElement;
+}
+export declare const jzodPromise: z.ZodType<JzodPromise>;
+export interface JzodRecord {
+    optional?: boolean;
+    nullable?: boolean;
+    extra?: {
+        [k: string]: any;
+    };
+    type: 'record';
+    definition: JzodElement;
+}
+export declare const jzodRecord: z.ZodType<JzodRecord>;
+export interface JzodReference {
+    optional?: boolean;
+    nullable?: boolean;
+    extra?: {
+        [k: string]: any;
+    };
+    context?: {
+        [attributeName: string]: JzodElement;
+    };
+    type: 'schemaReference';
+    definition: {
+        eager?: boolean;
+        relativePath?: string;
+        absolutePath?: string;
+    };
+}
+export declare const jzodReference: ZodType<JzodReference>;
+export interface JzodSet extends JzodRoot {
+    optional?: boolean;
+    nullable?: boolean;
+    extra?: {
+        [k: string]: any;
+    };
+    type: 'set';
+    definition: JzodElement;
+}
+export declare const jzodSet: z.ZodType<JzodSet>;
+export interface JzodTuple {
+    optional?: boolean;
+    nullable?: boolean;
+    extra?: {
+        [k: string]: any;
+    };
+    type: 'tuple';
+    definition: JzodElement[];
+}
+export declare const jzodTuple: z.ZodType<JzodTuple>;
+export interface JzodUnion {
+    optional?: boolean;
+    nullable?: boolean;
+    extra?: {
+        [k: string]: any;
+    };
+    type: "union";
+    discriminator?: string;
+    definition: JzodElement[];
+}
+export declare const jzodUnion: z.ZodType<JzodUnion>;
+export {};