@ikatec/digisac-api-sdk 4.5.1 → 4.6.0

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

package/src/apis/schedule/ScheduleApi.ts

@@ -1,13 +1,66 @@
 import type { ApiClient } from '../../core/ApiClient'
-import { BaseCrudApi } from '../../core/BaseCrudApi'
-import type { Schedule, CreateSchedulePayload, UpdateSchedulePayload } from './types'
-
-export class ScheduleApi extends BaseCrudApi<
+import { BaseReadApi } from '../../core/BaseReadApi'
+import type {
   Schedule,
+  ScheduleRecord,
   CreateSchedulePayload,
-  UpdateSchedulePayload
-> {
+  UpdateSchedulePayload,
+} from './types'
+
+/**
+ * Scheduled messages. Create answers no body and update answers the stored record, so this
+ * class extends `BaseReadApi` and writes its own create/update/delete.
+ */
+export class ScheduleApi extends BaseReadApi<Schedule> {
   constructor(client: ApiClient) {
     super(client, '/schedule')
   }
+
+  /**
+   * Creates a schedule. Resolves with NO CONTENT: find it back with `getOne` (e.g. by
+   * `contactId` and `scheduledAt`).
+   * @permissions schedule.create
+   */
+  create(body: CreateSchedulePayload, headers?: Record<string, string>): Promise<void> {
+    return this.client.post<void, CreateSchedulePayload>(this.basePath, body, headers)
+  }
+
+  /**
+   * Updates a schedule. Resolves to the stored record, without relationships. An unknown id
+   * answers 500.
+   * @permissions schedule.view OR schedule.update
+   */
+  updateById(
+    id: string,
+    body: UpdateSchedulePayload,
+    headers?: Record<string, string>,
+  ): Promise<ScheduleRecord> {
+    return this.client.put<ScheduleRecord, UpdateSchedulePayload>(
+      `${this.basePath}/${id}`,
+      body,
+      headers,
+    )
+  }
+
+  /**
+   * Deletes a schedule (soft delete). Resolves to `'OK'`; an unknown id answers 500.
+   * @permissions schedule.view OR schedule.destroy
+   */
+  deleteById(id: string, headers?: Record<string, string>): Promise<'OK'> {
+    return this.client.delete<'OK'>(`${this.basePath}/${id}`, headers)
+  }
+
+  /**
+   * Deletes several schedules of the account. Ids that are not UUIDs, or of another account, are
+   * skipped in silence; always resolves to `'OK'`.
+   * @permissions schedule.destroy
+   */
+  deleteMany(ids: string[], headers?: Record<string, string>): Promise<'OK'> {
+    return this.client.request<'OK', { where: { id: string[] } }>(
+      'DELETE',
+      `${this.basePath}/many`,
+      { where: { id: ids } },
+      headers,
+    )
+  }
 }

package/src/apis/schedule/types.ts

@@ -1,15 +1,28 @@
 import type { Contact } from '../contacts/types'
 import type { Department } from '../departments/types'
+import type { File } from '../files/types'
 import type { User } from '../users/types'
 
+/** `scheduled` until the worker runs it; `error` and `not_sent` come with the `reason`. */
+export type ScheduleStatus = 'scheduled' | 'done' | 'error' | 'not_sent'
+
 export type Schedule = {
   id: string
-  status: string
+  status: ScheduleStatus
+  /**
+   * Why it was not sent: `ALREADY_TICKET_OPENED`, `DDD_BLOCKED`, `SERVICE_IS_NOT_ENABLED`,
+   * `CONTACT_IS_BLOCKED`, `CONTACT_NOT_EXISTS`, `HSM_LIMIT_EXCEEDED`, `HSM_IS_BLOCKED`,
+   * `SERVICE_IS_BLOCKED`, `INVALID_PAYLOAD`, a WhatsApp Business error code or
+   * `SCHEDULE_UNKNOWN_REASON`.
+   */
   reason: string | null
-  message: string
+  /** For a WhatsApp Business template (`hsmId`), the message the server built from it. */
+  message: string | null
   notes: string
-  openTicket: boolean
-  notificateUser: boolean
+  openTicket: boolean | null
+  notificateUser: boolean | null
+  /** Sends the message even when the contact already has an open ticket. */
+  sendWithOpenTicket: boolean | null
   extraOptions: Record<string, unknown> | null
   hsmId: string | null
   hsmFileId: string | null
@@ -20,39 +33,81 @@ export type Schedule = {
   accountId: string
   createdAt: string
   updatedAt: string
-  deletedAt: string | null
   // relationships
   contact?: Contact
   department?: Department
   user?: User | null
+  files?: File[]
+  /** The header media of the WhatsApp Business template. */
+  hsmFile?: File
+}
+
+/** The schedule as stored, without relationships: what `updateById` resolves to. */
+export type ScheduleRecord = Omit<
+  Schedule,
+  'contact' | 'department' | 'user' | 'files' | 'hsmFile'
+> & {
+  deletedAt: string | null
 }
 
-export type ScheduleRelationships = 'contact' | 'department' | 'user'
+export type ScheduleRelationships =
+  | 'contact'
+  | 'department'
+  | 'user'
+  | 'files'
+  | 'hsmFile'
+  | 'contact.service'
+  | 'contact.person'
+
+/** A new attachment. */
+export type ScheduleNewFilePayload = { base64: string; name: string; mimetype: string }
 
+/** On update: a new attachment, or one to keep (`id`). */
+export type ScheduleFilePayload = ScheduleNewFilePayload | { id: string }
+
+/**
+ * Another schedule of the connection less than 5 minutes apart answers 402
+ * (`Schedule time is already exist.`). A contact of another account answers 500.
+ */
 export type CreateSchedulePayload = {
   scheduledAt: string
   contactId: string
   departmentId: string
-  message: string
+  /** Up to 1024 characters. Optional for a WhatsApp Business template, built from `hsmId`. */
+  message?: string
+  /**
+   * Up to 1024 characters. Required by the route only with `openTicket: true`, but the column is
+   * NOT NULL: send it always (an empty string is fine).
+   */
   notes: string
-  openTicket: boolean
+  openTicket?: boolean
   notificateUser?: boolean
+  sendWithOpenTicket?: boolean
   userId?: string
   hsmId?: string
   hsmFileId?: string
   extraOptions?: Record<string, unknown>
+  /** New attachments only: the create drops `{ id }` items. */
+  files?: ScheduleNewFilePayload[]
 }
 
+/**
+ * Not partial: `scheduledAt`, `contactId` and `departmentId` are required on update too. The
+ * 5-minute conflict (402) is checked against the whole account.
+ */
 export type UpdateSchedulePayload = {
-  scheduledAt?: string
-  contactId?: string
-  departmentId?: string
+  scheduledAt: string
+  contactId: string
+  departmentId: string
   userId?: string | null
   message?: string
   notes?: string
   openTicket?: boolean
   notificateUser?: boolean
+  sendWithOpenTicket?: boolean
   hsmId?: string | null
   hsmFileId?: string | null
   extraOptions?: Record<string, unknown> | null
+  /** Replaces the attachments: `{ id }` keeps one, `{ base64, ... }` adds one; omitted or `[]` removes all. */
+  files?: ScheduleFilePayload[]
 }

package/src/apis/ticketTopics/TicketTopicsApi.test.ts

@@ -55,4 +55,44 @@ describe('TicketTopicsApi', () => {
     await unarchive('t1')
     expect(client.post).toHaveBeenCalledTimes(2)
   })
+
+  it('create sends the department ids', async () => {
+    await api.create({ name: 'Dúvida', departments: ['d1'] })
+    expect(client.post).toHaveBeenCalledWith(
+      '/ticket-topics',
+      { name: 'Dúvida', departments: ['d1'] },
+      undefined,
+    )
+  })
+
+  it('getMany sends the department filters at the top of the query', async () => {
+    const query = { departmentIds: ['d1'], includeNoDepartment: true }
+    await api.getMany(query)
+    expect(client.get).toHaveBeenCalledWith(
+      `/ticket-topics?query=${encodeURIComponent(JSON.stringify(query))}`,
+      undefined,
+    )
+  })
+
+  it('deleteById resolves to the OK of the route', async () => {
+    vi.mocked(client.delete).mockResolvedValue('OK')
+    expect(await api.deleteById('t1')).toBe('OK')
+    expect(client.delete).toHaveBeenCalledWith('/ticket-topics/t1', undefined)
+  })
+
+  it('getOne reads one item of the paginated list, where the department filters apply', async () => {
+    vi.mocked(client.get).mockResolvedValue({ data: [{ id: 't1' }], total: 1 })
+    expect(await api.getOne({ departmentIds: ['d1'] })).toEqual({ id: 't1' })
+    expect(client.get).toHaveBeenCalledWith(
+      `/ticket-topics?query=${encodeURIComponent(
+        JSON.stringify({ departmentIds: ['d1'], paginate: true, perPage: 1, page: 1 }),
+      )}`,
+      undefined,
+    )
+  })
+
+  it('getOne resolves null on an empty page', async () => {
+    vi.mocked(client.get).mockResolvedValue({ data: [], total: 0 })
+    expect(await api.getOne()).toBeNull()
+  })
 })

package/src/apis/ticketTopics/TicketTopicsApi.ts

@@ -1,11 +1,18 @@
 import type { ApiClient } from '../../core/ApiClient'
 import { BaseCrudApi } from '../../core/BaseCrudApi'
-import type { TicketTopic, CreateTicketTopicPayload, UpdateTicketTopicPayload } from './types'
+import type {
+  TicketTopic,
+  TicketTopicListQuery,
+  CreateTicketTopicPayload,
+  UpdateTicketTopicPayload,
+} from './types'
 
 export class TicketTopicsApi extends BaseCrudApi<
   TicketTopic,
   CreateTicketTopicPayload,
-  UpdateTicketTopicPayload
+  UpdateTicketTopicPayload,
+  TicketTopicListQuery,
+  'OK'
 > {
   constructor(client: ApiClient) {
     super(client, '/ticket-topics')
@@ -13,10 +20,34 @@ export class TicketTopicsApi extends BaseCrudApi<
     this.unarchive = this.unarchive.bind(this)
   }
 
+  /**
+   * Returns the first topic matching the query, or `null` when none match. Reads one item of the
+   * paginated list (instead of `paginate: false`), the only path where `departmentIds` and
+   * `includeNoDepartment` apply.
+   * @permissions ticketTopics.view
+   */
+  override async getOne(
+    query?: TicketTopicListQuery,
+    headers?: Record<string, string>,
+  ): Promise<TicketTopic | null> {
+    const page = await this.getMany({ ...query, paginate: true, perPage: 1, page: 1 }, headers)
+    return page?.data?.[0] ?? null
+  }
+
+  /**
+   * Deletes a ticket topic (soft delete). Resolves to `'OK'`; an unknown id answers 500.
+   * @permissions ticketTopics.view OR ticketTopics.destroy
+   */
+  override deleteById(id: string, headers?: Record<string, string>): Promise<'OK'> {
+    return super.deleteById(id, headers)
+  }
+
   /**
    * Archives a ticket topic. Unlike most resources, ticket-topics archive through a
    * dedicated endpoint (POST `${basePath}/${id}/archive`) rather than `updateById`.
-   * @permissions ticketTopic.update
+   * Resolves to the stored topic, without `departments`. A topic used in a bot answers 403;
+   * an unknown id answers 500.
+   * @permissions ticketTopics.archive
    */
   archive(id: string, headers?: Record<string, string>): Promise<TicketTopic> {
     return this.client.post<TicketTopic>(
@@ -28,7 +59,7 @@ export class TicketTopicsApi extends BaseCrudApi<
 
   /**
    * Restores a previously archived ticket topic via the same dedicated endpoint.
-   * @permissions ticketTopic.update
+   * @permissions ticketTopics.archive
    */
   unarchive(id: string, headers?: Record<string, string>): Promise<TicketTopic> {
     return this.client.post<TicketTopic>(

package/src/apis/ticketTopics/types.ts

@@ -1,3 +1,6 @@
+import type { ListQuery } from '../../core/types'
+import type { Department } from '../departments/types'
+
 export type TicketTopic = {
   id: string
   name: string
@@ -6,12 +9,34 @@ export type TicketTopic = {
   createdAt: string
   updatedAt: string
   deletedAt: string | null
+  // relationships
+  /** Always comes in the paginated `getMany`; elsewhere only with `include`. Empty = all departments. */
+  departments?: Department[]
+}
+
+export type TicketTopicRelationships = 'departments'
+
+/**
+ * Department filters of the paginated `getMany` and of `getOne`. `getMany({ paginate: false })`
+ * ignores them in silence (the route reads them only on the paginated path).
+ */
+export type TicketTopicListQuery = ListQuery<TicketTopic> & {
+  /** Topics linked to any of these departments. */
+  departmentIds?: string | string[]
+  /** Also (or only) the topics linked to no department. Only with the default `'json'` query format. */
+  includeNoDepartment?: boolean
 }
 
 export type CreateTicketTopicPayload = {
+  /** Unique in the account (409, unless the account allows duplicate names); trimmed. */
   name: string
+  /** Department ids; `[]` = all departments. Required: a missing list answers 500 after creating the topic. */
+  departments: string[]
 }
 
 export type UpdateTicketTopicPayload = {
-  name?: string
+  /** Required on update too. */
+  name: string
+  /** Department ids, replacing the current ones; omitted keeps them. */
+  departments?: string[]
 }

package/src/core/BaseCrudApi.ts

@@ -14,15 +14,19 @@ export type {
   CrudApi,
 } from './types'
 
-/** Generic CRUD resource: the reads of `BaseReadApi` plus `create`, `updateById` and `deleteById`. */
+/**
+ * Generic CRUD resource: the reads of `BaseReadApi` plus `create`, `updateById` and `deleteById`.
+ * `TDeleteResponse` is what `deleteById` resolves to (most routes answer the text `'OK'`).
+ */
 export class BaseCrudApi<
   TResponse,
   TCreate,
   TUpdate = TCreate,
   TQuery extends ListQuery<TResponse> = ListQuery<TResponse>,
+  TDeleteResponse = TResponse,
 >
   extends BaseReadApi<TResponse, TQuery>
-  implements CrudApi<TResponse, TCreate, TUpdate, TQuery>
+  implements CrudApi<TResponse, TCreate, TUpdate, TQuery, TDeleteResponse>
 {
   /**
    * Creates a new resource.
@@ -42,9 +46,9 @@ export class BaseCrudApi<
 
   /**
    * Deletes a resource by ID.
-   * @permissions $resourceName.delete
+   * @permissions $resourceName.destroy
    */
-  deleteById(id: string, headers?: Record<string, string>): Promise<TResponse> {
-    return this.client.delete<TResponse>(`${this.basePath}/${id}`, headers)
+  deleteById(id: string, headers?: Record<string, string>): Promise<TDeleteResponse> {
+    return this.client.delete<TDeleteResponse>(`${this.basePath}/${id}`, headers)
   }
 }

package/src/core/types.ts

@@ -159,8 +159,9 @@ export type CrudApi<
   TCreate,
   TUpdate = TCreate,
   TQuery extends ListQuery<TResponse> = ListQuery<TResponse>,
+  TDeleteResponse = TResponse,
 > = HasGetMany<TResponse, TQuery> &
   HasGetById<TResponse> &
   HasCreate<TResponse, TCreate> &
   HasUpdateById<TResponse, TUpdate> &
-  HasDeleteById<TResponse>
+  HasDeleteById<TDeleteResponse>

package/src/incommingWebhooks/index.test-d.ts

@@ -2,6 +2,7 @@ import { expectAssignable, expectNotAssignable, expectType } from 'tsd'
 import type { WebhookPayload, WebhookEvent, WebhookEventPayloadMap, BotCommandData } from './index'
 import type { Message, MessageRelationships } from '../apis/messages'
 import type { Ticket, TicketRelationships } from '../apis/tickets'
+import type { BotApiSignalData, BotContexts } from '../apis/bots'
 
 // ── WebhookPayload (generic) ─────────────────────────────────────────────────
 
@@ -37,6 +38,14 @@ declare const botPayload: WebhookPayload<'bot.command'>
 expectType<BotCommandData>(botPayload.data)
 expectAssignable<{ id: string; command: string }>(botPayload.data)
 
+// ── bot.* deliver the stored bot, with the contexts in the map form ──────────
+
+declare const botCreated: WebhookPayload<'bot.created'>
+expectType<BotContexts>(botCreated.data.contexts)
+
+declare const apiSignal: WebhookPayload<'bot.api-signal'>
+expectType<BotApiSignalData>(apiSignal.data)
+
 // ── invalid events are rejected ──────────────────────────────────────────────
 
 expectNotAssignable<WebhookEvent>('message.deleted')