@vulog/aima-business 1.2.39

package/src/createBusinessCostCenter.test.ts

@@ -0,0 +1,61 @@
+import { describe, test, vi, expect, beforeEach } from 'vitest';
+
+import { Client } from '@vulog/aima-client';
+import { createBusinessCostCenter } from './createBusinessCostCenter';
+import { CostCenter } from './types';
+
+describe('createBusinessCostCenter', () => {
+    const postMock = vi.fn();
+    const client = {
+        post: postMock,
+        clientOptions: {
+            fleetId: 'FLEET_ID',
+        },
+    } as unknown as Client;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    test('should throw for invalid businessId', async () => {
+        await expect(
+            createBusinessCostCenter(client, 'bad-id', { name: 'Test' })
+        ).rejects.toThrow(TypeError);
+    });
+
+    test('should throw for empty name', async () => {
+        await expect(
+            createBusinessCostCenter(client, '550e8400-e29b-41d4-a716-446655440000', { name: '' })
+        ).rejects.toThrow(TypeError);
+    });
+
+    test('should throw for name exceeding 255 characters', async () => {
+        await expect(
+            createBusinessCostCenter(client, '550e8400-e29b-41d4-a716-446655440000', {
+                name: 'a'.repeat(256),
+            })
+        ).rejects.toThrow(TypeError);
+    });
+
+    test('should create cost center with valid args', async () => {
+        const businessId = '550e8400-e29b-41d4-a716-446655440000';
+        const body = { name: 'Marketing' };
+
+        const mockResponse: CostCenter = {
+            id: '660e8400-e29b-41d4-a716-446655440000',
+            name: 'Marketing',
+            businessId,
+        };
+
+        postMock.mockResolvedValueOnce({
+            data: mockResponse,
+        });
+
+        const result = await createBusinessCostCenter(client, businessId, body);
+        expect(result).toEqual(mockResponse);
+        expect(postMock).toBeCalledWith(
+            `/boapi/proxy/business/fleets/FLEET_ID/business/${businessId}/costcenter`,
+            { name: 'Marketing' }
+        );
+    });
+});

package/src/createBusinessCostCenter.ts

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

package/src/deactivateBusinessProfile.ts

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

package/src/deleteBusinessCostCenter.test.ts

@@ -0,0 +1,45 @@
+import { describe, test, vi, expect, beforeEach } from 'vitest';
+
+import { Client } from '@vulog/aima-client';
+import { deleteBusinessCostCenter } from './deleteBusinessCostCenter';
+
+describe('deleteBusinessCostCenter', () => {
+    const deleteMock = vi.fn();
+    const client = {
+        delete: deleteMock,
+        clientOptions: {
+            fleetId: 'FLEET_ID',
+        },
+    } as unknown as Client;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    test('should throw for invalid businessId', async () => {
+        await expect(
+            deleteBusinessCostCenter(client, 'bad-id', '550e8400-e29b-41d4-a716-446655440000')
+        ).rejects.toThrow(TypeError);
+    });
+
+    test('should throw for invalid costCenterId', async () => {
+        await expect(
+            deleteBusinessCostCenter(client, '550e8400-e29b-41d4-a716-446655440000', 'bad-id')
+        ).rejects.toThrow(TypeError);
+    });
+
+    test('should delete cost center with valid args', async () => {
+        const businessId = '550e8400-e29b-41d4-a716-446655440000';
+        const costCenterId = '660e8400-e29b-41d4-a716-446655440000';
+
+        deleteMock.mockResolvedValueOnce({
+            data: undefined,
+        });
+
+        const result = await deleteBusinessCostCenter(client, businessId, costCenterId);
+        expect(result).toBeUndefined();
+        expect(deleteMock).toBeCalledWith(
+            `/boapi/proxy/business/fleets/FLEET_ID/business/${businessId}/costcenter/${costCenterId}`
+        );
+    });
+});

package/src/deleteBusinessCostCenter.ts

@@ -0,0 +1,23 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+const schema = z.object({
+    businessId: z.string().trim().min(1).uuid(),
+    costCenterId: z.string().trim().min(1).uuid(),
+});
+
+export const deleteBusinessCostCenter = async (
+    client: Client,
+    businessId: string,
+    costCenterId: string
+): Promise<void> => {
+    const result = schema.safeParse({ businessId, costCenterId });
+    if (!result.success) {
+        throw new TypeError('Invalid args', {
+            cause: result.error.issues,
+        });
+    }
+    await client.delete(
+        `/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/business/${result.data.businessId}/costcenter/${result.data.costCenterId}`
+    );
+};

package/src/deleteInvitationRequest.test.ts

@@ -0,0 +1,45 @@
+import { describe, test, vi, expect, beforeEach } from 'vitest';
+import { Client } from '@vulog/aima-client';
+import { deleteInvitationRequest } from './deleteInvitationRequest';
+
+describe('deleteInvitationRequest', () => {
+    const deleteMock = vi.fn();
+    const client = {
+        delete: deleteMock,
+        clientOptions: {
+            fleetId: 'FLEET_ID',
+        },
+    } as unknown as Client;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    const INVITATION_ID = '550e8400-e29b-41d4-a716-446655440000';
+
+    test('should delete invitation request with valid id', async () => {
+        deleteMock.mockResolvedValueOnce({ data: undefined });
+
+        const result = await deleteInvitationRequest(client, INVITATION_ID);
+
+        expect(result).toBeUndefined();
+        expect(deleteMock).toHaveBeenCalledWith(
+            `/boapi/proxy/business/fleets/FLEET_ID/invitationRequest/${INVITATION_ID}`
+        );
+    });
+
+    test('should throw for empty invitationId', async () => {
+        await expect(deleteInvitationRequest(client, '')).rejects.toThrow(TypeError);
+        expect(deleteMock).not.toHaveBeenCalled();
+    });
+
+    test('should throw for non-uuid invitationId', async () => {
+        await expect(deleteInvitationRequest(client, 'not-a-uuid')).rejects.toThrow(TypeError);
+        expect(deleteMock).not.toHaveBeenCalled();
+    });
+
+    test('should throw for whitespace-only invitationId', async () => {
+        await expect(deleteInvitationRequest(client, '   ')).rejects.toThrow(TypeError);
+        expect(deleteMock).not.toHaveBeenCalled();
+    });
+});

package/src/deleteInvitationRequest.ts

@@ -0,0 +1,13 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+export const deleteInvitationRequest = async (client: Client, invitationId: string): Promise<void> => {
+    const result = z.string().trim().min(1).uuid().safeParse(invitationId);
+    if (!result.success) {
+        throw new TypeError('Invalid args', { cause: result.error.issues });
+    }
+
+    await client.delete(
+        `/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/invitationRequest/${result.data}`
+    );
+};

package/src/getBillingGroups.ts

@@ -0,0 +1,9 @@
+import { Client } from '@vulog/aima-client';
+
+import { BusinessBillingGroup } from './types';
+
+export const getBusinessBillingGroups = async (client: Client): Promise<BusinessBillingGroup[]> => {
+    return client
+        .get<BusinessBillingGroup[]>(`/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/billing/groups`)
+        .then(({ data }) => data);
+};

package/src/getBusinessById.test.ts

@@ -0,0 +1,47 @@
+import { describe, test, vi, expect, beforeEach } from 'vitest';
+import { Client } from '@vulog/aima-client';
+import { getBusinessById } from './getBusinessById';
+
+describe('getBusinessById', () => {
+    const getMock = vi.fn();
+    const client = {
+        get: getMock,
+        clientOptions: {
+            fleetId: 'FLEET_ID',
+        },
+    } as unknown as Client;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    const BUSINESS_ID = '018ab2b6-71b2-4c76-90bd-6e8d3f268618';
+
+    test('should return a business by id', async () => {
+        const mockResponse = {
+            id: BUSINESS_ID,
+            name: 'Acme Corp',
+            status: 'ACTIVE',
+        };
+        getMock.mockResolvedValueOnce({ data: mockResponse });
+
+        const result = await getBusinessById(client, BUSINESS_ID);
+
+        expect(result).toEqual(mockResponse);
+        expect(getMock).toHaveBeenCalledWith(
+            `/boapi/proxy/business/fleets/FLEET_ID/business/${BUSINESS_ID}`
+        );
+    });
+
+    test('should throw for empty businessId', async () => {
+        await expect(getBusinessById(client, '')).rejects.toThrow(TypeError);
+    });
+
+    test('should throw for non-uuid businessId', async () => {
+        await expect(getBusinessById(client, 'not-a-uuid')).rejects.toThrow(TypeError);
+    });
+
+    test('should throw for whitespace-only businessId', async () => {
+        await expect(getBusinessById(client, '   ')).rejects.toThrow(TypeError);
+    });
+});

package/src/getBusinessById.ts

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

package/src/getBusinessContacts.ts

@@ -0,0 +1,17 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { BusinessContact } from './types';
+
+export const getBusinessContacts = async (client: Client, businessId: string): Promise<BusinessContact[]> => {
+    const result = z.string().trim().min(1).uuid().safeParse(businessId);
+    if (!result.success) {
+        throw new TypeError('Invalid args', { cause: result.error.issues });
+    }
+
+    return client
+        .get<
+            BusinessContact[]
+        >(`/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/business/${result.data}/contacts`)
+        .then(({ data }) => data);
+};

package/src/getBusinessCostCenterById.ts

@@ -0,0 +1,27 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { CostCenter } from './types';
+
+const schema = z.object({
+    businessId: z.string().trim().min(1).uuid(),
+    costCenterId: z.string().trim().min(1).uuid(),
+});
+
+export const getBusinessCostCenterById = async (
+    client: Client,
+    businessId: string,
+    costCenterId: string
+): Promise<CostCenter> => {
+    const result = schema.safeParse({ businessId, costCenterId });
+    if (!result.success) {
+        throw new TypeError('Invalid args', {
+            cause: result.error.issues,
+        });
+    }
+    return client
+        .get<CostCenter>(
+            `/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/business/${result.data.businessId}/costcenter/${result.data.costCenterId}`
+        )
+        .then(({ data }) => data);
+};

package/src/getBusinessCostCenters.ts

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

package/src/getBusinessInviteLink.ts

@@ -0,0 +1,17 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { BusinessInviteLink } from './types';
+
+export const getBusinessInviteLink = async (client: Client, businessId: string): Promise<BusinessInviteLink> => {
+    const result = z.string().trim().min(1).uuid().safeParse(businessId);
+    if (!result.success) {
+        throw new TypeError('Invalid args', { cause: result.error.issues });
+    }
+
+    return client
+        .get<BusinessInviteLink>(
+            `/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/business/${result.data}/user/invite/link`
+        )
+        .then(({ data }) => data);
+};

package/src/getBusinessInvoiceProducts.ts

@@ -0,0 +1,24 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+const uuidSchema = z.string().trim().min(1).uuid();
+
+export const getBusinessInvoiceProducts = async (
+    client: Client,
+    entityId: string,
+    invoiceId: string
+): Promise<any[]> => {
+    const parsedEntityId = uuidSchema.safeParse(entityId);
+    const parsedInvoiceId = uuidSchema.safeParse(invoiceId);
+    if (!parsedEntityId.success || !parsedInvoiceId.success) {
+        throw new TypeError('Invalid args', {
+            cause: [...(parsedEntityId.error?.issues ?? []), ...(parsedInvoiceId.error?.issues ?? [])],
+        });
+    }
+
+    return client
+        .get<
+            any[]
+        >(`/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/entities/${parsedEntityId.data}/businessInvoices/${parsedInvoiceId.data}/products`)
+        .then(({ data }) => data);
+};

package/src/getBusinessInvoiceTrips.ts

@@ -0,0 +1,20 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+const uuidSchema = z.string().trim().min(1).uuid();
+
+export const getBusinessInvoiceTrips = async (client: Client, entityId: string, invoiceId: string): Promise<any[]> => {
+    const parsedEntityId = uuidSchema.safeParse(entityId);
+    const parsedInvoiceId = uuidSchema.safeParse(invoiceId);
+    if (!parsedEntityId.success || !parsedInvoiceId.success) {
+        throw new TypeError('Invalid args', {
+            cause: [...(parsedEntityId.error?.issues ?? []), ...(parsedInvoiceId.error?.issues ?? [])],
+        });
+    }
+
+    return client
+        .get<
+            any[]
+        >(`/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/entities/${parsedEntityId.data}/businessInvoices/${parsedInvoiceId.data}/trips`)
+        .then(({ data }) => data);
+};

package/src/getBusinessInvoices.test.ts

@@ -0,0 +1,92 @@
+import { describe, test, vi, expect, beforeEach } from 'vitest';
+import { Client } from '@vulog/aima-client';
+import { getBusinessInvoices } from './getBusinessInvoices';
+
+describe('getBusinessInvoices', () => {
+    const getMock = vi.fn();
+    const client = {
+        get: getMock,
+        clientOptions: { fleetId: 'FLEET_ID' },
+    } as unknown as Client;
+
+    const entityId = 'ed539d7d-d815-405b-bc00-71008fb1954c';
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    test('should call GET with correct endpoint and default pagination', async () => {
+        const mockInvoices = [
+            { id: 'inv-1', amount: 100, status: 'PAID' },
+            { id: 'inv-2', amount: 200, status: 'PENDING' },
+        ];
+        getMock.mockResolvedValueOnce({
+            data: mockInvoices,
+            headers: { number: 0, size: 100, totalelements: 2, totalpages: 1 },
+        });
+
+        const result = await getBusinessInvoices(client, entityId);
+
+        expect(getMock).toHaveBeenCalledTimes(1);
+        const url = getMock.mock.calls[0][0] as string;
+        expect(url).toContain(`/boapi/proxy/business/fleets/FLEET_ID/entities/${entityId}/businessInvoices?`);
+        expect(url).toContain('page=0');
+        expect(url).toContain('size=100');
+        expect(result.data).toEqual(mockInvoices);
+        expect(result.page).toBe(0);
+        expect(result.pageSize).toBe(100);
+        expect(result.total).toBe(2);
+        expect(result.totalPages).toBe(1);
+    });
+
+    test('should pass custom pagination options', async () => {
+        getMock.mockResolvedValueOnce({
+            data: [],
+            headers: { number: 2, size: 25, totalelements: 0, totalpages: 0 },
+        });
+
+        await getBusinessInvoices(client, entityId, { page: 2, pageSize: 25, sort: 'amount', sortDirection: 'DESC' });
+
+        const url = getMock.mock.calls[0][0] as string;
+        expect(url).toContain('page=2');
+        expect(url).toContain('size=25');
+        expect(url).toContain('sort=amount%2CDESC');
+    });
+
+    test('should handle empty response', async () => {
+        getMock.mockResolvedValueOnce({
+            data: [],
+            headers: { number: 0, size: 100, totalelements: 0, totalpages: 0 },
+        });
+
+        const result = await getBusinessInvoices(client, entityId);
+
+        expect(result).toEqual({
+            data: [],
+            page: 0,
+            pageSize: 100,
+            total: 0,
+            totalPages: 0,
+        });
+    });
+
+    test('should throw TypeError for invalid entityId', async () => {
+        await expect(getBusinessInvoices(client, 'not-a-uuid')).rejects.toThrow(TypeError);
+        expect(getMock).not.toHaveBeenCalled();
+    });
+
+    test('should throw TypeError for empty entityId', async () => {
+        await expect(getBusinessInvoices(client, '')).rejects.toThrow(TypeError);
+        expect(getMock).not.toHaveBeenCalled();
+    });
+
+    test('should throw TypeError for invalid pagination options', async () => {
+        await expect(getBusinessInvoices(client, entityId, { page: -1 })).rejects.toThrow(TypeError);
+        expect(getMock).not.toHaveBeenCalled();
+    });
+
+    test('should throw TypeError for invalid page size', async () => {
+        await expect(getBusinessInvoices(client, entityId, { pageSize: 0 })).rejects.toThrow(TypeError);
+        expect(getMock).not.toHaveBeenCalled();
+    });
+});

package/src/getBusinessInvoices.ts

@@ -0,0 +1,43 @@
+import { Client } from '@vulog/aima-client';
+import { createPaginableOptionsSchema, PaginableOptions, PaginableResponse } from '@vulog/aima-core';
+import { z } from 'zod';
+
+import { BusinessInvoice } from './types';
+
+export const getBusinessInvoices = async (
+    client: Client,
+    entityId: string,
+    options?: PaginableOptions
+): Promise<PaginableResponse<BusinessInvoice>> => {
+    const resultId = z.string().trim().min(1).uuid().safeParse(entityId);
+    if (!resultId.success) {
+        throw new TypeError('Invalid args', { cause: resultId.error.issues });
+    }
+
+    const paginableOptionsSchema = createPaginableOptionsSchema();
+
+    const resultOptions = paginableOptionsSchema.safeParse(options ?? {});
+    if (!resultOptions.success) {
+        throw new TypeError('Invalid options', { cause: resultOptions.error.issues });
+    }
+
+    const finalOptions = resultOptions.data;
+
+    const searchParams = new URLSearchParams();
+    searchParams.append('page', finalOptions.page!.toString());
+    searchParams.append('size', finalOptions.pageSize!.toString());
+
+    if (finalOptions.sort) {
+        searchParams.append('sort', `${finalOptions.sort.toString()},${finalOptions.sortDirection!.toString()}`);
+    }
+
+    const url = `/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/entities/${resultId.data}/businessInvoices?${searchParams.toString()}`;
+
+    return client.get<BusinessInvoice[]>(url).then(({ data, headers }) => ({
+        data,
+        page: headers.number,
+        pageSize: headers.size,
+        total: headers.totalelements,
+        totalPages: headers.totalpages,
+    }));
+};

package/src/getBusinessPaymentDetails.ts

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

package/src/getBusinessProducts.ts

@@ -0,0 +1,9 @@
+import { Client } from '@vulog/aima-client';
+
+import { BusinessProduct } from './types';
+
+export const getBusinessProducts = async (client: Client): Promise<BusinessProduct[]> => {
+    return client
+        .get<BusinessProduct[]>(`/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/product`)
+        .then(({ data }) => data);
+};

package/src/getBusinessTripById.ts

@@ -0,0 +1,15 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { BusinessTrip } from './types';
+
+export const getBusinessTripById = async (client: Client, tripId: string): Promise<BusinessTrip> => {
+    const result = z.string().trim().min(1).uuid().safeParse(tripId);
+    if (!result.success) {
+        throw new TypeError('Invalid args', { cause: result.error.issues });
+    }
+
+    return client
+        .get<BusinessTrip>(`/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/trip/${result.data}`)
+        .then(({ data }) => data);
+};

package/src/getBusinessUserById.ts

@@ -0,0 +1,26 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { BusinessUser } from './types';
+
+const uuidSchema = z.string().trim().min(1).uuid();
+
+export const getBusinessUserById = async (
+    client: Client,
+    businessId: string,
+    userId: string
+): Promise<BusinessUser> => {
+    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 ?? [])],
+        });
+    }
+
+    return client
+        .get<BusinessUser>(
+            `/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/business/${parsedBusinessId.data}/user/${parsedUserId.data}`
+        )
+        .then(({ data }) => data);
+};