@vulog/aima-booking 1.1.89 → 1.1.92

package/README.md

@@ -1,26 +1,308 @@
 # @vulog/aima-booking
 
+Booking management module for the AIMA platform. This module provides functionality to manage booking requests, stations, and subscription bookings.
+
+## Installation
+
 ```bash
-npm i @vulog/aima-client @vulog/aima-core @vulog/aima-booking
+npm install @vulog/aima-client @vulog/aima-core @vulog/aima-booking
+```
+
+## Usage
+
+### Initialize Client
+
+```javascript
+import { getClient } from '@vulog/aima-client';
+import { 
+    getBookingRequests, 
+    getScheduleBookingRequests, 
+    getSubscriptionBookingRequests,
+    getSATBookingRequests,
+    getBookingRequestById,
+    getBookingRequestByTrip,
+    getSubscriptionBookingRequestById,
+    getStations,
+    getStationById
+} from '@vulog/aima-booking';
+
+const client = getClient({
+    apiKey: 'your-api-key',
+    baseUrl: 'https://your-api-base-url',
+    clientId: 'your-client-id',
+    clientSecret: 'your-client-secret',
+    fleetId: 'your-fleet-id',
+});
+```
+
+## API Reference
+
+### Booking Requests
+
+#### getBookingRequests
+
+Retrieve booking requests with optional filtering.
+
+```javascript
+const bookingRequests = await getBookingRequests(client, 'ONGOING', {
+    limit: 50,
+    offset: 0,
+    userId: 'user-uuid-here'
+});
+```
+
+**Parameters:**
+- `client`: AIMA client instance
+- `status`: Booking request status ('ONGOING', 'COMPLETED', 'CANCELLED', 'EXPIRED')
+- `filters`: Optional filter object
+  - `limit`: Maximum number of results
+  - `offset`: Number of results to skip
+  - `userId`: Filter by user ID
+  - `vehicleId`: Filter by vehicle ID
+  - `stationId`: Filter by station ID
+
+#### getScheduleBookingRequests
+
+Get scheduled booking requests.
+
+```javascript
+const scheduledRequests = await getScheduleBookingRequests(client, {
+    startDate: '2024-01-01T00:00:00Z',
+    endDate: '2024-01-31T23:59:59Z'
+});
+```
+
+#### getSubscriptionBookingRequests
+
+Get subscription-based booking requests.
+
+```javascript
+const subscriptionRequests = await getSubscriptionBookingRequests(client, {
+    status: 'ACTIVE',
+    userId: 'user-uuid-here'
+});
+```
+
+#### getSATBookingRequests
+
+Get SAT (Scheduled Access Time) booking requests.
+
+```javascript
+const satRequests = await getSATBookingRequests(client, 'PENDING');
+```
+
+### Individual Booking Requests
+
+#### getBookingRequestById
+
+Retrieve a specific booking request by ID.
+
+```javascript
+const bookingRequest = await getBookingRequestById(client, 'bb493049-5b4f-43ea-8a65-964a13aec549');
+```
+
+#### getBookingRequestByTrip
+
+Get booking request associated with a trip.
+
+```javascript
+const bookingRequest = await getBookingRequestByTrip(client, '33E8E42710144E15A5CC447E4D3524F4');
+```
+
+#### getSubscriptionBookingRequestById
+
+Get subscription booking request by ID.
+
+```javascript
+const subscriptionRequest = await getSubscriptionBookingRequestById(client, 'b7faa2a2-e8fc-4a29-8de7-09ce783b9797');
+```
+
+### Stations
+
+#### getStations
+
+Retrieve stations with optional includes.
+
+```javascript
+const stations = await getStations(client, ['OPEN_HOUR', 'INFO']);
+```
+
+**Parameters:**
+- `client`: AIMA client instance
+- `includes`: Array of data to include ('OPEN_HOUR', 'INFO', 'VEHICLES', 'ZONES')
+
+#### getStationById
+
+Get a specific station by ID.
+
+```javascript
+const station = await getStationById(client, 'station-id-here', ['OPEN_HOUR', 'INFO']);
+```
+
+## Types
+
+### BookingRequest
+
+```typescript
+interface BookingRequest {
+    id: string;
+    userId: string;
+    vehicleId: string;
+    stationId: string;
+    status: 'PENDING' | 'ONGOING' | 'COMPLETED' | 'CANCELLED' | 'EXPIRED';
+    startTime: string;
+    endTime: string;
+    createdAt: string;
+    updatedAt: string;
+}
+```
+
+### Station
+
+```typescript
+interface Station {
+    id: string;
+    name: string;
+    address: string;
+    coordinates: {
+        latitude: number;
+        longitude: number;
+    };
+    isActive: boolean;
+    openHours: OpenHours[];
+    info: StationInfo;
+    vehicles: Vehicle[];
+    zones: Zone[];
+}
+```
+
+### BookingRequestStatus
+
+```typescript
+type BookingRequestStatus = 'PENDING' | 'ONGOING' | 'COMPLETED' | 'CANCELLED' | 'EXPIRED';
+```
+
+### ServiceType
+
+```typescript
+type ServiceType = 'CAR_SHARING' | 'BIKE_SHARING' | 'SCOOTER_SHARING' | 'MULTIMODAL';
 ```
 
+## Error Handling
+
+All functions include validation and will throw appropriate errors if:
+- Required parameters are missing
+- Invalid booking request or station IDs are provided
+- Invalid status values are used
+- Network errors occur
+
+## Examples
+
+### Complete Booking Management Workflow
+
 ```javascript
 import { getClient } from '@vulog/aima-client';
-import { getBookingRequests } from '@vulog/aima-booking';
+import { 
+    getBookingRequests, 
+    getStations, 
+    getBookingRequestById 
+} from '@vulog/aima-booking';
 
 const client = getClient({
-    apiKey: '...',
-    baseUrl: '...',
-    clientId: '...',
-    clientSecret: '...',
-    fleetId: '...',
+    apiKey: 'your-api-key',
+    baseUrl: 'https://your-api-base-url',
+    clientId: 'your-client-id',
+    clientSecret: 'your-client-secret',
+    fleetId: 'your-fleet-id',
 });
 
-const response = await getBookingRequests(client, 'ONGOING');
+async function bookingWorkflow() {
+    try {
+        // Get all ongoing booking requests
+        const ongoingRequests = await getBookingRequests(client, 'ONGOING');
+        console.log(`Found ${ongoingRequests.length} ongoing booking requests`);
+        
+        // Get stations with full information
+        const stations = await getStations(client, ['OPEN_HOUR', 'INFO', 'VEHICLES']);
+        console.log(`Found ${stations.length} stations`);
+        
+        // Get specific booking request
+        const bookingRequest = await getBookingRequestById(client, 'bb493049-5b4f-43ea-8a65-964a13aec549');
+        console.log('Booking request details:', bookingRequest);
+        
+        return { ongoingRequests, stations, bookingRequest };
+    } catch (error) {
+        console.error('Booking workflow error:', error);
+        throw error;
+    }
+}
+```
 
-const station = await getStations(client, ['OPEN_HOUR', 'INFO']);
+### Station Analysis
 
-const br1 = await getBookingRequestById(client, 'bb493049-5b4f-43ea-8a65-964a13aec549');
-const br2 = await getBookingRequestByTrip(client, '33E8E42710144E15A5CC447E4D3524F4');
-const sub = await getSubscriptionBookingRequestById(client, 'b7faa2a2-e8fc-4a29-8de7-09ce783b9797');
+```javascript
+async function analyzeStations(client) {
+    try {
+        const stations = await getStations(client, ['OPEN_HOUR', 'INFO', 'VEHICLES']);
+        
+        const analysis = {
+            totalStations: stations.length,
+            activeStations: stations.filter(s => s.isActive).length,
+            stationsWithVehicles: stations.filter(s => s.vehicles && s.vehicles.length > 0).length,
+            averageVehiclesPerStation: stations.reduce((sum, s) => sum + (s.vehicles?.length || 0), 0) / stations.length,
+            stationsByZone: stations.reduce((acc, station) => {
+                station.zones?.forEach(zone => {
+                    acc[zone.name] = (acc[zone.name] || 0) + 1;
+                });
+                return acc;
+            }, {})
+        };
+        
+        console.log('Station Analysis:');
+        console.log(`Total Stations: ${analysis.totalStations}`);
+        console.log(`Active Stations: ${analysis.activeStations}`);
+        console.log(`Stations with Vehicles: ${analysis.stationsWithVehicles}`);
+        console.log(`Average Vehicles per Station: ${analysis.averageVehiclesPerStation.toFixed(2)}`);
+        console.log('Stations by Zone:', analysis.stationsByZone);
+        
+        return analysis;
+    } catch (error) {
+        console.error('Station analysis error:', error);
+        throw error;
+    }
+}
+```
+
+### Booking Request Monitoring
+
+```javascript
+async function monitorBookingRequests(client) {
+    try {
+        const [ongoing, completed, cancelled] = await Promise.all([
+            getBookingRequests(client, 'ONGOING'),
+            getBookingRequests(client, 'COMPLETED'),
+            getBookingRequests(client, 'CANCELLED')
+        ]);
+        
+        const monitoring = {
+            ongoing: ongoing.length,
+            completed: completed.length,
+            cancelled: cancelled.length,
+            total: ongoing.length + completed.length + cancelled.length,
+            completionRate: completed.length / (completed.length + cancelled.length) * 100
+        };
+        
+        console.log('Booking Request Monitoring:');
+        console.log(`Ongoing: ${monitoring.ongoing}`);
+        console.log(`Completed: ${monitoring.completed}`);
+        console.log(`Cancelled: ${monitoring.cancelled}`);
+        console.log(`Total: ${monitoring.total}`);
+        console.log(`Completion Rate: ${monitoring.completionRate.toFixed(2)}%`);
+        
+        return monitoring;
+    } catch (error) {
+        console.error('Booking monitoring error:', error);
+        throw error;
+    }
+}
 ```

package/dist/index.d.mts

@@ -1,6 +1,7 @@
 import { Client } from '@vulog/aima-client';
 import { PaginableOptions, PaginableResponse } from '@vulog/aima-core';
 import { z } from 'zod';
+import { UUID } from 'crypto';
 
 type PaymentReceipts = {
     id: string;
@@ -195,4 +196,8 @@ declare const IncludeSchema: z.ZodEnum<["INFO", "SERVICES"]>;
 type IncludeStation = z.infer<typeof IncludeSchema>;
 declare const getStationById: (client: Client, id: string, includes?: IncludeStation[]) => Promise<Station | null>;
 
-export { type BaseBookingRequest, type BookingRequest, type BookingRequestFilters, type BookingRequestStatus, type CustomPrice, type DayOpeningHours, type Days, type GeoInfo, type Include, type IncludeStation, type OpeningHours, type PaymentReceipts, type SATBookingRequest, type SATBookingRequestStatus, type Service, type ServiceInfo, type ServiceType, type Station, type Timetable, getBookingRequestById, getBookingRequestByTrip, getBookingRequests, getSATBookingRequests, getScheduleBookingRequests, getStationById, getStations, getSubscriptionBookingRequestById, getSubscriptionBookingRequests };
+declare const allocateVehicle: (client: Client, bookingRequestId: UUID, vehicleId: UUID, serviceId: UUID) => Promise<SATBookingRequest>;
+
+declare const deallocateVehicle: (client: Client, bookingRequestId: UUID, vehicleId: UUID) => Promise<SATBookingRequest>;
+
+export { type BaseBookingRequest, type BookingRequest, type BookingRequestFilters, type BookingRequestStatus, type CustomPrice, type DayOpeningHours, type Days, type GeoInfo, type Include, type IncludeStation, type OpeningHours, type PaymentReceipts, type SATBookingRequest, type SATBookingRequestStatus, type Service, type ServiceInfo, type ServiceType, type Station, type Timetable, allocateVehicle, deallocateVehicle, getBookingRequestById, getBookingRequestByTrip, getBookingRequests, getSATBookingRequests, getScheduleBookingRequests, getStationById, getStations, getSubscriptionBookingRequestById, getSubscriptionBookingRequests };

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import { Client } from '@vulog/aima-client';
 import { PaginableOptions, PaginableResponse } from '@vulog/aima-core';
 import { z } from 'zod';
+import { UUID } from 'crypto';
 
 type PaymentReceipts = {
     id: string;
@@ -195,4 +196,8 @@ declare const IncludeSchema: z.ZodEnum<["INFO", "SERVICES"]>;
 type IncludeStation = z.infer<typeof IncludeSchema>;
 declare const getStationById: (client: Client, id: string, includes?: IncludeStation[]) => Promise<Station | null>;
 
-export { type BaseBookingRequest, type BookingRequest, type BookingRequestFilters, type BookingRequestStatus, type CustomPrice, type DayOpeningHours, type Days, type GeoInfo, type Include, type IncludeStation, type OpeningHours, type PaymentReceipts, type SATBookingRequest, type SATBookingRequestStatus, type Service, type ServiceInfo, type ServiceType, type Station, type Timetable, getBookingRequestById, getBookingRequestByTrip, getBookingRequests, getSATBookingRequests, getScheduleBookingRequests, getStationById, getStations, getSubscriptionBookingRequestById, getSubscriptionBookingRequests };
+declare const allocateVehicle: (client: Client, bookingRequestId: UUID, vehicleId: UUID, serviceId: UUID) => Promise<SATBookingRequest>;
+
+declare const deallocateVehicle: (client: Client, bookingRequestId: UUID, vehicleId: UUID) => Promise<SATBookingRequest>;
+
+export { type BaseBookingRequest, type BookingRequest, type BookingRequestFilters, type BookingRequestStatus, type CustomPrice, type DayOpeningHours, type Days, type GeoInfo, type Include, type IncludeStation, type OpeningHours, type PaymentReceipts, type SATBookingRequest, type SATBookingRequestStatus, type Service, type ServiceInfo, type ServiceType, type Station, type Timetable, allocateVehicle, deallocateVehicle, getBookingRequestById, getBookingRequestByTrip, getBookingRequests, getSATBookingRequests, getScheduleBookingRequests, getStationById, getStations, getSubscriptionBookingRequestById, getSubscriptionBookingRequests };

package/dist/index.js

@@ -1,7 +1,9 @@
 "use strict";
+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 __export = (target, all) => {
   for (var name in all)
@@ -15,11 +17,21 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  allocateVehicle: () => allocateVehicle,
+  deallocateVehicle: () => deallocateVehicle,
   getBookingRequestById: () => getBookingRequestById,
   getBookingRequestByTrip: () => getBookingRequestByTrip,
   getBookingRequests: () => getBookingRequests,
@@ -358,7 +370,7 @@ var getStationById = async (client, id, includes = []) => {
   });
   if (station && includes.includes("INFO")) {
     const poi = await client.get(
-      `/boapi/proxy/geoloc/fleets/${client.clientOptions.fleetId}/poi/${station.poiId}`,
+      `/boapi/proxy/geoloc/fleets/${client.clientOptions.fleetId}/pois/${station.poiId}`,
       {
         headers: { accept: "application/vnd.geo+json" }
       }
@@ -409,8 +421,47 @@ var getStationById = async (client, id, includes = []) => {
   }
   return station;
 };
+
+// src/allocateVehicle.ts
+var import_zod6 = __toESM(require("zod"));
+var allocateVehicleSchema = import_zod6.default.object({
+  bookingRequestId: import_zod6.default.string().uuid(),
+  vehicleId: import_zod6.default.string().uuid(),
+  serviceId: import_zod6.default.string().uuid()
+});
+var allocateVehicle = async (client, bookingRequestId, vehicleId, serviceId) => {
+  const resultPayload = allocateVehicleSchema.safeParse({ bookingRequestId, vehicleId, serviceId });
+  if (!resultPayload.success) {
+    throw new TypeError("Invalid args", {
+      cause: resultPayload.error.issues
+    });
+  }
+  return client.post(
+    `boapi/proxy/user/scheduleATrip/fleets/${client.clientOptions.fleetId}/bookingrequests/${bookingRequestId}/allocate/${vehicleId}?serviceId=${serviceId}`
+  ).then(({ data }) => data);
+};
+
+// src/deallocateVehicle.ts
+var import_zod7 = __toESM(require("zod"));
+var deallocateVehicleSchema = import_zod7.default.object({
+  bookingRequestId: import_zod7.default.string().uuid(),
+  vehicleId: import_zod7.default.string().uuid()
+});
+var deallocateVehicle = async (client, bookingRequestId, vehicleId) => {
+  const resultPayload = deallocateVehicleSchema.safeParse({ bookingRequestId, vehicleId });
+  if (!resultPayload.success) {
+    throw new TypeError("Invalid args", {
+      cause: resultPayload.error.issues
+    });
+  }
+  return client.delete(
+    `boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/bookingrequests/${bookingRequestId}/vehicles/${vehicleId}`
+  ).then(({ data }) => data);
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  allocateVehicle,
+  deallocateVehicle,
   getBookingRequestById,
   getBookingRequestByTrip,
   getBookingRequests,

package/dist/index.mjs

@@ -324,7 +324,7 @@ var getStationById = async (client, id, includes = []) => {
   });
   if (station && includes.includes("INFO")) {
     const poi = await client.get(
-      `/boapi/proxy/geoloc/fleets/${client.clientOptions.fleetId}/poi/${station.poiId}`,
+      `/boapi/proxy/geoloc/fleets/${client.clientOptions.fleetId}/pois/${station.poiId}`,
       {
         headers: { accept: "application/vnd.geo+json" }
       }
@@ -375,7 +375,46 @@ var getStationById = async (client, id, includes = []) => {
   }
   return station;
 };
+
+// src/allocateVehicle.ts
+import z6 from "zod";
+var allocateVehicleSchema = z6.object({
+  bookingRequestId: z6.string().uuid(),
+  vehicleId: z6.string().uuid(),
+  serviceId: z6.string().uuid()
+});
+var allocateVehicle = async (client, bookingRequestId, vehicleId, serviceId) => {
+  const resultPayload = allocateVehicleSchema.safeParse({ bookingRequestId, vehicleId, serviceId });
+  if (!resultPayload.success) {
+    throw new TypeError("Invalid args", {
+      cause: resultPayload.error.issues
+    });
+  }
+  return client.post(
+    `boapi/proxy/user/scheduleATrip/fleets/${client.clientOptions.fleetId}/bookingrequests/${bookingRequestId}/allocate/${vehicleId}?serviceId=${serviceId}`
+  ).then(({ data }) => data);
+};
+
+// src/deallocateVehicle.ts
+import z7 from "zod";
+var deallocateVehicleSchema = z7.object({
+  bookingRequestId: z7.string().uuid(),
+  vehicleId: z7.string().uuid()
+});
+var deallocateVehicle = async (client, bookingRequestId, vehicleId) => {
+  const resultPayload = deallocateVehicleSchema.safeParse({ bookingRequestId, vehicleId });
+  if (!resultPayload.success) {
+    throw new TypeError("Invalid args", {
+      cause: resultPayload.error.issues
+    });
+  }
+  return client.delete(
+    `boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/bookingrequests/${bookingRequestId}/vehicles/${vehicleId}`
+  ).then(({ data }) => data);
+};
 export {
+  allocateVehicle,
+  deallocateVehicle,
   getBookingRequestById,
   getBookingRequestByTrip,
   getBookingRequests,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@vulog/aima-booking",
-    "version": "1.1.89",
+    "version": "1.1.92",
     "main": "dist/index.js",
     "module": "dist/index.mjs",
     "types": "dist/index.d.ts",
@@ -19,8 +19,8 @@
     "author": "Vulog",
     "license": "MIT",
     "dependencies": {
-        "@vulog/aima-client": "1.1.89",
-        "@vulog/aima-core": "1.1.89"
+        "@vulog/aima-client": "1.1.92",
+        "@vulog/aima-core": "1.1.92"
     },
     "peerDependencies": {
         "es-toolkit": "^1.39.9",

package/src/allocateVehicle.test.ts

@@ -0,0 +1,49 @@
+import { describe, test, vi, expect, beforeEach } from 'vitest';
+
+import { Client } from '@vulog/aima-client';
+import { allocateVehicle } from './allocateVehicle';
+import { UUID } from 'crypto';
+
+describe('allocateVehicle', () => {
+    const postMock = vi.fn();
+    const client = {
+        post: postMock,
+        clientOptions: {
+            fleetId: 'FLEET_ID',
+        },
+    } as unknown as Client;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    test('should return invalid args', async () => {
+        const bookingRequestId = 'BOOKING_REQUEST_ID';
+        const vehicleId = 'VEHICLE_ID';
+        const serviceId = 'SERVICE_ID';
+
+        // expect to throw error if invalid UUIDs are provided
+        await expect(
+            allocateVehicle(client, bookingRequestId as UUID, vehicleId as UUID, serviceId as UUID)
+        ).rejects.toThrow('Invalid args');
+    });
+
+    test('should allocate vehicle successfully', async () => {
+        const bookingRequestId = '550e8400-e29b-41d4-a716-446655440000';
+        const vehicleId = '550e8400-e29b-41d4-a716-446655440001';
+        const serviceId = '550e8400-e29b-41d4-a716-446655440002';
+
+        const mockResponse = {
+            id: 'some-id',
+            status: 'ALLOCATED',
+            // other properties of SATBookingRequest
+        };
+
+        postMock.mockResolvedValueOnce({
+            data: mockResponse,
+        });
+
+        const result = await allocateVehicle(client, bookingRequestId, vehicleId, serviceId);
+        expect(result).toEqual(mockResponse);
+    });
+});

package/src/allocateVehicle.ts

@@ -0,0 +1,32 @@
+import { UUID } from 'crypto';
+
+import { Client } from '@vulog/aima-client';
+
+import z from 'zod';
+
+import { SATBookingRequest } from './types';
+
+const allocateVehicleSchema = z.object({
+    bookingRequestId: z.string().uuid(),
+    vehicleId: z.string().uuid(),
+    serviceId: z.string().uuid(),
+});
+
+export const allocateVehicle = async (
+    client: Client,
+    bookingRequestId: UUID,
+    vehicleId: UUID,
+    serviceId: UUID
+): Promise<SATBookingRequest> => {
+    const resultPayload = allocateVehicleSchema.safeParse({ bookingRequestId, vehicleId, serviceId });
+    if (!resultPayload.success) {
+        throw new TypeError('Invalid args', {
+            cause: resultPayload.error.issues,
+        });
+    }
+    return client
+        .post<SATBookingRequest>(
+            `boapi/proxy/user/scheduleATrip/fleets/${client.clientOptions.fleetId}/bookingrequests/${bookingRequestId}/allocate/${vehicleId}?serviceId=${serviceId}`
+        )
+        .then(({ data }) => data);
+};

package/src/deallocateVehicle.test.ts

@@ -0,0 +1,47 @@
+import { describe, test, vi, expect, beforeEach } from 'vitest';
+
+import { Client } from '@vulog/aima-client';
+import { deallocateVehicle } from './deallocateVehicle';
+import { UUID } from 'crypto';
+
+describe('deallocateVehicle', () => {
+    const deleteMock = vi.fn();
+    const client = {
+        delete: deleteMock,
+        clientOptions: {
+            fleetId: 'FLEET_ID',
+        },
+    } as unknown as Client;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    test('should return invalid args', async () => {
+        const bookingRequestId = 'BOOKING_REQUEST_ID';
+        const vehicleId = 'VEHICLE_ID';
+
+        // expect to throw error if invalid UUIDs are provided
+        await expect(deallocateVehicle(client, bookingRequestId as UUID, vehicleId as UUID)).rejects.toThrow(
+            'Invalid args'
+        );
+    });
+
+    test('should deallocate vehicle successfully', async () => {
+        const bookingRequestId = '550e8400-e29b-41d4-a716-446655440000';
+        const vehicleId = '550e8400-e29b-41d4-a716-446655440001';
+
+        const mockResponse = {
+            id: 'some-id',
+            vehicleId: null,
+            // other properties of SATBookingRequest
+        };
+
+        deleteMock.mockResolvedValueOnce({
+            data: mockResponse,
+        });
+
+        const result = await deallocateVehicle(client, bookingRequestId, vehicleId);
+        expect(result).toEqual(mockResponse);
+    });
+});

package/src/deallocateVehicle.ts

@@ -0,0 +1,32 @@
+// https://java-sta.vulog.com/boapi/proxy/user/scheduledBooking/fleets/LEO-CAMTR/bookingrequests/2e603670-9684-4df1-9ff5-7f380ce6b8dc/vehicles/2e15c6f2-0b75-47ca-b885-b60f6ac35b12
+
+import { UUID } from 'crypto';
+
+import { Client } from '@vulog/aima-client';
+
+import z from 'zod';
+
+import { SATBookingRequest } from './types';
+
+const deallocateVehicleSchema = z.object({
+    bookingRequestId: z.string().uuid(),
+    vehicleId: z.string().uuid(),
+});
+
+export const deallocateVehicle = async (
+    client: Client,
+    bookingRequestId: UUID,
+    vehicleId: UUID
+): Promise<SATBookingRequest> => {
+    const resultPayload = deallocateVehicleSchema.safeParse({ bookingRequestId, vehicleId });
+    if (!resultPayload.success) {
+        throw new TypeError('Invalid args', {
+            cause: resultPayload.error.issues,
+        });
+    }
+    return client
+        .delete<SATBookingRequest>(
+            `boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/bookingrequests/${bookingRequestId}/vehicles/${vehicleId}`
+        )
+        .then(({ data }) => data);
+};

package/src/getStation.test.ts

@@ -227,7 +227,7 @@ describe('getStationById', () => {
                     config: {}
                });
             }
-            if (url === `/boapi/proxy/geoloc/fleets/${FLEET_ID}/poi/${POI_ID}` ) {
+            if (url === `/boapi/proxy/geoloc/fleets/${FLEET_ID}/pois/${POI_ID}` ) {
                 return Promise.resolve({
                     data: {
                         type: 'FeatureCollection',
@@ -262,7 +262,7 @@ describe('getStationById', () => {
                     config: {}
                });
             }
-            if (url.startsWith(`/boapi/proxy/geoloc/fleets/${FLEET_ID}/poi/`)) {
+            if (url.startsWith(`/boapi/proxy/geoloc/fleets/${FLEET_ID}/pois/`)) {
                 return Promise.resolve({
                     data: {
                         type: 'FeatureCollection',
@@ -369,7 +369,7 @@ describe('getStationById', () => {
         expect(getMock).toBeCalledTimes(2);
         expect(getMock).toBeCalledWith(`/boapi/proxy/user/scheduledBooking/fleets/${FLEET_ID}/stations/${STATION_ID}`);
         expect(getMock).toBeCalledWith(
-            `/boapi/proxy/geoloc/fleets/${FLEET_ID}/poi/${POI_ID}`,
+            `/boapi/proxy/geoloc/fleets/${FLEET_ID}/pois/${POI_ID}`,
             { headers: { accept: 'application/vnd.geo+json' } }
         );
         expectStation(station, STATION);
@@ -400,7 +400,7 @@ describe('getStationById', () => {
         expect(getMock).toBeCalledTimes(3);
         expect(getMock).toBeCalledWith(`/boapi/proxy/user/scheduledBooking/fleets/${FLEET_ID}/stations/${STATION_ID}`);
         expect(getMock).toBeCalledWith(
-            `/boapi/proxy/geoloc/fleets/${FLEET_ID}/poi/${POI_ID}`,
+            `/boapi/proxy/geoloc/fleets/${FLEET_ID}/pois/${POI_ID}`,
             { headers: { accept: 'application/vnd.geo+json' } }
         );
         expect(getMock).toBeCalledWith(`/boapi/proxy/user/fleets/${FLEET_ID}/stations/details?showTimetable=false`);

package/src/getStation.ts

@@ -66,7 +66,7 @@ export const getStationById = async (
     if (station && includes.includes('INFO')) {
         const poi = await client
             .get<{ features: any[] }>(
-                `/boapi/proxy/geoloc/fleets/${client.clientOptions.fleetId}/poi/${station.poiId}`,
+                `/boapi/proxy/geoloc/fleets/${client.clientOptions.fleetId}/pois/${station.poiId}`,
                 {
                     headers: { accept: 'application/vnd.geo+json' },
                 }

package/src/index.ts

@@ -8,3 +8,5 @@ export { getStations } from './getStations';
 export type { Include } from './getStations';
 export { getStationById } from './getStation';
 export type { IncludeStation } from './getStation';
+export { allocateVehicle } from './allocateVehicle';
+export { deallocateVehicle } from './deallocateVehicle';