@vulog/aima-booking 1.2.33 → 1.2.35

package/dist/index.mjs

@@ -148,6 +148,11 @@ const getSubscriptionBookingRequestById = async (client, id) => {
 		...data
 	}));
 };
+const getScheduledBookingById = async (client, bookingId) => {
+	const result = z.string().trim().min(1).uuid().safeParse(bookingId);
+	if (!result.success) throw new TypeError("Invalid bookingId", { cause: result.error.issues });
+	return client.get(`/boapi/proxy/user/scheduledBooking/by-service/fleets/${client.clientOptions.fleetId}/bookingrequests/${bookingId}`).then(({ data }) => data);
+};
 //#endregion
 //#region src/getAvailableVehicles.ts
 /** ISO date-time without milliseconds (e.g. 2025-02-10T12:00:00Z or 2025-02-10T12:00:00+01:00). */
@@ -328,7 +333,7 @@ const deallocateVehicle = async (client, bookingRequestId, vehicleId) => {
 };
 //#endregion
 //#region src/updateScheduleBooking.ts
-const schema$2 = z$1.object({
+const schema$7 = z$1.object({
 	id: z$1.string(),
 	startDate: z$1.string().refine((date) => !Number.isNaN(Date.parse(date)), { message: "Invalid date" }).optional(),
 	latitude: z$1.number().min(-90).max(90).optional(),
@@ -350,7 +355,7 @@ const schema$2 = z$1.object({
 	plannedReturnDate: z$1.string().refine((date) => !Number.isNaN(Date.parse(date)), { message: "Invalid date" }).optional()
 });
 const updateScheduleBooking = async (client, bookingRequestId, updateData) => {
-	const result = schema$2.safeParse({
+	const result = schema$7.safeParse({
 		id: bookingRequestId,
 		...updateData
 	});
@@ -386,9 +391,9 @@ const triggerBRPayment = async (client, bookingRequestId, body) => {
 };
 //#endregion
 //#region src/getBookingRequestsByUserId.ts
-const schema$1 = z.object({ userId: z.string().trim().min(1).uuid() });
+const schema$6 = z.object({ userId: z.string().trim().min(1).uuid() });
 const getBookingRequestsByUserId = async (client, userId) => {
-	const result = schema$1.safeParse({ userId });
+	const result = schema$6.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 [];
@@ -413,15 +418,80 @@ const releaseBRPayment = async (client, bookingRequestId, pspReference) => {
 };
 //#endregion
 //#region src/cancelBookingRequest.ts
-const schema = z$1.object({ id: z$1.string().uuid() });
+const schema$5 = z$1.object({ id: z$1.string().uuid() });
 const cancelBookingRequest = async (client, id) => {
-	const result = schema.safeParse({ id });
+	const result = schema$5.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 });
 	});
 };
 //#endregion
+//#region src/getDigitalContracts.ts
+const schema$4 = z.object({ bookingId: z.string().trim().min(1) });
+const getDigitalContracts = async (client, bookingId, status = "SIGNED") => {
+	const result = schema$4.safeParse({ bookingId });
+	if (!result.success) throw new TypeError("Invalid args", { cause: result.error.issues });
+	return client.get(`/boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/subscription/bookingrequests/${result.data.bookingId}/digitalContracts?status=${encodeURIComponent(status)}`).then(({ data }) => data);
+};
+//#endregion
+//#region src/getAdditionalDrivers.ts
+const schema$3 = z.object({ parentId: z.string().trim().min(1) });
+const getAdditionalDrivers = async (client, parentId) => {
+	const result = schema$3.safeParse({ parentId });
+	if (!result.success) throw new TypeError("Invalid parentId", { cause: result.error.issues });
+	return client.get(`/boapi/proxy/user/fleets/${client.clientOptions.fleetId}/bookingrequests/${parentId}/additionalDrivers`).then(({ data }) => data);
+};
+//#endregion
+//#region src/getSlaves.ts
+const schema$2 = z.object({
+	parentId: z.string().trim().min(1),
+	status: z.enum(["ONGOING, COMPLETED", "UPCOMING"])
+});
+const getSlaves = async (client, parentId, status) => {
+	const result = schema$2.safeParse({
+		parentId,
+		status
+	});
+	if (!result.success) throw new TypeError("Invalid bookingId", { cause: result.error.issues });
+	return client.get(`/boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/subscription/bookingRequests/${parentId}/bookingRequestsSlave?bookingStatus=${status}`).then(({ data }) => data);
+};
+//#endregion
+//#region src/getSubscriptionsByUserId.ts
+const schema$1 = z.object({
+	userId: z.string().trim().min(1).uuid(),
+	active: z.boolean().optional().default(true)
+});
+const getSubscriptionsByUserId = async (client, userId, active = true) => {
+	const result = schema$1.safeParse({
+		userId,
+		active
+	});
+	if (!result.success) throw new TypeError("Invalid userId", { cause: result.error.issues });
+	return client.get(`/boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/subscription/users/${userId}/${active ? "active" : "past"}`).then(({ data }) => data);
+};
+//#endregion
+//#region src/submitCancellationRequest.ts
+const schema = z.object({
+	bookingRequestId: z.string().uuid(),
+	userId: z.string().uuid()
+});
+const submitCancellationRequest = async (client, bookingRequestId, userId) => {
+	const result = schema.safeParse({
+		bookingRequestId,
+		userId
+	});
+	if (!result.success) throw new TypeError("Invalid args", { cause: result.error.issues });
+	return client.post(`/boapi/proxy/user/fleets/${client.clientOptions.fleetId}/bookingrequests/${bookingRequestId}/actions`, {
+		action: "EARLIER_CANCELLATION_REQUEST",
+		bookingStatusBO: "ONGOING",
+		status: "PENDING",
+		userId
+	}).then(({ data }) => data).catch((error) => {
+		throw new TypeError("Failed to submit cancellation request", { cause: error });
+	});
+};
+//#endregion
 //#region src/createSubscription.ts
 const createSubscriptionBodySchema = z.object({
 	userId: z.string().trim().min(1).uuid(),
@@ -451,4 +521,4 @@ const createSubscription = async (client, body) => {
 	return client.post(`/boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/subscription/bookingrequests`, result.data).then(({ data }) => data);
 };
 //#endregion
-export { allocateVehicle, cancelBookingRequest, createSubscription, deallocateVehicle, getAvailableVehicles, getBookingRequestById, getBookingRequestByTrip, getBookingRequests, getBookingRequestsByUserId, getSATBookingRequests, getScheduleBookingRequests, getStationById, getStations, getSubscriptionBookingRequestById, getSubscriptionBookingRequests, releaseBRPayment, triggerBRPayment, updateScheduleBooking };
+export { allocateVehicle, cancelBookingRequest, createSubscription, deallocateVehicle, getAdditionalDrivers, getAvailableVehicles, getBookingRequestById, getBookingRequestByTrip, getBookingRequests, getBookingRequestsByUserId, getDigitalContracts, getSATBookingRequests, getScheduleBookingRequests, getScheduledBookingById, getSlaves, getStationById, getStations, getSubscriptionBookingRequestById, getSubscriptionBookingRequests, getSubscriptionsByUserId, releaseBRPayment, submitCancellationRequest, triggerBRPayment, updateScheduleBooking };

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@vulog/aima-booking",
     "type": "module",
-    "version": "1.2.33",
+    "version": "1.2.35",
     "main": "dist/index.cjs",
     "module": "dist/index.mjs",
     "types": "dist/index.d.cts",
@@ -32,8 +32,8 @@
     "author": "Vulog",
     "license": "MIT",
     "dependencies": {
-        "@vulog/aima-client": "1.2.33",
-        "@vulog/aima-core": "1.2.33"
+        "@vulog/aima-client": "1.2.35",
+        "@vulog/aima-core": "1.2.35"
     },
     "peerDependencies": {
         "es-toolkit": "^1.39.9",

package/src/getAdditionalDrivers.test.ts

@@ -0,0 +1,61 @@
+import { describe, test, expect, vi, beforeEach } from 'vitest';
+import { Client } from '@vulog/aima-client';
+import { randomUUID } from 'crypto';
+import { getAdditionalDrivers } from './getAdditionalDrivers';
+
+describe('getAdditionalDrivers', () => {
+    const getMock = vi.fn();
+    const client = {
+        get: getMock,
+        clientOptions: {
+            fleetId: 'FLEET_ID',
+        },
+    } as unknown as Client;
+
+    beforeEach(() => {
+        getMock.mockReset();
+    });
+
+    test('throws Invalid parentId when parentId is empty', async () => {
+        await expect(getAdditionalDrivers(client, '')).rejects.toThrow(TypeError);
+        await expect(getAdditionalDrivers(client, '')).rejects.toMatchObject({
+            message: 'Invalid parentId',
+        });
+        expect(getMock).not.toHaveBeenCalled();
+    });
+
+    test('calls GET with correct URL and returns additional drivers', async () => {
+        const parentId = randomUUID();
+        const drivers = [
+            {
+                id: randomUUID(),
+                fleetId: 'FLEET_ID',
+                bookingRequestId: parentId,
+                profileId: randomUUID(),
+                updateDate: '2025-01-15T10:00:00Z',
+                invitationEmail: 'driver@example.com',
+                profileStatus: 'APPROVED',
+                userId: randomUUID(),
+            },
+        ];
+        getMock.mockResolvedValueOnce({ data: drivers });
+
+        const result = await getAdditionalDrivers(client, parentId);
+
+        expect(getMock).toHaveBeenCalledTimes(1);
+        expect(getMock).toHaveBeenCalledWith(
+            `/boapi/proxy/user/fleets/FLEET_ID/bookingrequests/${parentId}/additionalDrivers`
+        );
+        expect(result).toEqual(drivers);
+        expect(result).toHaveLength(1);
+    });
+
+    test('returns empty array when no additional drivers', async () => {
+        const parentId = randomUUID();
+        getMock.mockResolvedValueOnce({ data: [] });
+
+        const result = await getAdditionalDrivers(client, parentId);
+
+        expect(result).toEqual([]);
+    });
+});

package/src/getAdditionalDrivers.ts

@@ -0,0 +1,23 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { type AdditionalDriver } from './types';
+
+const schema = z.object({
+    parentId: z.string().trim().min(1),
+});
+
+export const getAdditionalDrivers = async (client: Client, parentId: string): Promise<AdditionalDriver[]> => {
+    const result = schema.safeParse({ parentId });
+    if (!result.success) {
+        throw new TypeError('Invalid parentId', {
+            cause: result.error.issues,
+        });
+    }
+
+    return client
+        .get<
+            AdditionalDriver[]
+        >(`/boapi/proxy/user/fleets/${client.clientOptions.fleetId}/bookingrequests/${parentId}/additionalDrivers`)
+        .then(({ data }) => data);
+};

package/src/getAvailableVehicles.test.ts

@@ -0,0 +1,53 @@
+import { describe, test, expect, vi, beforeEach } from 'vitest';
+import { Client } from '@vulog/aima-client';
+import { getAvailableVehicles } from './getAvailableVehicles';
+
+describe('getAvailableVehicles', () => {
+    const getMock = vi.fn();
+    const client = {
+        get: getMock,
+        clientOptions: {
+            fleetId: 'FLEET_ID',
+        },
+    } as unknown as Client;
+
+    beforeEach(() => {
+        getMock.mockReset();
+    });
+
+    test('throws Invalid args when stationId is empty', async () => {
+        await expect(
+            getAvailableVehicles(client, '', '2025-02-10T12:00:00Z')
+        ).rejects.toThrow(TypeError);
+        await expect(
+            getAvailableVehicles(client, '', '2025-02-10T12:00:00Z')
+        ).rejects.toMatchObject({ message: 'Invalid args' });
+        expect(getMock).not.toHaveBeenCalled();
+    });
+
+    test('throws Invalid args when startDate is invalid datetime', async () => {
+        await expect(
+            getAvailableVehicles(client, 'station-123', 'not-a-date')
+        ).rejects.toThrow(TypeError);
+        expect(getMock).not.toHaveBeenCalled();
+    });
+
+    test('calls GET with correct URL and returns available vehicles response', async () => {
+        const stationId = 'ded03b86-fa3f-4d79-80fa-191b2ec13b5e';
+        const startDate = '2025-02-10T12:00:00Z';
+        const response = {
+            stationId,
+            vehicles: [{ vehicleId: 'vehicle-1' }, { vehicleId: 'vehicle-2' }],
+        };
+        getMock.mockResolvedValueOnce({ data: response });
+
+        const result = await getAvailableVehicles(client, stationId, startDate);
+
+        expect(getMock).toHaveBeenCalledTimes(1);
+        expect(getMock).toHaveBeenCalledWith(
+            `/boapi/proxy/user/scheduledBooking/fleets/FLEET_ID/subscription/stations/${stationId}/vehicles/available?startDate=${startDate}`
+        );
+        expect(result).toEqual(response);
+        expect(result.vehicles).toHaveLength(2);
+    });
+});

package/src/getBookingRequest.test.ts

@@ -1,5 +1,10 @@
 import { describe, test, expect, vi, beforeEach, afterEach } from 'vitest';
-import { getBookingRequestById, getBookingRequestByTrip, getSubscriptionBookingRequestById } from './getBookingRequest';
+import {
+    getBookingRequestById,
+    getBookingRequestByTrip,
+    getSubscriptionBookingRequestById,
+    getScheduledBookingById,
+} from './getBookingRequest';
 import { Client } from '@vulog/aima-client';
 import { randomUUID } from 'crypto';
 import { PaymentReceipts } from './types';
@@ -436,3 +441,69 @@ describe('getsubscriptionBookingRequestByID', () => {
         expect(result.station).toEqual(data.stationId);
     });
 });
+
+describe('getScheduledBookingById', () => {
+    const getMock = vi.fn();
+    const client = {
+        get: getMock,
+        clientOptions: {
+            fleetId: 'FLEET_ID',
+        },
+    } as unknown as Client;
+
+    beforeEach(() => {
+        getMock.mockReset();
+    });
+
+    test('throws Invalid bookingId when bookingId is not a valid UUID', async () => {
+        await expect(getScheduledBookingById(client, 'not-a-uuid')).rejects.toThrow(TypeError);
+        await expect(getScheduledBookingById(client, 'not-a-uuid')).rejects.toMatchObject({
+            message: 'Invalid bookingId',
+        });
+        expect(getMock).not.toHaveBeenCalled();
+    });
+
+    test('throws Invalid bookingId when bookingId is empty', async () => {
+        await expect(getScheduledBookingById(client, '')).rejects.toThrow(TypeError);
+        expect(getMock).not.toHaveBeenCalled();
+    });
+
+    test('calls GET with by-service URL and returns SATBookingRequest', async () => {
+        const bookingId = randomUUID();
+        const data = {
+            id: bookingId,
+            startDate: '2026-03-03T10:00:00Z',
+            endDate: '2026-06-03T09:00:00Z',
+            returnedDate: null,
+            profileId: '76175b0c-7e39-41ad-a338-914df3a5fdf6',
+            vehicleId: null,
+            modelId: null,
+            journeyId: 'BEBD00056A9A16103D418CC36D940E26',
+            station: 'ded03b86-fa3f-4d79-80fa-191b2ec13b5e',
+            status: 'CONFIRMED',
+            creationDate: '2026-03-03T09:29:45Z',
+            fleetId: 'FLEET_ID',
+            userId: '20fb98a3-b60d-491a-9359-62e55f51fcb9',
+            serviceId: 'f49080b0-66bc-45e9-8e84-0dfb57bb8f92',
+            productIds: [],
+            pricingDetails: [],
+            completed: true,
+            rollingContract: true,
+            planDurationInMonths: 3,
+            planName: '3 mois',
+            contractType: 'SVS',
+            bookingReferenceId: 'q93UCF',
+        };
+        getMock.mockResolvedValueOnce({ data });
+
+        const result = await getScheduledBookingById(client, bookingId);
+
+        expect(getMock).toHaveBeenCalledTimes(1);
+        expect(getMock).toHaveBeenCalledWith(
+            `/boapi/proxy/user/scheduledBooking/by-service/fleets/FLEET_ID/bookingrequests/${bookingId}`
+        );
+        expect(result).toEqual(data);
+        expect(result.id).toBe(bookingId);
+        expect(result.status).toBe('CONFIRMED');
+    });
+});

package/src/getBookingRequest.ts

@@ -1,7 +1,7 @@
 import { Client } from '@vulog/aima-client';
 import { z } from 'zod';
 
-import { BookingRequest } from './types';
+import { BookingRequest, SATBookingRequest } from './types';
 
 export const getBookingRequestById = async (client: Client, id: string): Promise<BookingRequest> => {
     const result = z.string().trim().min(1).uuid().safeParse(id);
@@ -46,3 +46,17 @@ export const getSubscriptionBookingRequestById = async (client: Client, id: stri
         )
         .then(({ data: { stationId, ...data } }) => ({ station: stationId, ...data }) as BookingRequest);
 };
+
+export const getScheduledBookingById = async (client: Client, bookingId: string): Promise<SATBookingRequest> => {
+    const result = z.string().trim().min(1).uuid().safeParse(bookingId);
+    if (!result.success) {
+        throw new TypeError('Invalid bookingId', {
+            cause: result.error.issues,
+        });
+    }
+    return client
+        .get<SATBookingRequest>(
+            `/boapi/proxy/user/scheduledBooking/by-service/fleets/${client.clientOptions.fleetId}/bookingrequests/${bookingId}`
+        )
+        .then(({ data }) => data);
+};

package/src/getDigitalContracts.test.ts

@@ -0,0 +1,72 @@
+import { describe, test, expect, vi, beforeEach } from 'vitest';
+import { Client } from '@vulog/aima-client';
+import { getDigitalContracts } from './getDigitalContracts';
+import type { Contract } from './types';
+
+describe('getDigitalContracts', () => {
+    const getMock = vi.fn();
+    const client = {
+        get: getMock,
+        clientOptions: {
+            fleetId: 'FLEET_ID',
+        },
+    } as unknown as Client;
+
+    const mockContracts: Contract[] = [
+        {
+            id: 'contract-1',
+            status: 'SIGNED',
+            provider: 'DOCUSIGN',
+            creationDate: '2026-03-03T10:00:00Z',
+            profileId: '76175b0c-7e39-41ad-a338-914df3a5fdf6',
+            externalContractId: 'ext-1',
+            type: 'RENTAL',
+        },
+    ];
+
+    beforeEach(() => {
+        getMock.mockReset();
+    });
+
+    test('throws Invalid args when bookingId is empty', async () => {
+        await expect(getDigitalContracts(client, '')).rejects.toThrow(TypeError);
+        await expect(getDigitalContracts(client, '')).rejects.toMatchObject({
+            message: 'Invalid args',
+        });
+        expect(getMock).not.toHaveBeenCalled();
+    });
+
+    test('calls GET with default status SIGNED and returns contracts', async () => {
+        const bookingId = '66bcbd77-37ef-47bd-b9af-877e5d213b8f';
+        getMock.mockResolvedValueOnce({ data: mockContracts });
+
+        const result = await getDigitalContracts(client, bookingId);
+
+        expect(getMock).toHaveBeenCalledTimes(1);
+        expect(getMock).toHaveBeenCalledWith(
+            `/boapi/proxy/user/scheduledBooking/fleets/FLEET_ID/subscription/bookingrequests/${bookingId}/digitalContracts?status=SIGNED`
+        );
+        expect(result).toEqual(mockContracts);
+        expect(result[0].status).toBe('SIGNED');
+    });
+
+    test('calls GET with custom status when provided', async () => {
+        const bookingId = '66bcbd77-37ef-47bd-b9af-877e5d213b8f';
+        getMock.mockResolvedValueOnce({ data: [] });
+
+        await getDigitalContracts(client, bookingId, 'PENDING');
+
+        expect(getMock).toHaveBeenCalledWith(
+            `/boapi/proxy/user/scheduledBooking/fleets/FLEET_ID/subscription/bookingrequests/${bookingId}/digitalContracts?status=PENDING`
+        );
+    });
+
+    test('returns empty array when no contracts', async () => {
+        const bookingId = 'some-booking-id';
+        getMock.mockResolvedValueOnce({ data: [] });
+
+        const result = await getDigitalContracts(client, bookingId);
+
+        expect(result).toEqual([]);
+    });
+});

package/src/getDigitalContracts.ts

@@ -0,0 +1,26 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { Contract } from './types';
+
+const schema = z.object({
+    bookingId: z.string().trim().min(1),
+});
+
+export const getDigitalContracts = async (
+    client: Client,
+    bookingId: string,
+    status = 'SIGNED'
+): Promise<Contract[]> => {
+    const result = schema.safeParse({ bookingId });
+    if (!result.success) {
+        throw new TypeError('Invalid args', {
+            cause: result.error.issues,
+        });
+    }
+    return client
+        .get<
+            Contract[]
+        >(`/boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/subscription/bookingrequests/${result.data.bookingId}/digitalContracts?status=${encodeURIComponent(status)}`)
+        .then(({ data }) => data);
+};

package/src/getSlaves.test.ts

@@ -0,0 +1,60 @@
+import { describe, test, expect, vi, beforeEach } from 'vitest';
+import { Client } from '@vulog/aima-client';
+import { randomUUID } from 'crypto';
+import { getSlaves } from './getSlaves';
+import type { BookingRequestSlave } from './types';
+
+describe('getSlaves', () => {
+    const getMock = vi.fn();
+    const client = {
+        get: getMock,
+        clientOptions: {
+            fleetId: 'FLEET_ID',
+        },
+    } as unknown as Client;
+
+    beforeEach(() => {
+        getMock.mockReset();
+    });
+
+    test('throws Invalid bookingId when parentId is empty', async () => {
+        await expect(getSlaves(client, '', 'UPCOMING')).rejects.toThrow(TypeError);
+        await expect(getSlaves(client, '', 'UPCOMING')).rejects.toMatchObject({
+            message: 'Invalid bookingId',
+        });
+        expect(getMock).not.toHaveBeenCalled();
+    });
+
+    test('throws when status is not in enum', async () => {
+        const parentId = randomUUID();
+        await expect(getSlaves(client, parentId, 'INVALID_STATUS')).rejects.toThrow(TypeError);
+        expect(getMock).not.toHaveBeenCalled();
+    });
+
+    test('calls GET with correct URL for UPCOMING and returns slaves', async () => {
+        const parentId = randomUUID();
+        const slaves: BookingRequestSlave[] = [
+            {
+                id: randomUUID(),
+                vehicleId: randomUUID(),
+                modelId: 2597,
+                startDate: '2026-03-03T10:00:00Z',
+                endDate: '2026-03-06T09:00:00Z',
+                tripId: 'BEBD00056A9A16103D418CC36D940E26',
+                parentId,
+                traveledDistance: 120,
+                energyLevelEnd: 80,
+            },
+        ];
+        getMock.mockResolvedValueOnce({ data: slaves });
+
+        const result = await getSlaves(client, parentId, 'UPCOMING');
+
+        expect(getMock).toHaveBeenCalledTimes(1);
+        expect(getMock).toHaveBeenCalledWith(
+            `/boapi/proxy/user/scheduledBooking/fleets/FLEET_ID/subscription/bookingRequests/${parentId}/bookingRequestsSlave?bookingStatus=UPCOMING`
+        );
+        expect(result).toEqual(slaves);
+        expect(result).toHaveLength(1);
+    });
+});

package/src/getSlaves.ts

@@ -0,0 +1,24 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { BookingRequestSlave } from './types';
+
+const schema = z.object({
+    parentId: z.string().trim().min(1),
+    status: z.enum(['ONGOING, COMPLETED', 'UPCOMING']),
+});
+
+export const getSlaves = async (client: Client, parentId: string, status: string): Promise<BookingRequestSlave[]> => {
+    const result = schema.safeParse({ parentId, status });
+    if (!result.success) {
+        throw new TypeError('Invalid bookingId', {
+            cause: result.error.issues,
+        });
+    }
+
+    return client
+        .get<
+            BookingRequestSlave[]
+        >(`/boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/subscription/bookingRequests/${parentId}/bookingRequestsSlave?bookingStatus=${status}`)
+        .then(({ data }) => data);
+};