@miroir-framework/jzod-ts 0.7.0 → 0.8.2

package/dist/index.js

@@ -0,0 +1,182 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import { fileURLToPath } from 'url'
+import { dirname } from 'path'
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+
+// src/JzodToTs.ts
+import { createTypeAlias, printNode, zodToTs } from "zod-to-ts";
+import {
+  jzodToZodTextAndZodSchema
+} from "@miroir-framework/jzod";
+function jzodToZodTextAndZodSchemaForTsGeneration(element, context = {}) {
+  const contextFunction = () => context;
+  const elementZodSchemaAndDescription = jzodToZodTextAndZodSchema(
+    element,
+    contextFunction,
+    contextFunction,
+    { typeScriptGeneration: true }
+    // typeScriptGeneration
+  );
+  return elementZodSchemaAndDescription;
+}
+function jzodToZodTextAndTsTypeText(element, context = {}, typeName) {
+  const elementZodSchemaAndDescription = jzodToZodTextAndZodSchemaForTsGeneration(
+    element,
+    context
+  );
+  const contextTsTypesStringObject = Object.fromEntries(
+    Object.entries(elementZodSchemaAndDescription.contextZodSchema ?? {}).map((curr) => {
+      const actualTypeName2 = curr[0] ? curr[0].replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c) : "";
+      const tsNode = zodToTs(curr[1], typeName).node;
+      const typeAlias = createTypeAlias(tsNode, actualTypeName2);
+      const tsTypeString2 = printNode(typeAlias);
+      return [curr[0], tsTypeString2];
+    })
+  );
+  const actualTypeName = typeName ? typeName.replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c) : "";
+  const tsTypeStringNode = zodToTs(elementZodSchemaAndDescription.zodSchema, typeName).node;
+  const tsTypeAlias = createTypeAlias(tsTypeStringNode, actualTypeName);
+  const tsTypeString = printNode(tsTypeAlias);
+  return {
+    contextTsTypeText: contextTsTypesStringObject,
+    contextZodText: elementZodSchemaAndDescription.contextZodText ?? {},
+    zodText: elementZodSchemaAndDescription.zodText,
+    tsTypeText: tsTypeString
+  };
+}
+function jzodToZodTextAndTsTypeAliases(element, context = {}, typeName) {
+  const jzodToTsTypeAliasesAndZodTextStartTime = Date.now();
+  console.log("@@@@@@@@@@@@@@@@@ jzodToZodTextAndTsTypeAliases start!", Object.keys(context).length);
+  console.log("jzodToZodTextAndTsTypeAliases context:", JSON.stringify(Object.keys(context)));
+  const elementZodSchemaAndDescription = jzodToZodTextAndZodSchemaForTsGeneration(
+    element,
+    context
+  );
+  console.log(
+    "jzodToZodTextAndTsTypeAliases jzodToZodTextAndZodSchemaForTsGeneration duration",
+    Date.now() - jzodToTsTypeAliasesAndZodTextStartTime,
+    "ms"
+  );
+  const contextTsTypesStringStartTime = Date.now();
+  const contextTsTypesString = Object.fromEntries(
+    Object.entries(elementZodSchemaAndDescription.contextZodSchema ?? {}).map((curr) => {
+      console.log("jzodToZodTextAndTsTypeAliases converting elementZodSchemaAndDescription entry", curr[0]);
+      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];
+    })
+  );
+  console.log(
+    "jzodToZodTextAndTsTypeAliases contextTsTypesString duration",
+    Date.now() - contextTsTypesStringStartTime,
+    "ms"
+  );
+  const tsTypeStringNodeStartTime = Date.now();
+  const tsTypeStringNode = zodToTs(elementZodSchemaAndDescription.zodSchema, typeName).node;
+  const tsTypeStringTypeAlias = createTypeAlias(tsTypeStringNode, typeName ?? "");
+  console.log(
+    "jzodToZodTextAndTsTypeAliases tsTypeStringNode duration",
+    Date.now() - tsTypeStringNodeStartTime,
+    "ms"
+  );
+  console.log("@@@@@@@@@@@@@@@@@ jzodToZodTextAndTsTypeAliases end in:", Date.now() - jzodToTsTypeAliasesAndZodTextStartTime, "ms");
+  return {
+    contextTsTypeAliases: contextTsTypesString,
+    contextZodText: elementZodSchemaAndDescription.contextZodText ?? {},
+    zodText: elementZodSchemaAndDescription.zodText,
+    mainTsTypeAlias: tsTypeStringTypeAlias
+  };
+}
+function jzodToTsCode(typeName, jzodElement2, context = {}, exportPrefix = true, headerForZodImports = true, typeAnotationForSchema = [], extendedTsTypesText = "") {
+  console.log(
+    "################################### jzodToTsCode typeName",
+    typeName,
+    "jzodElement",
+    jzodElement2 && jzodElement2.context ? JSON.stringify(Object.keys(jzodElement2.context), null, 2) : void 0
+  );
+  const schemaName = typeName ? typeName.replace(/^(.)(.*)$/, (a, b, c) => b.toLowerCase() + c) : "";
+  const actualTypeName = typeName ? typeName.replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c) : "";
+  const header = typeof headerForZodImports == "string" ? headerForZodImports : headerForZodImports ? `import { ZodType, ZodTypeAny, z } from "zod";` : "";
+  const tsTypeStringsAndZodText = jzodToZodTextAndTsTypeText(jzodElement2, context, actualTypeName);
+  const contextTsTypesString = tsTypeStringsAndZodText.contextTsTypeText ? Object.entries(tsTypeStringsAndZodText.contextTsTypeText).reduce((acc, curr) => {
+    return exportPrefix ? `${acc}
+export ${curr[1]}` : `${acc}
+${curr[1]}`;
+  }, "") : "";
+  const contextJsCode = tsTypeStringsAndZodText.contextZodText ? Object.entries(tsTypeStringsAndZodText.contextZodText).reduce((acc, curr) => {
+    const contextTypeName = curr[0] ? curr[0].replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c) : "";
+    return typeAnotationForSchema.includes(curr[0]) ? `${acc}
+export const ${curr[0]}: z.ZodType<${contextTypeName}> = ${curr[1]};` : `${acc}
+export const ${curr[0]} = ${curr[1]};`;
+  }, "") : "";
+  const bodyTsCode = (exportPrefix ? "export " : "") + tsTypeStringsAndZodText.tsTypeText;
+  const bodyJsCode = typeAnotationForSchema.includes(schemaName ?? "") ? `export const ${schemaName}: z.ZodType<${actualTypeName}> = ${tsTypeStringsAndZodText.zodText};` : `export const ${schemaName} = ${tsTypeStringsAndZodText.zodText};`;
+  return `${header}
+${extendedTsTypesText ?? ""}
+${contextTsTypesString}
+${bodyTsCode}
+${contextJsCode}
+${bodyJsCode}
+`;
+}
+
+// src/generated_jzodBootstrapElementSchema.ts
+import { z } from "zod";
+var jzodBaseObject = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.any().optional(), tag: z.object({ value: z.any(), schema: z.object({ optional: z.boolean().optional(), metaSchema: z.lazy(() => jzodElement).optional(), valueSchema: z.lazy(() => jzodElement).optional() }).strict().optional(), optional: z.boolean().optional() }).strict().optional() }).strict();
+var jzodArray = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.any().optional(), tag: z.object({ value: z.any(), schema: z.object({ optional: z.boolean().optional(), metaSchema: z.lazy(() => jzodElement).optional(), valueSchema: z.lazy(() => jzodElement).optional() }).strict().optional(), optional: z.boolean().optional() }).strict().optional(), type: z.literal("array"), definition: z.lazy(() => jzodElement) }).strict();
+var jzodPlainAttribute = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.any().optional(), tag: z.object({ value: z.any(), schema: z.object({ optional: z.boolean().optional(), metaSchema: z.lazy(() => jzodElement).optional(), valueSchema: z.lazy(() => jzodElement).optional() }).strict().optional(), optional: z.boolean().optional() }).strict().optional(), type: z.lazy(() => jzodEnumAttributeTypes), coerce: z.boolean().optional() }).strict();
+var jzodAttributeDateValidations = z.object({ extra: z.record(z.string(), z.any()).optional(), type: z.enum(["min", "max"]), parameter: z.any() }).strict();
+var jzodAttributePlainDateWithValidations = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.any().optional(), tag: z.object({ value: z.any(), schema: z.object({ optional: z.boolean().optional(), metaSchema: z.lazy(() => jzodElement).optional(), valueSchema: z.lazy(() => jzodElement).optional() }).strict().optional(), optional: z.boolean().optional() }).strict().optional(), type: z.literal("date"), coerce: z.boolean().optional(), validations: z.array(z.lazy(() => jzodAttributeDateValidations)) }).strict();
+var 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();
+var jzodAttributePlainNumberWithValidations = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.any().optional(), tag: z.object({ value: z.any(), schema: z.object({ optional: z.boolean().optional(), metaSchema: z.lazy(() => jzodElement).optional(), valueSchema: z.lazy(() => jzodElement).optional() }).strict().optional(), optional: z.boolean().optional() }).strict().optional(), type: z.literal("number"), coerce: z.boolean().optional(), validations: z.array(z.lazy(() => jzodAttributeNumberValidations)) }).strict();
+var 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();
+var jzodAttributePlainStringWithValidations = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.any().optional(), tag: z.object({ value: z.any(), schema: z.object({ optional: z.boolean().optional(), metaSchema: z.lazy(() => jzodElement).optional(), valueSchema: z.lazy(() => jzodElement).optional() }).strict().optional(), optional: z.boolean().optional() }).strict().optional(), type: z.literal("string"), coerce: z.boolean().optional(), validations: z.array(z.lazy(() => jzodAttributeStringValidations)) }).strict();
+var jzodElement = z.union([z.lazy(() => jzodArray), z.lazy(() => jzodPlainAttribute), z.lazy(() => jzodAttributePlainDateWithValidations), z.lazy(() => jzodAttributePlainNumberWithValidations), z.lazy(() => jzodAttributePlainStringWithValidations), 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)]);
+var jzodEnum = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.any().optional(), tag: z.object({ value: z.any(), schema: z.object({ optional: z.boolean().optional(), metaSchema: z.lazy(() => jzodElement).optional(), valueSchema: z.lazy(() => jzodElement).optional() }).strict().optional(), optional: z.boolean().optional() }).strict().optional(), type: z.literal("enum"), definition: z.array(z.string()) }).strict();
+var jzodEnumAttributeTypes = z.enum(["any", "bigint", "boolean", "date", "never", "null", "number", "string", "uuid", "undefined", "unknown", "void"]);
+var jzodEnumElementTypes = z.enum(["array", "date", "enum", "function", "lazy", "literal", "intersection", "map", "number", "object", "promise", "record", "schemaReference", "set", "string", "tuple", "union"]);
+var jzodFunction = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.any().optional(), tag: z.object({ value: z.any(), schema: z.object({ optional: z.boolean().optional(), metaSchema: z.lazy(() => jzodElement).optional(), valueSchema: z.lazy(() => jzodElement).optional() }).strict().optional(), optional: z.boolean().optional() }).strict().optional(), type: z.literal("function"), definition: z.object({ args: z.array(z.lazy(() => jzodElement)), returns: z.lazy(() => jzodElement).optional() }).strict() }).strict();
+var jzodLazy = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.any().optional(), tag: z.object({ value: z.any(), schema: z.object({ optional: z.boolean().optional(), metaSchema: z.lazy(() => jzodElement).optional(), valueSchema: z.lazy(() => jzodElement).optional() }).strict().optional(), optional: z.boolean().optional() }).strict().optional(), type: z.literal("lazy"), definition: z.lazy(() => jzodReference) }).strict();
+var jzodLiteral = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.any().optional(), tag: z.object({ value: z.any(), schema: z.object({ optional: z.boolean().optional(), metaSchema: z.lazy(() => jzodElement).optional(), valueSchema: z.lazy(() => jzodElement).optional() }).strict().optional(), optional: z.boolean().optional() }).strict().optional(), type: z.literal("literal"), definition: z.union([z.string(), z.number(), z.bigint(), z.boolean()]) }).strict();
+var jzodIntersection = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.any().optional(), tag: z.object({ value: z.any(), schema: z.object({ optional: z.boolean().optional(), metaSchema: z.lazy(() => jzodElement).optional(), valueSchema: z.lazy(() => jzodElement).optional() }).strict().optional(), optional: z.boolean().optional() }).strict().optional(), type: z.literal("intersection"), definition: z.object({ left: z.lazy(() => jzodElement), right: z.lazy(() => jzodElement) }).strict() }).strict();
+var jzodMap = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.any().optional(), tag: z.object({ value: z.any(), schema: z.object({ optional: z.boolean().optional(), metaSchema: z.lazy(() => jzodElement).optional(), valueSchema: z.lazy(() => jzodElement).optional() }).strict().optional(), optional: z.boolean().optional() }).strict().optional(), type: z.literal("map"), definition: z.tuple([z.lazy(() => jzodElement), z.lazy(() => jzodElement)]) }).strict();
+var jzodObject = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.any().optional(), tag: z.object({ value: z.any(), schema: z.object({ optional: z.boolean().optional(), metaSchema: z.lazy(() => jzodElement).optional(), valueSchema: z.lazy(() => jzodElement).optional() }).strict().optional(), optional: z.boolean().optional() }).strict().optional(), extend: z.union([z.union([z.lazy(() => jzodReference), z.lazy(() => jzodObject)]).optional(), z.array(z.union([z.lazy(() => jzodReference), z.lazy(() => jzodObject)]).optional())]).optional(), type: z.literal("object"), nonStrict: z.boolean().optional(), partial: z.boolean().optional(), carryOn: z.union([z.lazy(() => jzodObject), z.lazy(() => jzodUnion)]).optional(), definition: z.record(z.string(), z.lazy(() => jzodElement)) }).strict();
+var jzodPromise = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.any().optional(), tag: z.object({ value: z.any(), schema: z.object({ optional: z.boolean().optional(), metaSchema: z.lazy(() => jzodElement).optional(), valueSchema: z.lazy(() => jzodElement).optional() }).strict().optional(), optional: z.boolean().optional() }).strict().optional(), type: z.literal("promise"), definition: z.lazy(() => jzodElement) }).strict();
+var jzodRecord = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.any().optional(), tag: z.object({ value: z.any(), schema: z.object({ optional: z.boolean().optional(), metaSchema: z.lazy(() => jzodElement).optional(), valueSchema: z.lazy(() => jzodElement).optional() }).strict().optional(), optional: z.boolean().optional() }).strict().optional(), type: z.literal("record"), definition: z.lazy(() => jzodElement) }).strict();
+var jzodReference = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.any().optional(), tag: z.object({ value: z.any(), schema: z.object({ optional: z.boolean().optional(), metaSchema: z.lazy(() => jzodElement).optional(), valueSchema: z.lazy(() => jzodElement).optional() }).strict().optional(), optional: z.boolean().optional() }).strict().optional(), type: z.literal("schemaReference"), context: z.record(z.string(), z.lazy(() => jzodElement)).optional(), carryOn: z.union([z.lazy(() => jzodObject), z.lazy(() => jzodUnion)]).optional(), definition: z.object({ eager: z.boolean().optional(), partial: z.boolean().optional(), relativePath: z.string().optional(), absolutePath: z.string().optional() }).strict() }).strict();
+var jzodSet = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.any().optional(), tag: z.object({ value: z.any(), schema: z.object({ optional: z.boolean().optional(), metaSchema: z.lazy(() => jzodElement).optional(), valueSchema: z.lazy(() => jzodElement).optional() }).strict().optional(), optional: z.boolean().optional() }).strict().optional(), type: z.literal("set"), definition: z.lazy(() => jzodElement) }).strict();
+var jzodTuple = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.any().optional(), tag: z.object({ value: z.any(), schema: z.object({ optional: z.boolean().optional(), metaSchema: z.lazy(() => jzodElement).optional(), valueSchema: z.lazy(() => jzodElement).optional() }).strict().optional(), optional: z.boolean().optional() }).strict().optional(), type: z.literal("tuple"), definition: z.array(z.lazy(() => jzodElement)) }).strict();
+var jzodUnion = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.any().optional(), tag: z.object({ value: z.any(), schema: z.object({ optional: z.boolean().optional(), metaSchema: z.lazy(() => jzodElement).optional(), valueSchema: z.lazy(() => jzodElement).optional() }).strict().optional(), optional: z.boolean().optional() }).strict().optional(), type: z.literal("union"), optInDiscriminator: z.boolean().optional(), discriminator: z.union([z.object({ discriminatorType: z.literal("string"), value: z.string() }).strict(), z.object({ discriminatorType: z.literal("array"), value: z.array(z.string()) }).strict()]).optional(), carryOn: z.union([z.lazy(() => jzodObject), z.lazy(() => jzodUnion)]).optional(), definition: z.array(z.lazy(() => jzodElement)) }).strict();
+var jzodBootstrapElementSchema = z.lazy(() => jzodElement);
+export {
+  jzodArray,
+  jzodAttributeDateValidations,
+  jzodAttributeNumberValidations,
+  jzodAttributePlainDateWithValidations,
+  jzodAttributePlainNumberWithValidations,
+  jzodAttributePlainStringWithValidations,
+  jzodAttributeStringValidations,
+  jzodElement,
+  jzodEnum,
+  jzodEnumAttributeTypes,
+  jzodEnumElementTypes,
+  jzodFunction,
+  jzodIntersection,
+  jzodLazy,
+  jzodLiteral,
+  jzodMap,
+  jzodObject,
+  jzodPlainAttribute,
+  jzodPromise,
+  jzodRecord,
+  jzodReference,
+  jzodSet,
+  jzodToTsCode,
+  jzodToZodTextAndTsTypeAliases,
+  jzodToZodTextAndZodSchemaForTsGeneration,
+  jzodTuple,
+  jzodUnion
+};

package/package.json

@@ -1,17 +1,23 @@
 {
   "name": "@miroir-framework/jzod-ts",
   "private": false,
-  "version": "0.7.0",
+  "version": "0.8.2",
   "description": "The Typescript-related functionalities of Jzod.",
-  "main": "dist/bundle.js",
-  "types": "dist/bundle.d.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "type": "module",
-  "scripts": {
-    "preBuild": "tsc --rootDir . --baseUrl . --module ESnext --target ES2017 --moduleResolution node --allowSyntheticDefaultImports --outdir ./tmp/ && node ./tmp/src/preBuild.js",
-    "preBuildRun": "node ./tmp/src/preBuild.js",
-    "build": "rollup --config",
-    "test": "cross-env NODE_ENV=test jest --verbose --silent=false -t"
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
   },
+  "keywords": [
+    "zod",
+    "typescript",
+    "generator"
+  ],
   "author": "Miroir Framework <miroir-framework@protonmail.com>",
   "homepage": "https://github.com/miroir-framework/jzod/#readme",
   "bugs": "https://github.com/miroir-framework/jzod/issues",
@@ -19,28 +25,30 @@
   "files": [
     "LICENSE.md",
     "package.json",
-    "dist/bundle.js",
-    "dist/bundle.d.ts"
+    "dist/index.js",
+    "dist/index.cjs",
+    "dist/index.d.ts",
+    "dist/src/worker.js"
   ],
+  "scripts": {
+    "preBuild": "tsx ./scripts/preBuild.ts",
+    "build": "tsup",
+    "test": "cross-env NODE_ENV=test vitest run --poolOptions.threads.singleThread --passWithNoTests -t"
+  },
   "dependencies": {
-    "@miroir-framework/jzod": "0.7.0",
-    "zod": "^3.22.2",
+    "@miroir-framework/jzod": "0.8.2",
+    "zod": "^3.24.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",
+    "path": "^0.12.7",
     "tsconfig-paths": "^4.1.2",
-    "typescript": "5.0.3",
+    "tsup": "^8.4.0",
+    "tsx": "^4.19.3",
+    "typescript": "5.8.2",
+    "url": "^0.11.4",
+    "vite-plugin-node-polyfills": "^0.23.0",
+    "vitest": "^3.0.8",
     "zod-to-json-schema": "^3.21.2"
   }
 }

package/dist/bundle.d.ts

@@ -1,303 +0,0 @@
-import ts from 'typescript';
-import { z } from 'zod';
-
-type JzodArray = {
-    optional?: boolean | undefined;
-    nullable?: boolean | undefined;
-    extra?: {
-        [x: string]: any;
-    } | undefined;
-    type: "array";
-    definition: JzodElement;
-};
-type JzodAttribute = {
-    optional?: boolean | undefined;
-    nullable?: boolean | undefined;
-    extra?: {
-        [x: string]: any;
-    } | undefined;
-    type: "simpleType";
-    coerce?: boolean | undefined;
-    definition: JzodEnumAttributeTypes;
-};
-type JzodPlainAttribute = {
-    optional?: boolean | undefined;
-    nullable?: boolean | undefined;
-    extra?: {
-        [x: string]: any;
-    } | undefined;
-    type: JzodEnumAttributeTypes;
-    coerce?: boolean | undefined;
-};
-type JzodAttributeDateValidations = {
-    extra?: {
-        [x: string]: any;
-    } | undefined;
-    type: "min" | "max";
-    parameter?: any;
-};
-type JzodAttributeDateWithValidations = {
-    optional?: boolean | undefined;
-    nullable?: boolean | undefined;
-    extra?: {
-        [x: string]: any;
-    } | undefined;
-    type: "simpleType";
-    definition: "date";
-    coerce?: boolean | undefined;
-    validations: JzodAttributeDateValidations[];
-};
-type JzodAttributePlainDateWithValidations = {
-    optional?: boolean | undefined;
-    nullable?: boolean | undefined;
-    extra?: {
-        [x: string]: any;
-    } | undefined;
-    type: "date";
-    coerce?: boolean | undefined;
-    validations: JzodAttributeDateValidations[];
-};
-type JzodAttributeNumberValidations = {
-    extra?: {
-        [x: string]: any;
-    } | undefined;
-    type: "gt" | "gte" | "lt" | "lte" | "int" | "positive" | "nonpositive" | "negative" | "nonnegative" | "multipleOf" | "finite" | "safe";
-    parameter?: any;
-};
-type JzodAttributeNumberWithValidations = {
-    optional?: boolean | undefined;
-    nullable?: boolean | undefined;
-    extra?: {
-        [x: string]: any;
-    } | undefined;
-    type: "simpleType";
-    definition: "number";
-    coerce?: boolean | undefined;
-    validations: JzodAttributeNumberValidations[];
-};
-type JzodAttributePlainNumberWithValidations = {
-    optional?: boolean | undefined;
-    nullable?: boolean | undefined;
-    extra?: {
-        [x: string]: any;
-    } | undefined;
-    type: "number";
-    coerce?: boolean | undefined;
-    validations: JzodAttributeNumberValidations[];
-};
-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;
-};
-type JzodAttributeStringWithValidations = {
-    optional?: boolean | undefined;
-    nullable?: boolean | undefined;
-    extra?: {
-        [x: string]: any;
-    } | undefined;
-    type: "simpleType";
-    definition: "string";
-    coerce?: boolean | undefined;
-    validations: JzodAttributeStringValidations[];
-};
-type JzodAttributePlainStringWithValidations = {
-    optional?: boolean | undefined;
-    nullable?: boolean | undefined;
-    extra?: {
-        [x: string]: any;
-    } | undefined;
-    type: "string";
-    coerce?: boolean | undefined;
-    validations: JzodAttributeStringValidations[];
-};
-type JzodElement = JzodArray | JzodAttribute | JzodPlainAttribute | JzodAttributeDateWithValidations | JzodAttributePlainDateWithValidations | JzodAttributeNumberWithValidations | JzodAttributePlainNumberWithValidations | JzodAttributeStringWithValidations | JzodAttributePlainStringWithValidations | JzodEnum | JzodFunction | JzodLazy | JzodLiteral | JzodIntersection | JzodMap | JzodObject | JzodPromise | JzodRecord | JzodReference | JzodSet | JzodTuple | JzodUnion;
-type JzodEnum = {
-    optional?: boolean | undefined;
-    nullable?: boolean | undefined;
-    extra?: {
-        [x: string]: any;
-    } | undefined;
-    type: "enum";
-    definition: string[];
-};
-type JzodEnumAttributeTypes = "any" | "bigint" | "boolean" | "date" | "never" | "null" | "number" | "string" | "uuid" | "undefined" | "unknown" | "void";
-type JzodEnumElementTypes = "array" | "date" | "enum" | "function" | "lazy" | "literal" | "intersection" | "map" | "number" | "object" | "promise" | "record" | "schemaReference" | "set" | "simpleType" | "string" | "tuple" | "union";
-type JzodFunction = {
-    optional?: boolean | undefined;
-    nullable?: boolean | undefined;
-    extra?: {
-        [x: string]: any;
-    } | undefined;
-    type: "function";
-    definition: {
-        args: JzodElement[];
-        returns?: JzodElement | undefined;
-    };
-};
-type JzodLazy = {
-    optional?: boolean | undefined;
-    nullable?: boolean | undefined;
-    extra?: {
-        [x: string]: any;
-    } | undefined;
-    type: "lazy";
-    definition: JzodFunction;
-};
-type JzodLiteral = {
-    optional?: boolean | undefined;
-    nullable?: boolean | undefined;
-    extra?: {
-        [x: string]: any;
-    } | undefined;
-    type: "literal";
-    definition: string | number | bigint | boolean;
-};
-type JzodIntersection = {
-    optional?: boolean | undefined;
-    nullable?: boolean | undefined;
-    extra?: {
-        [x: string]: any;
-    } | undefined;
-    type: "intersection";
-    definition: {
-        left: JzodElement;
-        right: JzodElement;
-    };
-};
-type JzodMap = {
-    optional?: boolean | undefined;
-    nullable?: boolean | undefined;
-    extra?: {
-        [x: string]: any;
-    } | undefined;
-    type: "map";
-    definition: [
-        JzodElement,
-        JzodElement
-    ];
-};
-type JzodObject = {
-    optional?: boolean | undefined;
-    nullable?: boolean | undefined;
-    extra?: {
-        [x: string]: any;
-    } | undefined;
-    extend?: (JzodReference | JzodObject) | undefined;
-    type: "object";
-    nonStrict?: boolean | undefined;
-    partial?: boolean | undefined;
-    definition: {
-        [x: string]: JzodElement;
-    };
-};
-type JzodPromise = {
-    optional?: boolean | undefined;
-    nullable?: boolean | undefined;
-    extra?: {
-        [x: string]: any;
-    } | undefined;
-    type: "promise";
-    definition: JzodElement;
-};
-type JzodRecord = {
-    optional?: boolean | undefined;
-    nullable?: boolean | undefined;
-    extra?: {
-        [x: string]: any;
-    } | undefined;
-    type: "record";
-    definition: JzodElement;
-};
-type JzodReference = {
-    optional?: boolean | undefined;
-    nullable?: boolean | undefined;
-    extra?: {
-        [x: string]: any;
-    } | undefined;
-    type: "schemaReference";
-    context?: {
-        [x: string]: JzodElement;
-    } | undefined;
-    definition: {
-        eager?: boolean | undefined;
-        partial?: boolean | undefined;
-        relativePath?: string | undefined;
-        absolutePath?: string | undefined;
-    };
-};
-type JzodSet = {
-    optional?: boolean | undefined;
-    nullable?: boolean | undefined;
-    extra?: {
-        [x: string]: any;
-    } | undefined;
-    type: "set";
-    definition: JzodElement;
-};
-type JzodTuple = {
-    optional?: boolean | undefined;
-    nullable?: boolean | undefined;
-    extra?: {
-        [x: string]: any;
-    } | undefined;
-    type: "tuple";
-    definition: JzodElement[];
-};
-type JzodUnion = {
-    optional?: boolean | undefined;
-    nullable?: boolean | undefined;
-    extra?: {
-        [x: string]: any;
-    } | undefined;
-    type: "union";
-    discriminator?: string | undefined;
-    definition: JzodElement[];
-};
-declare const jzodArray: z.ZodType<JzodArray>;
-declare const jzodAttribute: z.ZodType<JzodAttribute>;
-declare const jzodAttributeDateValidations: z.ZodType<JzodAttributeDateValidations>;
-declare const jzodAttributeDateWithValidations: z.ZodType<JzodAttributeDateWithValidations>;
-declare const jzodAttributeNumberValidations: z.ZodType<JzodAttributeNumberValidations>;
-declare const jzodAttributeNumberWithValidations: z.ZodType<JzodAttributeNumberWithValidations>;
-declare const jzodAttributeStringValidations: z.ZodType<JzodAttributeStringValidations>;
-declare const jzodAttributeStringWithValidations: z.ZodType<JzodAttributeStringWithValidations>;
-declare const jzodElement: z.ZodType<JzodElement>;
-declare const jzodEnum: z.ZodType<JzodEnum>;
-declare const jzodEnumAttributeTypes: z.ZodType<JzodEnumAttributeTypes>;
-declare const jzodEnumElementTypes: z.ZodType<JzodEnumElementTypes>;
-declare const jzodFunction: z.ZodType<JzodFunction>;
-declare const jzodLazy: z.ZodType<JzodLazy>;
-declare const jzodLiteral: z.ZodType<JzodLiteral>;
-declare const jzodIntersection: z.ZodType<JzodIntersection>;
-declare const jzodMap: z.ZodType<JzodMap>;
-declare const jzodObject: z.ZodType<JzodObject>;
-declare const jzodPromise: z.ZodType<JzodPromise>;
-declare const jzodRecord: z.ZodType<JzodRecord>;
-declare const jzodReference: z.ZodType<JzodReference>;
-declare const jzodSet: z.ZodType<JzodSet>;
-declare const jzodTuple: z.ZodType<JzodTuple>;
-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;
-declare function jzodToTsCode(jzodElement: JzodElement, exportPrefix?: boolean, typeName?: string, typeAnotationForSchema?: string[]): 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, JzodAttributePlainDateWithValidations, JzodAttributePlainNumberWithValidations, JzodAttributePlainStringWithValidations, JzodAttributeStringValidations, JzodAttributeStringWithValidations, JzodElement, JzodEnum, JzodEnumAttributeTypes, JzodEnumElementTypes, JzodFunction, JzodIntersection, JzodLazy, JzodLiteral, JzodMap, JzodObject, JzodPlainAttribute, 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, jzodMap, jzodObject, jzodPromise, jzodRecord, jzodReference, jzodSet, jzodToTsCode, jzodToTsTypeAliasesAndZodText, jzodTuple, jzodUnion, printTsTypeAlias, printTsTypeAliases };