@ikatec/digisac-api-sdk 4.12.0 → 4.13.0

package/src/apis/creditMovements/CreditMovementsApi.test.ts

@@ -0,0 +1,88 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { CreditMovementsApi } from './CreditMovementsApi'
+import type { ApiClient } from '../../core/ApiClient'
+
+// ── Mock client factory ──────────────────────────────────────────────
+
+function createMockClient(): ApiClient {
+  return {
+    setAccessToken: vi.fn().mockReturnThis(),
+    request: vi.fn(),
+    requestRaw: vi.fn(),
+    get: vi.fn(),
+    post: vi.fn(),
+    put: vi.fn(),
+    patch: vi.fn(),
+    delete: vi.fn(),
+  }
+}
+
+// ── Tests ────────────────────────────────────────────────────────────
+
+describe('CreditMovementsApi', () => {
+  let client: ReturnType<typeof createMockClient>
+  let api: CreditMovementsApi
+
+  beforeEach(() => {
+    client = createMockClient()
+    api = new CreditMovementsApi(client)
+  })
+
+  it('balances calls client.get with /credit-movements/balances', async () => {
+    await api.balances()
+    expect(client.get).toHaveBeenCalledWith('/credit-movements/balances', undefined)
+  })
+
+  it('balance posts the service type to /credit-movements/balance', async () => {
+    vi.mocked(client.post).mockResolvedValue(20)
+    await expect(api.balance('sms-wavy')).resolves.toBe(20)
+    expect(client.post).toHaveBeenCalledWith(
+      '/credit-movements/balance',
+      { serviceType: 'sms-wavy' },
+      undefined,
+    )
+  })
+
+  it('balancesV2 serializes the period', async () => {
+    await api.balancesV2({ from: '2026-10-01', to: '2026-10-17' })
+    const url = vi.mocked(client.get).mock.calls[0]?.[0] as string
+    expect(url).toMatch(/^\/credit-movements\/v2\/balances\?/)
+    expect(decodeURIComponent(url)).toContain('"from":"2026-10-01"')
+  })
+
+  it('balancesV2 sends no query without a period', async () => {
+    await api.balancesV2()
+    expect(client.get).toHaveBeenCalledWith('/credit-movements/v2/balances', undefined)
+  })
+
+  it('totalServices serializes the filters and the page', async () => {
+    await api.totalServices({
+      filters: { from: '2026-10-01', to: '2026-10-17', serviceType: 'summary' },
+      page: 1,
+    })
+    const url = vi.mocked(client.get).mock.calls[0]?.[0] as string
+    expect(url).toMatch(/^\/credit-movements\/total-services\?/)
+    expect(decodeURIComponent(url)).toContain('"page":1')
+  })
+
+  it('exportXlsx resolves the binary body of requestRaw', async () => {
+    const requestRaw = vi.fn().mockResolvedValue(new Response(new ArrayBuffer(4)))
+    client.requestRaw = requestRaw
+    const result = await api.exportXlsx({
+      from: '2026-10-01',
+      to: '2026-10-17',
+      where: { $and: [] },
+    })
+    expect(result.byteLength).toBe(4)
+    const [method, url] = requestRaw.mock.calls[0] ?? []
+    expect(method).toBe('GET')
+    expect(url).toMatch(/^\/credit-movements\/export\?/)
+  })
+
+  it('exportXlsx refuses a client without requestRaw', async () => {
+    const withoutRaw: ApiClient = { ...client, requestRaw: undefined }
+    await expect(
+      new CreditMovementsApi(withoutRaw).exportXlsx({ from: 'a', to: 'b', where: { $and: [] } }),
+    ).rejects.toThrow('requestRaw')
+  })
+})

package/src/apis/creditMovements/CreditMovementsApi.ts

@@ -4,12 +4,19 @@ import type {
   CreditMovement,
   CreateCreditMovementPayload,
   UpdateCreditMovementPayload,
+  CreditBalances,
+  CreditBalanceV2,
+  CreditBalancesV2Query,
+  CreditMovementServiceType,
+  CreditMovementsExportQuery,
+  CreditTotalServices,
+  CreditTotalServicesQuery,
 } from './types'
 
 /**
  * Credit movements of the account (SMS and AI credits), only for reading: the writes are super
- * admin routes (`/admin/credit-movements`). The backend serves only `GET /credit-movements` and
- * `GET /credit-movements/:id`.
+ * admin routes (`/admin/credit-movements`). Besides the list and the read by id, the backend serves the
+ * balances, the totals per connection and the xlsx export.
  */
 export class CreditMovementsApi extends BaseCrudApi<
   CreditMovement,
@@ -41,4 +48,68 @@ export class CreditMovementsApi extends BaseCrudApi<
   override deleteById(id: string, headers?: Record<string, string>): Promise<CreditMovement> {
     return super.deleteById(id, headers)
   }
+
+  /** The balance of each service type of the account. */
+  balances(headers?: Record<string, string>): Promise<CreditBalances> {
+    return this.client.get<CreditBalances>(`${this.basePath}/balances`, headers)
+  }
+
+  /**
+   * The balance of one service type (a read, despite the POST). Without `serviceType` the route answers 500.
+   */
+  balance(
+    serviceType: CreditMovementServiceType,
+    headers?: Record<string, string>,
+  ): Promise<number> {
+    return this.client.post<number, { serviceType: CreditMovementServiceType }>(
+      `${this.basePath}/balance`,
+      { serviceType },
+      headers,
+    )
+  }
+
+  /** The balances of the period by service type and connection (`ins` without the trial credits). */
+  balancesV2(
+    query?: CreditBalancesV2Query,
+    headers?: Record<string, string>,
+  ): Promise<Record<CreditMovementServiceType, CreditBalanceV2>> {
+    return this.client.get<Record<CreditMovementServiceType, CreditBalanceV2>>(
+      `${this.basePath}/v2/balances${this.toQueryString(query)}`,
+      headers,
+    )
+  }
+
+  /**
+   * The total of credits of each connection in the period (five per page). Resolves `undefined` (no body)
+   * when `filters.from`, `filters.to`, `filters.serviceType` or `page` is missing.
+   */
+  totalServices(
+    query: CreditTotalServicesQuery,
+    headers?: Record<string, string>,
+  ): Promise<CreditTotalServices | undefined> {
+    return this.client.get<CreditTotalServices | undefined>(
+      `${this.basePath}/total-services${this.toQueryString(query)}`,
+      headers,
+    )
+  }
+
+  /**
+   * Exports the movements of the period as an xlsx workbook (binary). Needs a client with `requestRaw`.
+   * Without `where.$and` the route answers 500.
+   */
+  async exportXlsx(
+    query: CreditMovementsExportQuery,
+    headers?: Record<string, string>,
+  ): Promise<ArrayBuffer> {
+    if (!this.client.requestRaw) {
+      throw new Error('exportXlsx needs a client with requestRaw (the answer is a binary xlsx)')
+    }
+    const response = await this.client.requestRaw(
+      'GET',
+      `${this.basePath}/export${this.toQueryString(query)}`,
+      undefined,
+      headers,
+    )
+    return response.arrayBuffer()
+  }
 }

package/src/apis/creditMovements/types.ts

@@ -26,6 +26,7 @@ export type CreditMovementOrigin =
   | 'additional'
   | 'agent'
 
+/** A movement as the transformer answers it (no `userId`; the relations are never served). */
 export type CreditMovement = {
   id: string
   type: CreditMovementType
@@ -33,19 +34,90 @@ export type CreditMovement = {
   serviceType: CreditMovementServiceType
   origin: CreditMovementOrigin | null
   accountId: string
-  serviceId: string
-  userId: string | null
+  /** `null` on the movements of the account (e.g. the trial SMS credits of a new account). */
+  serviceId: string | null
+  /** @deprecated Not answered: the transformer of the backend does not send it. */
+  userId?: string | null
   campaignId: string | null
   createdAt: string
   updatedAt: string
   // relationships
+  /** @deprecated Not served: the include is dropped by the backend. */
   service?: Service
+  /** @deprecated Not served: the include is dropped by the backend. */
   user?: User | null
+  /** @deprecated Not served: the include is dropped by the backend. */
   campaign?: Campaign | null
 }
 
+/** None is served: the backend drops every include of this route. */
 export type CreditMovementRelationships = 'service' | 'user' | 'campaign'
 
+/** The balance of each service type (`balances`): the movements in minus the movements out. */
+export type CreditBalances = Record<CreditMovementServiceType, number>
+
+/** The totals of a service type in `balancesV2`. */
+export type CreditBalanceTotals = {
+  ins: number
+  outs: number
+  balance: number
+  used: number
+  contractedCredits?: number
+  additionalCredits?: number
+  realConsumption?: number
+}
+
+/**
+ * A service type in `balancesV2`: `all` with the totals, `history` with the rows of the period, and one
+ * key per connection name with its totals. The `ins` count the credits of the plan (`plan.ai`) and the
+ * additional ones: the trial SMS credits are not counted (they show in `balances`).
+ */
+export type CreditBalanceV2 = {
+  all: CreditBalanceTotals
+  history?: Record<string, unknown>[]
+  [serviceName: string]: unknown
+}
+
+export type CreditBalancesV2Query = {
+  from?: string
+  to?: string
+  serviceId?: string
+}
+
+/**
+ * Query of `totalServices`: without `filters.from`, `filters.to`, `filters.serviceType` and `page` the route
+ * answers 200 with no body.
+ */
+export type CreditTotalServicesQuery = {
+  filters: {
+    from: string
+    to: string
+    serviceType: CreditMovementServiceType
+    servicesIds?: string[]
+  }
+  /** From 1 (`0` answers 500 `Invalid param`). Five connections per page. */
+  page: number
+}
+
+/** The total of credits of each connection in the period, five per page (the counts come as text). */
+export type CreditTotalServices = {
+  data: { id: string; name: string; total: string }[]
+  total: string
+  limit: number
+  skip: number
+  currentPage: string | number
+  lastPage: number
+  from: number
+  to: number
+}
+
+/** Query of `exportXlsx`: the period and the conditions in `where.$and` (required by the backend). */
+export type CreditMovementsExportQuery = {
+  from: string
+  to: string
+  where: { $and: Record<string, unknown>[] }
+}
+
 export type CreateCreditMovementPayload = {
   type: CreditMovementType
   serviceType: CreditMovementServiceType

package/src/apis/knowledgeBase/KnowledgeBaseApi.test.ts

@@ -0,0 +1,54 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { KnowledgeBaseApi } from './KnowledgeBaseApi'
+import type { ApiClient } from '../../core/ApiClient'
+
+// ── Mock client factory ──────────────────────────────────────────────
+
+function createMockClient(): ApiClient {
+  return {
+    setAccessToken: vi.fn().mockReturnThis(),
+    request: vi.fn(),
+    requestRaw: vi.fn(),
+    get: vi.fn(),
+    post: vi.fn(),
+    put: vi.fn(),
+    patch: vi.fn(),
+    delete: vi.fn(),
+  }
+}
+
+// ── Tests ────────────────────────────────────────────────────────────
+
+describe('KnowledgeBaseApi', () => {
+  let client: ReturnType<typeof createMockClient>
+  let api: KnowledgeBaseApi
+
+  beforeEach(() => {
+    client = createMockClient()
+    api = new KnowledgeBaseApi(client)
+  })
+
+  it('saveWithItems posts the base with its items', async () => {
+    const body = { name: 'QA', items: [], deleteItemIds: [] }
+    await api.saveWithItems(body)
+    expect(client.post).toHaveBeenCalledWith('/knowledge-base/save-with-items', body, undefined)
+  })
+
+  it('suggestByMessage posts the message to /knowledge-base/suggest-by-message', async () => {
+    await api.suggestByMessage({ messageId: 'm-1' })
+    expect(client.post).toHaveBeenCalledWith(
+      '/knowledge-base/suggest-by-message',
+      { messageId: 'm-1' },
+      undefined,
+    )
+  })
+
+  it('suggestByTicket posts the ticket to /knowledge-base/suggest-by-ticket', async () => {
+    await api.suggestByTicket({ ticketId: 't-1', outsideTheKnowledgeBase: true })
+    expect(client.post).toHaveBeenCalledWith(
+      '/knowledge-base/suggest-by-ticket',
+      { ticketId: 't-1', outsideTheKnowledgeBase: true },
+      undefined,
+    )
+  })
+})

package/src/apis/knowledgeBase/KnowledgeBaseApi.ts

@@ -1,8 +1,22 @@
 import type { ApiClient } from '../../core/ApiClient'
 import type { ListQuery } from '../../core/types'
 import { BaseCrudApi } from '../../core/BaseCrudApi'
-import type { KnowledgeBase, CreateKnowledgeBasePayload, UpdateKnowledgeBasePayload } from './types'
+import type {
+  KnowledgeBase,
+  CreateKnowledgeBasePayload,
+  UpdateKnowledgeBasePayload,
+  KnowledgeBaseSuggestion,
+  SaveKnowledgeBaseWithItemsPayload,
+  SavedKnowledgeBase,
+  SuggestByMessagePayload,
+  SuggestByTicketPayload,
+} from './types'
 
+/**
+ * Knowledge bases of the AI (copilot). The CRUD of a base without items only touches the database; an item
+ * VECTORIZES its content in the AI service, and the suggestions call the AI and DEBIT the copilot credits of
+ * the account.
+ */
 export class KnowledgeBaseApi extends BaseCrudApi<
   KnowledgeBase,
   CreateKnowledgeBasePayload,
@@ -22,4 +36,50 @@ export class KnowledgeBaseApi extends BaseCrudApi<
   override deleteById(id: string, headers?: Record<string, string>): Promise<false> {
     return super.deleteById(id, headers)
   }
+
+  /**
+   * Creates a base, or updates the one of `id`, with its items, in a transaction. Each item VECTORIZES its
+   * content in the AI service (with `items: []` only the database is touched). Resolves the stored base
+   * (raw). A body out of the schema answers 500 with the issues of the validation.
+   */
+  saveWithItems(
+    body: SaveKnowledgeBaseWithItemsPayload,
+    headers?: Record<string, string>,
+  ): Promise<SavedKnowledgeBase> {
+    return this.client.post<SavedKnowledgeBase, SaveKnowledgeBaseWithItemsPayload>(
+      `${this.basePath}/save-with-items`,
+      body,
+      headers,
+    )
+  }
+
+  /**
+   * Suggests an answer to a message with the AI (copilot) and DEBITS the copilot credits of the account; an
+   * audio is transcribed first (charged too).
+   */
+  suggestByMessage(
+    body: SuggestByMessagePayload,
+    headers?: Record<string, string>,
+  ): Promise<KnowledgeBaseSuggestion> {
+    return this.client.post<KnowledgeBaseSuggestion, SuggestByMessagePayload>(
+      `${this.basePath}/suggest-by-message`,
+      body,
+      headers,
+    )
+  }
+
+  /**
+   * Suggests an answer to a ticket with the AI (copilot) and DEBITS the copilot credits of the account; the
+   * audios of the ticket are transcribed first (charged too).
+   */
+  suggestByTicket(
+    body: SuggestByTicketPayload,
+    headers?: Record<string, string>,
+  ): Promise<KnowledgeBaseSuggestion> {
+    return this.client.post<KnowledgeBaseSuggestion, SuggestByTicketPayload>(
+      `${this.basePath}/suggest-by-ticket`,
+      body,
+      headers,
+    )
+  }
 }

package/src/apis/knowledgeBase/types.ts

@@ -1,5 +1,6 @@
 import type { KnowledgeBaseItem } from '../knowledgeBaseItem/types'
 
+/** A knowledge base as the transformer answers it (`items` always comes: `[]` without the include). */
 export type KnowledgeBase = {
   id: string
   name: string
@@ -7,19 +8,78 @@ export type KnowledgeBase = {
   accountId: string
   createdAt: string
   updatedAt: string
-  deletedAt: string | null
+  /** @deprecated Not answered: the transformer of the backend does not send it. */
+  deletedAt?: string | null
   // relationships
   items?: KnowledgeBaseItem[]
+  account?: Record<string, unknown>
 }
 
-export type KnowledgeBaseRelationships = 'items'
+export type KnowledgeBaseRelationships = 'items' | 'account'
 
 export type CreateKnowledgeBasePayload = {
+  /** Up to 60 characters. */
   name: string
+  /** Up to 600 characters. */
   description?: string
 }
 
+/** The backend requires `name` on the update too (400 without it). */
 export type UpdateKnowledgeBasePayload = {
   name?: string
   description?: string | null
 }
+
+/**
+ * An item of `saveWithItems`. Any item VECTORIZES its content in the AI service (Haystack) on the save:
+ * `text` for `messages`, `url` for `urls` (the service fetches the page), `fileId` for `files`.
+ */
+export type SaveKnowledgeBaseItemInput = {
+  name: string
+  type: 'urls' | 'files' | 'messages'
+  url?: string
+  fileId?: string
+  text?: string
+}
+
+/** The body of `saveWithItems`: creates the base, or updates the one of `id`, with its items. */
+export type SaveKnowledgeBaseWithItemsPayload = {
+  /** 1 to 60 characters. */
+  name: string
+  /** Up to 600 characters. */
+  description?: string
+  /** The base to update (absent: a new base). */
+  id?: string
+  items?: SaveKnowledgeBaseItemInput[]
+  /** Items of the base to delete. */
+  deleteItemIds?: string[]
+}
+
+/** The stored base answered by `saveWithItems` (raw: with `synchronized`, without `items`). */
+export type SavedKnowledgeBase = Omit<KnowledgeBase, 'items' | 'account' | 'deletedAt'> & {
+  synchronized: boolean | null
+  deletedAt: string | null
+}
+
+/**
+ * What the suggestions answer: the suggested text, or a `message` code when nothing was suggested (e.g.
+ * `COPILOT_LIMIT_REACHED`, `COPILOT_TRANSCRIPTION_NOT_ENABLED`, `TRANSCRIBING_AUDIO_MESSAGES`).
+ */
+export type KnowledgeBaseSuggestion = {
+  message: string
+  hasAudioMessage?: boolean
+  hadEnoughCreditsToTranscribe?: boolean
+  [key: string]: unknown
+}
+
+export type SuggestByMessagePayload = {
+  messageId: string
+  /** Lets the AI answer beyond the knowledge base. */
+  outsideTheKnowledgeBase?: boolean
+}
+
+export type SuggestByTicketPayload = {
+  ticketId: string
+  /** Lets the AI answer beyond the knowledge base. */
+  outsideTheKnowledgeBase?: boolean
+}

package/src/apis/knowledgeBaseItem/KnowledgeBaseItemApi.test.ts

@@ -0,0 +1,57 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { KnowledgeBaseItemApi } from './KnowledgeBaseItemApi'
+import type { ApiClient } from '../../core/ApiClient'
+
+// ── Mock client factory ──────────────────────────────────────────────
+
+function createMockClient(): ApiClient {
+  return {
+    setAccessToken: vi.fn().mockReturnThis(),
+    request: vi.fn(),
+    requestRaw: vi.fn(),
+    get: vi.fn(),
+    post: vi.fn(),
+    put: vi.fn(),
+    patch: vi.fn(),
+    delete: vi.fn(),
+  }
+}
+
+// ── Tests ────────────────────────────────────────────────────────────
+
+describe('KnowledgeBaseItemApi', () => {
+  let client: ReturnType<typeof createMockClient>
+  let api: KnowledgeBaseItemApi
+
+  beforeEach(() => {
+    client = createMockClient()
+    api = new KnowledgeBaseItemApi(client)
+  })
+
+  it('fetchMany posts the ids to /knowledge-base-item/fetch-many', async () => {
+    vi.mocked(client.post).mockResolvedValue([])
+    await expect(api.fetchMany(['i-1'])).resolves.toEqual([])
+    expect(client.post).toHaveBeenCalledWith(
+      '/knowledge-base-item/fetch-many',
+      { ids: ['i-1'] },
+      undefined,
+    )
+  })
+
+  it('deleteMany sends DELETE /knowledge-base-item/many with the ids in the body', async () => {
+    vi.mocked(client.request).mockResolvedValue(true)
+    await expect(api.deleteMany(['i-1'])).resolves.toBe(true)
+    expect(client.request).toHaveBeenCalledWith(
+      'DELETE',
+      '/knowledge-base-item/many',
+      { ids: ['i-1'] },
+      undefined,
+    )
+  })
+
+  it('checkPdfText posts the file to /knowledge-base-item/check-pdf-text', async () => {
+    vi.mocked(client.post).mockResolvedValue({ hasText: false })
+    await expect(api.checkPdfText({})).resolves.toEqual({ hasText: false })
+    expect(client.post).toHaveBeenCalledWith('/knowledge-base-item/check-pdf-text', {}, undefined)
+  })
+})

package/src/apis/knowledgeBaseItem/KnowledgeBaseItemApi.ts

@@ -7,6 +7,10 @@ import type {
   UpdateKnowledgeBaseItemPayload,
 } from './types'
 
+/**
+ * Items of the knowledge bases. Creating an item VECTORIZES its content in the AI service; reading the
+ * `docs` (include, `fetchMany`) reads them from it.
+ */
 export class KnowledgeBaseItemApi extends BaseCrudApi<
   KnowledgeBaseItem,
   CreateKnowledgeBaseItemPayload,
@@ -26,4 +30,45 @@ export class KnowledgeBaseItemApi extends BaseCrudApi<
   override deleteById(id: string, headers?: Record<string, string>): Promise<false> {
     return super.deleteById(id, headers)
   }
+
+  /**
+   * Reads the items of `ids` with their documents (read from the AI service). Resolves the stored items, raw:
+   * unlike the other reads they carry `knowledgeBaseId`, `fileId` and `deletedAt`. An empty or absent `ids`
+   * answers 400 `Invalid knowledge base item ids`.
+   */
+  fetchMany(ids: string[], headers?: Record<string, string>): Promise<KnowledgeBaseItem[]> {
+    return this.client.post<KnowledgeBaseItem[], { ids: string[] }>(
+      `${this.basePath}/fetch-many`,
+      { ids },
+      headers,
+    )
+  }
+
+  /**
+   * Deletes the items of `ids` of the account (soft delete; their documents stay in the AI service).
+   * Resolves `true`; an empty or absent `ids` answers 400 `Invalid knowledge base item ids`.
+   */
+  deleteMany(ids: string[], headers?: Record<string, string>): Promise<true> {
+    return this.client.request<true, { ids: string[] }>(
+      'DELETE',
+      `${this.basePath}/many`,
+      { ids },
+      headers,
+    )
+  }
+
+  /**
+   * Tells whether the PDF of `fileId` has text to be vectorized (read locally, no AI). Without `fileId` it
+   * resolves `{ hasText: false }`.
+   */
+  checkPdfText(
+    body: { fileId?: string },
+    headers?: Record<string, string>,
+  ): Promise<{ hasText: boolean }> {
+    return this.client.post<{ hasText: boolean }, { fileId?: string }>(
+      `${this.basePath}/check-pdf-text`,
+      body,
+      headers,
+    )
+  }
 }

package/src/apis/knowledgeBaseItem/types.ts

@@ -1,35 +1,52 @@
 import type { File } from '../files/types'
 import type { KnowledgeBase } from '../knowledgeBase/types'
 
+/** An item as the transformer answers it (no `knowledgeBaseId`, `fileId` nor `deletedAt`). */
 export type KnowledgeBaseItem = {
   id: string
   name: string
-  type: string
+  type: 'urls' | 'files' | 'messages' | (string & {})
   sourceId: string | null
   url: string | null
   accountId: string
-  knowledgeBaseId: string
-  fileId: string | null
+  /** @deprecated Not answered: the transformer of the backend does not send it. */
+  knowledgeBaseId?: string
+  /** @deprecated Not answered: the transformer of the backend does not send it. */
+  fileId?: string | null
   createdAt: string
   updatedAt: string
-  deletedAt: string | null
+  /** @deprecated Not answered: the transformer of the backend does not send it. */
+  deletedAt?: string | null
   // relationships
+  /** @deprecated Not served: the include is dropped by the backend. */
   knowledgeBase?: KnowledgeBase
   file?: File | null
+  /** The vectorized documents (the include reads them from the AI service). */
+  docs?: Record<string, unknown>[]
+  account?: Record<string, unknown>
 }
 
-export type KnowledgeBaseItemRelationships = 'knowledgeBase' | 'file'
+export type KnowledgeBaseItemRelationships = 'knowledgeBase' | 'file' | 'docs' | 'account'
 
+/**
+ * Creates an item and VECTORIZES its content in the AI service right away: `text` (type `messages`), `url`
+ * (type `urls`, the service fetches the page) or `fileId` (type `files`). Without any of the three it
+ * answers 400 `You must provide fileId, text, or url`.
+ */
 export type CreateKnowledgeBaseItemPayload = {
   name: string
-  type: string
+  type: 'urls' | 'files' | 'messages' | (string & {})
   knowledgeBaseId: string
+  /** @deprecated Ignored by the backend. */
   sourceId?: string
+  text?: string
   url?: string
   fileId?: string
 }
 
+/** The backend requires `name`, `type` and `knowledgeBaseId` on the update too (400 without them). */
 export type UpdateKnowledgeBaseItemPayload = {
+  knowledgeBaseId?: string
   name?: string
   type?: string
   sourceId?: string | null

package/src/apis/me/MeApi.test.ts

@@ -296,7 +296,7 @@ describe('MeApi', () => {
   describe('registerToken', () => {
     it('calls client.post with /me/one-signal/register-token and body', async () => {
       vi.mocked(client.post).mockResolvedValue(undefined)
-      const body: RegisterTokenPayload = { token: 'abc123', platform: 'web' }
+      const body: RegisterTokenPayload = { data: { oneSignalToken: 'abc123' } }
       await api.registerToken(body)
       expect(client.post).toHaveBeenCalledWith('/me/one-signal/register-token', body, undefined)
     })