vms-nest-prisma-api-document 1.2.1 → 1.3.1

package/dist/zod/{zod_base_schema.js → zod_base_schema.mjs}

@@ -1,31 +1,5 @@
-"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_base_schema.ts
-var zod_base_schema_exports = {};
-__export(zod_base_schema_exports, {
-  BaseQuerySchema: () => BaseQuerySchema,
-  MongoBaseQuerySchema: () => MongoBaseQuerySchema,
-  OrderBySchema: () => OrderBySchema
-});
-module.exports = __toCommonJS(zod_base_schema_exports);
-var import_zod2 = require("zod");
+import { z as z2 } from "zod";
 
 // src/core/Enums.ts
 var PAGING = /* @__PURE__ */ ((PAGING2) => {
@@ -76,7 +50,7 @@ var YesNo = /* @__PURE__ */ ((YesNo2) => {
 })(YesNo || {});
 
 // src/zod/zod_utils.ts
-var import_zod = require("zod");
+import { z } from "zod";
 
 // src/core/BaseResponse.ts
 var r_log = (data = {}) => {
@@ -86,15 +60,15 @@ var r_log = (data = {}) => {
 // src/zod/zod_utils.ts
 var handleNullOrUndefined = (value) => typeof value === "string" ? value : "";
 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);
+  const schema = 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);
+  const schema = 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 stringArrayOptional = (fieldName, min = 0, max = 100, defaultValue = [], unique = false) => {
-  const schema = import_zod.z.array(import_zod.z.string().trim(), {
+  const schema = z.array(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) {
@@ -106,19 +80,19 @@ var stringArrayOptional = (fieldName, min = 0, max = 100, defaultValue = [], uni
   return schema.optional().default(defaultValue);
 };
 var numberOptional = (fieldName, min = 0, max = 1e9, defaultValue = 0) => {
-  return import_zod.z.preprocess(
+  return 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)
+    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 enumMandatory = (fieldName, enumType, defaultValue) => {
-  return import_zod.z.union([
-    import_zod.z.nativeEnum(enumType, {
+  return z.union([
+    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), {
+    z.string().refine((val) => Object.values(enumType).includes(val), {
       message: `${fieldName} should be one of the following values: ${Object.values(
         enumType
       ).join(", ")}.`
@@ -128,7 +102,7 @@ var enumMandatory = (fieldName, enumType, defaultValue) => {
   });
 };
 var enumOptional = (fieldName, enumType, defaultValue) => {
-  return import_zod.z.nativeEnum(enumType, {
+  return z.nativeEnum(enumType, {
     invalid_type_error: `${fieldName} must be an array containing only the following values: ${Object.values(
       enumType
     ).join(", ")}.`
@@ -138,7 +112,7 @@ var getAllEnums = (enumType) => {
   return Object.values(enumType);
 };
 var enumArrayOptional = (fieldName, enumType, defaultValue = getAllEnums(enumType), min = 0, max = 100, unique = false) => {
-  const schema = import_zod.z.array(import_zod.z.nativeEnum(enumType), {
+  const schema = z.array(z.nativeEnum(enumType), {
     invalid_type_error: `${fieldName} must be an array containing only the following values: ${Object.values(
       enumType
     ).join(", ")}.`
@@ -151,22 +125,22 @@ var enumArrayOptional = (fieldName, enumType, defaultValue = getAllEnums(enumTyp
   }
   return schema.optional().default(() => defaultValue);
 };
-var dynamicJsonSchema = (fieldName, defaultValue = {}) => import_zod.z.record(import_zod.z.any()).optional().default(() => defaultValue);
+var dynamicJsonSchema = (fieldName, defaultValue = {}) => z.record(z.any()).optional().default(() => defaultValue);
 var single_select_optional = (fieldName) => {
   r_log(fieldName);
-  const schema = import_zod.z.string().trim().transform(handleNullOrUndefined);
+  const schema = z.string().trim().transform(handleNullOrUndefined);
   return schema;
 };
 
 // src/zod/zod_base_schema.ts
-var OrderBySchema = import_zod2.z.array(
-  import_zod2.z.object({
+var OrderBySchema = z2.array(
+  z2.object({
     name: stringMandatory("Order Field Name", 0, 255),
     field: stringMandatory("Order Field Name", 0, 255),
     direction: enumMandatory("Order Direction", OrderBy, "asc" /* asc */)
   })
 );
-var BaseQuerySchema = import_zod2.z.object({
+var BaseQuerySchema = z2.object({
   search: stringOptional("Search", 0, 255, ""),
   status: enumArrayOptional("Status", Status, getAllEnums(Status), 0, 10, true),
   paging: enumOptional("Paging", PAGING, "Yes" /* Yes */),
@@ -189,7 +163,7 @@ var BaseQuerySchema = import_zod2.z.object({
   date_format_id: single_select_optional("MasterMainDateFormat"),
   time_zone_id: single_select_optional("MasterMainTimeZone")
 });
-var MongoBaseQuerySchema = import_zod2.z.object({
+var MongoBaseQuerySchema = z2.object({
   search: stringOptional("Search", 0, 255, ""),
   paging: enumOptional("Paging", PAGING, "Yes" /* Yes */),
   page_count: numberOptional("Page Count", 0, 1e3, 100),
@@ -200,9 +174,8 @@ var MongoBaseQuerySchema = import_zod2.z.object({
   time_zone_id: single_select_optional("MasterMainTimeZone")
   // ✅ Single-selection -> MasterMainTimeZone
 });
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   BaseQuerySchema,
   MongoBaseQuerySchema,
   OrderBySchema
-});
+};

package/dist/zod/{zod_utils.js → zod_utils.mjs}

@@ -1,63 +1,5 @@
-"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");
+import { z } from "zod";
 
 // src/core/BaseResponse.ts
 var r_log = (data = {}) => {
@@ -67,20 +9,20 @@ var r_log = (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);
+  const schema = 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);
+  const schema = 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);
+  const schema = 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(), {
+  const schema = z.array(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) {
@@ -92,7 +34,7 @@ var stringArrayMandatory = (fieldName, min = 1, max = 100, unique = false) => {
   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(), {
+  const schema = z.array(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) {
@@ -104,7 +46,7 @@ var stringArrayOptional = (fieldName, min = 0, max = 100, defaultValue = [], uni
   return schema.optional().default(defaultValue);
 };
 var numberMandatory = (fieldName, min = 1, max = 1e9, defaultValue = 0) => {
-  return import_zod.z.preprocess(
+  return z.preprocess(
     (val) => {
       if (val === null || val === void 0 || val === "") {
         return defaultValue;
@@ -114,19 +56,19 @@ var numberMandatory = (fieldName, min = 1, max = 1e9, defaultValue = 0) => {
       }
       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}.`)
+    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(
+  return 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)
+    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({
+  const schema = z.array(
+    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.`);
@@ -139,8 +81,8 @@ var numberArrayMandatory = (fieldName, min = 1, max = 100, unique = false) => {
   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({
+  const schema = z.array(
+    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.`);
@@ -153,7 +95,7 @@ var numberArrayOptional = (fieldName, min = 0, max = 100, defaultValue = [], uni
   return schema.optional().default(defaultValue);
 };
 var doubleMandatory = (fieldName, min = 0.1, max = 1e6, decimalPlaces = 2, defaultValue = 0) => {
-  return import_zod.z.preprocess(
+  return z.preprocess(
     (val) => {
       if (typeof val === "string") {
         val = parseFloat(val);
@@ -163,11 +105,11 @@ var doubleMandatory = (fieldName, min = 0.1, max = 1e6, decimalPlaces = 2, defau
       }
       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)
+    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(
+  return z.preprocess(
     (val) => {
       if (typeof val === "string") {
         val = parseFloat(val);
@@ -177,11 +119,11 @@ var doubleMandatoryLatLng = (fieldName, defaultValue = 0) => {
       }
       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)
+    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) => {
+  return z.preprocess((val) => {
     if (typeof val === "string") {
       val = parseFloat(val);
     }
@@ -189,10 +131,10 @@ var doubleMandatoryAmount = (fieldName, defaultValue = 0) => {
       return parseFloat(val.toFixed(6));
     }
     return val;
-  }, import_zod.z.number({ invalid_type_error: `${fieldName} must be a number.` }).default(defaultValue));
+  }, 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(
+  return z.preprocess(
     (val) => {
       if (typeof val === "string") {
         val = parseFloat(val);
@@ -202,11 +144,11 @@ var doubleOptional = (fieldName, min = 0, max = 1e6, decimalPlaces = 2, defaultV
       }
       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)
+    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(
+  return z.preprocess(
     (val) => {
       if (typeof val === "string") {
         val = parseFloat(val);
@@ -216,11 +158,11 @@ var doubleOptionalLatLng = (fieldName, defaultValue = 0) => {
       }
       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)
+    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) => {
+  return z.preprocess((val) => {
     if (typeof val === "string") {
       val = parseFloat(val);
     }
@@ -228,23 +170,23 @@ var doubleOptionalAmount = (fieldName, defaultValue = 0) => {
       return parseFloat(val.toFixed(6));
     }
     return val;
-  }, import_zod.z.number({ invalid_type_error: `${fieldName} must be a number.` }).default(defaultValue)).optional();
+  }, 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));
+  return 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);
+  return 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, {
+  return z.union([
+    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), {
+    z.string().refine((val) => Object.values(enumType).includes(val), {
       message: `${fieldName} should be one of the following values: ${Object.values(
         enumType
       ).join(", ")}.`
@@ -254,7 +196,7 @@ var enumMandatory = (fieldName, enumType, defaultValue) => {
   });
 };
 var enumOptional = (fieldName, enumType, defaultValue) => {
-  return import_zod.z.nativeEnum(enumType, {
+  return z.nativeEnum(enumType, {
     invalid_type_error: `${fieldName} must be an array containing only the following values: ${Object.values(
       enumType
     ).join(", ")}.`
@@ -265,7 +207,7 @@ 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), {
+  const schema = z.array(z.nativeEnum(enumType), {
     invalid_type_error: `${fieldName} must be an array containing only the following values: ${Object.values(
       enumType
     ).join(", ")}.`
@@ -280,7 +222,7 @@ var enumArrayMandatory = (fieldName, enumType, defaultValue = getAllEnums(enumTy
   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), {
+  const schema = z.array(z.nativeEnum(enumType), {
     invalid_type_error: `${fieldName} must be an array containing only the following values: ${Object.values(
       enumType
     ).join(", ")}.`
@@ -300,7 +242,7 @@ var handleNullOrUndefinedDate = (value, defaultValue) => {
   return defaultValue;
 };
 var dateMandatory = (fieldName, minDate, maxDate, defaultValue = (/* @__PURE__ */ new Date()).toISOString()) => {
-  const schema = import_zod.z.string().refine((val) => !isNaN(Date.parse(val)), {
+  const schema = z.string().refine((val) => !isNaN(Date.parse(val)), {
     message: `${fieldName} must be a valid ISO date.`
   }).transform((val) => handleNullOrUndefinedDate(val, defaultValue));
   if (minDate) {
@@ -316,7 +258,7 @@ var dateMandatory = (fieldName, minDate, maxDate, defaultValue = (/* @__PURE__ *
   return schema;
 };
 var dateOptional = (fieldName, minDate, maxDate, defaultValue = (/* @__PURE__ */ new Date()).toISOString()) => {
-  const schema = import_zod.z.string().refine((val) => !isNaN(Date.parse(val)), {
+  const schema = z.string().refine((val) => !isNaN(Date.parse(val)), {
     message: `${fieldName} must be a valid ISO date.`
   }).optional().default(defaultValue);
   if (minDate) {
@@ -332,7 +274,7 @@ var dateOptional = (fieldName, minDate, maxDate, defaultValue = (/* @__PURE__ */
   return schema;
 };
 var dateTimeMandatory = (fieldName, minDate, maxDate, defaultValue = (/* @__PURE__ */ new Date()).toISOString()) => {
-  const schema = import_zod.z.string().refine((val) => !isNaN(Date.parse(val)), {
+  const schema = z.string().refine((val) => !isNaN(Date.parse(val)), {
     message: `${fieldName} must be a valid ISO date.`
   }).transform((val) => handleNullOrUndefinedDate(val, defaultValue));
   if (minDate) {
@@ -348,7 +290,7 @@ var dateTimeMandatory = (fieldName, minDate, maxDate, defaultValue = (/* @__PURE
   return schema;
 };
 var dateTimeOptional = (fieldName, minDate, maxDate, defaultValue = (/* @__PURE__ */ new Date()).toISOString()) => {
-  const schema = import_zod.z.string().refine((val) => !isNaN(Date.parse(val)), {
+  const schema = z.string().refine((val) => !isNaN(Date.parse(val)), {
     message: `${fieldName} must be a valid ISO date.`
   }).optional().default(defaultValue);
   if (minDate) {
@@ -369,9 +311,9 @@ var nestedObjectMandatory = (fieldName, schema, 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 dynamicJsonSchema = (fieldName, defaultValue = {}) => z.record(z.any()).optional().default(() => defaultValue);
 var nestedArrayOfObjectMandatory = (fieldName, schema, defaultValue = [], min = 1, max) => {
-  let arraySchema = import_zod.z.array(schema, {
+  let arraySchema = 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) {
@@ -383,7 +325,7 @@ var nestedArrayOfObjectMandatory = (fieldName, schema, defaultValue = [], min =
   return arraySchema.default(() => defaultValue);
 };
 var nestedArrayOfObjectsOptional = (fieldName, schema, defaultValue = [], min = 0, max) => {
-  let arraySchema = import_zod.z.array(schema, {
+  let arraySchema = 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) {
@@ -395,17 +337,17 @@ var nestedArrayOfObjectsOptional = (fieldName, schema, defaultValue = [], min =
   return arraySchema.optional().default(() => defaultValue);
 };
 var single_select_mandatory = (fieldName) => {
-  const schema = import_zod.z.string().trim().nonempty(`Please select ${fieldName}.`).transform(handleNullOrUndefined);
+  const schema = 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);
+  const schema = 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({
+  const schema = z.array(
+    z.string({
       invalid_type_error: `${fieldName} must be an array of strings.`
     })
   ).min(
@@ -418,8 +360,8 @@ var multi_select_mandatory = (fieldName, min = 1, max = 100, defaultValue = [])
   return schema.optional().default(defaultValue);
 };
 var multi_select_optional = (fieldName, max = 1e3, defaultValue = []) => {
-  const schema = import_zod.z.array(
-    import_zod.z.string({
+  const schema = z.array(
+    z.string({
       invalid_type_error: `${fieldName} must be an array of strings.`
     })
   ).max(
@@ -428,8 +370,7 @@ var multi_select_optional = (fieldName, max = 1e3, defaultValue = []) => {
   );
   return schema.optional().default(defaultValue);
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   booleanMandatory,
   booleanOptional,
   dateMandatory,
@@ -465,4 +406,4 @@ var multi_select_optional = (fieldName, max = 1e3, defaultValue = []) => {
   stringMandatory,
   stringOptional,
   stringUUIDMandatory
-});
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vms-nest-prisma-api-document",
-  "version": "1.2.1",
+  "version": "1.3.1",
   "description": "Reusable API SDK built with NestJS, Prisma, Axios, and Zod for VMS frontends.",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/dist/core/BaseRequest.js

@@ -1,43 +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/core/BaseRequest.ts
-var BaseRequest_exports = {};
-__export(BaseRequest_exports, {
-  DefaultBaseFindParams: () => DefaultBaseFindParams,
-  withDefaults: () => withDefaults
-});
-module.exports = __toCommonJS(BaseRequest_exports);
-var DefaultBaseFindParams = {
-  search: "",
-  status: "Active,Inactive",
-  load_child: "No" /* No */,
-  load_parents: "No" /* No */,
-  paging: "Yes" /* Yes */,
-  page_index: 0,
-  page_count: 100
-};
-var withDefaults = (defaults, overrides = {}) => {
-  return { ...defaults, ...overrides };
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  DefaultBaseFindParams,
-  withDefaults
-});

package/dist/core/BaseResponse.js

@@ -1,32 +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/core/BaseResponse.ts
-var BaseResponse_exports = {};
-__export(BaseResponse_exports, {
-  r_log: () => r_log
-});
-module.exports = __toCommonJS(BaseResponse_exports);
-var r_log = (data = {}) => {
-  return data;
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  r_log
-});