vms-nest-api-document 1.0.0

package/dist/services/main/vehicle/master_vehicle_service.js

@@ -0,0 +1,1367 @@
+// src/core/sdk-config.ts
+var KEY = "__vms_axios_instance__";
+var getAxiosInstance = () => {
+  const instance = globalThis[KEY];
+  if (!instance) {
+    throw new Error("\u274C Axios instance not configured. Call setAxiosInstance() first.");
+  }
+  return instance;
+};
+
+// src/core/apiCall.ts
+var apiGet = async (url, params) => {
+  const response = await getAxiosInstance().get(url, { params });
+  return response.data;
+};
+var apiPost = async (url, data) => {
+  const response = await getAxiosInstance().post(url, data);
+  return response.data;
+};
+var apiPatch = async (url, data) => {
+  const response = await getAxiosInstance().patch(url, data);
+  return response.data;
+};
+var apiDelete = async (url) => {
+  const response = await getAxiosInstance().delete(url);
+  return response.data;
+};
+
+// src/services/main/vehicle/master_vehicle_service.ts
+import { z as z3 } from "zod";
+
+// src/zod_utils/zod_utils.ts
+import { z } from "zod";
+
+// src/core/BaseResponse.ts
+var r_log = (data = {}) => {
+  return data;
+};
+
+// src/zod_utils/zod_utils.ts
+var handleNullOrUndefined = (value) => typeof value === "string" ? value : "";
+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);
+  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);
+  return schema;
+};
+var stringArrayOptional = (fieldName, min = 0, max = 100, defaultValue = [], unique = false) => {
+  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) {
+    schema.refine(
+      (arr) => new Set(arr).size === arr.length,
+      `${fieldName} must contain unique values.`
+    );
+  }
+  return schema.optional().default(defaultValue);
+};
+var numberOptional = (fieldName, min = 0, max = 1e14, defaultValue = 0) => {
+  return 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)
+  );
+};
+var doubleOptional = (fieldName, min = 0, max = 1e6, decimalPlaces = 2, defaultValue = 0) => {
+  return z.preprocess(
+    (val) => {
+      if (typeof val === "string") {
+        val = parseFloat(val);
+      }
+      if (typeof val === "number") {
+        return parseFloat(val.toFixed(decimalPlaces));
+      }
+      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)
+  ).optional();
+};
+var doubleOptionalAmount = (fieldName, defaultValue = 0) => {
+  return z.preprocess((val) => {
+    if (typeof val === "string") {
+      val = parseFloat(val);
+    }
+    if (typeof val === "number") {
+      return parseFloat(val.toFixed(6));
+    }
+    return val;
+  }, z.number({ invalid_type_error: `${fieldName} must be a number.` }).default(defaultValue)).optional();
+};
+var enumMandatory = (fieldName, enumType, defaultValue) => {
+  return z.union([
+    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), {
+      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 z.nativeEnum(enumType, {
+    invalid_type_error: `${fieldName} must be an array containing only the following values: ${Object.values(
+      enumType
+    ).join(", ")}.`
+  }).optional().default(() => defaultValue);
+};
+var getAllEnums = (enumType) => {
+  return Object.values(enumType);
+};
+var enumArrayOptional = (fieldName, enumType, defaultValue = getAllEnums(enumType), min = 0, max = 100, unique = false) => {
+  const schema = z.array(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 dateOptional = (fieldName, minDate, maxDate) => {
+  const base = z.string();
+  const refinements = [
+    {
+      check: (val) => !val.trim() || !isNaN(Date.parse(val)),
+      message: `${fieldName} must be a valid ISO date.`
+    }
+  ];
+  if (minDate) {
+    refinements.push({
+      check: (val) => !val.trim() || new Date(val) >= new Date(minDate),
+      message: `${fieldName} must be after ${minDate}.`
+    });
+  }
+  if (maxDate) {
+    refinements.push({
+      check: (val) => !val.trim() || new Date(val) <= new Date(maxDate),
+      message: `${fieldName} must be before ${maxDate}.`
+    });
+  }
+  let refined = base;
+  for (const { check, message } of refinements) {
+    refined = refined.refine(check, { message });
+  }
+  return refined.optional().default("");
+};
+var dynamicJsonSchema = (fieldName, defaultValue = {}) => z.record(z.any()).optional().default(() => defaultValue);
+var nestedArrayOfObjectsOptional = (fieldName, schema, defaultValue = [], min = 0, max) => {
+  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) {
+    arraySchema = arraySchema.max(
+      max,
+      `${fieldName} must contain at most ${max} items.`
+    );
+  }
+  return arraySchema.optional().default(() => defaultValue);
+};
+var single_select_mandatory = (fieldName) => {
+  const schema = 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);
+  return schema;
+};
+var multi_select_optional = (fieldName, max = 1e3, defaultValue = []) => {
+  const schema = z.array(
+    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);
+};
+
+// src/zod_utils/zod_base_schema.ts
+import { z as z2 } from "zod";
+
+// src/core/Enums.ts
+var PAGING = /* @__PURE__ */ ((PAGING2) => {
+  PAGING2["Yes"] = "Yes";
+  PAGING2["No"] = "No";
+  return PAGING2;
+})(PAGING || {});
+var LoadParents = /* @__PURE__ */ ((LoadParents2) => {
+  LoadParents2["Yes"] = "Yes";
+  LoadParents2["No"] = "No";
+  LoadParents2["Custom"] = "Custom";
+  return LoadParents2;
+})(LoadParents || {});
+var LoadChild = /* @__PURE__ */ ((LoadChild2) => {
+  LoadChild2["No"] = "No";
+  LoadChild2["Yes"] = "Yes";
+  LoadChild2["Count"] = "Count";
+  LoadChild2["Custom"] = "Custom";
+  LoadChild2["Direct"] = "Direct";
+  return LoadChild2;
+})(LoadChild || {});
+var LoadChildCount = /* @__PURE__ */ ((LoadChildCount2) => {
+  LoadChildCount2["No"] = "No";
+  LoadChildCount2["Yes"] = "Yes";
+  LoadChildCount2["Custom"] = "Custom";
+  return LoadChildCount2;
+})(LoadChildCount || {});
+var OrderBy = /* @__PURE__ */ ((OrderBy2) => {
+  OrderBy2["asc"] = "asc";
+  OrderBy2["desc"] = "desc";
+  return OrderBy2;
+})(OrderBy || {});
+var LoginFrom = /* @__PURE__ */ ((LoginFrom2) => {
+  LoginFrom2["Web"] = "Web";
+  LoginFrom2["Android"] = "Android";
+  LoginFrom2["IPhone"] = "IPhone";
+  LoginFrom2["AndroidPWA"] = "AndroidPWA";
+  LoginFrom2["iOSPWA"] = "iOSPWA";
+  return LoginFrom2;
+})(LoginFrom || {});
+var Status = /* @__PURE__ */ ((Status2) => {
+  Status2["Active"] = "Active";
+  Status2["Inactive"] = "Inactive";
+  return Status2;
+})(Status || {});
+var LifeExpiry = /* @__PURE__ */ ((LifeExpiry2) => {
+  LifeExpiry2["No"] = "No";
+  LifeExpiry2["Expiring"] = "Expiring";
+  LifeExpiry2["Expired"] = "Expired";
+  return LifeExpiry2;
+})(LifeExpiry || {});
+var PurchaseVehicleType = /* @__PURE__ */ ((PurchaseVehicleType2) => {
+  PurchaseVehicleType2["New"] = "New";
+  PurchaseVehicleType2["Used"] = "Used";
+  return PurchaseVehicleType2;
+})(PurchaseVehicleType || {});
+var PurchaseType = /* @__PURE__ */ ((PurchaseType2) => {
+  PurchaseType2["Loan"] = "Loan";
+  PurchaseType2["Lease"] = "Lease";
+  PurchaseType2["NoFinance"] = "NoFinance";
+  return PurchaseType2;
+})(PurchaseType || {});
+var FileType = /* @__PURE__ */ ((FileType2) => {
+  FileType2["NoFile"] = "NoFile";
+  FileType2["Image"] = "Image";
+  FileType2["Video"] = "Video";
+  FileType2["PDF"] = "PDF";
+  FileType2["Excel"] = "Excel";
+  return FileType2;
+})(FileType || {});
+var YesNo = /* @__PURE__ */ ((YesNo2) => {
+  YesNo2["Yes"] = "Yes";
+  YesNo2["No"] = "No";
+  return YesNo2;
+})(YesNo || {});
+var FuelTankType = /* @__PURE__ */ ((FuelTankType2) => {
+  FuelTankType2["SingleTank"] = "SingleTank";
+  FuelTankType2["DualTank"] = "DualTank";
+  return FuelTankType2;
+})(FuelTankType || {});
+var GPSVehicleCategory = /* @__PURE__ */ ((GPSVehicleCategory2) => {
+  GPSVehicleCategory2["ALL"] = "ALL";
+  GPSVehicleCategory2["Moving"] = "Moving";
+  GPSVehicleCategory2["Stopped"] = "Stopped";
+  GPSVehicleCategory2["AwaitingGPS"] = "AwaitingGPS";
+  return GPSVehicleCategory2;
+})(GPSVehicleCategory || {});
+var SteeringType = /* @__PURE__ */ ((SteeringType2) => {
+  SteeringType2["Manual"] = "Manual";
+  SteeringType2["Power"] = "Power";
+  SteeringType2["Electric"] = "Electric";
+  SteeringType2["Hydraulic"] = "Hydraulic";
+  return SteeringType2;
+})(SteeringType || {});
+var WheelDriveType = /* @__PURE__ */ ((WheelDriveType2) => {
+  WheelDriveType2["FWD"] = "FWD";
+  WheelDriveType2["RWD"] = "RWD";
+  WheelDriveType2["AWD"] = "AWD";
+  WheelDriveType2["FourWD"] = "FourWD";
+  WheelDriveType2["TwoWD"] = "TwoWD";
+  WheelDriveType2["SixWD"] = "SixWD";
+  WheelDriveType2["EightWD"] = "EightWD";
+  WheelDriveType2["EAWD"] = "EAWD";
+  WheelDriveType2["SelectableFourWD"] = "SelectableFourWD";
+  return WheelDriveType2;
+})(WheelDriveType || {});
+var VehicleLifeStatus = /* @__PURE__ */ ((VehicleLifeStatus2) => {
+  VehicleLifeStatus2["Active"] = "Active";
+  VehicleLifeStatus2["Retired"] = "Retired";
+  VehicleLifeStatus2["Scrapped"] = "Scrapped";
+  VehicleLifeStatus2["Reassigned"] = "Reassigned";
+  VehicleLifeStatus2["Sold"] = "Sold";
+  VehicleLifeStatus2["Inactive"] = "Inactive";
+  return VehicleLifeStatus2;
+})(VehicleLifeStatus || {});
+var LoanInterestType = /* @__PURE__ */ ((LoanInterestType2) => {
+  LoanInterestType2["Simple"] = "Simple";
+  LoanInterestType2["Compound"] = "Compound";
+  LoanInterestType2["Reducing"] = "Reducing";
+  return LoanInterestType2;
+})(LoanInterestType || {});
+
+// src/zod_utils/zod_base_schema.ts
+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 BaseFileSchema = z2.object({
+  usage_type: stringMandatory("Usage Type", 3, 100),
+  file_type: enumMandatory("File Type", FileType, "Image" /* Image */),
+  file_url: stringOptional("File URL", 0, 300),
+  file_key: stringOptional("File Key", 0, 300),
+  file_name: stringOptional("File Name", 0, 300),
+  file_description: stringOptional("File Description", 0, 2e3),
+  file_size: numberOptional("File Size"),
+  file_metadata: dynamicJsonSchema("File Metadata", {}),
+  status: enumMandatory("Status", Status, "Active" /* Active */)
+});
+var BaseQuerySchema = z2.object({
+  search: stringOptional("Search", 0, 255, ""),
+  status: enumArrayOptional("Status", Status, getAllEnums(Status), 0, 10, true),
+  paging: enumOptional("Paging", PAGING, "Yes" /* Yes */),
+  page_count: numberOptional("Page Count", 0, 1e3, 100),
+  page_index: numberOptional("Page Index", 0, 1e3, 0),
+  load_parents: enumOptional("Load Parents", LoadParents, "No" /* No */),
+  load_parents_list: stringArrayOptional("Load Parents List"),
+  load_child: enumOptional("Load Child", LoadChild, "No" /* No */),
+  load_child_list: stringArrayOptional("Load Child List"),
+  load_child_count: enumOptional(
+    "Load Child",
+    LoadChildCount,
+    "No" /* No */
+  ),
+  load_child_count_list: stringArrayOptional("Load Child List"),
+  include_details: dynamicJsonSchema("Include Details", {}),
+  where_relations: dynamicJsonSchema("Where Relations", {}),
+  order_by: OrderBySchema.optional().default([]),
+  include_master_data: enumOptional("Include Master Data", YesNo, "No" /* No */),
+  date_format_id: single_select_optional("MasterMainDateFormat"),
+  time_zone_id: single_select_optional("MasterMainTimeZone")
+});
+var FilePresignedUrlSchema = z2.object({
+  file_name: stringMandatory("File Name", 1, 255),
+  file_type: enumMandatory("File Type", FileType, "Image" /* Image */)
+});
+var MongoBaseQuerySchema = z2.object({
+  search: stringOptional("Search", 0, 255, ""),
+  paging: enumOptional("Paging", PAGING, "Yes" /* Yes */),
+  page_count: numberOptional("Page Count", 0, 1e3, 100),
+  page_index: numberOptional("Page Index", 0, 1e3, 0),
+  login_from: enumMandatory("Login From", LoginFrom, "Web" /* Web */),
+  date_format_id: single_select_optional("MasterMainDateFormat"),
+  // ✅ Single-selection -> MasterMainDateFormat
+  time_zone_id: single_select_optional("MasterMainTimeZone")
+  // ✅ Single-selection -> MasterMainTimeZone
+});
+
+// src/services/main/vehicle/master_vehicle_service.ts
+var URL = "main/master_vehicle";
+var ENDPOINTS = {
+  // AWS S3 PRESIGNED
+  vehicle_file_presigned_url: `${URL}/vehicle_file_presigned_url`,
+  device_file_presigned_url: `${URL}/device_file_presigned_url`,
+  calibration_file_presigned_url: (fileName) => `${URL}/calibration_file_presigned_url/${fileName}`,
+  // File Uploads
+  create_vehicle_file: `${URL}/create_vehicle_file`,
+  remove_vehicle_file: (id) => `${URL}/remove_vehicle_file/${id}`,
+  create_device_file: `${URL}/create_device_file`,
+  remove_device_file: (id) => `${URL}/remove_device_file/${id}`,
+  update_calibration_file: (id) => `${URL}/update_calibration_file/${id}`,
+  remove_calibration_file: (id) => `${URL}/remove_calibration_file/${id}`,
+  // MasterVehicle APIs
+  find: `${URL}/search`,
+  find_no_gps_data_vehicles: `${URL}/no_gps_data_vehicles`,
+  find_live_dashboard: `${URL}/live_dashboard/search`,
+  find_gps_details: `${URL}/gps_details/search`,
+  create: `${URL}`,
+  update: (id) => `${URL}/${id}`,
+  delete: (id) => `${URL}/${id}`,
+  // API Updates
+  update_details_gps_sensor: (id) => `${URL}/gps_sensor_details/${id}`,
+  update_details_trip: (id) => `${URL}/trip_details/${id}`,
+  update_details_body: (id) => `${URL}/body_details/${id}`,
+  update_details_life_cycle: (id) => `${URL}/life_cycle_details/${id}`,
+  update_details_purchase: (id) => `${URL}/purchase_details/${id}`,
+  // API Vehicle Driver Link
+  vehicle_driver_link: `${URL}/vehicle_driver_link`,
+  vehicle_driver_unlink: `${URL}/vehicle_driver_unlink`,
+  find_vehicle_driver_link_history_by_vehicle: (id) => `${URL}/vehicle_driver_link_history_by_vehicle/${id}`,
+  find_vehicle_driver_link_history_by_driver: (id) => `${URL}/vehicle_driver_link_history_by_driver/${id}`,
+  // API Vehicle Device Link
+  vehicle_device_link: `${URL}/vehicle_device_link`,
+  vehicle_device_unlink: `${URL}/vehicle_device_unlink`,
+  vehicle_device_link_history_by_vehicle: (id) => `${URL}/vehicle_device_link_history_by_vehicle/${id}`,
+  vehicle_device_link_history_by_device: (id) => `${URL}/vehicle_device_link_history_by_device/${id}`,
+  // Cache APIs
+  find_cache: `${URL}/cache/:organisation_id`,
+  find_cache_simple: `${URL}/cache_simple/:organisation_id`,
+  find_cache_parent: `${URL}/cache_parent/:organisation_id`,
+  find_cache_dropdown: `${URL}/cache_dropdown/:organisation_id`,
+  find_cache_dropdown_live_data: `${URL}/cache_dropdown_live_data/:organisation_id`
+};
+var MasterVehicleFileSchema = BaseFileSchema.extend({
+  organisation_id: single_select_optional("UserOrganisation"),
+  // Single-Selection -> UserOrganisation
+  user_id: single_select_optional("User"),
+  // Single-Selection -> User
+  vehicle_id: single_select_optional("MasterVehicle")
+  // Single-Selection -> MasterVehicle
+});
+var CalibrationFileSchema = z3.object({
+  // Profile Image/Logo
+  calibration_file_url: stringOptional("Calibration File URL", 0, 300),
+  calibration_file_key: stringOptional("Calibration File Key", 0, 300),
+  calibration_file_name: stringOptional("Calibration File Name", 0, 300)
+});
+var VehicleSchema = z3.object({
+  // Relations - Parent
+  organisation_id: single_select_mandatory("UserOrganisation"),
+  // Single-Selection -> UserOrganisation
+  user_id: single_select_optional("User"),
+  // Single-Selection -> User
+  organisation_sub_company_id: single_select_optional(
+    "Organisation Sub Company ID"
+  ),
+  // Single-Selection -> OrganisationSubCompany
+  organisation_branch_id: single_select_optional("OrganisationBranch"),
+  // Single-Selection -> OrganisationBranch
+  organisation_tag_id: single_select_optional("OrganisationTag"),
+  // Single-Selection -> OrganisationTag
+  organisation_color_id: single_select_optional("OrganisationColor"),
+  // Single-Selection -> OrganisationColor
+  organisation_group_ids: multi_select_optional("OrganisationGroup"),
+  // Multi selection -> OrganisationGroup
+  vehicle_type_id: single_select_mandatory("MasterVehicleType"),
+  // Single-Selection -> MasterVehicleType
+  vehicle_make_id: single_select_optional("MasterVehicleMake"),
+  // Single-Selection -> MasterVehicleMake
+  vehicle_model_id: single_select_optional("MasterVehicleModel"),
+  // Single-Selection -> MasterVehicleModel
+  vehicle_sub_model_id: single_select_optional("MasterVehicleSubModel"),
+  // Single-Selection -> MasterVehicleSubModel
+  vehicle_status_type_id: single_select_optional("MasterVehicleStatusType"),
+  // Single-Selection -> MasterVehicleStatusType
+  vehicle_ownership_type_id: single_select_optional(
+    "MasterVehicleOwnershipType"
+  ),
+  // Single-Selection -> MasterVehicleOwnershipType
+  vehicle_associated_to_id: single_select_optional("MasterVehicleAssociatedTo"),
+  // Single-Selection -> MasterVehicleAssociatedTo
+  // Fuel
+  vehicle_fuel_type_id: single_select_optional("MasterVehicleFuelType"),
+  // Single-Selection -> MasterVehicleFuelType
+  vehicle_fuel_unit_id: single_select_optional("MasterVehicleFuelUnit"),
+  // Single-Selection -> MasterVehicleFuelUnit
+  secondary_vehicle_fuel_type_id: single_select_optional(
+    "Vehicle Secondary Fuel Type ID"
+  ),
+  // Single-Selection -> MasterVehicleFuelType
+  secondary_vehicle_fuel_unit_id: single_select_optional(
+    "Vehicle Secondary Fuel Unit ID"
+  ),
+  // Single-Selection -> MasterVehicleFuelUnit
+  fuel_tank_type: enumOptional(
+    "Fuel Tank Type",
+    FuelTankType,
+    "SingleTank" /* SingleTank */
+  ),
+  fuel_tank_size: numberOptional("Fuel Tank Quantity"),
+  fuel_tank_1_size: numberOptional("Tank 1 Fuel Quantity"),
+  fuel_tank_2_size: numberOptional("Tank 2 Fuel Quantity"),
+  fuel_tank_total_size: numberOptional("Fuel Tank Full Quantity"),
+  // Main Field Details
+  vehicle_number: stringMandatory("Vehicle Number", 2, 50),
+  vehicle_name: stringOptional("Vehicle Name", 0, 50),
+  odometer_reading: numberOptional("Odometer Reading"),
+  engine_number: stringOptional("Engine Number", 0, 20),
+  chassis_number: stringOptional("Chassis Number", 0, 20),
+  vehicle_make_year: numberOptional("Vehicle Make Year"),
+  is_fleet_active: enumMandatory("Is Fleet Active", YesNo, "Yes" /* Yes */),
+  is_gps_active: enumMandatory("Is GPS Active", YesNo, "No" /* No */),
+  is_trip_active: enumMandatory("Is Trip Active", YesNo, "No" /* No */),
+  // Bus Seats
+  vehicle_passenger_capacity: numberOptional("Vehicle Passenger Capacity"),
+  standing_passenger_capacity: numberOptional("Standing Passenger Capacity"),
+  // Metadata
+  status: enumMandatory("Status", Status, "Active" /* Active */),
+  // Additional Files
+  MasterVehicleFileSchema: nestedArrayOfObjectsOptional(
+    "MasterVehicleFileSchema",
+    MasterVehicleFileSchema,
+    []
+  )
+});
+var VehicleBulkSchema = z3.object({
+  // Relations - Parent
+  organisation_id: single_select_mandatory("UserOrganisation"),
+  // Single-Selection -> UserOrganisation
+  vehicle_type_id: single_select_mandatory("MasterVehicleType"),
+  // Single-Selection -> MasterVehicleType
+  device_manufacturer_id: single_select_optional("MasterDeviceManufacturer"),
+  // Single-Selection -> MasterDeviceManufacturer
+  device_model_id: single_select_optional("MasterDeviceModel"),
+  // Single-Selection -> MasterDeviceModel
+  device_type_id: single_select_optional("MasterDeviceType"),
+  // Single-Selection -> MasterDeviceType
+  country_id: single_select_optional("MasterMainCountry"),
+  // Single-Selection -> MasterMainCountry
+  time_zone_id: single_select_optional("MasterMainTimeZone"),
+  // Single-Selection -> MasterMainTimeZone
+  fuel_tank_type: enumOptional(
+    "Fuel Tank Type",
+    FuelTankType,
+    "SingleTank" /* SingleTank */
+  ),
+  fuel_tank_size: numberOptional("Fuel Tank Quantity"),
+  fuel_tank_1_size: numberOptional("Tank 1 Fuel Quantity"),
+  fuel_tank_2_size: numberOptional("Tank 2 Fuel Quantity"),
+  fuel_tank_total_size: numberOptional("Fuel Tank Full Quantity"),
+  // Main Field Details
+  vehicle_number: stringMandatory("Vehicle Number", 2, 50),
+  vehicle_name: stringOptional("Vehicle Name", 0, 50),
+  odometer_reading: numberOptional("Odometer Reading"),
+  engine_number: stringOptional("Engine Number", 0, 20),
+  chassis_number: stringOptional("Chassis Number", 0, 20),
+  vehicle_make_year: numberOptional("Vehicle Make Year"),
+  is_fleet_active: enumMandatory("Is Fleet Active", YesNo, "Yes" /* Yes */),
+  is_gps_active: enumMandatory("Is GPS Active", YesNo, "No" /* No */),
+  is_trip_active: enumMandatory("Is Trip Active", YesNo, "No" /* No */),
+  // Bus Seats
+  vehicle_passenger_capacity: numberOptional("Vehicle Passenger Capacity"),
+  standing_passenger_capacity: numberOptional("Standing Passenger Capacity"),
+  // Metadata
+  status: enumMandatory("Status", Status, "Active" /* Active */)
+});
+var MasterDeviceFileSchema = BaseFileSchema.extend({
+  organisation_id: single_select_optional("UserOrganisation"),
+  // Single-Selection -> UserOrganisation
+  user_id: single_select_optional("User"),
+  // Single-Selection -> User
+  device_id: single_select_optional("MasterDevice")
+  // Single-Selection -> MasterDevice
+});
+var VehicleDeviceLinkSchema = z3.object({
+  // Relations - Parent
+  device_id: single_select_mandatory("MasterDevice"),
+  // Single-Selection -> MasterDevice
+  device_manufacturer_id: single_select_mandatory("MasterDeviceManufacturer"),
+  // Single-Selection -> MasterDeviceManufacturer
+  device_model_id: single_select_mandatory("MasterDeviceModel"),
+  // Single-Selection -> MasterDeviceModel
+  device_type_id: single_select_mandatory("MasterDeviceType"),
+  // Single-Selection -> MasterDeviceType
+  organisation_id: single_select_mandatory("UserOrganisation"),
+  // Single-Selection -> UserOrganisation
+  user_id: single_select_optional("User"),
+  // Single-Selection -> User
+  country_id: single_select_mandatory("MasterMainCountry"),
+  // Single-Selection -> MasterMainCountry
+  time_zone_id: single_select_mandatory("MasterMainTimeZone"),
+  // Single-Selection -> MasterMainTimeZone
+  vehicle_id: single_select_mandatory("MasterVehicle"),
+  // Single-Selection -> MasterVehicle
+  // Main Field Details
+  temperature: enumOptional("Temperature", YesNo, "No" /* No */),
+  duel_temperature: enumOptional("Dual Temperature", YesNo, "No" /* No */),
+  fuel: enumOptional("Fuel", YesNo, "No" /* No */),
+  fuel_bluetooth: enumOptional("Fuel Bluetooth", YesNo, "No" /* No */),
+  fuel_tank_type: enumOptional(
+    "Fuel Tank Type",
+    FuelTankType,
+    "SingleTank" /* SingleTank */
+  ),
+  fuel_tank_size: numberOptional("Fuel Tank Quantity"),
+  fuel_tank_1_size: numberOptional("Tank 1 Fuel Quantity"),
+  fuel_tank_2_size: numberOptional("Tank 2 Fuel Quantity"),
+  fuel_tank_total_size: numberOptional("Fuel Tank Full Quantity"),
+  over_speed_kmph: numberOptional("Over Speed KMPH"),
+  is_obd: enumOptional("Is OBD", YesNo, "No" /* No */),
+  gps_lock_relay: enumOptional("GPS Lock Relay", YesNo, "No" /* No */),
+  gps_door_locker: enumOptional("GPS Door Locker", YesNo, "No" /* No */),
+  door_sensor: enumOptional("Door Sensor", YesNo, "No" /* No */),
+  genset_sensor: enumOptional("Genset Sensor", YesNo, "No" /* No */),
+  dashcam_sensor: enumOptional("Dashcam Sensor", YesNo, "No" /* No */),
+  is_rear_cam: enumOptional("Is Rear Cam", YesNo, "No" /* No */),
+  is_front_cam: enumOptional("Is Front Cam", YesNo, "No" /* No */),
+  camera_extra_count: numberOptional("Camera Extra Count"),
+  fuel_mapping: dynamicJsonSchema("Fuel Mapping"),
+  // Profile Image/Logo
+  calibration_file_url: stringOptional("Calibration File URL", 0, 300),
+  calibration_file_key: stringOptional("Calibration File Key", 0, 300),
+  calibration_file_name: stringOptional("Calibration File Name", 0, 300),
+  // Metadata
+  MasterDeviceFileSchema: nestedArrayOfObjectsOptional(
+    "MasterDeviceFileSchema",
+    MasterDeviceFileSchema,
+    []
+  )
+});
+var VehicleDeviceUnlinkSchema = z3.object({
+  // Relations - Parent
+  organisation_id: single_select_mandatory("UserOrganisation"),
+  // Single-Selection -> UserOrganisation
+  vehicle_id: single_select_mandatory("MasterVehicle"),
+  // Single-Selection -> MasterVehicle
+  device_id: single_select_mandatory("MasterDevice")
+  // Single-Selection -> MasterDevice
+});
+var VehicleDriverLinkSchema = z3.object({
+  // Relations - Parent
+  organisation_id: single_select_mandatory("UserOrganisation"),
+  // Single-Selection -> UserOrganisation
+  vehicle_id: single_select_mandatory("MasterVehicle"),
+  // Single-Selection -> MasterVehicle
+  driver_id: single_select_mandatory("MasterDriver")
+  // Single-Selection -> MasterDriver
+});
+var VehicleDetailGPSSensorSchema = z3.object({
+  // Main Field Details
+  temperature: enumOptional("Temperature", YesNo, "No" /* No */),
+  duel_temperature: enumOptional("Dual Temperature", YesNo, "No" /* No */),
+  fuel: enumOptional("Fuel", YesNo, "No" /* No */),
+  fuel_bluetooth: enumOptional("Fuel Bluetooth", YesNo, "No" /* No */),
+  fuel_tank_type: enumOptional(
+    "Fuel Tank Type",
+    FuelTankType,
+    "SingleTank" /* SingleTank */
+  ),
+  fuel_tank_size: numberOptional("Fuel Tank Quantity"),
+  fuel_tank_1_size: numberOptional("Tank 1 Fuel Quantity"),
+  fuel_tank_2_size: numberOptional("Tank 2 Fuel Quantity"),
+  fuel_tank_total_size: numberOptional("Fuel Tank Full Quantity"),
+  over_speed_kmph: numberOptional("Over Speed KMPH"),
+  is_obd: enumOptional("Is OBD", YesNo, "No" /* No */),
+  gps_lock_relay: enumOptional("GPS Lock Relay", YesNo, "No" /* No */),
+  gps_door_locker: enumOptional("GPS Door Locker", YesNo, "No" /* No */),
+  door_sensor: enumOptional("Door Sensor", YesNo, "No" /* No */),
+  genset_sensor: enumOptional("Genset Sensor", YesNo, "No" /* No */),
+  dashcam_sensor: enumOptional("Dashcam Sensor", YesNo, "No" /* No */),
+  is_rear_cam: enumOptional("Is Rear Cam", YesNo, "No" /* No */),
+  is_front_cam: enumOptional("Is Front Cam", YesNo, "No" /* No */),
+  camera_extra_count: numberOptional("Camera Extra Count"),
+  fuel_mapping: dynamicJsonSchema("Fuel Mapping"),
+  // Profile Image/Logo
+  calibration_file_url: stringOptional("Calibration File URL", 0, 300),
+  calibration_file_key: stringOptional("Calibration File Key", 0, 300),
+  calibration_file_name: stringOptional("Calibration File Name", 0, 300)
+});
+var VehicleDetailTripSchema = z3.object({
+  // Main Field Details
+  trip_name: stringOptional("Trip Name", 0, 100),
+  trip_no: stringOptional("Trip No", 0, 100),
+  eway_bill_number: stringOptional("E-Way Bill Number", 0, 100),
+  route_name: stringOptional("Route Name", 0, 100),
+  trip_start_date: dateOptional("Trip Start Date"),
+  trip_end_date: dateOptional("Trip End Date"),
+  trip_notes_1: stringOptional("Trip Notes 1", 0, 200),
+  trip_notes_2: stringOptional("Trip Notes 2", 0, 200),
+  trip_notes_3: stringOptional("Trip Notes 3", 0, 200),
+  // Metadata
+  status: enumMandatory("Status", Status, "Active" /* Active */),
+  time_zone_id: single_select_mandatory("MasterMainTimeZone")
+});
+var VehicleDetailBodySchema = z3.object({
+  // 📦 Body & Dimension (Common)
+  vehicle_body_details: stringOptional("Vehicle Body Details", 0, 300),
+  vehicle_height: doubleOptional("Vehicle Height"),
+  vehicle_width: doubleOptional("Vehicle Width"),
+  vehicle_length: doubleOptional("Vehicle Length"),
+  wheel_base: doubleOptional("Wheel Base"),
+  number_of_doors: numberOptional("Number Of Doors"),
+  // Passenger Configuration (Cars/Buses)
+  vehicle_passenger_capacity: numberOptional("Vehicle Passenger Capacity"),
+  standing_passenger_capacity: numberOptional("Standing Passenger Capacity"),
+  seat_configuration: stringOptional("Seat Configuration", 0, 100),
+  has_air_conditioning: enumMandatory("Has Air Conditioning", YesNo, "No" /* No */),
+  has_heating_system: enumMandatory("Has Heating System", YesNo, "No" /* No */),
+  has_reclining_seats: enumMandatory("Has Reclining Seats", YesNo, "No" /* No */),
+  has_safety_belts: enumMandatory("Has Safety Belts", YesNo, "No" /* No */),
+  has_headrests: enumMandatory("Has Headrests", YesNo, "No" /* No */),
+  has_armrests: enumMandatory("Has Armrests", YesNo, "No" /* No */),
+  has_infotainment_system: enumMandatory(
+    "Has Infotainment System",
+    YesNo,
+    "No" /* No */
+  ),
+  infotainment_type: stringOptional("Infotainment Type", 0, 100),
+  has_individual_lighting: enumMandatory(
+    "Has Individual Lighting",
+    YesNo,
+    "No" /* No */
+  ),
+  has_overhead_luggage_storage: enumMandatory(
+    "Has Overhead Luggage Storage",
+    YesNo,
+    "No" /* No */
+  ),
+  wheelchair_accessible: enumMandatory(
+    "Wheelchair Accessible",
+    YesNo,
+    "No" /* No */
+  ),
+  // Cargo Configuration (Trucks/Vans)
+  vehicle_cargo_volume: doubleOptional("Vehicle Cargo Volume"),
+  vehicle_maximum_weight_capacity: doubleOptional(
+    "Vehicle Maximum Weight Capacity"
+  ),
+  cargo_area_type: stringOptional("Cargo Area Type", 0, 100),
+  has_lift_gate: enumMandatory("Has Lift Gate", YesNo, "No" /* No */),
+  has_refrigeration_unit: enumMandatory(
+    "Has Refrigeration Unit",
+    YesNo,
+    "No" /* No */
+  ),
+  refrigeration_temperature_range: stringOptional(
+    "Refrigeration Temperature Range",
+    0,
+    100
+  ),
+  cargo_bed_length: doubleOptional("Cargo Bed Length"),
+  cargo_bed_width: doubleOptional("Cargo Bed Width"),
+  cargo_bed_height: doubleOptional("Cargo Bed Height"),
+  cargo_floor_material: stringOptional("Cargo Floor Material", 0, 100),
+  has_side_doors: enumMandatory("Has Side Doors", YesNo, "No" /* No */),
+  has_roof_hatch: enumMandatory("Has Roof Hatch", YesNo, "No" /* No */),
+  cargo_tie_down_hooks_count: numberOptional("Cargo Tie Down Hooks Count"),
+  is_custom_body_built: enumMandatory("Is Custom Body Built", YesNo, "No" /* No */),
+  number_of_axles: numberOptional("Number Of Axles"),
+  axle_configuration: stringOptional("Axle Configuration", 0, 50),
+  has_dual_rear_wheels: enumMandatory("Has Dual Rear Wheels", YesNo, "No" /* No */),
+  suspension_type: stringOptional("Suspension Type", 0, 100),
+  suspension_adjustability: enumMandatory(
+    "Suspension Adjustability",
+    YesNo,
+    "No" /* No */
+  ),
+  ground_clearance_mm: doubleOptional("Ground Clearance MM"),
+  tire_size: stringOptional("Tire Size", 0, 50),
+  has_spare_tire: enumMandatory("Has Spare Tire", YesNo, "Yes" /* Yes */),
+  has_all_terrain_tires: enumMandatory(
+    "Has All Terrain Tires",
+    YesNo,
+    "No" /* No */
+  ),
+  has_run_flat_tires: enumMandatory("Has Run Flat Tires", YesNo, "No" /* No */),
+  steering_type: enumMandatory(
+    "Steering Type",
+    SteeringType,
+    "Power" /* Power */
+  ),
+  wheel_drive_type: enumMandatory(
+    "Wheel Drive Type",
+    WheelDriveType,
+    "FWD" /* FWD */
+  ),
+  // 🛡️ Safety Features
+  has_abs: enumMandatory("Has ABS", YesNo, "No" /* No */),
+  has_airbags: enumMandatory("Has Airbags", YesNo, "No" /* No */),
+  has_speed_limiter: enumMandatory("Has Speed Limiter", YesNo, "No" /* No */),
+  has_gps_tracker: enumMandatory("Has GPS Tracker", YesNo, "No" /* No */),
+  has_parking_sensors: enumMandatory("Has Parking Sensors", YesNo, "No" /* No */),
+  has_rear_camera: enumMandatory("Has Rear Camera", YesNo, "No" /* No */),
+  has_lane_assist: enumMandatory("Has Lane Assist", YesNo, "No" /* No */),
+  has_automatic_emergency_brake: enumMandatory(
+    "Has Automatic Emergency Brake",
+    YesNo,
+    "No" /* No */
+  ),
+  has_tire_pressure_monitoring: enumMandatory(
+    "Has Tire Pressure Monitoring",
+    YesNo,
+    "No" /* No */
+  ),
+  has_blind_spot_monitoring: enumMandatory(
+    "Has Blind Spot Monitoring",
+    YesNo,
+    "No" /* No */
+  ),
+  has_collision_warning_system: enumMandatory(
+    "Has Collision Warning System",
+    YesNo,
+    "No" /* No */
+  ),
+  has_immobilizer: enumMandatory("Has Immobilizer", YesNo, "No" /* No */),
+  has_dashcam: enumMandatory("Has DashCam", YesNo, "No" /* No */),
+  has_emergency_exit: enumMandatory("Has Emergency Exit", YesNo, "No" /* No */),
+  status: enumMandatory("Status", Status, "Active" /* Active */)
+});
+var VehicleDetailLifeCycleSchema = z3.object({
+  // Lifecycle Start
+  service_start_date: dateOptional("Service Start Date"),
+  service_start_odometer_reading: numberOptional(
+    "Service Start Odometer Reading"
+  ),
+  // Lifecycle End
+  service_end_date: dateOptional("Service End Date"),
+  service_end_odometer_reading: numberOptional("Service End Odometer Reading"),
+  // Estimated Life
+  life_estimate_max_month_year: dateOptional("Life Estimate Max Month/Year"),
+  life_estimate_max_odometer_reading: numberOptional(
+    "Life Estimate Max Odometer Reading"
+  ),
+  // Lifecycle Status
+  life_expiry: enumMandatory("Life Expiry", LifeExpiry, "No" /* No */),
+  is_extended_life_approved: enumMandatory(
+    "Is Extended Life Approved",
+    YesNo,
+    "No" /* No */
+  ),
+  life_status: enumMandatory(
+    "Life Status",
+    VehicleLifeStatus,
+    "Active" /* Active */
+  ),
+  life_expiry_message: stringOptional("Life Expiry Message", 0, 300),
+  life_expiry_note: stringOptional("Life Expiry Note", 0, 2e3),
+  status: enumMandatory("Status", Status, "Active" /* Active */),
+  time_zone_id: single_select_mandatory("MasterMainTimeZone")
+});
+var VehicleDetailPurchaseSchema = z3.object({
+  // Basic Purchase Info
+  purchase_date: dateOptional("Purchase Date"),
+  purchase_notes: stringOptional("Purchase Notes", 0, 300),
+  purchase_vehicle_type: enumMandatory(
+    "Purchase Vehicle Type",
+    PurchaseVehicleType,
+    "New" /* New */
+  ),
+  purchase_type: enumMandatory(
+    "Purchase Type",
+    PurchaseType,
+    "NoFinance" /* NoFinance */
+  ),
+  purchase_total_amount: doubleOptionalAmount("Purchase Total Amount", 2),
+  // Loan Details
+  loan_amount: doubleOptionalAmount("Loan Amount", 2),
+  loan_down_payment: doubleOptionalAmount("Loan Down Payment", 2),
+  loan_interest_rate: doubleOptionalAmount("Loan Interest Rate", 2),
+  loan_interest_type: enumOptional(
+    "Loan Interest Type",
+    LoanInterestType,
+    "Simple" /* Simple */
+  ),
+  loan_no_of_installments: numberOptional("Loan No of Installments"),
+  loan_first_payment_date: dateOptional("Loan First Payment Date"),
+  loan_last_payment_date: dateOptional("Loan Last Payment Date"),
+  loan_monthly_emi: doubleOptionalAmount("Loan Monthly EMI"),
+  loan_emi_date: numberOptional("Loan EMI Date"),
+  // Lease Details
+  lease_start_date: dateOptional("Lease Start Date"),
+  lease_end_date: dateOptional("Lease End Date"),
+  lease_security_deposit_amount: doubleOptionalAmount(
+    "Lease Security Deposit Amount",
+    2
+  ),
+  lease_monthly_emi_amount: doubleOptionalAmount("Lease Monthly EMI Amount", 2),
+  lease_emi_date: numberOptional("Lease EMI Date"),
+  // Warranty Info
+  warranty_expiration_date: dateOptional("Warranty Expiration Date"),
+  warranty_max_odometer_reading: numberOptional(
+    "Warranty Max Odometer Reading"
+  ),
+  warranty_exchange_date: dateOptional("Warranty Exchange Date"),
+  purchase_vendor_id: single_select_optional("Purchase Vendor ID"),
+  loan_vendor_id: single_select_optional("Loan Vendor ID"),
+  lease_vendor_id: single_select_optional("Lease Vendor ID"),
+  // Metadata
+  status: enumMandatory("Status", Status, "Active" /* Active */),
+  time_zone_id: single_select_mandatory("MasterMainTimeZone")
+});
+var VehicleQuerySchema = BaseQuerySchema.extend({
+  // Self Table
+  vehicle_ids: multi_select_optional("MasterVehicle"),
+  // Multi-Selection -> MasterVehicle
+  // Relations - Parent
+  organisation_ids: multi_select_optional("UserOrganisation"),
+  // Multi-Selection -> UserOrganisation
+  user_ids: multi_select_optional("User"),
+  // Multi-Selection -> User
+  driver_ids: multi_select_optional("MasterDriver"),
+  // Multi-Selection -> MasterDriver
+  device_ids: multi_select_optional("MasterDevice"),
+  // Multi-Selection -> MasterDevice
+  organisation_sub_company_ids: multi_select_optional("OrganisationSubCompany"),
+  // Multi-Selection -> OrganisationSubCompany
+  organisation_branch_ids: multi_select_optional("OrganisationBranch"),
+  // Multi-Selection -> OrganisationBranch
+  organisation_tag_ids: multi_select_optional("OrganisationTag"),
+  // Multi-Selection -> OrganisationTag
+  organisation_color_ids: multi_select_optional("OrganisationColor"),
+  // Multi-Selection -> OrganisationColor
+  vehicle_type_ids: multi_select_optional("MasterVehicleType"),
+  // Multi-Selection -> MasterVehicleType
+  vehicle_make_ids: multi_select_optional("MasterVehicleMake"),
+  // Multi-Selection -> MasterVehicleMake
+  vehicle_model_ids: multi_select_optional("MasterVehicleModel"),
+  // Multi-Selection -> MasterVehicleModel
+  vehicle_sub_model_ids: multi_select_optional("MasterVehicleSubModel"),
+  // Multi-Selection -> MasterVehicleSubModel
+  vehicle_status_type_ids: multi_select_optional("MasterVehicleStatusType"),
+  // Multi-Selection -> MasterVehicleStatusType
+  vehicle_ownership_type_ids: multi_select_optional(
+    "MasterVehicleOwnershipType"
+  ),
+  // Multi-Selection -> MasterVehicleOwnershipType
+  vehicle_associated_to_ids: multi_select_optional("MasterVehicleAssociatedTo"),
+  // Multi-Selection -> MasterVehicleAssociatedTo
+  vehicle_fuel_type_ids: multi_select_optional("MasterVehicleFuelType"),
+  // Multi-Selection -> MasterVehicleFuelType
+  vehicle_fuel_unit_ids: multi_select_optional("MasterVehicleFuelUnit"),
+  // Multi-Selection -> MasterVehicleFuelUnit
+  // Enums
+  is_device_installed: enumArrayOptional(
+    "Is Device Installed",
+    YesNo,
+    getAllEnums(YesNo)
+  ),
+  is_driver_assigned: enumArrayOptional(
+    "Is Driver Assigned",
+    YesNo,
+    getAllEnums(YesNo)
+  ),
+  gps_vehicle_category: enumOptional(
+    "GPS Vehicle Category",
+    GPSVehicleCategory,
+    "ALL" /* ALL */
+  )
+});
+var NoGPSDataVehiclesQuerySchema = BaseQuerySchema.extend({
+  selected_time_zone_id: single_select_mandatory("MasterMainTimeZone")
+  // Single-Selection -> MasterMainTimeZone
+});
+var VehicleGPSQuerySchema = BaseQuerySchema.extend({
+  organisation_id: single_select_mandatory("UserOrganisation"),
+  // Single-Selection -> UserOrganisation
+  vehicle_id: single_select_mandatory("MasterVehicle")
+  // Single-selection -> MasterVehicle
+});
+var toVehiclePayload = (row) => ({
+  organisation_id: row.organisation_id || "",
+  user_id: row.user_id || "",
+  vehicle_number: row.vehicle_number || "",
+  vehicle_name: row.vehicle_name || "",
+  engine_number: row.engine_number || "",
+  chassis_number: row.chassis_number || "",
+  vehicle_make_year: row.vehicle_make_year || 0,
+  is_fleet_active: row.is_fleet_active || "No" /* No */,
+  is_gps_active: row.is_gps_active || "No" /* No */,
+  is_trip_active: row.is_trip_active || "No" /* No */,
+  organisation_sub_company_id: row.organisation_sub_company_id || "",
+  organisation_branch_id: row.organisation_branch_id || "",
+  organisation_tag_id: row.organisation_tag_id || "",
+  organisation_color_id: row.organisation_color_id || "",
+  organisation_group_ids: row.VehicleOrganisationGroupLink?.map((v) => v.organisation_group_id) || [],
+  vehicle_type_id: row.vehicle_type_id || "",
+  vehicle_make_id: row.vehicle_make_id || "",
+  vehicle_model_id: row.vehicle_model_id || "",
+  vehicle_sub_model_id: row.vehicle_sub_model_id || "",
+  vehicle_status_type_id: row.vehicle_status_type_id || "",
+  vehicle_ownership_type_id: row.vehicle_ownership_type_id || "",
+  vehicle_associated_to_id: row.vehicle_associated_to_id || "",
+  vehicle_fuel_type_id: row.vehicle_fuel_type_id || "",
+  vehicle_fuel_unit_id: row.vehicle_fuel_unit_id || "",
+  secondary_vehicle_fuel_type_id: row.secondary_vehicle_fuel_type_id || "",
+  secondary_vehicle_fuel_unit_id: row.secondary_vehicle_fuel_unit_id || "",
+  odometer_reading: row.odometer_reading || 0,
+  fuel_tank_type: row.fuel_tank_type || "SingleTank" /* SingleTank */,
+  fuel_tank_size: row.fuel_tank_size || 0,
+  fuel_tank_1_size: row.fuel_tank_1_size || 0,
+  fuel_tank_2_size: row.fuel_tank_2_size || 0,
+  fuel_tank_total_size: row.fuel_tank_total_size || 0,
+  vehicle_passenger_capacity: row.vehicle_passenger_capacity || 0,
+  standing_passenger_capacity: row.standing_passenger_capacity || 0,
+  status: row.status || "Active" /* Active */,
+  MasterVehicleFileSchema: row.MasterVehicleFile?.map((file) => ({
+    vehicle_file_id: file.vehicle_file_id || "",
+    usage_type: file.usage_type,
+    file_type: file.file_type,
+    file_url: file.file_url || "",
+    file_key: file.file_key || "",
+    file_name: file.file_name || "",
+    file_description: file.file_description || "",
+    file_size: file.file_size || 0,
+    file_metadata: file.file_metadata || {},
+    status: file.status,
+    added_date_time: file.added_date_time,
+    modified_date_time: file.modified_date_time,
+    organisation_id: file.organisation_id ?? "",
+    user_id: file.user_id ?? "",
+    vehicle_id: file.vehicle_id ?? ""
+  })) ?? []
+});
+var newVehiclePayload = () => ({
+  organisation_id: "",
+  user_id: "",
+  vehicle_number: "",
+  vehicle_name: "",
+  engine_number: "",
+  chassis_number: "",
+  vehicle_make_year: 0,
+  is_fleet_active: "No" /* No */,
+  is_gps_active: "No" /* No */,
+  is_trip_active: "No" /* No */,
+  organisation_sub_company_id: "",
+  organisation_branch_id: "",
+  organisation_tag_id: "",
+  organisation_color_id: "",
+  organisation_group_ids: [],
+  vehicle_type_id: "",
+  vehicle_make_id: "",
+  vehicle_model_id: "",
+  vehicle_sub_model_id: "",
+  vehicle_status_type_id: "",
+  vehicle_ownership_type_id: "",
+  vehicle_associated_to_id: "",
+  vehicle_fuel_type_id: "",
+  vehicle_fuel_unit_id: "",
+  secondary_vehicle_fuel_type_id: "",
+  secondary_vehicle_fuel_unit_id: "",
+  odometer_reading: 0,
+  fuel_tank_type: "SingleTank" /* SingleTank */,
+  fuel_tank_size: 0,
+  fuel_tank_1_size: 0,
+  fuel_tank_2_size: 0,
+  fuel_tank_total_size: 0,
+  vehicle_passenger_capacity: 0,
+  standing_passenger_capacity: 0,
+  status: "Active" /* Active */,
+  MasterVehicleFileSchema: []
+});
+var toVehicleDetailsGPSPayload = (vehicleGPS) => ({
+  temperature: vehicleGPS?.temperature || "No" /* No */,
+  duel_temperature: vehicleGPS?.duel_temperature || "No" /* No */,
+  fuel: vehicleGPS?.fuel || "No" /* No */,
+  fuel_bluetooth: vehicleGPS?.fuel_bluetooth || "No" /* No */,
+  fuel_tank_type: vehicleGPS?.fuel_tank_type || "SingleTank" /* SingleTank */,
+  fuel_tank_size: vehicleGPS?.fuel_tank_size || 0,
+  fuel_tank_1_size: vehicleGPS?.fuel_tank_1_size || 0,
+  fuel_tank_2_size: vehicleGPS?.fuel_tank_2_size || 0,
+  fuel_tank_total_size: vehicleGPS?.fuel_tank_total_size || 0,
+  over_speed_kmph: vehicleGPS?.over_speed_kmph || 0,
+  is_obd: vehicleGPS?.is_obd || "No" /* No */,
+  gps_lock_relay: vehicleGPS?.gps_lock_relay || "No" /* No */,
+  gps_door_locker: vehicleGPS?.gps_door_locker || "No" /* No */,
+  door_sensor: vehicleGPS?.door_sensor || "No" /* No */,
+  genset_sensor: vehicleGPS?.genset_sensor || "No" /* No */,
+  dashcam_sensor: vehicleGPS?.dashcam_sensor || "No" /* No */,
+  is_rear_cam: vehicleGPS?.is_rear_cam || "No" /* No */,
+  is_front_cam: vehicleGPS?.is_front_cam || "No" /* No */,
+  camera_extra_count: vehicleGPS?.camera_extra_count || 0,
+  fuel_mapping: vehicleGPS?.fuel_mapping || {},
+  calibration_file_url: vehicleGPS?.calibration_file_url || "",
+  calibration_file_key: vehicleGPS?.calibration_file_key || "",
+  calibration_file_name: vehicleGPS?.calibration_file_name || ""
+});
+var toVehicleDetailsTripPayload = (trip) => ({
+  trip_name: trip?.trip_name || "",
+  trip_no: trip?.trip_no || "",
+  eway_bill_number: trip?.eway_bill_number || "",
+  route_name: trip?.route_name || "",
+  trip_start_date: trip?.trip_start_date || "",
+  trip_end_date: trip?.trip_end_date || "",
+  trip_notes_1: trip?.trip_notes_1 || "",
+  trip_notes_2: trip?.trip_notes_2 || "",
+  trip_notes_3: trip?.trip_notes_3 || "",
+  status: trip ? trip.status : "Active" /* Active */,
+  time_zone_id: ""
+});
+var toVehicleDetailsBodyPayload = (vehicleBody) => ({
+  // 📦 Body & Dimension (Common)
+  vehicle_body_details: vehicleBody?.vehicle_body_details || "",
+  vehicle_height: vehicleBody?.vehicle_height || 0,
+  vehicle_width: vehicleBody?.vehicle_width || 0,
+  vehicle_length: vehicleBody?.vehicle_length || 0,
+  wheel_base: vehicleBody?.wheel_base || 0,
+  number_of_doors: vehicleBody?.number_of_doors || 0,
+  // Passenger Configuration (Cars/Buses)
+  vehicle_passenger_capacity: vehicleBody?.vehicle_passenger_capacity || 0,
+  standing_passenger_capacity: vehicleBody?.standing_passenger_capacity || 0,
+  seat_configuration: vehicleBody?.seat_configuration || "",
+  has_air_conditioning: vehicleBody?.has_air_conditioning || "No" /* No */,
+  has_heating_system: vehicleBody?.has_heating_system || "No" /* No */,
+  has_reclining_seats: vehicleBody?.has_reclining_seats || "No" /* No */,
+  has_safety_belts: vehicleBody?.has_safety_belts || "No" /* No */,
+  has_headrests: vehicleBody?.has_headrests || "No" /* No */,
+  has_armrests: vehicleBody?.has_armrests || "No" /* No */,
+  has_infotainment_system: vehicleBody?.has_infotainment_system || "No" /* No */,
+  infotainment_type: vehicleBody?.infotainment_type || "",
+  has_individual_lighting: vehicleBody?.has_individual_lighting || "No" /* No */,
+  has_overhead_luggage_storage: vehicleBody?.has_overhead_luggage_storage || "No" /* No */,
+  wheelchair_accessible: vehicleBody?.wheelchair_accessible || "No" /* No */,
+  // Cargo Configuration (Trucks/Vans)
+  vehicle_cargo_volume: vehicleBody?.vehicle_cargo_volume || 0,
+  vehicle_maximum_weight_capacity: vehicleBody?.vehicle_maximum_weight_capacity || 0,
+  cargo_area_type: vehicleBody?.cargo_area_type || "",
+  has_lift_gate: vehicleBody?.has_lift_gate || "No" /* No */,
+  has_refrigeration_unit: vehicleBody?.has_refrigeration_unit || "No" /* No */,
+  refrigeration_temperature_range: vehicleBody?.refrigeration_temperature_range || "",
+  cargo_bed_length: vehicleBody?.cargo_bed_length || 0,
+  cargo_bed_width: vehicleBody?.cargo_bed_width || 0,
+  cargo_bed_height: vehicleBody?.cargo_bed_height || 0,
+  cargo_floor_material: vehicleBody?.cargo_floor_material || "",
+  has_side_doors: vehicleBody?.has_side_doors || "No" /* No */,
+  has_roof_hatch: vehicleBody?.has_roof_hatch || "No" /* No */,
+  cargo_tie_down_hooks_count: vehicleBody?.cargo_tie_down_hooks_count || 0,
+  is_custom_body_built: vehicleBody?.is_custom_body_built || "No" /* No */,
+  // 🛞 Wheel & Suspension
+  number_of_axles: vehicleBody?.number_of_axles || 0,
+  axle_configuration: vehicleBody?.axle_configuration || "",
+  has_dual_rear_wheels: vehicleBody?.has_dual_rear_wheels || "No" /* No */,
+  suspension_type: vehicleBody?.suspension_type || "",
+  suspension_adjustability: vehicleBody?.suspension_adjustability || "No" /* No */,
+  ground_clearance_mm: vehicleBody?.ground_clearance_mm || 0,
+  tire_size: vehicleBody?.tire_size || "",
+  has_spare_tire: vehicleBody?.has_spare_tire || "No" /* No */,
+  has_all_terrain_tires: vehicleBody?.has_all_terrain_tires || "No" /* No */,
+  has_run_flat_tires: vehicleBody?.has_run_flat_tires || "No" /* No */,
+  steering_type: vehicleBody?.steering_type || "Manual" /* Manual */,
+  wheel_drive_type: vehicleBody?.wheel_drive_type || "FWD" /* FWD */,
+  // 🛡️ Safety Features
+  has_abs: vehicleBody?.has_abs || "No" /* No */,
+  has_airbags: vehicleBody?.has_airbags || "No" /* No */,
+  has_speed_limiter: vehicleBody?.has_speed_limiter || "No" /* No */,
+  has_gps_tracker: vehicleBody?.has_gps_tracker || "No" /* No */,
+  has_parking_sensors: vehicleBody?.has_parking_sensors || "No" /* No */,
+  has_rear_camera: vehicleBody?.has_rear_camera || "No" /* No */,
+  has_lane_assist: vehicleBody?.has_lane_assist || "No" /* No */,
+  has_automatic_emergency_brake: vehicleBody?.has_automatic_emergency_brake || "No" /* No */,
+  has_tire_pressure_monitoring: vehicleBody?.has_tire_pressure_monitoring || "No" /* No */,
+  has_blind_spot_monitoring: vehicleBody?.has_blind_spot_monitoring || "No" /* No */,
+  has_collision_warning_system: vehicleBody?.has_collision_warning_system || "No" /* No */,
+  has_immobilizer: vehicleBody?.has_immobilizer || "No" /* No */,
+  has_dashcam: vehicleBody?.has_dashcam || "No" /* No */,
+  has_emergency_exit: vehicleBody?.has_emergency_exit || "No" /* No */,
+  status: vehicleBody ? vehicleBody?.status : "Active" /* Active */
+});
+var toVehicleDetailLifeCyclePayload = (vehicleLifeCycle) => ({
+  // Lifecycle Start
+  service_start_date: vehicleLifeCycle?.service_start_date || "",
+  service_start_odometer_reading: vehicleLifeCycle?.service_start_odometer_reading || 0,
+  // Lifecycle End
+  service_end_date: vehicleLifeCycle?.service_end_date || "",
+  service_end_odometer_reading: vehicleLifeCycle?.service_end_odometer_reading || 0,
+  // Estimated Life
+  life_estimate_max_month_year: vehicleLifeCycle?.life_estimate_max_month_year || "",
+  life_estimate_max_odometer_reading: vehicleLifeCycle?.life_estimate_max_odometer_reading || 0,
+  // Lifecycle Status
+  life_expiry: vehicleLifeCycle?.life_expiry || "No" /* No */,
+  is_extended_life_approved: vehicleLifeCycle?.is_extended_life_approved || "No" /* No */,
+  life_status: "Active" /* Active */,
+  life_expiry_message: vehicleLifeCycle?.life_expiry_message || "",
+  life_expiry_note: vehicleLifeCycle?.life_expiry_note || "",
+  status: vehicleLifeCycle ? vehicleLifeCycle.status : "Active" /* Active */,
+  time_zone_id: ""
+});
+var toVehicleDetailPurchasePayload = (vehiclePurchase) => ({
+  // Basic Purchase Info
+  purchase_date: vehiclePurchase?.purchase_date || "",
+  purchase_notes: vehiclePurchase?.purchase_notes || "",
+  purchase_vehicle_type: vehiclePurchase?.purchase_vehicle_type || "New" /* New */,
+  purchase_type: vehiclePurchase?.purchase_type || "NoFinance" /* NoFinance */,
+  purchase_total_amount: vehiclePurchase?.purchase_total_amount || 0,
+  // Loan Details
+  loan_amount: vehiclePurchase?.loan_amount || 0,
+  loan_down_payment: vehiclePurchase?.loan_down_payment || 0,
+  loan_interest_rate: vehiclePurchase?.loan_interest_rate || 0,
+  loan_interest_type: vehiclePurchase?.loan_interest_type || "Simple" /* Simple */,
+  loan_no_of_installments: vehiclePurchase?.loan_no_of_installments || 0,
+  loan_first_payment_date: vehiclePurchase?.loan_first_payment_date || "",
+  loan_last_payment_date: vehiclePurchase?.loan_last_payment_date || "",
+  loan_monthly_emi: vehiclePurchase?.loan_monthly_emi || 0,
+  loan_emi_date: vehiclePurchase?.loan_emi_date || 0,
+  // Lease Details
+  lease_start_date: vehiclePurchase?.lease_start_date || "",
+  lease_end_date: vehiclePurchase?.lease_end_date || "",
+  lease_security_deposit_amount: vehiclePurchase?.lease_security_deposit_amount || 0,
+  lease_monthly_emi_amount: vehiclePurchase?.lease_monthly_emi_amount || 0,
+  lease_emi_date: vehiclePurchase?.lease_emi_date || 0,
+  // Warranty Info
+  warranty_expiration_date: vehiclePurchase?.warranty_expiration_date || "",
+  warranty_max_odometer_reading: vehiclePurchase?.warranty_max_odometer_reading || 0,
+  warranty_exchange_date: vehiclePurchase?.warranty_exchange_date || "",
+  status: vehiclePurchase ? vehiclePurchase.status : "Active" /* Active */,
+  // Relations
+  purchase_vendor_id: vehiclePurchase?.purchase_vendor_id || "",
+  loan_vendor_id: vehiclePurchase?.loan_vendor_id || "",
+  lease_vendor_id: vehiclePurchase?.lease_vendor_id || "",
+  time_zone_id: ""
+});
+var get_vehicle_file_presigned_url = async (data) => {
+  return apiPost(ENDPOINTS.vehicle_file_presigned_url, data);
+};
+var get_device_file_presigned_url = async (data) => {
+  return apiPost(ENDPOINTS.device_file_presigned_url, data);
+};
+var get_calibration_file_presigned_url = async (file_name) => {
+  return apiGet(ENDPOINTS.calibration_file_presigned_url(file_name));
+};
+var create_vehicle_file = async (payload) => {
+  return apiPost(ENDPOINTS.create_vehicle_file, payload);
+};
+var remove_vehicle_file = async (id) => {
+  return apiDelete(ENDPOINTS.remove_vehicle_file(id));
+};
+var create_device_file = async (payload) => {
+  return apiPost(ENDPOINTS.create_device_file, payload);
+};
+var remove_device_file = async (id) => {
+  return apiDelete(ENDPOINTS.remove_device_file(id));
+};
+var update_calibration_file = async (id, data) => {
+  return apiPatch(ENDPOINTS.update_calibration_file(id), data);
+};
+var remove_calibration_file = async (id) => {
+  return apiDelete(ENDPOINTS.remove_calibration_file(id));
+};
+var findVehicles = async (payload) => {
+  return apiPost(ENDPOINTS.find, payload);
+};
+var find_no_gps_data_vehicles = async (payload) => {
+  return apiPost(ENDPOINTS.find_no_gps_data_vehicles, payload);
+};
+var findVehiclesLiveDashboard = async (payload) => {
+  return apiPost(ENDPOINTS.find_live_dashboard, payload);
+};
+var findVehicleGPSDetails = async (payload) => {
+  return apiPost(ENDPOINTS.find_gps_details, payload);
+};
+var createVehicle = async (payload) => {
+  return apiPost(ENDPOINTS.create, payload);
+};
+var updateVehicle = async (id, payload) => {
+  return apiPatch(ENDPOINTS.update(id), payload);
+};
+var deleteVehicle = async (id) => {
+  return apiDelete(ENDPOINTS.delete(id));
+};
+var updateDetailsGpsSensor = async (id, payload) => {
+  return apiPatch(ENDPOINTS.update_details_gps_sensor(id), payload);
+};
+var updateDetailsTrip = async (id, payload) => {
+  return apiPatch(ENDPOINTS.update_details_trip(id), payload);
+};
+var updateVehicleBodyDetails = async (id, payload) => {
+  return apiPatch(ENDPOINTS.update_details_body(id), payload);
+};
+var updateVehicleLifeCycleDetails = async (id, payload) => {
+  return apiPatch(ENDPOINTS.update_details_life_cycle(id), payload);
+};
+var updateVehiclePurchaseDetails = async (id, payload) => {
+  return apiPatch(ENDPOINTS.update_details_purchase(id), payload);
+};
+var linkDriverToVehicle = async (payload) => {
+  return apiPost(ENDPOINTS.vehicle_driver_link, payload);
+};
+var unlinkDriverFromVehicle = async (payload) => {
+  return apiPost(ENDPOINTS.vehicle_driver_unlink, payload);
+};
+var getDriverLinkHistoryByVehicle = async (id, params) => {
+  return apiGet(ENDPOINTS.find_vehicle_driver_link_history_by_vehicle(id), params);
+};
+var getDriverLinkHistoryByDriver = async (id, params) => {
+  return apiGet(ENDPOINTS.find_vehicle_driver_link_history_by_driver(id), params);
+};
+var linkDeviceToVehicle = async (payload) => {
+  return apiPost(ENDPOINTS.vehicle_device_link, payload);
+};
+var unlinkDeviceFromVehicle = async (payload) => {
+  return apiPost(ENDPOINTS.vehicle_device_unlink, payload);
+};
+var getDeviceLinkHistoryByVehicle = async (id, params) => {
+  return apiGet(ENDPOINTS.vehicle_device_link_history_by_vehicle(id), params);
+};
+var getDeviceLinkHistoryByDevice = async (id, params) => {
+  return apiGet(ENDPOINTS.vehicle_device_link_history_by_device(id), params);
+};
+var getVehicleCache = async (organisationId) => {
+  return apiGet(ENDPOINTS.find_cache.replace(":organisation_id", organisationId));
+};
+var getVehicleSimpleCache = async (organisationId) => {
+  return apiGet(ENDPOINTS.find_cache_simple.replace(":organisation_id", organisationId));
+};
+var getVehicleParentCache = async (organisationId) => {
+  return apiGet(ENDPOINTS.find_cache_parent.replace(":organisation_id", organisationId));
+};
+var getVehicleSimpleDropdownCustom = async (organisationId) => {
+  return apiGet(ENDPOINTS.find_cache_dropdown.replace(":organisation_id", organisationId));
+};
+var getVehicleSimpleDropdownCacheLiveData = async (organisationId) => {
+  return apiGet(ENDPOINTS.find_cache_dropdown_live_data.replace(":organisation_id", organisationId));
+};
+export {
+  CalibrationFileSchema,
+  MasterDeviceFileSchema,
+  MasterVehicleFileSchema,
+  NoGPSDataVehiclesQuerySchema,
+  VehicleBulkSchema,
+  VehicleDetailBodySchema,
+  VehicleDetailGPSSensorSchema,
+  VehicleDetailLifeCycleSchema,
+  VehicleDetailPurchaseSchema,
+  VehicleDetailTripSchema,
+  VehicleDeviceLinkSchema,
+  VehicleDeviceUnlinkSchema,
+  VehicleDriverLinkSchema,
+  VehicleGPSQuerySchema,
+  VehicleQuerySchema,
+  VehicleSchema,
+  createVehicle,
+  create_device_file,
+  create_vehicle_file,
+  deleteVehicle,
+  findVehicleGPSDetails,
+  findVehicles,
+  findVehiclesLiveDashboard,
+  find_no_gps_data_vehicles,
+  getDeviceLinkHistoryByDevice,
+  getDeviceLinkHistoryByVehicle,
+  getDriverLinkHistoryByDriver,
+  getDriverLinkHistoryByVehicle,
+  getVehicleCache,
+  getVehicleParentCache,
+  getVehicleSimpleCache,
+  getVehicleSimpleDropdownCacheLiveData,
+  getVehicleSimpleDropdownCustom,
+  get_calibration_file_presigned_url,
+  get_device_file_presigned_url,
+  get_vehicle_file_presigned_url,
+  linkDeviceToVehicle,
+  linkDriverToVehicle,
+  newVehiclePayload,
+  remove_calibration_file,
+  remove_device_file,
+  remove_vehicle_file,
+  toVehicleDetailLifeCyclePayload,
+  toVehicleDetailPurchasePayload,
+  toVehicleDetailsBodyPayload,
+  toVehicleDetailsGPSPayload,
+  toVehicleDetailsTripPayload,
+  toVehiclePayload,
+  unlinkDeviceFromVehicle,
+  unlinkDriverFromVehicle,
+  updateDetailsGpsSensor,
+  updateDetailsTrip,
+  updateVehicle,
+  updateVehicleBodyDetails,
+  updateVehicleLifeCycleDetails,
+  updateVehiclePurchaseDetails,
+  update_calibration_file
+};