@vulog/aima-booking 1.2.21 → 1.2.23

package/dist/index.d.mts

@@ -1,6 +1,6 @@
 import { Client } from '@vulog/aima-client';
 import { PaginableOptions, PaginableResponse } from '@vulog/aima-core';
-import { z } from 'zod';
+import z$1, { z } from 'zod';
 import { UUID } from 'crypto';
 
 type PaymentReceipts = {
@@ -18,6 +18,51 @@ type PaymentReceipts = {
         scope: string;
     };
 };
+/** Payment intent or receipt item as returned by trigger BR payment (and similar payment endpoints). */
+type BRPaymentItem = {
+    id: string;
+    pspName: string;
+    pspReference: string;
+    pspPublishableKey: string;
+    amount: number;
+    currency: string;
+    date: string;
+    captureBefore: string;
+    status: string;
+    paymentMethodType: string;
+    paymentMethodPspReference: string;
+    paymentIntentPspReference: string;
+    number: number;
+    code?: string;
+    declineCode?: string;
+    pspClientSecret?: string;
+    reason?: string;
+    note?: string;
+    nextAction?: {
+        nextActionRedirectUrl: {
+            url: string;
+            method: string;
+            data: Record<string, string>;
+        };
+        type: string;
+    };
+    metadatas: Record<string, string>;
+};
+/** Credit entry in a booking request (e.g. trigger BR payment response). */
+type BookingCredit = {
+    id: string;
+    fleetId: string;
+    amount: number;
+    availableAmount: number;
+    status: string;
+    walletId: string;
+    date: string;
+};
+/** Preferred payment method entry in request/response. */
+type PreferredPaymentMethod = {
+    pspReference: string;
+    amount: number;
+};
 type CustomPrice = {
     id: string;
     fleetId: string;
@@ -105,6 +150,13 @@ type SATBookingRequest = BaseBookingRequest & {
     trip: any | null;
     warning: string | null;
 };
+/** Response of the trigger BR payment endpoint (booking request + payment intents/receipts). */
+type TriggerBRPaymentResponse = Omit<SATBookingRequest, 'credits'> & {
+    paymentIntents: BRPaymentItem[];
+    paymentReceipts: BRPaymentItem[];
+    credits: BookingCredit[];
+    preferredPaymentMethods?: PreferredPaymentMethod[];
+};
 type GeoInfo = {
     name: string;
     coordinates: {
@@ -147,7 +199,7 @@ type Station = Partial<GeoInfo> & Partial<ServiceInfo> & {
     [key: string]: any;
 };
 
-declare const BookingRequestStatusSchema: z.ZodEnum<["ALERT", "UPCOMING", "ONGOING", "COMPLETED", "CANCELLED", "PENDING_APPROVAL"]>;
+declare const BookingRequestStatusSchema: z.ZodEnum<["ALERT", "UPCOMING", "ONGOING", "COMPLETED", "CANCELLED", "PENDING_APPROVAL", "CONFIRMED", "PENDING", "LATE"]>;
 type BookingRequestStatus = z.infer<typeof BookingRequestStatusSchema>;
 declare const ServiceTypeSchema: z.ZodEnum<["SUBSCRIPTION", "ROUND_TRIP_BOOKING", "SCHEDULED_BOOKING_STATION"]>;
 type ServiceType = z.infer<typeof ServiceTypeSchema>;
@@ -202,4 +254,77 @@ declare const deallocateVehicle: (client: Client, bookingRequestId: UUID, vehicl
 
 declare const updateScheduleBooking: (client: Client, bookingRequestId: string, updateData: Record<string, unknown>) => 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, updateScheduleBooking };
+declare const triggerBRPaymentSchema: z$1.ZodObject<{
+    bookingRequestId: z$1.ZodString;
+    body: z$1.ZodObject<{
+        scope: z$1.ZodEnum<["RENTAL", "DEPOSIT"]>;
+        requiresActionReturnURL: z$1.ZodOptional<z$1.ZodString>;
+        online: z$1.ZodBoolean;
+        amountType: z$1.ZodEnum<["FIXED", "PERCENTAGE"]>;
+        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>;
+        }, "strip", z$1.ZodTypeAny, {
+            pspReference: string;
+            amount: number;
+        }, {
+            pspReference: string;
+            amount?: number | undefined;
+        }>, "many">>;
+        profileId: z$1.ZodString;
+    }, "strip", z$1.ZodTypeAny, {
+        profileId: string;
+        scope: "RENTAL" | "DEPOSIT";
+        online: boolean;
+        amountType: "FIXED" | "PERCENTAGE";
+        amountValue: number;
+        requiresActionReturnURL?: string | undefined;
+        preferredPaymentMethods?: {
+            pspReference: string;
+            amount: number;
+        }[] | undefined;
+    }, {
+        profileId: string;
+        scope: "RENTAL" | "DEPOSIT";
+        online: boolean;
+        amountType: "FIXED" | "PERCENTAGE";
+        amountValue: number;
+        requiresActionReturnURL?: string | undefined;
+        preferredPaymentMethods?: {
+            pspReference: string;
+            amount?: number | undefined;
+        }[] | undefined;
+    }>;
+}, "strip", z$1.ZodTypeAny, {
+    body: {
+        profileId: string;
+        scope: "RENTAL" | "DEPOSIT";
+        online: boolean;
+        amountType: "FIXED" | "PERCENTAGE";
+        amountValue: number;
+        requiresActionReturnURL?: string | undefined;
+        preferredPaymentMethods?: {
+            pspReference: string;
+            amount: number;
+        }[] | undefined;
+    };
+    bookingRequestId: string;
+}, {
+    body: {
+        profileId: string;
+        scope: "RENTAL" | "DEPOSIT";
+        online: boolean;
+        amountType: "FIXED" | "PERCENTAGE";
+        amountValue: number;
+        requiresActionReturnURL?: string | undefined;
+        preferredPaymentMethods?: {
+            pspReference: string;
+            amount?: number | undefined;
+        }[] | undefined;
+    };
+    bookingRequestId: string;
+}>;
+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 };

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { Client } from '@vulog/aima-client';
 import { PaginableOptions, PaginableResponse } from '@vulog/aima-core';
-import { z } from 'zod';
+import z$1, { z } from 'zod';
 import { UUID } from 'crypto';
 
 type PaymentReceipts = {
@@ -18,6 +18,51 @@ type PaymentReceipts = {
         scope: string;
     };
 };
+/** Payment intent or receipt item as returned by trigger BR payment (and similar payment endpoints). */
+type BRPaymentItem = {
+    id: string;
+    pspName: string;
+    pspReference: string;
+    pspPublishableKey: string;
+    amount: number;
+    currency: string;
+    date: string;
+    captureBefore: string;
+    status: string;
+    paymentMethodType: string;
+    paymentMethodPspReference: string;
+    paymentIntentPspReference: string;
+    number: number;
+    code?: string;
+    declineCode?: string;
+    pspClientSecret?: string;
+    reason?: string;
+    note?: string;
+    nextAction?: {
+        nextActionRedirectUrl: {
+            url: string;
+            method: string;
+            data: Record<string, string>;
+        };
+        type: string;
+    };
+    metadatas: Record<string, string>;
+};
+/** Credit entry in a booking request (e.g. trigger BR payment response). */
+type BookingCredit = {
+    id: string;
+    fleetId: string;
+    amount: number;
+    availableAmount: number;
+    status: string;
+    walletId: string;
+    date: string;
+};
+/** Preferred payment method entry in request/response. */
+type PreferredPaymentMethod = {
+    pspReference: string;
+    amount: number;
+};
 type CustomPrice = {
     id: string;
     fleetId: string;
@@ -105,6 +150,13 @@ type SATBookingRequest = BaseBookingRequest & {
     trip: any | null;
     warning: string | null;
 };
+/** Response of the trigger BR payment endpoint (booking request + payment intents/receipts). */
+type TriggerBRPaymentResponse = Omit<SATBookingRequest, 'credits'> & {
+    paymentIntents: BRPaymentItem[];
+    paymentReceipts: BRPaymentItem[];
+    credits: BookingCredit[];
+    preferredPaymentMethods?: PreferredPaymentMethod[];
+};
 type GeoInfo = {
     name: string;
     coordinates: {
@@ -147,7 +199,7 @@ type Station = Partial<GeoInfo> & Partial<ServiceInfo> & {
     [key: string]: any;
 };
 
-declare const BookingRequestStatusSchema: z.ZodEnum<["ALERT", "UPCOMING", "ONGOING", "COMPLETED", "CANCELLED", "PENDING_APPROVAL"]>;
+declare const BookingRequestStatusSchema: z.ZodEnum<["ALERT", "UPCOMING", "ONGOING", "COMPLETED", "CANCELLED", "PENDING_APPROVAL", "CONFIRMED", "PENDING", "LATE"]>;
 type BookingRequestStatus = z.infer<typeof BookingRequestStatusSchema>;
 declare const ServiceTypeSchema: z.ZodEnum<["SUBSCRIPTION", "ROUND_TRIP_BOOKING", "SCHEDULED_BOOKING_STATION"]>;
 type ServiceType = z.infer<typeof ServiceTypeSchema>;
@@ -202,4 +254,77 @@ declare const deallocateVehicle: (client: Client, bookingRequestId: UUID, vehicl
 
 declare const updateScheduleBooking: (client: Client, bookingRequestId: string, updateData: Record<string, unknown>) => 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, updateScheduleBooking };
+declare const triggerBRPaymentSchema: z$1.ZodObject<{
+    bookingRequestId: z$1.ZodString;
+    body: z$1.ZodObject<{
+        scope: z$1.ZodEnum<["RENTAL", "DEPOSIT"]>;
+        requiresActionReturnURL: z$1.ZodOptional<z$1.ZodString>;
+        online: z$1.ZodBoolean;
+        amountType: z$1.ZodEnum<["FIXED", "PERCENTAGE"]>;
+        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>;
+        }, "strip", z$1.ZodTypeAny, {
+            pspReference: string;
+            amount: number;
+        }, {
+            pspReference: string;
+            amount?: number | undefined;
+        }>, "many">>;
+        profileId: z$1.ZodString;
+    }, "strip", z$1.ZodTypeAny, {
+        profileId: string;
+        scope: "RENTAL" | "DEPOSIT";
+        online: boolean;
+        amountType: "FIXED" | "PERCENTAGE";
+        amountValue: number;
+        requiresActionReturnURL?: string | undefined;
+        preferredPaymentMethods?: {
+            pspReference: string;
+            amount: number;
+        }[] | undefined;
+    }, {
+        profileId: string;
+        scope: "RENTAL" | "DEPOSIT";
+        online: boolean;
+        amountType: "FIXED" | "PERCENTAGE";
+        amountValue: number;
+        requiresActionReturnURL?: string | undefined;
+        preferredPaymentMethods?: {
+            pspReference: string;
+            amount?: number | undefined;
+        }[] | undefined;
+    }>;
+}, "strip", z$1.ZodTypeAny, {
+    body: {
+        profileId: string;
+        scope: "RENTAL" | "DEPOSIT";
+        online: boolean;
+        amountType: "FIXED" | "PERCENTAGE";
+        amountValue: number;
+        requiresActionReturnURL?: string | undefined;
+        preferredPaymentMethods?: {
+            pspReference: string;
+            amount: number;
+        }[] | undefined;
+    };
+    bookingRequestId: string;
+}, {
+    body: {
+        profileId: string;
+        scope: "RENTAL" | "DEPOSIT";
+        online: boolean;
+        amountType: "FIXED" | "PERCENTAGE";
+        amountValue: number;
+        requiresActionReturnURL?: string | undefined;
+        preferredPaymentMethods?: {
+            pspReference: string;
+            amount?: number | undefined;
+        }[] | undefined;
+    };
+    bookingRequestId: string;
+}>;
+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 };

package/dist/index.js

@@ -41,6 +41,7 @@ __export(index_exports, {
   getStations: () => getStations,
   getSubscriptionBookingRequestById: () => getSubscriptionBookingRequestById,
   getSubscriptionBookingRequests: () => getSubscriptionBookingRequests,
+  triggerBRPayment: () => triggerBRPayment,
   updateScheduleBooking: () => updateScheduleBooking
 });
 module.exports = __toCommonJS(index_exports);
@@ -55,7 +56,10 @@ var BookingRequestStatusSchema = import_zod.z.enum([
   "ONGOING",
   "COMPLETED",
   "CANCELLED",
-  "PENDING_APPROVAL"
+  "PENDING_APPROVAL",
+  "CONFIRMED",
+  "PENDING",
+  "LATE"
 ]);
 var ServiceTypeSchema = import_zod.z.enum(["SUBSCRIPTION", "ROUND_TRIP_BOOKING", "SCHEDULED_BOOKING_STATION"]);
 var getBookingRequests = async (client, status, options) => {
@@ -495,6 +499,42 @@ var updateScheduleBooking = async (client, bookingRequestId, updateData) => {
     updateData
   ).then(({ data }) => data);
 };
+
+// src/triggerBRPayment.ts
+var import_zod9 = __toESM(require("zod"));
+var triggerBRPaymentSchema = import_zod9.default.object({
+  bookingRequestId: import_zod9.default.string().uuid(),
+  body: import_zod9.default.object({
+    scope: import_zod9.default.enum(["RENTAL", "DEPOSIT"]),
+    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(),
+    preferredPaymentMethods: import_zod9.default.array(
+      import_zod9.default.object({
+        pspReference: import_zod9.default.string(),
+        amount: import_zod9.default.number().default(0)
+      })
+    ).optional(),
+    profileId: import_zod9.default.string().uuid()
+  })
+});
+var triggerBRPayment = async (client, bookingRequestId, body) => {
+  const resultPayload = triggerBRPaymentSchema.safeParse({ bookingRequestId, body });
+  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}/payment`,
+    resultPayload.data.body
+  ).then(({ data }) => data).catch((error) => {
+    throw new TypeError("Failed to trigger booking request payment", {
+      cause: error
+    });
+  });
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   allocateVehicle,
@@ -508,5 +548,6 @@ var updateScheduleBooking = async (client, bookingRequestId, updateData) => {
   getStations,
   getSubscriptionBookingRequestById,
   getSubscriptionBookingRequests,
+  triggerBRPayment,
   updateScheduleBooking
 });

package/dist/index.mjs

@@ -8,7 +8,10 @@ var BookingRequestStatusSchema = z.enum([
   "ONGOING",
   "COMPLETED",
   "CANCELLED",
-  "PENDING_APPROVAL"
+  "PENDING_APPROVAL",
+  "CONFIRMED",
+  "PENDING",
+  "LATE"
 ]);
 var ServiceTypeSchema = z.enum(["SUBSCRIPTION", "ROUND_TRIP_BOOKING", "SCHEDULED_BOOKING_STATION"]);
 var getBookingRequests = async (client, status, options) => {
@@ -448,6 +451,42 @@ var updateScheduleBooking = async (client, bookingRequestId, updateData) => {
     updateData
   ).then(({ data }) => data);
 };
+
+// src/triggerBRPayment.ts
+import z9 from "zod";
+var triggerBRPaymentSchema = z9.object({
+  bookingRequestId: z9.string().uuid(),
+  body: z9.object({
+    scope: z9.enum(["RENTAL", "DEPOSIT"]),
+    requiresActionReturnURL: z9.string().url().optional(),
+    online: z9.boolean(),
+    amountType: z9.enum(["FIXED", "PERCENTAGE"]),
+    amountValue: z9.number().nonnegative(),
+    preferredPaymentMethods: z9.array(
+      z9.object({
+        pspReference: z9.string(),
+        amount: z9.number().default(0)
+      })
+    ).optional(),
+    profileId: z9.string().uuid()
+  })
+});
+var triggerBRPayment = async (client, bookingRequestId, body) => {
+  const resultPayload = triggerBRPaymentSchema.safeParse({ bookingRequestId, body });
+  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}/payment`,
+    resultPayload.data.body
+  ).then(({ data }) => data).catch((error) => {
+    throw new TypeError("Failed to trigger booking request payment", {
+      cause: error
+    });
+  });
+};
 export {
   allocateVehicle,
   deallocateVehicle,
@@ -460,5 +499,6 @@ export {
   getStations,
   getSubscriptionBookingRequestById,
   getSubscriptionBookingRequests,
+  triggerBRPayment,
   updateScheduleBooking
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@vulog/aima-booking",
-    "version": "1.2.21",
+    "version": "1.2.23",
     "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.21",
-        "@vulog/aima-core": "1.2.21"
+        "@vulog/aima-client": "1.2.23",
+        "@vulog/aima-core": "1.2.23"
     },
     "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/${id}/cancel`,
+            {}
+        );
+        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/${id}/cancel`,
+            {}
+        )
+        .then(({ data }) => data)
+        .catch((error) => {
+            throw new TypeError('Failed to cancel booking request', {
+                cause: error,
+            });
+        });
+};

package/src/getBookingRequests.ts

@@ -12,6 +12,9 @@ const BookingRequestStatusSchema = z.enum([
     'COMPLETED',
     'CANCELLED',
     'PENDING_APPROVAL',
+    'CONFIRMED',
+    'PENDING',
+    'LATE',
 ]);
 export type BookingRequestStatus = z.infer<typeof BookingRequestStatusSchema>;
 

package/src/index.ts

@@ -11,3 +11,4 @@ export type { IncludeStation } from './getStation';
 export { allocateVehicle } from './allocateVehicle';
 export { deallocateVehicle } from './deallocateVehicle';
 export { updateScheduleBooking } from './updateScheduleBooking';
+export { triggerBRPayment } from './triggerBRPayment';

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.test.ts

@@ -0,0 +1,192 @@
+import { describe, test, expect, vi, beforeEach } from 'vitest';
+import { Client } from '@vulog/aima-client';
+import { randomUUID } from 'crypto';
+import { triggerBRPayment } from './triggerBRPayment';
+import type { TriggerBRPaymentResponse } from './types';
+
+describe('triggerBRPayment', () => {
+    const postMock = vi.fn();
+    const client = {
+        post: postMock,
+        clientOptions: {
+            fleetId: 'FLEET_ID',
+        },
+    } as unknown as Client;
+
+    const validBody = {
+        scope: 'RENTAL' as const,
+        online: true,
+        amountType: 'FIXED' as const,
+        amountValue: 0,
+        profileId: '16de5c48-3898-49c5-97c1-b8344c1db564',
+    };
+
+    const minimalTriggerBRPaymentResponse: TriggerBRPaymentResponse = {
+        id: randomUUID(),
+        cityId: 'city-1',
+        completed: false,
+        creationDate: '2017-07-02T22:58:34Z',
+        customPrice: null,
+        fleetId: 'FLEET_ID',
+        pricingDetails: [],
+        productIds: [],
+        profileId: '9f0fd479-28a9-4754-9c77-611ea48bfb8f',
+        rollingContract: false,
+        serviceId: '9ed7d9d4-8c64-43ef-bb3d-e2b271fed682',
+        startDate: '2017-08-07T07:18:40Z',
+        status: 'CONFIRMED',
+        userId: '465d4067-5332-432f-ac2c-e45af2f85694',
+        cancellationDate: null,
+        cancelledBy: null,
+        endDate: null,
+        entityName: null,
+        journeyId: null,
+        modelId: null,
+        profileType: null,
+        realStartDate: null,
+        returnedDate: null,
+        station: null,
+        vehicleId: null,
+        cancellationFeeAmount: null,
+        credits: [],
+        earlyCancelledByUser: false,
+        email: null,
+        failureReason: null,
+        latitude: 43.68,
+        longitude: 7.2,
+        parentId: null,
+        planName: null,
+        preallocatedVehicleId: null,
+        previous: null,
+        price: null,
+        radius: 30,
+        requiresActionReturnURL: null,
+        thresholdDateLimit: null,
+        trip: null,
+        warning: null,
+        paymentIntents: [
+            {
+                id: '0009ca58-c698-4a08-9a91-6116da1a932e',
+                pspName: 'STRIPE',
+                pspReference: 'pi_1H4QuyCOd50lRjiuhiCUMi9e',
+                pspPublishableKey: 'pk_test_xxx',
+                amount: 215.5,
+                currency: 'EUR',
+                date: '2024-05-01T12:55:02',
+                captureBefore: '2024-05-01T12:55:02',
+                status: 'PAID',
+                paymentMethodType: 'CREDIT_CARD',
+                paymentMethodPspReference: 'pm_xxx',
+                paymentIntentPspReference: 'pi_xxx',
+                number: 4564456465,
+                metadatas: {},
+            },
+        ],
+        paymentReceipts: [],
+    };
+
+    beforeEach(() => {
+        postMock.mockReset();
+    });
+
+    test('throws Invalid args when bookingRequestId is not a valid UUID', async () => {
+        await expect(
+            triggerBRPayment(client, 'not-a-uuid' as any, validBody)
+        ).rejects.toThrow(TypeError);
+
+        await expect(
+            triggerBRPayment(client, 'not-a-uuid' as any, validBody)
+        ).rejects.toMatchObject({ message: 'Invalid args' });
+
+        expect(postMock).not.toHaveBeenCalled();
+    });
+
+    test('throws Invalid args when body.scope is invalid', async () => {
+        await expect(
+            triggerBRPayment(client, randomUUID(), {
+                ...validBody,
+                scope: 'INVALID' as any,
+            })
+        ).rejects.toThrow(TypeError);
+
+        expect(postMock).not.toHaveBeenCalled();
+    });
+
+    test('throws Invalid args when body.profileId is not a valid UUID', async () => {
+        await expect(
+            triggerBRPayment(client, randomUUID(), {
+                ...validBody,
+                profileId: 'not-a-uuid',
+            })
+        ).rejects.toThrow(TypeError);
+
+        expect(postMock).not.toHaveBeenCalled();
+    });
+
+    test('throws Invalid args when body.amountType is invalid', async () => {
+        await expect(
+            triggerBRPayment(client, randomUUID(), {
+                ...validBody,
+                amountType: 'INVALID' as any,
+            })
+        ).rejects.toThrow(TypeError);
+
+        expect(postMock).not.toHaveBeenCalled();
+    });
+
+    test('calls POST with correct URL and body and returns data', async () => {
+        const bookingRequestId = randomUUID();
+        postMock.mockResolvedValueOnce({ data: minimalTriggerBRPaymentResponse });
+
+        const result = await triggerBRPayment(client, bookingRequestId, validBody);
+
+        expect(postMock).toHaveBeenCalledTimes(1);
+        expect(postMock).toHaveBeenCalledWith(
+            `boapi/proxy/user/scheduledBooking/fleets/FLEET_ID/bookingrequests/${bookingRequestId}/payment`,
+            validBody
+        );
+        expect(result).toEqual(minimalTriggerBRPaymentResponse);
+        expect(result.paymentIntents).toHaveLength(1);
+        expect(result.paymentIntents[0].pspName).toBe('STRIPE');
+    });
+
+    test('sends optional requiresActionReturnURL and preferredPaymentMethods when provided', async () => {
+        const bookingRequestId = randomUUID();
+        const bodyWithOptionals = {
+            ...validBody,
+            requiresActionReturnURL: 'https://example.com/return',
+            preferredPaymentMethods: [{ pspReference: 'pm_xxx', amount: 100 }],
+        };
+        postMock.mockResolvedValueOnce({ data: minimalTriggerBRPaymentResponse });
+
+        await triggerBRPayment(client, bookingRequestId, bodyWithOptionals);
+
+        expect(postMock).toHaveBeenCalledWith(
+            `boapi/proxy/user/scheduledBooking/fleets/FLEET_ID/bookingrequests/${bookingRequestId}/payment`,
+            bodyWithOptionals
+        );
+    });
+
+    test('throws when client.post rejects', async () => {
+        const bookingRequestId = randomUUID();
+        const networkError = new Error('Network error');
+        postMock.mockRejectedValueOnce(networkError);
+
+        let thrown: unknown;
+        try {
+            await triggerBRPayment(client, bookingRequestId, validBody);
+        } catch (e) {
+            thrown = e;
+        }
+        expect(thrown).toBeDefined();
+        const err = thrown as Error & { cause?: unknown };
+        expect(err instanceof Error).toBe(true);
+        // Implementation may wrap in TypeError('Failed to trigger booking request payment', { cause })
+        const isWrapped =
+            err.name === 'TypeError' &&
+            err.message === 'Failed to trigger booking request payment' &&
+            err.cause === networkError;
+        const isPropagated = err.message === 'Network error';
+        expect(isWrapped || isPropagated).toBe(true);
+    });
+});

package/src/triggerBRPayment.ts

@@ -0,0 +1,52 @@
+import { UUID } from 'crypto';
+
+import { Client } from '@vulog/aima-client';
+
+import z from 'zod';
+
+import { TriggerBRPaymentResponse } from './types';
+
+const triggerBRPaymentSchema = z.object({
+    bookingRequestId: z.string().uuid(),
+    body: z.object({
+        scope: z.enum(['RENTAL', 'DEPOSIT']),
+        requiresActionReturnURL: z.string().url().optional(),
+        online: z.boolean(),
+        amountType: z.enum(['FIXED', 'PERCENTAGE']),
+        amountValue: z.number().nonnegative(),
+        preferredPaymentMethods: z
+            .array(
+                z.object({
+                    pspReference: z.string(),
+                    amount: z.number().default(0),
+                })
+            )
+            .optional(),
+        profileId: z.string().uuid(),
+    }),
+});
+
+// /scheduledBooking/fleets/{fleetId}/bookingrequests/{id}/payment
+export const triggerBRPayment = async (
+    client: Client,
+    bookingRequestId: UUID,
+    body: z.infer<typeof triggerBRPaymentSchema>['body']
+): Promise<TriggerBRPaymentResponse> => {
+    const resultPayload = triggerBRPaymentSchema.safeParse({ bookingRequestId, body });
+    if (!resultPayload.success) {
+        throw new TypeError('Invalid args', {
+            cause: resultPayload.error.issues,
+        });
+    }
+    return client
+        .post<TriggerBRPaymentResponse>(
+            `boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/bookingrequests/${bookingRequestId}/payment`,
+            resultPayload.data.body
+        )
+        .then(({ data }) => data)
+        .catch((error) => {
+            throw new TypeError('Failed to trigger booking request payment', {
+                cause: error,
+            });
+        });
+};

package/src/types.ts

@@ -15,6 +15,54 @@ export type PaymentReceipts = {
     };
 };
 
+/** Payment intent or receipt item as returned by trigger BR payment (and similar payment endpoints). */
+export type BRPaymentItem = {
+    id: string;
+    pspName: string;
+    pspReference: string;
+    pspPublishableKey: string;
+    amount: number;
+    currency: string;
+    date: string;
+    captureBefore: string;
+    status: string;
+    paymentMethodType: string;
+    paymentMethodPspReference: string;
+    paymentIntentPspReference: string;
+    number: number;
+    code?: string;
+    declineCode?: string;
+    pspClientSecret?: string;
+    reason?: string;
+    note?: string;
+    nextAction?: {
+        nextActionRedirectUrl: {
+            url: string;
+            method: string;
+            data: Record<string, string>;
+        };
+        type: string;
+    };
+    metadatas: Record<string, string>;
+};
+
+/** Credit entry in a booking request (e.g. trigger BR payment response). */
+export type BookingCredit = {
+    id: string;
+    fleetId: string;
+    amount: number;
+    availableAmount: number;
+    status: string;
+    walletId: string;
+    date: string;
+};
+
+/** Preferred payment method entry in request/response. */
+export type PreferredPaymentMethod = {
+    pspReference: string;
+    amount: number;
+};
+
 export type CustomPrice = {
     id: string;
     fleetId: string;
@@ -104,6 +152,14 @@ export type SATBookingRequest = BaseBookingRequest & {
     warning: string | null;
 };
 
+/** Response of the trigger BR payment endpoint (booking request + payment intents/receipts). */
+export type TriggerBRPaymentResponse = Omit<SATBookingRequest, 'credits'> & {
+    paymentIntents: BRPaymentItem[];
+    paymentReceipts: BRPaymentItem[];
+    credits: BookingCredit[];
+    preferredPaymentMethods?: PreferredPaymentMethod[];
+};
+
 // Station types
 export type GeoInfo = {
     name: string;