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

package/dist/zod/zod_utils.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vms-nest-prisma-api-document",
-  "version": "1.1.7",
+  "version": "1.2.1",
   "description": "Reusable API SDK built with NestJS, Prisma, Axios, and Zod for VMS frontends.",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -65,7 +65,7 @@
       ]
     }
   },
-  "type": "module",
+  "type": "commonjs",
   "dependencies": {
     "axios": "^1.11.0",
     "zod": "^3.24.1"

package/dist/{user_organisation_service-umUoNvpJ.d.ts → user_organisation_service-CNOJPhQD.d.ts}

@@ -1268,6 +1268,8 @@ declare const DriverQuerySchema: z.ZodObject<{
     is_vehicle_assigned: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodNativeEnum<typeof YesNo>, "many">>>;
 }, "strip", z.ZodTypeAny, {
     status: Status[];
+    vehicle_ids: string[];
+    driver_ids: string[];
     search: string;
     paging: PAGING;
     page_count: number;
@@ -1291,12 +1293,12 @@ declare const DriverQuerySchema: z.ZodObject<{
     organisation_ids: string[];
     can_login: YesNo[];
     is_vehicle_assigned: YesNo[];
-    vehicle_ids: string[];
-    driver_ids: string[];
 }, {
     date_format_id: string;
     time_zone_id: string;
     status?: Status[] | undefined;
+    vehicle_ids?: string[] | undefined;
+    driver_ids?: string[] | undefined;
     search?: string | undefined;
     paging?: PAGING | undefined;
     page_count?: unknown;
@@ -1318,8 +1320,6 @@ declare const DriverQuerySchema: z.ZodObject<{
     organisation_ids?: string[] | undefined;
     can_login?: YesNo[] | undefined;
     is_vehicle_assigned?: YesNo[] | undefined;
-    vehicle_ids?: string[] | undefined;
-    driver_ids?: string[] | undefined;
 }>;
 type DriverQueryDTO = z.infer<typeof DriverQuerySchema>;
 declare const toDriverPayload: (driver?: MasterDriver) => MasterDriverDTO;
@@ -2006,6 +2006,7 @@ declare const MasterDeviceQuerySchema: z.ZodObject<{
     device_gps_source: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodNativeEnum<typeof GPSSource>, "many">>>;
 }, "strip", z.ZodTypeAny, {
     status: Status[];
+    vehicle_ids: string[];
     search: string;
     paging: PAGING;
     page_count: number;
@@ -2029,7 +2030,6 @@ declare const MasterDeviceQuerySchema: z.ZodObject<{
     organisation_ids: string[];
     country_ids: string[];
     time_zone_ids: string[];
-    vehicle_ids: string[];
     device_manufacturer_ids: string[];
     device_model_ids: string[];
     device_type_ids: string[];
@@ -2041,6 +2041,7 @@ declare const MasterDeviceQuerySchema: z.ZodObject<{
     date_format_id: string;
     time_zone_id: string;
     status?: Status[] | undefined;
+    vehicle_ids?: string[] | undefined;
     search?: string | undefined;
     paging?: PAGING | undefined;
     page_count?: unknown;
@@ -2062,7 +2063,6 @@ declare const MasterDeviceQuerySchema: z.ZodObject<{
     organisation_ids?: string[] | undefined;
     country_ids?: string[] | undefined;
     time_zone_ids?: string[] | undefined;
-    vehicle_ids?: string[] | undefined;
     device_manufacturer_ids?: string[] | undefined;
     device_model_ids?: string[] | undefined;
     device_type_ids?: string[] | undefined;
@@ -2674,6 +2674,7 @@ declare const OrganisationGroupQuerySchema: z.ZodObject<{
     vehicle_ids: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
 }, "strip", z.ZodTypeAny, {
     status: Status[];
+    vehicle_ids: string[];
     search: string;
     paging: PAGING;
     page_count: number;
@@ -2695,12 +2696,12 @@ declare const OrganisationGroupQuerySchema: z.ZodObject<{
     date_format_id: string;
     time_zone_id: string;
     organisation_ids: string[];
-    vehicle_ids: string[];
     organisation_group_ids: string[];
 }, {
     date_format_id: string;
     time_zone_id: string;
     status?: Status[] | undefined;
+    vehicle_ids?: string[] | undefined;
     search?: string | undefined;
     paging?: PAGING | undefined;
     page_count?: unknown;
@@ -2720,7 +2721,6 @@ declare const OrganisationGroupQuerySchema: z.ZodObject<{
     }[] | undefined;
     include_master_data?: YesNo | undefined;
     organisation_ids?: string[] | undefined;
-    vehicle_ids?: string[] | undefined;
     organisation_group_ids?: string[] | undefined;
 }>;
 type OrganisationGroupQueryDTO = z.infer<typeof OrganisationGroupQuerySchema>;
@@ -4056,9 +4056,9 @@ declare const VehicleDeviceLinkSchema: z.ZodObject<{
     camera_extra_count: z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodNumber>>, number, unknown>;
 }, "strip", z.ZodTypeAny, {
     organisation_id: string;
+    vehicle_id: string;
     time_zone_id: string;
     country_id: string;
-    vehicle_id: string;
     device_type_id: string;
     device_manufacturer_id: string;
     device_model_id: string;
@@ -4079,9 +4079,9 @@ declare const VehicleDeviceLinkSchema: z.ZodObject<{
     camera_extra_count: number;
 }, {
     organisation_id: string;
+    vehicle_id: string;
     time_zone_id: string;
     country_id: string;
-    vehicle_id: string;
     device_type_id: string;
     device_manufacturer_id: string;
     device_model_id: string;
@@ -4119,12 +4119,12 @@ declare const VehicleDriverLinkSchema: z.ZodObject<{
     driver_id: z.ZodEffects<z.ZodString, string, string>;
 }, "strip", z.ZodTypeAny, {
     organisation_id: string;
-    driver_id: string;
     vehicle_id: string;
+    driver_id: string;
 }, {
     organisation_id: string;
-    driver_id: string;
     vehicle_id: string;
+    driver_id: string;
 }>;
 type VehicleDriverLinkDTO = z.infer<typeof VehicleDriverLinkSchema>;
 declare const SimpleFindQuerySchema: z.ZodObject<{
@@ -4634,6 +4634,8 @@ declare const VehicleQuerySchema: z.ZodObject<{
     is_driver_assigned: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodNativeEnum<typeof YesNo>, "many">>>;
 }, "strip", z.ZodTypeAny, {
     status: Status[];
+    vehicle_ids: string[];
+    driver_ids: string[];
     search: string;
     paging: PAGING;
     page_count: number;
@@ -4655,8 +4657,6 @@ declare const VehicleQuerySchema: z.ZodObject<{
     date_format_id: string;
     time_zone_id: string;
     organisation_ids: string[];
-    vehicle_ids: string[];
-    driver_ids: string[];
     device_ids: string[];
     organisation_sub_company_ids: string[];
     organisation_branch_ids: string[];
@@ -4675,6 +4675,8 @@ declare const VehicleQuerySchema: z.ZodObject<{
     date_format_id: string;
     time_zone_id: string;
     status?: Status[] | undefined;
+    vehicle_ids?: string[] | undefined;
+    driver_ids?: string[] | undefined;
     search?: string | undefined;
     paging?: PAGING | undefined;
     page_count?: unknown;
@@ -4694,8 +4696,6 @@ declare const VehicleQuerySchema: z.ZodObject<{
     }[] | undefined;
     include_master_data?: YesNo | undefined;
     organisation_ids?: string[] | undefined;
-    vehicle_ids?: string[] | undefined;
-    driver_ids?: string[] | undefined;
     device_ids?: string[] | undefined;
     organisation_sub_company_ids?: string[] | undefined;
     organisation_branch_ids?: string[] | undefined;
@@ -4748,6 +4748,7 @@ declare const VehicleGPSQuerySchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     status: Status[];
     organisation_id: string;
+    vehicle_id: string;
     search: string;
     paging: PAGING;
     page_count: number;
@@ -4768,12 +4769,11 @@ declare const VehicleGPSQuerySchema: z.ZodObject<{
     include_master_data: YesNo;
     date_format_id: string;
     time_zone_id: string;
-    vehicle_id: string;
 }, {
     organisation_id: string;
+    vehicle_id: string;
     date_format_id: string;
     time_zone_id: string;
-    vehicle_id: string;
     status?: Status[] | undefined;
     search?: string | undefined;
     paging?: PAGING | undefined;
@@ -5636,6 +5636,7 @@ declare const UserQuerySchema: z.ZodObject<{
     is_activated: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodNativeEnum<typeof YesNo>, "many">>>;
 }, "strip", z.ZodTypeAny, {
     status: Status[];
+    user_ids: string[];
     search: string;
     paging: PAGING;
     page_count: number;
@@ -5657,7 +5658,6 @@ declare const UserQuerySchema: z.ZodObject<{
     date_format_id: string;
     time_zone_id: string;
     organisation_ids: string[];
-    user_ids: string[];
     country_ids: string[];
     can_login: YesNo[];
     user_role_ids: string[];
@@ -5668,6 +5668,7 @@ declare const UserQuerySchema: z.ZodObject<{
     date_format_id: string;
     time_zone_id: string;
     status?: Status[] | undefined;
+    user_ids?: string[] | undefined;
     search?: string | undefined;
     paging?: PAGING | undefined;
     page_count?: unknown;
@@ -5687,7 +5688,6 @@ declare const UserQuerySchema: z.ZodObject<{
     }[] | undefined;
     include_master_data?: YesNo | undefined;
     organisation_ids?: string[] | undefined;
-    user_ids?: string[] | undefined;
     country_ids?: string[] | undefined;
     can_login?: YesNo[] | undefined;
     user_role_ids?: string[] | undefined;