@ikatec/digisac-api-sdk 4.11.0 → 4.13.0

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

@@ -0,0 +1,59 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { InteractiveMessagesApi } from './InteractiveMessagesApi'
+import type { ApiClient } from '../../core/ApiClient'
+
+// ── 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(),
+  }
+}
+
+// ── Tests ────────────────────────────────────────────────────────────
+
+describe('InteractiveMessagesApi', () => {
+  let client: ReturnType<typeof createMockClient>
+  let api: InteractiveMessagesApi
+
+  beforeEach(() => {
+    client = createMockClient()
+    api = new InteractiveMessagesApi(client)
+  })
+
+  describe('count', () => {
+    it('calls client.get with /interactive-messages/count when no query is provided', async () => {
+      vi.mocked(client.get).mockResolvedValue({ count: 4 })
+      await expect(api.count()).resolves.toEqual({ count: 4 })
+      expect(client.get).toHaveBeenCalledWith('/interactive-messages/count', undefined)
+    })
+
+    it('serializes the query', async () => {
+      vi.mocked(client.get).mockResolvedValue({ count: 1 })
+      await api.count({ where: { name: 'QA' } })
+      const url = vi.mocked(client.get).mock.calls[0]?.[0] as string
+      expect(url).toContain('/interactive-messages/count?')
+      expect(url).toContain('where')
+    })
+  })
+
+  it('create posts the message to /interactive-messages', async () => {
+    const body = {
+      name: 'QA',
+      interactive: {
+        type: 'button' as const,
+        body: 'Oi',
+        action: { buttons: [{ type: 'reply' as const, reply: { id: '1', title: 'Sim' } }] },
+      },
+    }
+    vi.mocked(client.post).mockResolvedValue({ id: 'im-1' })
+    await api.create(body)
+    expect(client.post).toHaveBeenCalledWith('/interactive-messages', body, undefined)
+  })
+})

package/src/apis/interactiveMessages/InteractiveMessagesApi.ts

@@ -18,6 +18,32 @@ export class InteractiveMessagesApi extends BaseCrudApi<
     super(client, '/interactive-messages')
   }
 
+  /**
+   * Counts the interactive messages matching the query.
+   * @permissions interactive-messages.view OR interactive-messages.management.all.departments
+   */
+  count(
+    query?: ListQuery<InteractiveMessage>,
+    headers?: Record<string, string>,
+  ): Promise<{ count: number }> {
+    return this.client.get<{ count: number }>(
+      `${this.basePath}/count${this.toQueryString(query)}`,
+      headers,
+    )
+  }
+
+  /**
+   * Creates an interactive message. Only `cta_url` is validated by the backend (the other types are stored as
+   * sent). The answer has no `departments` nor `file`: read them with `getById` and `include`.
+   * @permissions interactive-messages.create OR interactive-messages.management.all.departments
+   */
+  override create(
+    body: CreateInteractiveMessagePayload,
+    headers?: Record<string, string>,
+  ): Promise<InteractiveMessage> {
+    return super.create(body, headers)
+  }
+
   /**
    * Deletes an interactive message. Resolves the text `'OK'`; an unknown id answers 500.
    * @permissions interactive-messages.destroy OR interactive-messages.management.all.departments

package/src/apis/interactiveMessages/types.ts

@@ -169,7 +169,8 @@ type InteractiveMessageFilePayload =
 export type InteractiveMessage = {
   id: string
   name: string
-  type: 'list' | 'button' | 'cta_url' | 'request_contact_info'
+  /** @deprecated Not a field of the backend (no such column): the type is `interactive.type`. */
+  type?: 'list' | 'button' | 'cta_url' | 'request_contact_info'
   interactive: InteractiveMessageContent
   archivedAt: string | null
   accountId: string
@@ -179,9 +180,10 @@ export type InteractiveMessage = {
   // relationships
   file?: File | null
   departments?: Department[]
+  account?: Record<string, unknown>
 }
 
-export type InteractiveMessageRelationships = 'file' | 'departments'
+export type InteractiveMessageRelationships = 'file' | 'departments' | 'account'
 
 export type CreateInteractiveMessagePayload = {
   name: string
@@ -191,6 +193,10 @@ export type CreateInteractiveMessagePayload = {
   file?: InteractiveMessageFilePayload
 }
 
+/**
+ * The backend requires `name` and `interactive` on the update too. It replaces the departments: omitting
+ * `departmentIds`/`departments` clears them. Only `file.base64Url` is read (a `file.id` is ignored).
+ */
 export type UpdateInteractiveMessagePayload = {
   name?: string
   interactive?: InteractiveMessageContentInput

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

@@ -110,6 +110,50 @@ describe('MeApi', () => {
     })
   })
 
+  describe('getMe with a query', () => {
+    it('serializes the include and keeps the headers', async () => {
+      vi.mocked(client.get).mockResolvedValue(user)
+      const headers = { 'X-Custom': 'h' }
+      await api.getMe({ include: ['roles', 'account'] }, headers)
+      const [url, sent] = vi.mocked(client.get).mock.calls[0] ?? []
+      expect(url).toMatch(/^\/me\?/)
+      expect(url).toContain('include')
+      expect(sent).toBe(headers)
+    })
+  })
+
+  describe('getAccount with where.id', () => {
+    it('serializes the id of the account', async () => {
+      vi.mocked(client.get).mockResolvedValue(account)
+      await api.getAccount({ where: { id: 'acc-1' } })
+      const url = vi.mocked(client.get).mock.calls[0]?.[0] as string
+      expect(url).toMatch(/^\/me\/account\?/)
+      expect(url).toContain('acc-1')
+    })
+  })
+
+  describe('getAccountAmounts with a filter', () => {
+    it('sends the filter as a comma-separated list', async () => {
+      vi.mocked(client.get).mockResolvedValue({ accountId: 'acc-1' })
+      await api.getAccountAmounts({ filter: ['services.amounts', 'users.amounts'] })
+      const url = vi.mocked(client.get).mock.calls[0]?.[0] as string
+      expect(url).toMatch(/^\/me\/get-account-amounts\?/)
+      expect(decodeURIComponent(url)).toContain('services.amounts,users.amounts')
+    })
+
+    it('keeps the headers-only call', async () => {
+      const headers = { 'X-Custom': 'h' }
+      await api.getAccountAmounts(headers)
+      expect(client.get).toHaveBeenCalledWith('/me/get-account-amounts', headers)
+    })
+
+    it('keeps a header that comes as undefined at runtime as a header', async () => {
+      const headers = { Authorization: undefined } as unknown as Record<string, string>
+      await api.getAccountAmounts(headers)
+      expect(client.get).toHaveBeenCalledWith('/me/get-account-amounts', headers)
+    })
+  })
+
   // ── getAccount ───────────────────────────────────────────────────
 
   describe('getAccount', () => {
@@ -252,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)
     })