@miroir-framework/jzod-ts 0.5.3 → 0.6.0

package/package.json

@@ -1,38 +1,40 @@
-{
-  "name": "@miroir-framework/jzod-ts",
-  "private": false,
-  "version": "0.5.3",
-  "description": "The Typescript-related functionalities of Jzod.",
-  "main": "dist/bundle.js",
-  "types": "dist/bundle.d.ts",
-  "type": "module",
-  "scripts": {
-    "build": "rollup --config",
-    "test": "cross-env NODE_ENV=test jest --verbose --silent=false -t"
-  },
-  "author": "Arnaud Bailly <miroir-framework@protonmail.com>",
-  "homepage": "https://github.com/miroir-framework/jzod/#readme",
-  "bugs": "https://github.com/miroir-framework/jzod/issues",
-  "license": "MIT",
-  "dependencies": {
-    "@miroir-framework/jzod": "0.5.3",
-    "zod": "^3.22.2",
-    "zod-to-ts": "^1.2.0"
-  },
-  "devDependencies": {
-    "@babel/plugin-transform-modules-commonjs": "^7.20.11",
-    "@babel/preset-env": "^7.22.5",
-    "@jest/globals": "^29.3.1",
-    "@rollup/plugin-commonjs": "^24.0.1",
-    "@rollup/plugin-json": "^6.0.0",
-    "@types/jest": "^29.2.4",
-    "babel-jest": "^29.4.0",
-    "rollup": "^3.10.1",
-    "rollup-plugin-dts": "^5.1.1",
-    "rollup-plugin-typescript2": "^0.34.1",
-    "ts-jest": "^29.0.3",
-    "tsconfig-paths": "^4.1.2",
-    "typescript": "^4.9.4",
-    "zod-to-json-schema": "^3.21.2"
-  }
-}
+{
+  "name": "@miroir-framework/jzod-ts",
+  "private": false,
+  "version": "0.6.0",
+  "description": "The Typescript-related functionalities of Jzod.",
+  "main": "dist/bundle.js",
+  "types": "dist/bundle.d.ts",
+  "type": "module",
+  "scripts": {
+    "preBuild": "npm run-script ./dist/out-tsc/src/preBuild.js",
+    "compile": "npx tsc",
+    "build": "rollup --config",
+    "test": "cross-env NODE_ENV=test jest --verbose --silent=false -t"
+  },
+  "author": "Arnaud Bailly <miroir-framework@protonmail.com>",
+  "homepage": "https://github.com/miroir-framework/jzod/#readme",
+  "bugs": "https://github.com/miroir-framework/jzod/issues",
+  "license": "MIT",
+  "dependencies": {
+    "@miroir-framework/jzod": "0.6.0",
+    "zod": "^3.22.2",
+    "zod-to-ts": "^1.2.0"
+  },
+  "devDependencies": {
+    "@babel/plugin-transform-modules-commonjs": "^7.20.11",
+    "@babel/preset-env": "^7.22.5",
+    "@jest/globals": "^29.3.1",
+    "@rollup/plugin-commonjs": "^24.0.1",
+    "@rollup/plugin-json": "^6.0.0",
+    "@types/jest": "^29.2.4",
+    "babel-jest": "^29.4.0",
+    "rollup": "^3.10.1",
+    "rollup-plugin-dts": "^5.1.1",
+    "rollup-plugin-typescript2": "^0.34.1",
+    "ts-jest": "^29.0.3",
+    "tsconfig-paths": "^4.1.2",
+    "typescript": "5.0.3",
+    "zod-to-json-schema": "^3.21.2"
+  }
+}

package/src/JzodToTs.ts

@@ -1,109 +1,114 @@
-import ts from "typescript";
-import { ZodLazy } from "zod";
-import { createTypeAlias, printNode, withGetType, zodToTs } from "zod-to-ts";
-
-import { jzodElementSchemaToZodSchemaAndDescription } from "@miroir-framework/jzod";
-
-import { JzodElement } from "./JzodTsInterface";
-
-import { printTsTypeAliases } from "./tools";
-// ################################################################################################
-export type TsTypeAliases =  {
-  [k: string]: ts.TypeAliasDeclaration;
-}
-
-// ################################################################################################
-export interface TsTypeAliasesAndZodText {
-  contextTsTypeAliases: { [k: string]: ts.TypeAliasDeclaration },
-  contextZodText: { [k: string]: string },
-  mainTsTypeAlias: ts.TypeAliasDeclaration,
-  mainZodText: string 
-}
-
-// ################################################################################################
-export function jzodToTsTypeAliasesAndZodText(
-  element: JzodElement,
-  typeName?: string,
-): TsTypeAliasesAndZodText
-{
-  const elementZodSchemaAndDescription = jzodElementSchemaToZodSchemaAndDescription(
-    element,
-    () => ({}),
-    () => ({}),
-    (innerReference: ZodLazy<any>, relativeReference: string | undefined) =>
-      withGetType(innerReference, (ts) => {
-        const actualTypeName = relativeReference?relativeReference.replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c):"";
-        return ts.factory.createTypeReferenceNode(
-
-          ts.factory.createIdentifier(actualTypeName ? actualTypeName : "RELATIVEPATH_NOT_DEFINED")
-        );
-      }
-    )
-  );
-
-  const contextTsTypesString = Object.fromEntries(
-    Object.entries(elementZodSchemaAndDescription.contextZodSchema ?? {}).map((curr) => {
-      const actualTypeName = curr[0]?curr[0].replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c):"";
-      // console.log("getTsCodeCorrespondingToZodSchemaAndDescription ", JSON.stringify(curr));
-      const tsNode = zodToTs(curr[1], typeName).node;
-      const typeAlias = createTypeAlias(tsNode, actualTypeName);
-      return [curr[0], typeAlias];
-    })
-  );
-
-  const tsTypeStringNode = zodToTs(elementZodSchemaAndDescription.zodSchema, typeName).node;
-  const tsTypeStringTypeAlias = createTypeAlias(tsTypeStringNode, typeName??"");
-
-  return {
-    contextTsTypeAliases: contextTsTypesString,
-    contextZodText: elementZodSchemaAndDescription.contextZodText??{},
-    mainZodText: elementZodSchemaAndDescription.zodText,
-    mainTsTypeAlias: tsTypeStringTypeAlias,
-  };
-}
-
-
-// ################################################################################################
-export function jzodToTsCode (
-  jzodElement: JzodElement,
-  exportPrefix: boolean = true,
-  typeName?: string,
-): string {
-  // console.log(
-  //   "getTsCodeCorrespondingToZodSchemaAndDescription jzodSchemaZodSchemaAndDescription.contextZodSchema",
-  //   "jzodElement",
-  //   JSON.stringify(jzodElement)
-  // );
-  
-  const schemaName = typeName?typeName.replace(/^(.)(.*)$/, (a, b, c) => b.toLowerCase() + c):"";
-  const actualTypeName = typeName?typeName.replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c):"";
-  // console.log("getTsCodeCorrespondingToZodSchemaAndDescription convertedJsonZodSchema", bodyJsCode);
-
-  const header = `import { ZodType, ZodTypeAny, z } from "zod";`;
-
-  const typeAliasesAndZodText = jzodToTsTypeAliasesAndZodText(jzodElement, actualTypeName);
-
-  const bodyJsCode = `export const ${schemaName}: z.ZodType<${actualTypeName}> = ${typeAliasesAndZodText.mainZodText};`;
-
-  const contextTsTypesString = printTsTypeAliases(typeAliasesAndZodText.contextTsTypeAliases, exportPrefix);
-  // console.log("getTsCodeCorrespondingToZodSchemaAndDescription contextTsTypesString",contextTsTypesString);
-
-  const contextJsCode = typeAliasesAndZodText.contextZodText
-    ? Object.entries(typeAliasesAndZodText.contextZodText).reduce((acc, curr) => {
-        const contextTypeName = curr[0]?curr[0].replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c):"";
-        return `${acc}
-export const ${curr[0]}:z.ZodType<${contextTypeName}> = ${curr[1]};`;
-      }, "")
-    : ""
-  ;
-
-  const tsTypesString = (exportPrefix?"export ":"") + printNode(typeAliasesAndZodText.mainTsTypeAlias);
-  // console.log("getTsCodeCorrespondingToZodSchemaAndDescription tsTypeString",tsTypesString);
-
-  return `${header}
-${contextTsTypesString}
-${tsTypesString}
-${contextJsCode}
-${bodyJsCode}
-`;
-}
+import ts from "typescript";
+import { ZodTypeAny } from "zod";
+import { GetType, createTypeAlias, printNode, withGetType, zodToTs } from "zod-to-ts";
+
+import { jzodElementSchemaToZodSchemaAndDescription } from "@miroir-framework/jzod";
+
+import { JzodElement } from "./generated_jzodBootstrapElementSchema";
+
+import { printTsTypeAliases } from "./tools";
+// ################################################################################################
+export type TsTypeAliases =  {
+  [k: string]: ts.TypeAliasDeclaration;
+}
+
+// ################################################################################################
+export interface TsTypeAliasesAndZodText {
+  contextTsTypeAliases: { [k: string]: ts.TypeAliasDeclaration },
+  contextZodText: { [k: string]: string },
+  mainTsTypeAlias: ts.TypeAliasDeclaration,
+  mainZodText: string 
+}
+
+// ################################################################################################
+export function jzodToTsTypeAliasesAndZodText(
+  element: JzodElement,
+  typeName?: string,
+): TsTypeAliasesAndZodText
+{
+  const elementZodSchemaAndDescription = jzodElementSchemaToZodSchemaAndDescription(
+    element,
+    () => ({}),
+    () => ({}),
+    (innerReference: ZodTypeAny & GetType, relativeReference: string | undefined) =>
+      withGetType(innerReference, (ts:any) => {
+        const actualTypeName = relativeReference?relativeReference.replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c):"";
+        return ts.factory.createTypeReferenceNode(
+          ts.factory.createIdentifier(actualTypeName ? actualTypeName : "RELATIVEPATH_NOT_DEFINED"),
+          undefined
+        );
+      }
+    ) 
+  );
+
+  const contextTsTypesString = Object.fromEntries(
+    Object.entries(elementZodSchemaAndDescription.contextZodSchema ?? {}).map((curr) => {
+      const actualTypeName = curr[0]?curr[0].replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c):"";
+      const tsNode = zodToTs(curr[1], typeName).node;
+      const typeAlias = createTypeAlias(tsNode, actualTypeName);
+      return [curr[0], typeAlias];
+    })
+  );
+
+  const tsTypeStringNode = zodToTs(elementZodSchemaAndDescription.zodSchema, typeName).node;
+  const tsTypeStringTypeAlias = createTypeAlias(tsTypeStringNode, typeName??"");
+
+  return {
+    contextTsTypeAliases: contextTsTypesString,
+    contextZodText: elementZodSchemaAndDescription.contextZodText??{},
+    mainZodText: elementZodSchemaAndDescription.zodText,
+    mainTsTypeAlias: tsTypeStringTypeAlias,
+  };
+}
+
+
+// ################################################################################################
+export function jzodToTsCode (
+  jzodElement: JzodElement,
+  exportPrefix: boolean = true,
+  typeName?: string,
+  typeSchema: boolean = false,
+): string {
+  // console.log(
+  //   "################################### jzodToTsCode ",
+  //   "jzodElement",
+  //   JSON.stringify(jzodElement, null, 2)
+  // );
+  
+  const schemaName = typeName?typeName.replace(/^(.)(.*)$/, (a, b, c) => b.toLowerCase() + c):"";
+  const actualTypeName = typeName?typeName.replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c):"";
+  // console.log("jzodToTsCode convertedJsonZodSchema", bodyJsCode);
+
+  const header = `import { ZodType, ZodTypeAny, z } from "zod";`;
+
+  const typeAliasesAndZodText = jzodToTsTypeAliasesAndZodText(jzodElement, actualTypeName);
+
+  const bodyJsCode = typeSchema
+    ? `export const ${schemaName}: z.ZodType<${actualTypeName}> = ${typeAliasesAndZodText.mainZodText};`
+    : `export const ${schemaName} = ${typeAliasesAndZodText.mainZodText};`;
+
+  const contextTsTypesString = printTsTypeAliases(typeAliasesAndZodText.contextTsTypeAliases, exportPrefix);
+  // console.log("jzodToTsCode zod text for converted jzodElement",typeAliasesAndZodText.contextZodText);
+
+  const contextJsCode = typeAliasesAndZodText.contextZodText
+    ? Object.entries(typeAliasesAndZodText.contextZodText).reduce((acc, curr) => {
+      const contextTypeName = curr[0]?curr[0].replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c):"";
+      return typeSchema?
+        `${acc}
+export const ${curr[0]}: z.ZodType<${contextTypeName}> = ${curr[1]};`:
+        `${acc}
+export const ${curr[0]} = ${curr[1]};`;
+      }, "")
+    : ""
+  ;
+
+  const tsTypesString = (exportPrefix?"export ":"") + printNode(typeAliasesAndZodText.mainTsTypeAlias);
+  // console.log("getTsCodeCorrespondingToZodSchemaAndDescription tsTypeString",tsTypesString);
+
+  return `${header}
+${contextTsTypesString}
+${tsTypesString}
+${contextJsCode}
+${bodyJsCode}
+`;
+}

package/src/generated_jzodBootstrapElementSchema.ts

@@ -0,0 +1,249 @@
+import { ZodType, ZodTypeAny, z } from "zod";
+
+export type JzodBaseObject = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+};
+export type JzodArray = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "array";
+    definition: JzodElement;
+};
+export type JzodAttribute = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "simpleType";
+    coerce?: boolean | undefined;
+    definition: JzodEnumAttributeTypes;
+};
+export type JzodAttributeDateValidations = {
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "min" | "max";
+    parameter?: any;
+};
+export type JzodAttributeDateWithValidations = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "simpleType";
+    definition: "date";
+    validations: JzodAttributeDateValidations[];
+};
+export type JzodAttributeNumberValidations = {
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "gt" | "gte" | "lt" | "lte" | "int" | "positive" | "nonpositive" | "negative" | "nonnegative" | "multipleOf" | "finite" | "safe";
+    parameter?: any;
+};
+export type JzodAttributeNumberWithValidations = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "simpleType";
+    definition: "number";
+    validations: JzodAttributeNumberValidations[];
+};
+export type JzodAttributeStringValidations = {
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "max" | "min" | "length" | "email" | "url" | "emoji" | "uuid" | "cuid" | "cuid2" | "ulid" | "regex" | "includes" | "startsWith" | "endsWith" | "datetime" | "ip";
+    parameter?: any;
+};
+export type JzodAttributeStringWithValidations = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "simpleType";
+    definition: "string";
+    validations: JzodAttributeStringValidations[];
+};
+export type JzodElement = JzodArray | JzodAttribute | JzodAttributeDateWithValidations | JzodAttributeNumberWithValidations | JzodAttributeStringWithValidations | JzodEnum | JzodFunction | JzodLazy | JzodLiteral | JzodIntersection | JzodMap | JzodObject | JzodPromise | JzodRecord | JzodReference | JzodSet | JzodTuple | JzodUnion;
+export type JzodEnum = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "enum";
+    definition: string[];
+};
+export type JzodEnumAttributeTypes = "any" | "bigint" | "boolean" | "date" | "never" | "null" | "number" | "string" | "uuid" | "undefined" | "unknown" | "void";
+export type JzodEnumElementTypes = "array" | "enum" | "function" | "lazy" | "literal" | "intersection" | "map" | "object" | "promise" | "record" | "schemaReference" | "set" | "simpleType" | "tuple" | "union";
+export type JzodFunction = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "function";
+    definition: {
+        args: JzodElement[];
+        returns?: JzodElement | undefined;
+    };
+};
+export type JzodLazy = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "lazy";
+    definition: JzodFunction;
+};
+export type JzodLiteral = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "literal";
+    definition: string;
+};
+export type JzodIntersection = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "intersection";
+    definition: {
+        left: JzodElement;
+        right: JzodElement;
+    };
+};
+export type JzodMap = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "map";
+    definition: [
+        JzodElement,
+        JzodElement
+    ];
+};
+export type JzodObject = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    extend?: (JzodReference | JzodObject) | undefined;
+    type: "object";
+    nonStrict?: boolean | undefined;
+    definition: {
+        [x: string]: JzodElement;
+    };
+};
+export type JzodPromise = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "promise";
+    definition: JzodElement;
+};
+export type JzodRecord = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "record";
+    definition: JzodElement;
+};
+export type JzodReference = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "schemaReference";
+    context?: {
+        [x: string]: JzodElement;
+    } | undefined;
+    definition: {
+        eager?: boolean | undefined;
+        relativePath?: string | undefined;
+        absolutePath?: string | undefined;
+    };
+};
+export type JzodSet = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "set";
+    definition: JzodElement;
+};
+export type JzodTuple = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "tuple";
+    definition: JzodElement[];
+};
+export type JzodUnion = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "union";
+    discriminator?: string | undefined;
+    definition: JzodElement[];
+};
+export type JzodBootstrapElementSchema = JzodElement;
+
+export const jzodBaseObject: z.ZodType<JzodBaseObject> = z.object({optional:z.boolean().optional(), nullable:z.boolean().optional(), extra:z.record(z.string(),z.any()).optional()}).strict();
+export const jzodArray: z.ZodType<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.ZodType<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.ZodType<JzodAttributeDateValidations> = z.object({extra:z.record(z.string(),z.any()).optional(), type:z.enum(["min","max"]), parameter:z.any()}).strict();
+export const jzodAttributeDateWithValidations: z.ZodType<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.ZodType<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.ZodType<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.ZodType<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.ZodType<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 jzodElement: z.ZodType<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.ZodType<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.ZodType<JzodEnumAttributeTypes> = z.enum(["any","bigint","boolean","date","never","null","number","string","uuid","undefined","unknown","void"]);
+export const jzodEnumElementTypes: z.ZodType<JzodEnumElementTypes> = z.enum(["array","enum","function","lazy","literal","intersection","map","object","promise","record","schemaReference","set","simpleType","tuple","union"]);
+export const jzodFunction: z.ZodType<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.ZodType<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.ZodType<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.ZodType<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.ZodType<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.ZodType<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.ZodType<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.ZodType<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();
+export const jzodReference: z.ZodType<JzodReference> = z.object({optional:z.boolean().optional(), nullable:z.boolean().optional(), extra:z.record(z.string(),z.any()).optional()}).strict().extend({type:z.literal("schemaReference"), context:z.record(z.string(),z.lazy(() =>jzodElement)).optional(), definition:z.object({eager:z.boolean().optional(), relativePath:z.string().optional(), absolutePath:z.string().optional()}).strict()}).strict();
+export const jzodSet: z.ZodType<JzodSet> = z.object({optional:z.boolean().optional(), nullable:z.boolean().optional(), extra:z.record(z.string(),z.any()).optional()}).strict().extend({type:z.literal("set"), definition:z.lazy(() =>jzodElement)}).strict();
+export const jzodTuple: z.ZodType<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.ZodType<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 jzodBootstrapElementSchema: z.ZodType<JzodBootstrapElementSchema> = z.lazy(() =>jzodElement);
+