@ikatec/digisac-api-sdk 4.6.0 → 4.8.0

package/src/apis/campaigns/CampaignsApi.ts

@@ -1,10 +1,16 @@
+import qs from 'qs'
 import type { ApiClient } from '../../core'
 import { BaseCrudApi } from '../../core'
 import type {
   AutoPauseModePayload,
   Campaign,
+  CampaignContactsPage,
+  CampaignContactsQuery,
+  CampaignListQuery,
   CampaignStats,
+  CampaignTimelineEvent,
   CreateCampaignPayload,
+  ExportCampaignImportErrorsQuery,
   ExportCampaignResultPayload,
   ExportTemplateCsvPayload,
   HsmLimit,
@@ -12,79 +18,195 @@ import type {
   UpdateCampaignPayload,
 } from './types'
 
+/**
+ * Campaigns (mass sending). Every `/campaigns` route requires the campaigns feature in the plan of
+ * the account.
+ * `getMany` takes the `where` of a `ListQuery` and the flat filters of the Campaigns screen (see
+ * {@link CampaignListQuery}); `getById` of an unknown id resolves `null`. `deleteById` answers the
+ * text `'OK'`. `getMany({ paginate: false })` answers 400 `FILTER_PARAM_INVALID` with the default
+ * `'json'` query format (the route only takes `paginate` as a string): use `withQueryFormat('qs')`.
+ */
 export class CampaignsApi extends BaseCrudApi<
   Campaign,
   CreateCampaignPayload,
-  UpdateCampaignPayload
+  UpdateCampaignPayload,
+  CampaignListQuery,
+  'OK'
 > {
   constructor(client: ApiClient) {
     super(client, '/campaigns')
+  }
+
+  /**
+   * Starts sending the campaign: answers it as `processing` (an `import_error` campaign goes back
+   * to `importing_contacts`). It becomes `done` once every contact is fired.
+   * @permissions campaigns.view
+   */
+  sendById(id: string, headers?: Record<string, string>): Promise<Campaign> {
+    return this.client.post<Campaign>(`${this.basePath}/${id}/send`, undefined, headers)
+  }
+
+  /**
+   * Sets the campaign as `paused` and answers `true`. An unknown id answers 500.
+   * @permissions campaigns.view
+   */
+  pauseById(id: string, headers?: Record<string, string>): Promise<boolean> {
+    return this.client.post<boolean>(`${this.basePath}/${id}/pause`, undefined, headers)
+  }
+
+  /**
+   * Sets the campaign back to `processing` and answers `true`. An unknown id answers 500.
+   * @permissions campaigns.view
+   */
+  resumeById(id: string, headers?: Record<string, string>): Promise<boolean> {
+    return this.client.post<boolean>(`${this.basePath}/${id}/resume`, undefined, headers)
+  }
+
+  /**
+   * Fires again the messages that failed: sets them as pending and the campaign as `processing`.
+   * Answers the text `'OK'` (also when nothing failed, and then the status does not change); an
+   * unknown id answers `false` (status 200).
+   * @permissions campaigns.view
+   */
+  retryById(id: string, headers?: Record<string, string>): Promise<'OK' | false> {
+    return this.client.post<'OK' | false>(`${this.basePath}/${id}/retry`, undefined, headers)
+  }
+
+  /**
+   * Creates a copy of the campaign (`ready`, same title, messages and tags), answered without the
+   * messages. An unknown id answers 500.
+   * @permissions campaigns.view
+   */
+  duplicateById(id: string, headers?: Record<string, string>): Promise<Campaign> {
+    return this.client.post<Campaign>(`${this.basePath}/${id}/duplicate`, undefined, headers)
+  }
 
-    this.sendById = this.sendById.bind(this)
-    this.pauseById = this.pauseById.bind(this)
-    this.resumeById = this.resumeById.bind(this)
-    this.duplicateById = this.duplicateById.bind(this)
-    this.getStatsById = this.getStatsById.bind(this)
-    this.setIntervalById = this.setIntervalById.bind(this)
-    this.getContactCount = this.getContactCount.bind(this)
-    this.setAutoPauseMode = this.setAutoPauseMode.bind(this)
-    this.exportCampaignResult = this.exportCampaignResult.bind(this)
-    this.exportTemplateCsv = this.exportTemplateCsv.bind(this)
-    this.getHsmLimit = this.getHsmLimit.bind(this)
+  /** Returns the send, delivery and interaction statistics of the campaign. */
+  getStatsById(id: string, headers?: Record<string, string>): Promise<CampaignStats> {
+    return this.client.get<CampaignStats>(`${this.basePath}/${id}/stats`, headers)
   }
 
-  /** Starts sending messages for the given campaign. */
-  sendById(id: string): Promise<Campaign> {
-    return this.client.post<Campaign>(`${this.basePath}/${id}/send`)
+  /**
+   * Returns the events of the campaign (created, scheduled, started, finished and the last
+   * interruption), the most recent first.
+   */
+  getTimeline(id: string, headers?: Record<string, string>): Promise<CampaignTimelineEvent[]> {
+    return this.client.get<CampaignTimelineEvent[]>(`${this.basePath}/${id}/timeline`, headers)
   }
 
-  /** Pauses a campaign that is currently sending. */
-  pauseById(id: string): Promise<Campaign> {
-    return this.client.post<Campaign>(`${this.basePath}/${id}/pause`)
+  /**
+   * Returns a page of the contacts of the campaign with their sending status (15 per page by
+   * default). An unknown id answers an empty page.
+   */
+  getContacts(
+    id: string,
+    query?: CampaignContactsQuery,
+    headers?: Record<string, string>,
+  ): Promise<CampaignContactsPage> {
+    return this.client.get<CampaignContactsPage>(
+      `${this.basePath}/${id}/contacts${this.toQueryString(query)}`,
+      headers,
+    )
   }
 
-  /** Resumes a previously paused campaign. */
-  resumeById(id: string): Promise<Campaign> {
-    return this.client.post<Campaign>(`${this.basePath}/${id}/resume`)
+  /**
+   * Sets the min/max interval between the sends (whole numbers, `0` or more) and answers `true`.
+   * An unknown id answers 500.
+   * @permissions campaigns.view
+   */
+  setIntervalById(
+    id: string,
+    data: SetIntervalPayload,
+    headers?: Record<string, string>,
+  ): Promise<boolean> {
+    return this.client.post<boolean, SetIntervalPayload>(
+      `${this.basePath}/${id}/interval`,
+      data,
+      headers,
+    )
   }
 
-  /** Creates a copy of an existing campaign. */
-  duplicateById(id: string): Promise<Campaign> {
-    return this.client.post<Campaign>(`${this.basePath}/${id}/duplicate`)
+  /** Returns the number of contacts targeted by the campaign. */
+  getContactCount(id: string, headers?: Record<string, string>): Promise<number> {
+    return this.client.get<number>(`${this.basePath}/${id}/contactCount`, headers)
   }
 
-  /** Returns send/delivery/view statistics for a campaign. */
-  getStatsById(id: string): Promise<CampaignStats> {
-    return this.client.get<CampaignStats>(`${this.basePath}/${id}/stats`)
+  /** Counts the `ready` campaigns of a connection. An unknown id counts 0. */
+  countReadyByService(serviceId: string, headers?: Record<string, string>): Promise<number> {
+    return this.client.get<number>(`${this.basePath}/count-ready/${serviceId}`, headers)
   }
 
-  /** Updates the min/max send interval for a campaign. */
-  setIntervalById(id: string, data: SetIntervalPayload): Promise<Campaign> {
-    return this.client.post<Campaign, SetIntervalPayload>(`${this.basePath}/${id}/interval`, data)
+  /**
+   * Sets the auto-pause mode of the campaigns of the account (`settings.campaign`). Answers the
+   * text `'OK'`, or `false` when the account was not updated.
+   */
+  setAutoPauseMode(
+    data: AutoPauseModePayload,
+    headers?: Record<string, string>,
+  ): Promise<'OK' | false> {
+    return this.client.put<'OK' | false, AutoPauseModePayload>(
+      `${this.basePath}/autoPauseMode`,
+      data,
+      headers,
+    )
   }
 
-  /** Returns the total number of contacts targeted by a campaign. */
-  getContactCount(id: string): Promise<number> {
-    return this.client.get<number>(`${this.basePath}/${id}/contactCount`)
+  /**
+   * Exports the contacts of the campaign and their sending result as CSV (13 columns in the
+   * language of the user; `,`, or `;` with `type: 'semiColon'`), streamed without a Content-Type.
+   */
+  exportCampaignResult(
+    data: ExportCampaignResultPayload,
+    headers?: Record<string, string>,
+  ): Promise<string> {
+    return this.client.post<string, ExportCampaignResultPayload>(
+      `${this.basePath}/export/csv`,
+      data,
+      headers,
+    )
   }
 
-  /** Configures the auto-pause behavior for campaigns. */
-  setAutoPauseMode(data: AutoPauseModePayload): Promise<unknown> {
-    return this.client.put(`${this.basePath}/autoPauseMode`, data)
+  /** Exports the CSV (`;`) to fill in the contacts of a campaign of the given HSM template. */
+  exportTemplateCsv(
+    data: ExportTemplateCsvPayload,
+    headers?: Record<string, string>,
+  ): Promise<string> {
+    return this.client.post<string, ExportTemplateCsvPayload>(
+      `${this.basePath}/exportTemplate`,
+      data,
+      headers,
+    )
   }
 
-  /** Exports campaign send results as a CSV file. */
-  exportCampaignResult(data: ExportCampaignResultPayload): Promise<unknown> {
-    return this.client.post(`${this.basePath}/export/csv`, data)
+  /**
+   * Exports the rows of the import file that were not imported (invalid number, unknown or
+   * ambiguous username) as CSV: line, name, number, username and reason.
+   */
+  exportImportErrors(
+    id: string,
+    query?: ExportCampaignImportErrorsQuery,
+    headers?: Record<string, string>,
+  ): Promise<string> {
+    const queryString = query?.delimiter ? `?${qs.stringify({ delimiter: query.delimiter })}` : ''
+    return this.client.get<string>(`${this.basePath}/${id}/import-errors${queryString}`, headers)
   }
 
-  /** Exports a CSV template for importing contacts into an HSM campaign. */
-  exportTemplateCsv(data: ExportTemplateCsvPayload): Promise<unknown> {
-    return this.client.post(`${this.basePath}/exportTemplate`, data)
+  /**
+   * Deletes the campaigns of the given ids and answers `true` (unknown ids are skipped). No id, or
+   * an id that is not a UUID, answers 400 `{ error: 'Invalid ids', code: 'INVALID_IDS' }`.
+   * @permissions campaigns.view OR campaigns.destroy
+   */
+  deleteMany(ids: string[], headers?: Record<string, string>): Promise<true> {
+    return this.client.request<true, { ids: string[] }>(
+      'DELETE',
+      `${this.basePath}/delete-many`,
+      { ids },
+      headers,
+    )
   }
 
-  /** Returns the HSM message usage and limit for an account. */
-  getHsmLimit(accountId: string): Promise<HsmLimit> {
-    return this.client.get<HsmLimit>(`/whatsapp-business-templates/${accountId}/hsmLimit`)
+  /** Returns the HSM message usage and limit of an account. */
+  getHsmLimit(accountId: string, headers?: Record<string, string>): Promise<HsmLimit> {
+    return this.client.get<HsmLimit>(`/whatsapp-business-templates/${accountId}/hsmLimit`, headers)
   }
 }

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/payloads.test-d.ts

@@ -6,6 +6,15 @@ 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 { KanbanColumnsApi } from './kanbanColumns/KanbanColumnsApi'
@@ -20,7 +29,7 @@ import type { ScheduleRecord } from './schedule/types'
 import { TagsApi } from './tags/TagsApi'
 import { TicketTopicsApi } from './ticketTopics/TicketTopicsApi'
 import { TicketsApi } from './tickets/TicketsApi'
-import type { Ticket, TicketTransfer } from './tickets/types'
+import type { Ticket, TicketTransfer, TicketsCount, TicketsCounts } from './tickets/types'
 import { TimetableApi } from './timetable/TimetableApi'
 import { UsersApi } from './users/UsersApi'
 
@@ -127,6 +136,35 @@ declare const transfer: TicketTransfer
 expectType<string | null>(transfer.byUserId)
 expectType<'opened' | 'transferred' | 'closed' | null>(transfer.action)
 
+// ── tickets: the counts, the first waiting time and the exports ─────
+
+expectType<Promise<TicketsCount>>(tickets.count({ where: { isOpen: true } }))
+expectType<Promise<TicketsCounts>>(tickets.count({ queries: [{ where: { isOpen: true } }] }))
+expectType<Promise<TicketsCount>>(tickets.countPost({ where: { isOpen: true }, query: {} }))
+expectType<Promise<TicketsCounts>>(
+  tickets.countPost({ query: { queries: [{ where: { isOpen: false } }] } }),
+)
+// `query` is required: without it the route answers 500
+expectError(tickets.countPost({ where: { isOpen: true } }))
+expectType<Promise<number>>(tickets.countOpenByService('s-1'))
+expectType<Promise<number>>(tickets.countOpenByDepartment('d-1'))
+expectType<Promise<number>>(tickets.countOpenByUser('u-1'))
+expectType<Promise<string>>(tickets.getFirstWaitingTime('t-1'))
+expectType<Promise<string>>(tickets.exportTxt('202610061675'))
+expectType<Promise<string>>(
+  tickets.exportHistory({ include: [{ model: 'contact', include: ['service'] }] }),
+)
+expectType<Promise<void>>(tickets.closeMany({ ids: ['t-1'], comments: 'Resolved' }))
+expectType<Promise<void>>(
+  tickets.closeMany({
+    allContactsSelected: true,
+    query: { query: '{}' },
+    ticketTopicIds: ['tt-1'],
+  }),
+)
+tickets.getById('t-1', { include: ['ticketTopics', 'firstMessage', 'account'] })
+expectType<string | undefined>(ticket.metrics.maxWaitingTimeDepartmentId)
+
 // ── bots: the /bots routes take and return the contexts as a list ───
 
 const bots = new BotsApi(client)
@@ -263,3 +301,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)