@ikatec/digisac-api-sdk 4.9.0 → 4.10.0

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

@@ -46,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 ─────────────
@@ -497,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/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)
+      })
+    },
+  )
 })

package/src/apis/services/ServicesApi.ts

@@ -1,6 +1,12 @@
 import type { ApiClient } from '../../core/ApiClient'
 import { ArchivableCrudApi } from '../../core/ArchivableCrudApi'
-import type { Service, CreateServicePayload, ServiceLimits, UpdateServicePayload } from './types'
+import type {
+  Service,
+  CreateServicePayload,
+  ServiceLimits,
+  UpdateServicePayload,
+  ArchiveServicePayload,
+} from './types'
 
 export class ServicesApi extends ArchivableCrudApi<
   Service,
@@ -19,4 +25,88 @@ export class ServicesApi extends ArchivableCrudApi<
   getLimits(headers?: Record<string, string>): Promise<ServiceLimits> {
     return this.client.get<ServiceLimits>(`${this.basePath}/limits`, headers)
   }
+
+  /**
+   * @deprecated The backend does not archive a connection by `PUT { archivedAt }`: the PUT
+   * requires `type` (400 without it) and ignores `archivedAt`. Use {@link archiveWithValidation}.
+   */
+  override archive(id: string, headers?: Record<string, string>): Promise<Service> {
+    return super.archive(id, headers)
+  }
+
+  /**
+   * @deprecated The backend does not restore a connection by `PUT { archivedAt: null }`: the PUT
+   * requires `type` (400 without it) and ignores `archivedAt`. Use {@link archiveWithValidation}.
+   */
+  override unarchive(id: string, headers?: Record<string, string>): Promise<Service> {
+    return super.unarchive(id, headers)
+  }
+
+  /**
+   * Archives (`archive: true`) or restores (`archive: false`) a connection through the route used
+   * by the UI. Archiving shuts the connection down, closes its open tickets, marks its schedules
+   * as done and cancels its campaigns; restoring checks the plan limit of the `type` (400 when it
+   * is full).
+   *
+   * Resolves `{}` before the work is done (the route does not await it): poll `getById` until
+   * `archivedAt` changes. Send the `type` of the connection: without it the request is never
+   * answered.
+   * @permissions services.disabled
+   */
+  archiveWithValidation(
+    id: string,
+    body: ArchiveServicePayload,
+    headers?: Record<string, string>,
+  ): Promise<Record<string, never>> {
+    return this.client.post<Record<string, never>, ArchiveServicePayload>(
+      `${this.basePath}/${id}/archive`,
+      body,
+      headers,
+    )
+  }
+
+  /**
+   * Takes the session of the connection over to this server. Resolves the text `'OK'`; an
+   * unknown id answers 404 `Service not found.`.
+   * @permissions services.operate
+   */
+  takeover(id: string, headers?: Record<string, string>): Promise<'OK'> {
+    return this.client.post<'OK'>(`${this.basePath}/${id}/takeover`, undefined, headers)
+  }
+
+  /**
+   * Logs the connection out of the messaging service. Resolves the text `'OK'`; an unknown id
+   * answers 404 `Service not found.`.
+   * @permissions services.operate
+   */
+  logout(id: string, headers?: Record<string, string>): Promise<'OK'> {
+    return this.client.post<'OK'>(`${this.basePath}/${id}/logout`, undefined, headers)
+  }
+
+  /**
+   * Shuts the connection down. Resolves the text `'OK'`; an unknown id answers 404
+   * `Service not found.`.
+   * @permissions services.operate
+   */
+  shutdown(id: string, headers?: Record<string, string>): Promise<'OK'> {
+    return this.client.post<'OK'>(`${this.basePath}/${id}/shutdown`, undefined, headers)
+  }
+
+  /**
+   * Starts the connection. Resolves the text `'OK'`; an unknown id answers 404
+   * `Service not found.`.
+   * @permissions services.operate
+   */
+  start(id: string, headers?: Record<string, string>): Promise<'OK'> {
+    return this.client.post<'OK'>(`${this.basePath}/${id}/start`, undefined, headers)
+  }
+
+  /**
+   * Restarts the connection. Resolves the text `'OK'`; an unknown id answers 404
+   * `Service not found.`.
+   * @permissions services.operate
+   */
+  restart(id: string, headers?: Record<string, string>): Promise<'OK'> {
+    return this.client.post<'OK'>(`${this.basePath}/${id}/restart`, undefined, headers)
+  }
 }

package/src/apis/services/types.ts

@@ -253,6 +253,8 @@ export type ServiceRelationships = 'bot' | 'defaultDepartment'
 export type CreateServicePayload = {
   name: string
   type: ServiceType
+  /** Send `null`: without it the duplicate-name check never answers (SUS-3784). */
+  archivedAt?: null
   data?: ServiceData
   settings?: ServiceSettings
   defaultDepartmentId?: string
@@ -260,14 +262,28 @@ export type CreateServicePayload = {
 }
 
 export type UpdateServicePayload = {
+  /** Required by the backend (400 without it), although optional here for compatibility. */
+  type?: ServiceType
   name?: string
   data?: ServiceData
   settings?: ServiceSettings
   defaultDepartmentId?: string | null
   botId?: string | null
+  /**
+   * Ignored by the backend (archive through `ServicesApi.archiveWithValidation`). Send `null`
+   * with a `name`: without `archivedAt` the duplicate-name check never answers (SUS-3784).
+   */
   archivedAt?: string | null
 }
 
+/** Body of `ServicesApi.archiveWithValidation`. */
+export type ArchiveServicePayload = {
+  /** `true` archives, `false` restores. */
+  archive: boolean
+  /** The type of the connection, used by the plan limit check (the request hangs without it). */
+  type: ServiceType
+}
+
 export type ServiceLimit = {
   used: number
   total: number

package/src/apis/stickers/StickersApi.ts

@@ -1,9 +1,41 @@
 import type { ApiClient } from '../../core/ApiClient'
 import { BaseCrudApi } from '../../core/BaseCrudApi'
+import type { GetByIdQuery } from '../../core/types'
 import type { Sticker, CreateStickerPayload, UpdateStickerPayload } from './types'
 
+/**
+ * Stickers of the account. The backend serves `GET /stickers` and `POST /stickers` (plus
+ * `GET /stickers/exist`, `POST /stickers/add` and `DELETE /stickers/remove/:stickerId`); there is
+ * no read by id, update nor `DELETE /stickers/:id`.
+ */
 export class StickersApi extends BaseCrudApi<Sticker, CreateStickerPayload, UpdateStickerPayload> {
   constructor(client: ApiClient) {
     super(client, '/stickers')
   }
+
+  /** @deprecated Not served: the backend has no GET /stickers/:id, so this route answers 404. */
+  override getById(
+    id: string,
+    query?: GetByIdQuery<Sticker>,
+    headers?: Record<string, string>,
+  ): Promise<Sticker> {
+    return super.getById(id, query, headers)
+  }
+
+  /** @deprecated Not served: the backend has no PUT /stickers/:id, so this route answers 404. */
+  override updateById(
+    id: string,
+    body: UpdateStickerPayload,
+    headers?: Record<string, string>,
+  ): Promise<Sticker> {
+    return super.updateById(id, body, headers)
+  }
+
+  /**
+   * @deprecated Not served: the backend has no DELETE /stickers/:id (it removes a sticker by
+   * `DELETE /stickers/remove/:stickerId`), so this route answers 404.
+   */
+  override deleteById(id: string, headers?: Record<string, string>): Promise<Sticker> {
+    return super.deleteById(id, headers)
+  }
 }

package/src/apis/tags/TagsApi.ts

@@ -1,4 +1,5 @@
 import type { ApiClient } from '../../core/ApiClient'
+import type { ListQuery } from '../../core/types'
 import { BaseCrudApi } from '../../core/BaseCrudApi'
 import type { ContactsSelection } from '../contacts/types'
 import type {
@@ -9,11 +10,25 @@ import type {
   UpdateTagPayload,
 } from './types'
 
-export class TagsApi extends BaseCrudApi<Tag, CreateTagPayload, UpdateTagPayload> {
+export class TagsApi extends BaseCrudApi<
+  Tag,
+  CreateTagPayload,
+  UpdateTagPayload,
+  ListQuery<Tag>,
+  'OK'
+> {
   constructor(client: ApiClient) {
     super(client, '/tags')
   }
 
+  /**
+   * Deletes a tag. Resolves the text `'OK'`; an unknown id answers 500.
+   * @permissions tags.view OR tags.destroy
+   */
+  override deleteById(id: string, headers?: Record<string, string>): Promise<'OK'> {
+    return super.deleteById(id, headers)
+  }
+
   /**
    * Adds the tag to every contact of the account that matches the selection. Resolves to `'OK'`,
    * or `false` when every contact already had the tag.

package/src/apis/timetable/TimetableApi.ts

@@ -1,13 +1,24 @@
 import type { ApiClient } from '../../core/ApiClient'
+import type { ListQuery } from '../../core/types'
 import { BaseCrudApi } from '../../core/BaseCrudApi'
 import type { Timetable, CreateTimetablePayload, UpdateTimetablePayload } from './types'
 
 export class TimetableApi extends BaseCrudApi<
   Timetable,
   CreateTimetablePayload,
-  UpdateTimetablePayload
+  UpdateTimetablePayload,
+  ListQuery<Timetable>,
+  'OK'
 > {
   constructor(client: ApiClient) {
     super(client, '/timetable')
   }
+
+  /**
+   * Deletes a timetable. Resolves the text `'OK'`.
+   * @permissions timetables.view OR timetables.destroy
+   */
+  override deleteById(id: string, headers?: Record<string, string>): Promise<'OK'> {
+    return super.deleteById(id, headers)
+  }
 }

package/src/apis/users/UsersApi.ts

@@ -1,4 +1,5 @@
 import type { ApiClient } from '../../core/ApiClient'
+import type { ListQuery } from '../../core/types'
 import { ArchivableCrudApi } from '../../core/ArchivableCrudApi'
 import type { Contact } from '../contacts/types'
 import type {
@@ -19,11 +20,26 @@ import type {
   ValidateUserImportResult,
 } from './types'
 
-export class UsersApi extends ArchivableCrudApi<User, CreateUserPayload, UpdateUserPayload> {
+export class UsersApi extends ArchivableCrudApi<
+  User,
+  CreateUserPayload,
+  UpdateUserPayload,
+  ListQuery<User>,
+  'OK'
+> {
   constructor(client: ApiClient) {
     super(client, '/users')
   }
 
+  /**
+   * Deletes a user (removes it as the default user of the contacts and deletes its webhooks first).
+   * Resolves the text `'OK'`.
+   * @permissions users.destroy
+   */
+  override deleteById(id: string, headers?: Record<string, string>): Promise<'OK'> {
+    return super.deleteById(id, headers)
+  }
+
   /**
    * Archives or restores a user through the dedicated route used by the UI, which also
    * sets the user offline and ends its sessions. The route enforces the business rules that

package/src/apis/users/types.ts

@@ -71,7 +71,10 @@ export type CreateUserPayload = {
   isClientUser?: boolean
   roles?: string[]
   departments?: string[]
+  /** @deprecated Not read by the backend: restrict the connections with `restrictedServices`. */
   services?: string[]
+  /** Connections the user cannot access, as `{ value: serviceId }`. */
+  restrictedServices?: { value: string }[]
   scheduleId?: string
 }
 
@@ -83,7 +86,15 @@ export type UpdateUserPayload = {
   isClientUser?: boolean
   roles?: string[]
   departments?: string[]
+  /** @deprecated Not read by the backend: restrict the connections with `restrictedServices`. */
   services?: string[]
+  /**
+   * Connections the user cannot access, as `{ value: serviceId }`. Every update without it (and
+   * every update of an admin) clears the restrictions of the user.
+   */
+  restrictedServices?: { value: string }[]
+  /** New password of the user. */
+  password?: string
   timetableId?: string | null
   preferences?: UserPreferences
   language?: string

package/src/apis/webhooks/WebhooksApi.ts

@@ -1,9 +1,24 @@
 import type { ApiClient } from '../../core/ApiClient'
+import type { ListQuery } from '../../core/types'
 import { BaseCrudApi } from '../../core/BaseCrudApi'
 import type { Webhook, CreateWebhookPayload, UpdateWebhookPayload } from './types'
 
-export class WebhooksApi extends BaseCrudApi<Webhook, CreateWebhookPayload, UpdateWebhookPayload> {
+export class WebhooksApi extends BaseCrudApi<
+  Webhook,
+  CreateWebhookPayload,
+  UpdateWebhookPayload,
+  ListQuery<Webhook>,
+  'OK'
+> {
   constructor(client: ApiClient) {
     super(client, '/me/webhooks')
   }
+
+  /**
+   * Deletes a webhook. Resolves the text `'OK'`; an unknown id answers 500.
+   * @permissions settingsApi.update
+   */
+  override deleteById(id: string, headers?: Record<string, string>): Promise<'OK'> {
+    return super.deleteById(id, headers)
+  }
 }

package/src/core/ApiClient.ts

@@ -32,4 +32,28 @@ export interface ApiClient {
     endpoint: string,
     headers?: Record<string, string>,
   ): Promise<TResponse>
+  /**
+   * Like {@link request}, but resolves the raw `Response` of a successful (2xx) call instead of
+   * the parsed body, for the routes whose headers matter (`Content-Type`, `Content-Disposition`)
+   * or whose body is binary (xlsx, pdf, files). Non-2xx still throws the `ApiError` subclass.
+   * Optional: a custom client without it cannot call the API methods that need the raw response.
+   */
+  requestRaw?<TBody = unknown>(
+    method: HttpMethod,
+    endpoint: string,
+    body?: TBody,
+    headers?: Record<string, string>,
+  ): Promise<Response>
+  /**
+   * Sends a request to an absolute URL outside the API (e.g. the signed storage URL of
+   * `FilesApi.upload`): no base URL, no `Authorization` header and no JSON serialization, `body`
+   * goes as is. Resolves the raw `Response` of a 2xx answer; non-2xx throws the `ApiError`
+   * subclass. Optional: without it, the API methods that need it send through the global `fetch`.
+   */
+  requestExternal?(
+    method: HttpMethod,
+    url: string,
+    body?: BodyInit,
+    headers?: Record<string, string>,
+  ): Promise<Response>
 }

package/src/core/ArchivableCrudApi.ts

@@ -17,7 +17,8 @@ export class ArchivableCrudApi<
   TCreate,
   TUpdate extends { archivedAt?: string | null } = TCreate & { archivedAt?: string | null },
   TQuery extends ListQuery<TResponse> = ListQuery<TResponse>,
-> extends BaseCrudApi<TResponse, TCreate, TUpdate, TQuery> {
+  TDeleteResponse = TResponse,
+> extends BaseCrudApi<TResponse, TCreate, TUpdate, TQuery, TDeleteResponse> {
   constructor(client: ApiClient, basePath: string) {
     super(client, basePath)
   }