@ikatec/digisac-api-sdk 4.11.0 → 4.12.0

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/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', () => {

package/src/apis/me/MeApi.ts

@@ -2,6 +2,11 @@ import { BaseApi } from '../../core/BaseApi'
 import type { Account } from '../accounts/types'
 import type { User } from '../users/types'
 import type {
+  AccountAmounts,
+  AccountAmountsQuery,
+  MeAccountQuery,
+  MeQuery,
+  MeStatusResponse,
   RegisterTokenPayload,
   SetOtpSecretKeyPayload,
   TakeoverPayload,
@@ -10,30 +15,74 @@ import type {
   UpdateMeStatusPayload,
 } from './types'
 
+/**
+ * A query object always has an array or an object among its values; the headers only have strings (a header that
+ * comes as `undefined` at runtime stays a header). That tells the two apart in the methods that took only the
+ * headers before and now take a query first.
+ */
+function splitQueryAndHeaders<TQuery extends object>(
+  queryOrHeaders: TQuery | Record<string, string> | undefined,
+  headers: Record<string, string> | undefined,
+): [TQuery | undefined, Record<string, string> | undefined] {
+  const isQuery =
+    !!queryOrHeaders &&
+    Object.values(queryOrHeaders).some((value) => typeof value === 'object' && value !== null)
+  return isQuery
+    ? [queryOrHeaders as TQuery, headers]
+    : [undefined, queryOrHeaders as Record<string, string> | undefined]
+}
+
 export class MeApi extends BaseApi {
   /**
-   * Returns the currently authenticated user, including their roles, departments, and timetable.
+   * Returns the currently authenticated user. Without `include`, the user comes without relations (roles,
+   * departments, timetable, account).
    * @permissions users.view
    */
-  getMe(headers?: Record<string, string>): Promise<User> {
-    return this.client.get<User>('/me', headers)
+  getMe(headers?: Record<string, string>): Promise<User>
+  getMe(query: MeQuery, headers?: Record<string, string>): Promise<User>
+  getMe(
+    queryOrHeaders?: MeQuery | Record<string, string>,
+    headers?: Record<string, string>,
+  ): Promise<User> {
+    const [query, sent] = splitQueryAndHeaders<MeQuery>(queryOrHeaders, headers)
+    return this.client.get<User>(`/me${this.toQueryString(query)}`, sent)
   }
 
-  /** Returns the account associated with the currently authenticated user. */
-  getAccount(headers?: Record<string, string>): Promise<Account> {
-    return this.client.get<Account>('/me/account', headers)
+  /**
+   * Returns the account of the current user. Send `where.id` with the `accountId` of the user (what the web app
+   * does): without it, the route answers 500.
+   */
+  getAccount(headers?: Record<string, string>): Promise<Account>
+  getAccount(query: MeAccountQuery, headers?: Record<string, string>): Promise<Account>
+  getAccount(
+    queryOrHeaders?: MeAccountQuery | Record<string, string>,
+    headers?: Record<string, string>,
+  ): Promise<Account> {
+    const [query, sent] = splitQueryAndHeaders<MeAccountQuery>(queryOrHeaders, headers)
+    return this.client.get<Account>(`/me/account${this.toQueryString(query)}`, sent)
   }
 
   /**
-   * Returns credit and usage amounts for the current account.
-   * Excludes Digisac's own internal credit amounts.
+   * Returns the amounts of the current account named in `filter` (services and/or users). The credit amounts are
+   * never answered here. An account without credits control answers 400.
    */
-  getAccountAmounts(headers?: Record<string, string>): Promise<Record<string, unknown>> {
-    return this.client.get<Record<string, unknown>>('/me/get-account-amounts', headers)
+  getAccountAmounts(headers?: Record<string, string>): Promise<AccountAmounts>
+  getAccountAmounts(
+    query: AccountAmountsQuery,
+    headers?: Record<string, string>,
+  ): Promise<AccountAmounts>
+  getAccountAmounts(
+    queryOrHeaders?: AccountAmountsQuery | Record<string, string>,
+    headers?: Record<string, string>,
+  ): Promise<AccountAmounts> {
+    const [query, sent] = splitQueryAndHeaders<AccountAmountsQuery>(queryOrHeaders, headers)
+    const queryString = query ? this.toQueryString({ filter: query.filter.join(',') }) : ''
+    return this.client.get<AccountAmounts>(`/me/get-account-amounts${queryString}`, sent)
   }
 
   /**
-   * Returns a URL to the Agnus billing/plan management page for the current account.
+   * Returns a URL to the Agnus billing/plan management page for the current account. Calls Agnus (an external
+   * service) and, for accounts without credits control, reports the consumption to it first.
    * @permissions myAccount.myPlan
    */
   getAgnusMyPlanUrl(headers?: Record<string, string>): Promise<{ url: string }> {
@@ -41,39 +90,45 @@ export class MeApi extends BaseApi {
   }
 
   /**
-   * Updates the current user's profile fields such as name, language, and preferences.
-   * If a new password is provided, it is validated against the last 6 password history entries
-   * and all existing access tokens for the user are revoked.
+   * Updates the current user's profile fields such as name, language, and preferences (`data` and `preferences`
+   * replace the stored objects). A new `password` needs `currentPassword` and a recent login, is validated against
+   * the last 6 passwords, and revokes the access tokens with an expiration — including the one of this request.
    */
   updateMe(body: UpdateMePayload, headers?: Record<string, string>): Promise<User> {
     return this.client.put<User, UpdateMePayload>('/me', body, headers)
   }
 
-  /** Updates account-level settings such as name, settings object, wizard progress, and default department. */
+  /**
+   * Updates account-level settings such as name, settings object, wizard progress, and default department. It
+   * applies to the whole account; the default department is required while the tickets are enabled.
+   */
   updateAccount(body: UpdateMeAccountPayload, headers?: Record<string, string>): Promise<Account> {
     return this.client.put<Account, UpdateMeAccountPayload>('/me/account', body, headers)
   }
 
   /**
-   * Updates the presence status of the current user (`online`, `offline`, or `away`).
+   * Updates the presence status of the current user (`online`, `offline`, or `away`) for a `client`.
    * If setting to `online`, validates the user's timetable first — if outside working hours,
-   * the status is set to `offline` instead.
+   * the status is set to `offline` instead. Resolves the status fields of the user.
    */
-  updateStatus(body: UpdateMeStatusPayload, headers?: Record<string, string>): Promise<User> {
-    return this.client.put<User, UpdateMeStatusPayload>('/me/status', body, headers)
+  updateStatus(
+    body: UpdateMeStatusPayload,
+    headers?: Record<string, string>,
+  ): Promise<MeStatusResponse> {
+    return this.client.put<MeStatusResponse, UpdateMeStatusPayload>('/me/status', body, headers)
   }
 
   /**
-   * Extends the grace period for the current account when it has expired or is about to expire.
-   * Returns the updated account.
+   * Extends the grace period for the current account when it has expired or is about to expire, and notifies the
+   * billing webhook. Returns the updated account; an account not in a grace period answers 400.
    */
   extendAccountGracePeriod(headers?: Record<string, string>): Promise<Account> {
     return this.client.post<Account>('/me/account/extend-grace-period', undefined, headers)
   }
 
   /**
-   * Registers a OneSignal push notification token for the current user.
-   * Used to enable push notifications on mobile/web clients.
+   * Registers the push notification tokens of the current user (`data` replaces the whole `data` of the user).
+   * Resolves with no body.
    */
   registerToken(body: RegisterTokenPayload, headers?: Record<string, string>): Promise<void> {
     return this.client.post<void, RegisterTokenPayload>(
@@ -89,8 +144,8 @@ export class MeApi extends BaseApi {
   }
 
   /**
-   * Sets the current user's status to `online` for the given client and emits a takeover event,
-   * which signals other connected sessions to yield control to this one.
+   * Sets the current user's status to `online` for the given client (`'web'` by default) and emits a takeover
+   * event, which signals other connected sessions to yield control to this one. Resolves with no body.
    */
   takeover(body?: TakeoverPayload, headers?: Record<string, string>): Promise<void> {
     return this.client.post<void, TakeoverPayload>('/me/takeover', body, headers)
@@ -107,9 +162,9 @@ export class MeApi extends BaseApi {
   /**
    * Activates OTP (two-factor) authentication for the current user.
    * Requires the `x-digisac-otp` header with a valid TOTP token generated from the secret key
-   * previously set via `setOtpSecretKey`.
+   * previously set via `setOtpSecretKey`. Resolves the text `'OK'`.
    */
-  activateOtpAuth(headers?: Record<string, string>): Promise<boolean> {
-    return this.client.post<boolean>('/me/activate-otp-auth', undefined, headers)
+  activateOtpAuth(headers?: Record<string, string>): Promise<'OK'> {
+    return this.client.post<'OK'>('/me/activate-otp-auth', undefined, headers)
   }
 }

package/src/apis/me/types.ts

@@ -2,9 +2,68 @@ import type { AccountSettings } from '../accounts/types'
 import type { UserPreferences } from '../users/types'
 import type { UserStatus } from '../users/types'
 
+/** The client of the session that sets the status: the web app or the mobile app. */
+export type MeClient = 'web' | 'app'
+
+/** Query of `GET /me`: without `include`, the user comes without relations. */
+export type MeQuery = {
+  include?: (
+    | 'roles'
+    | 'departments'
+    | 'timetable'
+    | 'account'
+    | 'permissions'
+    | 'organizations'
+    | (string & {})
+  )[]
+  attributes?: string[]
+}
+
+/** Query of `GET /me/account`: `where.id` is the id of the account of the user (`accountId` of `getMe`). */
+export type MeAccountQuery = {
+  where: { id: string }
+  include?: string[]
+  attributes?: string[]
+}
+
+export type AccountAmountsFilter = 'services.amounts' | 'users.amounts'
+
+/** Query of `GET /me/get-account-amounts`: which amounts to answer (the credit amounts are never answered). */
+export type AccountAmountsQuery = {
+  filter: AccountAmountsFilter[]
+}
+
+export type UsersAmounts = {
+  planBase: number
+  additional: number
+  totalContracted: number
+  planBaseConsumed: number
+  additionalConsumed: number
+  totalConsumed: number
+  available: number
+}
+
+export type AccountAmounts = {
+  accountId: string
+  servicesAmounts?: Record<string, unknown>
+  usersAmounts?: UsersAmounts
+}
+
+/** What `updateStatus` answers: the status fields of the user, not the whole user. */
+export type MeStatusResponse = {
+  id: string
+  updatedAt: string
+  status: UserStatus
+  clientsStatus: Partial<Record<MeClient, UserStatus>>
+  language: string
+  account?: unknown
+}
+
 export type UpdateMePayload = {
   name?: string
   password?: string
+  /** Required with `password`: the current password of the user. */
+  currentPassword?: string
   language?: string
   preferences?: UserPreferences
   otpAuthActive?: boolean
@@ -14,22 +73,34 @@ export type UpdateMePayload = {
 
 export type UpdateMeStatusPayload = {
   status: UserStatus
-  client?: string
+  /** Required by the backend (400 without it). */
+  client?: MeClient
 }
 
+/**
+ * Merged over the account. The default department is required while the tickets are enabled
+ * (`settings.ticketsEnabled`; 400 `DEFAULT_DEPARTMENT_REQUIRED`).
+ */
 export type UpdateMeAccountPayload = {
   name?: string
   settings?: Partial<AccountSettings>
-  wizardProgress?: string
+  wizardProgress?: 'notStarted' | 'started' | 'finished' | (string & {})
   defaultDepartmentId?: string
+  defaultDepartment?: { id: string }
 }
 
 export type TakeoverPayload = {
-  client?: string
+  /** Defaults to `'web'`. */
+  client?: MeClient
 }
 
 export type SetOtpSecretKeyPayload = {
   secretKey: string
 }
 
-export type RegisterTokenPayload = Record<string, unknown>
+/** The push tokens of the user. `data` REPLACES the whole `data` of the user (it is not merged). */
+export type RegisterTokenPayload = {
+  data?: { oneSignalToken?: string; expoPushToken?: string | null; fromApp?: boolean }
+  /** The backend ignores the call when it is `true`. */
+  isClientUser?: boolean
+}

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

@@ -18,6 +18,10 @@ import type {
 import { CardsApi } from './cards/CardsApi'
 import { ContactsApi } from './contacts/ContactsApi'
 import { InteractiveMessagesApi } from './interactiveMessages/InteractiveMessagesApi'
+import { MeApi } from './me/MeApi'
+import type { AccountAmounts, MeStatusResponse } from './me/types'
+import { TranscriptsApi } from './transcripts/TranscriptsApi'
+import { WhatsappBusinessTemplatesApi } from './whatsappBusinessTemplates/WhatsappBusinessTemplatesApi'
 import type {
   ChannelRedirect,
   CtaUrlInteractiveMessageContent,
@@ -70,7 +74,7 @@ import { NotificationsApi } from './notifications/NotificationsApi'
 import { OrganizationsApi } from './organizations/OrganizationsApi'
 import { PeopleApi } from './people/PeopleApi'
 import { ServicesApi } from './services/ServicesApi'
-import type { UpdateUserPayload } from './users/types'
+import type { UpdateUserPayload, User } from './users/types'
 import { WebhooksApi } from './webhooks/WebhooksApi'
 
 declare const client: ApiClient
@@ -210,7 +214,10 @@ expectError(
 )
 
 declare const interactiveMessage: InteractiveMessage
-expectType<'list' | 'button' | 'cta_url' | 'request_contact_info'>(interactiveMessage.type)
+// `type` is not a field of the backend (deprecated, optional): the type is `interactive.type`.
+expectType<'list' | 'button' | 'cta_url' | 'request_contact_info' | undefined>(
+  interactiveMessage.type,
+)
 if (interactiveMessage.interactive.type === 'cta_url') {
   expectType<CtaUrlInteractiveMessageContent>(interactiveMessage.interactive)
   expectType<string>(interactiveMessage.interactive.action.parameters.url)
@@ -548,6 +555,33 @@ expectType<Promise<boolean>>(new RolesApi(client).deleteById('r-1'))
 expectType<Promise<void>>(new AcceptanceTermsApi(client).deleteById('t-1'))
 expectType<Promise<void>>(new DistributionApi(client).deleteById('d-1'))
 
+// ── QARC-1009: /me, transcripts, interactive messages, templates ─────
+
+expectType<Promise<'OK'>>(new MeApi(client).activateOtpAuth({ 'x-digisac-otp': '123456' }))
+expectType<Promise<MeStatusResponse>>(
+  new MeApi(client).updateStatus({ status: 'offline', client: 'web' }),
+)
+expectType<Promise<AccountAmounts>>(
+  new MeApi(client).getAccountAmounts({ filter: ['users.amounts'] }),
+)
+expectType<Promise<User>>(new MeApi(client).getMe({ include: ['account'] }))
+expectError(new MeApi(client).updateStatus({ status: 'offline', client: 'desktop' }))
+expectType<Promise<void>>(new TranscriptsApi(client).transcribe('m-1'))
+expectType<Promise<{ count: number }>>(new InteractiveMessagesApi(client).count())
+expectType<Promise<{ count: number }>>(new WhatsappBusinessTemplatesApi(client).count())
+expectType<Promise<'OK'>>(new WhatsappBusinessTemplatesApi(client).refreshTemplates())
+expectError(
+  new WhatsappBusinessTemplatesApi(client).create({
+    name: 'qa',
+    internalName: 'QA',
+    components: [],
+    serviceId: 's-1',
+    messageType: 'text_only',
+    language: 'pt_BR',
+    category: 'UTILITY',
+  }),
+)
+
 // ── create/updateById: what each route really answers (QARC-1008) ─────
 
 expectType<Promise<Distribution | undefined>>(

package/src/apis/transcripts/TranscriptsApi.test.ts

@@ -1,7 +1,6 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 import { TranscriptsApi } from './TranscriptsApi'
 import type { ApiClient } from '../../core/ApiClient'
-import type { TranscriptResponse } from './types'
 
 // ── Mock client factory ──────────────────────────────────────────────
 
@@ -28,36 +27,30 @@ describe('TranscriptsApi', () => {
     api = new TranscriptsApi(client)
   })
 
-  // ── getById ──────────────────────────────────────────────────────
-
-  describe('getById', () => {
-    it('calls client.get with /transcripts/:id', async () => {
-      const response: TranscriptResponse = {
-        id: 'msg-1',
-        isTranscribing: true,
-        transcribeError: false,
-      }
-      vi.mocked(client.get).mockResolvedValue(response)
-      const result = await api.getById('msg-1')
+  describe('transcribe', () => {
+    it('calls client.get with /transcripts/:messageId and resolves the empty answer', async () => {
+      vi.mocked(client.get).mockResolvedValue(undefined)
+      await expect(api.transcribe('msg-1')).resolves.toBeUndefined()
       expect(client.get).toHaveBeenCalledWith('/transcripts/msg-1', undefined)
-      expect(result).toEqual(response)
     })
 
     it('forwards custom headers', async () => {
-      const response: TranscriptResponse = {
-        id: 'msg-2',
-        isTranscribing: false,
-        transcribeError: true,
-      }
-      vi.mocked(client.get).mockResolvedValue(response)
       const headers = { 'X-Custom': 'h' }
-      await api.getById('msg-2', headers)
+      await api.transcribe('msg-2', headers)
       expect(client.get).toHaveBeenCalledWith('/transcripts/msg-2', headers)
     })
 
     it('propagates errors from client.get', async () => {
       vi.mocked(client.get).mockRejectedValue(new Error('Not found'))
-      await expect(api.getById('missing')).rejects.toThrow('Not found')
+      await expect(api.transcribe('missing')).rejects.toThrow('Not found')
+    })
+  })
+
+  describe('getById (deprecated)', () => {
+    it('starts the transcription through the same route', async () => {
+      vi.mocked(client.get).mockResolvedValue(undefined)
+      await expect(api.getById('msg-3')).resolves.toBeUndefined()
+      expect(client.get).toHaveBeenCalledWith('/transcripts/msg-3', undefined)
     })
   })
 })

package/src/apis/transcripts/TranscriptsApi.ts

@@ -1,12 +1,21 @@
 import { BaseApi } from '../../core/BaseApi'
-import type { HasGetById } from '../../core/types'
-import type { TranscriptResponse } from './types'
 
-export class TranscriptsApi extends BaseApi implements HasGetById<TranscriptResponse> {
+export class TranscriptsApi extends BaseApi {
   private readonly basePath = '/transcripts'
 
-  /** Triggers audio transcription for a message by dispatching an async job, and marks it as transcribing. */
-  getById(id: string, headers?: Record<string, string>): Promise<TranscriptResponse> {
-    return this.client.get<TranscriptResponse>(`${this.basePath}/${id}`, headers)
+  /**
+   * Starts the transcription of the audio of a message: marks the message as transcribing and dispatches an async
+   * job, which calls the transcription service (AI) and debits the AI credits of the account. Resolves with no body;
+   * the result shows on the message. An unknown message answers 500.
+   */
+  transcribe(messageId: string, headers?: Record<string, string>): Promise<void> {
+    return this.client.get<void>(`${this.basePath}/${messageId}`, headers)
+  }
+
+  /**
+   * @deprecated Not a read: it starts the transcription of the message. Use {@link transcribe}.
+   */
+  getById(id: string, headers?: Record<string, string>): Promise<void> {
+    return this.transcribe(id, headers)
   }
 }

package/src/apis/transcripts/types.ts

@@ -1,3 +1,7 @@
+/**
+ * @deprecated The route answers no body: `TranscriptsApi.transcribe` (and `getById`) resolve `undefined`. The
+ * transcription status shows on the message (`isTranscribing`, `transcribeError`).
+ */
 export type TranscriptResponse = {
   id: string
   isTranscribing: boolean

package/src/apis/whatsappBusinessTemplates/WhatsappBusinessTemplatesApi.test.ts

@@ -0,0 +1,86 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { WhatsappBusinessTemplatesApi } from './WhatsappBusinessTemplatesApi'
+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('WhatsappBusinessTemplatesApi', () => {
+  let client: ReturnType<typeof createMockClient>
+  let api: WhatsappBusinessTemplatesApi
+
+  beforeEach(() => {
+    client = createMockClient()
+    api = new WhatsappBusinessTemplatesApi(client)
+  })
+
+  it('count calls client.get with /whatsapp-business-templates/count', async () => {
+    vi.mocked(client.get).mockResolvedValue({ count: 2 })
+    await expect(api.count()).resolves.toEqual({ count: 2 })
+    expect(client.get).toHaveBeenCalledWith('/whatsapp-business-templates/count', undefined)
+  })
+
+  it('getHsmLimit calls client.get with /whatsapp-business-templates/:accountId/hsmLimit', async () => {
+    const limit = { hsmLimit: 10, hsmUsedLimit: 3, hasLimit: 7 }
+    vi.mocked(client.get).mockResolvedValue(limit)
+    await expect(api.getHsmLimit('acc-1')).resolves.toEqual(limit)
+    expect(client.get).toHaveBeenCalledWith(
+      '/whatsapp-business-templates/acc-1/hsmLimit',
+      undefined,
+    )
+  })
+
+  it('sendToReview posts to /whatsapp-business-templates/:id/send-to-review', async () => {
+    await api.sendToReview('t-1')
+    expect(client.post).toHaveBeenCalledWith(
+      '/whatsapp-business-templates/t-1/send-to-review',
+      undefined,
+      undefined,
+    )
+  })
+
+  it('refreshTemplates posts to /whatsapp-business-templates/refresh-templates and resolves OK', async () => {
+    vi.mocked(client.post).mockResolvedValue('OK')
+    await expect(api.refreshTemplates()).resolves.toBe('OK')
+    expect(client.post).toHaveBeenCalledWith(
+      '/whatsapp-business-templates/refresh-templates',
+      undefined,
+      undefined,
+    )
+  })
+
+  it('resume calls client.get with /whatsapp-business-templates/resume', async () => {
+    vi.mocked(client.get).mockResolvedValue([])
+    await expect(api.resume()).resolves.toEqual([])
+    expect(client.get).toHaveBeenCalledWith('/whatsapp-business-templates/resume', undefined)
+  })
+
+  it('create posts the draft with status and namespace', async () => {
+    const body = {
+      name: 'qa_template',
+      internalName: 'QA',
+      status: '',
+      namespace: '',
+      components: [{ type: 'BODY' as const, text: 'Olá' }],
+      serviceId: 's-1',
+      messageType: 'text_only' as const,
+      language: 'pt_BR' as const,
+      category: 'UTILITY' as const,
+    }
+    await api.create(body)
+    expect(client.post).toHaveBeenCalledWith('/whatsapp-business-templates', body, undefined)
+  })
+})