@ikatec/digisac-api-sdk 4.8.0 → 4.10.0

package/src/apis/departments/DepartmentsApi.ts

@@ -1,13 +1,52 @@
 import type { ApiClient } from '../../core/ApiClient'
+import type { ListQuery } from '../../core/types'
 import { ArchivableCrudApi } from '../../core/ArchivableCrudApi'
-import type { Department, CreateDepartmentPayload, UpdateDepartmentPayload } from './types'
+import type {
+  Department,
+  CreateDepartmentPayload,
+  UpdateDepartmentPayload,
+  ArchiveDepartmentPayload,
+} from './types'
 
 export class DepartmentsApi extends ArchivableCrudApi<
   Department,
   CreateDepartmentPayload,
-  UpdateDepartmentPayload
+  UpdateDepartmentPayload,
+  ListQuery<Department>,
+  'OK'
 > {
   constructor(client: ApiClient) {
     super(client, '/departments')
   }
+
+  /**
+   * Archives (`archive: true`) or restores (`archive: false`) a department through the route used
+   * by the UI, which enforces what {@link archive}/{@link unarchive} (a plain `PUT { archivedAt }`)
+   * skip: archiving refuses (403 `Cannot archive department.`, with the reasons and the open
+   * tickets count) a department in use, and clears it as the default department of contacts and
+   * connections, marks its schedules as done and unlinks its users and quick replies. Resolves the
+   * stored department (not transformed); an unknown id answers 500.
+   * @permissions departments.view OR departments.archive
+   */
+  archiveWithValidation(
+    id: string,
+    body: ArchiveDepartmentPayload,
+    headers?: Record<string, string>,
+  ): Promise<Department> {
+    return this.client.post<Department, ArchiveDepartmentPayload>(
+      `${this.basePath}/${id}/archive`,
+      body,
+      headers,
+    )
+  }
+
+  /**
+   * Deletes a department. Resolves the text `'OK'`; a department that is the default of the account
+   * or that is referenced in the attendant name visibility settings is refused, and an unknown id
+   * answers 500.
+   * @permissions departments.view OR departments.archive
+   */
+  override deleteById(id: string, headers?: Record<string, string>): Promise<'OK'> {
+    return super.deleteById(id, headers)
+  }
 }

package/src/apis/departments/types.ts

@@ -26,3 +26,9 @@ export type UpdateDepartmentPayload = {
   distributionId?: string | null
   archivedAt?: string | null
 }
+
+/** Body of `DepartmentsApi.archiveWithValidation`. */
+export type ArchiveDepartmentPayload = {
+  /** `true` archives, `false` restores. */
+  archive: boolean
+}

package/src/apis/distribution/DistributionApi.ts

@@ -1,13 +1,24 @@
 import type { ApiClient } from '../../core/ApiClient'
+import type { ListQuery } from '../../core/types'
 import { BaseCrudApi } from '../../core/BaseCrudApi'
 import type { Distribution, CreateDistributionPayload, UpdateDistributionPayload } from './types'
 
 export class DistributionApi extends BaseCrudApi<
   Distribution,
   CreateDistributionPayload,
-  UpdateDistributionPayload
+  UpdateDistributionPayload,
+  ListQuery<Distribution>,
+  void
 > {
   constructor(client: ApiClient) {
     super(client, '/distribution')
   }
+
+  /**
+   * Deletes a distribution. Resolves with no body, also for an unknown id (200).
+   * @permissions distribution.view OR distribution.destroy
+   */
+  override deleteById(id: string, headers?: Record<string, string>): Promise<void> {
+    return super.deleteById(id, headers)
+  }
 }

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/interactiveMessages/types.ts

@@ -10,6 +10,37 @@ type InteractiveMessageButton = {
 
 type InteractiveMessageBodyFooter = string | { text: string }
 
+export type ChannelRedirectChannel = 'whatsapp' | 'telegram' | 'instagram' | 'webchat'
+
+export type ChannelRedirectIdentifierType = 'phone' | 'botName'
+
+/**
+ * Digisac-only setting of a `cta_url` message: the channel its URL was built for. It sits next to
+ * `action`, never inside `action.parameters`, and is stripped before the message reaches Meta. The
+ * backend reads it to add the ticket parameters to the URL on send. A missing key means
+ * `{ enabled: false }`.
+ */
+export type ChannelRedirect = {
+  enabled: boolean
+  channel?: ChannelRedirectChannel
+  /** `'phone'` for WhatsApp; `'phone'` or `'botName'` for Telegram; unset for the others. */
+  identifierType?: ChannelRedirectIdentifierType
+  /** Phone as `+<DDI><number>` without mask, or the Telegram bot / Instagram user name. */
+  identifier?: string
+  /** Id of the Webchat service, when `channel` is `'webchat'`. */
+  serviceId?: string
+}
+
+type CtaUrlAction = {
+  name: 'cta_url'
+  parameters: {
+    /** 1–20 characters after trim, without `{{…}}` variables. */
+    display_text: string
+    /** 1–2000 characters after trim, starting with `http://` or `https://`. */
+    url: string
+  }
+}
+
 // --- Response types ---
 
 type InteractiveMedia = {
@@ -60,9 +91,27 @@ type ButtonInteractiveMessageContent = {
   }
 }
 
+export type CtaUrlInteractiveMessageContent = {
+  type: 'cta_url'
+  header?: ButtonInteractiveMessageContent['header']
+  body: InteractiveMessageBodyFooter
+  footer?: InteractiveMessageBodyFooter
+  action: CtaUrlAction
+  channelRedirect?: ChannelRedirect
+}
+
+/** Has no header or footer: WhatsApp refuses them on this type. */
+export type RequestContactInfoInteractiveMessageContent = {
+  type: 'request_contact_info'
+  body: InteractiveMessageBodyFooter
+  action: { name?: string }
+}
+
 export type InteractiveMessageContent =
   | ListInteractiveMessageContent
   | ButtonInteractiveMessageContent
+  | CtaUrlInteractiveMessageContent
+  | RequestContactInfoInteractiveMessageContent
 
 // --- Input types (create/update) ---
 
@@ -90,9 +139,26 @@ type ButtonInteractiveMessageContentInput = {
   }
 }
 
+type CtaUrlInteractiveMessageContentInput = {
+  type: 'cta_url'
+  header?: ButtonInteractiveMessageContentInput['header']
+  body: InteractiveMessageBodyFooter
+  footer?: InteractiveMessageBodyFooter
+  action: CtaUrlAction
+  channelRedirect?: ChannelRedirect
+}
+
+type RequestContactInfoInteractiveMessageContentInput = {
+  type: 'request_contact_info'
+  body: InteractiveMessageBodyFooter
+  action: { name: 'request_contact_info' }
+}
+
 type InteractiveMessageContentInput =
   | ListInteractiveMessageContentInput
   | ButtonInteractiveMessageContentInput
+  | CtaUrlInteractiveMessageContentInput
+  | RequestContactInfoInteractiveMessageContentInput
 
 type InteractiveMessageFilePayload =
   | { id: string }
@@ -103,7 +169,7 @@ type InteractiveMessageFilePayload =
 export type InteractiveMessage = {
   id: string
   name: string
-  type: 'list' | 'button'
+  type: 'list' | 'button' | 'cta_url' | 'request_contact_info'
   interactive: InteractiveMessageContent
   archivedAt: string | null
   accountId: string

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)
+  }
 }