@ikatec/digisac-api-sdk 4.5.1 → 4.7.0

package/src/apis/index.ts

@@ -4,6 +4,7 @@ export * from './accounts'
 export * from './activityLog'
 export * from './answers'
 export * from './authHistory'
+export * from './botSimulators'
 export * from './botVersions'
 export * from './bots'
 export * from './campaigns'

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

@@ -1,15 +1,26 @@
 import { expectAssignable, expectError, expectNotAssignable, expectType } from 'tsd'
 import type { ApiClient } from '../core/ApiClient'
+import type { Paginated } from '../core/types'
+import { AnswersApi } from './answers/AnswersApi'
+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 { CardsApi } from './cards/CardsApi'
 import { ContactsApi } from './contacts/ContactsApi'
 import { KanbanColumnsApi } from './kanbanColumns/KanbanColumnsApi'
 import { PipelineApi } from './pipeline/PipelineApi'
 import type { PermissionName } from './permissions/types'
 import { PersonalAccessTokensApi } from './personalAccessTokens/PersonalAccessTokensApi'
+import { QuestionsApi } from './questions/QuestionsApi'
+import { QuickRepliesApi } from './quickReplies/QuickRepliesApi'
 import { RolesApi } from './roles/RolesApi'
+import { ScheduleApi } from './schedule/ScheduleApi'
+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'
 
@@ -115,3 +126,169 @@ expectType<TicketTransfer[] | undefined>(ticket.ticketTransfers)
 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)
+const botContexts: BotContextInput[] = [
+  {
+    id: '@INIT',
+    triggers: [
+      {
+        trigger: { type: 'MESSAGE_RECEIVED' },
+        rules: [
+          { conditions: [], actions: [{ type: { value: 'SEND_MESSAGE' }, data: { text: 'Oi' } }] },
+        ],
+      },
+    ],
+  },
+]
+bots.create({ name: 'Bot', contexts: botContexts, flowJson: { nodes: [], edges: [] } })
+expectError(bots.create({ name: 'Bot', contexts: botContexts, flowJson: { nodes: [] } }))
+expectError(bots.create({ name: 'Bot' }))
+expectError(bots.create({ name: 'Bot', contexts: { '@INIT': { name: 'Início', triggers: {} } } }))
+expectError(
+  bots.create({
+    name: 'Bot',
+    contexts: [
+      {
+        id: '@INIT',
+        triggers: [
+          {
+            trigger: { type: 'MESSAGE_RECEIVED' },
+            rules: [
+              {
+                conditions: [],
+                actions: [{ type: { value: 'SET_VAR' }, data: { key: 'k', value: 'v' } }],
+              },
+            ],
+          },
+        ],
+      },
+    ],
+  }),
+)
+bots.updateById('b-1', { name: 'Bot', contexts: botContexts, isDraft: true })
+bots.updateById('b-1', { name: 'Bot', onlyUpdateBotName: true })
+bots.create({
+  name: 'Bot',
+  contexts: [
+    {
+      id: '@INIT',
+      triggers: [
+        {
+          trigger: { type: 'TICKET_OPENED' },
+          rules: [
+            {
+              conditions: [],
+              actions: [
+                { type: { value: 'SEND_TERM' }, data: { acceptanceTerms: { id: 'term-1' } } },
+              ],
+            },
+          ],
+        },
+      ],
+    },
+  ],
+})
+expectError(bots.updateById('b-1', { contexts: botContexts }))
+expectError(bots.updateById('b-1', { name: 'Bot' }))
+expectType<Promise<Paginated<Bot>>>(bots.getMany({ paginate: false }))
+expectType<Promise<'OK' | false>>(bots.deleteById('b-1'))
+declare const bot: Bot
+expectType<BotParsedContext[]>(bot.contexts)
+
+// ── bot simulator: the trigger pick needs the id of the selection message ──
+
+const simulator = new BotSimulatorsApi(client)
+simulator.sendEvent('b-1', { type: 'text_contact', text: 'oi' })
+simulator.sendEvent('b-1', { type: 'select_trigger', id: 'm-1', selectedValue: 'TICKET_OPENED' })
+expectError(simulator.sendEvent('b-1', { type: 'select_trigger', selectedValue: 'TICKET_OPENED' }))
+expectError(
+  simulator.sendEvent('b-1', { type: 'select_condition', id: 'm-1', selectedValue: 'yes' }),
+)
+
+// ── questions: duration goes as a string; update is not partial ─────
+
+const questions = new QuestionsApi(client)
+const question = {
+  name: 'NPS',
+  type: 'nps',
+  questionMessage: 'De 0 a 10?',
+  duration: '60',
+  tries: 3,
+  successMessage: 'Obrigado!',
+  invalidMessage: 'De 0 a 10, por favor',
+} as const
+questions.create(question)
+expectType<Promise<'OK'>>(questions.deleteById('q-1'))
+expectError(questions.create({ ...question, duration: 60 }))
+questions.updateById('q-1', { type: 'nps', questionMessage: 'x', duration: 60, tries: 3 })
+expectError(questions.updateById('q-1', { name: 'NPS' }))
+
+// ── answers: the overview NPS is positional ─────────────────────────
+
+const answers = new AnswersApi(client)
+expectType<Promise<AnswersOverview>>(answers.overview({ type: 'nps', periodType: 'closeDate' }))
+expectError(answers.overview({ type: 'custom' }))
+expectType<Promise<'OK'>>(answers.deleteById('a-1'))
+
+// ── schedule: create answers no body; update is not partial ─────────
+
+const schedule = new ScheduleApi(client)
+const scheduled = {
+  scheduledAt: '2026-10-02T12:00:00Z',
+  contactId: 'c-1',
+  departmentId: 'd-1',
+  notes: '',
+}
+expectType<Promise<void>>(schedule.create({ ...scheduled, message: 'Oi' }))
+expectType<Promise<ScheduleRecord>>(schedule.updateById('s-1', scheduled))
+expectError(schedule.updateById('s-1', { message: 'Oi' }))
+expectError(schedule.create({ ...scheduled, files: [{ name: 'a.png' }] }))
+expectError(schedule.create({ ...scheduled, files: [{ id: 'f-1' }] }))
+schedule.updateById('s-1', { ...scheduled, files: [{ id: 'f-1' }] })
+
+// ── ticket topics: create needs the departments ─────────────────────
+
+const topics = new TicketTopicsApi(client)
+topics.create({ name: 'Dúvida', departments: [] })
+expectError(topics.create({ name: 'Dúvida' }))
+expectError(topics.updateById('t-1', { departments: [] }))
+expectType<Promise<'OK'>>(topics.deleteById('t-1'))
+
+// ── quick replies: update fails without the files ───────────────────
+
+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'))

package/src/apis/queryFormat.test.ts

@@ -11,6 +11,7 @@ import { PermissionsApi } from './permissions/PermissionsApi'
 import { ServiceAccessManagementApi } from './serviceAccessManagement/ServiceAccessManagementApi'
 import { StickerUsersApi } from './stickerUsers/StickerUsersApi'
 import { TermsApi } from './terms/TermsApi'
+import { TicketsApi } from './tickets/TicketsApi'
 
 /**
  * Every method that sends a list/get query must serialize it in the client's `queryFormat` and
@@ -34,6 +35,10 @@ 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 ticketsQuery = {
+  where: { isOpen: true },
+  order: [['startedAt', 'DESC'] as ['startedAt', 'DESC']],
+}
 
 type Case = {
   name: string
@@ -273,6 +278,24 @@ const cases: Case[] = [
       return (f ? api.withQueryFormat(f) : api).getById('t1', { attributes: ['id'] })
     },
   },
+  {
+    name: 'TicketsApi.count',
+    path: '/tickets/count',
+    query: ticketsQuery,
+    call: (client, f) => {
+      const api = new TicketsApi(client)
+      return (f ? api.withQueryFormat(f) : api).count(ticketsQuery)
+    },
+  },
+  {
+    name: 'TicketsApi.exportHistory',
+    path: '/tickets/export-history',
+    query: ticketsQuery,
+    call: (client, f) => {
+      const api = new TicketsApi(client)
+      return (f ? api.withQueryFormat(f) : api).exportHistory(ticketsQuery)
+    },
+  },
 ]
 
 const jsonUrl = (path: string, query: object) =>

package/src/apis/questions/QuestionsApi.test.ts

@@ -0,0 +1,49 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type { ApiClient } from '../../core/ApiClient'
+import { QuestionsApi } from './QuestionsApi'
+
+// ── 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('QuestionsApi', () => {
+  let client: ReturnType<typeof createMockClient>
+  let api: QuestionsApi
+
+  beforeEach(() => {
+    client = createMockClient()
+    api = new QuestionsApi(client)
+  })
+
+  it('create sends duration as a string', async () => {
+    const body = {
+      name: 'NPS',
+      type: 'nps',
+      questionMessage: 'De 0 a 10?',
+      duration: '60',
+      tries: 3,
+      successMessage: 'Obrigado!',
+      invalidMessage: 'De 0 a 10',
+    } as const
+    await api.create(body)
+    expect(client.post).toHaveBeenCalledWith('/questions', body, undefined)
+  })
+
+  it('deleteById resolves to the OK of the route', async () => {
+    vi.mocked(client.delete).mockResolvedValue('OK')
+    expect(await api.deleteById('q1')).toBe('OK')
+    expect(client.delete).toHaveBeenCalledWith('/questions/q1', undefined)
+  })
+})

package/src/apis/questions/QuestionsApi.ts

@@ -1,13 +1,32 @@
 import type { ApiClient } from '../../core/ApiClient'
 import { BaseCrudApi } from '../../core/BaseCrudApi'
+import type { ListQuery } from '../../core/types'
 import type { Question, CreateQuestionPayload, UpdateQuestionPayload } from './types'
 
+/**
+ * Evaluation questions (NPS/CSAT), sent to the contact by the `SEND_QUESTION` bot action. The
+ * backend also serves the same routes under the singular `/question` (kept for compatibility).
+ *
+ * Permissions: `evaluation.view` to read; `evaluation.view` OR `evaluation.create`/`update`/
+ * `destroy` to write.
+ */
 export class QuestionsApi extends BaseCrudApi<
   Question,
   CreateQuestionPayload,
-  UpdateQuestionPayload
+  UpdateQuestionPayload,
+  ListQuery<Question>,
+  'OK'
 > {
   constructor(client: ApiClient) {
     super(client, '/questions')
   }
+
+  /**
+   * Deletes a question (soft delete). Resolves to `'OK'`. A question used in a bot answers 403;
+   * the answers of a deleted question leave the overview and the exports.
+   * @permissions evaluation.view OR evaluation.destroy
+   */
+  override deleteById(id: string, headers?: Record<string, string>): Promise<'OK'> {
+    return super.deleteById(id, headers)
+  }
 }

package/src/apis/questions/types.ts

@@ -1,5 +1,6 @@
 import type { Answer } from '../answers/types'
 
+/** `custom` exists in the database, but it never takes an answer (the UI hides it). */
 export type QuestionType = 'nps' | 'csat' | 'custom'
 
 export type Question = {
@@ -7,39 +8,57 @@ export type Question = {
   name: string
   type: QuestionType
   questionMessage: string
+  /** Minutes the contact has to answer. Comes back as a number, although it is sent as a string. */
   duration: number
   tries: number
   successMessage: string
   invalidMessage: string
   reasonMessage: string | null
+  /** Sends `closureMessage` after the evaluation ends. */
+  sendClosureMessage: boolean
+  closureMessage: string | null
   accountId: string
   createdAt: string
   updatedAt: string
   deletedAt: string | null
-  // relationships
+  /** @deprecated Never comes: the route drops every `include` (empty whitelist). */
   answers?: Answer[]
 }
 
+/** @deprecated The route drops every `include` (empty whitelist). */
 export type QuestionRelationships = 'answers'
 
 export type CreateQuestionPayload = {
+  /** Unique in the account (409, unless the account allows duplicate names). */
   name: string
+  /** An unknown type answers 500 (no validation before the database). */
   type: QuestionType
   questionMessage: string
-  duration: number
+  /** Minutes, AS A STRING: a number answers 400 (`Should be of type string.`). */
+  duration: string
+  /** Greater than 0. */
   tries: number
+  /** Not validated by the route: missing answers 500. */
   successMessage: string
+  /** Not validated by the route: missing answers 500. */
   invalidMessage: string
   reasonMessage?: string
+  sendClosureMessage?: boolean
+  /** Required when `sendClosureMessage` is true (400); up to 500 characters. */
+  closureMessage?: string
 }
 
+/** Not partial: `type`, `questionMessage`, `duration` and `tries` are required on update. */
 export type UpdateQuestionPayload = {
+  type: QuestionType
+  questionMessage: string
+  /** Minutes; on update a number is also taken. */
+  duration: string | number
+  tries: number
   name?: string
-  type?: QuestionType
-  questionMessage?: string
-  duration?: number
-  tries?: number
   successMessage?: string
   invalidMessage?: string
   reasonMessage?: string | null
+  sendClosureMessage?: boolean
+  closureMessage?: string | null
 }

package/src/apis/quickReplies/QuickRepliesApi.test.ts

@@ -0,0 +1,69 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type { ApiClient } from '../../core/ApiClient'
+import { QuickRepliesApi } from './QuickRepliesApi'
+import type { QuickRepliesLoadOnDemandQuery } from './types'
+
+// ── 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(),
+  }
+}
+
+const headers = { 'X-Custom': 'value' }
+
+// ── Tests ────────────────────────────────────────────────────────────
+
+describe('QuickRepliesApi', () => {
+  let client: ReturnType<typeof createMockClient>
+  let api: QuickRepliesApi
+
+  beforeEach(() => {
+    client = createMockClient()
+    api = new QuickRepliesApi(client)
+  })
+
+  it('loadOnDemand calls client.get with /quick-replies/load-on-demand and the query', async () => {
+    const query: QuickRepliesLoadOnDemandQuery = { order: [['title', 'ASC']], limit: 20, offset: 0 }
+    vi.mocked(client.get).mockResolvedValue({ data: [], total: 0 })
+    expect(await api.loadOnDemand(query, headers)).toEqual({
+      data: [],
+      total: 0,
+    })
+    expect(client.get).toHaveBeenCalledWith(
+      `/quick-replies/load-on-demand?query=${encodeURIComponent(JSON.stringify(query))}`,
+      headers,
+    )
+  })
+
+  it('create sends the departments, categories and files', async () => {
+    const body = {
+      title: 'Saudação',
+      text: 'Olá!',
+      departmentIds: ['d1'],
+      categoryIds: ['c1'],
+      files: [{ id: 'f1' }],
+    }
+    await api.create(body)
+    expect(client.post).toHaveBeenCalledWith('/quick-replies', body, undefined)
+  })
+
+  it('updateById sends the whole reply', async () => {
+    const body = { title: 'Saudação', text: 'Oi!', files: [] }
+    await api.updateById('q1', body, headers)
+    expect(client.put).toHaveBeenCalledWith('/quick-replies/q1', body, headers)
+  })
+
+  it('deleteById resolves to the OK of the route', async () => {
+    vi.mocked(client.delete).mockResolvedValue('OK')
+    expect(await api.deleteById('q1')).toBe('OK')
+    expect(client.delete).toHaveBeenCalledWith('/quick-replies/q1', undefined)
+  })
+})

package/src/apis/quickReplies/QuickRepliesApi.ts

@@ -1,13 +1,46 @@
 import type { ApiClient } from '../../core/ApiClient'
 import { BaseCrudApi } from '../../core/BaseCrudApi'
-import type { QuickReply, CreateQuickReplyPayload, UpdateQuickReplyPayload } from './types'
+import type { ListQuery } from '../../core/types'
+import type {
+  QuickReply,
+  QuickRepliesLoadOnDemandQuery,
+  QuickRepliesLoadOnDemandResult,
+  CreateQuickReplyPayload,
+  UpdateQuickReplyPayload,
+} from './types'
 
 export class QuickRepliesApi extends BaseCrudApi<
   QuickReply,
   CreateQuickReplyPayload,
-  UpdateQuickReplyPayload
+  UpdateQuickReplyPayload,
+  ListQuery<QuickReply>,
+  'OK'
 > {
   constructor(client: ApiClient) {
     super(client, '/quick-replies')
   }
+
+  /**
+   * Deletes a quick reply (soft delete). Resolves to `'OK'`; an unknown id answers 500.
+   * @permissions quickReplies.view OR quickReplies.destroy
+   */
+  override deleteById(id: string, headers?: Record<string, string>): Promise<'OK'> {
+    return super.deleteById(id, headers)
+  }
+
+  /**
+   * Lists the replies the user can use (no department, or one of the departments of the user),
+   * the way the chat loads them: `limit`/`offset` instead of pages, and `{ data, total }`
+   * instead of the pagination envelope.
+   * @permissions quickReplies.view
+   */
+  loadOnDemand(
+    query?: QuickRepliesLoadOnDemandQuery,
+    headers?: Record<string, string>,
+  ): Promise<QuickRepliesLoadOnDemandResult> {
+    return this.client.get<QuickRepliesLoadOnDemandResult>(
+      `${this.basePath}/load-on-demand${this.toQueryString(query)}`,
+      headers,
+    )
+  }
 }

package/src/apis/quickReplies/types.ts

@@ -1,3 +1,4 @@
+import type { ListQuery } from '../../core/types'
 import type { Category } from '../categories/types'
 import type { Department } from '../departments/types'
 import type { File } from '../files/types'
@@ -11,6 +12,7 @@ export type QuickReply = {
   updatedAt: string
   deletedAt: string | null
   // relationships
+  /** Empty = all departments. */
   departments?: Department[]
   categories?: Category[]
   files?: File[]
@@ -18,12 +20,42 @@ export type QuickReply = {
 
 export type QuickReplyRelationships = 'departments' | 'categories' | 'files'
 
+/**
+ * Files already uploaded through `FilesApi` with `attachedType: 'quickreply.file'` — uploaded
+ * with another type they get the `attachedId` but never show in `files`.
+ */
+export type QuickReplyFilePayload = { id: string }
+
+/** `title` and `text` are each unique in the account (409, unless the account allows duplicate names). */
 export type CreateQuickReplyPayload = {
   title: string
   text: string
+  /** Department ids; omitted = all departments. */
+  departmentIds?: string[]
+  categoryIds?: string[]
+  files?: QuickReplyFilePayload[]
 }
 
+/**
+ * Not partial: `title` and `text` are required, the departments and categories are replaced
+ * (omitted = none), and so are the files.
+ */
 export type UpdateQuickReplyPayload = {
-  title?: string
-  text?: string
+  title: string
+  text: string
+  departmentIds?: string[]
+  categoryIds?: string[]
+  /** The files to keep or attach; `[]` removes all. Required: omitted, the update fails (500). */
+  files: QuickReplyFilePayload[]
+}
+
+/** The query of `loadOnDemand`, passed to the database as is. */
+export type QuickRepliesLoadOnDemandQuery = Pick<
+  ListQuery<QuickReply>,
+  'where' | 'include' | 'order' | 'attributes' | 'limit' | 'offset'
+>
+
+export type QuickRepliesLoadOnDemandResult = {
+  data: QuickReply[]
+  total: number
 }

package/src/apis/schedule/ScheduleApi.test.ts

@@ -0,0 +1,80 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type { ApiClient } from '../../core/ApiClient'
+import { ScheduleApi } from './ScheduleApi'
+
+// ── 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(),
+  }
+}
+
+const headers = { 'X-Custom': 'value' }
+const body = {
+  scheduledAt: '2026-10-02T12:00:00.000Z',
+  contactId: 'c1',
+  departmentId: 'd1',
+  message: 'Lembrete',
+  notes: '',
+}
+
+// ── Tests ────────────────────────────────────────────────────────────
+
+describe('ScheduleApi', () => {
+  let client: ReturnType<typeof createMockClient>
+  let api: ScheduleApi
+
+  beforeEach(() => {
+    client = createMockClient()
+    api = new ScheduleApi(client)
+  })
+
+  it('create calls client.post with /schedule and resolves with no content', async () => {
+    vi.mocked(client.post).mockResolvedValue(undefined)
+    expect(await api.create(body, headers)).toBeUndefined()
+    expect(client.post).toHaveBeenCalledWith('/schedule', body, headers)
+  })
+
+  it('updateById calls client.put with /schedule/:id', async () => {
+    await api.updateById('s1', { ...body, files: [{ id: 'f1' }] })
+    expect(client.put).toHaveBeenCalledWith(
+      '/schedule/s1',
+      { ...body, files: [{ id: 'f1' }] },
+      undefined,
+    )
+  })
+
+  it('deleteById calls client.delete with /schedule/:id', async () => {
+    vi.mocked(client.delete).mockResolvedValue('OK')
+    expect(await api.deleteById('s1', headers)).toBe('OK')
+    expect(client.delete).toHaveBeenCalledWith('/schedule/s1', headers)
+  })
+
+  it('deleteMany sends the ids in where.id of a DELETE body', async () => {
+    vi.mocked(client.request).mockResolvedValue('OK')
+    expect(await api.deleteMany(['s1', 's2'], headers)).toBe('OK')
+    expect(client.request).toHaveBeenCalledWith(
+      'DELETE',
+      '/schedule/many',
+      { where: { id: ['s1', 's2'] } },
+      headers,
+    )
+  })
+
+  it('reads through the inherited getMany', async () => {
+    await api.getMany({ where: { contactId: 'c1' }, paginate: false })
+    expect(client.get).toHaveBeenCalledWith(
+      `/schedule?query=${encodeURIComponent(
+        JSON.stringify({ where: { contactId: 'c1' }, paginate: false }),
+      )}`,
+      undefined,
+    )
+  })
+})