@ikatec/digisac-api-sdk 4.11.0 → 4.13.0

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,
@@ -67,10 +71,18 @@ import { KnowledgeBaseApi } from './knowledgeBase/KnowledgeBaseApi'
 import { KnowledgeBaseItemApi } from './knowledgeBaseItem/KnowledgeBaseItemApi'
 import { MessagesApi } from './messages/MessagesApi'
 import { NotificationsApi } from './notifications/NotificationsApi'
+import type { NotificationCountsResponse } from './notifications/types'
+import { AbsenceApi } from './absence/AbsenceApi'
+import type { AbsenceReportItem, UnlockAbsenceResponse } from './absence/types'
+import { ActivityLogApi } from './activityLog/ActivityLogApi'
+import { CreditMovementsApi } from './creditMovements/CreditMovementsApi'
+import type { CreditBalances, CreditTotalServices } from './creditMovements/types'
+import { StickersApi } from './stickers/StickersApi'
+import type { Sticker } from './stickers/types'
 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 +222,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 +563,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>>(
@@ -669,3 +711,41 @@ expectAssignable<ApiClient>({
   patch: async <T>() => undefined as T,
   delete: async <T>() => undefined as T,
 })
+
+// ── QARC-1010: notifications, absence, log, knowledge base, credits, stickers ─────
+
+expectType<Promise<NotificationCountsResponse>>(new NotificationsApi(client).count())
+expectType<Promise<string>>(new NotificationsApi(client).count().then(({ count }) => count.total))
+expectError(new NotificationsApi(client).sendAll({ to: 'admin' }))
+expectType<Promise<void>>(new NotificationsApi(client).readMany(['n-1']))
+expectType<Promise<Paginated<AbsenceReportItem>>>(
+  new AbsenceApi(client).report({ filters: { reason: 'x' }, order: 'ASC' }),
+)
+expectType<Promise<UnlockAbsenceResponse>>(new AbsenceApi(client).unlock({}))
+expectError(new AbsenceApi(client).report({ sort: 'name' }))
+expectType<Promise<string>>(
+  new ActivityLogApi(client).exportCsv({ filters: { from: 'a', to: 'b' } }),
+)
+expectAssignable<Parameters<ActivityLogApi['create']>[0]>({
+  resourceType: 'contact',
+  event: 'update',
+})
+expectType<Promise<true>>(new KnowledgeBaseItemApi(client).deleteMany(['i-1']))
+expectError(
+  new KnowledgeBaseApi(client).saveWithItems({ name: 'qa', items: [{ name: 'x', type: 'pdf' }] }),
+)
+expectType<Promise<CreditBalances>>(new CreditMovementsApi(client).balances())
+expectType<Promise<number>>(new CreditMovementsApi(client).balance('sms-wavy'))
+expectType<Promise<CreditTotalServices | undefined>>(
+  new CreditMovementsApi(client).totalServices({
+    filters: { from: 'a', to: 'b', serviceType: 'summary' },
+    page: 1,
+  }),
+)
+expectType<Promise<ArrayBuffer>>(
+  new CreditMovementsApi(client).exportXlsx({ from: 'a', to: 'b', where: { $and: [] } }),
+)
+expectType<Promise<Sticker>>(new StickersApi(client).create({ base64: 'iVBOR', name: 'qa' }))
+expectError(new StickersApi(client).create({ type: 'created' }))
+expectType<Promise<'OK' | false>>(new StickersApi(client).remove('s-1'))
+expectAssignable<Parameters<StickersApi['getMany']>[0]>({ include: ['file'] })

package/src/apis/serviceAccessManagement/ServiceAccessManagementApi.ts

@@ -6,7 +6,10 @@ export class ServiceAccessManagementApi
   extends BaseApi
   implements HasGetMany<ServiceAccessManagement>
 {
-  /** Returns a paginated list of which users have access to which services. */
+  /**
+   * The connections denied to each user (one row per user × connection, written by
+   * `POST /services/:id/access-management`), raw. Filter by the `serviceId` or `userId` you want.
+   */
   getMany(
     query: ListQuery<ServiceAccessManagement> & { paginate: false },
     headers?: Record<string, string>,

package/src/apis/serviceAccessManagement/types.ts

@@ -6,8 +6,11 @@ export type ServiceAccessManagement = {
   serviceId: string
   createdAt: string
   // relationships
+  /** @deprecated Not served: the backend drops every include of this route. */
   user?: User
+  /** @deprecated Not served: the backend drops every include of this route. */
   service?: Service
 }
 
+/** None is served: the backend drops every include of this route. */
 export type ServiceAccessManagementRelationships = 'user' | 'service'

package/src/apis/stickerUsers/StickerUsersApi.ts

@@ -4,7 +4,9 @@ import type { StickerUser } from './types'
 
 export class StickerUsersApi extends BaseApi implements HasGetMany<StickerUser> {
   /**
-   * Returns a paginated list of sticker-user associations with their related file.
+   * The stickers the current user sent recently (`lastSendAt`), paginated; only the `file` include is
+   * served. A row is written when the user sends a message of type `sticker` (in the background, after the
+   * send).
    * @permissions stickers.send
    */
   getMany(

package/src/apis/stickerUsers/types.ts

@@ -10,9 +10,13 @@ export type StickerUser = {
   createdAt: string
   updatedAt: string
   // relationships
+  /** @deprecated Not served: the backend only serves the `file` include. */
   sticker?: Sticker
+  /** @deprecated Not served: the backend only serves the `file` include. */
   user?: User
+  /** The image of the sticker. */
   file?: File
 }
 
+/** The backend serves only `file` (`sticker` and `user` are dropped). */
 export type StickerUserRelationships = 'sticker' | 'user' | 'file'

package/src/apis/stickers/StickersApi.test.ts

@@ -0,0 +1,58 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { StickersApi } from './StickersApi'
+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('StickersApi', () => {
+  let client: ReturnType<typeof createMockClient>
+  let api: StickersApi
+
+  beforeEach(() => {
+    client = createMockClient()
+    api = new StickersApi(client)
+  })
+
+  it('create posts the image to /stickers', async () => {
+    await api.create({ base64: 'iVBOR', name: 'qa' })
+    expect(client.post).toHaveBeenCalledWith(
+      '/stickers',
+      { base64: 'iVBOR', name: 'qa' },
+      undefined,
+    )
+  })
+
+  it('exist serializes the message and the checksum', async () => {
+    vi.mocked(client.get).mockResolvedValue({})
+    await expect(api.exist({ messageId: 'm-1', fileChecksum: 'abc' })).resolves.toEqual({})
+    const url = vi.mocked(client.get).mock.calls[0]?.[0] as string
+    expect(url).toMatch(/^\/stickers\/exist\?/)
+    expect(decodeURIComponent(url)).toContain('"fileChecksum":"abc"')
+  })
+
+  it('add posts the message to /stickers/add', async () => {
+    await api.add('m-1')
+    expect(client.post).toHaveBeenCalledWith('/stickers/add', { messageId: 'm-1' }, undefined)
+  })
+
+  it('remove deletes /stickers/remove/:stickerId', async () => {
+    vi.mocked(client.delete).mockResolvedValue('OK')
+    await expect(api.remove('s-1')).resolves.toBe('OK')
+    expect(client.delete).toHaveBeenCalledWith('/stickers/remove/s-1', undefined)
+  })
+})

package/src/apis/stickers/StickersApi.ts

@@ -1,12 +1,18 @@
 import type { ApiClient } from '../../core/ApiClient'
 import { BaseCrudApi } from '../../core/BaseCrudApi'
 import type { GetByIdQuery } from '../../core/types'
-import type { Sticker, CreateStickerPayload, UpdateStickerPayload } from './types'
+import type {
+  Sticker,
+  CreateStickerPayload,
+  UpdateStickerPayload,
+  StickerExistQuery,
+} from './types'
 
 /**
- * Stickers of the account. The backend serves `GET /stickers` and `POST /stickers` (plus
- * `GET /stickers/exist`, `POST /stickers/add` and `DELETE /stickers/remove/:stickerId`); there is
- * no read by id, update nor `DELETE /stickers/:id`.
+ * Stickers of the account: every user of the account sees them. The backend serves `GET /stickers`,
+ * `POST /stickers`, `GET /stickers/exist`, `POST /stickers/add` and `DELETE /stickers/remove/:stickerId`;
+ * there is no read by id, update nor `DELETE /stickers/:id`. The list accepts only the `file` include.
+ * @permissions stickers.send (list) · stickers.management (create, exist, add, remove)
  */
 export class StickersApi extends BaseCrudApi<Sticker, CreateStickerPayload, UpdateStickerPayload> {
   constructor(client: ApiClient) {
@@ -38,4 +44,40 @@ export class StickersApi extends BaseCrudApi<Sticker, CreateStickerPayload, Upda
   override deleteById(id: string, headers?: Record<string, string>): Promise<Sticker> {
     return super.deleteById(id, headers)
   }
+
+  /**
+   * Finds the sticker of the account that came from the message, or from the file of `fileChecksum` or
+   * `filehash`. Resolves `{ stickerId }`, or `{}` when there is none; without `messageId` it answers 500
+   * `Invalid message ID`.
+   */
+  exist(
+    query: StickerExistQuery,
+    headers?: Record<string, string>,
+  ): Promise<{ stickerId?: string }> {
+    return this.client.get<{ stickerId?: string }>(
+      `${this.basePath}/exist${this.toQueryString(query)}`,
+      headers,
+    )
+  }
+
+  /**
+   * Turns the file of a message of the account into a sticker (`type: 'added'`). Idempotent: a sticker that
+   * already came from the message (or its file) is answered as is, and a removed one is restored. A message
+   * without file answers 500 `Message or file not found`.
+   */
+  add(messageId: string, headers?: Record<string, string>): Promise<Sticker> {
+    return this.client.post<Sticker, { messageId: string }>(
+      `${this.basePath}/add`,
+      { messageId },
+      headers,
+    )
+  }
+
+  /**
+   * Removes a sticker of the account (soft delete; its file stays in the storage) and clears it from the
+   * recent stickers of every user. Resolves the text `'OK'`, or `false` when there is no such sticker.
+   */
+  remove(stickerId: string, headers?: Record<string, string>): Promise<'OK' | false> {
+    return this.client.delete<'OK' | false>(`${this.basePath}/remove/${stickerId}`, headers)
+  }
 }

package/src/apis/stickers/types.ts

@@ -1,8 +1,11 @@
+import type { File } from '../files/types'
 import type { User } from '../users/types'
 
+/** A sticker of the account (every user of the account sees it). */
 export type Sticker = {
   id: string
-  type: string
+  /** `'created'` (uploaded with `create`) or `'added'` (taken from a message with `add`). */
+  type: 'created' | 'added' | (string & {})
   originFileChecksum: string | null
   originFilehash: string | null
   originMessageId: string | null
@@ -10,20 +13,42 @@ export type Sticker = {
   accountId: string
   createdAt: string
   updatedAt: string
-  deletedAt: string | null
+  deletedAt?: string | null
   // relationships
+  /** @deprecated Not served: the backend only serves the `file` include. */
   user?: User
+  /** The image (webp) of the sticker. */
+  file?: File
 }
 
-export type StickerRelationships = 'user'
+/** The backend serves only `file` (`user` is dropped). */
+export type StickerRelationships = 'user' | 'file'
 
+/**
+ * Uploads an image as a sticker: the backend converts it to a 512x512 webp (413 when it ends up too large:
+ * 100KB static, 500KB animated). `base64` without the `data:...;base64,` prefix.
+ */
 export type CreateStickerPayload = {
-  type: string
+  base64: string
+  /** The name of the file (`<name>.webp`). */
+  name: string
+  /** @deprecated Ignored by the backend: a created sticker is always `'created'`. */
+  type?: string
+  /** @deprecated Ignored by the backend: use `add` to take a sticker from a message. */
   originMessageId?: string
+  /** @deprecated Ignored by the backend. */
   originFileChecksum?: string
+  /** @deprecated Ignored by the backend. */
   originFilehash?: string
 }
 
 export type UpdateStickerPayload = {
   type?: string
 }
+
+/** Query of `exist`: finds a sticker of the account by the message or by the file it came from. */
+export type StickerExistQuery = {
+  messageId: string
+  fileChecksum?: string
+  filehash?: string
+}

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

package/src/apis/whatsappBusinessTemplates/WhatsappBusinessTemplatesApi.ts

@@ -1,17 +1,90 @@
 import type { ApiClient } from '../../core/ApiClient'
+import type { ListQuery } from '../../core/types'
 import { BaseCrudApi } from '../../core/BaseCrudApi'
 import type {
   WhatsappBusinessTemplate,
   CreateWhatsappBusinessTemplatePayload,
   UpdateWhatsappBusinessTemplatePayload,
+  WhatsappBusinessTemplateHsmLimit,
 } from './types'
 
+/**
+ * WhatsApp Business templates. Create, update, reads and count are local; `sendToReview`, `refreshTemplates`,
+ * `resume` and the delete of a template of a `whatsapp-business` connection call the provider (Meta, 360Dialog).
+ * `getById` answers `null` for an unknown id.
+ */
 export class WhatsappBusinessTemplatesApi extends BaseCrudApi<
   WhatsappBusinessTemplate,
   CreateWhatsappBusinessTemplatePayload,
-  UpdateWhatsappBusinessTemplatePayload
+  UpdateWhatsappBusinessTemplatePayload,
+  ListQuery<WhatsappBusinessTemplate>,
+  unknown
 > {
   constructor(client: ApiClient) {
     super(client, '/whatsapp-business-templates')
   }
+
+  /**
+   * Counts the templates matching the query.
+   * @permissions hsm.view
+   */
+  count(
+    query?: ListQuery<WhatsappBusinessTemplate>,
+    headers?: Record<string, string>,
+  ): Promise<{ count: number }> {
+    return this.client.get<{ count: number }>(
+      `${this.basePath}/count${this.toQueryString(query)}`,
+      headers,
+    )
+  }
+
+  /**
+   * Reads the template limit of the plan of the account. Send the `accountId` of the current user: the route is
+   * outside the error handler of the backend, so an unknown id gets no answer (the request waits for the timeout).
+   * @permissions hsm.view
+   */
+  getHsmLimit(
+    accountId: string,
+    headers?: Record<string, string>,
+  ): Promise<WhatsappBusinessTemplateHsmLimit> {
+    return this.client.get<WhatsappBusinessTemplateHsmLimit>(
+      `${this.basePath}/${accountId}/hsmLimit`,
+      headers,
+    )
+  }
+
+  /**
+   * Deletes a template. On a `whatsapp-business` connection it goes to the provider (and answers what it answers);
+   * a draft of another connection type is deleted locally (answers the stored template). An unknown id answers 500.
+   * @permissions hsm.view OR hsm.destroy
+   */
+  override deleteById(id: string, headers?: Record<string, string>): Promise<unknown> {
+    return super.deleteById(id, headers)
+  }
+
+  /**
+   * SENDS the template to Meta for approval (through the provider of the connection). An unknown or archived
+   * template answers 500 before anything is sent.
+   * @permissions hsm.view OR hsm.send OR hsm.send.before.expire
+   */
+  sendToReview(id: string, headers?: Record<string, string>): Promise<unknown> {
+    return this.client.post<unknown>(`${this.basePath}/${id}/send-to-review`, undefined, headers)
+  }
+
+  /**
+   * Reads the templates of the connected `whatsapp-business` connections from the provider and syncs them (it may
+   * archive the local templates the provider no longer has). Resolves the text `'OK'`.
+   * @permissions hsm.view
+   */
+  refreshTemplates(headers?: Record<string, string>): Promise<'OK'> {
+    return this.client.post<'OK'>(`${this.basePath}/refresh-templates`, undefined, headers)
+  }
+
+  /**
+   * Reads the template balance from 360Dialog (an external call, when there is a 360Dialog connection).
+   * @permissions hsm.view
+   */
+  resume(headers?: Record<string, string>): Promise<Record<string, unknown>[]> {
+    return this.client.get<Record<string, unknown>[]>(`${this.basePath}/resume`, headers)
+  }
 }