@ikatec/digisac-api-sdk 4.9.0 → 4.10.0

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

@@ -0,0 +1,122 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { FilesApi } from './FilesApi'
+import type { ApiClient } from '../../core/ApiClient'
+import { ApiConnectionError, ApiError } from '../../core/errors'
+import type { CreateToUploadResult } from './types'
+
+// ── Mock client factory ──────────────────────────────────────────────
+
+function createMockClient(): ApiClient {
+  return {
+    setAccessToken: vi.fn().mockReturnThis(),
+    request: vi.fn(),
+    get: vi.fn(),
+    post: vi.fn(),
+    put: vi.fn(),
+    patch: vi.fn(),
+    delete: vi.fn(),
+  }
+}
+
+const URL_TO_UPLOAD = 'https://storage.example.com/acc-1/file-1.plain?X-Amz-Signature=abc'
+
+// ── Tests ────────────────────────────────────────────────────────────
+
+describe('FilesApi', () => {
+  let client: ReturnType<typeof createMockClient>
+  let api: FilesApi
+
+  beforeEach(() => {
+    client = createMockClient()
+    api = new FilesApi(client)
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  describe('createToUpload', () => {
+    it('calls client.post with /files/create-to-upload and body', async () => {
+      const created: CreateToUploadResult = {
+        urlToUpload: URL_TO_UPLOAD,
+        id: 'file-1',
+        name: 'report.txt',
+        mimetype: 'text/plain',
+      }
+      vi.mocked(client.post).mockResolvedValue(created)
+      const body = { name: 'report.txt', mimetype: 'text/plain', attachedType: 'campaign.file' }
+      const result = await api.createToUpload(body)
+      expect(client.post).toHaveBeenCalledWith('/files/create-to-upload', body, undefined)
+      expect(result).toEqual(created)
+    })
+  })
+
+  describe('upload', () => {
+    it('sends through client.requestExternal when the client has it', async () => {
+      const requestExternal = vi.fn().mockResolvedValue(new Response(null, { status: 200 }))
+      const fetchSpy = vi.spyOn(globalThis, 'fetch')
+      api = new FilesApi({ ...client, requestExternal })
+      await api.upload(URL_TO_UPLOAD, 'content', 'text/plain')
+      expect(requestExternal).toHaveBeenCalledWith('PUT', URL_TO_UPLOAD, 'content', {
+        'Content-Type': 'text/plain',
+      })
+      expect(fetchSpy).not.toHaveBeenCalled()
+    })
+
+    it('without client.requestExternal, PUTs the content to the signed URL with the global fetch', async () => {
+      const spy = vi
+        .spyOn(globalThis, 'fetch')
+        .mockResolvedValue(new Response(null, { status: 200 }))
+      await api.upload(URL_TO_UPLOAD, 'content', 'text/plain')
+      expect(spy).toHaveBeenCalledWith(URL_TO_UPLOAD, {
+        method: 'PUT',
+        headers: { 'Content-Type': 'text/plain' },
+        body: 'content',
+      })
+      expect(client.request).not.toHaveBeenCalled()
+    })
+
+    it('throws ApiError when the storage refuses the upload', async () => {
+      vi.spyOn(globalThis, 'fetch').mockResolvedValue(
+        new Response('<Error><Code>SignatureDoesNotMatch</Code></Error>', {
+          status: 403,
+          statusText: 'Forbidden',
+        }),
+      )
+      const captured = await api.upload(URL_TO_UPLOAD, 'content', 'text/plain').catch((e) => e)
+      expect(captured).toBeInstanceOf(ApiError)
+      expect((captured as ApiError).status).toBe(403)
+      expect((captured as ApiError).body).toBe('<Error><Code>SignatureDoesNotMatch</Code></Error>')
+    })
+
+    it('throws ApiConnectionError when the request fails', async () => {
+      vi.spyOn(globalThis, 'fetch').mockRejectedValue(new TypeError('fetch failed'))
+      await expect(api.upload(URL_TO_UPLOAD, 'content', 'text/plain')).rejects.toBeInstanceOf(
+        ApiConnectionError,
+      )
+    })
+  })
+
+  describe('deleteById', () => {
+    it('calls client.delete with /files/:id and resolves { success }', async () => {
+      vi.mocked(client.delete).mockResolvedValue({ success: true })
+      const result = await api.deleteById('file-1')
+      expect(client.delete).toHaveBeenCalledWith('/files/file-1', undefined)
+      expect(result).toEqual({ success: true })
+    })
+  })
+
+  describe('deprecated reads and update (no backend route)', () => {
+    it('still call the same paths', async () => {
+      await api.getById('file-1')
+      await api.getMany({ where: { id: 'file-1' } })
+      await api.updateById('file-1', { name: 'x' })
+      expect(client.get).toHaveBeenCalledWith('/files/file-1', undefined)
+      expect(client.get).toHaveBeenCalledWith(
+        `/files?query=${encodeURIComponent(JSON.stringify({ where: { id: 'file-1' } }))}`,
+        undefined,
+      )
+      expect(client.put).toHaveBeenCalledWith('/files/file-1', { name: 'x' }, undefined)
+    })
+  })
+})

package/src/apis/files/FilesApi.ts

@@ -1,9 +1,114 @@
 import type { ApiClient } from '../../core/ApiClient'
 import { BaseCrudApi } from '../../core/BaseCrudApi'
-import type { File, CreateFilePayload, UpdateFilePayload } from './types'
+import { requestExternal } from '../../core/requestExternal'
+import type { GetByIdQuery, ListQuery, Paginated } from '../../core/types'
+import type {
+  File,
+  CreateFilePayload,
+  UpdateFilePayload,
+  CreateToUploadPayload,
+  CreateToUploadResult,
+  DeleteFileResult,
+} from './types'
 
-export class FilesApi extends BaseCrudApi<File, CreateFilePayload, UpdateFilePayload> {
+/**
+ * Files of the account. The backend serves `POST /files` (the record only, no content),
+ * `POST /files/create-to-upload` (record + signed URL to upload the content), `POST
+ * /files/duplicate-file`, `DELETE /files/:id` and the signed download `GET
+ * /files/:accountId/:filename`; there is no list, read by id nor update.
+ */
+export class FilesApi extends BaseCrudApi<
+  File,
+  CreateFilePayload,
+  UpdateFilePayload,
+  ListQuery<File>,
+  DeleteFileResult
+> {
   constructor(client: ApiClient) {
     super(client, '/files')
   }
+
+  /** @deprecated Not served: the backend has no GET /files, so this route answers 404. */
+  override getMany(
+    query: ListQuery<File> & { paginate: false },
+    headers?: Record<string, string>,
+  ): Promise<File[]>
+  /** @deprecated Not served: the backend has no GET /files, so this route answers 404. */
+  override getMany(
+    query?: ListQuery<File> & { paginate?: true },
+    headers?: Record<string, string>,
+  ): Promise<Paginated<File>>
+  /** @deprecated Not served: the backend has no GET /files, so this route answers 404. */
+  override getMany(
+    query?: ListQuery<File>,
+    headers?: Record<string, string>,
+  ): Promise<Paginated<File> | File[]>
+  override getMany(
+    query?: ListQuery<File>,
+    headers?: Record<string, string>,
+  ): Promise<Paginated<File> | File[]> {
+    return super.getMany(query, headers)
+  }
+
+  /** @deprecated Not served: the backend has no GET /files, so this route answers 404. */
+  override getOne(query?: ListQuery<File>, headers?: Record<string, string>): Promise<File | null> {
+    return super.getOne(query, headers)
+  }
+
+  /** @deprecated Not served: the backend has no GET /files/:id, so this route answers 404. */
+  override getById(
+    id: string,
+    query?: GetByIdQuery<File>,
+    headers?: Record<string, string>,
+  ): Promise<File> {
+    return super.getById(id, query, headers)
+  }
+
+  /** @deprecated Not served: the backend has no PUT /files/:id, so this route answers 404. */
+  override updateById(
+    id: string,
+    body: UpdateFilePayload,
+    headers?: Record<string, string>,
+  ): Promise<File> {
+    return super.updateById(id, body, headers)
+  }
+
+  /**
+   * Deletes a file. Resolves `{ success: true }`, also for an unknown id; a file of another
+   * account answers 403.
+   */
+  override deleteById(id: string, headers?: Record<string, string>): Promise<DeleteFileResult> {
+    return super.deleteById(id, headers)
+  }
+
+  /**
+   * 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`).
+   */
+  createToUpload(
+    body: CreateToUploadPayload,
+    headers?: Record<string, string>,
+  ): Promise<CreateToUploadResult> {
+    return this.client.post<CreateToUploadResult, CreateToUploadPayload>(
+      `${this.basePath}/create-to-upload`,
+      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
+   * storage refuses an `Authorization` header). `mimetype` must be the one sent to
+   * `createToUpload`. Sent through `client.requestExternal` (the global `fetch` for a client
+   * without it). A non-2xx answer of the storage throws `ApiError`.
+   */
+  async upload(urlToUpload: string, content: BodyInit, mimetype: string): Promise<void> {
+    const headers = { 'Content-Type': mimetype }
+    await (this.client.requestExternal
+      ? this.client.requestExternal('PUT', urlToUpload, content, headers)
+      : requestExternal('PUT', urlToUpload, content, headers))
+  }
 }

package/src/apis/files/types.ts

@@ -23,22 +23,32 @@ export type FileStorage =
 
 export type File = {
   id: string
+  /** Signed URL to download the content. */
   url: string
   name: string | null
+  /** Name of the file in the storage (`<id>.<extension>`). */
+  publicFilename: string | null
   checksum: string | null
   mimetype: string
   extension: string
-  isEncrypted: boolean
-  iv: string | null
-  attachedId: string | null
-  attachedType: string | null
-  storage: FileStorage
   data: FileData
   accountId: string
-  serviceId: string | null
   createdAt: string
   updatedAt: string
-  deletedAt: string | null
+  /** @deprecated Never answered: the file transformer leaves it out. */
+  isEncrypted?: boolean
+  /** @deprecated Never answered: the file transformer leaves it out. */
+  iv?: string | null
+  /** @deprecated Never answered: the file transformer leaves it out. */
+  attachedId?: string | null
+  /** @deprecated Never answered: the file transformer leaves it out. */
+  attachedType?: string | null
+  /** @deprecated Never answered: the file transformer leaves it out. */
+  storage?: FileStorage
+  /** @deprecated Never answered: the file transformer leaves it out. */
+  serviceId?: string | null
+  /** @deprecated Never answered: the file transformer leaves it out. */
+  deletedAt?: string | null
 }
 
 export type CreateFilePayload = {
@@ -56,3 +66,34 @@ export type UpdateFilePayload = {
   attachedId?: string | null
   attachedType?: string | null
 }
+
+/** Body of `FilesApi.createToUpload`. */
+export type CreateToUploadPayload = {
+  /** File name (commas are replaced by spaces). Required, except for an audio. */
+  name?: string
+  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). */
+  serviceId?: string
+  /** Audio sent as a voice message (default `true`). */
+  isPtt?: boolean
+  /** Audio sent as a document, with no conversion (default `false`). */
+  sendAsDocument?: boolean
+  /** Content of an audio that must be converted (required in that case). */
+  base64?: string
+}
+
+/** Result of `FilesApi.createToUpload`. */
+export type CreateToUploadResult = {
+  /** Signed URL to send the content to (`FilesApi.upload`); absent when the audio was converted. */
+  urlToUpload?: string
+  id: string
+  name: string
+  mimetype: string
+}
+
+/** Result of `FilesApi.deleteById`. */
+export type DeleteFileResult = {
+  success: boolean
+}

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.ts

@@ -1,13 +1,24 @@
 import type { ApiClient } from '../../core/ApiClient'
+import type { ListQuery } from '../../core/types'
 import { BaseCrudApi } from '../../core/BaseCrudApi'
 import type { Integration, CreateIntegrationPayload, UpdateIntegrationPayload } from './types'
 
 export class IntegrationsApi extends BaseCrudApi<
   Integration,
   CreateIntegrationPayload,
-  UpdateIntegrationPayload
+  UpdateIntegrationPayload,
+  ListQuery<Integration>,
+  'OK'
 > {
   constructor(client: ApiClient) {
     super(client, '/integrations')
   }
+
+  /**
+   * 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/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)
+  }
 }