@ikatec/digisac-api-sdk 4.7.0 → 4.9.0

package/src/apis/campaigns/types.ts

@@ -1,6 +1,7 @@
+import type { ListQuery } from '../../core'
+import type { Account } from '../accounts'
 import type { Department } from '../departments'
 import type { File } from '../files'
-import type { Message } from '../messages'
 import type { Service } from '../services'
 import type { Tag } from '../tags'
 import type { User } from '../users'
@@ -22,10 +23,13 @@ export type CampaignStatus =
   | 'preventive_break'
 
 export type CampaignConfig = {
-  /** Minimum interval in ms between sends. */
-  minInterval: number
-  /** Maximum interval in ms between sends. */
-  maxInterval: number
+  /**
+   * Minimum interval in ms between sends. Absent until set (a new campaign answers `config: {}`);
+   * `setIntervalById` stores a number, `updateById` stores what it is sent (a string stays a string).
+   */
+  minInterval?: number | string
+  /** Maximum interval in ms between sends. Same rules as `minInterval`. */
+  maxInterval?: number | string
   /** Column name in the import file used as the contact name. */
   nameField?: string
   /** Column name in the import file used as the phone number. */
@@ -50,11 +54,19 @@ export type Campaign = {
   totalContacts: number | null
   totalContactsImported: number | null
   totalValidContacts: number | null
-  sentContacts: number | null
-  viewedContacts: number | null
-  contactCount: number | null
+  /** @deprecated Never answered: the campaign has no such column. */
+  sentContacts?: number | null
+  /** @deprecated Never answered: the campaign has no such column. */
+  viewedContacts?: number | null
+  /** @deprecated Never answered: read `getContactCount`. */
+  contactCount?: number | null
   mustOpenTicket: boolean
-  marketingIntegration: boolean
+  /** @deprecated Never answered: the campaign transformer leaves the column out. */
+  marketingIntegration?: boolean
+  /** Always `null`: the campaign has no such column (answered by the transformer). */
+  userId?: null
+  /** Only in `getMany`: messages sent and viewed (ack 3). */
+  stats?: { sent: number; viewed: number }
   accountId: string
   serviceId: string
   defaultDepartmentId: string | null
@@ -71,10 +83,29 @@ export type Campaign = {
   createdBy?: User | null
   sentBy?: User | null
   tags?: Tag[]
-  messages?: Message[]
+  messages?: CampaignMessage[]
   importFile?: File | null
 }
 
+/** A message of the campaign (`campaign_messages`), as the `messages` include answers it. */
+export type CampaignMessage = {
+  id: string
+  text: string | null
+  extraOptions: Record<string, unknown> | null
+  hsmId: string | null
+  hsmFileId: string | null
+  accountId: string
+  campaignId: string
+  createdAt: string
+  updatedAt: string
+  deletedAt: string | null
+  // relationships (includes `messages.file`, `messages.hsmFile` and `messages.hsm`)
+  account?: Account
+  file?: File | null
+  hsmFile?: File | null
+  hsm?: WhatsappBusinessTemplate | null
+}
+
 export type CampaignRelationships =
   | 'service'
   | 'defaultDepartment'
@@ -129,6 +160,96 @@ export type CreateCampaignPayload = {
 
 export type UpdateCampaignPayload = Partial<CreateCampaignPayload>
 
+/** The visible states the `status` filter of `getMany` takes (`'scheduled'` is derived from `isScheduled` + `sendsAt`). */
+export type CampaignListStatus = CampaignStatus | 'scheduled'
+
+/**
+ * `getMany` query: the `ListQuery` of a campaign plus the flat filters of the Campaigns screen.
+ * A flat `status` takes precedence over `where.status`. An invalid `status` or date answers 400
+ * `{ error: 'Invalid status' | 'Invalid date', code: 'FILTER_STATUS_INVALID' | 'FILTER_DATE_INVALID' }`.
+ */
+export type CampaignListQuery = ListQuery<Campaign> & {
+  serviceId?: string
+  status?: CampaignListStatus
+  /**
+   * Quality of the HSM template of the messages. `'HIGH'`, `'MEDIUM'` and `'LOW'` only filter when
+   * `include` has `messages` (the filter rewrites that include); without it they are ignored.
+   * `'UNKNOWN'` keeps the campaigns without a rated template.
+   */
+  templateHealth?: 'UNKNOWN' | 'HIGH' | 'MEDIUM' | 'LOW'
+  /** Searches the title (accent-insensitive). */
+  q?: string
+  /**
+   * UTC ISO date-times ending in `Z` (a date alone answers 400 `FILTER_DATE_INVALID`); the days are
+   * taken in the timezone of the account. `sentAt*` filter `startedAt`.
+   */
+  sentAtFrom?: string
+  sentAtTo?: string
+  createdAtFrom?: string
+  createdAtTo?: string
+}
+
+/** The sending status of a contact of the campaign (`not_sent` in the filter also matches `pending`). */
+export type CampaignContactStatus =
+  | 'pending'
+  | 'not_sent'
+  | 'sent'
+  | 'received'
+  | 'read'
+  | 'answered'
+  | 'quality_hold'
+  | 'quality_dropped'
+
+export type CampaignContactsQuery = {
+  page?: number
+  perPage?: number
+  /** Searches the name, the number and the username of the contact. */
+  search?: string
+  contactStatus?: CampaignContactStatus[]
+  failReason?: string
+  sortBy?: 'contactName' | 'contactNumber' | 'contactUsername' | 'status' | 'sentAt' | 'failReason'
+  sortDir?: 'ASC' | 'DESC'
+}
+
+export type CampaignContact = {
+  id: string
+  sentAt: string | null
+  failed: boolean
+  failReason: string | null
+  parameters: unknown
+  contactName: string
+  /** `null` for a contact known only by its username. */
+  contactNumber: string | null
+  contactUsername: string | null
+  contactId: string
+  status: CampaignContactStatus
+}
+
+export type CampaignContactsPage = {
+  data: CampaignContact[]
+  total: number
+  limit: number
+  skip: number
+  currentPage: number
+  lastPage: number
+  from: number
+  to: number
+}
+
+export type CampaignTimelineEvent = {
+  /** `created`, `scheduled`, `started`, `finished` or `status-<status>`. */
+  id: string
+  type: 'created' | 'scheduled' | 'started' | 'finished' | CampaignStatus
+  timestamp: string
+  /** The name of the user who created or sent the campaign, or `'Sistema'`. */
+  actor: string
+  triggerType: 'manual' | 'automatic'
+}
+
+export type ExportCampaignImportErrorsQuery = {
+  delimiter?: ',' | ';' | ':'
+}
+
 export type CampaignStatsInfo = {
   totalValidContacts: number
   totalContacts: number
@@ -136,29 +257,57 @@ export type CampaignStatsInfo = {
   firedSuccessCount: number
   firedFailedCount: number
   totalMessagesCount: number
+  sentMessagesCount: number
   totalFiredCount: number
   firedBlockedByMessageRuleCount: number
 }
 
+/** Messages of the campaign by ack: `error`, `sending` (0), `sentToServer` (1), `received` (2), `viewed` (3), `played` (4). */
 export type CampaignStatsMessages = {
   error: number
+  sending: number
+  sentToServer: number
   received: number
   viewed: number
+  played: number
   answered: number
 }
 
 export type CampaignStats = {
   campaignInfo: CampaignStatsInfo
   messageInfo: CampaignStatsMessages
+  /** @deprecated Kept by the backend for backward compatibility: read `campaignInfo.totalMessagesCount`. */
+  total: number
+  /** @deprecated Read `campaignInfo.sentMessagesCount`. */
+  sent: number
+  /** @deprecated Read `campaignInfo.firedFailedCount`. */
+  failed: number
+  /** @deprecated Read `messageInfo.sending`. */
+  sending: number
+  /** @deprecated Read `messageInfo.sentToServer`. */
+  sentToServer: number
+  /** @deprecated Read `messageInfo.received`. */
+  received: number
+  /** @deprecated Read `messageInfo.viewed`. */
+  viewed: number
+  /** @deprecated Read `messageInfo.played`. */
+  played: number
+  /** @deprecated Read `messageInfo.answered`. */
+  answered: number
+  /** @deprecated Same as `messageInfo.sentToServer`. */
+  sentAndNotReceived: number
 }
 
+/** Whole numbers, `0` or more (numeric strings are accepted). */
 export type SetIntervalPayload = {
-  minInterval: string
-  maxInterval: string
+  minInterval: number | string
+  maxInterval: number | string
 }
 
 export type ExportCampaignResultPayload = {
-  campaignId: string
+  where: { campaignId: string; [key: string]: unknown }
+  /** `'semiColon'` separates the columns with `;` (default `,`). */
+  type?: 'semiColon'
 }
 
 export type ExportTemplateCsvPayload = {
@@ -166,10 +315,12 @@ export type ExportTemplateCsvPayload = {
 }
 
 export type AutoPauseModePayload = {
-  mode: string
+  mode: 'low-health' | 'medium-health' | 'disabled'
 }
 
 export type HsmLimit = {
   hsmLimit: number
   hsmUsedLimit: number
+  /** The HSM messages still available (`0` when none or the plan has no WhatsApp Business); `true` when the limit is disabled. */
+  hasLimit: number | boolean
 }

package/src/apis/interactiveMessages/types.ts

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

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

@@ -6,8 +6,24 @@ import type { AnswersOverview } from './answers/types'
 import { BotSimulatorsApi } from './botSimulators/BotSimulatorsApi'
 import { BotsApi } from './bots/BotsApi'
 import type { Bot, BotContextInput, BotParsedContext } from './bots/types'
+import { CampaignsApi } from './campaigns/CampaignsApi'
+import type {
+  Campaign,
+  CampaignContact,
+  CampaignContactsPage,
+  CampaignMessage,
+  CampaignStats,
+  CampaignTimelineEvent,
+} from './campaigns/types'
 import { CardsApi } from './cards/CardsApi'
 import { ContactsApi } from './contacts/ContactsApi'
+import { InteractiveMessagesApi } from './interactiveMessages/InteractiveMessagesApi'
+import type {
+  ChannelRedirect,
+  CtaUrlInteractiveMessageContent,
+  InteractiveMessage,
+  RequestContactInfoInteractiveMessageContent,
+} from './interactiveMessages'
 import { KanbanColumnsApi } from './kanbanColumns/KanbanColumnsApi'
 import { PipelineApi } from './pipeline/PipelineApi'
 import type { PermissionName } from './permissions/types'
@@ -17,6 +33,12 @@ import { QuickRepliesApi } from './quickReplies/QuickRepliesApi'
 import { RolesApi } from './roles/RolesApi'
 import { ScheduleApi } from './schedule/ScheduleApi'
 import type { ScheduleRecord } from './schedule/types'
+import type {
+  CreateServicePayload,
+  Service,
+  UpdateServicePayload,
+  WebchatServiceData,
+} from './services'
 import { TagsApi } from './tags/TagsApi'
 import { TicketTopicsApi } from './ticketTopics/TicketTopicsApi'
 import { TicketsApi } from './tickets/TicketsApi'
@@ -58,6 +80,154 @@ expectError(tokens.create({ name: 'CI', accessTokenExpiresAt: '2030-01-01T00:00:
 expectError(tokens.create({ name: 'CI', expiresIn: '7d' }))
 expectError(tokens.updateById('t-1', { scope: '*' }))
 
+// ── interactive messages: cta_url and request_contact_info ──────────
+
+const interactiveMessages = new InteractiveMessagesApi(client)
+interactiveMessages.create({
+  name: 'Boleto',
+  interactive: {
+    type: 'cta_url',
+    header: { type: 'text', text: 'Seu boleto' },
+    body: { text: 'Clique para continuar' },
+    footer: { text: 'Digisac' },
+    action: {
+      name: 'cta_url',
+      parameters: { display_text: 'Continuar', url: 'https://wa.me/5541999999999' },
+    },
+    channelRedirect: {
+      enabled: true,
+      channel: 'whatsapp',
+      identifierType: 'phone',
+      identifier: '+5541999999999',
+    },
+  },
+})
+interactiveMessages.create({
+  name: 'Webchat',
+  interactive: {
+    type: 'cta_url',
+    header: { type: 'image' },
+    body: { text: 'Fale conosco' },
+    action: {
+      name: 'cta_url',
+      parameters: { display_text: 'Abrir', url: 'https://webchat.digisac.app/w-1' },
+    },
+    channelRedirect: { enabled: true, channel: 'webchat', serviceId: 's-1' },
+  },
+})
+interactiveMessages.updateById('im-1', {
+  interactive: {
+    type: 'cta_url',
+    body: { text: 'Site' },
+    action: { name: 'cta_url', parameters: { display_text: 'Abrir', url: 'https://exemplo.com' } },
+  },
+})
+interactiveMessages.create({
+  name: 'Dados',
+  interactive: {
+    type: 'request_contact_info',
+    body: { text: 'Compartilhe seu contato' },
+    action: { name: 'request_contact_info' },
+  },
+})
+// `channelRedirect` is a sibling of `action`, never inside `action.parameters`
+expectError(
+  interactiveMessages.create({
+    name: 'Boleto',
+    interactive: {
+      type: 'cta_url',
+      body: { text: 'Clique' },
+      action: {
+        name: 'cta_url',
+        parameters: {
+          display_text: 'Continuar',
+          url: 'https://wa.me/5541999999999',
+          channelRedirect: { enabled: true },
+        },
+      },
+    },
+  }),
+)
+expectError(
+  interactiveMessages.create({
+    name: 'Boleto',
+    interactive: {
+      type: 'cta_url',
+      body: { text: 'Clique' },
+      action: { name: 'cta_url', parameters: { url: 'https://exemplo.com' } },
+    },
+  }),
+)
+expectError(
+  interactiveMessages.create({
+    name: 'Boleto',
+    interactive: {
+      type: 'cta_url',
+      body: { text: 'Clique' },
+      action: { name: 'cta_url', parameters: { display_text: 'Abrir', url: 'https://x.com' } },
+      channelRedirect: { enabled: true, channel: 'email' },
+    },
+  }),
+)
+// WhatsApp refuses header and footer on request_contact_info
+expectError(
+  interactiveMessages.create({
+    name: 'Dados',
+    interactive: {
+      type: 'request_contact_info',
+      header: { type: 'text', text: 'Olá' },
+      body: { text: 'Compartilhe seu contato' },
+      action: { name: 'request_contact_info' },
+    },
+  }),
+)
+
+declare const interactiveMessage: InteractiveMessage
+expectType<'list' | 'button' | 'cta_url' | 'request_contact_info'>(interactiveMessage.type)
+if (interactiveMessage.interactive.type === 'cta_url') {
+  expectType<CtaUrlInteractiveMessageContent>(interactiveMessage.interactive)
+  expectType<string>(interactiveMessage.interactive.action.parameters.url)
+  expectType<ChannelRedirect | undefined>(interactiveMessage.interactive.channelRedirect)
+}
+if (interactiveMessage.interactive.type === 'request_contact_info') {
+  expectType<RequestContactInfoInteractiveMessageContent>(interactiveMessage.interactive)
+}
+expectAssignable<ChannelRedirect>({ enabled: false })
+expectAssignable<ChannelRedirect>({
+  enabled: true,
+  channel: 'telegram',
+  identifierType: 'botName',
+  identifier: '@lojabot',
+})
+expectNotAssignable<ChannelRedirect>({ enabled: true, channel: 'telegram', identifierType: 'user' })
+expectNotAssignable<ChannelRedirect>({ channel: 'whatsapp' })
+
+// ── services: data.webchat of a Webchat service ─────────────────────
+
+declare const service: Service
+expectType<WebchatServiceData | undefined>(service.data.webchat)
+expectType<string | undefined>(service.data.webchat?.id)
+expectType<string | null | undefined>(service.data.webchat?.instagram)
+expectAssignable<WebchatServiceData>({})
+expectAssignable<WebchatServiceData>({ id: 'w-1', phone: '5541999999999', telegram: null })
+expectNotAssignable<WebchatServiceData>({ id: 1 })
+// values the web forms already store: the new form sends `null`, the legacy one `{}`
+expectType<{ id?: string; name?: string } | null | undefined>(service.data.webchat?.customField)
+expectAssignable<WebchatServiceData>({ customField: null })
+expectAssignable<WebchatServiceData>({ customField: {} })
+expectAssignable<WebchatServiceData>({ customField: { id: 'cf-1', name: 'CPF' } })
+expectAssignable<WebchatServiceData>({ name: null, googleId: null, file: {} })
+expectAssignable<WebchatServiceData>({
+  file: { base64Url: 'aGVsbG8=', mimetype: 'image/png', fileName: 'perfil.png' },
+})
+expectAssignable<WebchatServiceData>({ custom: { webchatBalloonText: null } })
+expectNotAssignable<WebchatServiceData>({ customField: 'cf-1' })
+// the same shape types the `data` of the create and update payloads
+expectAssignable<CreateServicePayload['data']>({
+  webchat: { customField: null, googleId: null, name: null, custom: { webchatBalloonText: null } },
+})
+expectAssignable<UpdateServicePayload['data']>({ webchat: { customField: {}, file: {} } })
+
 // ── users: the dedicated archive route takes a boolean, not a date ──
 
 const users = new UsersApi(client)
@@ -292,3 +462,38 @@ const quickReplies = new QuickRepliesApi(client)
 quickReplies.updateById('r-1', { title: 'Oi', text: 'Olá', files: [] })
 expectError(quickReplies.updateById('r-1', { title: 'Oi', text: 'Olá' }))
 expectType<Promise<'OK'>>(quickReplies.deleteById('r-1'))
+
+// ── campaigns: the actions answer booleans or 'OK'; the CSV export takes a where ──
+
+const campaigns = new CampaignsApi(client)
+expectType<Promise<Campaign>>(campaigns.sendById('c-1'))
+expectType<Promise<boolean>>(campaigns.pauseById('c-1'))
+expectType<Promise<boolean>>(campaigns.resumeById('c-1'))
+expectType<Promise<'OK' | false>>(campaigns.retryById('c-1'))
+expectType<Promise<boolean>>(campaigns.setIntervalById('c-1', { minInterval: 5, maxInterval: 10 }))
+expectType<Promise<CampaignStats>>(campaigns.getStatsById('c-1'))
+expectType<Promise<CampaignTimelineEvent[]>>(campaigns.getTimeline('c-1'))
+expectType<Promise<CampaignContactsPage>>(
+  campaigns.getContacts('c-1', { contactStatus: ['not_sent', 'read'], sortDir: 'DESC' }),
+)
+expectType<Promise<number>>(campaigns.countReadyByService('s-1'))
+expectType<Promise<'OK'>>(campaigns.deleteById('c-1'))
+expectType<Promise<true>>(campaigns.deleteMany(['c-1']))
+expectType<Promise<string>>(campaigns.exportCampaignResult({ where: { campaignId: 'c-1' } }))
+expectType<Promise<string>>(campaigns.exportImportErrors('c-1', { delimiter: ';' }))
+// the export takes the campaign in `where`: `{ campaignId }` answers 400
+expectError(campaigns.exportCampaignResult({ campaignId: 'c-1' }))
+expectError(campaigns.setAutoPauseMode({ mode: 'auto' }))
+campaigns.getMany({
+  status: 'scheduled',
+  q: 'Black Friday',
+  createdAtFrom: '2026-10-01T00:00:00.000Z',
+})
+expectError(campaigns.getMany({ status: 'sending' }))
+declare const listed: Campaign
+expectType<{ sent: number; viewed: number } | undefined>(listed.stats)
+// a new campaign answers `config: {}`; the include answers the campaign messages, not chat messages
+expectType<number | string | undefined>(listed.config.minInterval)
+expectType<CampaignMessage[] | undefined>(listed.messages)
+declare const campaignContact: CampaignContact
+expectType<string | null>(campaignContact.contactNumber)

package/src/apis/payloads.test.ts

@@ -1,5 +1,6 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 import type { ApiClient } from '../core/ApiClient'
+import { InteractiveMessagesApi } from './interactiveMessages/InteractiveMessagesApi'
 import { PersonalAccessTokensApi } from './personalAccessTokens/PersonalAccessTokensApi'
 import { RolesApi } from './roles/RolesApi'
 import { TimetableApi } from './timetable/TimetableApi'
@@ -78,4 +79,44 @@ describe('payloads sent to the backend', () => {
       )
     })
   })
+
+  describe('InteractiveMessagesApi', () => {
+    it('create sends a cta_url with channelRedirect next to action, not inside parameters', async () => {
+      const body = {
+        name: 'Boleto',
+        departments: [{ id: 'd-1' }],
+        interactive: {
+          type: 'cta_url' as const,
+          header: { type: 'text' as const, text: 'Seu boleto' },
+          body: { text: 'Clique para continuar' },
+          footer: { text: 'Digisac' },
+          action: {
+            name: 'cta_url' as const,
+            parameters: { display_text: 'Continuar', url: 'https://wa.me/5541999999999' },
+          },
+          channelRedirect: {
+            enabled: true,
+            channel: 'whatsapp' as const,
+            identifierType: 'phone' as const,
+            identifier: '+5541999999999',
+          },
+        },
+      }
+      await new InteractiveMessagesApi(client).create(body)
+      expect(client.post).toHaveBeenCalledWith('/interactive-messages', body, undefined)
+    })
+
+    it('create sends a request_contact_info with only body and action', async () => {
+      const body = {
+        name: 'Dados',
+        interactive: {
+          type: 'request_contact_info' as const,
+          body: { text: 'Compartilhe seu contato' },
+          action: { name: 'request_contact_info' as const },
+        },
+      }
+      await new InteractiveMessagesApi(client).create(body)
+      expect(client.post).toHaveBeenCalledWith('/interactive-messages', body, undefined)
+    })
+  })
 })

package/src/apis/queryFormat.test.ts

@@ -4,6 +4,7 @@ import type { ApiClient } from '../core/ApiClient'
 import { BaseApiClient } from '../core/BaseApiClient'
 import type { QueryFormat } from '../core/queryString'
 import { AuthHistoryApi } from './authHistory/AuthHistoryApi'
+import { CampaignsApi } from './campaigns/CampaignsApi'
 import { ContactsApi } from './contacts/ContactsApi'
 import { DashboardApi } from './dashboard/DashboardApi'
 import { NowApi } from './now/NowApi'
@@ -35,6 +36,12 @@ const listQuery = { where: { name: 'x' }, page: 2, perPage: 5 }
 const getQuery = { attributes: ['id'] }
 /** `Permission.name` is a union of the catalog names, so the permissions case filters by a real one. */
 const permissionsQuery = { where: { name: 'chat' as const }, page: 2, perPage: 5 }
+const campaignsQuery = { status: 'scheduled' as const, q: 'Black Friday', page: 2, perPage: 5 }
+const campaignContactsQuery = {
+  contactStatus: ['not_sent' as const],
+  sortBy: 'sentAt' as const,
+  page: 2,
+}
 const ticketsQuery = {
   where: { isOpen: true },
   order: [['startedAt', 'DESC'] as ['startedAt', 'DESC']],
@@ -49,6 +56,24 @@ type Case = {
 }
 
 const cases: Case[] = [
+  {
+    name: 'CampaignsApi.getMany (flat filters)',
+    path: '/campaigns',
+    query: campaignsQuery,
+    call: (client, f) => {
+      const api = new CampaignsApi(client)
+      return (f ? api.withQueryFormat(f) : api).getMany(campaignsQuery)
+    },
+  },
+  {
+    name: 'CampaignsApi.getContacts',
+    path: '/campaigns/c1/contacts',
+    query: campaignContactsQuery,
+    call: (client, f) => {
+      const api = new CampaignsApi(client)
+      return (f ? api.withQueryFormat(f) : api).getContacts('c1', campaignContactsQuery)
+    },
+  },
   {
     name: 'ContactsApi.getMany (BaseCrudApi)',
     path: '/contacts',