@ikatec/digisac-api-sdk 4.0.0 → 4.2.0

package/src/apis/now/types.ts

@@ -0,0 +1,47 @@
+import type { User } from '../users/types'
+
+/**
+ * Filters of the "Agora" (now) overview. Each accepts one id, an array or a comma-separated list.
+ * A user with only `overview.now.view.departments` gets 403 for departments/users outside their
+ * departments.
+ */
+export type NowQuery = {
+  departmentId?: string | string[]
+  userId?: string | string[]
+}
+
+/** Every `/now` route answers its data under `totals`. */
+export type NowResponse<T> = { totals: T }
+
+export type NowResumeTotals = {
+  openTickets: number
+  queueTickets: number
+  usersWithAttendance: number
+  usersWithoutAttendance: number
+  /** Postgres `avg()` — a numeric string, or `0` when there is no data. */
+  averageOpenTicketsTime: number | string
+  /** Postgres `avg()` — a numeric string, or `0` when there is no data. */
+  averageOpenTicketsWaitTime: number | string
+  onlineUsersCount: number
+  offlineUsersCount: number
+  absentUsersCount: number
+}
+
+/** One entry per department. */
+export type NowDepartmentResume = {
+  name: string
+  onlineUserCount: number
+  offlineUserCount: number
+  absentUserCount: number
+  onQueueTicketCount: number
+  openTicketCount: number
+}
+
+/** One entry per attendant (user). */
+export type NowAttendanceResume = {
+  name?: string
+  /** Department names — `0` when the attendant has no department. */
+  departments: string[] | 0
+  status?: User['status']
+  ticketsOpenCount: number
+}

package/src/apis/payloads.test-d.ts

@@ -0,0 +1,39 @@
+import { expectError } from 'tsd'
+import type { ApiClient } from '../core/ApiClient'
+import { PersonalAccessTokensApi } from './personalAccessTokens/PersonalAccessTokensApi'
+import { RolesApi } from './roles/RolesApi'
+import { TimetableApi } from './timetable/TimetableApi'
+
+declare const client: ApiClient
+
+// ── roles: the backend drops `permissionIds` in silence ─────────────
+
+const roles = new RolesApi(client)
+roles.create({ displayName: 'Supervisor', permissions: ['p-1', { id: 'p-2' }] })
+expectError(roles.create({ displayName: 'Supervisor', permissionIds: ['p-1'] }))
+expectError(roles.updateById('r-1', { permissions: ['p-1'] }))
+
+// ── timetable: the old workPlan shape answers 400 ───────────────────
+
+const timetable = new TimetableApi(client)
+timetable.create({
+  name: 'Business hours',
+  previousTimeToNotification: 15,
+  workPlan: [{ start: '08:00', end: '18:00', weekDays: ['mon'] }],
+})
+expectError(
+  timetable.create({
+    name: 'Business hours',
+    previousTimeToNotification: 15,
+    workPlan: [{ day: 1, start: '08:00', end: '18:00', active: true }],
+  }),
+)
+expectError(timetable.updateById('t-1', { name: 'Business hours' }))
+
+// ── personal access tokens: `expiresIn` is the only lifetime accepted ─
+
+const tokens = new PersonalAccessTokensApi(client)
+tokens.create({ name: 'CI', expiresIn: '90d' })
+expectError(tokens.create({ name: 'CI', accessTokenExpiresAt: '2030-01-01T00:00:00Z' }))
+expectError(tokens.create({ name: 'CI', expiresIn: '7d' }))
+expectError(tokens.updateById('t-1', { scope: '*' }))

package/src/apis/payloads.test.ts

@@ -0,0 +1,81 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type { ApiClient } from '../core/ApiClient'
+import { PersonalAccessTokensApi } from './personalAccessTokens/PersonalAccessTokensApi'
+import { RolesApi } from './roles/RolesApi'
+import { TimetableApi } from './timetable/TimetableApi'
+
+// Pins the body keys the backend reads: a key it does not know is dropped in silence, so a
+// regression would only show up as missing data (e.g. a role created without permissions).
+
+// ── Mock client factory ──────────────────────────────────────────────
+
+function createMockClient(): ApiClient {
+  return {
+    setAccessToken: vi.fn().mockReturnThis(),
+    request: vi.fn(),
+    get: vi.fn(),
+    post: vi.fn(),
+    put: vi.fn(),
+    patch: vi.fn(),
+    delete: vi.fn(),
+  }
+}
+
+// ── Tests ────────────────────────────────────────────────────────────
+
+describe('payloads sent to the backend', () => {
+  let client: ReturnType<typeof createMockClient>
+
+  beforeEach(() => {
+    client = createMockClient()
+  })
+
+  describe('RolesApi', () => {
+    it('create sends the permissions under `permissions`', async () => {
+      await new RolesApi(client).create({
+        displayName: 'Supervisor',
+        permissions: ['p-1', { id: 'p-2' }],
+      })
+      expect(client.post).toHaveBeenCalledWith(
+        '/roles',
+        { displayName: 'Supervisor', permissions: ['p-1', { id: 'p-2' }] },
+        undefined,
+      )
+    })
+
+    it('updateById sends displayName and the permissions under `permissions`', async () => {
+      await new RolesApi(client).updateById('r-1', {
+        displayName: 'Supervisor',
+        permissions: ['p-1'],
+      })
+      expect(client.put).toHaveBeenCalledWith(
+        '/roles/r-1',
+        { displayName: 'Supervisor', permissions: ['p-1'] },
+        undefined,
+      )
+    })
+  })
+
+  describe('TimetableApi', () => {
+    it('create sends the workPlan as { start, end, weekDays }', async () => {
+      const body = {
+        name: 'Business hours',
+        previousTimeToNotification: 15,
+        workPlan: [{ start: '08:00', end: '18:00', weekDays: ['mon' as const, 'fri' as const] }],
+      }
+      await new TimetableApi(client).create(body)
+      expect(client.post).toHaveBeenCalledWith('/timetable', body, undefined)
+    })
+  })
+
+  describe('PersonalAccessTokensApi', () => {
+    it('create sends the lifetime under `expiresIn`', async () => {
+      await new PersonalAccessTokensApi(client).create({ name: 'CI', expiresIn: '90d' })
+      expect(client.post).toHaveBeenCalledWith(
+        '/me/tokens',
+        { name: 'CI', expiresIn: '90d' },
+        undefined,
+      )
+    })
+  })
+})

package/src/apis/people/types.ts

@@ -17,10 +17,15 @@ export type PersonRelationships = 'organizations' | 'contacts'
 
 export type CreatePersonPayload = {
   name: string
-  document?: string
+  document?: string | null
+  /** Organizations of the account to link the person to (400 if any belongs to another account). */
+  organizationIds?: string[]
 }
 
 export type UpdatePersonPayload = {
-  name?: string
+  /** Required by the backend on every update (400 `required` otherwise). */
+  name: string
   document?: string | null
+  /** Replaces the linked organizations: `[]` unlinks all, omitting it keeps them. */
+  organizationIds?: string[]
 }

package/src/apis/permissions/PermissionsApi.test.ts

@@ -0,0 +1,93 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { PermissionsApi } from './PermissionsApi'
+import type { ApiClient } from '../../core/ApiClient'
+import type { Permission } from './types'
+
+// ── Mock client factory ──────────────────────────────────────────────
+
+function createMockClient(): ApiClient {
+  return {
+    setAccessToken: vi.fn().mockReturnThis(),
+    request: vi.fn(),
+    get: vi.fn(),
+    post: vi.fn(),
+    put: vi.fn(),
+    patch: vi.fn(),
+    delete: vi.fn(),
+  }
+}
+
+// ── Fixtures ─────────────────────────────────────────────────────────
+
+const permission: Permission = { id: 'p-1', name: 'customFields.create', type: 'customFields' }
+
+// ── Tests ────────────────────────────────────────────────────────────
+
+describe('PermissionsApi', () => {
+  let client: ReturnType<typeof createMockClient>
+  let api: PermissionsApi
+
+  beforeEach(() => {
+    client = createMockClient()
+    api = new PermissionsApi(client)
+  })
+
+  it('exposes only the read routes served by the backend', () => {
+    expect(api.basePath).toBe('/permissions')
+    expect(api).not.toHaveProperty('create')
+    expect(api).not.toHaveProperty('updateById')
+    expect(api).not.toHaveProperty('deleteById')
+  })
+
+  describe('getMany', () => {
+    it('calls client.get with /permissions and no query string when there is no query', async () => {
+      vi.mocked(client.get).mockResolvedValue({ data: [permission], total: 1 })
+      await api.getMany()
+      expect(client.get).toHaveBeenCalledWith('/permissions', undefined)
+    })
+
+    it('serializes the query in the client format', async () => {
+      vi.mocked(client.get).mockResolvedValue([permission])
+      const result = await api.getMany({ paginate: false })
+      expect(client.get).toHaveBeenCalledWith(
+        `/permissions?query=${encodeURIComponent(JSON.stringify({ paginate: false }))}`,
+        undefined,
+      )
+      expect(result).toEqual([permission])
+    })
+  })
+
+  describe('getOne', () => {
+    it('asks for a single unpaginated result and returns it', async () => {
+      vi.mocked(client.get).mockResolvedValue([permission])
+      const result = await api.getOne({ where: { name: 'customFields.create' } })
+      const query = { where: { name: 'customFields.create' }, limit: 1, paginate: false }
+      expect(client.get).toHaveBeenCalledWith(
+        `/permissions?query=${encodeURIComponent(JSON.stringify(query))}`,
+        undefined,
+      )
+      expect(result).toEqual(permission)
+    })
+
+    it('returns null when nothing matches', async () => {
+      vi.mocked(client.get).mockResolvedValue([])
+      expect(await api.getOne()).toBeNull()
+    })
+  })
+
+  describe('getById', () => {
+    it('calls client.get with /permissions/:id', async () => {
+      vi.mocked(client.get).mockResolvedValue(permission)
+      const result = await api.getById('p-1')
+      expect(client.get).toHaveBeenCalledWith('/permissions/p-1', undefined)
+      expect(result).toEqual(permission)
+    })
+
+    it('forwards custom headers', async () => {
+      vi.mocked(client.get).mockResolvedValue(permission)
+      const headers = { 'X-Custom': 'h' }
+      await api.getById('p-1', undefined, headers)
+      expect(client.get).toHaveBeenCalledWith('/permissions/p-1', headers)
+    })
+  })
+})

package/src/apis/permissions/PermissionsApi.ts

@@ -1,12 +1,12 @@
 import type { ApiClient } from '../../core/ApiClient'
-import { BaseCrudApi } from '../../core/BaseCrudApi'
-import type { Permission, CreatePermissionPayload, UpdatePermissionPayload } from './types'
+import { BaseReadApi } from '../../core/BaseReadApi'
+import type { Permission } from './types'
 
-export class PermissionsApi extends BaseCrudApi<
-  Permission,
-  CreatePermissionPayload,
-  UpdatePermissionPayload
-> {
+/**
+ * The permission catalog used by roles. The backend only serves `GET /permissions` and
+ * `GET /permissions/:id` (guarded by `roles.view`), so there is no create/update/delete.
+ */
+export class PermissionsApi extends BaseReadApi<Permission> {
   constructor(client: ApiClient) {
     super(client, '/permissions')
   }

package/src/apis/permissions/types.ts

@@ -210,24 +210,12 @@ export type PermissionName =
   | 'kanban.update'
   | 'kanban.destroy'
 
+/**
+ * A permission, as `GET /permissions` answers it (the transformer only picks these fields).
+ * Permissions are a fixed catalog: the API is read-only.
+ */
 export type Permission = {
   id: string
   name: PermissionName
   type: PermissionType | null
-  description: string | null
-  createdAt: string
-  updatedAt: string
-  deletedAt: string | null
-}
-
-export type CreatePermissionPayload = {
-  name: PermissionName
-  type?: PermissionType
-  description?: string
-}
-
-export type UpdatePermissionPayload = {
-  name?: PermissionName
-  type?: PermissionType | null
-  description?: string | null
 }

package/src/apis/personalAccessTokens/PersonalAccessTokensApi.ts

@@ -6,6 +6,11 @@ import type {
   UpdatePersonalAccessTokenPayload,
 } from './types'
 
+/**
+ * Personal access tokens of the authenticated user (`/me/tokens`, all routes guarded by
+ * `settingsApi.update`). The listing is scoped to the user; `getById` of a missing token answers
+ * 404 (`{ message: 'Not found' }`) instead of `null`.
+ */
 export class PersonalAccessTokensApi extends BaseCrudApi<
   PersonalAccessToken,
   CreatePersonalAccessTokenPayload,

package/src/apis/personalAccessTokens/types.ts

@@ -1,28 +1,49 @@
 import type { User } from '../users/types'
 
+export type PersonalAccessTokenStatus = 'active' | 'revoked' | 'expired'
+
+/** Accepted lifetimes of a token (`No expiration` keeps `accessTokenExpiresAt` null). */
+export type PersonalAccessTokenExpiresIn = '30d' | '90d' | '180d' | '1y' | 'No expiration'
+
+/**
+ * A personal access token of the authenticated user.
+ *
+ * `accessToken` comes in full only in the `create` answer; every other route masks it
+ * (`abcde***vwxyz`). `status` and `user` (only `{ name }`) come on `getMany`/`getById`.
+ * `deleteById` revokes the token (soft delete): it keeps being listed with `status: 'revoked'`.
+ */
 export type PersonalAccessToken = {
   id: string
   name: string
+  /** `*` when created without a scope. */
   scope: string | null
   accessToken: string
   accessTokenExpiresAt: string | null
   userId: string
+  clientId: string | null
+  impersonate?: boolean | null
   createdAt: string
   updatedAt: string
   deletedAt: string | null
+  /** Only on `getMany`/`getById` answers. */
+  status?: PersonalAccessTokenStatus
   // relationships
-  user?: User
+  /** Only on `getMany`/`getById` answers, with just the name. */
+  user?: Pick<User, 'name'>
 }
 
 export type PersonalAccessTokenRelationships = 'user'
 
 export type CreatePersonalAccessTokenPayload = {
+  /** Up to 255 characters. */
   name: string
+  /** Up to 255 characters (`*` by default). */
   scope?: string
-  accessTokenExpiresAt?: string
+  expiresIn?: PersonalAccessTokenExpiresIn
 }
 
 export type UpdatePersonalAccessTokenPayload = {
-  name?: string
-  scope?: string | null
+  /** Required by the backend on every update (400 `required` otherwise). */
+  name: string
+  scope?: string
 }

package/src/apis/queryFormat.test.ts

@@ -0,0 +1,273 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import qs from 'qs'
+import type { ApiClient } from '../core/ApiClient'
+import { BaseApiClient } from '../core/BaseApiClient'
+import type { QueryFormat } from '../core/queryString'
+import { AuthHistoryApi } from './authHistory/AuthHistoryApi'
+import { ContactsApi } from './contacts/ContactsApi'
+import { DashboardApi } from './dashboard/DashboardApi'
+import { NowApi } from './now/NowApi'
+import { PermissionsApi } from './permissions/PermissionsApi'
+import { ServiceAccessManagementApi } from './serviceAccessManagement/ServiceAccessManagementApi'
+import { StickerUsersApi } from './stickerUsers/StickerUsersApi'
+import { TermsApi } from './terms/TermsApi'
+
+/**
+ * Every method that sends a list/get query must serialize it in the client's `queryFormat` and
+ * honor `withQueryFormat`. A method listed here that ignored the format would fail below.
+ */
+
+function createMockClient(queryFormat?: QueryFormat): ApiClient {
+  return {
+    ...(queryFormat && { queryFormat }),
+    setAccessToken: vi.fn().mockReturnThis(),
+    request: vi.fn(),
+    get: vi.fn().mockResolvedValue([]),
+    post: vi.fn(),
+    put: vi.fn(),
+    patch: vi.fn(),
+    delete: vi.fn(),
+  }
+}
+
+const listQuery = { where: { name: 'x' }, page: 2, perPage: 5 }
+const getQuery = { attributes: ['id'] }
+
+type Case = {
+  name: string
+  path: string
+  query: object
+  /** Calls the method on the API built from `client`, optionally through `withQueryFormat`. */
+  call: (client: ApiClient, override?: QueryFormat) => Promise<unknown>
+}
+
+const cases: Case[] = [
+  {
+    name: 'ContactsApi.getMany (BaseCrudApi)',
+    path: '/contacts',
+    query: listQuery,
+    call: (client, f) => {
+      const api = new ContactsApi(client)
+      return (f ? api.withQueryFormat(f) : api).getMany(listQuery)
+    },
+  },
+  {
+    name: 'ContactsApi.getById (BaseCrudApi)',
+    path: '/contacts/c1',
+    query: getQuery,
+    call: (client, f) => {
+      const api = new ContactsApi(client)
+      return (f ? api.withQueryFormat(f) : api).getById('c1', { attributes: ['id'] })
+    },
+  },
+  {
+    name: 'ContactsApi.count',
+    path: '/contacts/count',
+    query: listQuery,
+    call: (client, f) => {
+      const api = new ContactsApi(client)
+      return (f ? api.withQueryFormat(f) : api).count(listQuery)
+    },
+  },
+  {
+    name: 'ContactsApi.forward',
+    path: '/contacts/forward',
+    query: listQuery,
+    call: (client, f) => {
+      const api = new ContactsApi(client)
+      return (f ? api.withQueryFormat(f) : api).forward(listQuery)
+    },
+  },
+  {
+    name: 'AuthHistoryApi.getMany',
+    path: '/auth-history',
+    query: { page: 2, perPage: 5 },
+    call: (client, f) => {
+      const api = new AuthHistoryApi(client)
+      return (f ? api.withQueryFormat(f) : api).getMany({ page: 2, perPage: 5 })
+    },
+  },
+  {
+    name: 'DashboardApi.getGeneral',
+    path: '/dashboard/general',
+    query: { status: 'closed', departmentId: ['d1'] },
+    call: (client, f) => {
+      const api = new DashboardApi(client)
+      return (f ? api.withQueryFormat(f) : api).getGeneral({
+        status: 'closed',
+        departmentId: ['d1'],
+      })
+    },
+  },
+  {
+    name: 'NowApi.getResume',
+    path: '/now/resume',
+    query: { departmentId: ['d1'], userId: 'u1' },
+    call: (client, f) => {
+      const api = new NowApi(client)
+      return (f ? api.withQueryFormat(f) : api).getResume({ departmentId: ['d1'], userId: 'u1' })
+    },
+  },
+  {
+    name: 'NowApi.getAttendanceResume',
+    path: '/now/attendance-resume',
+    query: { departmentId: ['d1'], userId: 'u1' },
+    call: (client, f) => {
+      const api = new NowApi(client)
+      return (f ? api.withQueryFormat(f) : api).getAttendanceResume({
+        departmentId: ['d1'],
+        userId: 'u1',
+      })
+    },
+  },
+  {
+    name: 'NowApi.getDepartmentsResume',
+    path: '/now/departments-resume',
+    query: { departmentId: ['d1'], userId: 'u1' },
+    call: (client, f) => {
+      const api = new NowApi(client)
+      return (f ? api.withQueryFormat(f) : api).getDepartmentsResume({
+        departmentId: ['d1'],
+        userId: 'u1',
+      })
+    },
+  },
+  {
+    name: 'PermissionsApi.getMany',
+    path: '/permissions',
+    query: listQuery,
+    call: (client, f) => {
+      const api = new PermissionsApi(client)
+      return (f ? api.withQueryFormat(f) : api).getMany(listQuery)
+    },
+  },
+  {
+    name: 'PermissionsApi.getById',
+    path: '/permissions/p1',
+    query: getQuery,
+    call: (client, f) => {
+      const api = new PermissionsApi(client)
+      return (f ? api.withQueryFormat(f) : api).getById('p1', { attributes: ['id'] })
+    },
+  },
+  {
+    name: 'AuthHistoryApi.getById',
+    path: '/auth-history/a1',
+    query: getQuery,
+    call: (client, f) => {
+      const api = new AuthHistoryApi(client)
+      return (f ? api.withQueryFormat(f) : api).getById('a1', { attributes: ['id'] })
+    },
+  },
+  {
+    name: 'ServiceAccessManagementApi.getMany',
+    path: '/service-access-management',
+    query: { page: 2, perPage: 5 },
+    call: (client, f) => {
+      const api = new ServiceAccessManagementApi(client)
+      return (f ? api.withQueryFormat(f) : api).getMany({ page: 2, perPage: 5 })
+    },
+  },
+  {
+    name: 'StickerUsersApi.getMany',
+    path: '/sticker-users',
+    query: { page: 2, perPage: 5 },
+    call: (client, f) => {
+      const api = new StickerUsersApi(client)
+      return (f ? api.withQueryFormat(f) : api).getMany({ page: 2, perPage: 5 })
+    },
+  },
+  {
+    name: 'TermsApi.getById',
+    path: '/terms/t1',
+    query: getQuery,
+    call: (client, f) => {
+      const api = new TermsApi(client)
+      return (f ? api.withQueryFormat(f) : api).getById('t1', { attributes: ['id'] })
+    },
+  },
+]
+
+const jsonUrl = (path: string, query: object) =>
+  `${path}?query=${encodeURIComponent(JSON.stringify(query))}`
+const qsUrl = (path: string, query: object) => `${path}?${qs.stringify(query)}`
+const calledUrl = (client: ApiClient) => vi.mocked(client.get).mock.calls.at(0)?.at(0)
+
+describe.each(cases)('$name', ({ path, query, call }) => {
+  it("sends JSON with the default client format ('json')", async () => {
+    const client = createMockClient()
+    await call(client)
+    expect(calledUrl(client)).toBe(jsonUrl(path, query))
+  })
+
+  it("sends bracket notation with a 'qs' client", async () => {
+    const client = createMockClient('qs')
+    await call(client)
+    expect(calledUrl(client)).toBe(qsUrl(path, query))
+  })
+
+  it("withQueryFormat('qs') overrides a 'json' client", async () => {
+    const client = createMockClient()
+    await call(client, 'qs')
+    expect(calledUrl(client)).toBe(qsUrl(path, query))
+  })
+
+  it("withQueryFormat('json') overrides a 'qs' client", async () => {
+    const client = createMockClient('qs')
+    await call(client, 'json')
+    expect(calledUrl(client)).toBe(jsonUrl(path, query))
+  })
+})
+
+describe('query format through BaseApiClient', () => {
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  const mockFetch = () =>
+    vi
+      .spyOn(globalThis, 'fetch')
+      .mockImplementation(
+        async () =>
+          new Response('[]', { status: 200, headers: { 'Content-Type': 'application/json' } }),
+      )
+
+  it('builds the full ?query=<JSON> URL by default, keeping null typed', async () => {
+    const fetchSpy = mockFetch()
+    const contacts = new ContactsApi(new BaseApiClient('https://api.example.com/'))
+
+    await contacts.getMany({ where: { name: null }, paginate: false })
+
+    const query = '{"where":{"name":null},"paginate":false}'
+    expect(fetchSpy.mock.calls[0]?.[0]).toBe(
+      `https://api.example.com/contacts?query=${encodeURIComponent(query)}`,
+    )
+  })
+
+  it("builds the bracket URL with queryFormat 'qs'", async () => {
+    const fetchSpy = mockFetch()
+    const client = new BaseApiClient('https://api.example.com', undefined, { queryFormat: 'qs' })
+
+    await new ContactsApi(client).getMany({ where: { name: 'x' }, paginate: false })
+
+    expect(decodeURIComponent(fetchSpy.mock.calls[0]?.[0] as string)).toBe(
+      'https://api.example.com/contacts?where[name]=x&paginate=false',
+    )
+  })
+
+  it("setAccessToken on a copy's client only affects the copy", async () => {
+    const fetchSpy = mockFetch()
+    const client = new BaseApiClient('https://api.example.com', 'original')
+    const contacts = new ContactsApi(client)
+    const copy = contacts.withQueryFormat('qs')
+
+    copy.client.setAccessToken('copy-only')
+    await contacts.getMany({ paginate: false })
+    await copy.getMany({ paginate: false })
+
+    const authorization = (call: number) =>
+      (fetchSpy.mock.calls[call]?.[1]?.headers as Record<string, string>).Authorization
+    expect(authorization(0)).toBe('Bearer original')
+    expect(authorization(1)).toBe('Bearer copy-only')
+  })
+})

package/src/apis/roles/RolesApi.ts

@@ -1,8 +1,13 @@
 import type { ApiClient } from '../../core/ApiClient'
 import { BaseCrudApi } from '../../core/BaseCrudApi'
-import type { Role, CreateRolePayload, UpdateRolePayload } from './types'
+import type { Role, CreateRolePayload, UpdateRolePayload, RolesListQuery } from './types'
 
-export class RolesApi extends BaseCrudApi<Role, CreateRolePayload, UpdateRolePayload> {
+export class RolesApi extends BaseCrudApi<
+  Role,
+  CreateRolePayload,
+  UpdateRolePayload,
+  RolesListQuery
+> {
   constructor(client: ApiClient) {
     super(client, '/roles')
   }