@vulog/aima-vehicle 1.1.50 → 1.1.52

package/README.md

@@ -1,12 +1,20 @@
-# @vulog/aima-booking
+# @vulog/aima-vehicle
+
+Vehicle management module for AIMA platform.
+
+## Installation
 
 ```bash
 npm i @vulog/aima-client @vulog/aima-core @vulog/aima-vehicle
 ```
 
+## Usage
+
+### Initialize Client
+
 ```javascript
 import { getClient } from '@vulog/aima-client';
-import { getModelById } from '@vulog/aima-vehicle';
+import { getVehicles, getModelById, getModels, getVehicleById, getVehiclesRealTime } from '@vulog/aima-vehicle';
 
 const client = getClient({
     apiKey: '...',
@@ -15,7 +23,240 @@ const client = getClient({
     clientSecret: '...',
     fleetId: '...',
 });
+```
+
+### Get All Vehicles
+
+Fetches all vehicles with pagination (default page size: 500). The implementation uses an internal `getVehiclesPage` function to fetch individual pages of vehicles.
+
+```javascript
+// Get all vehicles
+const vehicles = await getVehicles(client);
+
+// Get all vehicles with custom page size
+const vehicles = await getVehicles(client, 1000);
+```
+
+The `getVehicles` function automatically handles pagination and will fetch all available vehicles up to a maximum of 50 pages. If you need to fetch a specific page of vehicles, you can use the internal `getVehiclesPage` function:
+
+```javascript
+// Get a specific page of vehicles
+const vehiclesPage = await getVehiclesPage(client, 0, 100); // First page, 100 vehicles per page
+```
+
+Note: `getVehiclesPage` is an internal function and is not exported from the package. It's used internally by `getVehicles` to handle the pagination logic.
+
+### Get Vehicle by ID
+
+Fetches a specific vehicle by its ID.
+
+```javascript
+const vehicle = await getVehicleById(client, 'dcb0c41e-4be3-11ea-83a5-024d0cba6da4');
+```
+
+### Get All Models
+
+Fetches all vehicle models.
+
+```javascript
+const models = await getModels(client);
+```
+
+### Get Model by ID
+
+Fetches a specific model by its ID.
+
+```javascript
+const model = await getModelById(client, 372);
+```
+
+### Get Real-Time Vehicle Data
+
+Fetches real-time data for all vehicles with pagination (default page size: 500). The implementation uses an internal `getVehiclesRealTimePage` function to fetch individual pages of real-time vehicle data.
+
+```javascript
+// Get real-time data for all vehicles
+const realTimeVehicles = await getVehiclesRealTime(client);
+
+// Get real-time data with custom page size
+const realTimeVehicles = await getVehiclesRealTime(client, 1000);
+
+// Get only vehicles updated after a specific timestamp (in UTC milliseconds)
+const lastSyncTime = Date.now() - 24 * 60 * 60 * 1000; // 24 hours ago
+const updatedVehicles = await getVehiclesRealTime(client, 500, lastSyncTime);
+```
+
+The `getVehiclesRealTime` function automatically handles pagination and will fetch all available vehicles up to a maximum of 50 pages. If you need to fetch a specific page of real-time vehicle data, you can use the internal `getVehiclesRealTimePage` function:
+
+```javascript
+// Get a specific page of real-time vehicle data
+const realTimeVehiclesPage = await getVehiclesRealTimePage(client, 0, 100); // First page, 100 vehicles per page
+
+// Get a specific page with lastUpdatedMillis filter
+const updatedVehiclesPage = await getVehiclesRealTimePage(client, 0, 100, lastSyncTime);
+```
+
+Note: `getVehiclesRealTimePage` is an internal function and is not exported from the package. It's used internally by `getVehiclesRealTime` to handle the pagination logic.
+
+## Types
+
+### Vehicle
+
+```typescript
+interface Vehicle {
+    id: string;
+    name: string;
+    plate: string;
+    vin: string;
+    model: Model;
+    options: Options[];
+    createDate: string;
+    updateDate: string;
+    fleetId: string;
+    externalId: string;
+    wakeupProvider?: string;
+    msisdn: string;
+    iccid: string;
+    imsi?: string;
+    published: boolean;
+    noBox: boolean;
+    archived: boolean;
+}
+```
+
+### Model
+
+```typescript
+interface Model {
+    id: number;
+    name: string;
+    energyType: string;
+    status: string;
+    nbOfSeats: number;
+    autonomy: number;
+    creationDate: string;
+    updateDate: string;
+    description: string;
+    fleetId: string;
+    vehicleType: string;
+    transmission: string;
+    outOfServiceRange: string;
+    recoveryRange: string;
+    incentiveThresholds: any[];
+    redistributeVehicleChargedEnoughRange: string;
+    odometerReliable?: boolean;
+}
+```
+
+### Options
+
+```typescript
+interface Options {
+    id: number;
+    fleetId: string;
+    name: string;
+    type: string;
+    description: string;
+}
+```
 
-const response = await getModelById(client, 25);
+### VehicleRealTime
 
+```typescript
+interface VehicleRealTime {
+    id: string;
+    name: string;
+    plate: string;
+    vin: string;
+    fleetid: 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;
+}
 ```

package/dist/index.d.mts

@@ -1,23 +1,99 @@
 import { Client } from '@vulog/aima-client';
 
+/**
+ * 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;
-    brand: 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;
-    incentiveThresholds: [];
+    /** 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 = {
@@ -133,6 +209,25 @@ declare const getModelsById: (client: Client, id: number) => Promise<Model>;
 
 declare const getModels: (client: Client) => Promise<Model[]>;
 
-declare const getVehicleRealTimeById: (client: Client, id: string) => Promise<VehicleRealTime | null>;
+/**
+ * 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[]>;
+
+declare const getVehicleById: (client: Client, id: string) => Promise<Vehicle | null>;
 
-export { type Model, getModels, getModelsById, getVehicleRealTimeById };
+export { type Model, type Vehicle, getModels, getModelsById, getVehicleById, getVehicles, getVehiclesRealTime };

package/dist/index.d.ts

@@ -1,23 +1,99 @@
 import { Client } from '@vulog/aima-client';
 
+/**
+ * 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;
-    brand: 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;
-    incentiveThresholds: [];
+    /** 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 = {
@@ -133,6 +209,25 @@ declare const getModelsById: (client: Client, id: number) => Promise<Model>;
 
 declare const getModels: (client: Client) => Promise<Model[]>;
 
-declare const getVehicleRealTimeById: (client: Client, id: string) => Promise<VehicleRealTime | null>;
+/**
+ * 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[]>;
+
+declare const getVehicleById: (client: Client, id: string) => Promise<Vehicle | null>;
 
-export { type Model, getModels, getModelsById, getVehicleRealTimeById };
+export { type Model, type Vehicle, getModels, getModelsById, getVehicleById, getVehicles, getVehiclesRealTime };

package/dist/index.js

@@ -22,7 +22,9 @@ var index_exports = {};
 __export(index_exports, {
   getModels: () => getModels,
   getModelsById: () => getModelsById,
-  getVehicleRealTimeById: () => getVehicleRealTimeById
+  getVehicleById: () => getVehicleById,
+  getVehicles: () => getVehicles,
+  getVehiclesRealTime: () => getVehiclesRealTime
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -36,21 +38,107 @@ var getModels = async (client) => {
   return client.get(`boapi/proxy/user/vehicle/fleets/${client.clientOptions.fleetId}/vehicles/models`).then(({ data }) => data);
 };
 
-// src/getVehicle.ts
+// src/getVehicles.ts
 var import_zod = require("zod");
-var schema = import_zod.z.object({
-  id: import_zod.z.string().trim().min(1).uuid()
+var getVehiclesPage = async (client, page, pageSize) => {
+  const response = await client.get(
+    `boapi/proxy/user/vehicle/fleets/${client.clientOptions.fleetId}/vehicles?page=${page}&size=${pageSize}`
+  );
+  return response.data;
+};
+var getVehicles = async (client, pageSize = 500) => {
+  const schema2 = import_zod.z.object({
+    pageSize: import_zod.z.number().min(1).default(500)
+  });
+  const result = schema2.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;
+};
+var 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());
+  }
+  const response = await client.get(
+    `boapi/proxy/fleetmanager/public/fleets/${client.clientOptions.fleetId}/vehicles?${queryParams.toString()}`
+  );
+  return response.data;
+};
+var getVehiclesRealTime = async (client, pageSize = 500, lastUpdatedMillis) => {
+  const schema2 = import_zod.z.object({
+    pageSize: import_zod.z.number().min(1).default(500),
+    lastUpdatedMillis: import_zod.z.number().positive().optional()
+  });
+  const result = schema2.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) {
+    const now = Date.now();
+    if (lastUpdatedMillis > 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;
+};
+
+// src/getVehicle.ts
+var import_zod2 = require("zod");
+var schema = import_zod2.z.object({
+  id: import_zod2.z.string().trim().min(1).uuid()
 });
-var getVehicleRealTimeById = async (client, id) => {
+var getVehicleById = async (client, id) => {
   const result = schema.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) => {
+  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;
     }
@@ -61,5 +149,7 @@ var getVehicleRealTimeById = async (client, id) => {
 0 && (module.exports = {
   getModels,
   getModelsById,
-  getVehicleRealTimeById
+  getVehicleById,
+  getVehicles,
+  getVehiclesRealTime
 });

package/dist/index.mjs

@@ -8,21 +8,107 @@ var getModels = async (client) => {
   return client.get(`boapi/proxy/user/vehicle/fleets/${client.clientOptions.fleetId}/vehicles/models`).then(({ data }) => data);
 };
 
-// src/getVehicle.ts
+// src/getVehicles.ts
 import { z } from "zod";
-var schema = z.object({
-  id: z.string().trim().min(1).uuid()
+var getVehiclesPage = async (client, page, pageSize) => {
+  const response = await client.get(
+    `boapi/proxy/user/vehicle/fleets/${client.clientOptions.fleetId}/vehicles?page=${page}&size=${pageSize}`
+  );
+  return response.data;
+};
+var getVehicles = async (client, pageSize = 500) => {
+  const schema2 = z.object({
+    pageSize: z.number().min(1).default(500)
+  });
+  const result = schema2.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;
+};
+var 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());
+  }
+  const response = await client.get(
+    `boapi/proxy/fleetmanager/public/fleets/${client.clientOptions.fleetId}/vehicles?${queryParams.toString()}`
+  );
+  return response.data;
+};
+var getVehiclesRealTime = async (client, pageSize = 500, lastUpdatedMillis) => {
+  const schema2 = z.object({
+    pageSize: z.number().min(1).default(500),
+    lastUpdatedMillis: z.number().positive().optional()
+  });
+  const result = schema2.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) {
+    const now = Date.now();
+    if (lastUpdatedMillis > 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;
+};
+
+// src/getVehicle.ts
+import { z as z2 } from "zod";
+var schema = z2.object({
+  id: z2.string().trim().min(1).uuid()
 });
-var getVehicleRealTimeById = async (client, id) => {
+var getVehicleById = async (client, id) => {
   const result = schema.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) => {
+  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;
     }
@@ -32,5 +118,7 @@ var getVehicleRealTimeById = async (client, id) => {
 export {
   getModels,
   getModelsById,
-  getVehicleRealTimeById
+  getVehicleById,
+  getVehicles,
+  getVehiclesRealTime
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@vulog/aima-vehicle",
-    "version": "1.1.50",
+    "version": "1.1.52",
     "main": "dist/index.js",
     "module": "dist/index.mjs",
     "types": "dist/index.d.ts",
@@ -19,8 +19,8 @@
     "author": "Vulog",
     "license": "ISC",
     "dependencies": {
-        "@vulog/aima-client": "1.1.50",
-        "@vulog/aima-core": "1.1.50"
+        "@vulog/aima-client": "1.1.52",
+        "@vulog/aima-core": "1.1.52"
     },
     "peerDependencies": {
         "zod": "^3.24.2"

package/src/getVehicle.ts

@@ -1,12 +1,30 @@
 import { Client } from '@vulog/aima-client';
 import { z } from 'zod';
 
-import { VehicleRealTime } from './types';
+import { Vehicle, VehicleRealTime } from './types';
 
 const schema = z.object({
     id: z.string().trim().min(1).uuid(),
 });
 
+export const getVehicleById = async (client: Client, id: string) => {
+    const result = schema.safeParse({ id });
+    if (!result.success) {
+        throw new TypeError('Invalid args', {
+            cause: result.error.issues,
+        });
+    }
+    return client
+        .get<Vehicle>(`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;
+        });
+};
+
 export const getVehicleRealTimeById = async (client: Client, id: string) => {
     const result = schema.safeParse({ id });
     if (!result.success) {

package/src/getVehicles.ts

@@ -0,0 +1,151 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { Vehicle, VehicleRealTime } from './types';
+
+/**
+ * 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: Client, page: number, pageSize: number): Promise<Vehicle[]> => {
+    const response = await client.get<Vehicle[]>(
+        `boapi/proxy/user/vehicle/fleets/${client.clientOptions.fleetId}/vehicles?page=${page}&size=${pageSize}`
+    );
+    return response.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
+ */
+export const getVehicles = async (client: Client, pageSize = 500): Promise<Vehicle[]> => {
+    const schema = z.object({
+        pageSize: z.number().min(1).default(500),
+    });
+    const result = schema.safeParse({ pageSize });
+    if (!result.success) {
+        throw new TypeError('Invalid args', {
+            cause: result.error.issues,
+        });
+    }
+    const allVehicles: Vehicle[] = [];
+    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.`
+            );
+        }
+
+        // eslint-disable-next-line no-await-in-loop -- Pagination requires sequential API calls
+        const vehicles = await getVehiclesPage(client, currentPage, result.data.pageSize);
+        allVehicles.push(...vehicles);
+
+        // Stop if we received fewer vehicles than the page size (including 0)
+        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: Client,
+    page: number,
+    pageSize: number,
+    lastUpdatedMillis?: number
+): Promise<VehicleRealTime[]> => {
+    // Build query parameters
+    const queryParams = new URLSearchParams({
+        page: page.toString(),
+        size: pageSize.toString(),
+    });
+
+    if (lastUpdatedMillis !== undefined) {
+        queryParams.append('lastUpdatedMillis', lastUpdatedMillis.toString());
+    }
+
+    // Using the fleetmanager public API endpoint for real-time vehicle data
+    const response = await client.get<VehicleRealTime[]>(
+        `boapi/proxy/fleetmanager/public/fleets/${client.clientOptions.fleetId}/vehicles?${queryParams.toString()}`
+    );
+    return response.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
+ */
+export const getVehiclesRealTime = async (
+    client: Client,
+    pageSize = 500,
+    lastUpdatedMillis?: number
+): Promise<VehicleRealTime[]> => {
+    const schema = z.object({
+        pageSize: z.number().min(1).default(500),
+        lastUpdatedMillis: z.number().positive().optional(),
+    });
+    const result = schema.safeParse({ pageSize, lastUpdatedMillis });
+    if (!result.success) {
+        throw new TypeError('Invalid args', {
+            cause: result.error.issues,
+        });
+    }
+    const allVehicles: VehicleRealTime[] = [];
+    let currentPage = 0;
+    let hasMorePages = true;
+    const MAX_PAGES = 50;
+
+    // Validate lastUpdatedMillis if provided
+    if (lastUpdatedMillis !== undefined) {
+        const now = Date.now();
+        if (lastUpdatedMillis > 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.`
+            );
+        }
+
+        // eslint-disable-next-line no-await-in-loop -- Pagination requires sequential API calls
+        const vehicles = await getVehiclesRealTimePage(
+            client,
+            currentPage,
+            result.data.pageSize,
+            result.data.lastUpdatedMillis
+        );
+        allVehicles.push(...vehicles);
+
+        // Stop if we received fewer vehicles than the page size (including 0)
+        hasMorePages = vehicles.length === result.data.pageSize;
+        currentPage += 1;
+    }
+
+    return allVehicles;
+};

package/src/index.ts

@@ -1,4 +1,5 @@
-export * from './getModel';
-export * from './getModels';
-export * from './getVehicle';
-export type { Model } from './types';
+export { getModelsById } from './getModel';
+export { getModels } from './getModels';
+export { getVehicles, getVehiclesRealTime } from './getVehicles';
+export { getVehicleById } from './getVehicle';
+export type { Model, Vehicle } from './types';

package/src/types.ts

@@ -1,21 +1,99 @@
+/**
+ * Represents a vehicle model with its specifications and characteristics
+ */
 export type Model = {
+    /** Unique identifier of the model */
     id: number;
+    /** Name of the model (e.g., "C-Zero") */
     name: string;
-    brand: 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;
-    incentiveThresholds: [];
+    /** 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
+ */
+export 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
+ */
+export 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;
 };