@vulog/aima-booking 1.2.22 → 1.2.25

package/dist/index.d.mts

@@ -261,7 +261,7 @@ declare const triggerBRPaymentSchema: z$1.ZodObject<{
         requiresActionReturnURL: z$1.ZodOptional<z$1.ZodString>;
         online: z$1.ZodBoolean;
         amountType: z$1.ZodEnum<["FIXED", "PERCENTAGE"]>;
-        amountValue: z$1.ZodOptional<z$1.ZodNumber>;
+        amountValue: z$1.ZodNumber;
         preferredPaymentMethods: z$1.ZodOptional<z$1.ZodArray<z$1.ZodObject<{
             pspReference: z$1.ZodString;
             amount: z$1.ZodDefault<z$1.ZodNumber>;
@@ -278,8 +278,8 @@ declare const triggerBRPaymentSchema: z$1.ZodObject<{
         scope: "RENTAL" | "DEPOSIT";
         online: boolean;
         amountType: "FIXED" | "PERCENTAGE";
+        amountValue: number;
         requiresActionReturnURL?: string | undefined;
-        amountValue?: number | undefined;
         preferredPaymentMethods?: {
             pspReference: string;
             amount: number;
@@ -289,8 +289,8 @@ declare const triggerBRPaymentSchema: z$1.ZodObject<{
         scope: "RENTAL" | "DEPOSIT";
         online: boolean;
         amountType: "FIXED" | "PERCENTAGE";
+        amountValue: number;
         requiresActionReturnURL?: string | undefined;
-        amountValue?: number | undefined;
         preferredPaymentMethods?: {
             pspReference: string;
             amount?: number | undefined;
@@ -302,8 +302,8 @@ declare const triggerBRPaymentSchema: z$1.ZodObject<{
         scope: "RENTAL" | "DEPOSIT";
         online: boolean;
         amountType: "FIXED" | "PERCENTAGE";
+        amountValue: number;
         requiresActionReturnURL?: string | undefined;
-        amountValue?: number | undefined;
         preferredPaymentMethods?: {
             pspReference: string;
             amount: number;
@@ -316,8 +316,8 @@ declare const triggerBRPaymentSchema: z$1.ZodObject<{
         scope: "RENTAL" | "DEPOSIT";
         online: boolean;
         amountType: "FIXED" | "PERCENTAGE";
+        amountValue: number;
         requiresActionReturnURL?: string | undefined;
-        amountValue?: number | undefined;
         preferredPaymentMethods?: {
             pspReference: string;
             amount?: number | undefined;
@@ -327,4 +327,10 @@ declare const triggerBRPaymentSchema: z$1.ZodObject<{
 }>;
 declare const triggerBRPayment: (client: Client, bookingRequestId: UUID, body: z$1.infer<typeof triggerBRPaymentSchema>["body"]) => Promise<TriggerBRPaymentResponse>;
 
-export { type BRPaymentItem, type BaseBookingRequest, type BookingCredit, type BookingRequest, type BookingRequestFilters, type BookingRequestStatus, type CustomPrice, type DayOpeningHours, type Days, type GeoInfo, type Include, type IncludeStation, type OpeningHours, type PaymentReceipts, type PreferredPaymentMethod, type SATBookingRequest, type SATBookingRequestStatus, type Service, type ServiceInfo, type ServiceType, type Station, type Timetable, type TriggerBRPaymentResponse, allocateVehicle, deallocateVehicle, getBookingRequestById, getBookingRequestByTrip, getBookingRequests, getSATBookingRequests, getScheduleBookingRequests, getStationById, getStations, getSubscriptionBookingRequestById, getSubscriptionBookingRequests, triggerBRPayment, updateScheduleBooking };
+declare const getBookingRequestsByUserId: (client: Client, userId: string) => Promise<BookingRequest[]>;
+
+declare const releaseBRPayment: (client: Client, bookingRequestId: UUID, pspReference: string) => Promise<SATBookingRequest>;
+
+declare const cancelBookingRequest: (client: Client, id: string) => Promise<SATBookingRequest>;
+
+export { type BRPaymentItem, type BaseBookingRequest, type BookingCredit, type BookingRequest, type BookingRequestFilters, type BookingRequestStatus, type CustomPrice, type DayOpeningHours, type Days, type GeoInfo, type Include, type IncludeStation, type OpeningHours, type PaymentReceipts, type PreferredPaymentMethod, type SATBookingRequest, type SATBookingRequestStatus, type Service, type ServiceInfo, type ServiceType, type Station, type Timetable, type TriggerBRPaymentResponse, allocateVehicle, cancelBookingRequest, deallocateVehicle, getBookingRequestById, getBookingRequestByTrip, getBookingRequests, getBookingRequestsByUserId, getSATBookingRequests, getScheduleBookingRequests, getStationById, getStations, getSubscriptionBookingRequestById, getSubscriptionBookingRequests, releaseBRPayment, triggerBRPayment, updateScheduleBooking };

package/dist/index.d.ts

@@ -261,7 +261,7 @@ declare const triggerBRPaymentSchema: z$1.ZodObject<{
         requiresActionReturnURL: z$1.ZodOptional<z$1.ZodString>;
         online: z$1.ZodBoolean;
         amountType: z$1.ZodEnum<["FIXED", "PERCENTAGE"]>;
-        amountValue: z$1.ZodOptional<z$1.ZodNumber>;
+        amountValue: z$1.ZodNumber;
         preferredPaymentMethods: z$1.ZodOptional<z$1.ZodArray<z$1.ZodObject<{
             pspReference: z$1.ZodString;
             amount: z$1.ZodDefault<z$1.ZodNumber>;
@@ -278,8 +278,8 @@ declare const triggerBRPaymentSchema: z$1.ZodObject<{
         scope: "RENTAL" | "DEPOSIT";
         online: boolean;
         amountType: "FIXED" | "PERCENTAGE";
+        amountValue: number;
         requiresActionReturnURL?: string | undefined;
-        amountValue?: number | undefined;
         preferredPaymentMethods?: {
             pspReference: string;
             amount: number;
@@ -289,8 +289,8 @@ declare const triggerBRPaymentSchema: z$1.ZodObject<{
         scope: "RENTAL" | "DEPOSIT";
         online: boolean;
         amountType: "FIXED" | "PERCENTAGE";
+        amountValue: number;
         requiresActionReturnURL?: string | undefined;
-        amountValue?: number | undefined;
         preferredPaymentMethods?: {
             pspReference: string;
             amount?: number | undefined;
@@ -302,8 +302,8 @@ declare const triggerBRPaymentSchema: z$1.ZodObject<{
         scope: "RENTAL" | "DEPOSIT";
         online: boolean;
         amountType: "FIXED" | "PERCENTAGE";
+        amountValue: number;
         requiresActionReturnURL?: string | undefined;
-        amountValue?: number | undefined;
         preferredPaymentMethods?: {
             pspReference: string;
             amount: number;
@@ -316,8 +316,8 @@ declare const triggerBRPaymentSchema: z$1.ZodObject<{
         scope: "RENTAL" | "DEPOSIT";
         online: boolean;
         amountType: "FIXED" | "PERCENTAGE";
+        amountValue: number;
         requiresActionReturnURL?: string | undefined;
-        amountValue?: number | undefined;
         preferredPaymentMethods?: {
             pspReference: string;
             amount?: number | undefined;
@@ -327,4 +327,10 @@ declare const triggerBRPaymentSchema: z$1.ZodObject<{
 }>;
 declare const triggerBRPayment: (client: Client, bookingRequestId: UUID, body: z$1.infer<typeof triggerBRPaymentSchema>["body"]) => Promise<TriggerBRPaymentResponse>;
 
-export { type BRPaymentItem, type BaseBookingRequest, type BookingCredit, type BookingRequest, type BookingRequestFilters, type BookingRequestStatus, type CustomPrice, type DayOpeningHours, type Days, type GeoInfo, type Include, type IncludeStation, type OpeningHours, type PaymentReceipts, type PreferredPaymentMethod, type SATBookingRequest, type SATBookingRequestStatus, type Service, type ServiceInfo, type ServiceType, type Station, type Timetable, type TriggerBRPaymentResponse, allocateVehicle, deallocateVehicle, getBookingRequestById, getBookingRequestByTrip, getBookingRequests, getSATBookingRequests, getScheduleBookingRequests, getStationById, getStations, getSubscriptionBookingRequestById, getSubscriptionBookingRequests, triggerBRPayment, updateScheduleBooking };
+declare const getBookingRequestsByUserId: (client: Client, userId: string) => Promise<BookingRequest[]>;
+
+declare const releaseBRPayment: (client: Client, bookingRequestId: UUID, pspReference: string) => Promise<SATBookingRequest>;
+
+declare const cancelBookingRequest: (client: Client, id: string) => Promise<SATBookingRequest>;
+
+export { type BRPaymentItem, type BaseBookingRequest, type BookingCredit, type BookingRequest, type BookingRequestFilters, type BookingRequestStatus, type CustomPrice, type DayOpeningHours, type Days, type GeoInfo, type Include, type IncludeStation, type OpeningHours, type PaymentReceipts, type PreferredPaymentMethod, type SATBookingRequest, type SATBookingRequestStatus, type Service, type ServiceInfo, type ServiceType, type Station, type Timetable, type TriggerBRPaymentResponse, allocateVehicle, cancelBookingRequest, deallocateVehicle, getBookingRequestById, getBookingRequestByTrip, getBookingRequests, getBookingRequestsByUserId, getSATBookingRequests, getScheduleBookingRequests, getStationById, getStations, getSubscriptionBookingRequestById, getSubscriptionBookingRequests, releaseBRPayment, triggerBRPayment, updateScheduleBooking };

package/dist/index.js

@@ -31,16 +31,19 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   allocateVehicle: () => allocateVehicle,
+  cancelBookingRequest: () => cancelBookingRequest,
   deallocateVehicle: () => deallocateVehicle,
   getBookingRequestById: () => getBookingRequestById,
   getBookingRequestByTrip: () => getBookingRequestByTrip,
   getBookingRequests: () => getBookingRequests,
+  getBookingRequestsByUserId: () => getBookingRequestsByUserId,
   getSATBookingRequests: () => getSATBookingRequests,
   getScheduleBookingRequests: () => getScheduleBookingRequests,
   getStationById: () => getStationById,
   getStations: () => getStations,
   getSubscriptionBookingRequestById: () => getSubscriptionBookingRequestById,
   getSubscriptionBookingRequests: () => getSubscriptionBookingRequests,
+  releaseBRPayment: () => releaseBRPayment,
   triggerBRPayment: () => triggerBRPayment,
   updateScheduleBooking: () => updateScheduleBooking
 });
@@ -509,7 +512,7 @@ var triggerBRPaymentSchema = import_zod9.default.object({
     requiresActionReturnURL: import_zod9.default.string().url().optional(),
     online: import_zod9.default.boolean(),
     amountType: import_zod9.default.enum(["FIXED", "PERCENTAGE"]),
-    amountValue: import_zod9.default.number().nonnegative().optional(),
+    amountValue: import_zod9.default.number().nonnegative(),
     preferredPaymentMethods: import_zod9.default.array(
       import_zod9.default.object({
         pspReference: import_zod9.default.string(),
@@ -535,19 +538,89 @@ var triggerBRPayment = async (client, bookingRequestId, body) => {
     });
   });
 };
+
+// src/getBookingRequestsByUserId.ts
+var import_zod10 = require("zod");
+var schema2 = import_zod10.z.object({
+  userId: import_zod10.z.string().trim().min(1).uuid()
+});
+var getBookingRequestsByUserId = async (client, userId) => {
+  const result = schema2.safeParse({ userId });
+  if (!result.success) {
+    throw new TypeError("Invalid userId", {
+      cause: result.error.issues
+    });
+  }
+  return client.get(
+    `/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/bookingrequests/users/${userId}`
+  ).then(({ data }) => data).catch((error) => {
+    if (error.formattedError?.status === 404) {
+      return [];
+    }
+    throw error;
+  });
+};
+
+// src/releaseBRPayment.ts
+var import_zod11 = __toESM(require("zod"));
+var releaseBRPaymentSchema = import_zod11.default.object({
+  bookingRequestId: import_zod11.default.string().uuid(),
+  pspReference: import_zod11.default.string().uuid()
+});
+var releaseBRPayment = async (client, bookingRequestId, pspReference) => {
+  const resultPayload = releaseBRPaymentSchema.safeParse({ bookingRequestId, pspReference });
+  if (!resultPayload.success) {
+    throw new TypeError("Invalid args", {
+      cause: resultPayload.error.issues
+    });
+  }
+  return client.post(
+    `boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/bookingrequests/${bookingRequestId}/paymentintent/${pspReference}/cancel`,
+    {}
+  ).then(({ data }) => data).catch((error) => {
+    throw new TypeError("Failed to release booking request payment", {
+      cause: error
+    });
+  });
+};
+
+// src/cancelBookingRequest.ts
+var import_zod12 = __toESM(require("zod"));
+var schema3 = import_zod12.default.object({
+  id: import_zod12.default.string().uuid()
+});
+var cancelBookingRequest = async (client, id) => {
+  const result = schema3.safeParse({ id });
+  if (!result.success) {
+    throw new TypeError("Invalid args", {
+      cause: result.error.issues
+    });
+  }
+  return client.post(
+    `/boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/bookingrequests/cancel/${id}`,
+    {}
+  ).then(({ data }) => data).catch((error) => {
+    throw new TypeError("Failed to cancel booking request", {
+      cause: error
+    });
+  });
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   allocateVehicle,
+  cancelBookingRequest,
   deallocateVehicle,
   getBookingRequestById,
   getBookingRequestByTrip,
   getBookingRequests,
+  getBookingRequestsByUserId,
   getSATBookingRequests,
   getScheduleBookingRequests,
   getStationById,
   getStations,
   getSubscriptionBookingRequestById,
   getSubscriptionBookingRequests,
+  releaseBRPayment,
   triggerBRPayment,
   updateScheduleBooking
 });

package/dist/index.mjs

@@ -461,7 +461,7 @@ var triggerBRPaymentSchema = z9.object({
     requiresActionReturnURL: z9.string().url().optional(),
     online: z9.boolean(),
     amountType: z9.enum(["FIXED", "PERCENTAGE"]),
-    amountValue: z9.number().nonnegative().optional(),
+    amountValue: z9.number().nonnegative(),
     preferredPaymentMethods: z9.array(
       z9.object({
         pspReference: z9.string(),
@@ -487,18 +487,88 @@ var triggerBRPayment = async (client, bookingRequestId, body) => {
     });
   });
 };
+
+// src/getBookingRequestsByUserId.ts
+import { z as z10 } from "zod";
+var schema2 = z10.object({
+  userId: z10.string().trim().min(1).uuid()
+});
+var getBookingRequestsByUserId = async (client, userId) => {
+  const result = schema2.safeParse({ userId });
+  if (!result.success) {
+    throw new TypeError("Invalid userId", {
+      cause: result.error.issues
+    });
+  }
+  return client.get(
+    `/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/bookingrequests/users/${userId}`
+  ).then(({ data }) => data).catch((error) => {
+    if (error.formattedError?.status === 404) {
+      return [];
+    }
+    throw error;
+  });
+};
+
+// src/releaseBRPayment.ts
+import z11 from "zod";
+var releaseBRPaymentSchema = z11.object({
+  bookingRequestId: z11.string().uuid(),
+  pspReference: z11.string().uuid()
+});
+var releaseBRPayment = async (client, bookingRequestId, pspReference) => {
+  const resultPayload = releaseBRPaymentSchema.safeParse({ bookingRequestId, pspReference });
+  if (!resultPayload.success) {
+    throw new TypeError("Invalid args", {
+      cause: resultPayload.error.issues
+    });
+  }
+  return client.post(
+    `boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/bookingrequests/${bookingRequestId}/paymentintent/${pspReference}/cancel`,
+    {}
+  ).then(({ data }) => data).catch((error) => {
+    throw new TypeError("Failed to release booking request payment", {
+      cause: error
+    });
+  });
+};
+
+// src/cancelBookingRequest.ts
+import z12 from "zod";
+var schema3 = z12.object({
+  id: z12.string().uuid()
+});
+var cancelBookingRequest = async (client, id) => {
+  const result = schema3.safeParse({ id });
+  if (!result.success) {
+    throw new TypeError("Invalid args", {
+      cause: result.error.issues
+    });
+  }
+  return client.post(
+    `/boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/bookingrequests/cancel/${id}`,
+    {}
+  ).then(({ data }) => data).catch((error) => {
+    throw new TypeError("Failed to cancel booking request", {
+      cause: error
+    });
+  });
+};
 export {
   allocateVehicle,
+  cancelBookingRequest,
   deallocateVehicle,
   getBookingRequestById,
   getBookingRequestByTrip,
   getBookingRequests,
+  getBookingRequestsByUserId,
   getSATBookingRequests,
   getScheduleBookingRequests,
   getStationById,
   getStations,
   getSubscriptionBookingRequestById,
   getSubscriptionBookingRequests,
+  releaseBRPayment,
   triggerBRPayment,
   updateScheduleBooking
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@vulog/aima-booking",
-    "version": "1.2.22",
+    "version": "1.2.25",
     "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.2.22",
-        "@vulog/aima-core": "1.2.22"
+        "@vulog/aima-client": "1.2.25",
+        "@vulog/aima-core": "1.2.25"
     },
     "peerDependencies": {
         "es-toolkit": "^1.39.9",

package/src/cancelBookingRequest.test.ts

@@ -0,0 +1,122 @@
+import { describe, test, expect, vi, beforeEach } from 'vitest';
+import { Client } from '@vulog/aima-client';
+import { randomUUID } from 'crypto';
+import { cancelBookingRequest } from './cancelBookingRequest';
+import type { SATBookingRequest } from './types';
+
+describe('cancelBookingRequest', () => {
+    const postMock = vi.fn();
+    const client = {
+        post: postMock,
+        clientOptions: {
+            fleetId: 'FLEET_ID',
+        },
+    } as unknown as Client;
+
+    const minimalCancelledResponse = {
+        id: '09c6daa5-9b4d-471c-8d2d-627d2ce7902d',
+        startDate: '2026-02-17T15:15:00Z',
+        endDate: '2026-02-19T15:15:00Z',
+        returnedDate: null,
+        profileId: '9cf8f71b-a535-4b26-b6bd-2b9856cd1cbc',
+        vehicleId: null,
+        modelId: 2597,
+        journeyId: null,
+        station: '37a505b8-a45e-4970-9adc-3bb6f177a868',
+        profileType: null,
+        entityName: null,
+        status: 'CANCELLED',
+        creationDate: '2026-02-13T14:12:04Z',
+        realStartDate: null,
+        cancellationDate: '2026-02-16T12:32:09Z',
+        cancelledBy: 'b60db6f0-67d3-4beb-a835-d7bc32f448c2',
+        fleetId: 'FLEET_ID',
+        userId: 'e2a19a00-87de-4e3e-8da3-6053cb137c47',
+        latitude: 0,
+        longitude: 0,
+        radius: 0,
+        serviceId: '3ef72482-94c1-40c0-a467-abffaef03d45',
+        warning: null,
+        email: null,
+        credits: null,
+        requiresActionReturnURL: null,
+        trip: null,
+        failureReason: null,
+        cityId: 'a91a8d56-4bf8-4a88-9afb-3f3cc255e4f8',
+        vehicleResidualValue: null,
+        price: null,
+        notes: null,
+        plannedReturnDate: null,
+        deliveryAddress: null,
+        deliveryAddressAdditionalInfo: null,
+        deliveryCity: null,
+        deliveryPostalCode: null,
+        dropOffStation: null,
+        thresholdDateLimit: null,
+        cancellationFeeAmount: null,
+        rollingContract: false,
+        planDurationInMonths: null,
+        planName: null,
+        parentId: null,
+        contractType: null,
+        previous: null,
+        customPrice: null,
+        productIds: ['f271997b-1184-429d-b951-bde23c1e2711'],
+        preallocatedVehicleId: null,
+        bookingReferenceId: 'p9JNDE',
+        pricingDetails: [
+            { pricingId: '0c5363cf-2763-4df7-92e4-1d66b04fc186', providerType: 'DEFAULT' },
+        ],
+        earlyCancelledByUser: false,
+        completed: false,
+    } as unknown as SATBookingRequest;
+
+    beforeEach(() => {
+        postMock.mockReset();
+    });
+
+    test('throws Invalid args when id is not a valid UUID', async () => {
+        await expect(cancelBookingRequest(client, 'not-a-uuid')).rejects.toThrow(TypeError);
+        await expect(cancelBookingRequest(client, 'not-a-uuid')).rejects.toMatchObject({
+            message: 'Invalid args',
+        });
+        expect(postMock).not.toHaveBeenCalled();
+    });
+
+    test('calls POST with correct URL and empty body and returns data', async () => {
+        const id = randomUUID();
+        postMock.mockResolvedValueOnce({ data: minimalCancelledResponse });
+
+        const result = await cancelBookingRequest(client, id);
+
+        expect(postMock).toHaveBeenCalledTimes(1);
+        expect(postMock).toHaveBeenCalledWith(
+            `/boapi/proxy/user/scheduledBooking/fleets/FLEET_ID/bookingrequests/cancel/${id}`,
+            {}
+        );
+        expect(result).toEqual(minimalCancelledResponse);
+        expect(result.status).toBe('CANCELLED');
+    });
+
+    test('throws when client.post rejects', async () => {
+        const id = randomUUID();
+        const networkError = new Error('Network error');
+        postMock.mockRejectedValueOnce(networkError);
+
+        let thrown: unknown;
+        try {
+            await cancelBookingRequest(client, id);
+        } catch (e) {
+            thrown = e;
+        }
+        expect(thrown).toBeDefined();
+        const err = thrown as Error & { cause?: unknown };
+        expect(err instanceof Error).toBe(true);
+        const isWrapped =
+            err.name === 'TypeError' &&
+            err.message === 'Failed to cancel booking request' &&
+            err.cause === networkError;
+        const isPropagated = err.message === 'Network error';
+        expect(isWrapped || isPropagated).toBe(true);
+    });
+});

package/src/cancelBookingRequest.ts

@@ -0,0 +1,28 @@
+import { Client } from '@vulog/aima-client';
+import z from 'zod';
+
+import { SATBookingRequest } from './types';
+
+const schema = z.object({
+    id: z.string().uuid(),
+});
+
+export const cancelBookingRequest = async (client: Client, id: string): Promise<SATBookingRequest> => {
+    const result = schema.safeParse({ id });
+    if (!result.success) {
+        throw new TypeError('Invalid args', {
+            cause: result.error.issues,
+        });
+    }
+    return client
+        .post<SATBookingRequest>(
+            `/boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/bookingrequests/cancel/${id}`,
+            {}
+        )
+        .then(({ data }) => data)
+        .catch((error) => {
+            throw new TypeError('Failed to cancel booking request', {
+                cause: error,
+            });
+        });
+};

package/src/getBookingRequestsByUserId.test.ts

@@ -0,0 +1,102 @@
+import { describe, test, expect, vi, beforeEach } from 'vitest';
+import { getBookingRequestsByUserId } from './getBookingRequestsByUserId';
+import { Client } from '@vulog/aima-client';
+import { randomUUID } from 'crypto';
+
+describe('getBookingRequestsByUserId', () => {
+    const getMock = vi.fn();
+    const client = {
+        get: getMock,
+        clientOptions: {
+            fleetId: 'FLEET_ID',
+        },
+    } as unknown as Client;
+
+    beforeEach(() => {
+        getMock.mockReset();
+    });
+
+    test('invalid userId (empty string)', async () => {
+        const rejects = expect(() => getBookingRequestsByUserId(client, '')).rejects;
+        await rejects.toThrow(TypeError);
+        await rejects.toThrow('Invalid userId');
+        await rejects.toSatisfy((error: Error & { cause?: unknown }) => {
+            expect(error).toHaveProperty('cause');
+            return true;
+        });
+    });
+
+    test('invalid userId (not a UUID)', async () => {
+        const rejects = expect(() => getBookingRequestsByUserId(client, 'not-a-uuid')).rejects;
+        await rejects.toThrow(TypeError);
+        await rejects.toThrow('Invalid userId');
+        await rejects.toSatisfy((error: Error & { cause?: unknown }) => {
+            expect(error).toHaveProperty('cause');
+            const issues = error.cause as Array<{ code?: string }>;
+            expect(issues?.some((e) => e.code === 'invalid_string')).toBe(true);
+            return true;
+        });
+    });
+
+    test('invalid userId (whitespace only)', async () => {
+        const rejects = expect(() => getBookingRequestsByUserId(client, '   ')).rejects;
+        await rejects.toThrow(TypeError);
+        await rejects.toThrow('Invalid userId');
+    });
+
+    test('call returns booking requests', async () => {
+        const userId = randomUUID();
+        const data = [
+            {
+                id: randomUUID(),
+                status: 'CONFIRMED',
+                creationDate: '2024-11-14T13:27:30Z',
+                fleetId: 'VULOG-FRNCE',
+                userId,
+                cityId: 'a91a8d56-4bf8-4a88-9afb-3f3cc255e4f8',
+                completed: false,
+            },
+        ];
+        getMock.mockResolvedValueOnce({ data });
+
+        const result = await getBookingRequestsByUserId(client, userId);
+
+        expect(getMock).toHaveBeenCalledWith(
+            `/user/scheduledBooking/fleets/FLEET_ID/bookingrequests/users/${userId}`
+        );
+        expect(result).toEqual(data);
+    });
+
+    test('call with valid UUID returns empty array when 404', async () => {
+        const userId = randomUUID();
+        getMock.mockRejectedValueOnce({
+            formattedError: { status: 404 },
+        });
+
+        const result = await getBookingRequestsByUserId(client, userId);
+
+        expect(getMock).toHaveBeenCalledWith(
+            `/user/scheduledBooking/fleets/FLEET_ID/bookingrequests/users/${userId}`
+        );
+        expect(result).toEqual([]);
+    });
+
+    test('rethrows on non-404 error', async () => {
+        const userId = randomUUID();
+        const err = new Error('Network error');
+        getMock.mockRejectedValueOnce(err);
+
+        await expect(getBookingRequestsByUserId(client, userId)).rejects.toThrow('Network error');
+    });
+
+    test('rethrows when formattedError status is not 404', async () => {
+        const userId = randomUUID();
+        getMock.mockRejectedValueOnce({
+            formattedError: { status: 500 },
+        });
+
+        await expect(getBookingRequestsByUserId(client, userId)).rejects.toMatchObject({
+            formattedError: { status: 500 },
+        });
+    });
+});

package/src/getBookingRequestsByUserId.ts

@@ -0,0 +1,28 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { BookingRequest } from './types';
+
+const schema = z.object({
+    userId: z.string().trim().min(1).uuid(),
+});
+
+export const getBookingRequestsByUserId = async (client: Client, userId: string): Promise<BookingRequest[]> => {
+    const result = schema.safeParse({ userId });
+    if (!result.success) {
+        throw new TypeError('Invalid userId', {
+            cause: result.error.issues,
+        });
+    }
+    return client
+        .get<BookingRequest[]>(
+            `/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/bookingrequests/users/${userId}`
+        )
+        .then(({ data }) => data)
+        .catch((error) => {
+            if (error.formattedError?.status === 404) {
+                return [];
+            }
+            throw error;
+        });
+};

package/src/index.ts

@@ -12,3 +12,6 @@ export { allocateVehicle } from './allocateVehicle';
 export { deallocateVehicle } from './deallocateVehicle';
 export { updateScheduleBooking } from './updateScheduleBooking';
 export { triggerBRPayment } from './triggerBRPayment';
+export { getBookingRequestsByUserId } from './getBookingRequestsByUserId';
+export { releaseBRPayment } from './releaseBRPayment';
+export { cancelBookingRequest } from './cancelBookingRequest';

package/src/releaseBRPayment.test.ts

@@ -0,0 +1,135 @@
+import { describe, test, expect, vi, beforeEach } from 'vitest';
+import { Client } from '@vulog/aima-client';
+import { randomUUID } from 'crypto';
+import { releaseBRPayment } from './releaseBRPayment';
+import type { SATBookingRequest } from './types';
+
+describe('releaseBRPayment', () => {
+    const postMock = vi.fn();
+    const client = {
+        post: postMock,
+        clientOptions: {
+            fleetId: 'FLEET_ID',
+        },
+    } as unknown as Client;
+
+    const minimalResponse = {
+        id: randomUUID(),
+        startDate: '2026-02-17T15:15:00Z',
+        endDate: '2026-02-19T15:15:00Z',
+        returnedDate: null,
+        profileId: '9cf8f71b-a535-4b26-b6bd-2b9856cd1cbc',
+        vehicleId: null,
+        modelId: 2597,
+        journeyId: null,
+        station: '37a505b8-a45e-4970-9adc-3bb6f177a868',
+        profileType: null,
+        entityName: null,
+        status: 'CONFIRMED',
+        creationDate: '2026-02-13T14:12:04Z',
+        realStartDate: null,
+        cancellationDate: null,
+        cancelledBy: null,
+        fleetId: 'FLEET_ID',
+        userId: 'e2a19a00-87de-4e3e-8da3-6053cb137c47',
+        latitude: 0,
+        longitude: 0,
+        radius: 0,
+        serviceId: '3ef72482-94c1-40c0-a467-abffaef03d45',
+        warning: null,
+        email: null,
+        credits: null,
+        requiresActionReturnURL: null,
+        trip: null,
+        failureReason: null,
+        cityId: 'a91a8d56-4bf8-4a88-9afb-3f3cc255e4f8',
+        vehicleResidualValue: null,
+        price: null,
+        notes: null,
+        plannedReturnDate: null,
+        deliveryAddress: null,
+        deliveryAddressAdditionalInfo: null,
+        deliveryCity: null,
+        deliveryPostalCode: null,
+        dropOffStation: null,
+        thresholdDateLimit: null,
+        cancellationFeeAmount: null,
+        rollingContract: false,
+        planDurationInMonths: null,
+        planName: null,
+        parentId: null,
+        contractType: null,
+        previous: null,
+        customPrice: null,
+        productIds: ['f271997b-1184-429d-b951-bde23c1e2711'],
+        preallocatedVehicleId: null,
+        bookingReferenceId: 'p9JNDE',
+        pricingDetails: [
+            { pricingId: '0c5363cf-2763-4df7-92e4-1d66b04fc186', providerType: 'DEFAULT' },
+        ],
+        earlyCancelledByUser: false,
+        completed: false,
+    } as unknown as SATBookingRequest;
+
+    beforeEach(() => {
+        postMock.mockReset();
+    });
+
+    test('throws Invalid args when bookingRequestId is not a valid UUID', async () => {
+        await expect(
+            releaseBRPayment(client, 'not-a-uuid' as any, randomUUID())
+        ).rejects.toThrow(TypeError);
+        await expect(
+            releaseBRPayment(client, 'not-a-uuid' as any, randomUUID())
+        ).rejects.toMatchObject({ message: 'Invalid args' });
+        expect(postMock).not.toHaveBeenCalled();
+    });
+
+    test('throws Invalid args when pspReference is not a valid UUID', async () => {
+        await expect(
+            releaseBRPayment(client, randomUUID(), 'not-a-uuid')
+        ).rejects.toThrow(TypeError);
+        await expect(
+            releaseBRPayment(client, randomUUID(), 'not-a-uuid')
+        ).rejects.toMatchObject({ message: 'Invalid args' });
+        expect(postMock).not.toHaveBeenCalled();
+    });
+
+    test('calls POST with correct URL and empty body and returns data', async () => {
+        const bookingRequestId = randomUUID();
+        const pspReference = randomUUID();
+        postMock.mockResolvedValueOnce({ data: minimalResponse });
+
+        const result = await releaseBRPayment(client, bookingRequestId, pspReference);
+
+        expect(postMock).toHaveBeenCalledTimes(1);
+        expect(postMock).toHaveBeenCalledWith(
+            `boapi/proxy/user/scheduledBooking/fleets/FLEET_ID/bookingrequests/${bookingRequestId}/paymentintent/${pspReference}/cancel`,
+            {}
+        );
+        expect(result).toEqual(minimalResponse);
+    });
+
+    test('throws when client.post rejects', async () => {
+        const bookingRequestId = randomUUID();
+        const pspReference = randomUUID();
+        const networkError = new Error('Network error');
+        postMock.mockRejectedValueOnce(networkError);
+
+        let thrown: unknown;
+        try {
+            await releaseBRPayment(client, bookingRequestId, pspReference);
+        } catch (e) {
+            thrown = e;
+        }
+        expect(thrown).toBeDefined();
+        const err = thrown as Error & { cause?: unknown };
+        expect(err instanceof Error).toBe(true);
+        const isWrapped =
+            err.name === 'TypeError' &&
+            err.message === 'Failed to release booking request payment' &&
+            err.cause === networkError;
+        const isPropagated = err.message === 'Network error';
+        expect(isWrapped || isPropagated).toBe(true);
+    });
+});

package/src/releaseBRPayment.ts

@@ -0,0 +1,38 @@
+// /scheduledBooking/fleets/{fleetId}/bookingrequests/{id}/paymentintent/{pspReference}/cancel
+
+import { UUID } from 'crypto';
+
+import { Client } from '@vulog/aima-client';
+
+import z from 'zod';
+
+import { SATBookingRequest } from './types';
+
+const releaseBRPaymentSchema = z.object({
+    bookingRequestId: z.string().uuid(),
+    pspReference: z.string().uuid(),
+});
+
+export const releaseBRPayment = async (
+    client: Client,
+    bookingRequestId: UUID,
+    pspReference: string
+): Promise<SATBookingRequest> => {
+    const resultPayload = releaseBRPaymentSchema.safeParse({ bookingRequestId, pspReference });
+    if (!resultPayload.success) {
+        throw new TypeError('Invalid args', {
+            cause: resultPayload.error.issues,
+        });
+    }
+    return client
+        .post<SATBookingRequest>(
+            `boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/bookingrequests/${bookingRequestId}/paymentintent/${pspReference}/cancel`,
+            {}
+        )
+        .then(({ data }) => data)
+        .catch((error) => {
+            throw new TypeError('Failed to release booking request payment', {
+                cause: error,
+            });
+        });
+};

package/src/triggerBRPayment.ts

@@ -13,7 +13,7 @@ const triggerBRPaymentSchema = z.object({
         requiresActionReturnURL: z.string().url().optional(),
         online: z.boolean(),
         amountType: z.enum(['FIXED', 'PERCENTAGE']),
-        amountValue: z.number().nonnegative().optional(),
+        amountValue: z.number().nonnegative(),
         preferredPaymentMethods: z
             .array(
                 z.object({