@vulog/aima-unavailability 1.2.7

package/.eslintrc.js

@@ -0,0 +1,112 @@
+module.exports = {
+    parser: '@typescript-eslint/parser',
+    parserOptions: {
+        // Indicates the location of the TypeScript configuration file
+        project: 'tsconfig.json',
+        // Sets the root directory for the TypeScript configuration
+        tsconfigRootDir: __dirname,
+        // Specifies the version of ECMAScript syntax to be used
+        ecmaVersion: 'latest',
+        // Indicates the type of source code (script or module)
+        sourceType: 'module',
+    },
+    plugins: ['@typescript-eslint', 'prettier', 'import'],
+    extends: [
+        'airbnb-base',
+        'airbnb-typescript/base',
+        'plugin:@typescript-eslint/recommended',
+        'prettier',
+        'plugin:prettier/recommended',
+    ],
+    root: true,
+    env: {
+        es6: true,
+        node: true,
+    },
+    ignorePatterns: [
+        '/dist/**/*', // Ignore built files.
+        '.eslintrc.js',
+        '**/*.test.ts',
+    ],
+    rules: {
+        // Configures the Prettier integration with ESLint
+        'prettier/prettier': ['error', { endOfLine: 'auto' }],
+        // Disables the rule requiring an 'I' prefix for interfaces
+        '@typescript-eslint/interface-name-prefix': 'off',
+        // Configures the naming conventions for various code constructs
+        '@typescript-eslint/naming-convention': [
+            // ... various naming convention configurations ...
+            'error',
+            // Allows any naming format for destructured variables
+            {
+                selector: 'variable',
+                modifiers: ['destructured'],
+                format: null,
+            },
+            // Requires strict camelCase for function names
+            {
+                selector: 'function',
+                format: ['strictCamelCase'],
+            },
+            // Requires boolean variables to have one of the specified prefixes
+            {
+                selector: 'variable',
+                format: null,
+                types: ['boolean'],
+                prefix: ['is', 'should', 'has', 'can', 'did', 'will'],
+            },
+            // Requires enum names to have a strict PascalCase format
+            {
+                selector: 'enum',
+                format: ['StrictPascalCase'],
+            },
+        ],
+        'import/extensions': 'off',
+        // Disables the rule requiring explicit return types for functions
+        '@typescript-eslint/explicit-function-return-type': 'off',
+        // Disables the rule requiring explicit boundary types for modules
+        '@typescript-eslint/explicit-module-boundary-types': 'off',
+        // Disables the rule prohibiting the use of 'any' type
+        '@typescript-eslint/no-explicit-any': 'off',
+        // Disables the rule detecting unused variables
+        'no-unused-vars': 0,
+        // Disables the rule disallowing named exports used as a default export
+        'import/no-named-as-default': 0,
+        // Configures the order and formatting of import statements
+        'import/order': [
+            // ... import order configuration ...
+            'error',
+            {
+                // Configure the alphabetization settings
+                alphabetize: {
+                    // Enforce ascending alphabetical order
+                    order: 'asc',
+                    // Do not ignore the case while sorting
+                    caseInsensitive: false,
+                },
+                // Enforce newlines between different groups and inside groups of imports
+                'newlines-between': 'always-and-inside-groups',
+                // Warn when there is an import statement that is not part of any group
+                warnOnUnassignedImports: true,
+            },
+        ],
+        // Configures the rule detecting extraneous dependencies
+        'import/no-extraneous-dependencies': [
+            // ... extraneous dependencies configuration ...
+            'error',
+            {
+                // Specify the file patterns where devDependencies imports are allowed
+                devDependencies: [
+                    // Allow devDependencies imports in test and spec files
+                    '**/*.test.{ts,js}',
+                    '**/*.spec.{ts,js}',
+                    // Allow devDependencies imports in the 'test' folder
+                    './test/**.{ts,js}',
+                    // Allow devDependencies imports in the 'scripts' folder
+                    './scripts/**/*.{ts,js}',
+                ],
+            },
+        ],
+        'import/prefer-default-export': 'off',
+    },
+};

package/API_SUMMARY.md

@@ -0,0 +1,36 @@
+# 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;
+};
+```
+

package/package.json

@@ -0,0 +1,29 @@
+{
+    "name": "@vulog/aima-unavailability",
+    "version": "1.2.7",
+    "main": "dist/index.js",
+    "module": "dist/index.mjs",
+    "types": "dist/index.d.ts",
+    "scripts": {
+        "build": "tsup",
+        "dev": "tsup --watch",
+        "test": "vitest run",
+        "test:watch": "vitest",
+        "lint": "eslint src/**/* --ext .ts"
+    },
+    "keywords": [
+        "AIMA",
+        "VULOG",
+        "UNAVAILABILITY"
+    ],
+    "author": "Vulog",
+    "license": "MIT",
+    "dependencies": {
+        "@vulog/aima-client": "1.2.7",
+        "@vulog/aima-core": "1.2.7"
+    },
+    "peerDependencies": {
+        "zod": "^3.25.76"
+    },
+    "description": ""
+}

package/src/createUnavailability.test.ts

@@ -0,0 +1,64 @@
+import { describe, test, vi, expect, beforeEach } from 'vitest';
+
+import { Client } from '@vulog/aima-client';
+import { createUnavailability } from './createUnavailability';
+import { Unavailability } from './types';
+
+describe('createUnavailability', () => {
+    const postMock = vi.fn();
+    const client = {
+        post: postMock,
+        clientOptions: {
+            fleetId: 'FLEET_ID',
+        },
+    } as unknown as Client;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    test('should return invalid args for invalid body', async () => {
+        const body = {
+            cronExpression: '',
+            duration: -1,
+            maintenanceTitle: '',
+            vehicleId: 'INVALID_UUID',
+        };
+
+        await expect(createUnavailability(client, body)).rejects.toThrow('Invalid args');
+    });
+
+    test('should create unavailability successfully', async () => {
+        const body = {
+            cronExpression: '0 0 23 * * ? *',
+            duration: 60,
+            maintenanceTitle: 'GetAround booking 234535',
+            vehicleId: '550e8400-e29b-41d4-a716-446655440000',
+        };
+
+        const mockResponse: Unavailability = {
+            id: '550e8400-e29b-41d4-a716-446655440001',
+            cronExpression: '0 0 23 * * ? *',
+            duration: 60,
+            maintenanceTitle: 'GetAround booking 234535',
+            vehicleId: '550e8400-e29b-41d4-a716-446655440000',
+        };
+
+        postMock.mockResolvedValueOnce({
+            data: mockResponse,
+        });
+
+        const result = await createUnavailability(client, body);
+        expect(result).toEqual(mockResponse);
+        expect(postMock).toBeCalledWith(
+            `/boapi/proxy/user/fleets/FLEET_ID/scheduledRules/unavailability`,
+            {
+                cronExpression: body.cronExpression,
+                duration: body.duration,
+                maintenanceTitle: body.maintenanceTitle,
+                vehicleId: body.vehicleId,
+            }
+        );
+    });
+});
+

package/src/createUnavailability.ts

@@ -0,0 +1,31 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { CreateUnavailabilityBody, Unavailability } from './types';
+
+const schema = z.object({
+    cronExpression: z.string().min(1),
+    duration: z.number().int().positive(),
+    maintenanceTitle: z.string().min(1),
+    vehicleId: z.string().uuid(),
+});
+
+export const createUnavailability = async (client: Client, body: CreateUnavailabilityBody): Promise<Unavailability> => {
+    const result = schema.safeParse(body);
+    if (!result.success) {
+        throw new TypeError('Invalid args', {
+            cause: result.error.issues,
+        });
+    }
+    return client
+        .post<Unavailability>(
+            `/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);
+};

package/src/deleteUnavailability.test.ts

@@ -0,0 +1,71 @@
+import { describe, test, vi, expect, beforeEach } from 'vitest';
+
+import { Client } from '@vulog/aima-client';
+import { deleteUnavailability } from './deleteUnavailability';
+
+describe('deleteUnavailability', () => {
+    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 id', async () => {
+        const id = 'INVALID_UUID';
+
+        await expect(deleteUnavailability(client, id)).rejects.toThrow('Invalid args');
+    });
+
+    test('should handle 404 gracefully (idempotent)', async () => {
+        const id = '550e8400-e29b-41d4-a716-446655440001';
+
+        deleteMock.mockRejectedValueOnce({
+            formattedError: {
+                status: 404,
+            },
+        });
+
+        const result = await deleteUnavailability(client, id);
+        expect(result).toBeUndefined();
+        expect(deleteMock).toBeCalledWith(
+            `/boapi/proxy/user/fleets/FLEET_ID/scheduledRules/unavailability/${id}`
+        );
+    });
+
+    test('should delete unavailability successfully', async () => {
+        const id = '550e8400-e29b-41d4-a716-446655440001';
+
+        deleteMock.mockResolvedValueOnce({
+            data: undefined,
+        });
+
+        const result = await deleteUnavailability(client, id);
+        expect(result).toBeUndefined();
+        expect(deleteMock).toBeCalledWith(
+            `/boapi/proxy/user/fleets/FLEET_ID/scheduledRules/unavailability/${id}`
+        );
+    });
+
+    test('should throw error on non-404 errors', async () => {
+        const id = '550e8400-e29b-41d4-a716-446655440001';
+
+        deleteMock.mockRejectedValueOnce({
+            formattedError: {
+                status: 500,
+            },
+        });
+
+        await expect(deleteUnavailability(client, id)).rejects.toEqual({
+            formattedError: {
+                status: 500,
+            },
+        });
+    });
+});
+

package/src/deleteUnavailability.ts

@@ -0,0 +1,27 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+const schema = z.object({
+    id: z.string().trim().min(1).uuid(),
+});
+
+export const deleteUnavailability = async (client: Client, id: string): Promise<void> => {
+    const result = schema.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(() => undefined)
+        .catch((error) => {
+            // Handle 404 gracefully (idempotent - if already deleted, that's fine)
+            if (error.formattedError?.status === 404) {
+                return undefined;
+            }
+            throw error;
+        });
+};

package/src/generateCronExpression.test.ts

@@ -0,0 +1,112 @@
+import { describe, test, expect } from 'vitest';
+
+import { generateCronExpression } from './generateCronExpression';
+
+describe('generateCronExpression', () => {
+    test('should generate cron expression from Date object', () => {
+        const date = new Date('2018-08-14T23:00:00Z');
+        const cron = generateCronExpression(date);
+
+        // Note: This will depend on the local timezone where the test runs
+        // The date is in UTC, so we expect it to be converted to local time
+        // Just verify the format is correct
+        expect(cron).toMatch(/^\d+ \d+ \d+ \d+ 8 \? 2018$/);
+        expect(cron.split(' ').length).toBe(7);
+    });
+
+    test('should generate cron expression from ISO string', () => {
+        const dateStr = '2018-08-14T23:00:00Z';
+        const cron = generateCronExpression(dateStr);
+
+        // Just verify the format is correct (date will vary by timezone)
+        expect(cron).toMatch(/^\d+ \d+ \d+ \d+ 8 \? 2018$/);
+        expect(cron.split(' ').length).toBe(7);
+    });
+
+    test('should generate cron expression with specific timezone', () => {
+        // Test with Europe/Paris timezone (UTC+2 in summer)
+        const date = new Date('2018-08-14T21:00:00Z'); // 21:00 UTC = 23:00 CEST
+        const cron = generateCronExpression(date, 'Europe/Paris');
+
+        // Should be 23:00 in Paris timezone
+        expect(cron).toMatch(/^\d+ 0 23 14 8 \? 2018$/);
+    });
+
+    test('should generate cron expression with America/New_York timezone', () => {
+        // Test with America/New_York timezone (UTC-4 in summer)
+        const date = new Date('2018-08-14T23:00:00Z'); // 23:00 UTC = 19:00 EDT
+        const cron = generateCronExpression(date, 'America/New_York');
+
+        // Should be 19:00 in New York timezone
+        expect(cron).toMatch(/^\d+ 0 19 14 8 \? 2018$/);
+    });
+
+    test('should handle date with specific time components', () => {
+        const date = new Date('2018-08-14T15:30:45Z');
+        const cron = generateCronExpression(date, 'UTC');
+
+        // Should match: 45 30 15 14 8 ? 2018
+        expect(cron).toBe('45 30 15 14 8 ? 2018');
+    });
+
+    test('should handle date at midnight', () => {
+        const date = new Date('2018-08-14T00:00:00Z');
+        const cron = generateCronExpression(date, 'UTC');
+
+        expect(cron).toBe('0 0 0 14 8 ? 2018');
+    });
+
+    test('should handle date at end of day', () => {
+        const date = new Date('2018-08-14T23:59:59Z');
+        const cron = generateCronExpression(date, 'UTC');
+
+        expect(cron).toBe('59 59 23 14 8 ? 2018');
+    });
+
+    test('should handle different months correctly', () => {
+        const date = new Date('2018-12-25T12:00:00Z');
+        const cron = generateCronExpression(date, 'UTC');
+
+        expect(cron).toBe('0 0 12 25 12 ? 2018');
+    });
+
+    test('should handle different years correctly', () => {
+        const date = new Date('2024-01-01T00:00:00Z');
+        const cron = generateCronExpression(date, 'UTC');
+
+        expect(cron).toBe('0 0 0 1 1 ? 2024');
+    });
+
+    test('should throw error for invalid date string', () => {
+        expect(() => generateCronExpression('invalid-date')).toThrow('Invalid date provided');
+    });
+
+    test('should throw error for invalid Date object', () => {
+        const invalidDate = new Date('invalid');
+        expect(() => generateCronExpression(invalidDate)).toThrow('Invalid date provided');
+    });
+
+    test('should handle timezone conversion correctly for different dates', () => {
+        // Test with a date that might have different DST rules
+        const date = new Date('2018-01-14T12:00:00Z'); // Winter in Europe/Paris (UTC+1)
+        const cron = generateCronExpression(date, 'Europe/Paris');
+
+        // Should be 13:00 in Paris timezone (UTC+1 in winter)
+        expect(cron).toMatch(/^\d+ 0 13 14 1 \? 2018$/);
+    });
+
+    test('should handle edge case: last day of month', () => {
+        const date = new Date('2018-01-31T12:00:00Z');
+        const cron = generateCronExpression(date, 'UTC');
+
+        expect(cron).toBe('0 0 12 31 1 ? 2018');
+    });
+
+    test('should handle edge case: leap year February 29', () => {
+        const date = new Date('2020-02-29T12:00:00Z');
+        const cron = generateCronExpression(date, 'UTC');
+
+        expect(cron).toBe('0 0 12 29 2 ? 2020');
+    });
+});
+

package/src/generateCronExpression.ts

@@ -0,0 +1,61 @@
+/**
+ * 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
+ */
+export const generateCronExpression = (date: Date | string, timezone?: string): string => {
+    let dateObj: Date;
+
+    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 is provided, convert to that timezone
+    if (timezone) {
+        // Use Intl.DateTimeFormat to get the date components in the specified 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 year = parseInt(parts.find((p) => p.type === 'year')?.value || '0', 10);
+        const month = parseInt(parts.find((p) => p.type === 'month')?.value || '0', 10);
+        const day = parseInt(parts.find((p) => p.type === 'day')?.value || '0', 10);
+        const hour = parseInt(parts.find((p) => p.type === 'hour')?.value || '0', 10);
+        const minute = parseInt(parts.find((p) => p.type === 'minute')?.value || '0', 10);
+        const second = parseInt(parts.find((p) => p.type === 'second')?.value || '0', 10);
+
+        // Format: second minute hour day month ? year
+        return `${second} ${minute} ${hour} ${day} ${month} ? ${year}`;
+    }
+
+    // If no timezone, use local time components
+    const year = dateObj.getFullYear();
+    const month = dateObj.getMonth() + 1; // getMonth() returns 0-11, cron expects 1-12
+    const day = dateObj.getDate();
+    const hour = dateObj.getHours();
+    const minute = dateObj.getMinutes();
+    const second = dateObj.getSeconds();
+
+    // Format: second minute hour day month ? year
+    return `${second} ${minute} ${hour} ${day} ${month} ? ${year}`;
+};

package/src/getUnavailabilities.test.ts

@@ -0,0 +1,123 @@
+import { describe, test, vi, expect, beforeEach } from 'vitest';
+
+import { Client } from '@vulog/aima-client';
+import { getUnavailabilities } from './getUnavailabilities';
+import { Unavailability } from './types';
+
+describe('getUnavailabilities', () => {
+    const getMock = vi.fn();
+    const client = {
+        get: getMock,
+        clientOptions: {
+            fleetId: 'FLEET_ID',
+        },
+    } as unknown as Client;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    test('should return invalid args for invalid date format', async () => {
+        const options = {
+            from: 'invalid-date',
+            to: '2018-08-16T07:30:00Z',
+        };
+
+        await expect(getUnavailabilities(client, options)).rejects.toThrow('Invalid args');
+    });
+
+    test('should return empty array on 404', async () => {
+        const options = {
+            from: '2018-08-14T07:30:00Z',
+            to: '2018-08-16T07:30:00Z',
+        };
+
+        getMock.mockRejectedValueOnce({
+            formattedError: {
+                status: 404,
+            },
+        });
+
+        const result = await getUnavailabilities(client, options);
+        expect(result).toEqual([]);
+    });
+
+    test('should get unavailabilities successfully with pagination', async () => {
+        const options = {
+            from: '2018-08-14T07:30:00Z',
+            to: '2018-08-16T07:30:00Z',
+            page: 0,
+        };
+
+        const mockResponsePage1: Unavailability[] = [
+            {
+                id: '550e8400-e29b-41d4-a716-446655440001',
+                cronExpression: '0 0 23 * * ? *',
+                duration: 60,
+                maintenanceTitle: 'GetAround booking 234535',
+                vehicleId: '550e8400-e29b-41d4-a716-446655440000',
+            },
+        ];
+
+        const mockResponsePage2: Unavailability[] = [];
+
+        getMock
+            .mockResolvedValueOnce({
+                data: mockResponsePage1,
+            })
+            .mockResolvedValueOnce({
+                data: mockResponsePage2,
+            });
+
+        const result = await getUnavailabilities(client, options);
+        expect(result).toEqual(mockResponsePage1);
+        expect(getMock).toBeCalledTimes(2);
+    });
+
+    test('should throw error when max pages reached', async () => {
+        const options = {
+            from: '2018-08-14T07:30:00Z',
+            to: '2018-08-16T07:30:00Z',
+            page: 0,
+        };
+
+        const mockResponse: Unavailability[] = [
+            {
+                id: '550e8400-e29b-41d4-a716-446655440001',
+                cronExpression: '0 0 23 * * ? *',
+                duration: 60,
+                maintenanceTitle: 'GetAround booking 234535',
+                vehicleId: '550e8400-e29b-41d4-a716-446655440000',
+            },
+        ];
+
+        // Mock 51 pages to trigger max pages error
+        for (let i = 0; i < 51; i++) {
+            getMock.mockResolvedValueOnce({
+                data: mockResponse,
+            });
+        }
+
+        await expect(getUnavailabilities(client, options)).rejects.toThrow('Maximum page limit');
+    });
+
+    test('should throw error on non-404 errors', async () => {
+        const options = {
+            from: '2018-08-14T07:30:00Z',
+            to: '2018-08-16T07:30:00Z',
+        };
+
+        getMock.mockRejectedValueOnce({
+            formattedError: {
+                status: 500,
+            },
+        });
+
+        await expect(getUnavailabilities(client, options)).rejects.toEqual({
+            formattedError: {
+                status: 500,
+            },
+        });
+    });
+});
+

package/src/getUnavailabilities.ts

@@ -0,0 +1,67 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { Unavailability, UnavailabilityOptions } from './types';
+
+const schema = z.object({
+    from: z.string().datetime({ offset: false, precision: 0 }),
+    to: z.string().datetime({ offset: false, precision: 0 }),
+    page: z.number().int().nonnegative().default(0),
+});
+
+export const getUnavailabilities = async (
+    client: Client,
+    options: UnavailabilityOptions
+): Promise<Unavailability[]> => {
+    const result = schema.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: Unavailability[] = [];
+    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(),
+        });
+
+        // eslint-disable-next-line no-await-in-loop -- Pagination requires sequential API calls
+        const unavailabilities = await client
+            .get<Unavailability[]>(
+                `/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);
+
+        // Stop if we received fewer unavailabilities than expected (including 0)
+        // Assuming page size is consistent, stop when we get an empty array
+        hasMorePages = unavailabilities.length > 0;
+        currentPage += 1;
+    }
+
+    return allUnavailabilities;
+};

package/src/getUnavailabilitiesByVehicle.test.ts

@@ -0,0 +1,79 @@
+import { describe, test, vi, expect, beforeEach } from 'vitest';
+
+import { Client } from '@vulog/aima-client';
+import { getUnavailabilitiesByVehicle } from './getUnavailabilitiesByVehicle';
+import { Unavailability } from './types';
+
+describe('getUnavailabilitiesByVehicle', () => {
+    const getMock = vi.fn();
+    const client = {
+        get: getMock,
+        clientOptions: {
+            fleetId: 'FLEET_ID',
+        },
+    } as unknown as Client;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    test('should return invalid args', async () => {
+        const vehicleId = 'INVALID_VEHICLE_ID';
+
+        await expect(getUnavailabilitiesByVehicle(client, vehicleId)).rejects.toThrow('Invalid args');
+    });
+
+    test('should return empty array on 404', async () => {
+        const vehicleId = '550e8400-e29b-41d4-a716-446655440000';
+
+        getMock.mockRejectedValueOnce({
+            formattedError: {
+                status: 404,
+            },
+        });
+
+        const result = await getUnavailabilitiesByVehicle(client, vehicleId);
+        expect(result).toEqual([]);
+    });
+
+    test('should get unavailabilities by vehicle successfully', async () => {
+        const vehicleId = '550e8400-e29b-41d4-a716-446655440000';
+
+        const mockResponse: Unavailability[] = [
+            {
+                id: '550e8400-e29b-41d4-a716-446655440001',
+                cronExpression: '0 0 23 * * ? *',
+                duration: 60,
+                maintenanceTitle: 'GetAround booking 234535',
+                vehicleId: '550e8400-e29b-41d4-a716-446655440000',
+            },
+        ];
+
+        getMock.mockResolvedValueOnce({
+            data: mockResponse,
+        });
+
+        const result = await getUnavailabilitiesByVehicle(client, vehicleId);
+        expect(result).toEqual(mockResponse);
+        expect(getMock).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';
+
+        getMock.mockRejectedValueOnce({
+            formattedError: {
+                status: 500,
+            },
+        });
+
+        await expect(getUnavailabilitiesByVehicle(client, vehicleId)).rejects.toEqual({
+            formattedError: {
+                status: 500,
+            },
+        });
+    });
+});
+

package/src/getUnavailabilitiesByVehicle.ts

@@ -0,0 +1,28 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { Unavailability } from './types';
+
+const schema = z.object({
+    vehicleId: z.string().trim().min(1).uuid(),
+});
+
+export const getUnavailabilitiesByVehicle = async (client: Client, vehicleId: string): Promise<Unavailability[]> => {
+    const result = schema.safeParse({ vehicleId });
+    if (!result.success) {
+        throw new TypeError('Invalid args', {
+            cause: result.error.issues,
+        });
+    }
+    return client
+        .get<Unavailability[]>(
+            `/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;
+        });
+};

package/src/index.ts

@@ -0,0 +1,7 @@
+export { getUnavailabilitiesByVehicle } from './getUnavailabilitiesByVehicle';
+export { getUnavailabilities } from './getUnavailabilities';
+export { createUnavailability } from './createUnavailability';
+export { updateUnavailability } from './updateUnavailability';
+export { deleteUnavailability } from './deleteUnavailability';
+export { generateCronExpression } from './generateCronExpression';
+export * from './types';

package/src/types.ts

@@ -0,0 +1,22 @@
+export type Unavailability = {
+    id: string;
+    cronExpression: string;
+    duration: number;
+    maintenanceTitle: string;
+    vehicleId: string;
+};
+
+export type CreateUnavailabilityBody = {
+    cronExpression: string;
+    duration: number;
+    maintenanceTitle: string;
+    vehicleId: string;
+};
+
+export type UpdateUnavailabilityBody = CreateUnavailabilityBody;
+
+export type UnavailabilityOptions = {
+    from: string; // ISO date time
+    to: string; // ISO date time
+    page?: number;
+};

package/src/updateUnavailability.test.ts

@@ -0,0 +1,78 @@
+import { describe, test, vi, expect, beforeEach } from 'vitest';
+
+import { Client } from '@vulog/aima-client';
+import { updateUnavailability } from './updateUnavailability';
+import { Unavailability } from './types';
+
+describe('updateUnavailability', () => {
+    const putMock = vi.fn();
+    const client = {
+        put: putMock,
+        clientOptions: {
+            fleetId: 'FLEET_ID',
+        },
+    } as unknown as Client;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    test('should return invalid args for invalid id', async () => {
+        const id = 'INVALID_UUID';
+        const body = {
+            cronExpression: '0 0 23 * * ? *',
+            duration: 60,
+            maintenanceTitle: 'GetAround booking 234535',
+            vehicleId: '550e8400-e29b-41d4-a716-446655440000',
+        };
+
+        await expect(updateUnavailability(client, id, body)).rejects.toThrow('Invalid args');
+    });
+
+    test('should return invalid args for invalid body', async () => {
+        const id = '550e8400-e29b-41d4-a716-446655440001';
+        const body = {
+            cronExpression: '',
+            duration: -1,
+            maintenanceTitle: '',
+            vehicleId: 'INVALID_UUID',
+        };
+
+        await expect(updateUnavailability(client, id, body)).rejects.toThrow('Invalid args');
+    });
+
+    test('should update unavailability successfully', async () => {
+        const id = '550e8400-e29b-41d4-a716-446655440001';
+        const body = {
+            cronExpression: '0 0 24 * * ? *',
+            duration: 120,
+            maintenanceTitle: 'GetAround booking 234535 updated',
+            vehicleId: '550e8400-e29b-41d4-a716-446655440000',
+        };
+
+        const mockResponse: Unavailability = {
+            id: id,
+            cronExpression: '0 0 24 * * ? *',
+            duration: 120,
+            maintenanceTitle: 'GetAround booking 234535 updated',
+            vehicleId: '550e8400-e29b-41d4-a716-446655440000',
+        };
+
+        putMock.mockResolvedValueOnce({
+            data: mockResponse,
+        });
+
+        const result = await updateUnavailability(client, id, body);
+        expect(result).toEqual(mockResponse);
+        expect(putMock).toBeCalledWith(
+            `/boapi/proxy/user/fleets/FLEET_ID/scheduledRules/unavailability/${id}`,
+            {
+                cronExpression: body.cronExpression,
+                duration: body.duration,
+                maintenanceTitle: body.maintenanceTitle,
+                vehicleId: body.vehicleId,
+            }
+        );
+    });
+});
+

package/src/updateUnavailability.ts

@@ -0,0 +1,39 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { UpdateUnavailabilityBody, Unavailability } from './types';
+
+const schema = z.object({
+    id: z.string().trim().min(1).uuid(),
+    cronExpression: z.string().min(1),
+    duration: z.number().int().positive(),
+    maintenanceTitle: z.string().min(1),
+    vehicleId: z.string().uuid(),
+});
+
+export const updateUnavailability = async (
+    client: Client,
+    id: string,
+    body: UpdateUnavailabilityBody
+): Promise<Unavailability> => {
+    const result = schema.safeParse({
+        id,
+        ...body,
+    });
+    if (!result.success) {
+        throw new TypeError('Invalid args', {
+            cause: result.error.issues,
+        });
+    }
+    return client
+        .put<Unavailability>(
+            `/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);
+};

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+    "include": ["src"],
+    "exclude": ["**/*.test.ts"],
+    "compilerOptions": {
+        "module": "esnext",
+        "target": "esnext",
+        "lib": ["esnext"],
+        "declaration": true,
+        "strict": true,
+        "moduleResolution": "node",
+        "skipLibCheck": true,
+        "esModuleInterop": true,
+        "outDir": "dist",
+        "rootDir": "src"
+    }
+}
+

package/tsup.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+    entry: ['src/index.ts'],
+    clean: true,
+    format: ['cjs', 'esm'],
+    dts: true,
+});
+

package/vitest.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+    test: {
+        globals: true,
+        environment: 'node',
+    },
+});
+