@miroir-framework/jzod-ts 0.6.0 → 0.6.1

package/tests/resources/tsTypeGeneration-testJzodSchema4 - reference.ts

@@ -41,6 +41,7 @@ export type JzodAttributeDateWithValidations = {
     } | undefined;
     type: "simpleType";
     definition: "date";
+    coerce?: boolean | undefined;
     validations: JzodAttributeDateValidations[];
 };
 export type JzodAttributeNumberValidations = {
@@ -58,6 +59,7 @@ export type JzodAttributeNumberWithValidations = {
     } | undefined;
     type: "simpleType";
     definition: "number";
+    coerce?: boolean | undefined;
     validations: JzodAttributeNumberValidations[];
 };
 export type JzodAttributeStringValidations = {
@@ -75,6 +77,7 @@ export type JzodAttributeStringWithValidations = {
     } | undefined;
     type: "simpleType";
     definition: "string";
+    coerce?: boolean | undefined;
     validations: JzodAttributeStringValidations[];
 };
 export type JzodElement = JzodArray | JzodAttribute | JzodAttributeDateWithValidations | JzodAttributeNumberWithValidations | JzodAttributeStringWithValidations | JzodEnum | JzodFunction | JzodLazy | JzodLiteral | JzodIntersection | JzodMap | JzodObject | JzodPromise | JzodRecord | JzodReference | JzodSet | JzodTuple | JzodUnion;
@@ -98,7 +101,7 @@ export type JzodFunction = {
     type: "function";
     definition: {
         args: JzodElement[];
-        returns: JzodElement;
+        returns?: JzodElement | undefined;
     };
 };
 export type JzodLazy = {
@@ -224,21 +227,21 @@ export type TestJzodSchema4 = A;
 export const jzodBaseObject = z.object({optional:z.boolean().optional(), nullable:z.boolean().optional(), extra:z.record(z.string(),z.any()).optional()}).strict();
 export const jzodArray = z.object({optional:z.boolean().optional(), nullable:z.boolean().optional(), extra:z.record(z.string(),z.any()).optional()}).strict().extend({type:z.literal("array"), definition:z.lazy(() =>jzodElement)}).strict();
 export const jzodAttribute = z.object({optional:z.boolean().optional(), nullable:z.boolean().optional(), extra:z.record(z.string(),z.any()).optional()}).strict().extend({type:z.literal("simpleType"), coerce:z.boolean().optional(), definition:z.lazy(() =>jzodEnumAttributeTypes)}).strict();
-export const jzodAttributeDateValidations = z.object({extra:z.record(z.string(),z.any()).optional(), type:z.enum(["min","max"] as any), parameter:z.any()}).strict();
-export const jzodAttributeDateWithValidations = z.object({optional:z.boolean().optional(), nullable:z.boolean().optional(), extra:z.record(z.string(),z.any()).optional()}).strict().extend({type:z.literal("simpleType"), definition:z.literal("date"), validations:z.array(z.lazy(() =>jzodAttributeDateValidations))}).strict();
-export 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"] as any), parameter:z.any()}).strict();
-export const jzodAttributeNumberWithValidations = z.object({optional:z.boolean().optional(), nullable:z.boolean().optional(), extra:z.record(z.string(),z.any()).optional()}).strict().extend({type:z.literal("simpleType"), definition:z.literal("number"), validations:z.array(z.lazy(() =>jzodAttributeNumberValidations))}).strict();
-export 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"] as any), parameter:z.any()}).strict();
-export const jzodAttributeStringWithValidations = z.object({optional:z.boolean().optional(), nullable:z.boolean().optional(), extra:z.record(z.string(),z.any()).optional()}).strict().extend({type:z.literal("simpleType"), definition:z.literal("string"), validations:z.array(z.lazy(() =>jzodAttributeStringValidations))}).strict();
+export const jzodAttributeDateValidations = z.object({extra:z.record(z.string(),z.any()).optional(), type:z.enum(["min","max"]), parameter:z.any()}).strict();
+export const jzodAttributeDateWithValidations = z.object({optional:z.boolean().optional(), nullable:z.boolean().optional(), extra:z.record(z.string(),z.any()).optional()}).strict().extend({type:z.literal("simpleType"), definition:z.literal("date"), coerce:z.boolean().optional(), validations:z.array(z.lazy(() =>jzodAttributeDateValidations))}).strict();
+export 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();
+export const jzodAttributeNumberWithValidations = z.object({optional:z.boolean().optional(), nullable:z.boolean().optional(), extra:z.record(z.string(),z.any()).optional()}).strict().extend({type:z.literal("simpleType"), definition:z.literal("number"), coerce:z.boolean().optional(), validations:z.array(z.lazy(() =>jzodAttributeNumberValidations))}).strict();
+export 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();
+export const jzodAttributeStringWithValidations = z.object({optional:z.boolean().optional(), nullable:z.boolean().optional(), extra:z.record(z.string(),z.any()).optional()}).strict().extend({type:z.literal("simpleType"), definition:z.literal("string"), coerce:z.boolean().optional(), validations:z.array(z.lazy(() =>jzodAttributeStringValidations))}).strict();
 export 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(() =>jzodMap), z.lazy(() =>jzodObject), z.lazy(() =>jzodPromise), z.lazy(() =>jzodRecord), z.lazy(() =>jzodReference), z.lazy(() =>jzodSet), z.lazy(() =>jzodTuple), z.lazy(() =>jzodUnion)]);
 export const jzodEnum = z.object({optional:z.boolean().optional(), nullable:z.boolean().optional(), extra:z.record(z.string(),z.any()).optional()}).strict().extend({type:z.literal("enum"), definition:z.array(z.string())}).strict();
-export const jzodEnumAttributeTypes = z.enum(["any","bigint","boolean","date","never","null","number","string","uuid","undefined","unknown","void"] as any);
-export const jzodEnumElementTypes = z.enum(["array","enum","function","lazy","literal","intersection","map","object","promise","record","schemaReference","set","simpleType","tuple","union"] as any);
+export const jzodEnumAttributeTypes = z.enum(["any","bigint","boolean","date","never","null","number","string","uuid","undefined","unknown","void"]);
+export const jzodEnumElementTypes = z.enum(["array","enum","function","lazy","literal","intersection","map","object","promise","record","schemaReference","set","simpleType","tuple","union"]);
 export const jzodFunction = z.object({optional:z.boolean().optional(), nullable:z.boolean().optional(), extra:z.record(z.string(),z.any()).optional()}).strict().extend({type:z.literal("function"), definition:z.object({args:z.array(z.lazy(() =>jzodElement)), returns:z.lazy(() =>jzodElement).optional()}).strict()}).strict();
 export const jzodLazy = z.object({optional:z.boolean().optional(), nullable:z.boolean().optional(), extra:z.record(z.string(),z.any()).optional()}).strict().extend({type:z.literal("lazy"), definition:z.lazy(() =>jzodFunction)}).strict();
 export const jzodLiteral = z.object({optional:z.boolean().optional(), nullable:z.boolean().optional(), extra:z.record(z.string(),z.any()).optional()}).strict().extend({type:z.literal("literal"), definition:z.string()}).strict();
 export const jzodIntersection = z.object({optional:z.boolean().optional(), nullable:z.boolean().optional(), extra:z.record(z.string(),z.any()).optional()}).strict().extend({type:z.literal("intersection"), definition:z.object({left:z.lazy(() =>jzodElement), right:z.lazy(() =>jzodElement)}).strict()}).strict();
-export const jzodMap = z.object({optional:z.boolean().optional(), nullable:z.boolean().optional(), extra:z.record(z.string(),z.any()).optional()}).strict().extend({type:z.literal("map"), definition:z.tuple(["z.lazy(() =>jzodElement)","z.lazy(() =>jzodElement)"] as any)}).strict();
+export const jzodMap = z.object({optional:z.boolean().optional(), nullable:z.boolean().optional(), extra:z.record(z.string(),z.any()).optional()}).strict().extend({type:z.literal("map"), definition:z.tuple([z.lazy(() =>jzodElement), z.lazy(() =>jzodElement)])}).strict();
 export const jzodObject = z.object({optional:z.boolean().optional(), nullable:z.boolean().optional(), extra:z.record(z.string(),z.any()).optional()}).strict().extend({extend:z.union([z.lazy(() =>jzodReference), z.lazy(() =>jzodObject)]).optional(), type:z.literal("object"), nonStrict:z.boolean().optional(), definition:z.record(z.string(),z.lazy(() =>jzodElement))}).strict();
 export const jzodPromise = z.object({optional:z.boolean().optional(), nullable:z.boolean().optional(), extra:z.record(z.string(),z.any()).optional()}).strict().extend({type:z.literal("promise"), definition:z.lazy(() =>jzodElement)}).strict();
 export const jzodRecord = z.object({optional:z.boolean().optional(), nullable:z.boolean().optional(), extra:z.record(z.string(),z.any()).optional()}).strict().extend({type:z.literal("record"), definition:z.lazy(() =>jzodElement)}).strict();
@@ -247,4 +250,4 @@ export const jzodSet = z.object({optional:z.boolean().optional(), nullable:z.boo
 export const jzodTuple = z.object({optional:z.boolean().optional(), nullable:z.boolean().optional(), extra:z.record(z.string(),z.any()).optional()}).strict().extend({type:z.literal("tuple"), definition:z.array(z.lazy(() =>jzodElement))}).strict();
 export const jzodUnion = z.object({optional:z.boolean().optional(), nullable:z.boolean().optional(), extra:z.record(z.string(),z.any()).optional()}).strict().extend({type:z.literal("union"), discriminator:z.string().optional(), definition:z.array(z.lazy(() =>jzodElement))}).strict();
 export const a = z.array(z.lazy(() =>jzodArray));
-export const testJzodSchema4 = z.lazy(() =>a);
+export const testJzodSchema4 = z.lazy(() =>a);

package/dist/out-tsc/dts/src/JzodTsInterface.d.ts

@@ -1,397 +0,0 @@
-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: "max" | "min";
-    extra?: Record<string, any> | undefined;
-    parameter?: any;
-}, {
-    type: "max" | "min";
-    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" | "int" | "finite" | "gt" | "gte" | "lt" | "lte" | "positive" | "nonpositive" | "negative" | "nonnegative" | "safe";
-    extra?: Record<string, any> | undefined;
-    parameter?: any;
-}, {
-    type: "multipleOf" | "int" | "finite" | "gt" | "gte" | "lt" | "lte" | "positive" | "nonpositive" | "negative" | "nonnegative" | "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" | "endsWith" | "startsWith" | "max" | "url" | "email" | "emoji" | "uuid" | "regex" | "cuid" | "cuid2" | "ulid" | "datetime" | "ip" | "min";
-    extra?: Record<string, any> | undefined;
-    parameter?: any;
-}, {
-    type: "length" | "includes" | "endsWith" | "startsWith" | "max" | "url" | "email" | "emoji" | "uuid" | "regex" | "cuid" | "cuid2" | "ulid" | "datetime" | "ip" | "min";
-    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: "max" | "min";
-        extra?: Record<string, any> | undefined;
-        parameter?: any;
-    }, {
-        type: "max" | "min";
-        extra?: Record<string, any> | undefined;
-        parameter?: any;
-    }>, "many">;
-}, "strict", z.ZodTypeAny, {
-    type: "simpleType";
-    definition: "date";
-    validations: {
-        type: "max" | "min";
-        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: "max" | "min";
-        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" | "int" | "finite" | "gt" | "gte" | "lt" | "lte" | "positive" | "nonpositive" | "negative" | "nonnegative" | "safe";
-        extra?: Record<string, any> | undefined;
-        parameter?: any;
-    }, {
-        type: "multipleOf" | "int" | "finite" | "gt" | "gte" | "lt" | "lte" | "positive" | "nonpositive" | "negative" | "nonnegative" | "safe";
-        extra?: Record<string, any> | undefined;
-        parameter?: any;
-    }>, "many">;
-}, "strict", z.ZodTypeAny, {
-    type: "simpleType";
-    definition: "number";
-    validations: {
-        type: "multipleOf" | "int" | "finite" | "gt" | "gte" | "lt" | "lte" | "positive" | "nonpositive" | "negative" | "nonnegative" | "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" | "int" | "finite" | "gt" | "gte" | "lt" | "lte" | "positive" | "nonpositive" | "negative" | "nonnegative" | "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" | "endsWith" | "startsWith" | "max" | "url" | "email" | "emoji" | "uuid" | "regex" | "cuid" | "cuid2" | "ulid" | "datetime" | "ip" | "min";
-        extra?: Record<string, any> | undefined;
-        parameter?: any;
-    }, {
-        type: "length" | "includes" | "endsWith" | "startsWith" | "max" | "url" | "email" | "emoji" | "uuid" | "regex" | "cuid" | "cuid2" | "ulid" | "datetime" | "ip" | "min";
-        extra?: Record<string, any> | undefined;
-        parameter?: any;
-    }>, "many">;
-}, "strict", z.ZodTypeAny, {
-    type: "simpleType";
-    definition: "string";
-    validations: {
-        type: "length" | "includes" | "endsWith" | "startsWith" | "max" | "url" | "email" | "emoji" | "uuid" | "regex" | "cuid" | "cuid2" | "ulid" | "datetime" | "ip" | "min";
-        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" | "endsWith" | "startsWith" | "max" | "url" | "email" | "emoji" | "uuid" | "regex" | "cuid" | "cuid2" | "ulid" | "datetime" | "ip" | "min";
-        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" | "unknown" | "any" | "never" | "date" | "null" | "void" | "uuid";
-    optional?: boolean | undefined;
-    nullable?: boolean | undefined;
-    extra?: Record<string, any> | undefined;
-    coerce?: boolean | undefined;
-}, {
-    type: "simpleType";
-    definition: "string" | "number" | "bigint" | "boolean" | "undefined" | "unknown" | "any" | "never" | "date" | "null" | "void" | "uuid";
-    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 {};

package/dist/out-tsc/src/JzodToTs.js

@@ -1,47 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.jzodToTsCode = exports.jzodToTsTypeAliasesAndZodText = void 0;
-var zod_to_ts_1 = require("zod-to-ts");
-var jzod_1 = require("@miroir-framework/jzod");
-var tools_1 = require("./tools");
-function jzodToTsTypeAliasesAndZodText(element, typeName) {
-    var _a, _b;
-    var elementZodSchemaAndDescription = (0, jzod_1.jzodElementSchemaToZodSchemaAndDescription)(element, function () { return ({}); }, function () { return ({}); }, function (innerReference, relativeReference) {
-        return (0, zod_to_ts_1.withGetType)(innerReference, function (ts) {
-            var actualTypeName = relativeReference ? relativeReference.replace(/^(.)(.*)$/, function (a, b, c) { return b.toUpperCase() + c; }) : "";
-            return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(actualTypeName ? actualTypeName : "RELATIVEPATH_NOT_DEFINED"), undefined);
-        });
-    });
-    var contextTsTypesString = Object.fromEntries(Object.entries((_a = elementZodSchemaAndDescription.contextZodSchema) !== null && _a !== void 0 ? _a : {}).map(function (curr) {
-        var actualTypeName = curr[0] ? curr[0].replace(/^(.)(.*)$/, function (a, b, c) { return b.toUpperCase() + c; }) : "";
-        var tsNode = (0, zod_to_ts_1.zodToTs)(curr[1], typeName).node;
-        var typeAlias = (0, zod_to_ts_1.createTypeAlias)(tsNode, actualTypeName);
-        return [curr[0], typeAlias];
-    }));
-    var tsTypeStringNode = (0, zod_to_ts_1.zodToTs)(elementZodSchemaAndDescription.zodSchema, typeName).node;
-    var tsTypeStringTypeAlias = (0, zod_to_ts_1.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,
-    };
-}
-exports.jzodToTsTypeAliasesAndZodText = jzodToTsTypeAliasesAndZodText;
-function jzodToTsCode(jzodElement, exportPrefix, typeName) {
-    if (exportPrefix === void 0) { exportPrefix = true; }
-    var schemaName = typeName ? typeName.replace(/^(.)(.*)$/, function (a, b, c) { return b.toLowerCase() + c; }) : "";
-    var actualTypeName = typeName ? typeName.replace(/^(.)(.*)$/, function (a, b, c) { return b.toUpperCase() + c; }) : "";
-    var header = "import { ZodType, ZodTypeAny, z } from \"zod\";";
-    var typeAliasesAndZodText = jzodToTsTypeAliasesAndZodText(jzodElement, actualTypeName);
-    var bodyJsCode = "export const ".concat(schemaName, " = ").concat(typeAliasesAndZodText.mainZodText, ";");
-    var contextTsTypesString = (0, tools_1.printTsTypeAliases)(typeAliasesAndZodText.contextTsTypeAliases, exportPrefix);
-    var contextJsCode = typeAliasesAndZodText.contextZodText
-        ? Object.entries(typeAliasesAndZodText.contextZodText).reduce(function (acc, curr) {
-            return "".concat(acc, "\nexport const ").concat(curr[0], " = ").concat(curr[1], ";");
-        }, "")
-        : "";
-    var tsTypesString = (exportPrefix ? "export " : "") + (0, zod_to_ts_1.printNode)(typeAliasesAndZodText.mainTsTypeAlias);
-    return "".concat(header, "\n").concat(contextTsTypesString, "\n").concat(tsTypesString, "\n").concat(contextJsCode, "\n").concat(bodyJsCode, "\n");
-}
-exports.jzodToTsCode = jzodToTsCode;