@vulog/aima-vehicle 1.2.30 → 1.2.31

package/dist/index.cjs

@@ -0,0 +1,252 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let zod = require("zod");
+zod = __toESM(zod);
+let _vulog_aima_core = require("@vulog/aima-core");
+//#region src/getModel.ts
+const getModelsById = async (client, id) => {
+	return client.get(`boapi/proxy/user/vehicle/fleets/${client.clientOptions.fleetId}/vehicles/models/${id}`).then(({ data }) => data);
+};
+//#endregion
+//#region src/getModelAssets.ts
+const schema$5 = zod.z.object({ id: zod.z.number().int().positive() });
+const getModelByIdAssets = async (client, id) => {
+	const result = schema$5.safeParse({ id });
+	if (!result.success) throw new TypeError("Invalid args", { cause: result.error.issues });
+	return client.get(`boapi/proxy/eds/rest_pub/rest/fleets/${client.clientOptions.fleetId}/models/${id}/`).then(({ data }) => data);
+};
+//#endregion
+//#region src/getModels.ts
+const getModels = async (client) => {
+	return client.get(`boapi/proxy/user/vehicle/fleets/${client.clientOptions.fleetId}/vehicles/models`).then(({ data }) => data);
+};
+//#endregion
+//#region src/getVehicle.ts
+const schema$4 = zod.z.object({ id: zod.z.string().trim().min(1).uuid() });
+const getVehicleById = async (client, id) => {
+	const result = schema$4.safeParse({ id });
+	if (!result.success) throw new TypeError("Invalid args", { cause: result.error.issues });
+	return client.get(`boapi/proxy/user/vehicle/fleets/${client.clientOptions.fleetId}/vehicles/${result.data.id}`).then(({ data }) => data).catch((error) => {
+		if (error.formattedError?.status === 404) return null;
+		throw error;
+	});
+};
+const getVehicleRealTimeById = async (client, id) => {
+	const result = schema$4.safeParse({ id });
+	if (!result.success) throw new TypeError("Invalid args", { cause: result.error.issues });
+	return client.get(`boapi/proxy/fleetmanager/public/fleets/${client.clientOptions.fleetId}/vehicles/${result.data.id}`).then(({ data }) => data).catch((error) => {
+		if (error.formattedError?.status === 404) return null;
+		throw error;
+	});
+};
+//#endregion
+//#region src/getVehicleAssets.ts
+const schema$3 = zod.z.object({ id: zod.z.string().uuid() });
+const getVehicleByIdAssets = async (client, id) => {
+	const result = schema$3.safeParse({ id });
+	if (!result.success) throw new TypeError("Invalid args", { cause: result.error.issues });
+	return client.get(`boapi/proxy/eds/rest_pub/rest/fleets/${client.clientOptions.fleetId}/vehicles/${id}/`).then(({ data }) => data);
+};
+//#endregion
+//#region src/getVehicles.ts
+/**
+* Fetches a single page of vehicles from the API
+* @param client - The AIMA client instance
+* @param page - The page number to fetch
+* @param pageSize - Number of vehicles per page
+* @returns Promise that resolves to an array of vehicles for the requested page
+*/
+const getVehiclesPage = async (client, page, pageSize) => {
+	return (await client.get(`boapi/proxy/user/vehicle/fleets/${client.clientOptions.fleetId}/vehicles?page=${page}&size=${pageSize}`)).data;
+};
+/**
+* Fetches all vehicles from the API using pagination
+* @param client - The AIMA client instance
+* @param pageSize - Number of vehicles per page (default: 500)
+* @returns Promise that resolves to an array of all vehicles
+* @throws Error if more than 50 pages are required to fetch all vehicles
+*/
+const getVehicles = async (client, pageSize = 500) => {
+	const result = zod.z.object({ pageSize: zod.z.number().min(1).default(500) }).safeParse({ pageSize });
+	if (!result.success) throw new TypeError("Invalid args", { cause: result.error.issues });
+	const allVehicles = [];
+	let currentPage = 0;
+	let hasMorePages = true;
+	const MAX_PAGES = 50;
+	while (hasMorePages) {
+		if (currentPage >= MAX_PAGES) throw new Error(`Maximum page limit (${MAX_PAGES}) reached. This might indicate an issue with the pagination or a very large dataset.`);
+		const vehicles = await getVehiclesPage(client, currentPage, result.data.pageSize);
+		allVehicles.push(...vehicles);
+		hasMorePages = vehicles.length === result.data.pageSize;
+		currentPage += 1;
+	}
+	return allVehicles;
+};
+/**
+* Fetches a single page of real-time vehicle data from the API
+* @param client - The AIMA client instance
+* @param page - The page number to fetch
+* @param pageSize - Number of vehicles per page
+* @param lastUpdatedMillis - Optional timestamp in UTC milliseconds
+* @returns Promise that resolves to an array of real-time vehicle data for the requested page
+*/
+const getVehiclesRealTimePage = async (client, page, pageSize, lastUpdatedMillis) => {
+	const queryParams = new URLSearchParams({
+		page: page.toString(),
+		size: pageSize.toString()
+	});
+	if (lastUpdatedMillis !== void 0) queryParams.append("lastUpdatedMillis", lastUpdatedMillis.toString());
+	return (await client.get(`boapi/proxy/fleetmanager/public/fleets/${client.clientOptions.fleetId}/vehicles?${queryParams.toString()}`)).data;
+};
+/**
+* Fetches all real-time vehicle data from the API using pagination
+* @param client - The AIMA client instance
+* @param pageSize - Number of vehicles per page (default: 500)
+* @param lastUpdatedMillis - Optional timestamp in UTC milliseconds. If provided, only vehicles updated after this timestamp will be returned.
+* @returns Promise that resolves to an array of all real-time vehicle data
+* @throws Error if more than 50 pages are required to fetch all vehicles
+* @throws Error if lastUpdatedMillis is in the future
+*/
+const getVehiclesRealTime = async (client, pageSize = 500, lastUpdatedMillis) => {
+	const result = zod.z.object({
+		pageSize: zod.z.number().min(1).default(500),
+		lastUpdatedMillis: zod.z.number().positive().optional()
+	}).safeParse({
+		pageSize,
+		lastUpdatedMillis
+	});
+	if (!result.success) throw new TypeError("Invalid args", { cause: result.error.issues });
+	const allVehicles = [];
+	let currentPage = 0;
+	let hasMorePages = true;
+	const MAX_PAGES = 50;
+	if (lastUpdatedMillis !== void 0) {
+		if (lastUpdatedMillis > Date.now()) throw new Error("lastUpdatedMillis must be in the past");
+	}
+	while (hasMorePages) {
+		if (currentPage >= MAX_PAGES) throw new Error(`Maximum page limit (${MAX_PAGES}) reached. This might indicate an issue with the pagination or a very large dataset.`);
+		const vehicles = await getVehiclesRealTimePage(client, currentPage, result.data.pageSize, result.data.lastUpdatedMillis);
+		allVehicles.push(...vehicles);
+		hasMorePages = vehicles.length === result.data.pageSize;
+		currentPage += 1;
+	}
+	return allVehicles;
+};
+//#endregion
+//#region src/pingVehicle.ts
+const schema$2 = zod.z.object({ id: zod.z.string().trim().min(1).uuid() });
+/**
+* Pings a vehicle to check if it is alive (box connected).
+* Returns true if alive (HTTP 200), false if box not connected (code 410, codeStr 'carConnectionProblem'),
+* throws for other errors or invalid id.
+*/
+const pingVehicleById = async (client, id) => {
+	const result = schema$2.safeParse({ id });
+	if (!result.success) throw new TypeError("Invalid args", { cause: result.error.issues });
+	try {
+		await client.get(`boapi/proxy/fleetmanager/public/v2/fleets/${client.clientOptions.fleetId}/vehicles/${result.data.id}/ping`);
+		return true;
+	} catch (error) {
+		if (error?.response?.data?.codeStr === "carConnectionProblem" && error?.response?.data?.code === 410) return false;
+		throw error;
+	}
+};
+//#endregion
+//#region src/enableVehicle.ts
+const schema$1 = zod.default.object({ subStatus: zod.default.string() });
+const enableVehicle = async (client, vehicleId, payload) => {
+	const result = schema$1.safeParse(payload);
+	if (!result.success) throw new TypeError("Invalid args", { cause: result.error.issues });
+	return client.post(`boapi/proxy/fleetmanager/public/fleets/${client.clientOptions.fleetId}/vehicles/${vehicleId}/enable`, payload).then(({ data }) => data);
+};
+//#endregion
+//#region src/disableVehicle.ts
+const schema = zod.default.object({ subStatus: zod.default.string() });
+const disableVehicle = async (client, vehicleId, payload) => {
+	const result = schema.safeParse(payload);
+	if (!result.success) throw new TypeError("Invalid args", { cause: result.error.issues });
+	return client.post(`boapi/proxy/fleetmanager/public/fleets/${client.clientOptions.fleetId}/vehicles/${vehicleId}/disable`, payload).then(({ data }) => data);
+};
+//#endregion
+//#region src/getModelVehicles.ts
+const getModelVehicles = async (client, options) => {
+	const resultOptions = (0, _vulog_aima_core.createPaginableOptionsSchema)().default({}).safeParse(options);
+	if (!resultOptions.success) throw new TypeError("Invalid options", { cause: resultOptions.error.issues });
+	const finalOptions = resultOptions.data;
+	const searchParams = new URLSearchParams();
+	searchParams.append("page", finalOptions.page.toString());
+	searchParams.append("size", finalOptions.pageSize.toString());
+	if (finalOptions.sort) searchParams.append("sort", `${finalOptions.sort.toString()},${finalOptions.sortDirection.toString()}`);
+	if (finalOptions.filters) Object.entries(finalOptions.filters).forEach(([key, value]) => {
+		if (value === void 0) return;
+		searchParams.append(key, value);
+	});
+	const urlWithParams = `${`boapi/proxy/user/vehicle/fleets/${client.clientOptions.fleetId}/vehicles/models/modelvehicles`}?${searchParams.toString()}`;
+	return client.get(urlWithParams).then(({ data, headers }) => {
+		return {
+			data,
+			page: headers.number,
+			pageSize: headers.size,
+			total: headers.totalelements,
+			totalPages: headers.totalpages
+		};
+	});
+};
+//#endregion
+//#region src/createVehicle.ts
+const createVehicleBodySchema = zod.z.object({
+	vin: zod.z.string().trim().min(1).max(20),
+	plate: zod.z.string().trim().min(1).max(16),
+	name: zod.z.string().trim().min(1).max(64),
+	model: zod.z.object({ id: zod.z.number().int().positive() }),
+	vuboxId: zod.z.string().optional(),
+	externalId: zod.z.string().max(32).optional(),
+	wakeupProvider: zod.z.string().max(16).optional(),
+	noBox: zod.z.boolean().optional(),
+	published: zod.z.boolean().optional(),
+	archived: zod.z.boolean().optional(),
+	msisdn: zod.z.string().max(32).optional(),
+	iccid: zod.z.string().max(32).optional(),
+	imsi: zod.z.string().max(32).optional(),
+	residualValue: zod.z.number().optional()
+});
+const createVehicle = async (client, body) => {
+	const result = createVehicleBodySchema.safeParse(body);
+	if (!result.success) throw new TypeError("Invalid args", { cause: result.error.issues });
+	return client.post(`/boapi/proxy/vehicle/fleets/${client.clientOptions.fleetId}/vehicles`, result.data).then(({ data }) => data);
+};
+//#endregion
+exports.createVehicle = createVehicle;
+exports.disableVehicle = disableVehicle;
+exports.enableVehicle = enableVehicle;
+exports.getModelByIdAssets = getModelByIdAssets;
+exports.getModelVehicles = getModelVehicles;
+exports.getModels = getModels;
+exports.getModelsById = getModelsById;
+exports.getVehicleById = getVehicleById;
+exports.getVehicleByIdAssets = getVehicleByIdAssets;
+exports.getVehicleRealTimeById = getVehicleRealTimeById;
+exports.getVehicles = getVehicles;
+exports.getVehiclesRealTime = getVehiclesRealTime;
+exports.pingVehicleById = pingVehicleById;

package/dist/index.d.cts

@@ -0,0 +1,273 @@
+import { Client } from "@vulog/aima-client";
+import { PaginableOptions, PaginableResponse } from "@vulog/aima-core";
+
+//#region src/types.d.ts
+/**
+ * Represents a vehicle model with its specifications and characteristics
+ */
+type Model = {
+  /** Unique identifier of the model */id: number; /** Name of the model (e.g., "C-Zero") */
+  name: string; /** Type of energy used by the vehicle (e.g., "ELECTRIC") */
+  energyType: string; /** Current status of the model (e.g., "ACTIVE") */
+  status: string; /** Number of seats in the vehicle */
+  nbOfSeats: number; /** Maximum range/autonomy of the vehicle in kilometers */
+  autonomy: number; /** Date when the model was created */
+  creationDate: string; /** Date when the model was last updated */
+  updateDate: string; /** Description of the model (e.g., brand name) */
+  description: string; /** ID of the fleet this model belongs to */
+  fleetId: string; /** Type of vehicle (e.g., "CAR") */
+  vehicleType: string; /** Type of transmission (e.g., "UNDEFINED") */
+  transmission: string; /** Range threshold for out of service status */
+  outOfServiceRange: string; /** Range threshold for recovery */
+  recoveryRange: string; /** Array of incentive thresholds */
+  incentiveThresholds: any[]; /** Range threshold for vehicle redistribution */
+  redistributeVehicleChargedEnoughRange: string; /** Indicates if the odometer readings are reliable */
+  odometerReliable?: boolean;
+  [key: string]: any;
+};
+/**
+ * Represents a vehicle in the system
+ */
+type Vehicle = {
+  /** Unique identifier of the vehicle */id: string; /** Name of the vehicle */
+  name: string; /** License plate number */
+  plate: string; /** Vehicle Identification Number */
+  vin: string; /** Model information of the vehicle */
+  model: Model; /** List of options/features installed on the vehicle */
+  options: Options[]; /** Date when the vehicle was created */
+  createDate: string; /** Date when the vehicle was last updated */
+  updateDate: string; /** ID of the fleet this vehicle belongs to */
+  fleetId: string; /** External system identifier */
+  externalId: string; /** Provider used for vehicle wakeup */
+  wakeupProvider?: string; /** Mobile Subscriber Integrated Services Digital Network Number */
+  msisdn: string; /** Integrated Circuit Card Identifier */
+  iccid: string; /** International Mobile Subscriber Identity */
+  imsi?: string; /** Whether the vehicle is published in the system */
+  published: boolean; /** Whether the vehicle has no box installed */
+  noBox: boolean; /** Whether the vehicle is archived */
+  archived: boolean;
+  [key: string]: any;
+};
+/**
+ * Represents a vehicle option or feature
+ */
+type Options = {
+  /** Unique identifier of the option */id: number; /** ID of the fleet this option belongs to */
+  fleetId: string; /** Name of the option */
+  name: string; /** Type of the option (e.g., "Color", "Gearbox") */
+  type: string; /** Description of the option */
+  description: string;
+  [key: string]: any;
+};
+type Zone = {
+  type: string;
+  version: number;
+  zoneId: string;
+  sticky: boolean;
+  labels: {
+    labelId: string;
+    name: string;
+    publicName: string;
+  }[];
+};
+type VehicleRealTime = {
+  id: string;
+  name: string;
+  plate: string;
+  vin: string;
+  fleetid: string;
+  currentFleetId: string;
+  ownerFleetId: string;
+  boxid: string;
+  vehicle_status: number;
+  zones: Zone[];
+  releasable: boolean;
+  box_status: number;
+  autonomy: number;
+  autonomy2: number;
+  isCharging: boolean;
+  battery: number;
+  km: number;
+  speed: number;
+  location: {
+    geohash: string;
+    cap: number;
+    latitude: number;
+    longitude: number;
+    gpsDate: string;
+    lastMovingDate: string;
+  };
+  endTripLocation: {
+    latitude: number;
+    longitude: number;
+  };
+  endZoneIds: [];
+  productIds: [];
+  isDoorClosed: boolean;
+  isDoorLocked: boolean;
+  engineOn: boolean;
+  immobilizerOn: boolean;
+  secureOn: boolean;
+  spareLockOn: boolean | null;
+  pileLockOn: boolean | null;
+  helmetPresent: boolean | null;
+  helmet2Present: boolean | null;
+  helmetBoxLockOn: boolean | null;
+  helmet2LockOn: boolean | null;
+  userId: string | null;
+  user_locale: string | null;
+  rfid: string | null;
+  orderId: string | null;
+  gatewayUrl: string | null;
+  booking_status: number;
+  booking_date: string | null;
+  expiresOn: boolean | null;
+  last_active_date: string;
+  last_wakeUp_date: string;
+  version: string;
+  pricingId: string | null;
+  start_date: string | null;
+  theorStartDate: string | null;
+  theorEndDate: string | null;
+  startZones: Zone[];
+  endZones: Zone[];
+  disabled: boolean;
+  outOfServiceReason: string;
+  ignitionOffGeohash: string | null;
+  geohashNeighbours: string[];
+  cleanlinessStatus: boolean;
+  needsRedistribution: boolean;
+  batteryUnderThreshold: boolean;
+  isBeingTowed: boolean;
+  automaticallyEnableVehicleAfterRangeRecovery: boolean;
+  key: {
+    deviceName: string;
+  };
+  doNotTrack: boolean;
+  energyLevel: number;
+  lastOosDate: string;
+  hasAlerts: boolean;
+  firmwareModel: string;
+  comeFromApp: string;
+  doors: {
+    frontLeftClosed: boolean;
+    frontRightClosed: boolean;
+    rearLeftClosed: boolean;
+    rearRightClosed: boolean;
+    trunkClosed: boolean;
+    hoodClosed: boolean;
+  };
+  windows: {
+    frontLeftClosed: boolean;
+    frontRightClosed: boolean;
+    rearLeftClosed: boolean;
+    rearRightClosed: boolean;
+    trunkClosed: boolean;
+  };
+  doorsAndWindowsClosed: boolean;
+  vpChecksum: string;
+  firmwareBuildDate: string;
+  [key: string]: any;
+};
+type Assets = {
+  fleet_id: string;
+  model_id: number;
+  assets: {
+    aid: string;
+    type: string;
+    url: string | null;
+    value: number | null;
+    b_value: boolean | null;
+    text: string | null;
+    [key: string]: any;
+  }[];
+  [key: string]: any;
+};
+type ModelVehicle = {
+  serviceId: string;
+  serviceVisibility: 'PUBLIC' | 'PRIVATE';
+  modelId: number;
+  vehicles: string[];
+};
+//#endregion
+//#region src/getModel.d.ts
+declare const getModelsById: (client: Client, id: number) => Promise<Model>;
+//#endregion
+//#region src/getModelAssets.d.ts
+declare const getModelByIdAssets: (client: Client, id: number) => Promise<Assets>;
+//#endregion
+//#region src/getModels.d.ts
+declare const getModels: (client: Client) => Promise<Model[]>;
+//#endregion
+//#region src/getVehicle.d.ts
+declare const getVehicleById: (client: Client, id: string) => Promise<Vehicle | null>;
+declare const getVehicleRealTimeById: (client: Client, id: string) => Promise<VehicleRealTime | null>;
+//#endregion
+//#region src/getVehicleAssets.d.ts
+declare const getVehicleByIdAssets: (client: Client, id: string) => Promise<Assets>;
+//#endregion
+//#region src/getVehicles.d.ts
+/**
+ * Fetches all vehicles from the API using pagination
+ * @param client - The AIMA client instance
+ * @param pageSize - Number of vehicles per page (default: 500)
+ * @returns Promise that resolves to an array of all vehicles
+ * @throws Error if more than 50 pages are required to fetch all vehicles
+ */
+declare const getVehicles: (client: Client, pageSize?: number) => Promise<Vehicle[]>;
+/**
+ * Fetches all real-time vehicle data from the API using pagination
+ * @param client - The AIMA client instance
+ * @param pageSize - Number of vehicles per page (default: 500)
+ * @param lastUpdatedMillis - Optional timestamp in UTC milliseconds. If provided, only vehicles updated after this timestamp will be returned.
+ * @returns Promise that resolves to an array of all real-time vehicle data
+ * @throws Error if more than 50 pages are required to fetch all vehicles
+ * @throws Error if lastUpdatedMillis is in the future
+ */
+declare const getVehiclesRealTime: (client: Client, pageSize?: number, lastUpdatedMillis?: number) => Promise<VehicleRealTime[]>;
+//#endregion
+//#region src/pingVehicle.d.ts
+/**
+ * Pings a vehicle to check if it is alive (box connected).
+ * Returns true if alive (HTTP 200), false if box not connected (code 410, codeStr 'carConnectionProblem'),
+ * throws for other errors or invalid id.
+ */
+declare const pingVehicleById: (client: Client, id: string) => Promise<boolean>;
+//#endregion
+//#region src/enableVehicle.d.ts
+type EnableVehicleBody = {
+  subStatus: string;
+};
+declare const enableVehicle: (client: Client, vehicleId: string, payload: EnableVehicleBody) => Promise<void>;
+//#endregion
+//#region src/disableVehicle.d.ts
+type DisableVehicleBody = {
+  subStatus: string;
+};
+declare const disableVehicle: (client: Client, vehicleId: string, payload: DisableVehicleBody) => Promise<void>;
+//#endregion
+//#region src/getModelVehicles.d.ts
+declare const getModelVehicles: (client: Client, options?: PaginableOptions) => Promise<PaginableResponse<ModelVehicle>>;
+//#endregion
+//#region src/createVehicle.d.ts
+type CreateVehicleBody = {
+  vin: string;
+  plate: string;
+  name: string;
+  model: {
+    id: number;
+  };
+  vuboxId?: string;
+  externalId?: string;
+  wakeupProvider?: string;
+  noBox?: boolean;
+  published?: boolean;
+  archived?: boolean;
+  msisdn?: string;
+  iccid?: string;
+  imsi?: string;
+  residualValue?: number;
+};
+declare const createVehicle: (client: Client, body: CreateVehicleBody) => Promise<Vehicle>;
+//#endregion
+export { Assets, CreateVehicleBody, DisableVehicleBody, EnableVehicleBody, Model, ModelVehicle, Options, Vehicle, VehicleRealTime, Zone, createVehicle, disableVehicle, enableVehicle, getModelByIdAssets, getModelVehicles, getModels, getModelsById, getVehicleById, getVehicleByIdAssets, getVehicleRealTimeById, getVehicles, getVehiclesRealTime, pingVehicleById };