@vulog/aima-unavailability 1.2.7 → 1.2.9

package/dist/index.d.mts

@@ -0,0 +1,48 @@
+import { Client } from '@vulog/aima-client';
+
+type Unavailability = {
+    id: number;
+    cronExpression: string;
+    duration: number;
+    maintenanceTitle: string;
+    vehicleId: string;
+};
+type CreateUnavailabilityBody = {
+    cronExpression: string;
+    duration: number;
+    maintenanceTitle: string;
+    vehicleId: string;
+};
+type UpdateUnavailabilityBody = CreateUnavailabilityBody;
+type UnavailabilityOptions = {
+    from: string;
+    to: string;
+    page?: number;
+};
+
+declare const getUnavailabilitiesByVehicle: (client: Client, vehicleId: string) => Promise<Unavailability[]>;
+
+declare const getUnavailabilities: (client: Client, options: UnavailabilityOptions) => Promise<Unavailability[]>;
+
+declare const createUnavailability: (client: Client, body: CreateUnavailabilityBody) => Promise<Unavailability>;
+
+declare const updateUnavailability: (client: Client, id: number, body: UpdateUnavailabilityBody) => Promise<Unavailability>;
+
+declare const deleteUnavailability: (client: Client, id: number) => Promise<void>;
+
+declare const deleteUnavailabilitiesByVehicle: (client: Client, vehicleId: string) => Promise<void>;
+
+/**
+ * Generates a Quartz cron expression from a date.
+ * Format: second minute hour day month dayOfWeek year
+ * Example: "0 0 23 14 8 ? 2018"
+ *
+ * @param date - The date to convert to cron expression (Date object or ISO string)
+ * @param timezone - Optional timezone string (e.g., "Europe/Paris", "America/New_York")
+ *                   If provided, the date will be converted to the specified timezone.
+ *                   If not provided, the date will be used as-is.
+ * @returns A cron expression string in Quartz format
+ */
+declare const generateCronExpression: (date: Date | string, timezone?: string) => string;
+
+export { type CreateUnavailabilityBody, type Unavailability, type UnavailabilityOptions, type UpdateUnavailabilityBody, createUnavailability, deleteUnavailabilitiesByVehicle, deleteUnavailability, generateCronExpression, getUnavailabilities, getUnavailabilitiesByVehicle, updateUnavailability };

package/dist/index.d.ts

@@ -0,0 +1,48 @@
+import { Client } from '@vulog/aima-client';
+
+type Unavailability = {
+    id: number;
+    cronExpression: string;
+    duration: number;
+    maintenanceTitle: string;
+    vehicleId: string;
+};
+type CreateUnavailabilityBody = {
+    cronExpression: string;
+    duration: number;
+    maintenanceTitle: string;
+    vehicleId: string;
+};
+type UpdateUnavailabilityBody = CreateUnavailabilityBody;
+type UnavailabilityOptions = {
+    from: string;
+    to: string;
+    page?: number;
+};
+
+declare const getUnavailabilitiesByVehicle: (client: Client, vehicleId: string) => Promise<Unavailability[]>;
+
+declare const getUnavailabilities: (client: Client, options: UnavailabilityOptions) => Promise<Unavailability[]>;
+
+declare const createUnavailability: (client: Client, body: CreateUnavailabilityBody) => Promise<Unavailability>;
+
+declare const updateUnavailability: (client: Client, id: number, body: UpdateUnavailabilityBody) => Promise<Unavailability>;
+
+declare const deleteUnavailability: (client: Client, id: number) => Promise<void>;
+
+declare const deleteUnavailabilitiesByVehicle: (client: Client, vehicleId: string) => Promise<void>;
+
+/**
+ * Generates a Quartz cron expression from a date.
+ * Format: second minute hour day month dayOfWeek year
+ * Example: "0 0 23 14 8 ? 2018"
+ *
+ * @param date - The date to convert to cron expression (Date object or ISO string)
+ * @param timezone - Optional timezone string (e.g., "Europe/Paris", "America/New_York")
+ *                   If provided, the date will be converted to the specified timezone.
+ *                   If not provided, the date will be used as-is.
+ * @returns A cron expression string in Quartz format
+ */
+declare const generateCronExpression: (date: Date | string, timezone?: string) => string;
+
+export { type CreateUnavailabilityBody, type Unavailability, type UnavailabilityOptions, type UpdateUnavailabilityBody, createUnavailability, deleteUnavailabilitiesByVehicle, deleteUnavailability, generateCronExpression, getUnavailabilities, getUnavailabilitiesByVehicle, updateUnavailability };

package/dist/index.js

@@ -0,0 +1,251 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createUnavailability: () => createUnavailability,
+  deleteUnavailabilitiesByVehicle: () => deleteUnavailabilitiesByVehicle,
+  deleteUnavailability: () => deleteUnavailability,
+  generateCronExpression: () => generateCronExpression,
+  getUnavailabilities: () => getUnavailabilities,
+  getUnavailabilitiesByVehicle: () => getUnavailabilitiesByVehicle,
+  updateUnavailability: () => updateUnavailability
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/getUnavailabilitiesByVehicle.ts
+var import_zod = require("zod");
+var schema = import_zod.z.object({
+  vehicleId: import_zod.z.string().trim().min(1).uuid()
+});
+var getUnavailabilitiesByVehicle = async (client, vehicleId) => {
+  const result = schema.safeParse({ vehicleId });
+  if (!result.success) {
+    throw new TypeError("Invalid args", {
+      cause: result.error.issues
+    });
+  }
+  return client.get(
+    `/boapi/proxy/user/fleets/${client.clientOptions.fleetId}/scheduledRules/unavailability/vehicles/${result.data.vehicleId}`
+  ).then(({ data }) => data).catch((error) => {
+    if (error.formattedError?.status === 404) {
+      return [];
+    }
+    throw error;
+  });
+};
+
+// src/getUnavailabilities.ts
+var import_zod2 = require("zod");
+var schema2 = import_zod2.z.object({
+  from: import_zod2.z.string().datetime({ offset: false, precision: 0 }),
+  to: import_zod2.z.string().datetime({ offset: false, precision: 0 }),
+  page: import_zod2.z.number().int().nonnegative().default(0)
+});
+var getUnavailabilities = async (client, options) => {
+  const result = schema2.safeParse({
+    from: options.from,
+    to: options.to,
+    page: options.page ?? 0
+  });
+  if (!result.success) {
+    throw new TypeError("Invalid args", {
+      cause: result.error.issues
+    });
+  }
+  const allUnavailabilities = [];
+  let currentPage = result.data.page;
+  let hasMorePages = true;
+  const MAX_PAGES = 50;
+  while (hasMorePages) {
+    if (currentPage >= MAX_PAGES) {
+      throw new Error(
+        `Maximum page limit (${MAX_PAGES}) reached. This might indicate an issue with the pagination or a very large dataset.`
+      );
+    }
+    const queryParams = new URLSearchParams({
+      from: result.data.from,
+      to: result.data.to,
+      page: currentPage.toString()
+    });
+    const unavailabilities = await client.get(
+      `/boapi/proxy/user/fleets/${client.clientOptions.fleetId}/scheduledRules/unavailability/vehicles?${queryParams.toString()}`
+    ).then(({ data }) => data).catch((error) => {
+      if (error.formattedError?.status === 404) {
+        return [];
+      }
+      throw error;
+    });
+    allUnavailabilities.push(...unavailabilities);
+    hasMorePages = unavailabilities.length > 0;
+    currentPage += 1;
+  }
+  return allUnavailabilities;
+};
+
+// src/createUnavailability.ts
+var import_zod3 = require("zod");
+var schema3 = import_zod3.z.object({
+  cronExpression: import_zod3.z.string().min(1),
+  duration: import_zod3.z.number().int().positive(),
+  maintenanceTitle: import_zod3.z.string().min(1),
+  vehicleId: import_zod3.z.string().uuid()
+});
+var createUnavailability = async (client, body) => {
+  const result = schema3.safeParse(body);
+  if (!result.success) {
+    throw new TypeError("Invalid args", {
+      cause: result.error.issues
+    });
+  }
+  return client.post(
+    `/boapi/proxy/user/fleets/${client.clientOptions.fleetId}/scheduledRules/unavailability`,
+    {
+      cronExpression: result.data.cronExpression,
+      duration: result.data.duration,
+      maintenanceTitle: result.data.maintenanceTitle,
+      vehicleId: result.data.vehicleId
+    }
+  ).then(({ data }) => data);
+};
+
+// src/updateUnavailability.ts
+var import_zod4 = require("zod");
+var schema4 = import_zod4.z.object({
+  id: import_zod4.z.number().int().positive(),
+  cronExpression: import_zod4.z.string().min(1),
+  duration: import_zod4.z.number().int().positive(),
+  maintenanceTitle: import_zod4.z.string().min(1),
+  vehicleId: import_zod4.z.string().uuid()
+});
+var updateUnavailability = async (client, id, body) => {
+  const result = schema4.safeParse({
+    id,
+    ...body
+  });
+  if (!result.success) {
+    throw new TypeError("Invalid args", {
+      cause: result.error.issues
+    });
+  }
+  return client.put(
+    `/boapi/proxy/user/fleets/${client.clientOptions.fleetId}/scheduledRules/unavailability/${result.data.id}`,
+    {
+      cronExpression: result.data.cronExpression,
+      duration: result.data.duration,
+      maintenanceTitle: result.data.maintenanceTitle,
+      vehicleId: result.data.vehicleId
+    }
+  ).then(({ data }) => data);
+};
+
+// src/deleteUnavailability.ts
+var import_zod5 = require("zod");
+var schema5 = import_zod5.z.object({
+  id: import_zod5.z.number().int().positive()
+});
+var deleteUnavailability = async (client, id) => {
+  const result = schema5.safeParse({ id });
+  if (!result.success) {
+    throw new TypeError("Invalid args", {
+      cause: result.error.issues
+    });
+  }
+  return client.delete(
+    `/boapi/proxy/user/fleets/${client.clientOptions.fleetId}/scheduledRules/unavailability/${result.data.id}`
+  ).then(() => void 0).catch((error) => {
+    if (error.formattedError?.status === 404) {
+      return void 0;
+    }
+    throw error;
+  });
+};
+
+// src/deleteUnavailabilitiesByVehicle.ts
+var import_zod6 = require("zod");
+var schema6 = import_zod6.z.object({
+  vehicleId: import_zod6.z.string().trim().min(1).uuid()
+});
+var deleteUnavailabilitiesByVehicle = async (client, vehicleId) => {
+  const result = schema6.safeParse({ vehicleId });
+  if (!result.success) {
+    throw new TypeError("Invalid args", {
+      cause: result.error.issues
+    });
+  }
+  return client.delete(
+    `/boapi/proxy/user/fleets/${client.clientOptions.fleetId}/scheduledRules/unavailability/vehicles/${result.data.vehicleId}`
+  ).then(() => void 0).catch((error) => {
+    if (error.formattedError?.status === 404) {
+      return void 0;
+    }
+    throw error;
+  });
+};
+
+// src/generateCronExpression.ts
+var generateCronExpression = (date, timezone) => {
+  let dateObj;
+  if (typeof date === "string") {
+    dateObj = new Date(date);
+  } else {
+    dateObj = new Date(date);
+  }
+  if (Number.isNaN(dateObj.getTime())) {
+    throw new TypeError("Invalid date provided");
+  }
+  if (timezone) {
+    const formatter = new Intl.DateTimeFormat("en-US", {
+      timeZone: timezone,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      hour12: false
+    });
+    const parts = formatter.formatToParts(dateObj);
+    const year2 = parseInt(parts.find((p) => p.type === "year")?.value || "0", 10);
+    const month2 = parseInt(parts.find((p) => p.type === "month")?.value || "0", 10);
+    const day2 = parseInt(parts.find((p) => p.type === "day")?.value || "0", 10);
+    const hour2 = parseInt(parts.find((p) => p.type === "hour")?.value || "0", 10);
+    const minute2 = parseInt(parts.find((p) => p.type === "minute")?.value || "0", 10);
+    const second2 = parseInt(parts.find((p) => p.type === "second")?.value || "0", 10);
+    return `${second2} ${minute2} ${hour2} ${day2} ${month2} ? ${year2}`;
+  }
+  const year = dateObj.getFullYear();
+  const month = dateObj.getMonth() + 1;
+  const day = dateObj.getDate();
+  const hour = dateObj.getHours();
+  const minute = dateObj.getMinutes();
+  const second = dateObj.getSeconds();
+  return `${second} ${minute} ${hour} ${day} ${month} ? ${year}`;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createUnavailability,
+  deleteUnavailabilitiesByVehicle,
+  deleteUnavailability,
+  generateCronExpression,
+  getUnavailabilities,
+  getUnavailabilitiesByVehicle,
+  updateUnavailability
+});

package/dist/index.mjs

@@ -0,0 +1,218 @@
+// src/getUnavailabilitiesByVehicle.ts
+import { z } from "zod";
+var schema = z.object({
+  vehicleId: z.string().trim().min(1).uuid()
+});
+var getUnavailabilitiesByVehicle = async (client, vehicleId) => {
+  const result = schema.safeParse({ vehicleId });
+  if (!result.success) {
+    throw new TypeError("Invalid args", {
+      cause: result.error.issues
+    });
+  }
+  return client.get(
+    `/boapi/proxy/user/fleets/${client.clientOptions.fleetId}/scheduledRules/unavailability/vehicles/${result.data.vehicleId}`
+  ).then(({ data }) => data).catch((error) => {
+    if (error.formattedError?.status === 404) {
+      return [];
+    }
+    throw error;
+  });
+};
+
+// src/getUnavailabilities.ts
+import { z as z2 } from "zod";
+var schema2 = z2.object({
+  from: z2.string().datetime({ offset: false, precision: 0 }),
+  to: z2.string().datetime({ offset: false, precision: 0 }),
+  page: z2.number().int().nonnegative().default(0)
+});
+var getUnavailabilities = async (client, options) => {
+  const result = schema2.safeParse({
+    from: options.from,
+    to: options.to,
+    page: options.page ?? 0
+  });
+  if (!result.success) {
+    throw new TypeError("Invalid args", {
+      cause: result.error.issues
+    });
+  }
+  const allUnavailabilities = [];
+  let currentPage = result.data.page;
+  let hasMorePages = true;
+  const MAX_PAGES = 50;
+  while (hasMorePages) {
+    if (currentPage >= MAX_PAGES) {
+      throw new Error(
+        `Maximum page limit (${MAX_PAGES}) reached. This might indicate an issue with the pagination or a very large dataset.`
+      );
+    }
+    const queryParams = new URLSearchParams({
+      from: result.data.from,
+      to: result.data.to,
+      page: currentPage.toString()
+    });
+    const unavailabilities = await client.get(
+      `/boapi/proxy/user/fleets/${client.clientOptions.fleetId}/scheduledRules/unavailability/vehicles?${queryParams.toString()}`
+    ).then(({ data }) => data).catch((error) => {
+      if (error.formattedError?.status === 404) {
+        return [];
+      }
+      throw error;
+    });
+    allUnavailabilities.push(...unavailabilities);
+    hasMorePages = unavailabilities.length > 0;
+    currentPage += 1;
+  }
+  return allUnavailabilities;
+};
+
+// src/createUnavailability.ts
+import { z as z3 } from "zod";
+var schema3 = z3.object({
+  cronExpression: z3.string().min(1),
+  duration: z3.number().int().positive(),
+  maintenanceTitle: z3.string().min(1),
+  vehicleId: z3.string().uuid()
+});
+var createUnavailability = async (client, body) => {
+  const result = schema3.safeParse(body);
+  if (!result.success) {
+    throw new TypeError("Invalid args", {
+      cause: result.error.issues
+    });
+  }
+  return client.post(
+    `/boapi/proxy/user/fleets/${client.clientOptions.fleetId}/scheduledRules/unavailability`,
+    {
+      cronExpression: result.data.cronExpression,
+      duration: result.data.duration,
+      maintenanceTitle: result.data.maintenanceTitle,
+      vehicleId: result.data.vehicleId
+    }
+  ).then(({ data }) => data);
+};
+
+// src/updateUnavailability.ts
+import { z as z4 } from "zod";
+var schema4 = z4.object({
+  id: z4.number().int().positive(),
+  cronExpression: z4.string().min(1),
+  duration: z4.number().int().positive(),
+  maintenanceTitle: z4.string().min(1),
+  vehicleId: z4.string().uuid()
+});
+var updateUnavailability = async (client, id, body) => {
+  const result = schema4.safeParse({
+    id,
+    ...body
+  });
+  if (!result.success) {
+    throw new TypeError("Invalid args", {
+      cause: result.error.issues
+    });
+  }
+  return client.put(
+    `/boapi/proxy/user/fleets/${client.clientOptions.fleetId}/scheduledRules/unavailability/${result.data.id}`,
+    {
+      cronExpression: result.data.cronExpression,
+      duration: result.data.duration,
+      maintenanceTitle: result.data.maintenanceTitle,
+      vehicleId: result.data.vehicleId
+    }
+  ).then(({ data }) => data);
+};
+
+// src/deleteUnavailability.ts
+import { z as z5 } from "zod";
+var schema5 = z5.object({
+  id: z5.number().int().positive()
+});
+var deleteUnavailability = async (client, id) => {
+  const result = schema5.safeParse({ id });
+  if (!result.success) {
+    throw new TypeError("Invalid args", {
+      cause: result.error.issues
+    });
+  }
+  return client.delete(
+    `/boapi/proxy/user/fleets/${client.clientOptions.fleetId}/scheduledRules/unavailability/${result.data.id}`
+  ).then(() => void 0).catch((error) => {
+    if (error.formattedError?.status === 404) {
+      return void 0;
+    }
+    throw error;
+  });
+};
+
+// src/deleteUnavailabilitiesByVehicle.ts
+import { z as z6 } from "zod";
+var schema6 = z6.object({
+  vehicleId: z6.string().trim().min(1).uuid()
+});
+var deleteUnavailabilitiesByVehicle = async (client, vehicleId) => {
+  const result = schema6.safeParse({ vehicleId });
+  if (!result.success) {
+    throw new TypeError("Invalid args", {
+      cause: result.error.issues
+    });
+  }
+  return client.delete(
+    `/boapi/proxy/user/fleets/${client.clientOptions.fleetId}/scheduledRules/unavailability/vehicles/${result.data.vehicleId}`
+  ).then(() => void 0).catch((error) => {
+    if (error.formattedError?.status === 404) {
+      return void 0;
+    }
+    throw error;
+  });
+};
+
+// src/generateCronExpression.ts
+var generateCronExpression = (date, timezone) => {
+  let dateObj;
+  if (typeof date === "string") {
+    dateObj = new Date(date);
+  } else {
+    dateObj = new Date(date);
+  }
+  if (Number.isNaN(dateObj.getTime())) {
+    throw new TypeError("Invalid date provided");
+  }
+  if (timezone) {
+    const formatter = new Intl.DateTimeFormat("en-US", {
+      timeZone: timezone,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      hour12: false
+    });
+    const parts = formatter.formatToParts(dateObj);
+    const year2 = parseInt(parts.find((p) => p.type === "year")?.value || "0", 10);
+    const month2 = parseInt(parts.find((p) => p.type === "month")?.value || "0", 10);
+    const day2 = parseInt(parts.find((p) => p.type === "day")?.value || "0", 10);
+    const hour2 = parseInt(parts.find((p) => p.type === "hour")?.value || "0", 10);
+    const minute2 = parseInt(parts.find((p) => p.type === "minute")?.value || "0", 10);
+    const second2 = parseInt(parts.find((p) => p.type === "second")?.value || "0", 10);
+    return `${second2} ${minute2} ${hour2} ${day2} ${month2} ? ${year2}`;
+  }
+  const year = dateObj.getFullYear();
+  const month = dateObj.getMonth() + 1;
+  const day = dateObj.getDate();
+  const hour = dateObj.getHours();
+  const minute = dateObj.getMinutes();
+  const second = dateObj.getSeconds();
+  return `${second} ${minute} ${hour} ${day} ${month} ? ${year}`;
+};
+export {
+  createUnavailability,
+  deleteUnavailabilitiesByVehicle,
+  deleteUnavailability,
+  generateCronExpression,
+  getUnavailabilities,
+  getUnavailabilitiesByVehicle,
+  updateUnavailability
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@vulog/aima-unavailability",
-    "version": "1.2.7",
+    "version": "1.2.9",
     "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.7",
-        "@vulog/aima-core": "1.2.7"
+        "@vulog/aima-client": "1.2.9",
+        "@vulog/aima-core": "1.2.9"
     },
     "peerDependencies": {
         "zod": "^3.25.76"

package/src/createUnavailability.test.ts

@@ -37,7 +37,7 @@ describe('createUnavailability', () => {
         };
 
         const mockResponse: Unavailability = {
-            id: '550e8400-e29b-41d4-a716-446655440001',
+            id: 123,
             cronExpression: '0 0 23 * * ? *',
             duration: 60,
             maintenanceTitle: 'GetAround booking 234535',

package/src/deleteUnavailabilitiesByVehicle.test.ts

@@ -0,0 +1,71 @@
+import { describe, test, vi, expect, beforeEach } from 'vitest';
+
+import { Client } from '@vulog/aima-client';
+import { deleteUnavailabilitiesByVehicle } from './deleteUnavailabilitiesByVehicle';
+
+describe('deleteUnavailabilitiesByVehicle', () => {
+    const deleteMock = vi.fn();
+    const client = {
+        delete: deleteMock,
+        clientOptions: {
+            fleetId: 'FLEET_ID',
+        },
+    } as unknown as Client;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    test('should return invalid args for invalid vehicleId', async () => {
+        const vehicleId = 'INVALID_VEHICLE_ID';
+
+        await expect(deleteUnavailabilitiesByVehicle(client, vehicleId)).rejects.toThrow('Invalid args');
+    });
+
+    test('should handle 404 gracefully (idempotent)', async () => {
+        const vehicleId = '550e8400-e29b-41d4-a716-446655440000';
+
+        deleteMock.mockRejectedValueOnce({
+            formattedError: {
+                status: 404,
+            },
+        });
+
+        const result = await deleteUnavailabilitiesByVehicle(client, vehicleId);
+        expect(result).toBeUndefined();
+        expect(deleteMock).toBeCalledWith(
+            `/boapi/proxy/user/fleets/FLEET_ID/scheduledRules/unavailability/vehicles/${vehicleId}`
+        );
+    });
+
+    test('should delete unavailabilities by vehicle successfully', async () => {
+        const vehicleId = '550e8400-e29b-41d4-a716-446655440000';
+
+        deleteMock.mockResolvedValueOnce({
+            data: undefined,
+        });
+
+        const result = await deleteUnavailabilitiesByVehicle(client, vehicleId);
+        expect(result).toBeUndefined();
+        expect(deleteMock).toBeCalledWith(
+            `/boapi/proxy/user/fleets/FLEET_ID/scheduledRules/unavailability/vehicles/${vehicleId}`
+        );
+    });
+
+    test('should throw error on non-404 errors', async () => {
+        const vehicleId = '550e8400-e29b-41d4-a716-446655440000';
+
+        deleteMock.mockRejectedValueOnce({
+            formattedError: {
+                status: 500,
+            },
+        });
+
+        await expect(deleteUnavailabilitiesByVehicle(client, vehicleId)).rejects.toEqual({
+            formattedError: {
+                status: 500,
+            },
+        });
+    });
+});
+

package/src/deleteUnavailabilitiesByVehicle.ts

@@ -0,0 +1,28 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+const schema = z.object({
+    vehicleId: z.string().trim().min(1).uuid(),
+});
+
+export const deleteUnavailabilitiesByVehicle = async (client: Client, vehicleId: string): Promise<void> => {
+    const result = schema.safeParse({ vehicleId });
+    if (!result.success) {
+        throw new TypeError('Invalid args', {
+            cause: result.error.issues,
+        });
+    }
+    return client
+        .delete(
+            `/boapi/proxy/user/fleets/${client.clientOptions.fleetId}/scheduledRules/unavailability/vehicles/${result.data.vehicleId}`
+        )
+        .then(() => undefined)
+        .catch((error) => {
+            // Handle 404 gracefully (idempotent - if vehicle has no unavailabilities, that's fine)
+            if (error.formattedError?.status === 404) {
+                return undefined;
+            }
+            throw error;
+        });
+};
+

package/src/deleteUnavailability.test.ts

@@ -17,13 +17,13 @@ describe('deleteUnavailability', () => {
     });
 
     test('should return invalid args for invalid id', async () => {
-        const id = 'INVALID_UUID';
+        const id = -1;
 
         await expect(deleteUnavailability(client, id)).rejects.toThrow('Invalid args');
     });
 
     test('should handle 404 gracefully (idempotent)', async () => {
-        const id = '550e8400-e29b-41d4-a716-446655440001';
+        const id = 123;
 
         deleteMock.mockRejectedValueOnce({
             formattedError: {
@@ -39,7 +39,7 @@ describe('deleteUnavailability', () => {
     });
 
     test('should delete unavailability successfully', async () => {
-        const id = '550e8400-e29b-41d4-a716-446655440001';
+        const id = 123;
 
         deleteMock.mockResolvedValueOnce({
             data: undefined,
@@ -53,7 +53,7 @@ describe('deleteUnavailability', () => {
     });
 
     test('should throw error on non-404 errors', async () => {
-        const id = '550e8400-e29b-41d4-a716-446655440001';
+        const id = 123;
 
         deleteMock.mockRejectedValueOnce({
             formattedError: {

package/src/deleteUnavailability.ts

@@ -2,10 +2,10 @@ import { Client } from '@vulog/aima-client';
 import { z } from 'zod';
 
 const schema = z.object({
-    id: z.string().trim().min(1).uuid(),
+    id: z.number().int().positive(),
 });
 
-export const deleteUnavailability = async (client: Client, id: string): Promise<void> => {
+export const deleteUnavailability = async (client: Client, id: number): Promise<void> => {
     const result = schema.safeParse({ id });
     if (!result.success) {
         throw new TypeError('Invalid args', {

package/src/getUnavailabilities.test.ts

@@ -51,7 +51,7 @@ describe('getUnavailabilities', () => {
 
         const mockResponsePage1: Unavailability[] = [
             {
-                id: '550e8400-e29b-41d4-a716-446655440001',
+                id: 123,
                 cronExpression: '0 0 23 * * ? *',
                 duration: 60,
                 maintenanceTitle: 'GetAround booking 234535',
@@ -83,7 +83,7 @@ describe('getUnavailabilities', () => {
 
         const mockResponse: Unavailability[] = [
             {
-                id: '550e8400-e29b-41d4-a716-446655440001',
+                id: 123,
                 cronExpression: '0 0 23 * * ? *',
                 duration: 60,
                 maintenanceTitle: 'GetAround booking 234535',

package/src/getUnavailabilitiesByVehicle.test.ts

@@ -41,7 +41,7 @@ describe('getUnavailabilitiesByVehicle', () => {
 
         const mockResponse: Unavailability[] = [
             {
-                id: '550e8400-e29b-41d4-a716-446655440001',
+                id: 123,
                 cronExpression: '0 0 23 * * ? *',
                 duration: 60,
                 maintenanceTitle: 'GetAround booking 234535',

package/src/index.ts

@@ -3,5 +3,6 @@ export { getUnavailabilities } from './getUnavailabilities';
 export { createUnavailability } from './createUnavailability';
 export { updateUnavailability } from './updateUnavailability';
 export { deleteUnavailability } from './deleteUnavailability';
+export { deleteUnavailabilitiesByVehicle } from './deleteUnavailabilitiesByVehicle';
 export { generateCronExpression } from './generateCronExpression';
 export * from './types';

package/src/types.ts

@@ -1,5 +1,5 @@
 export type Unavailability = {
-    id: string;
+    id: number;
     cronExpression: string;
     duration: number;
     maintenanceTitle: string;

package/src/updateUnavailability.test.ts

@@ -18,7 +18,7 @@ describe('updateUnavailability', () => {
     });
 
     test('should return invalid args for invalid id', async () => {
-        const id = 'INVALID_UUID';
+        const id = -1;
         const body = {
             cronExpression: '0 0 23 * * ? *',
             duration: 60,
@@ -30,7 +30,7 @@ describe('updateUnavailability', () => {
     });
 
     test('should return invalid args for invalid body', async () => {
-        const id = '550e8400-e29b-41d4-a716-446655440001';
+        const id = 123;
         const body = {
             cronExpression: '',
             duration: -1,
@@ -42,7 +42,7 @@ describe('updateUnavailability', () => {
     });
 
     test('should update unavailability successfully', async () => {
-        const id = '550e8400-e29b-41d4-a716-446655440001';
+        const id = 123;
         const body = {
             cronExpression: '0 0 24 * * ? *',
             duration: 120,

package/src/updateUnavailability.ts

@@ -4,7 +4,7 @@ import { z } from 'zod';
 import { UpdateUnavailabilityBody, Unavailability } from './types';
 
 const schema = z.object({
-    id: z.string().trim().min(1).uuid(),
+    id: z.number().int().positive(),
     cronExpression: z.string().min(1),
     duration: z.number().int().positive(),
     maintenanceTitle: z.string().min(1),
@@ -13,7 +13,7 @@ const schema = z.object({
 
 export const updateUnavailability = async (
     client: Client,
-    id: string,
+    id: number,
     body: UpdateUnavailabilityBody
 ): Promise<Unavailability> => {
     const result = schema.safeParse({

package/API_SUMMARY.md

@@ -1,36 +0,0 @@
-# Vulog Unavailability API Calls - Summary
-
-## Implemented API Endpoints
-
-### 1. GET `/boapi/proxy/user/fleets/{fleetId}/scheduledRules/unavailability/vehicles/{vehicleId}`
-Lists all unavailability rules for a specific vehicle. Returns array of `Unavailability` objects. Returns empty array on 404.
-
-### 2. GET `/boapi/proxy/user/fleets/{fleetId}/scheduledRules/unavailability/vehicles`
-Lists unavailability rules with date range filtering and pagination. Query parameters: `from` (ISO date), `to` (ISO date), `page` (number). Automatically iterates through pages until no more results.
-
-### 3. POST `/boapi/proxy/user/fleets/{fleetId}/scheduledRules/unavailability`
-Creates a new unavailability rule. Request body: `{ cronExpression, duration, maintenanceTitle, vehicleId }`. Returns created `Unavailability` object.
-
-### 4. PUT `/boapi/proxy/user/fleets/{fleetId}/scheduledRules/unavailability/{id}`
-Updates an existing unavailability rule. Request body same as POST. Returns updated `Unavailability` object.
-
-### 5. DELETE `/boapi/proxy/user/fleets/{fleetId}/scheduledRules/unavailability/{id}`
-Deletes an unavailability rule by ID. Idempotent - returns successfully if already deleted (404).
-
-## Utility Function
-
-### `generateCronExpression(date: Date | string, timezone?: string): string`
-Generates Quartz cron expression from a date. Supports timezone conversion. Format: `second minute hour day month ? year`.
-
-## Type Definitions
-
-```typescript
-type Unavailability = {
-    id: string;
-    cronExpression: string;
-    duration: number;
-    maintenanceTitle: string;
-    vehicleId: string;
-};
-```
-