@ikatec/digisac-api-sdk 4.9.0 → 4.11.0

package/src/apis/holiday/HolidayApi.ts

@@ -1,9 +1,24 @@
 import type { ApiClient } from '../../core/ApiClient'
+import type { ListQuery } from '../../core/types'
 import { BaseCrudApi } from '../../core/BaseCrudApi'
 import type { Holiday, CreateHolidayPayload, UpdateHolidayPayload } from './types'
 
-export class HolidayApi extends BaseCrudApi<Holiday, CreateHolidayPayload, UpdateHolidayPayload> {
+export class HolidayApi extends BaseCrudApi<
+  Holiday,
+  CreateHolidayPayload,
+  UpdateHolidayPayload,
+  ListQuery<Holiday>,
+  'OK'
+> {
   constructor(client: ApiClient) {
     super(client, '/holiday')
   }
+
+  /**
+   * Deletes a holiday. Resolves the text `'OK'`.
+   * @permissions holidays.view OR holidays.destroy
+   */
+  override deleteById(id: string, headers?: Record<string, string>): Promise<'OK'> {
+    return super.deleteById(id, headers)
+  }
 }

package/src/apis/integrations/IntegrationsApi.test.ts

@@ -0,0 +1,42 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { IntegrationsApi } from './IntegrationsApi'
+import type { ApiClient } from '../../core/ApiClient'
+
+// ── 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('IntegrationsApi', () => {
+  let client: ReturnType<typeof createMockClient>
+  let api: IntegrationsApi
+
+  beforeEach(() => {
+    client = createMockClient()
+    api = new IntegrationsApi(client)
+  })
+
+  it('create posts to /integrations and resolves the empty object the route answers', async () => {
+    vi.mocked(client.post).mockResolvedValue({})
+    const body = { type: 'menu_button', url: 'https://example.com', icon: '', text: 'QA' }
+    await expect(api.create(body)).resolves.toEqual({})
+    expect(client.post).toHaveBeenCalledWith('/integrations', body, undefined)
+  })
+
+  it('updateById puts to /integrations/:id and resolves the empty object', async () => {
+    vi.mocked(client.put).mockResolvedValue({})
+    await expect(api.updateById('int-1', { text: 'QA 2' })).resolves.toEqual({})
+    expect(client.put).toHaveBeenCalledWith('/integrations/int-1', { text: 'QA 2' }, undefined)
+  })
+})

package/src/apis/integrations/IntegrationsApi.ts

@@ -1,13 +1,57 @@
 import type { ApiClient } from '../../core/ApiClient'
+import type { ListQuery } from '../../core/types'
 import { BaseCrudApi } from '../../core/BaseCrudApi'
-import type { Integration, CreateIntegrationPayload, UpdateIntegrationPayload } from './types'
+import type {
+  Integration,
+  CreateIntegrationPayload,
+  UpdateIntegrationPayload,
+  IntegrationWriteResponse,
+} from './types'
 
+/** Integrations of the account (buttons and events of the UI). `getById` answers `null` for an unknown id. */
 export class IntegrationsApi extends BaseCrudApi<
   Integration,
   CreateIntegrationPayload,
-  UpdateIntegrationPayload
+  UpdateIntegrationPayload,
+  ListQuery<Integration>,
+  'OK',
+  IntegrationWriteResponse,
+  IntegrationWriteResponse
 > {
   constructor(client: ApiClient) {
     super(client, '/integrations')
   }
+
+  /**
+   * Creates an integration. Resolves `{}` — also when the type is unique (`event_ticket_transfer`,
+   * `event_ticket_closed`), already exists in the account and nothing is created. Find the integration with
+   * `getMany` (e.g. by `text`).
+   * @permissions integrations.create
+   */
+  override create(
+    body: CreateIntegrationPayload,
+    headers?: Record<string, string>,
+  ): Promise<IntegrationWriteResponse> {
+    return super.create(body, headers)
+  }
+
+  /**
+   * Updates an integration. Resolves `{}`; read it again with `getById`. An unknown id answers 500.
+   * @permissions integrations.view OR integrations.update
+   */
+  override updateById(
+    id: string,
+    body: UpdateIntegrationPayload,
+    headers?: Record<string, string>,
+  ): Promise<IntegrationWriteResponse> {
+    return super.updateById(id, body, headers)
+  }
+
+  /**
+   * Deletes an integration. Resolves the text `'OK'`; an unknown id answers 500.
+   * @permissions integrations.view OR integrations.destroy
+   */
+  override deleteById(id: string, headers?: Record<string, string>): Promise<'OK'> {
+    return super.deleteById(id, headers)
+  }
 }

package/src/apis/integrations/types.ts

@@ -1,27 +1,46 @@
+/**
+ * The types the UI shows: buttons (`menu_button` in the header, `context_menu_button_*` in the contact and
+ * message menus) and events that open the integration when a ticket is transferred or closed (unique per
+ * account). The backend accepts any string.
+ */
+export type IntegrationType =
+  | 'menu_button'
+  | 'context_menu_button_contact_modal'
+  | 'context_menu_button_contact_side_list'
+  | 'context_menu_button_message'
+  | 'event_ticket_transfer'
+  | 'event_ticket_closed'
+  | (string & {})
+
+export type IntegrationSize = 'sm' | 'md' | 'lg' | (string & {})
+
 export type Integration = {
   id: string
-  type: string
+  type: IntegrationType
   url: string | null
   icon: string | null
   text: string | null
-  size: string | null
+  size: IntegrationSize | null
   accountId: string
   createdAt: string
   updatedAt: string
 }
 
+/** What `create` and `updateById` resolve to: an empty object. */
+export type IntegrationWriteResponse = Record<string, never>
+
 export type CreateIntegrationPayload = {
-  type: string
+  type: IntegrationType
   url?: string
   icon?: string
   text?: string
-  size?: string
+  size?: IntegrationSize
 }
 
 export type UpdateIntegrationPayload = {
-  type?: string
+  type?: IntegrationType
   url?: string | null
   icon?: string | null
   text?: string | null
-  size?: string | null
+  size?: IntegrationSize | null
 }

package/src/apis/interactiveMessages/InteractiveMessagesApi.ts

@@ -1,4 +1,5 @@
 import type { ApiClient } from '../../core/ApiClient'
+import type { ListQuery } from '../../core/types'
 import { BaseCrudApi } from '../../core/BaseCrudApi'
 import type {
   InteractiveMessage,
@@ -9,9 +10,19 @@ import type {
 export class InteractiveMessagesApi extends BaseCrudApi<
   InteractiveMessage,
   CreateInteractiveMessagePayload,
-  UpdateInteractiveMessagePayload
+  UpdateInteractiveMessagePayload,
+  ListQuery<InteractiveMessage>,
+  'OK'
 > {
   constructor(client: ApiClient) {
     super(client, '/interactive-messages')
   }
+
+  /**
+   * Deletes an interactive message. Resolves the text `'OK'`; an unknown id answers 500.
+   * @permissions interactive-messages.destroy OR interactive-messages.management.all.departments
+   */
+  override deleteById(id: string, headers?: Record<string, string>): Promise<'OK'> {
+    return super.deleteById(id, headers)
+  }
 }

package/src/apis/kanbanBoards/KanbanBoardsApi.ts

@@ -1,13 +1,24 @@
 import type { ApiClient } from '../../core/ApiClient'
+import type { ListQuery } from '../../core/types'
 import { BaseCrudApi } from '../../core/BaseCrudApi'
 import type { KanbanBoard, CreateKanbanBoardPayload, UpdateKanbanBoardPayload } from './types'
 
 export class KanbanBoardsApi extends BaseCrudApi<
   KanbanBoard,
   CreateKanbanBoardPayload,
-  UpdateKanbanBoardPayload
+  UpdateKanbanBoardPayload,
+  ListQuery<KanbanBoard>,
+  'OK'
 > {
   constructor(client: ApiClient) {
     super(client, '/kanban-boards')
   }
+
+  /**
+   * Deletes a board with its columns. Resolves the text `'OK'`; an unknown id answers 500.
+   * @permissions kanban.boards.destroy
+   */
+  override deleteById(id: string, headers?: Record<string, string>): Promise<'OK'> {
+    return super.deleteById(id, headers)
+  }
 }

package/src/apis/kanbanCards/KanbanCardsApi.ts

@@ -1,4 +1,5 @@
 import type { ApiClient } from '../../core/ApiClient'
+import type { ListQuery } from '../../core/types'
 import { BaseCrudApi } from '../../core/BaseCrudApi'
 import type {
   KanbanCard,
@@ -10,12 +11,22 @@ import type {
 export class KanbanCardsApi extends BaseCrudApi<
   KanbanCard,
   CreateKanbanCardPayload,
-  UpdateKanbanCardPayload
+  UpdateKanbanCardPayload,
+  ListQuery<KanbanCard>,
+  'OK'
 > {
   constructor(client: ApiClient) {
     super(client, '/kanban-cards')
   }
 
+  /**
+   * Deletes a card. Resolves the text `'OK'`.
+   * @permissions kanban.cards.move
+   */
+  override deleteById(id: string, headers?: Record<string, string>): Promise<'OK'> {
+    return super.deleteById(id, headers)
+  }
+
   /**
    * Moves a card within its column or to another column (see {@link ReorderKanbanCardPayload}).
    * Resolves to the card with its new `position` and `columnId`.

package/src/apis/knowledgeBase/KnowledgeBaseApi.ts

@@ -1,13 +1,25 @@
 import type { ApiClient } from '../../core/ApiClient'
+import type { ListQuery } from '../../core/types'
 import { BaseCrudApi } from '../../core/BaseCrudApi'
 import type { KnowledgeBase, CreateKnowledgeBasePayload, UpdateKnowledgeBasePayload } from './types'
 
 export class KnowledgeBaseApi extends BaseCrudApi<
   KnowledgeBase,
   CreateKnowledgeBasePayload,
-  UpdateKnowledgeBasePayload
+  UpdateKnowledgeBasePayload,
+  ListQuery<KnowledgeBase>,
+  false
 > {
   constructor(client: ApiClient) {
     super(client, '/knowledge-base')
   }
+
+  /**
+   * Deletes a knowledge base. Resolves `false` even when it deleted (the backend answers nothing
+   * from the deletion), so do not read it as the result: check with `getById`. An unknown id
+   * answers 500.
+   */
+  override deleteById(id: string, headers?: Record<string, string>): Promise<false> {
+    return super.deleteById(id, headers)
+  }
 }

package/src/apis/knowledgeBaseItem/KnowledgeBaseItemApi.ts

@@ -1,4 +1,5 @@
 import type { ApiClient } from '../../core/ApiClient'
+import type { ListQuery } from '../../core/types'
 import { BaseCrudApi } from '../../core/BaseCrudApi'
 import type {
   KnowledgeBaseItem,
@@ -9,9 +10,20 @@ import type {
 export class KnowledgeBaseItemApi extends BaseCrudApi<
   KnowledgeBaseItem,
   CreateKnowledgeBaseItemPayload,
-  UpdateKnowledgeBaseItemPayload
+  UpdateKnowledgeBaseItemPayload,
+  ListQuery<KnowledgeBaseItem>,
+  false
 > {
   constructor(client: ApiClient) {
     super(client, '/knowledge-base-item')
   }
+
+  /**
+   * Deletes a knowledge base item (and its documents in the AI service). Resolves `false` even when
+   * it deleted (the backend answers nothing from the deletion), so do not read it as the result:
+   * check with `getById`.
+   */
+  override deleteById(id: string, headers?: Record<string, string>): Promise<false> {
+    return super.deleteById(id, headers)
+  }
 }

package/src/apis/messages/MessagesApi.test.ts

@@ -153,18 +153,24 @@ describe('MessagesApi', () => {
   // ── updateById ───────────────────────────────────────────────────
 
   describe('updateById', () => {
-    it('calls client.put with /messages/:id and body', async () => {
-      vi.mocked(client.put).mockResolvedValue(message)
-      const result = await api.updateById('msg-1', { text: 'Updated' })
-      expect(client.put).toHaveBeenCalledWith('/messages/msg-1', { text: 'Updated' }, undefined)
+    it('calls client.patch with /messages/:id and body (the backend has no PUT)', async () => {
+      vi.mocked(client.patch).mockResolvedValue(message)
+      const body = { text: 'Updated', contactId: 'ct-1', mentionedList: ['5511999999999'] }
+      const result = await api.updateById('msg-1', body)
+      expect(client.patch).toHaveBeenCalledWith('/messages/msg-1', body, undefined)
+      expect(client.put).not.toHaveBeenCalled()
       expect(result).toEqual(message)
     })
 
     it('forwards custom headers', async () => {
-      vi.mocked(client.put).mockResolvedValue(message)
+      vi.mocked(client.patch).mockResolvedValue(message)
       const headers = { 'If-Match': 'etag' }
-      await api.updateById('msg-1', { text: 'x' }, headers)
-      expect(client.put).toHaveBeenCalledWith('/messages/msg-1', { text: 'x' }, headers)
+      await api.updateById('msg-1', { text: 'x', contactId: 'ct-1' }, headers)
+      expect(client.patch).toHaveBeenCalledWith(
+        '/messages/msg-1',
+        { text: 'x', contactId: 'ct-1' },
+        headers,
+      )
     })
   })
 

package/src/apis/messages/MessagesApi.ts

@@ -23,6 +23,28 @@ export class MessagesApi extends BaseCrudApi<Message, CreateMessagePayload, Upda
     super(client, '/messages')
   }
 
+  /**
+   * Edits the text (or the file) of a message sent by the account, up to 15 minutes after it was
+   * sent (403 `Cannot edit message` after that). `contactId` is required (without it the route
+   * answers 500), and `text` or `file` (400 without both). Sent as `PATCH /messages/:id`.
+   * @permissions messages.update
+   */
+  override updateById(
+    id: string,
+    body: UpdateMessagePayload,
+    headers?: Record<string, string>,
+  ): Promise<Message> {
+    return this.client.patch<Message, UpdateMessagePayload>(`${this.basePath}/${id}`, body, headers)
+  }
+
+  /**
+   * @deprecated Not served: the backend has no DELETE /messages/:id, so this route answers 404.
+   * Use {@link bulkDestroy}.
+   */
+  override deleteById(id: string, headers?: Record<string, string>): Promise<Message> {
+    return super.deleteById(id, headers)
+  }
+
   /** Forwards one or more messages to one or more contacts (max 20 messages to 5 contacts). */
   forward(
     body: ForwardMessagesPayload,
@@ -102,8 +124,9 @@ export class MessagesApi extends BaseCrudApi<Message, CreateMessagePayload, Upda
   }
 
   /**
-   * Triggers an AI-generated summary for the conversation associated with the given message.
-   * Resolves to `'OK'`.
+   * Regenerates an existing AI summary: `id` is the id of the message of `type: 'summary'`. When
+   * there is no such message (or the AI limit was reached) nothing is done and it still resolves
+   * `'OK'`. To summarize the open ticket of a contact, use `ContactsApi.summarizeTicket`.
    */
   summarize(id: string, headers?: Record<string, string>): Promise<string> {
     return this.client.post<string>(`${this.basePath}/${id}/summarize`, undefined, headers)
@@ -122,7 +145,10 @@ export class MessagesApi extends BaseCrudApi<Message, CreateMessagePayload, Upda
     )
   }
 
-  /** Re-downloads and syncs the file attachment for a message from the messaging service. */
+  /**
+   * Re-downloads and syncs the file attachment for a message from the messaging service. Resolves
+   * what the driver answers; an unknown message answers 500.
+   */
   syncFile(id: string, headers?: Record<string, string>): Promise<unknown> {
     return this.client.post<unknown>(`${this.basePath}/${id}/sync-file`, undefined, headers)
   }

package/src/apis/messages/types.ts

@@ -203,7 +203,10 @@ export type UpdateMessagePayload = {
   text?: string
   file?: unknown
   fileId?: string
+  /** Required by the backend (500 without it), although optional here for compatibility. */
   contactId?: string
+  /** `idFromService` of the contacts mentioned in a group message. */
+  mentionedList?: string[]
   number?: string
   origin?: 'user' | 'bot'
   hsm?: unknown

package/src/apis/notifications/NotificationsApi.ts

@@ -1,13 +1,24 @@
 import type { ApiClient } from '../../core/ApiClient'
+import type { ListQuery } from '../../core/types'
 import { BaseCrudApi } from '../../core/BaseCrudApi'
 import type { Notification, CreateNotificationPayload, UpdateNotificationPayload } from './types'
 
 export class NotificationsApi extends BaseCrudApi<
   Notification,
   CreateNotificationPayload,
-  UpdateNotificationPayload
+  UpdateNotificationPayload,
+  ListQuery<Notification>,
+  'OK'
 > {
   constructor(client: ApiClient) {
     super(client, '/notifications')
   }
+
+  /**
+   * Deletes a notification. Resolves the text `'OK'`; an unknown id answers 500. The route checks
+   * no permission.
+   */
+  override deleteById(id: string, headers?: Record<string, string>): Promise<'OK'> {
+    return super.deleteById(id, headers)
+  }
 }

package/src/apis/organizations/OrganizationsApi.ts

@@ -1,13 +1,24 @@
 import type { ApiClient } from '../../core/ApiClient'
+import type { ListQuery } from '../../core/types'
 import { BaseCrudApi } from '../../core/BaseCrudApi'
 import type { Organization, CreateOrganizationPayload, UpdateOrganizationPayload } from './types'
 
 export class OrganizationsApi extends BaseCrudApi<
   Organization,
   CreateOrganizationPayload,
-  UpdateOrganizationPayload
+  UpdateOrganizationPayload,
+  ListQuery<Organization>,
+  'OK'
 > {
   constructor(client: ApiClient) {
     super(client, '/organizations')
   }
+
+  /**
+   * Deletes an organization. Resolves the text `'OK'`.
+   * @permissions organizations.view OR organizations.destroy
+   */
+  override deleteById(id: string, headers?: Record<string, string>): Promise<'OK'> {
+    return super.deleteById(id, headers)
+  }
 }

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

@@ -46,6 +46,33 @@ import type { Ticket, TicketTransfer, TicketsCount, TicketsCounts } from './tick
 import { TimetableApi } from './timetable/TimetableApi'
 import { UsersApi } from './users/UsersApi'
 
+import { AcceptanceTermsApi } from './acceptanceTerms/AcceptanceTermsApi'
+import { CategoriesApi } from './categories/CategoriesApi'
+import { ContactBlockListsApi } from './contactBlockLists/ContactBlockListsApi'
+import { ContactBlockListsControlsApi } from './contactBlockListsControls/ContactBlockListsControlsApi'
+import type { SummarizeTicketResult } from './contacts/types'
+import { CustomFieldsApi } from './customFields/CustomFieldsApi'
+import { DepartmentsApi } from './departments/DepartmentsApi'
+import type { Department } from './departments/types'
+import type { Distribution } from './distribution/types'
+import type { ContactBlockList } from './contactBlockLists/types'
+import { DistributionApi } from './distribution/DistributionApi'
+import { FilesApi } from './files/FilesApi'
+import type { CreateToUploadResult, DeleteFileResult, File } from './files/types'
+import { HolidayApi } from './holiday/HolidayApi'
+import { IntegrationsApi } from './integrations/IntegrationsApi'
+import { KanbanBoardsApi } from './kanbanBoards/KanbanBoardsApi'
+import { KanbanCardsApi } from './kanbanCards/KanbanCardsApi'
+import { KnowledgeBaseApi } from './knowledgeBase/KnowledgeBaseApi'
+import { KnowledgeBaseItemApi } from './knowledgeBaseItem/KnowledgeBaseItemApi'
+import { MessagesApi } from './messages/MessagesApi'
+import { NotificationsApi } from './notifications/NotificationsApi'
+import { OrganizationsApi } from './organizations/OrganizationsApi'
+import { PeopleApi } from './people/PeopleApi'
+import { ServicesApi } from './services/ServicesApi'
+import type { UpdateUserPayload } from './users/types'
+import { WebhooksApi } from './webhooks/WebhooksApi'
+
 declare const client: ApiClient
 
 // ── roles: the backend drops `permissionIds` in silence ─────────────
@@ -497,3 +524,148 @@ expectType<number | string | undefined>(listed.config.minInterval)
 expectType<CampaignMessage[] | undefined>(listed.messages)
 declare const campaignContact: CampaignContact
 expectType<string | null>(campaignContact.contactNumber)
+
+// ── deleteById: what each route really answers ───────────────────────
+
+expectType<Promise<'OK'>>(new DepartmentsApi(client).deleteById('d-1'))
+expectType<Promise<'OK'>>(new UsersApi(client).deleteById('u-1'))
+expectType<Promise<'OK'>>(new TagsApi(client).deleteById('t-1'))
+expectType<Promise<'OK'>>(new KanbanBoardsApi(client).deleteById('b-1'))
+expectType<Promise<'OK'>>(new KanbanCardsApi(client).deleteById('c-1'))
+expectType<Promise<'OK'>>(new WebhooksApi(client).deleteById('w-1'))
+expectType<Promise<'OK'>>(new CategoriesApi(client).deleteById('c-1'))
+expectType<Promise<'OK'>>(new IntegrationsApi(client).deleteById('i-1'))
+expectType<Promise<'OK'>>(new InteractiveMessagesApi(client).deleteById('i-1'))
+expectType<Promise<'OK'>>(new NotificationsApi(client).deleteById('n-1'))
+expectType<Promise<'OK'>>(new CustomFieldsApi(client).deleteById('f-1'))
+expectType<Promise<'OK'>>(new HolidayApi(client).deleteById('h-1'))
+expectType<Promise<'OK'>>(new PeopleApi(client).deleteById('p-1'))
+expectType<Promise<'OK'>>(new OrganizationsApi(client).deleteById('o-1'))
+expectType<Promise<'OK'>>(new TimetableApi(client).deleteById('t-1'))
+expectType<Promise<'OK'>>(new ContactBlockListsApi(client).deleteById('l-1'))
+expectType<Promise<'OK'>>(new ContactBlockListsControlsApi(client).deleteById('c-1'))
+expectType<Promise<boolean>>(new RolesApi(client).deleteById('r-1'))
+expectType<Promise<void>>(new AcceptanceTermsApi(client).deleteById('t-1'))
+expectType<Promise<void>>(new DistributionApi(client).deleteById('d-1'))
+
+// ── create/updateById: what each route really answers (QARC-1008) ─────
+
+expectType<Promise<Distribution | undefined>>(
+  new DistributionApi(client).create({
+    name: 'd',
+    maxNum: 1,
+    redistributeAll: false,
+    departments: [{ id: 'dep-1' }],
+  }),
+)
+expectType<Promise<Distribution | Department[]>>(
+  new DistributionApi(client).updateById('d-1', {
+    name: 'd',
+    roles: [{ id: 'r-1' }],
+    departments: [],
+  }),
+)
+expectType<Promise<Record<string, never>>>(
+  new IntegrationsApi(client).create({ type: 'menu_button', text: 'x' }),
+)
+expectType<Promise<Record<string, never>>>(
+  new IntegrationsApi(client).updateById('i-1', { text: 'x' }),
+)
+expectType<Promise<void>>(
+  new ContactBlockListsControlsApi(client).create({
+    reason: 'r',
+    servicesIds: ['s-1'],
+    contactBlockListsIds: ['l-1'],
+    action: 'block',
+    revertExceptions: false,
+  }),
+)
+expectType<Promise<{ count: number }>>(
+  new ContactBlockListsApi(client).count({ where: { name: 'x' } }),
+)
+expectType<Promise<{ count: number }>>(new ContactBlockListsControlsApi(client).count())
+expectType<Promise<Paginated<ContactBlockList>>>(
+  new ContactBlockListsApi(client).getMany({ include: ['importFile'] }),
+)
+expectError(
+  new DistributionApi(client).create({
+    name: 'd',
+    maxNum: 1,
+    redistributeAll: false,
+    departments: ['dep-1'],
+  }),
+)
+expectError(
+  new ContactBlockListsControlsApi(client).create({
+    reason: 'r',
+    servicesIds: [],
+    contactBlockListsIds: [],
+    action: 'remove',
+  }),
+)
+expectType<Promise<false>>(new KnowledgeBaseApi(client).deleteById('k-1'))
+expectType<Promise<false>>(new KnowledgeBaseItemApi(client).deleteById('k-1'))
+expectType<Promise<DeleteFileResult>>(new FilesApi(client).deleteById('f-1'))
+
+// ── services: archive through POST /:id/archive, with the type ───────
+
+const services = new ServicesApi(client)
+expectType<Promise<Record<string, never>>>(
+  services.archiveWithValidation('s-1', { archive: true, type: 'sms-wavy' }),
+)
+expectError(services.archiveWithValidation('s-1', { archive: true }))
+expectType<Promise<'OK'>>(services.takeover('s-1'))
+expectType<Promise<'OK'>>(services.logout('s-1'))
+expectType<Promise<'OK'>>(services.shutdown('s-1'))
+expectType<Promise<'OK'>>(services.start('s-1'))
+expectType<Promise<'OK'>>(services.restart('s-1'))
+expectAssignable<UpdateServicePayload>({ type: 'whatsapp', name: 'x', archivedAt: null })
+
+// ── contacts, departments, messages, users ──────────────────────────
+
+const contactsApi = new ContactsApi(client)
+expectType<Promise<SummarizeTicketResult>>(contactsApi.summarizeTicket('c-1'))
+expectType<Promise<string>>(contactsApi.exportTemplate({ serviceType: 'whatsapp' }))
+expectType<Promise<Department>>(
+  new DepartmentsApi(client).archiveWithValidation('d-1', { archive: true }),
+)
+expectError(new DepartmentsApi(client).archiveWithValidation('d-1', {}))
+new MessagesApi(client).updateById('m-1', { text: 'x', contactId: 'c-1', mentionedList: ['5511'] })
+expectAssignable<UpdateUserPayload>({ restrictedServices: [{ value: 's-1' }], password: 'x' })
+expectNotAssignable<UpdateUserPayload>({ restrictedServices: ['s-1'] })
+
+// ── files: upload through a signed URL ──────────────────────────────
+
+const files = new FilesApi(client)
+expectType<Promise<CreateToUploadResult>>(
+  files.createToUpload({ name: 'a.txt', mimetype: 'text/plain' }),
+)
+expectError(files.createToUpload({ name: 'a.txt' }))
+expectType<Promise<void>>(files.upload('https://storage/x', 'content', 'text/plain'))
+expectAssignable<File>({
+  id: 'f-1',
+  url: 'https://x',
+  name: 'a.txt',
+  publicFilename: 'f-1.txt',
+  checksum: null,
+  mimetype: 'text/plain',
+  extension: 'txt',
+  data: {},
+  accountId: 'a-1',
+  createdAt: '2026-01-01T00:00:00Z',
+  updatedAt: '2026-01-01T00:00:00Z',
+})
+
+// ── a custom ApiClient without requestRaw is still an ApiClient ──────
+
+expectAssignable<ApiClient>({
+  setAccessToken() {
+    return this
+  },
+  request: async <T>() => undefined as T,
+  get: async <T>() => undefined as T,
+  post: async <T>() => undefined as T,
+  put: async <T>() => undefined as T,
+  patch: async <T>() => undefined as T,
+  delete: async <T>() => undefined as T,
+})