@miroir-framework/jzod-ts 0.5.3 → 0.6.0

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

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jzodUnion = exports.jzodTuple = exports.jzodSet = exports.jzodReference = exports.jzodRecord = exports.jzodPromise = exports.jzodObject = exports.jzodMapSchema = exports.jzodIntersection = exports.jzodLiteral = exports.jzodLazy = exports.jzodFunction = exports.jzodEnum = exports.jzodElement = exports.jzodAttribute = exports.jzodAttributeStringWithValidations = exports.jzodAttributeNumberWithValidations = exports.jzodAttributeDateWithValidations = exports.jzodAttributeStringValidations = exports.jzodAttributeNumberValidations = exports.jzodAttributeDateValidations = exports.jzodArray = exports.jzodEnumElementTypes = exports.jzodEnumAttributeTypes = void 0;
+var zod_1 = require("zod");
+var jzodRootSchema = zod_1.z.object({
+    optional: zod_1.z.boolean().optional(),
+}).strict();
+exports.jzodEnumAttributeTypes = zod_1.z.enum([
+    "any",
+    "bigint",
+    "boolean",
+    "date",
+    "never",
+    "null",
+    "number",
+    "string",
+    "uuid",
+    "undefined",
+    "unknown",
+    "void",
+]);
+exports.jzodEnumElementTypes = zod_1.z.enum([
+    "array",
+    "enum",
+    "function",
+    "lazy",
+    "literal",
+    "intersection",
+    "map",
+    "object",
+    "promise",
+    "record",
+    "schemaReference",
+    "set",
+    "simpleType",
+    "tuple",
+    "union",
+]);
+exports.jzodArray = zod_1.z.object({
+    optional: zod_1.z.boolean().optional(),
+    nullable: zod_1.z.boolean().optional(),
+    extra: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional(),
+    type: zod_1.z.literal('array'),
+    definition: zod_1.z.lazy(function () { return exports.jzodElement; })
+}).strict();
+exports.jzodAttributeDateValidations = zod_1.z
+    .object({
+    extra: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional(),
+    type: zod_1.z.enum([
+        "min",
+        "max",
+    ]),
+    parameter: zod_1.z.any(),
+})
+    .strict();
+exports.jzodAttributeNumberValidations = zod_1.z
+    .object({
+    extra: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional(),
+    type: zod_1.z.enum([
+        "gt",
+        "gte",
+        "lt",
+        "lte",
+        "int",
+        "positive",
+        "nonpositive",
+        "negative",
+        "nonnegative",
+        "multipleOf",
+        "finite",
+        "safe",
+    ]),
+    parameter: zod_1.z.any(),
+})
+    .strict();
+exports.jzodAttributeStringValidations = zod_1.z
+    .object({
+    extra: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional(),
+    type: zod_1.z.enum([
+        "max",
+        "min",
+        "length",
+        "email",
+        "url",
+        "emoji",
+        "uuid",
+        "cuid",
+        "cuid2",
+        "ulid",
+        "regex",
+        "includes",
+        "startsWith",
+        "endsWith",
+        "datetime",
+        "ip",
+    ]),
+    parameter: zod_1.z.any(),
+})
+    .strict();
+exports.jzodAttributeDateWithValidations = zod_1.z.object({
+    optional: zod_1.z.boolean().optional(),
+    nullable: zod_1.z.boolean().optional(),
+    extra: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional(),
+    coerce: zod_1.z.boolean().optional(),
+    type: zod_1.z.literal(exports.jzodEnumElementTypes.enum.simpleType),
+    definition: zod_1.z.literal(exports.jzodEnumAttributeTypes.enum.date),
+    validations: zod_1.z.array(exports.jzodAttributeDateValidations),
+}).strict();
+exports.jzodAttributeNumberWithValidations = zod_1.z.object({
+    optional: zod_1.z.boolean().optional(),
+    nullable: zod_1.z.boolean().optional(),
+    extra: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional(),
+    coerce: zod_1.z.boolean().optional(),
+    type: zod_1.z.literal(exports.jzodEnumElementTypes.enum.simpleType),
+    definition: zod_1.z.literal(exports.jzodEnumAttributeTypes.enum.number),
+    validations: zod_1.z.array(exports.jzodAttributeNumberValidations),
+}).strict();
+exports.jzodAttributeStringWithValidations = zod_1.z.object({
+    optional: zod_1.z.boolean().optional(),
+    nullable: zod_1.z.boolean().optional(),
+    extra: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional(),
+    coerce: zod_1.z.boolean().optional(),
+    type: zod_1.z.literal(exports.jzodEnumElementTypes.enum.simpleType),
+    definition: zod_1.z.literal(exports.jzodEnumAttributeTypes.enum.string),
+    validations: zod_1.z.array(exports.jzodAttributeStringValidations),
+}).strict();
+exports.jzodAttribute = zod_1.z.object({
+    optional: zod_1.z.boolean().optional(),
+    nullable: zod_1.z.boolean().optional(),
+    extra: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional(),
+    coerce: zod_1.z.boolean().optional(),
+    type: zod_1.z.literal(exports.jzodEnumElementTypes.enum.simpleType),
+    definition: zod_1.z.lazy(function () { return exports.jzodEnumAttributeTypes; }),
+}).strict();
+exports.jzodElement = zod_1.z.union([
+    zod_1.z.lazy(function () { return exports.jzodArray; }),
+    zod_1.z.lazy(function () { return exports.jzodAttribute; }),
+    zod_1.z.lazy(function () { return exports.jzodAttributeDateWithValidations; }),
+    zod_1.z.lazy(function () { return exports.jzodAttributeNumberWithValidations; }),
+    zod_1.z.lazy(function () { return exports.jzodAttributeStringWithValidations; }),
+    zod_1.z.lazy(function () { return exports.jzodEnum; }),
+    zod_1.z.lazy(function () { return exports.jzodFunction; }),
+    zod_1.z.lazy(function () { return exports.jzodLazy; }),
+    zod_1.z.lazy(function () { return exports.jzodLiteral; }),
+    zod_1.z.lazy(function () { return exports.jzodIntersection; }),
+    zod_1.z.lazy(function () { return exports.jzodMapSchema; }),
+    zod_1.z.lazy(function () { return exports.jzodObject; }),
+    zod_1.z.lazy(function () { return exports.jzodPromise; }),
+    zod_1.z.lazy(function () { return exports.jzodRecord; }),
+    zod_1.z.lazy(function () { return exports.jzodReference; }),
+    zod_1.z.lazy(function () { return exports.jzodSet; }),
+    zod_1.z.lazy(function () { return exports.jzodTuple; }),
+    zod_1.z.lazy(function () { return exports.jzodUnion; }),
+]);
+exports.jzodEnum = zod_1.z.object({
+    optional: zod_1.z.boolean().optional(),
+    nullable: zod_1.z.boolean().optional(),
+    extra: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional(),
+    type: zod_1.z.literal(exports.jzodEnumElementTypes.enum.enum),
+    definition: zod_1.z.array(zod_1.z.string()),
+}).strict();
+exports.jzodFunction = zod_1.z.object({
+    type: zod_1.z.literal(exports.jzodEnumElementTypes.enum.function),
+    extra: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional(),
+    definition: zod_1.z.object({
+        args: zod_1.z.array(exports.jzodElement),
+        returns: exports.jzodElement.optional(),
+    })
+}).strict();
+exports.jzodLazy = zod_1.z.object({
+    type: zod_1.z.literal(exports.jzodEnumElementTypes.enum.lazy),
+    extra: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional(),
+    definition: exports.jzodFunction,
+}).strict();
+exports.jzodLiteral = zod_1.z.object({
+    optional: zod_1.z.boolean().optional(),
+    nullable: zod_1.z.boolean().optional(),
+    extra: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional(),
+    type: zod_1.z.literal(exports.jzodEnumElementTypes.enum.literal),
+    definition: zod_1.z.string(),
+}).strict();
+exports.jzodIntersection = zod_1.z.object({
+    optional: zod_1.z.boolean().optional(),
+    nullable: zod_1.z.boolean().optional(),
+    extra: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional(),
+    type: zod_1.z.literal(exports.jzodEnumElementTypes.enum.intersection),
+    definition: zod_1.z.lazy(function () { return zod_1.z.object({ left: exports.jzodElement, right: exports.jzodElement }); })
+}).strict();
+exports.jzodMapSchema = zod_1.z.object({
+    optional: zod_1.z.boolean().optional(),
+    nullable: zod_1.z.boolean().optional(),
+    extra: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional(),
+    type: zod_1.z.literal('map'),
+    definition: zod_1.z.lazy(function () { return zod_1.z.tuple([exports.jzodElement, exports.jzodElement]); })
+}).strict();
+exports.jzodObject = zod_1.z.object({
+    optional: zod_1.z.boolean().optional(),
+    nullable: zod_1.z.boolean().optional(),
+    extend: zod_1.z.lazy(function () { return zod_1.z.union([exports.jzodReference, exports.jzodObject]); }).optional(),
+    extra: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional(),
+    type: zod_1.z.literal(exports.jzodEnumElementTypes.enum.object),
+    nonStrict: zod_1.z.boolean().optional(),
+    definition: zod_1.z.lazy(function () { return zod_1.z.record(zod_1.z.string(), exports.jzodElement); }),
+}).strict();
+exports.jzodPromise = zod_1.z.object({
+    extra: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional(),
+    type: zod_1.z.literal('promise'),
+    definition: zod_1.z.lazy(function () { return exports.jzodElement; })
+}).strict();
+exports.jzodRecord = zod_1.z.object({
+    optional: zod_1.z.boolean().optional(),
+    nullable: zod_1.z.boolean().optional(),
+    extra: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional(),
+    type: zod_1.z.literal(exports.jzodEnumElementTypes.enum.record),
+    definition: zod_1.z.lazy(function () { return exports.jzodElement; })
+}).strict();
+exports.jzodReference = zod_1.z.object({
+    optional: zod_1.z.boolean().optional(),
+    nullable: zod_1.z.boolean().optional(),
+    extra: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional(),
+    type: zod_1.z.literal(exports.jzodEnumElementTypes.enum.schemaReference),
+    context: zod_1.z.lazy(function () { return zod_1.z.record(zod_1.z.string(), exports.jzodElement); }).optional(),
+    definition: zod_1.z.object({
+        eager: zod_1.z.boolean().optional(),
+        relativePath: zod_1.z.string().optional(),
+        absolutePath: zod_1.z.string().optional(),
+    })
+}).strict();
+exports.jzodSet = zod_1.z.object({
+    optional: zod_1.z.boolean().optional(),
+    nullable: zod_1.z.boolean().optional(),
+    extra: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional(),
+    type: zod_1.z.literal('set'),
+    definition: zod_1.z.lazy(function () { return exports.jzodElement; })
+}).strict();
+exports.jzodTuple = zod_1.z.object({
+    optional: zod_1.z.boolean().optional(),
+    nullable: zod_1.z.boolean().optional(),
+    extra: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional(),
+    type: zod_1.z.literal(exports.jzodEnumElementTypes.enum.tuple),
+    definition: zod_1.z.array(exports.jzodElement),
+}).strict();
+exports.jzodUnion = zod_1.z.object({
+    optional: zod_1.z.boolean().optional(),
+    nullable: zod_1.z.boolean().optional(),
+    extra: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional(),
+    type: zod_1.z.literal(exports.jzodEnumElementTypes.enum.union),
+    discriminator: zod_1.z.string().optional(),
+    definition: zod_1.z.lazy(function () { return zod_1.z.array(exports.jzodElement); })
+}).strict();

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jzodUnion = exports.jzodTuple = exports.jzodSet = exports.jzodReference = exports.jzodRecord = exports.jzodPromise = exports.jzodObject = exports.jzodMapSchema = exports.jzodLiteral = exports.jzodLazy = exports.jzodIntersection = exports.jzodFunction = exports.jzodEnum = exports.jzodEnumElementTypes = exports.jzodEnumAttributeTypes = exports.jzodElement = exports.jzodAttributeStringWithValidations = exports.jzodAttributeStringValidations = exports.jzodAttributeNumberWithValidations = exports.jzodAttributeNumberValidations = exports.jzodAttributeDateWithValidations = exports.jzodAttributeDateValidations = exports.jzodAttribute = exports.jzodArray = exports.printTsTypeAliases = exports.printTsTypeAlias = exports.jzodToTsTypeAliasesAndZodText = exports.jzodToTsCode = void 0;
+var JzodToTs_1 = require("./JzodToTs");
+Object.defineProperty(exports, "jzodToTsCode", { enumerable: true, get: function () { return JzodToTs_1.jzodToTsCode; } });
+Object.defineProperty(exports, "jzodToTsTypeAliasesAndZodText", { enumerable: true, get: function () { return JzodToTs_1.jzodToTsTypeAliasesAndZodText; } });
+var tools_1 = require("./tools");
+Object.defineProperty(exports, "printTsTypeAlias", { enumerable: true, get: function () { return tools_1.printTsTypeAlias; } });
+Object.defineProperty(exports, "printTsTypeAliases", { enumerable: true, get: function () { return tools_1.printTsTypeAliases; } });
+var JzodTsInterface_1 = require("./JzodTsInterface");
+Object.defineProperty(exports, "jzodArray", { enumerable: true, get: function () { return JzodTsInterface_1.jzodArray; } });
+Object.defineProperty(exports, "jzodAttribute", { enumerable: true, get: function () { return JzodTsInterface_1.jzodAttribute; } });
+Object.defineProperty(exports, "jzodAttributeDateValidations", { enumerable: true, get: function () { return JzodTsInterface_1.jzodAttributeDateValidations; } });
+Object.defineProperty(exports, "jzodAttributeDateWithValidations", { enumerable: true, get: function () { return JzodTsInterface_1.jzodAttributeDateWithValidations; } });
+Object.defineProperty(exports, "jzodAttributeNumberValidations", { enumerable: true, get: function () { return JzodTsInterface_1.jzodAttributeNumberValidations; } });
+Object.defineProperty(exports, "jzodAttributeNumberWithValidations", { enumerable: true, get: function () { return JzodTsInterface_1.jzodAttributeNumberWithValidations; } });
+Object.defineProperty(exports, "jzodAttributeStringValidations", { enumerable: true, get: function () { return JzodTsInterface_1.jzodAttributeStringValidations; } });
+Object.defineProperty(exports, "jzodAttributeStringWithValidations", { enumerable: true, get: function () { return JzodTsInterface_1.jzodAttributeStringWithValidations; } });
+Object.defineProperty(exports, "jzodElement", { enumerable: true, get: function () { return JzodTsInterface_1.jzodElement; } });
+Object.defineProperty(exports, "jzodEnumAttributeTypes", { enumerable: true, get: function () { return JzodTsInterface_1.jzodEnumAttributeTypes; } });
+Object.defineProperty(exports, "jzodEnumElementTypes", { enumerable: true, get: function () { return JzodTsInterface_1.jzodEnumElementTypes; } });
+Object.defineProperty(exports, "jzodEnum", { enumerable: true, get: function () { return JzodTsInterface_1.jzodEnum; } });
+Object.defineProperty(exports, "jzodFunction", { enumerable: true, get: function () { return JzodTsInterface_1.jzodFunction; } });
+Object.defineProperty(exports, "jzodIntersection", { enumerable: true, get: function () { return JzodTsInterface_1.jzodIntersection; } });
+Object.defineProperty(exports, "jzodLazy", { enumerable: true, get: function () { return JzodTsInterface_1.jzodLazy; } });
+Object.defineProperty(exports, "jzodLiteral", { enumerable: true, get: function () { return JzodTsInterface_1.jzodLiteral; } });
+Object.defineProperty(exports, "jzodMapSchema", { enumerable: true, get: function () { return JzodTsInterface_1.jzodMapSchema; } });
+Object.defineProperty(exports, "jzodObject", { enumerable: true, get: function () { return JzodTsInterface_1.jzodObject; } });
+Object.defineProperty(exports, "jzodPromise", { enumerable: true, get: function () { return JzodTsInterface_1.jzodPromise; } });
+Object.defineProperty(exports, "jzodRecord", { enumerable: true, get: function () { return JzodTsInterface_1.jzodRecord; } });
+Object.defineProperty(exports, "jzodReference", { enumerable: true, get: function () { return JzodTsInterface_1.jzodReference; } });
+Object.defineProperty(exports, "jzodSet", { enumerable: true, get: function () { return JzodTsInterface_1.jzodSet; } });
+Object.defineProperty(exports, "jzodTuple", { enumerable: true, get: function () { return JzodTsInterface_1.jzodTuple; } });
+Object.defineProperty(exports, "jzodUnion", { enumerable: true, get: function () { return JzodTsInterface_1.jzodUnion; } });

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateZodSchemaFileFromJzodSchema = void 0;
+var fs_1 = require("fs");
+var jzod_1 = require("@miroir-framework/jzod");
+var JzodToTs_1 = require("./JzodToTs");
+function generateZodSchemaFileFromJzodSchema(jzodElement, targetFileName, jzodSchemaVariableName) {
+    console.log("generateZodSchemaFileFromJzodSchema called!");
+    var newFileContentsNotFormated = (0, JzodToTs_1.jzodToTsCode)(jzodElement, true, jzodSchemaVariableName);
+    var newFileContents = "import { JzodObject, jzodObject } from \"@miroir-framework/jzod-ts\";\n".concat(newFileContentsNotFormated, "\n");
+    if (targetFileName && (0, fs_1.existsSync)(targetFileName)) {
+        var oldFileContents = (0, fs_1.readFileSync)(targetFileName).toString();
+        if (newFileContents != oldFileContents) {
+            console.log("generateZodSchemaFileFromJzodSchema newFileContents", newFileContents);
+            (0, fs_1.writeFileSync)(targetFileName, newFileContents);
+        }
+        else {
+            console.log("generateZodSchemaFileFromJzodSchema entityDefinitionReport old contents equal new contents, no file generation needed.");
+        }
+    }
+    else {
+        (0, fs_1.writeFileSync)(targetFileName, newFileContents);
+    }
+}
+exports.generateZodSchemaFileFromJzodSchema = generateZodSchemaFileFromJzodSchema;
+var jzodSchemaConversion = [
+    {
+        jzodElement: jzod_1.jzodBootstrapElementSchema.definition,
+        targetFileName: "./src/generated_jzodBootstrapElementSchema.ts",
+        jzodSchemaVariableName: "jzodBootstrapElementSchema",
+    },
+];
+try {
+    for (var _i = 0, jzodSchemaConversion_1 = jzodSchemaConversion; _i < jzodSchemaConversion_1.length; _i++) {
+        var schema = jzodSchemaConversion_1[_i];
+        generateZodSchemaFileFromJzodSchema(schema.jzodElement, schema.targetFileName, schema.jzodSchemaVariableName);
+        console.info("GENERATED", schema.targetFileName);
+    }
+}
+catch (error) {
+    console.error("could not generate TS files from Jzod schemas", error);
+}

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printTsTypeAliases = exports.printTsTypeAlias = void 0;
+var zod_to_ts_1 = require("zod-to-ts");
+function printTsTypeAlias(typeAlias, exportPrefix) {
+    if (exportPrefix === void 0) { exportPrefix = true; }
+    return (exportPrefix ? "export " : "") + (0, zod_to_ts_1.printNode)(typeAlias);
+}
+exports.printTsTypeAlias = printTsTypeAlias;
+function printTsTypeAliases(typeAliases, exportPrefix) {
+    if (exportPrefix === void 0) { exportPrefix = true; }
+    var result = Object.entries(typeAliases).reduce(function (acc, curr) {
+        return "".concat(acc, "\n").concat(printTsTypeAlias(curr[1], exportPrefix));
+    }, "");
+    return result;
+}
+exports.printTsTypeAliases = printTsTypeAliases;

package/dist/src/JzodToTs.d.ts

@@ -1,5 +1,5 @@
 import ts from "typescript";
-import { JzodElement } from "./JzodTsInterface";
+import { JzodElement } from "./generated_jzodBootstrapElementSchema";
 export type TsTypeAliases = {
     [k: string]: ts.TypeAliasDeclaration;
 };
@@ -14,4 +14,4 @@ export interface TsTypeAliasesAndZodText {
     mainZodText: string;
 }
 export declare function jzodToTsTypeAliasesAndZodText(element: JzodElement, typeName?: string): TsTypeAliasesAndZodText;
-export declare function jzodToTsCode(jzodElement: JzodElement, exportPrefix?: boolean, typeName?: string): string;
+export declare function jzodToTsCode(jzodElement: JzodElement, exportPrefix?: boolean, typeName?: string, typeSchema?: boolean): string;

package/dist/src/generated_jzodBootstrapElementSchema.d.ts

@@ -0,0 +1,246 @@
+import { 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 declare const jzodBaseObject: z.ZodType<JzodBaseObject>;
+export declare const jzodArray: z.ZodType<JzodArray>;
+export declare const jzodAttribute: z.ZodType<JzodAttribute>;
+export declare const jzodAttributeDateValidations: z.ZodType<JzodAttributeDateValidations>;
+export declare const jzodAttributeDateWithValidations: z.ZodType<JzodAttributeDateWithValidations>;
+export declare const jzodAttributeNumberValidations: z.ZodType<JzodAttributeNumberValidations>;
+export declare const jzodAttributeNumberWithValidations: z.ZodType<JzodAttributeNumberWithValidations>;
+export declare const jzodAttributeStringValidations: z.ZodType<JzodAttributeStringValidations>;
+export declare const jzodAttributeStringWithValidations: z.ZodType<JzodAttributeStringWithValidations>;
+export declare const jzodElement: z.ZodType<JzodElement>;
+export declare const jzodEnum: z.ZodType<JzodEnum>;
+export declare const jzodEnumAttributeTypes: z.ZodType<JzodEnumAttributeTypes>;
+export declare const jzodEnumElementTypes: z.ZodType<JzodEnumElementTypes>;
+export declare const jzodFunction: z.ZodType<JzodFunction>;
+export declare const jzodLazy: z.ZodType<JzodLazy>;
+export declare const jzodLiteral: z.ZodType<JzodLiteral>;
+export declare const jzodIntersection: z.ZodType<JzodIntersection>;
+export declare const jzodMap: z.ZodType<JzodMap>;
+export declare const jzodObject: z.ZodType<JzodObject>;
+export declare const jzodPromise: z.ZodType<JzodPromise>;
+export declare const jzodRecord: z.ZodType<JzodRecord>;
+export declare const jzodReference: z.ZodType<JzodReference>;
+export declare const jzodSet: z.ZodType<JzodSet>;
+export declare const jzodTuple: z.ZodType<JzodTuple>;
+export declare const jzodUnion: z.ZodType<JzodUnion>;
+export declare const jzodBootstrapElementSchema: z.ZodType<JzodBootstrapElementSchema>;

package/dist/src/index.d.ts

@@ -1,3 +1,3 @@
 export { jzodToTsCode, jzodToTsTypeAliasesAndZodText, TsTypeAliasesAndZodText as JzodTypeAliasesAndZodText, TsTypeAliases, } from "./JzodToTs";
 export { printTsTypeAlias, printTsTypeAliases } from "./tools";
-export { jzodArray, jzodAttribute, jzodAttributeDateValidations, jzodAttributeDateWithValidations, jzodAttributeNumberValidations, jzodAttributeNumberWithValidations, jzodAttributeStringValidations, jzodAttributeStringWithValidations, jzodElement, jzodEnumAttributeTypes, jzodEnumElementTypes, jzodEnum, jzodFunction, jzodIntersection, jzodLazy, jzodLiteral, jzodMapSchema, jzodObject, jzodPromise, jzodRecord, jzodReference, jzodSet, jzodTuple, jzodUnion, JzodArray, JzodAttribute, JzodAttributeDateValidations, JzodAttributeDateWithValidations, JzodAttributeNumberValidations, JzodAttributeNumberWithValidations, JzodAttributeStringValidations, JzodAttributeStringWithValidations, JzodElement, JzodEnum, JzodEnumTypes, JzodFunction, JzodEnumElementTypes, JzodIntersection, JzodLazy, JzodLiteral, JzodMap, JzodObject, JzodPromise, JzodRecord, JzodReference, JzodSet, JzodUnion, JzodTuple, } from "./JzodTsInterface";
+export { jzodArray, jzodAttribute, jzodAttributeDateValidations, jzodAttributeDateWithValidations, jzodAttributeNumberValidations, jzodAttributeNumberWithValidations, jzodAttributeStringValidations, jzodAttributeStringWithValidations, jzodElement, jzodEnumAttributeTypes, jzodEnumElementTypes, jzodEnum, jzodFunction, jzodIntersection, jzodLazy, jzodLiteral, jzodMap, jzodObject, jzodPromise, jzodRecord, jzodReference, jzodSet, jzodTuple, jzodUnion, JzodArray, JzodAttribute, JzodAttributeDateValidations, JzodAttributeDateWithValidations, JzodAttributeNumberValidations, JzodAttributeNumberWithValidations, JzodAttributeStringValidations, JzodAttributeStringWithValidations, JzodElement, JzodEnum, JzodEnumAttributeTypes, JzodFunction, JzodEnumElementTypes, JzodIntersection, JzodLazy, JzodLiteral, JzodMap, JzodObject, JzodPromise, JzodRecord, JzodReference, JzodSet, JzodUnion, JzodTuple, } from "./generated_jzodBootstrapElementSchema";

package/dist/src/preBuild.d.ts

@@ -0,0 +1 @@
+export declare function generateZodSchemaFileFromJzodSchema(jzodElement: any, targetFileName: string, jzodSchemaVariableName: string): void;