@ikatec/digisac-api-sdk 4.8.0 → 4.10.0

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

@@ -17,6 +17,13 @@ import type {
 } from './campaigns/types'
 import { CardsApi } from './cards/CardsApi'
 import { ContactsApi } from './contacts/ContactsApi'
+import { InteractiveMessagesApi } from './interactiveMessages/InteractiveMessagesApi'
+import type {
+  ChannelRedirect,
+  CtaUrlInteractiveMessageContent,
+  InteractiveMessage,
+  RequestContactInfoInteractiveMessageContent,
+} from './interactiveMessages'
 import { KanbanColumnsApi } from './kanbanColumns/KanbanColumnsApi'
 import { PipelineApi } from './pipeline/PipelineApi'
 import type { PermissionName } from './permissions/types'
@@ -26,6 +33,12 @@ import { QuickRepliesApi } from './quickReplies/QuickRepliesApi'
 import { RolesApi } from './roles/RolesApi'
 import { ScheduleApi } from './schedule/ScheduleApi'
 import type { ScheduleRecord } from './schedule/types'
+import type {
+  CreateServicePayload,
+  Service,
+  UpdateServicePayload,
+  WebchatServiceData,
+} from './services'
 import { TagsApi } from './tags/TagsApi'
 import { TicketTopicsApi } from './ticketTopics/TicketTopicsApi'
 import { TicketsApi } from './tickets/TicketsApi'
@@ -33,6 +46,31 @@ 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 { 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 ─────────────
@@ -67,6 +105,154 @@ expectError(tokens.create({ name: 'CI', accessTokenExpiresAt: '2030-01-01T00:00:
 expectError(tokens.create({ name: 'CI', expiresIn: '7d' }))
 expectError(tokens.updateById('t-1', { scope: '*' }))
 
+// ── interactive messages: cta_url and request_contact_info ──────────
+
+const interactiveMessages = new InteractiveMessagesApi(client)
+interactiveMessages.create({
+  name: 'Boleto',
+  interactive: {
+    type: 'cta_url',
+    header: { type: 'text', text: 'Seu boleto' },
+    body: { text: 'Clique para continuar' },
+    footer: { text: 'Digisac' },
+    action: {
+      name: 'cta_url',
+      parameters: { display_text: 'Continuar', url: 'https://wa.me/5541999999999' },
+    },
+    channelRedirect: {
+      enabled: true,
+      channel: 'whatsapp',
+      identifierType: 'phone',
+      identifier: '+5541999999999',
+    },
+  },
+})
+interactiveMessages.create({
+  name: 'Webchat',
+  interactive: {
+    type: 'cta_url',
+    header: { type: 'image' },
+    body: { text: 'Fale conosco' },
+    action: {
+      name: 'cta_url',
+      parameters: { display_text: 'Abrir', url: 'https://webchat.digisac.app/w-1' },
+    },
+    channelRedirect: { enabled: true, channel: 'webchat', serviceId: 's-1' },
+  },
+})
+interactiveMessages.updateById('im-1', {
+  interactive: {
+    type: 'cta_url',
+    body: { text: 'Site' },
+    action: { name: 'cta_url', parameters: { display_text: 'Abrir', url: 'https://exemplo.com' } },
+  },
+})
+interactiveMessages.create({
+  name: 'Dados',
+  interactive: {
+    type: 'request_contact_info',
+    body: { text: 'Compartilhe seu contato' },
+    action: { name: 'request_contact_info' },
+  },
+})
+// `channelRedirect` is a sibling of `action`, never inside `action.parameters`
+expectError(
+  interactiveMessages.create({
+    name: 'Boleto',
+    interactive: {
+      type: 'cta_url',
+      body: { text: 'Clique' },
+      action: {
+        name: 'cta_url',
+        parameters: {
+          display_text: 'Continuar',
+          url: 'https://wa.me/5541999999999',
+          channelRedirect: { enabled: true },
+        },
+      },
+    },
+  }),
+)
+expectError(
+  interactiveMessages.create({
+    name: 'Boleto',
+    interactive: {
+      type: 'cta_url',
+      body: { text: 'Clique' },
+      action: { name: 'cta_url', parameters: { url: 'https://exemplo.com' } },
+    },
+  }),
+)
+expectError(
+  interactiveMessages.create({
+    name: 'Boleto',
+    interactive: {
+      type: 'cta_url',
+      body: { text: 'Clique' },
+      action: { name: 'cta_url', parameters: { display_text: 'Abrir', url: 'https://x.com' } },
+      channelRedirect: { enabled: true, channel: 'email' },
+    },
+  }),
+)
+// WhatsApp refuses header and footer on request_contact_info
+expectError(
+  interactiveMessages.create({
+    name: 'Dados',
+    interactive: {
+      type: 'request_contact_info',
+      header: { type: 'text', text: 'Olá' },
+      body: { text: 'Compartilhe seu contato' },
+      action: { name: 'request_contact_info' },
+    },
+  }),
+)
+
+declare const interactiveMessage: InteractiveMessage
+expectType<'list' | 'button' | 'cta_url' | 'request_contact_info'>(interactiveMessage.type)
+if (interactiveMessage.interactive.type === 'cta_url') {
+  expectType<CtaUrlInteractiveMessageContent>(interactiveMessage.interactive)
+  expectType<string>(interactiveMessage.interactive.action.parameters.url)
+  expectType<ChannelRedirect | undefined>(interactiveMessage.interactive.channelRedirect)
+}
+if (interactiveMessage.interactive.type === 'request_contact_info') {
+  expectType<RequestContactInfoInteractiveMessageContent>(interactiveMessage.interactive)
+}
+expectAssignable<ChannelRedirect>({ enabled: false })
+expectAssignable<ChannelRedirect>({
+  enabled: true,
+  channel: 'telegram',
+  identifierType: 'botName',
+  identifier: '@lojabot',
+})
+expectNotAssignable<ChannelRedirect>({ enabled: true, channel: 'telegram', identifierType: 'user' })
+expectNotAssignable<ChannelRedirect>({ channel: 'whatsapp' })
+
+// ── services: data.webchat of a Webchat service ─────────────────────
+
+declare const service: Service
+expectType<WebchatServiceData | undefined>(service.data.webchat)
+expectType<string | undefined>(service.data.webchat?.id)
+expectType<string | null | undefined>(service.data.webchat?.instagram)
+expectAssignable<WebchatServiceData>({})
+expectAssignable<WebchatServiceData>({ id: 'w-1', phone: '5541999999999', telegram: null })
+expectNotAssignable<WebchatServiceData>({ id: 1 })
+// values the web forms already store: the new form sends `null`, the legacy one `{}`
+expectType<{ id?: string; name?: string } | null | undefined>(service.data.webchat?.customField)
+expectAssignable<WebchatServiceData>({ customField: null })
+expectAssignable<WebchatServiceData>({ customField: {} })
+expectAssignable<WebchatServiceData>({ customField: { id: 'cf-1', name: 'CPF' } })
+expectAssignable<WebchatServiceData>({ name: null, googleId: null, file: {} })
+expectAssignable<WebchatServiceData>({
+  file: { base64Url: 'aGVsbG8=', mimetype: 'image/png', fileName: 'perfil.png' },
+})
+expectAssignable<WebchatServiceData>({ custom: { webchatBalloonText: null } })
+expectNotAssignable<WebchatServiceData>({ customField: 'cf-1' })
+// the same shape types the `data` of the create and update payloads
+expectAssignable<CreateServicePayload['data']>({
+  webchat: { customField: null, googleId: null, name: null, custom: { webchatBalloonText: null } },
+})
+expectAssignable<UpdateServicePayload['data']>({ webchat: { customField: {}, file: {} } })
+
 // ── users: the dedicated archive route takes a boolean, not a date ──
 
 const users = new UsersApi(client)
@@ -336,3 +522,92 @@ 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'))
+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,
+})

package/src/apis/payloads.test.ts

@@ -1,5 +1,6 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 import type { ApiClient } from '../core/ApiClient'
+import { InteractiveMessagesApi } from './interactiveMessages/InteractiveMessagesApi'
 import { PersonalAccessTokensApi } from './personalAccessTokens/PersonalAccessTokensApi'
 import { RolesApi } from './roles/RolesApi'
 import { TimetableApi } from './timetable/TimetableApi'
@@ -78,4 +79,44 @@ describe('payloads sent to the backend', () => {
       )
     })
   })
+
+  describe('InteractiveMessagesApi', () => {
+    it('create sends a cta_url with channelRedirect next to action, not inside parameters', async () => {
+      const body = {
+        name: 'Boleto',
+        departments: [{ id: 'd-1' }],
+        interactive: {
+          type: 'cta_url' as const,
+          header: { type: 'text' as const, text: 'Seu boleto' },
+          body: { text: 'Clique para continuar' },
+          footer: { text: 'Digisac' },
+          action: {
+            name: 'cta_url' as const,
+            parameters: { display_text: 'Continuar', url: 'https://wa.me/5541999999999' },
+          },
+          channelRedirect: {
+            enabled: true,
+            channel: 'whatsapp' as const,
+            identifierType: 'phone' as const,
+            identifier: '+5541999999999',
+          },
+        },
+      }
+      await new InteractiveMessagesApi(client).create(body)
+      expect(client.post).toHaveBeenCalledWith('/interactive-messages', body, undefined)
+    })
+
+    it('create sends a request_contact_info with only body and action', async () => {
+      const body = {
+        name: 'Dados',
+        interactive: {
+          type: 'request_contact_info' as const,
+          body: { text: 'Compartilhe seu contato' },
+          action: { name: 'request_contact_info' as const },
+        },
+      }
+      await new InteractiveMessagesApi(client).create(body)
+      expect(client.post).toHaveBeenCalledWith('/interactive-messages', body, undefined)
+    })
+  })
 })

package/src/apis/people/PeopleApi.ts

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

package/src/apis/planAiHistory/PlanAiHistoryApi.ts

@@ -2,6 +2,10 @@ import type { ApiClient } from '../../core/ApiClient'
 import { BaseCrudApi } from '../../core/BaseCrudApi'
 import type { PlanAiHistory, CreatePlanAiHistoryPayload, UpdatePlanAiHistoryPayload } from './types'
 
+/**
+ * History of the AI products of the plan, only for reading: the records are written by super admin
+ * actions. The backend serves only `GET /plan-ai-history` and `GET /plan-ai-history/:id`.
+ */
 export class PlanAiHistoryApi extends BaseCrudApi<
   PlanAiHistory,
   CreatePlanAiHistoryPayload,
@@ -10,4 +14,26 @@ export class PlanAiHistoryApi extends BaseCrudApi<
   constructor(client: ApiClient) {
     super(client, '/plan-ai-history')
   }
+
+  /** @deprecated Not served: the backend has no POST /plan-ai-history, so this route answers 404. */
+  override create(
+    body: CreatePlanAiHistoryPayload,
+    headers?: Record<string, string>,
+  ): Promise<PlanAiHistory> {
+    return super.create(body, headers)
+  }
+
+  /** @deprecated Not served: the backend has no PUT /plan-ai-history/:id, so this route answers 404. */
+  override updateById(
+    id: string,
+    body: UpdatePlanAiHistoryPayload,
+    headers?: Record<string, string>,
+  ): Promise<PlanAiHistory> {
+    return super.updateById(id, body, headers)
+  }
+
+  /** @deprecated Not served: the backend has no DELETE /plan-ai-history/:id, so this route answers 404. */
+  override deleteById(id: string, headers?: Record<string, string>): Promise<PlanAiHistory> {
+    return super.deleteById(id, headers)
+  }
 }

package/src/apis/roles/RolesApi.ts

@@ -6,9 +6,18 @@ export class RolesApi extends BaseCrudApi<
   Role,
   CreateRolePayload,
   UpdateRolePayload,
-  RolesListQuery
+  RolesListQuery,
+  boolean
 > {
   constructor(client: ApiClient) {
     super(client, '/roles')
   }
+
+  /**
+   * Deletes a role. Resolves `true`.
+   * @permissions roles.destroy
+   */
+  override deleteById(id: string, headers?: Record<string, string>): Promise<boolean> {
+    return super.deleteById(id, headers)
+  }
 }

package/src/apis/services/ServicesApi.test.ts

@@ -46,4 +46,49 @@ describe('ServicesApi', () => {
       expect(client.get).toHaveBeenCalledWith('/services/limits', headers)
     })
   })
+
+  describe('archiveWithValidation', () => {
+    it('calls client.post with /services/:id/archive, the archive flag and the type', async () => {
+      vi.mocked(client.post).mockResolvedValue({})
+      const result = await api.archiveWithValidation('svc-1', { archive: true, type: 'sms-wavy' })
+      expect(client.post).toHaveBeenCalledWith(
+        '/services/svc-1/archive',
+        { archive: true, type: 'sms-wavy' },
+        undefined,
+      )
+      expect(result).toEqual({})
+    })
+
+    it('restores with { archive: false } and forwards custom headers', async () => {
+      const headers = { 'X-Custom': 'value' }
+      await api.archiveWithValidation('svc-1', { archive: false, type: 'whatsapp' }, headers)
+      expect(client.post).toHaveBeenCalledWith(
+        '/services/svc-1/archive',
+        { archive: false, type: 'whatsapp' },
+        headers,
+      )
+    })
+  })
+
+  describe.each(['takeover', 'logout', 'shutdown', 'start', 'restart'] as const)(
+    '%s',
+    (operation) => {
+      it(`calls client.post with /services/:id/${operation} and resolves 'OK'`, async () => {
+        vi.mocked(client.post).mockResolvedValue('OK')
+        const result = await api[operation]('svc-1')
+        expect(client.post).toHaveBeenCalledWith(
+          `/services/svc-1/${operation}`,
+          undefined,
+          undefined,
+        )
+        expect(result).toBe('OK')
+      })
+
+      it('forwards custom headers', async () => {
+        const headers = { 'X-Custom': 'value' }
+        await api[operation]('svc-1', headers)
+        expect(client.post).toHaveBeenCalledWith(`/services/svc-1/${operation}`, undefined, headers)
+      })
+    },
+  )
 })