@ikatec/digisac-api-sdk 4.14.0 → 4.16.0

package/src/apis/departments/types.ts

@@ -32,3 +32,16 @@ export type ArchiveDepartmentPayload = {
   /** `true` archives, `false` restores. */
   archive: boolean
 }
+
+/** The `extra` of the 403 `Cannot archive department.` error of `archiveWithValidation`. */
+export type ArchiveDepartmentErrorExtra = {
+  reasons: (
+    | 'ONLY_ONE'
+    | 'USED_BOT'
+    | 'DEFAULT_DEPARTMENT'
+    | 'VISIBILITY_SETTINGS'
+    | 'OPEN_TICKETS'
+  )[]
+  /** Only with open tickets. */
+  openTicketsCount?: number
+}

package/src/apis/distribution/DistributionApi.ts

@@ -34,10 +34,9 @@ export class DistributionApi extends BaseCrudApi<
   }
 
   /**
-   * Updates a distribution. The backend reads the id from the body, so it is sent there too. It replaces
-   * the links: omitting `roles` or `departments` clears them. Resolves the stored distribution (with
-   * `deletedAt`, without the links) or, when `departments` is sent, the updated departments. An unknown id
-   * answers 500.
+   * Updates a distribution. It replaces the links: omitting `roles` or `departments` clears them.
+   * Resolves the stored distribution (with `deletedAt`, without the links) or, when `departments`
+   * is sent, the updated departments. An unknown id answers 500.
    * @permissions distribution.view OR distribution.update
    */
   override updateById(

package/src/apis/files/FilesApi.test.ts

@@ -97,6 +97,27 @@ describe('FilesApi', () => {
     })
   })
 
+  describe('duplicateFile', () => {
+    it('calls client.post with /files/duplicate-file and resolves the id of the copy', async () => {
+      vi.mocked(client.post).mockResolvedValue('file-2')
+      const result = await api.duplicateFile({ fileId: 'file-1' })
+      expect(client.post).toHaveBeenCalledWith(
+        '/files/duplicate-file',
+        { fileId: 'file-1' },
+        undefined,
+      )
+      expect(result).toBe('file-2')
+    })
+
+    it('sends urlToUpload and serviceId in the body and forwards custom headers', async () => {
+      vi.mocked(client.post).mockResolvedValue('file-1')
+      const headers = { 'X-Req': 'r-1' }
+      const body = { fileId: 'file-1', urlToUpload: URL_TO_UPLOAD, serviceId: 'svc-1' }
+      await api.duplicateFile(body, headers)
+      expect(client.post).toHaveBeenCalledWith('/files/duplicate-file', body, headers)
+    })
+  })
+
   describe('deleteById', () => {
     it('calls client.delete with /files/:id and resolves { success }', async () => {
       vi.mocked(client.delete).mockResolvedValue({ success: true })

package/src/apis/files/FilesApi.ts

@@ -9,6 +9,7 @@ import type {
   CreateToUploadPayload,
   CreateToUploadResult,
   DeleteFileResult,
+  DuplicateFilePayload,
 } from './types'
 
 /**
@@ -85,7 +86,8 @@ export class FilesApi extends BaseCrudApi<
    * Creates the record of a file and returns the signed URL to upload its content: send the
    * content with {@link upload}. An audio that must be converted (a voice message for the
    * connection) is sent in `base64` instead, and then no `urlToUpload` is returned. `name` and
-   * `mimetype` are required (500 without them; an audio without `name` is named `recording`).
+   * `mimetype` are required (500 without them; an audio without `name` is named `recording`). With
+   * `serviceId`, an extension the account blocks for the type of the connection answers 403.
    */
   createToUpload(
     body: CreateToUploadPayload,
@@ -98,6 +100,22 @@ export class FilesApi extends BaseCrudApi<
     )
   }
 
+  /**
+   * Copies the content of a file. With `urlToUpload` (the signed URL of a record created by
+   * {@link createToUpload} with the same `mimetype` as the file copied), the content is sent to that
+   * record and the answer is the `fileId` given; without it, a new record (`attachedType`
+   * `'message.file'`) is created with the copied content and its id is the answer, and with
+   * `serviceId` an extension the account blocks for the type of the connection answers 403. An
+   * unknown `fileId` answers 500.
+   */
+  duplicateFile(body: DuplicateFilePayload, headers?: Record<string, string>): Promise<string> {
+    return this.client.post<string, DuplicateFilePayload>(
+      `${this.basePath}/duplicate-file`,
+      body,
+      headers,
+    )
+  }
+
   /**
    * Uploads the content of a file to the `urlToUpload` returned by {@link createToUpload}. The URL
    * is signed by the storage, so the request goes straight to it, without the API token (the

package/src/apis/files/types.ts

@@ -74,7 +74,10 @@ export type CreateToUploadPayload = {
   mimetype: string
   /** What the file is attached to, e.g. `'message.file'` (default), `'campaign.file'`, `'quickreply.file'`. */
   attachedType?: string
-  /** Connection that will send the file (used to decide the audio conversion). */
+  /**
+   * Connection that will send the file: used to decide the audio conversion and to apply the
+   * extensions the account blocks for its type (403).
+   */
   serviceId?: string
   /** Audio sent as a voice message (default `true`). */
   isPtt?: boolean
@@ -93,6 +96,22 @@ export type CreateToUploadResult = {
   mimetype: string
 }
 
+/** Body of `FilesApi.duplicateFile`. */
+export type DuplicateFilePayload = {
+  /** The file whose content is copied. */
+  fileId: string
+  /**
+   * Signed URL of a record created by `FilesApi.createToUpload`, with the same `mimetype` as the file
+   * copied, to receive the content. Without it, a new record is created with the copied content.
+   */
+  urlToUpload?: string
+  /**
+   * Connection that will send the new record (used only without `urlToUpload`): the extensions the
+   * account blocks for its type apply.
+   */
+  serviceId?: string
+}
+
 /** Result of `FilesApi.deleteById`. */
 export type DeleteFileResult = {
   success: boolean

package/src/apis/kanbanCards/KanbanCardsApi.test.ts

@@ -43,4 +43,25 @@ describe('KanbanCardsApi', () => {
       await expect(api.reorder('kc1', {})).rejects.toThrow('Invalid reorder operation.')
     })
   })
+
+  describe('getById / create / updateById', () => {
+    it('keep the generic routes of /kanban-cards', async () => {
+      vi.mocked(client.get).mockResolvedValue({ id: 'kc1' })
+      vi.mocked(client.post).mockResolvedValue({ id: 'kc1' })
+      vi.mocked(client.put).mockResolvedValue({ id: 'kc1' })
+      await api.getById('kc1', { attributes: ['id'] }, headers)
+      await api.create({ columnId: 'col1', ticketId: 't1' }, headers)
+      await api.updateById('kc1', { columnId: 'col2' }, headers)
+      expect(client.get).toHaveBeenCalledWith(
+        `/kanban-cards/kc1?query=${encodeURIComponent(JSON.stringify({ attributes: ['id'] }))}`,
+        headers,
+      )
+      expect(client.post).toHaveBeenCalledWith(
+        '/kanban-cards',
+        { columnId: 'col1', ticketId: 't1' },
+        headers,
+      )
+      expect(client.put).toHaveBeenCalledWith('/kanban-cards/kc1', { columnId: 'col2' }, headers)
+    })
+  })
 })

package/src/apis/kanbanCards/KanbanCardsApi.ts

@@ -1,5 +1,5 @@
 import type { ApiClient } from '../../core/ApiClient'
-import type { ListQuery } from '../../core/types'
+import type { GetByIdQuery, ListQuery } from '../../core/types'
 import { BaseCrudApi } from '../../core/BaseCrudApi'
 import type {
   KanbanCard,
@@ -8,6 +8,13 @@ import type {
   UpdateKanbanCardPayload,
 } from './types'
 
+/**
+ * Cards of the kanban boards: one per ticket in each board. The reads need `kanban.boards.view`
+ * and the writes `kanban.cards.move`. `getMany` takes the column in `where.columnId`. The errors of
+ * the writes (unknown column or ticket, ticket of a department not linked to the board, a second
+ * card of the ticket in the board, an update by a user outside the department of the ticket)
+ * answer 500.
+ */
 export class KanbanCardsApi extends BaseCrudApi<
   KanbanCard,
   CreateKanbanCardPayload,
@@ -19,6 +26,45 @@ export class KanbanCardsApi extends BaseCrudApi<
     super(client, '/kanban-cards')
   }
 
+  /**
+   * Returns a card by ID. An unknown id answers 404 `Kanban card not found.`.
+   * @permissions kanban.boards.view
+   */
+  override getById(
+    id: string,
+    query?: GetByIdQuery<KanbanCard>,
+    headers?: Record<string, string>,
+  ): Promise<KanbanCard> {
+    return super.getById(id, query, headers)
+  }
+
+  /**
+   * Creates the card of a ticket in a column. The ticket must be of a department linked to the
+   * board and have no card in it yet.
+   * @permissions kanban.cards.move
+   */
+  override create(
+    body: CreateKanbanCardPayload,
+    headers?: Record<string, string>,
+  ): Promise<KanbanCard> {
+    return super.create(body, headers)
+  }
+
+  /**
+   * Updates a card. To move it, use {@link reorder}: `updateById` does not recalculate the
+   * `position` and does not close or reopen the ticket. The user must belong to the
+   * department of the card's ticket (of the new `ticketId` when sent), or have
+   * `tickets.transfer.all`, or be admin; otherwise 500.
+   * @permissions kanban.cards.move
+   */
+  override updateById(
+    id: string,
+    body: UpdateKanbanCardPayload,
+    headers?: Record<string, string>,
+  ): Promise<KanbanCard> {
+    return super.updateById(id, body, headers)
+  }
+
   /**
    * Deletes a card. Resolves the text `'OK'`.
    * @permissions kanban.cards.move

package/src/apis/kanbanCards/types.ts

@@ -27,7 +27,7 @@ export type CreateKanbanCardPayload = {
 export type UpdateKanbanCardPayload = {
   columnId?: string
   position?: string
-  /** The caller must share a department with the ticket (or transfer to all / be admin). */
+  /** Moves the card to another ticket (see `KanbanCardsApi.updateById` for who can update it). */
   ticketId?: string
 }
 

package/src/apis/kanbanColumns/KanbanColumnsApi.test.ts

@@ -43,4 +43,30 @@ describe('KanbanColumnsApi', () => {
       await expect(api.reorder('col1', {})).rejects.toThrow('Invalid reorder operation.')
     })
   })
+
+  describe('deleteById', () => {
+    it('calls client.delete with /kanban-columns/:id and resolves the deleted column', async () => {
+      vi.mocked(client.delete).mockResolvedValue({ id: 'col1' })
+      expect(await api.deleteById('col1', headers)).toEqual({ id: 'col1' })
+      expect(client.delete).toHaveBeenCalledWith('/kanban-columns/col1', headers)
+    })
+  })
+
+  describe('deleteMovingCards', () => {
+    it('sends DELETE /kanban-columns/:id with the destination column in the body', async () => {
+      vi.mocked(client.request).mockResolvedValue({ id: 'col1' })
+      const body = { cardsDestinationColumnId: 'col2' }
+      expect(await api.deleteMovingCards('col1', body, headers)).toEqual({ id: 'col1' })
+      expect(client.request).toHaveBeenCalledWith('DELETE', '/kanban-columns/col1', body, headers)
+    })
+
+    it('propagates errors', async () => {
+      vi.mocked(client.request).mockRejectedValue(
+        new Error('Initial and final columns cannot be deleted.'),
+      )
+      await expect(
+        api.deleteMovingCards('col1', { cardsDestinationColumnId: 'col2' }),
+      ).rejects.toThrow('Initial and final columns cannot be deleted.')
+    })
+  })
 })

package/src/apis/kanbanColumns/KanbanColumnsApi.ts

@@ -3,6 +3,7 @@ import { BaseCrudApi } from '../../core/BaseCrudApi'
 import type {
   KanbanColumn,
   CreateKanbanColumnPayload,
+  DeleteKanbanColumnPayload,
   ReorderKanbanColumnPayload,
   UpdateKanbanColumnPayload,
 } from './types'
@@ -16,6 +17,36 @@ export class KanbanColumnsApi extends BaseCrudApi<
     super(client, '/kanban-columns')
   }
 
+  /**
+   * Deletes a column and its cards (their tickets are kept as they are). The `'initial'` and
+   * `'final'` columns cannot be deleted (500). Resolves to the deleted column. To keep the cards,
+   * use {@link deleteMovingCards}.
+   * @permissions kanban.columns.destroy
+   */
+  override deleteById(id: string, headers?: Record<string, string>): Promise<KanbanColumn> {
+    return super.deleteById(id, headers)
+  }
+
+  /**
+   * Deletes a column after moving its cards to the top of another column of the board, in their
+   * order. The cards move as `KanbanCardsApi.reorder` moves them: to the `'final'` column,
+   * their open tickets are closed. The `'initial'` and `'final'` columns cannot be deleted (500).
+   * Resolves to the deleted column.
+   * @permissions kanban.columns.destroy
+   */
+  deleteMovingCards(
+    id: string,
+    body: DeleteKanbanColumnPayload,
+    headers?: Record<string, string>,
+  ): Promise<KanbanColumn> {
+    return this.client.request<KanbanColumn, DeleteKanbanColumnPayload>(
+      'DELETE',
+      `${this.basePath}/${id}`,
+      body,
+      headers,
+    )
+  }
+
   /**
    * Moves a column between two neighbours of the same board. Both the column and a neighbour
    * must be draggable; swapped neighbours (`before` after `after`) fail with 500. Resolves to the

package/src/apis/kanbanColumns/types.ts

@@ -50,3 +50,8 @@ export type ReorderKanbanColumnPayload = {
   /** The column that ends up on the right. */
   afterColumnId?: string
 }
+
+export type DeleteKanbanColumnPayload = {
+  /** The column of the same board that receives the cards of the deleted one. */
+  cardsDestinationColumnId: string
+}

package/src/apis/messages/MessagesApi.ts

@@ -24,10 +24,19 @@ export class MessagesApi extends BaseCrudApi<Message, CreateMessagePayload, Upda
   }
 
   /**
-   * 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
+   * Edits the text of a message sent by the account, up to 15 minutes after it was sent. Sent as
+   * `PATCH /messages/:id`. `contactId` is required: without it the route answers 500, and an
+   * unknown or blocked contact answers 400 `The given data was invalid.` (the error comes in
+   * `contactId`). So is `text`: `text: ''` alone answers 400 (`At least one field (text or file)
+   * must be provided`), and a `text` with only spaces answers 400 `Text cannot be empty`. Only the
+   * text is edited: `file` is not sent to the connection. A message received, or sent more than
+   * 15 minutes ago, answers 403 `Cannot edit message`; an unknown message answers 404
+   * `Message not found`. The message passes to the user who edited it.
+   *
+   * The message is answered once the edit is sent to the connection, before the connection
+   * confirms it: read it again until `text` changes (`data.edited` is set to `true` when the
+   * connection reports the edit). On WhatsApp Business and Telegram connections the route answers
+   * the result of the edit job, not the message: read it again with `getById`.
    */
   override updateById(
     id: string,

package/src/apis/messages/types.ts

@@ -62,6 +62,11 @@ export type MessageData = {
   subject?: unknown
   resourceId?: string
   hasReaction?: boolean
+  /**
+   * `true` once the connection reports that the text was edited (see `MessagesApi.updateById`; on
+   * WhatsApp, an edit made by the contact included).
+   */
+  edited?: boolean
   whatsappMessageId?: string
   startBlockedAt?: string
   endBlockedAt?: string

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

@@ -13,6 +13,7 @@ import type {
   CampaignContactsPage,
   CampaignMessage,
   CampaignStats,
+  CampaignTemplateParameter,
   CampaignTimelineEvent,
 } from './campaigns/types'
 import { CardsApi } from './cards/CardsApi'
@@ -36,7 +37,7 @@ import { QuestionsApi } from './questions/QuestionsApi'
 import { QuickRepliesApi } from './quickReplies/QuickRepliesApi'
 import { RolesApi } from './roles/RolesApi'
 import { ScheduleApi } from './schedule/ScheduleApi'
-import type { ScheduleRecord } from './schedule/types'
+import type { Schedule, ScheduleRecord } from './schedule/types'
 import type {
   CreateServicePayload,
   Service,
@@ -48,16 +49,26 @@ import { TicketTopicsApi } from './ticketTopics/TicketTopicsApi'
 import { TicketsApi } from './tickets/TicketsApi'
 import type { Ticket, TicketTransfer, TicketsCount, TicketsCounts } from './tickets/types'
 import { TimetableApi } from './timetable/TimetableApi'
+import type { OutOfOfficeHoursErrorExtra, TimetableWorkSlot } from './timetable/types'
 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 type {
+  Contact,
+  CustomFieldValue,
+  FormattedCustomField,
+  SummarizeTicketResult,
+  TransferTicketKanbanCardResult,
+  TransferTicketPayload,
+} from './contacts/types'
+import { AuthHistoryApi } from './authHistory/AuthHistoryApi'
+import type { AuthHistoryEvent } from './authHistory/types'
 import { CustomFieldsApi } from './customFields/CustomFieldsApi'
 import { DepartmentsApi } from './departments/DepartmentsApi'
-import type { Department } from './departments/types'
+import type { ArchiveDepartmentErrorExtra, Department } from './departments/types'
 import type { Distribution } from './distribution/types'
 import type { ContactBlockList } from './contactBlockLists/types'
 import { DistributionApi } from './distribution/DistributionApi'
@@ -86,8 +97,11 @@ import type { Sticker } from './stickers/types'
 import { OrganizationsApi } from './organizations/OrganizationsApi'
 import { PeopleApi } from './people/PeopleApi'
 import { ServicesApi } from './services/ServicesApi'
-import type { UpdateUserPayload, User } from './users/types'
+import type { BulkUpdateUsersLinksResult, UpdateUserPayload, User } from './users/types'
 import { WebhooksApi } from './webhooks/WebhooksApi'
+import type { KanbanColumn } from './kanbanColumns/types'
+import type { Message } from './messages/types'
+import type { Webhook, WebhookMessageFilters, WebhookType } from './webhooks/types'
 
 declare const client: ApiClient
 
@@ -306,7 +320,7 @@ expectError(pipelines.deleteStatus('st-1', { action: 'move-to-another' }))
 expectError(pipelines.createAutomation({ pipelineId: 'p-1', type: 'email' }))
 expectError(pipelines.deleteStage('s-1', { typeAction: 'archive' }))
 
-// ── cards: getCards is not scoped by the backend and only answers the attributes asked ─
+// ── cards: getCards takes where.accountId and only answers the attributes asked ─
 
 const cards = new CardsApi(client)
 cards.getCards({
@@ -769,3 +783,229 @@ expectAssignable<Awaited<ReturnType<ServicesApi['accessManagement']>>>({
 })
 expectNotAssignable<Awaited<ReturnType<ServicesApi['accessManagement']>>>({ message: 'denied' })
 expectError(new ServicesApi(client).accessManagement('s-1', { userIds: ['u-1'] }))
+
+// ── QARC-1015 (4.15.0): custom fields of the contact, file copy, logout event ─────
+
+expectAssignable<Parameters<ContactsApi['create']>[0]>({
+  serviceId: 's-1',
+  customFields: [
+    { id: 'f-1', value: 'text' },
+    { id: 'f-2', value: { value: '10,50', identifier: 'BRL', min: '', max: '' } },
+  ],
+})
+expectAssignable<Parameters<ContactsApi['updateById']>[1]>({
+  customFields: [{ id: 'f-1', value: 'new' }],
+})
+expectError(
+  new ContactsApi(client).create({ serviceId: 's-1', customFields: [{ value: 'no id' }] }),
+)
+expectAssignable<Parameters<ContactsApi['getById']>[1]>({
+  include: [{ model: 'customFieldValues', include: ['customField'] }],
+  formatCustomFields: true,
+})
+declare const contactWithFields: Contact
+expectType<CustomFieldValue[] | undefined>(contactWithFields.customFieldValues)
+expectType<Record<string, FormattedCustomField> | undefined>(contactWithFields.customFields)
+expectAssignable<Parameters<ContactsApi['getMany']>[0]>({
+  include: [{ model: 'customFieldValues', include: ['customField'] }],
+  formatCustomFields: true,
+})
+expectType<Promise<string>>(new FilesApi(client).duplicateFile({ fileId: 'file-1' }))
+expectError(new FilesApi(client).duplicateFile({ urlToUpload: 'https://storage' }))
+expectType<Promise<void>>(new AuthHistoryApi(client).registerLogout())
+expectAssignable<AuthHistoryEvent>('2fa_disabled')
+
+// ── QARC-948 (4.16.0): the open subtasks ─────────────────────────────
+
+// campaigns: one page of one campaign, and the fields the create reads
+expectType<Promise<Campaign | null>>(new CampaignsApi(client).getOne({ status: 'ready' }))
+expectAssignable<Parameters<CampaignsApi['create']>[0]>({
+  title: 'Campanha',
+  serviceId: 's-1',
+  text: 'Olá',
+  messages: [{ text: 'Olá', base64Url: 'data:image/png;base64,AAAA' }],
+  fileId: 'f-1',
+  nameField: 'Nome',
+  numberField: 'Número',
+  usernameField: 'Usuário',
+  hsmFileId: 'f-2',
+})
+
+// campaigns: the update reads its own fields and updates the messages by id
+expectAssignable<Parameters<CampaignsApi['updateById']>[1]>({
+  title: 'Campanha',
+  messages: [{ id: 'm-1', text: 'Olá' }, { text: 'Nova' }],
+})
+expectAssignable<Parameters<CampaignsApi['updateById']>[1]>({
+  config: { minInterval: '1', maxInterval: '5' },
+  messages: [
+    { id: 'm-1', text: 'Olá', file: { id: 'f-1' } },
+    {
+      id: 'm-2',
+      base64Url: 'data:image/png;base64,AAAA',
+      fileName: 'b.png',
+    },
+  ],
+})
+expectError(new CampaignsApi(client).updateById('cmp-1', { text: 'Olá' }))
+expectError(new CampaignsApi(client).updateById('cmp-1', { usernameField: 'Usuário' }))
+expectError(new CampaignsApi(client).updateById('cmp-1', { hsmFileId: 'f-2' }))
+expectAssignable<CampaignTemplateParameter>({
+  type: 'header',
+  parameters: [{ type: 'image', image: { link: 'https://example.invalid/a.png' } }],
+})
+
+// messages: the edit flag of the connection
+declare const editedMessage: Message
+expectType<boolean | undefined>(editedMessage.data.edited)
+
+// schedule: the template parameters
+expectAssignable<Parameters<ScheduleApi['create']>[0]>({
+  scheduledAt: '2026-10-20T12:00:00.000Z',
+  contactId: 'c-1',
+  departmentId: 'd-1',
+  notes: '',
+  hsmId: 'h-1',
+  extraOptions: { parameters: [{ type: 'body', parameters: [{ type: 'text', text: 'Ana' }] }] },
+})
+expectError(
+  new ScheduleApi(client).create({
+    scheduledAt: '2026-10-20T12:00:00.000Z',
+    contactId: 'c-1',
+    departmentId: 'd-1',
+    notes: '',
+    extraOptions: { parameters: 'Ana' },
+  }),
+)
+
+declare const storedSchedule: Schedule
+expectType<CampaignTemplateParameter[] | undefined>(storedSchedule.extraOptions?.parameters)
+
+// kanban: deleting a column moving its cards
+expectType<Promise<KanbanColumn>>(
+  new KanbanColumnsApi(client).deleteMovingCards('col-1', { cardsDestinationColumnId: 'col-2' }),
+)
+expectError(new KanbanColumnsApi(client).deleteMovingCards('col-1', {}))
+expectType<Promise<KanbanColumn>>(new KanbanColumnsApi(client).deleteById('col-1'))
+
+// contacts: the result of the transfer and the close of the ticket
+const ticketContacts = new ContactsApi(client)
+expectType<Promise<TransferTicketKanbanCardResult>>(
+  ticketContacts.transferTicket('c-1', { departmentId: 'd-1', includeKanbanCardId: true }),
+)
+expectType<Promise<true>>(ticketContacts.transferTicket('c-1', { departmentId: 'd-1' }))
+declare const transferPayload: TransferTicketPayload
+expectType<Promise<true | TransferTicketKanbanCardResult>>(
+  ticketContacts.transferTicket('c-1', transferPayload),
+)
+declare const transferResult: TransferTicketKanbanCardResult
+expectType<string | null>(transferResult.kanbanCardId)
+expectType<Promise<true>>(ticketContacts.closeTicket('c-1'))
+expectType<Promise<true>>(
+  ticketContacts.closeTicket('c-1', { ticketTopicIds: ['tt-1'], aiSummaryRating: '5' }),
+)
+expectError(ticketContacts.closeTicket('c-1', { aiSummaryRating: '6' }))
+
+// webhooks: the type, the connections and the message filters
+declare const webhook: Webhook
+expectType<WebhookType>(webhook.type)
+expectType<WebhookMessageFilters | null | undefined>(webhook.messageFilters)
+expectType<number | null | undefined>(webhook.avgLatencyMs)
+expectAssignable<Parameters<WebhooksApi['create']>[0]>({
+  name: 'Webhook',
+  url: 'https://example.invalid/hook',
+  type: 'by_service',
+  events: ['message.created'],
+  services: ['s-1'],
+  messageFilters: { bot: false, system: false },
+})
+expectAssignable<Parameters<WebhooksApi['create']>[0]>({
+  name: 'Webhook',
+  url: 'https://example.invalid/hook',
+  type: 'general',
+  events: ['message.created'],
+  messageFilters: null,
+})
+expectError(
+  new WebhooksApi(client).create({
+    name: 'Webhook',
+    url: 'https://example.invalid/hook',
+    type: 'other',
+    events: [],
+  }),
+)
+expectError(
+  new WebhooksApi(client).create({
+    name: 'Webhook',
+    url: 'https://example.invalid/hook',
+    type: 'general',
+    events: [],
+    messageFilters: { comments: false },
+  }),
+)
+expectError(new WebhooksApi(client).updateById('w-1', { active: false }))
+const hookUrl = 'https://example.invalid/hook'
+const hooks = new WebhooksApi(client)
+expectError(hooks.updateById('w-1', { url: hookUrl, type: 'general', events: [] }))
+expectError(hooks.updateById('w-1', { name: 'Webhook', type: 'general', events: [] }))
+expectError(hooks.updateById('w-1', { name: 'Webhook', url: hookUrl, events: [] }))
+expectError(hooks.updateById('w-1', { name: 'Webhook', url: hookUrl, type: 'general' }))
+expectError(hooks.updateById('w-1', { name: 'Webhook', url: hookUrl, type: 'other', events: [] }))
+expectAssignable<WebhookType>('whatsapp_low_level')
+expectAssignable<WebhookMessageFilters>({ received: true, sent: false, bot: true, system: false })
+expectAssignable<Parameters<WebhooksApi['updateById']>[1]>({
+  name: 'Webhook',
+  url: 'https://example.invalid/hook',
+  type: 'by_service',
+  events: ['message.created'],
+  services: ['s-1'],
+  messageFilters: { received: false },
+})
+expectAssignable<Parameters<WebhooksApi['updateById']>[1]>({
+  name: 'Webhook',
+  url: 'https://example.invalid/hook',
+  type: 'general',
+  events: ['message.created'],
+  messageFilters: null,
+})
+
+// users, bots and answers
+expectType<Promise<BulkUpdateUsersLinksResult>>(
+  new UsersApi(client).bulkUpdateLinks({ ids: ['u-1'], timetableId: null }),
+)
+expectError(new UsersApi(client).bulkUpdateLinks({ timetableId: 't-1' }))
+expectType<Promise<ArrayBuffer>>(new BotsApi(client).exportErrors('b-1'))
+expectType<Promise<Response>>(new AnswersApi(client).exportTxtRaw())
+expectType<Promise<Response>>(new AnswersApi(client).exportCsvRaw())
+
+// QARC-948, second review: the remaining fields of the new types
+expectAssignable<CampaignTemplateParameter>({
+  type: 'header',
+  parameters: [
+    { type: 'video', video: { link: 'https://example.invalid/a.mp4' } },
+    { type: 'document', document: { link: 'https://example.invalid/a.pdf' } },
+  ],
+})
+expectAssignable<Parameters<ContactsApi['closeTicket']>[1]>({ comments: 'Resolvido' })
+expectAssignable<TransferTicketPayload>({ departmentId: 'd-1', includeKanbanCardId: true })
+expectError(
+  new ScheduleApi(client).updateById('sch-1', {
+    scheduledAt: '2026-10-20T12:00:00.000Z',
+    contactId: 'c-1',
+    departmentId: 'd-1',
+    extraOptions: { parameters: 'Ana' },
+  }),
+)
+expectAssignable<Parameters<UsersApi['bulkUpdateLinks']>[0]>({
+  ids: ['u-1'],
+  departmentIds: ['d-1'],
+  roleIds: ['r-1'],
+})
+declare const linksResult: BulkUpdateUsersLinksResult
+expectType<number>(linksResult.failed)
+expectType<string[]>(linksResult.missingIds)
+declare const outOfOffice: OutOfOfficeHoursErrorExtra
+expectType<TimetableWorkSlot[]>(outOfOffice.workPlan)
+declare const archiveRefusal: ArchiveDepartmentErrorExtra
+expectAssignable<ArchiveDepartmentErrorExtra['reasons'][number]>('ONLY_ONE')
+expectType<number | undefined>(archiveRefusal.openTicketsCount)