vms-nest-prisma-api-document 1.1.5 → 1.1.7

package/dist/zod/zod_utils.cjs

@@ -1,468 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/zod/zod_utils.ts
-var zod_utils_exports = {};
-__export(zod_utils_exports, {
-  booleanMandatory: () => booleanMandatory,
-  booleanOptional: () => booleanOptional,
-  dateMandatory: () => dateMandatory,
-  dateOptional: () => dateOptional,
-  dateTimeMandatory: () => dateTimeMandatory,
-  dateTimeOptional: () => dateTimeOptional,
-  doubleMandatory: () => doubleMandatory,
-  doubleMandatoryAmount: () => doubleMandatoryAmount,
-  doubleMandatoryLatLng: () => doubleMandatoryLatLng,
-  doubleOptional: () => doubleOptional,
-  doubleOptionalAmount: () => doubleOptionalAmount,
-  doubleOptionalLatLng: () => doubleOptionalLatLng,
-  dynamicJsonSchema: () => dynamicJsonSchema,
-  enumArrayMandatory: () => enumArrayMandatory,
-  enumArrayOptional: () => enumArrayOptional,
-  enumMandatory: () => enumMandatory,
-  enumOptional: () => enumOptional,
-  getAllEnums: () => getAllEnums,
-  multi_select_mandatory: () => multi_select_mandatory,
-  multi_select_optional: () => multi_select_optional,
-  nestedArrayOfObjectMandatory: () => nestedArrayOfObjectMandatory,
-  nestedArrayOfObjectsOptional: () => nestedArrayOfObjectsOptional,
-  nestedObjectMandatory: () => nestedObjectMandatory,
-  nestedObjectOptional: () => nestedObjectOptional,
-  numberArrayMandatory: () => numberArrayMandatory,
-  numberArrayOptional: () => numberArrayOptional,
-  numberMandatory: () => numberMandatory,
-  numberOptional: () => numberOptional,
-  single_select_mandatory: () => single_select_mandatory,
-  single_select_optional: () => single_select_optional,
-  stringArrayMandatory: () => stringArrayMandatory,
-  stringArrayOptional: () => stringArrayOptional,
-  stringMandatory: () => stringMandatory,
-  stringOptional: () => stringOptional,
-  stringUUIDMandatory: () => stringUUIDMandatory
-});
-module.exports = __toCommonJS(zod_utils_exports);
-var import_zod = require("zod");
-
-// src/core/BaseResponse.ts
-var r_log = (data = {}) => {
-  return data;
-};
-
-// src/zod/zod_utils.ts
-var handleNullOrUndefined = (value) => typeof value === "string" ? value : "";
-var stringUUIDMandatory = (fieldName) => {
-  const schema = import_zod.z.string().trim().uuid({ message: `${fieldName} must be a valid UUID` }).nonempty(`${fieldName} is required.`).transform(handleNullOrUndefined);
-  return schema;
-};
-var stringMandatory = (fieldName, min = 1, max = 100) => {
-  const schema = import_zod.z.string().trim().min(min, `${fieldName} must be at least ${min} characters.`).max(max, `${fieldName} must be at most ${max} characters.`).nonempty(`${fieldName} is required.`).transform(handleNullOrUndefined);
-  return schema;
-};
-var stringOptional = (fieldName, min = 0, max = 255, defaultValue = "") => {
-  const schema = import_zod.z.string().trim().min(min, `${fieldName} must be at least ${min} characters.`).max(max, `${fieldName} must be at most ${max} characters.`).transform(handleNullOrUndefined).default(defaultValue);
-  return schema;
-};
-var handleNullOrUndefinedStringArray = (value, defaultValue) => Array.isArray(value) ? value : defaultValue;
-var stringArrayMandatory = (fieldName, min = 1, max = 100, unique = false) => {
-  const schema = import_zod.z.array(import_zod.z.string().trim(), {
-    invalid_type_error: `${fieldName} must be an array of strings.`
-  }).min(min, `${fieldName} must contain at least ${min} items.`).max(max, `${fieldName} must contain at most ${max} items.`);
-  if (unique) {
-    schema.refine(
-      (arr) => new Set(arr).size === arr.length,
-      `${fieldName} must contain unique values.`
-    );
-  }
-  return schema.transform((val) => handleNullOrUndefinedStringArray(val, []));
-};
-var stringArrayOptional = (fieldName, min = 0, max = 100, defaultValue = [], unique = false) => {
-  const schema = import_zod.z.array(import_zod.z.string().trim(), {
-    invalid_type_error: `${fieldName} must be an array of strings.`
-  }).min(min, `${fieldName} must contain at least ${min} items.`).max(max, `${fieldName} must contain at most ${max} items.`);
-  if (unique) {
-    schema.refine(
-      (arr) => new Set(arr).size === arr.length,
-      `${fieldName} must contain unique values.`
-    );
-  }
-  return schema.optional().default(defaultValue);
-};
-var numberMandatory = (fieldName, min = 1, max = 1e9, defaultValue = 0) => {
-  return import_zod.z.preprocess(
-    (val) => {
-      if (val === null || val === void 0 || val === "") {
-        return defaultValue;
-      }
-      if (typeof val === "string" && !isNaN(Number(val))) {
-        return Number(val);
-      }
-      return val;
-    },
-    import_zod.z.number({ invalid_type_error: `${fieldName} must be a number.` }).min(min, `${fieldName} must be at least ${min}.`).max(max, `${fieldName} must be at most ${max}.`)
-  );
-};
-var numberOptional = (fieldName, min = 0, max = 1e9, defaultValue = 0) => {
-  return import_zod.z.preprocess(
-    (val) => typeof val === "string" && val.trim() !== "" ? Number(val) : val,
-    import_zod.z.number({ invalid_type_error: `${fieldName} must be a number.` }).min(min, `${fieldName} must be at least ${min}.`).max(max, `${fieldName} must be at most ${max}.`).optional().default(defaultValue)
-  );
-};
-var handleNullOrUndefinedNumberArray = (value, defaultValue) => Array.isArray(value) ? value : defaultValue;
-var numberArrayMandatory = (fieldName, min = 1, max = 100, unique = false) => {
-  const schema = import_zod.z.array(
-    import_zod.z.number({
-      invalid_type_error: `${fieldName} must be an array of numbers.`
-    })
-  ).min(min, `${fieldName} must contain at least ${min} items.`).max(max, `${fieldName} must contain at most ${max} items.`);
-  if (unique) {
-    schema.refine(
-      (arr) => new Set(arr).size === arr.length,
-      `${fieldName} must contain unique values.`
-    );
-  }
-  return schema.transform((val) => handleNullOrUndefinedNumberArray(val, []));
-};
-var numberArrayOptional = (fieldName, min = 0, max = 100, defaultValue = [], unique = false) => {
-  const schema = import_zod.z.array(
-    import_zod.z.number({
-      invalid_type_error: `${fieldName} must be an array of numbers.`
-    })
-  ).min(min, `${fieldName} must contain at least ${min} items.`).max(max, `${fieldName} must contain at most ${max} items.`);
-  if (unique) {
-    schema.refine(
-      (arr) => new Set(arr).size === arr.length,
-      `${fieldName} must contain unique values.`
-    );
-  }
-  return schema.optional().default(defaultValue);
-};
-var doubleMandatory = (fieldName, min = 0.1, max = 1e6, decimalPlaces = 2, defaultValue = 0) => {
-  return import_zod.z.preprocess(
-    (val) => {
-      if (typeof val === "string") {
-        val = parseFloat(val);
-      }
-      if (typeof val === "number") {
-        return parseFloat(val.toFixed(decimalPlaces));
-      }
-      return val;
-    },
-    import_zod.z.number({ invalid_type_error: `${fieldName} must be a number.` }).min(min, `${fieldName} must be at least ${min}.`).max(max, `${fieldName} must be at most ${max}.`).default(defaultValue)
-  );
-};
-var doubleMandatoryLatLng = (fieldName, defaultValue = 0) => {
-  return import_zod.z.preprocess(
-    (val) => {
-      if (typeof val === "string") {
-        val = parseFloat(val);
-      }
-      if (typeof val === "number") {
-        return parseFloat(val.toFixed(6));
-      }
-      return val;
-    },
-    import_zod.z.number({ invalid_type_error: `${fieldName} must be a number.` }).min(-180, `${fieldName} must be at least -180.`).max(180, `${fieldName} must be at most 180.`).default(defaultValue)
-  );
-};
-var doubleMandatoryAmount = (fieldName, defaultValue = 0) => {
-  return import_zod.z.preprocess((val) => {
-    if (typeof val === "string") {
-      val = parseFloat(val);
-    }
-    if (typeof val === "number") {
-      return parseFloat(val.toFixed(6));
-    }
-    return val;
-  }, import_zod.z.number({ invalid_type_error: `${fieldName} must be a number.` }).default(defaultValue));
-};
-var doubleOptional = (fieldName, min = 0, max = 1e6, decimalPlaces = 2, defaultValue = 0) => {
-  return import_zod.z.preprocess(
-    (val) => {
-      if (typeof val === "string") {
-        val = parseFloat(val);
-      }
-      if (typeof val === "number") {
-        return parseFloat(val.toFixed(decimalPlaces));
-      }
-      return val;
-    },
-    import_zod.z.number({ invalid_type_error: `${fieldName} must be a number.` }).min(min, `${fieldName} must be at least ${min}.`).max(max, `${fieldName} must be at most ${max}.`).default(defaultValue)
-  ).optional();
-};
-var doubleOptionalLatLng = (fieldName, defaultValue = 0) => {
-  return import_zod.z.preprocess(
-    (val) => {
-      if (typeof val === "string") {
-        val = parseFloat(val);
-      }
-      if (typeof val === "number") {
-        return parseFloat(val.toFixed(6));
-      }
-      return val;
-    },
-    import_zod.z.number({ invalid_type_error: `${fieldName} must be a number.` }).min(-180, `${fieldName} must be at least -180.`).max(180, `${fieldName} must be at most 180.`).default(defaultValue)
-  ).optional();
-};
-var doubleOptionalAmount = (fieldName, defaultValue = 0) => {
-  return import_zod.z.preprocess((val) => {
-    if (typeof val === "string") {
-      val = parseFloat(val);
-    }
-    if (typeof val === "number") {
-      return parseFloat(val.toFixed(6));
-    }
-    return val;
-  }, import_zod.z.number({ invalid_type_error: `${fieldName} must be a number.` }).default(defaultValue)).optional();
-};
-var handleNullOrUndefinedBoolean = (value, defaultValue) => typeof value === "boolean" ? value : defaultValue;
-var booleanMandatory = (fieldName, defaultValue = false) => {
-  return import_zod.z.boolean({ invalid_type_error: `${fieldName} must be true or false.` }).transform((val) => handleNullOrUndefinedBoolean(val, defaultValue));
-};
-var booleanOptional = (fieldName, defaultValue = false) => {
-  return import_zod.z.boolean({ invalid_type_error: `${fieldName} must be true or false.` }).optional().default(defaultValue);
-};
-var enumMandatory = (fieldName, enumType, defaultValue) => {
-  return import_zod.z.union([
-    import_zod.z.nativeEnum(enumType, {
-      invalid_type_error: `${fieldName} should be one of the following values: ${Object.values(
-        enumType
-      ).join(", ")}.`
-    }),
-    import_zod.z.string().refine((val) => Object.values(enumType).includes(val), {
-      message: `${fieldName} should be one of the following values: ${Object.values(
-        enumType
-      ).join(", ")}.`
-    })
-  ]).default(defaultValue).refine((val) => val !== "", {
-    message: `Please select ${fieldName}.`
-  });
-};
-var enumOptional = (fieldName, enumType, defaultValue) => {
-  return import_zod.z.nativeEnum(enumType, {
-    invalid_type_error: `${fieldName} must be an array containing only the following values: ${Object.values(
-      enumType
-    ).join(", ")}.`
-  }).optional().default(() => defaultValue);
-};
-var handleNullOrUndefinedEnumArray = (value, defaultValue) => Array.isArray(value) ? value : defaultValue;
-var getAllEnums = (enumType) => {
-  return Object.values(enumType);
-};
-var enumArrayMandatory = (fieldName, enumType, defaultValue = getAllEnums(enumType), min = 1, max = 100, unique = false) => {
-  const schema = import_zod.z.array(import_zod.z.nativeEnum(enumType), {
-    invalid_type_error: `${fieldName} must be an array containing only the following values: ${Object.values(
-      enumType
-    ).join(", ")}.`
-  }).min(min, `${fieldName} must contain at least ${min} items.`).max(max, `${fieldName} must contain at most ${max} items.`);
-  if (unique) {
-    schema.refine(
-      (arr) => new Set(arr).size === arr.length,
-      `${fieldName} must contain unique values.`
-    );
-  }
-  schema.transform((val) => handleNullOrUndefinedEnumArray(val, []));
-  return schema.default(() => defaultValue);
-};
-var enumArrayOptional = (fieldName, enumType, defaultValue = getAllEnums(enumType), min = 0, max = 100, unique = false) => {
-  const schema = import_zod.z.array(import_zod.z.nativeEnum(enumType), {
-    invalid_type_error: `${fieldName} must be an array containing only the following values: ${Object.values(
-      enumType
-    ).join(", ")}.`
-  }).min(min, `${fieldName} must contain at least ${min} items.`).max(max, `${fieldName} must contain at most ${max} items.`);
-  if (unique) {
-    schema.refine(
-      (arr) => new Set(arr).size === arr.length,
-      `${fieldName} must contain unique values.`
-    );
-  }
-  return schema.optional().default(() => defaultValue);
-};
-var handleNullOrUndefinedDate = (value, defaultValue) => {
-  if (typeof value === "string" && !isNaN(Date.parse(value))) {
-    return value;
-  }
-  return defaultValue;
-};
-var dateMandatory = (fieldName, minDate, maxDate, defaultValue = (/* @__PURE__ */ new Date()).toISOString()) => {
-  const schema = import_zod.z.string().refine((val) => !isNaN(Date.parse(val)), {
-    message: `${fieldName} must be a valid ISO date.`
-  }).transform((val) => handleNullOrUndefinedDate(val, defaultValue));
-  if (minDate) {
-    schema.refine((val) => new Date(val) >= new Date(minDate), {
-      message: `${fieldName} must be after ${minDate}.`
-    });
-  }
-  if (maxDate) {
-    schema.refine((val) => new Date(val) <= new Date(maxDate), {
-      message: `${fieldName} must be before ${maxDate}.`
-    });
-  }
-  return schema;
-};
-var dateOptional = (fieldName, minDate, maxDate, defaultValue = (/* @__PURE__ */ new Date()).toISOString()) => {
-  const schema = import_zod.z.string().refine((val) => !isNaN(Date.parse(val)), {
-    message: `${fieldName} must be a valid ISO date.`
-  }).optional().default(defaultValue);
-  if (minDate) {
-    schema.refine((val) => new Date(val) >= new Date(minDate), {
-      message: `${fieldName} must be after ${minDate}.`
-    });
-  }
-  if (maxDate) {
-    schema.refine((val) => new Date(val) <= new Date(maxDate), {
-      message: `${fieldName} must be before ${maxDate}.`
-    });
-  }
-  return schema;
-};
-var dateTimeMandatory = (fieldName, minDate, maxDate, defaultValue = (/* @__PURE__ */ new Date()).toISOString()) => {
-  const schema = import_zod.z.string().refine((val) => !isNaN(Date.parse(val)), {
-    message: `${fieldName} must be a valid ISO date.`
-  }).transform((val) => handleNullOrUndefinedDate(val, defaultValue));
-  if (minDate) {
-    schema.refine((val) => new Date(val) >= new Date(minDate), {
-      message: `${fieldName} must be after ${minDate}.`
-    });
-  }
-  if (maxDate) {
-    schema.refine((val) => new Date(val) <= new Date(maxDate), {
-      message: `${fieldName} must be before ${maxDate}.`
-    });
-  }
-  return schema;
-};
-var dateTimeOptional = (fieldName, minDate, maxDate, defaultValue = (/* @__PURE__ */ new Date()).toISOString()) => {
-  const schema = import_zod.z.string().refine((val) => !isNaN(Date.parse(val)), {
-    message: `${fieldName} must be a valid ISO date.`
-  }).optional().default(defaultValue);
-  if (minDate) {
-    schema.refine((val) => new Date(val) >= new Date(minDate), {
-      message: `${fieldName} must be after ${minDate}.`
-    });
-  }
-  if (maxDate) {
-    schema.refine((val) => new Date(val) <= new Date(maxDate), {
-      message: `${fieldName} must be before ${maxDate}.`
-    });
-  }
-  return schema;
-};
-var nestedObjectMandatory = (fieldName, schema, defaultValue) => {
-  return schema.default(() => defaultValue);
-};
-var nestedObjectOptional = (fieldName, schema, defaultValue) => {
-  return schema.optional().default(() => defaultValue);
-};
-var dynamicJsonSchema = (fieldName, defaultValue = {}) => import_zod.z.record(import_zod.z.any()).optional().default(() => defaultValue);
-var nestedArrayOfObjectMandatory = (fieldName, schema, defaultValue = [], min = 1, max) => {
-  let arraySchema = import_zod.z.array(schema, {
-    invalid_type_error: `${fieldName} must be an array of objects.`
-  }).min(min, `${fieldName} must contain at least ${min} items.`);
-  if (max !== void 0) {
-    arraySchema = arraySchema.max(
-      max,
-      `${fieldName} must contain at most ${max} items.`
-    );
-  }
-  return arraySchema.default(() => defaultValue);
-};
-var nestedArrayOfObjectsOptional = (fieldName, schema, defaultValue = [], min = 0, max) => {
-  let arraySchema = import_zod.z.array(schema, {
-    invalid_type_error: `${fieldName} must be an array of objects.`
-  }).min(min, `${fieldName} must contain at least ${min} items.`);
-  if (max !== void 0) {
-    arraySchema = arraySchema.max(
-      max,
-      `${fieldName} must contain at most ${max} items.`
-    );
-  }
-  return arraySchema.optional().default(() => defaultValue);
-};
-var single_select_mandatory = (fieldName) => {
-  const schema = import_zod.z.string().trim().nonempty(`Please select ${fieldName}.`).transform(handleNullOrUndefined);
-  return schema;
-};
-var single_select_optional = (fieldName) => {
-  r_log(fieldName);
-  const schema = import_zod.z.string().trim().transform(handleNullOrUndefined);
-  return schema;
-};
-var multi_select_mandatory = (fieldName, min = 1, max = 100, defaultValue = []) => {
-  const schema = import_zod.z.array(
-    import_zod.z.string({
-      invalid_type_error: `${fieldName} must be an array of strings.`
-    })
-  ).min(
-    min,
-    `Please select at least ${min} ${fieldName}${min > 1 ? "s" : ""}.`
-  ).max(
-    max,
-    `Please select at most ${max} ${fieldName}${max > 1 ? "s" : ""}.`
-  );
-  return schema.optional().default(defaultValue);
-};
-var multi_select_optional = (fieldName, max = 1e3, defaultValue = []) => {
-  const schema = import_zod.z.array(
-    import_zod.z.string({
-      invalid_type_error: `${fieldName} must be an array of strings.`
-    })
-  ).max(
-    max,
-    `Please select at most ${max} ${fieldName}${max > 1 ? "s" : ""}.`
-  );
-  return schema.optional().default(defaultValue);
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  booleanMandatory,
-  booleanOptional,
-  dateMandatory,
-  dateOptional,
-  dateTimeMandatory,
-  dateTimeOptional,
-  doubleMandatory,
-  doubleMandatoryAmount,
-  doubleMandatoryLatLng,
-  doubleOptional,
-  doubleOptionalAmount,
-  doubleOptionalLatLng,
-  dynamicJsonSchema,
-  enumArrayMandatory,
-  enumArrayOptional,
-  enumMandatory,
-  enumOptional,
-  getAllEnums,
-  multi_select_mandatory,
-  multi_select_optional,
-  nestedArrayOfObjectMandatory,
-  nestedArrayOfObjectsOptional,
-  nestedObjectMandatory,
-  nestedObjectOptional,
-  numberArrayMandatory,
-  numberArrayOptional,
-  numberMandatory,
-  numberOptional,
-  single_select_mandatory,
-  single_select_optional,
-  stringArrayMandatory,
-  stringArrayOptional,
-  stringMandatory,
-  stringOptional,
-  stringUUIDMandatory
-});

package/dist/zod/zod_utils.d.cts

@@ -1,39 +0,0 @@
-import { z } from 'zod';
-
-declare const stringUUIDMandatory: (fieldName: string) => z.ZodEffects<z.ZodString, string, string>;
-declare const stringMandatory: (fieldName: string, min?: number, max?: number) => z.ZodEffects<z.ZodString, string, string>;
-declare const stringOptional: (fieldName: string, min?: number, max?: number, defaultValue?: string) => z.ZodDefault<z.ZodEffects<z.ZodString, string, string>>;
-declare const stringArrayMandatory: (fieldName: string, min?: number, max?: number, unique?: boolean) => z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
-declare const stringArrayOptional: (fieldName: string, min?: number, max?: number, defaultValue?: string[], unique?: boolean) => z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
-declare const numberMandatory: (fieldName: string, min?: number, max?: number, defaultValue?: number) => z.ZodEffects<z.ZodNumber, number, unknown>;
-declare const numberOptional: (fieldName: string, min?: number, max?: number, defaultValue?: number) => z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodNumber>>, number, unknown>;
-declare const numberArrayMandatory: (fieldName: string, min?: number, max?: number, unique?: boolean) => z.ZodEffects<z.ZodArray<z.ZodNumber, "many">, number[], number[]>;
-declare const numberArrayOptional: (fieldName: string, min?: number, max?: number, defaultValue?: number[], unique?: boolean) => z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>>;
-declare const doubleMandatory: (fieldName: string, min?: number, max?: number, decimalPlaces?: number, defaultValue?: number) => z.ZodEffects<z.ZodDefault<z.ZodNumber>, number, unknown>;
-declare const doubleMandatoryLatLng: (fieldName: string, defaultValue?: number) => z.ZodEffects<z.ZodDefault<z.ZodNumber>, number, unknown>;
-declare const doubleMandatoryAmount: (fieldName: string, defaultValue?: number) => z.ZodEffects<z.ZodDefault<z.ZodNumber>, number, unknown>;
-declare const doubleOptional: (fieldName: string, min?: number, max?: number, decimalPlaces?: number, defaultValue?: number) => z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodNumber>, number, unknown>>;
-declare const doubleOptionalLatLng: (fieldName: string, defaultValue?: number) => z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodNumber>, number, unknown>>;
-declare const doubleOptionalAmount: (fieldName: string, defaultValue?: number) => z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodNumber>, number, unknown>>;
-declare const booleanMandatory: (fieldName: string, defaultValue?: boolean) => z.ZodEffects<z.ZodBoolean, boolean, boolean>;
-declare const booleanOptional: (fieldName: string, defaultValue?: boolean) => z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-declare const enumMandatory: <T extends Record<string, string>>(fieldName: string, enumType: T, defaultValue: T[keyof T]) => z.ZodType<T[keyof T]>;
-declare const enumOptional: <T extends Record<string, string>>(fieldName: string, enumType: T, defaultValue: T[keyof T]) => z.ZodDefault<z.ZodOptional<z.ZodNativeEnum<T>>>;
-declare const getAllEnums: <T extends Record<string, string>>(enumType: T) => (keyof T)[];
-declare const enumArrayMandatory: <T extends Record<string, string>>(fieldName: string, enumType: T, defaultValue?: (keyof T)[], min?: number, max?: number, unique?: boolean) => z.ZodDefault<z.ZodArray<z.ZodNativeEnum<T>, "many">>;
-declare const enumArrayOptional: <T extends Record<string, string>>(fieldName: string, enumType: T, defaultValue?: (keyof T)[], min?: number, max?: number, unique?: boolean) => z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodNativeEnum<T>, "many">>>;
-declare const dateMandatory: (fieldName: string, minDate?: string, maxDate?: string, defaultValue?: string) => z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
-declare const dateOptional: (fieldName: string, minDate?: string, maxDate?: string, defaultValue?: string) => z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>>;
-declare const dateTimeMandatory: (fieldName: string, minDate?: string, maxDate?: string, defaultValue?: string) => z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
-declare const dateTimeOptional: (fieldName: string, minDate?: string, maxDate?: string, defaultValue?: string) => z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>>;
-declare const nestedObjectMandatory: <T extends z.ZodRawShape>(fieldName: string, schema: z.ZodObject<T>, defaultValue: z.infer<typeof schema>) => z.ZodDefault<z.ZodObject<T, z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<T>, any> extends infer T_1 ? { [k in keyof T_1]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<T>, any>[k]; } : never, z.baseObjectInputType<T> extends infer T_2 ? { [k_1 in keyof T_2]: z.baseObjectInputType<T>[k_1]; } : never>>;
-declare const nestedObjectOptional: <T extends z.ZodRawShape>(fieldName: string, schema: z.ZodObject<T>, defaultValue: z.infer<typeof schema>) => z.ZodDefault<z.ZodOptional<z.ZodObject<T, z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<T>, any> extends infer T_1 ? { [k in keyof T_1]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<T>, any>[k]; } : never, z.baseObjectInputType<T> extends infer T_2 ? { [k_1 in keyof T_2]: z.baseObjectInputType<T>[k_1]; } : never>>>;
-declare const dynamicJsonSchema: (fieldName: string, defaultValue?: Record<string, unknown>) => z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>>;
-declare const nestedArrayOfObjectMandatory: <T extends z.ZodRawShape>(fieldName: string, schema: z.ZodObject<T>, defaultValue?: z.infer<typeof schema>[], min?: number, max?: number) => z.ZodDefault<z.ZodArray<z.ZodObject<T, z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<T>, any> extends infer T_1 ? { [k in keyof T_1]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<T>, any>[k]; } : never, z.baseObjectInputType<T> extends infer T_2 ? { [k_1 in keyof T_2]: z.baseObjectInputType<T>[k_1]; } : never>, "many">>;
-declare const nestedArrayOfObjectsOptional: <T extends z.ZodRawShape>(fieldName: string, schema: z.ZodObject<T>, defaultValue?: z.infer<typeof schema>[], min?: number, max?: number) => z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<T, z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<T>, any> extends infer T_1 ? { [k in keyof T_1]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<T>, any>[k]; } : never, z.baseObjectInputType<T> extends infer T_2 ? { [k_1 in keyof T_2]: z.baseObjectInputType<T>[k_1]; } : never>, "many">>>;
-declare const single_select_mandatory: (fieldName: string) => z.ZodEffects<z.ZodString, string, string>;
-declare const single_select_optional: (fieldName: string) => z.ZodEffects<z.ZodString, string, string>;
-declare const multi_select_mandatory: (fieldName: string, min?: number, max?: number, defaultValue?: string[]) => z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
-declare const multi_select_optional: (fieldName: string, max?: number, defaultValue?: string[]) => z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
-
-export { booleanMandatory, booleanOptional, dateMandatory, dateOptional, dateTimeMandatory, dateTimeOptional, doubleMandatory, doubleMandatoryAmount, doubleMandatoryLatLng, doubleOptional, doubleOptionalAmount, doubleOptionalLatLng, dynamicJsonSchema, enumArrayMandatory, enumArrayOptional, enumMandatory, enumOptional, getAllEnums, multi_select_mandatory, multi_select_optional, nestedArrayOfObjectMandatory, nestedArrayOfObjectsOptional, nestedObjectMandatory, nestedObjectOptional, numberArrayMandatory, numberArrayOptional, numberMandatory, numberOptional, single_select_mandatory, single_select_optional, stringArrayMandatory, stringArrayOptional, stringMandatory, stringOptional, stringUUIDMandatory };