@vulog/aima-business 1.2.39

package/src/addBusinessCredit.ts

@@ -0,0 +1,31 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+export type AddBusinessCreditBody = {
+    amount: number;
+};
+
+const bodySchema = z.object({
+    amount: z.number().min(0),
+});
+
+export const addBusinessCredit = async (
+    client: Client,
+    businessId: string,
+    body: AddBusinessCreditBody
+): Promise<void> => {
+    const parsedId = z.string().trim().min(1).uuid().safeParse(businessId);
+    if (!parsedId.success) {
+        throw new TypeError('Invalid args', { cause: parsedId.error.issues });
+    }
+
+    const result = bodySchema.safeParse(body);
+    if (!result.success) {
+        throw new TypeError('Invalid args', { cause: result.error.issues });
+    }
+
+    await client.post<void>(
+        `/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/business/${parsedId.data}/credit`,
+        result.data
+    );
+};

package/src/addStripePayment.ts

@@ -0,0 +1,18 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { StripeSetup } from './types';
+
+/** @deprecated */
+export const addStripePayment = async (client: Client, businessId: string): Promise<StripeSetup> => {
+    const result = z.string().trim().min(1).uuid().safeParse(businessId);
+    if (!result.success) {
+        throw new TypeError('Invalid args', { cause: result.error.issues });
+    }
+
+    return client
+        .post<StripeSetup>(
+            `/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/stripe/businesses/${result.data}/add`
+        )
+        .then(({ data }) => data);
+};

package/src/addTripNote.test.ts

@@ -0,0 +1,67 @@
+import { describe, test, vi, expect, beforeEach } from 'vitest';
+import { Client } from '@vulog/aima-client';
+import { addTripNote, AddTripNoteBody } from './addTripNote';
+
+describe('addTripNote', () => {
+    const postMock = vi.fn();
+    const client = {
+        post: postMock,
+        clientOptions: {
+            fleetId: 'FLEET_ID',
+        },
+    } as unknown as Client;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    const TRIP_ID = '018ab2b6-71b2-4c76-90bd-6e8d3f268618';
+
+    test('should create a trip note with valid params', async () => {
+        const body: AddTripNoteBody = { content: 'Customer requested early return' };
+        const mockResponse = { id: 'note-uuid', content: 'Customer requested early return' };
+        postMock.mockResolvedValueOnce({ data: mockResponse });
+
+        const result = await addTripNote(client, TRIP_ID, body);
+
+        expect(result).toEqual(mockResponse);
+        expect(postMock).toHaveBeenCalledWith(
+            `/boapi/proxy/business/fleets/FLEET_ID/trip/${TRIP_ID}/notes`,
+            body
+        );
+    });
+
+    test('should throw TypeError for invalid tripId', async () => {
+        const body: AddTripNoteBody = { content: 'Some note' };
+        await expect(addTripNote(client, 'not-a-uuid', body)).rejects.toThrow(TypeError);
+        expect(postMock).not.toHaveBeenCalled();
+    });
+
+    test('should throw TypeError for empty tripId', async () => {
+        const body: AddTripNoteBody = { content: 'Some note' };
+        await expect(addTripNote(client, '', body)).rejects.toThrow(TypeError);
+        expect(postMock).not.toHaveBeenCalled();
+    });
+
+    test('should throw TypeError for empty content', async () => {
+        const body: AddTripNoteBody = { content: '' };
+        await expect(addTripNote(client, TRIP_ID, body)).rejects.toThrow(TypeError);
+        expect(postMock).not.toHaveBeenCalled();
+    });
+
+    test('should throw TypeError for whitespace-only content', async () => {
+        const body: AddTripNoteBody = { content: '   ' };
+        await expect(addTripNote(client, TRIP_ID, body)).rejects.toThrow(TypeError);
+        expect(postMock).not.toHaveBeenCalled();
+    });
+
+    test('error cause includes Zod issues for both invalid tripId and empty content', async () => {
+        try {
+            await addTripNote(client, 'bad', { content: '' });
+        } catch (err) {
+            expect(err).toBeInstanceOf(TypeError);
+            expect((err as Error).cause).toBeDefined();
+            expect(Array.isArray((err as Error).cause)).toBe(true);
+        }
+    });
+});

package/src/addTripNote.ts

@@ -0,0 +1,30 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { TripNote } from './types';
+
+export type AddTripNoteBody = {
+    content: string;
+};
+
+const addTripNoteBodySchema = z.object({
+    content: z.string().trim().min(1),
+});
+
+export const addTripNote = async (client: Client, tripId: string, body: AddTripNoteBody): Promise<TripNote> => {
+    const tripIdResult = z.string().trim().min(1).uuid().safeParse(tripId);
+    const bodyResult = addTripNoteBodySchema.safeParse(body);
+
+    if (!tripIdResult.success || !bodyResult.success) {
+        throw new TypeError('Invalid args', {
+            cause: [...(tripIdResult.error?.issues ?? []), ...(bodyResult.error?.issues ?? [])],
+        });
+    }
+
+    return client
+        .post<TripNote>(
+            `/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/trip/${tripIdResult.data}/notes`,
+            bodyResult.data
+        )
+        .then(({ data }) => data);
+};

package/src/addUserToBusiness.test.ts

@@ -0,0 +1,74 @@
+import { describe, test, vi, expect, beforeEach } from 'vitest';
+import { Client } from '@vulog/aima-client';
+import { addUserToBusiness } from './addUserToBusiness';
+
+describe('addUserToBusiness', () => {
+    const postMock = vi.fn();
+    const client = {
+        post: postMock,
+        clientOptions: { fleetId: 'FLEET_ID' },
+    } as unknown as Client;
+
+    const businessId = 'ed539d7d-d815-405b-bc00-71008fb1954c';
+    const userId = 'b931b17e-214f-4a73-ad94-77a973435768';
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    test('should call POST with correct URL and empty body when no data provided', async () => {
+        const mockProfile = { id: 'profile-1', status: 'APPROVED' };
+        postMock.mockResolvedValueOnce({ data: mockProfile });
+
+        const result = await addUserToBusiness(client, businessId, userId);
+
+        expect(postMock).toHaveBeenCalledWith(
+            `/boapi/proxy/business/fleets/FLEET_ID/business/${businessId}/user/${userId}`,
+            {}
+        );
+        expect(result).toEqual(mockProfile);
+    });
+
+    test('should pass data as body when provided', async () => {
+        const mockProfile = { id: 'profile-1' };
+        postMock.mockResolvedValueOnce({ data: mockProfile });
+        const data = { emailConsent: true, email: 'test@example.com' };
+
+        await addUserToBusiness(client, businessId, userId, data);
+
+        expect(postMock).toHaveBeenCalledWith(
+            `/boapi/proxy/business/fleets/FLEET_ID/business/${businessId}/user/${userId}`,
+            data
+        );
+    });
+
+    test('should throw TypeError for invalid businessId', async () => {
+        await expect(addUserToBusiness(client, 'not-a-uuid', userId)).rejects.toThrow(TypeError);
+        expect(postMock).not.toHaveBeenCalled();
+    });
+
+    test('should throw TypeError for invalid userId', async () => {
+        await expect(addUserToBusiness(client, businessId, 'not-a-uuid')).rejects.toThrow(TypeError);
+        expect(postMock).not.toHaveBeenCalled();
+    });
+
+    test('should throw TypeError for empty businessId', async () => {
+        await expect(addUserToBusiness(client, '', userId)).rejects.toThrow(TypeError);
+        expect(postMock).not.toHaveBeenCalled();
+    });
+
+    test('should throw TypeError for empty userId', async () => {
+        await expect(addUserToBusiness(client, businessId, '')).rejects.toThrow(TypeError);
+        expect(postMock).not.toHaveBeenCalled();
+    });
+
+    test('error cause includes Zod issues', async () => {
+        try {
+            await addUserToBusiness(client, 'bad', 'bad');
+        } catch (err) {
+            expect(err).toBeInstanceOf(TypeError);
+            expect((err as Error).cause).toBeDefined();
+            expect(Array.isArray((err as Error).cause)).toBe(true);
+        }
+    });
+});

package/src/addUserToBusiness.ts

@@ -0,0 +1,49 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { BusinessUserProfile } from './types';
+
+export type AddUserToBusinessBody = {
+    email?: string;
+    emailConsent?: boolean;
+    requestId?: string;
+    costCenterId?: string;
+};
+
+const uuidSchema = z.string().trim().min(1).uuid();
+
+const bodySchema = z
+    .object({
+        email: z.string().trim().email().optional(),
+        emailConsent: z.boolean().optional(),
+        requestId: z.string().trim().min(1).uuid().optional(),
+        costCenterId: z.string().trim().min(1).uuid().optional(),
+    })
+    .optional();
+
+export const addUserToBusiness = async (
+    client: Client,
+    businessId: string,
+    userId: string,
+    data?: AddUserToBusinessBody
+): Promise<BusinessUserProfile> => {
+    const parsedBusinessId = uuidSchema.safeParse(businessId);
+    const parsedUserId = uuidSchema.safeParse(userId);
+    if (!parsedBusinessId.success || !parsedUserId.success) {
+        throw new TypeError('Invalid args', {
+            cause: [...(parsedBusinessId.error?.issues ?? []), ...(parsedUserId.error?.issues ?? [])],
+        });
+    }
+
+    const result = bodySchema.safeParse(data);
+    if (!result.success) {
+        throw new TypeError('Invalid args', { cause: result.error.issues });
+    }
+
+    return client
+        .post<BusinessUserProfile>(
+            `/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/business/${parsedBusinessId.data}/user/${parsedUserId.data}`,
+            result.data ?? {}
+        )
+        .then(({ data: d }) => d);
+};

package/src/archiveBusinessProfile.ts

@@ -0,0 +1,28 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+const uuidSchema = z.string().trim().min(1).uuid();
+
+export const archiveBusinessProfile = async (
+    client: Client,
+    businessId: string,
+    userId: string,
+    profileId: string
+): Promise<void> => {
+    const parsedBusinessId = uuidSchema.safeParse(businessId);
+    const parsedUserId = uuidSchema.safeParse(userId);
+    const parsedProfileId = uuidSchema.safeParse(profileId);
+    if (!parsedBusinessId.success || !parsedUserId.success || !parsedProfileId.success) {
+        throw new TypeError('Invalid args', {
+            cause: [
+                ...(parsedBusinessId.error?.issues ?? []),
+                ...(parsedUserId.error?.issues ?? []),
+                ...(parsedProfileId.error?.issues ?? []),
+            ],
+        });
+    }
+
+    await client.delete<void>(
+        `/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/business/${parsedBusinessId.data}/user/${parsedUserId.data}/profile/${parsedProfileId.data}`
+    );
+};

package/src/bulkAddBusinessUsers.ts

@@ -0,0 +1,27 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+export type BulkAddBusinessUsersBody = {
+    userIds: string[];
+};
+
+const bulkAddSchema = z.object({
+    businessId: z.string().trim().min(1).uuid(),
+    userIds: z.array(z.string().trim().min(1).uuid()).min(1),
+});
+
+export const bulkAddBusinessUsers = async (
+    client: Client,
+    businessId: string,
+    body: BulkAddBusinessUsersBody
+): Promise<void> => {
+    const result = bulkAddSchema.safeParse({ businessId, userIds: body.userIds });
+    if (!result.success) {
+        throw new TypeError('Invalid args', { cause: result.error.issues });
+    }
+
+    await client.post<void>(
+        `/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/business/${result.data.businessId}/user/bulk`,
+        { userIds: result.data.userIds }
+    );
+};

package/src/businessDelegatedAdmin.test.ts

@@ -0,0 +1,68 @@
+import { describe, test, vi, expect, beforeEach } from 'vitest';
+import { Client } from '@vulog/aima-client';
+import { setDelegatedAdmin, removeDelegatedAdmin } from './businessDelegatedAdmin';
+
+describe('businessDelegatedAdmin', () => {
+    const postMock = vi.fn();
+    const deleteMock = vi.fn();
+    const client = {
+        post: postMock,
+        delete: deleteMock,
+        clientOptions: { fleetId: 'FLEET_ID' },
+    } as unknown as Client;
+
+    const businessId = 'ed539d7d-d815-405b-bc00-71008fb1954c';
+    const userId = 'b931b17e-214f-4a73-ad94-77a973435768';
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    describe('setDelegatedAdmin', () => {
+        test('should call POST with correct URL', async () => {
+            postMock.mockResolvedValueOnce({ data: undefined });
+
+            await setDelegatedAdmin(client, businessId, userId);
+
+            expect(postMock).toHaveBeenCalledWith(
+                `/boapi/proxy/business/fleets/FLEET_ID/business/${businessId}/user/${userId}/delegatedAdmin`
+            );
+        });
+
+        test('should throw for invalid businessId', async () => {
+            await expect(setDelegatedAdmin(client, 'not-a-uuid', userId)).rejects.toThrow(TypeError);
+        });
+
+        test('should throw for invalid userId', async () => {
+            await expect(setDelegatedAdmin(client, businessId, 'not-a-uuid')).rejects.toThrow(TypeError);
+        });
+
+        test('should throw for empty businessId', async () => {
+            await expect(setDelegatedAdmin(client, '', userId)).rejects.toThrow(TypeError);
+        });
+
+        test('should throw for empty userId', async () => {
+            await expect(setDelegatedAdmin(client, businessId, '')).rejects.toThrow(TypeError);
+        });
+    });
+
+    describe('removeDelegatedAdmin', () => {
+        test('should call DELETE with correct URL', async () => {
+            deleteMock.mockResolvedValueOnce({ data: undefined });
+
+            await removeDelegatedAdmin(client, businessId, userId);
+
+            expect(deleteMock).toHaveBeenCalledWith(
+                `/boapi/proxy/business/fleets/FLEET_ID/business/${businessId}/user/${userId}/delegatedAdmin`
+            );
+        });
+
+        test('should throw for invalid businessId', async () => {
+            await expect(removeDelegatedAdmin(client, 'not-a-uuid', userId)).rejects.toThrow(TypeError);
+        });
+
+        test('should throw for invalid userId', async () => {
+            await expect(removeDelegatedAdmin(client, businessId, 'not-a-uuid')).rejects.toThrow(TypeError);
+        });
+    });
+});

package/src/businessDelegatedAdmin.ts

@@ -0,0 +1,32 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+const uuidSchema = z.string().trim().min(1).uuid();
+
+export const setDelegatedAdmin = async (client: Client, businessId: string, userId: string): Promise<void> => {
+    const parsedBusinessId = uuidSchema.safeParse(businessId);
+    const parsedUserId = uuidSchema.safeParse(userId);
+    if (!parsedBusinessId.success || !parsedUserId.success) {
+        throw new TypeError('Invalid args', {
+            cause: [...(parsedBusinessId.error?.issues ?? []), ...(parsedUserId.error?.issues ?? [])],
+        });
+    }
+
+    await client.post<void>(
+        `/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/business/${parsedBusinessId.data}/user/${parsedUserId.data}/delegatedAdmin`
+    );
+};
+
+export const removeDelegatedAdmin = async (client: Client, businessId: string, userId: string): Promise<void> => {
+    const parsedBusinessId = uuidSchema.safeParse(businessId);
+    const parsedUserId = uuidSchema.safeParse(userId);
+    if (!parsedBusinessId.success || !parsedUserId.success) {
+        throw new TypeError('Invalid args', {
+            cause: [...(parsedBusinessId.error?.issues ?? []), ...(parsedUserId.error?.issues ?? [])],
+        });
+    }
+
+    await client.delete<void>(
+        `/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/business/${parsedBusinessId.data}/user/${parsedUserId.data}/delegatedAdmin`
+    );
+};

package/src/businessOwner.test.ts

@@ -0,0 +1,68 @@
+import { describe, test, vi, expect, beforeEach } from 'vitest';
+import { Client } from '@vulog/aima-client';
+import { setBusinessOwner, removeBusinessOwner } from './businessOwner';
+
+describe('businessOwner', () => {
+    const postMock = vi.fn();
+    const deleteMock = vi.fn();
+    const client = {
+        post: postMock,
+        delete: deleteMock,
+        clientOptions: { fleetId: 'FLEET_ID' },
+    } as unknown as Client;
+
+    const businessId = 'ed539d7d-d815-405b-bc00-71008fb1954c';
+    const userId = 'b931b17e-214f-4a73-ad94-77a973435768';
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    describe('setBusinessOwner', () => {
+        test('should call POST with correct URL', async () => {
+            postMock.mockResolvedValueOnce({ data: undefined });
+
+            await setBusinessOwner(client, businessId, userId);
+
+            expect(postMock).toHaveBeenCalledWith(
+                `/boapi/proxy/business/fleets/FLEET_ID/business/${businessId}/user/${userId}/owner`
+            );
+        });
+
+        test('should throw for invalid businessId', async () => {
+            await expect(setBusinessOwner(client, 'not-a-uuid', userId)).rejects.toThrow(TypeError);
+        });
+
+        test('should throw for invalid userId', async () => {
+            await expect(setBusinessOwner(client, businessId, 'not-a-uuid')).rejects.toThrow(TypeError);
+        });
+
+        test('should throw for empty businessId', async () => {
+            await expect(setBusinessOwner(client, '', userId)).rejects.toThrow(TypeError);
+        });
+
+        test('should throw for empty userId', async () => {
+            await expect(setBusinessOwner(client, businessId, '')).rejects.toThrow(TypeError);
+        });
+    });
+
+    describe('removeBusinessOwner', () => {
+        test('should call DELETE with correct URL', async () => {
+            deleteMock.mockResolvedValueOnce({ data: undefined });
+
+            await removeBusinessOwner(client, businessId, userId);
+
+            expect(deleteMock).toHaveBeenCalledWith(
+                `/boapi/proxy/business/fleets/FLEET_ID/business/${businessId}/user/${userId}/owner`
+            );
+        });
+
+        test('should throw for invalid businessId', async () => {
+            await expect(removeBusinessOwner(client, 'not-a-uuid', userId)).rejects.toThrow(TypeError);
+        });
+
+        test('should throw for invalid userId', async () => {
+            await expect(removeBusinessOwner(client, businessId, 'not-a-uuid')).rejects.toThrow(TypeError);
+        });
+    });
+});

package/src/businessOwner.ts

@@ -0,0 +1,32 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+const uuidSchema = z.string().trim().min(1).uuid();
+
+export const setBusinessOwner = async (client: Client, businessId: string, userId: string): Promise<void> => {
+    const parsedBusinessId = uuidSchema.safeParse(businessId);
+    const parsedUserId = uuidSchema.safeParse(userId);
+    if (!parsedBusinessId.success || !parsedUserId.success) {
+        throw new TypeError('Invalid args', {
+            cause: [...(parsedBusinessId.error?.issues ?? []), ...(parsedUserId.error?.issues ?? [])],
+        });
+    }
+
+    await client.post<void>(
+        `/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/business/${parsedBusinessId.data}/user/${parsedUserId.data}/owner`
+    );
+};
+
+export const removeBusinessOwner = async (client: Client, businessId: string, userId: string): Promise<void> => {
+    const parsedBusinessId = uuidSchema.safeParse(businessId);
+    const parsedUserId = uuidSchema.safeParse(userId);
+    if (!parsedBusinessId.success || !parsedUserId.success) {
+        throw new TypeError('Invalid args', {
+            cause: [...(parsedBusinessId.error?.issues ?? []), ...(parsedUserId.error?.issues ?? [])],
+        });
+    }
+
+    await client.delete<void>(
+        `/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/business/${parsedBusinessId.data}/user/${parsedUserId.data}/owner`
+    );
+};

package/src/chargeBusinessProduct.ts

@@ -0,0 +1,31 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+export type ChargeBusinessProductBody = {
+    productId: string;
+};
+
+const bodySchema = z.object({
+    productId: z.string().trim().min(1),
+});
+
+export const chargeBusinessProduct = async (
+    client: Client,
+    businessId: string,
+    body: ChargeBusinessProductBody
+): Promise<void> => {
+    const parsedId = z.string().trim().min(1).uuid().safeParse(businessId);
+    if (!parsedId.success) {
+        throw new TypeError('Invalid args', { cause: parsedId.error.issues });
+    }
+
+    const result = bodySchema.safeParse(body);
+    if (!result.success) {
+        throw new TypeError('Invalid args', { cause: result.error.issues });
+    }
+
+    await client.post<void>(
+        `/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/business/${parsedId.data}/product`,
+        result.data
+    );
+};

package/src/createBusiness.test.ts

@@ -0,0 +1,54 @@
+import { describe, test, vi, expect, beforeEach } from 'vitest';
+import { Client } from '@vulog/aima-client';
+import { createBusiness, CreateBusinessBody } from './createBusiness';
+
+describe('createBusiness', () => {
+    const postMock = vi.fn();
+    const client = {
+        post: postMock,
+        clientOptions: {
+            fleetId: 'FLEET_ID',
+        },
+    } as unknown as Client;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    const validBody: CreateBusinessBody = {
+        name: 'Acme Corp',
+    };
+
+    test('should create a business with valid body', async () => {
+        const mockResponse = { id: 'business-uuid', name: 'Acme Corp', status: 'ACTIVE' };
+        postMock.mockResolvedValueOnce({ data: mockResponse });
+
+        const result = await createBusiness(client, validBody);
+
+        expect(result).toEqual(mockResponse);
+        expect(postMock).toHaveBeenCalledWith(
+            '/boapi/proxy/business/fleets/FLEET_ID/business',
+            validBody
+        );
+    });
+
+    test('should throw for empty name', async () => {
+        const body: CreateBusinessBody = { name: '' };
+        await expect(createBusiness(client, body)).rejects.toThrow(TypeError);
+    });
+
+    test('should throw for whitespace-only name', async () => {
+        const body: CreateBusinessBody = { name: '   ' };
+        await expect(createBusiness(client, body)).rejects.toThrow(TypeError);
+    });
+
+    test('should throw for name exceeding 255 characters', async () => {
+        const body: CreateBusinessBody = { name: 'a'.repeat(256) };
+        await expect(createBusiness(client, body)).rejects.toThrow(TypeError);
+    });
+
+    test('should throw for missing name', async () => {
+        const body = {} as CreateBusinessBody;
+        await expect(createBusiness(client, body)).rejects.toThrow(TypeError);
+    });
+});

package/src/createBusiness.ts

@@ -0,0 +1,23 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { Business } from './types';
+
+export type CreateBusinessBody = {
+    name: string;
+};
+
+const createBusinessBodySchema = z.object({
+    name: z.string().trim().min(1).max(255),
+});
+
+export const createBusiness = async (client: Client, body: CreateBusinessBody): Promise<Business> => {
+    const result = createBusinessBodySchema.safeParse(body);
+    if (!result.success) {
+        throw new TypeError('Invalid args', { cause: result.error.issues });
+    }
+
+    return client
+        .post<Business>(`/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/business`, result.data)
+        .then(({ data }) => data);
+};