@ikatec/digisac-api-sdk 4.3.0 → 4.4.0

package/src/apis/contacts/ContactsApi.test.ts

@@ -2,12 +2,20 @@ import { beforeEach, describe, expect, it, vi } from 'vitest'
 import { ContactsApi } from './ContactsApi'
 import type { ApiClient } from '../../core/ApiClient'
 import type {
+  BlockContactPayload,
+  BulkTransferTicketsPayload,
+  BulkTransferTicketsResult,
   Contact,
+  ContactMediaPage,
+  ContactsSelection,
   CreateContactPayload,
+  CreateManyContactsItem,
+  ExportCsvPayload,
   ExportTemplatePayload,
   CountContactsQuery,
   ExistsContactsParams,
   CountMediaResult,
+  ImportContactsPayload,
 } from './types'
 import type { Paginated } from '../../core/types'
 
@@ -101,7 +109,7 @@ describe('ContactsApi', () => {
     it('serializes query parameters', async () => {
       vi.mocked(client.get).mockResolvedValue(paginated)
       await api.getMany({ page: 2, perPage: 5 })
-      const url = vi.mocked(client.get).mock.calls[0][0] as string
+      const url = vi.mocked(client.get).mock.calls[0]?.[0] as string
       expect(url).toContain('/contacts?')
       expect(decodeURIComponent(url)).toContain('"page":2')
     })
@@ -225,7 +233,7 @@ describe('ContactsApi', () => {
       vi.mocked(client.get).mockResolvedValue({ count: 10 })
       const query: CountContactsQuery = { where: { name: 'Alice' } }
       await api.count(query)
-      const url = vi.mocked(client.get).mock.calls[0][0] as string
+      const url = vi.mocked(client.get).mock.calls[0]?.[0] as string
       expect(url).toContain('/contacts/count?')
       expect(url).toContain('where')
     })
@@ -270,7 +278,7 @@ describe('ContactsApi', () => {
     it('serializes query parameters', async () => {
       vi.mocked(client.get).mockResolvedValue(paginated)
       await api.forward({ page: 1, perPage: 10 })
-      const url = vi.mocked(client.get).mock.calls[0][0] as string
+      const url = vi.mocked(client.get).mock.calls[0]?.[0] as string
       expect(url).toContain('/contacts/forward?')
     })
 
@@ -289,7 +297,7 @@ describe('ContactsApi', () => {
       vi.mocked(client.get).mockResolvedValue({ '1234567890': true })
       const params: ExistsContactsParams = { serviceId: 'svc-1', numbers: ['1234567890'] }
       const result = await api.exists(params)
-      const url = vi.mocked(client.get).mock.calls[0][0] as string
+      const url = vi.mocked(client.get).mock.calls[0]?.[0] as string
       expect(url).toContain('/contacts/exists?')
       expect(url).toContain('serviceId=svc-1')
       expect(result).toEqual({ '1234567890': true })
@@ -299,7 +307,7 @@ describe('ContactsApi', () => {
       vi.mocked(client.get).mockResolvedValue({})
       const headers = { 'X-Custom': 'h' }
       await api.exists({ serviceId: 'svc-1', numbers: [] }, headers)
-      expect(vi.mocked(client.get).mock.calls[0][1]).toEqual(headers)
+      expect(vi.mocked(client.get).mock.calls[0]?.[1]).toEqual(headers)
     })
   })
 
@@ -365,6 +373,175 @@ describe('ContactsApi', () => {
     })
   })
 
+  // ── createMany ───────────────────────────────────────────────────
+
+  describe('createMany', () => {
+    const items: CreateManyContactsItem[] = [
+      { serviceId: 'svc-1', name: 'Alice', number: '5511999990001' },
+      { serviceId: 'svc-1', name: 'Bob', number: '5511999990002', tagIds: ['t1'] },
+    ]
+
+    it('calls client.post with /contacts/many and the array body', async () => {
+      vi.mocked(client.post).mockResolvedValue([contact])
+      const result = await api.createMany(items)
+      expect(client.post).toHaveBeenCalledWith('/contacts/many', items, undefined)
+      expect(result).toEqual([contact])
+    })
+
+    it('serializes the query and forwards custom headers', async () => {
+      const headers = { 'X-Custom': 'value' }
+      await api.createMany(items, { include: ['tags'] }, headers)
+      const [url, body, sentHeaders] = vi.mocked(client.post).mock.calls[0] ?? []
+      expect(decodeURIComponent(url as string)).toBe('/contacts/many?query={"include":["tags"]}')
+      expect(body).toBe(items)
+      expect(sentHeaders).toBe(headers)
+    })
+  })
+
+  // ── deleteMany ───────────────────────────────────────────────────
+
+  describe('deleteMany', () => {
+    it('calls client.request with DELETE /contacts/many and the selection', async () => {
+      vi.mocked(client.request).mockResolvedValue(true)
+      const body: ContactsSelection = { where: { id: { $in: ['c1', 'c2'] } } }
+      const result = await api.deleteMany(body)
+      expect(client.request).toHaveBeenCalledWith('DELETE', '/contacts/many', body, undefined)
+      expect(result).toBe(true)
+    })
+
+    it('forwards custom headers', async () => {
+      const headers = { 'X-Custom': 'value' }
+      await api.deleteMany({ where: { id: 'c1' } }, headers)
+      expect(client.request).toHaveBeenCalledWith(
+        'DELETE',
+        '/contacts/many',
+        { where: { id: 'c1' } },
+        headers,
+      )
+    })
+  })
+
+  // ── exportCsv ────────────────────────────────────────────────────
+
+  describe('exportCsv', () => {
+    it('calls client.post with /contacts/export/csv and resolves to the CSV text', async () => {
+      const csv = 'Nome,DDI,Número\nAlice,55,11999990001\n'
+      vi.mocked(client.post).mockResolvedValue(csv)
+      const body: ExportCsvPayload = {
+        serviceType: 'whatsapp',
+        type: 'comma',
+        where: { id: 'cnt-1' },
+      }
+      const result = await api.exportCsv(body)
+      expect(client.post).toHaveBeenCalledWith('/contacts/export/csv', body, undefined)
+      expect(result).toBe(csv)
+    })
+  })
+
+  // ── importCsv ────────────────────────────────────────────────────
+
+  describe('importCsv', () => {
+    it('calls client.post with /contacts/import-contacts and body', async () => {
+      const body: ImportContactsPayload = {
+        service: { id: 'svc-1', accountId: 'acc-1', type: 'whatsapp' },
+        file: { id: 'f1', name: 'contacts.csv', mimetype: 'text/csv', urlToUpload: 'https://s3' },
+        csvHeaderLine: ['Nome', 'DDI', 'Número'],
+        type: 'comma',
+        tagsIds: ['t1'],
+      }
+      vi.mocked(client.post).mockResolvedValue('OK')
+      const headers = { 'X-Custom': 'value' }
+      const result = await api.importCsv(body, headers)
+      expect(client.post).toHaveBeenCalledWith('/contacts/import-contacts', body, headers)
+      expect(result).toBe('OK')
+    })
+  })
+
+  // ── sync ─────────────────────────────────────────────────────────
+
+  describe('sync', () => {
+    it('calls client.post with /contacts/:id/sync and an empty body by default', async () => {
+      vi.mocked(client.post).mockResolvedValue('OK')
+      const result = await api.sync('c1')
+      expect(client.post).toHaveBeenCalledWith('/contacts/c1/sync', {}, undefined)
+      expect(result).toBe('OK')
+    })
+
+    it('sends forceSync and forwards custom headers', async () => {
+      const headers = { 'X-Custom': 'value' }
+      await api.sync('c1', { forceSync: true }, headers)
+      expect(client.post).toHaveBeenCalledWith('/contacts/c1/sync', { forceSync: true }, headers)
+    })
+  })
+
+  // ── block ────────────────────────────────────────────────────────
+
+  describe('block', () => {
+    it('calls client.post with /contacts/:id/block and body', async () => {
+      vi.mocked(client.post).mockResolvedValue({ ...contact, block: true })
+      const body: BlockContactPayload = { block: true, description: 'spam' }
+      const result = await api.block('c1', body)
+      expect(client.post).toHaveBeenCalledWith('/contacts/c1/block', body, undefined)
+      expect(result.block).toBe(true)
+    })
+  })
+
+  // ── markRead ─────────────────────────────────────────────────────
+
+  describe('markRead', () => {
+    it('calls client.post with /contacts/:id/mark-read and no body', async () => {
+      vi.mocked(client.post).mockResolvedValue('OK')
+      const headers = { 'X-Custom': 'value' }
+      const result = await api.markRead('c1', headers)
+      expect(client.post).toHaveBeenCalledWith('/contacts/c1/mark-read', undefined, headers)
+      expect(result).toBe('OK')
+    })
+  })
+
+  // ── getMedia ─────────────────────────────────────────────────────
+
+  describe('getMedia', () => {
+    const page: ContactMediaPage = { data: [], limit: 50, hasNextPage: false, nextCursor: null }
+
+    it('calls client.get with /contacts/:id/media when no query is provided', async () => {
+      vi.mocked(client.get).mockResolvedValue(page)
+      const result = await api.getMedia('c1')
+      expect(client.get).toHaveBeenCalledWith('/contacts/c1/media', undefined)
+      expect(result).toEqual(page)
+    })
+
+    it('serializes the type, cursor and perPage', async () => {
+      await api.getMedia('c1', {
+        where: { type: 'document', cursor: '2026-01-01T00:00:00Z' },
+        perPage: 10,
+      })
+      const url = decodeURIComponent(vi.mocked(client.get).mock.calls[0]?.[0] as string)
+      expect(url).toBe(
+        '/contacts/c1/media?query={"where":{"type":"document","cursor":"2026-01-01T00:00:00Z"},"perPage":10}',
+      )
+    })
+  })
+
+  // ── bulkTransferTickets ──────────────────────────────────────────
+
+  describe('bulkTransferTickets', () => {
+    it('calls client.post with /contacts/ticket/bulk-transfer and body', async () => {
+      const response: BulkTransferTicketsResult = {
+        message: 'Transferência realizada com sucesso',
+        ticketsSelectedId: ['t1'],
+      }
+      vi.mocked(client.post).mockResolvedValue(response)
+      const body: BulkTransferTicketsPayload = {
+        departmentId: 'd1',
+        userId: null,
+        ticketsSelectedId: ['t1'],
+      }
+      const result = await api.bulkTransferTickets(body)
+      expect(client.post).toHaveBeenCalledWith('/contacts/ticket/bulk-transfer', body, undefined)
+      expect(result).toEqual(response)
+    })
+  })
+
   // ── Error propagation ────────────────────────────────────────────
 
   describe('error propagation', () => {

package/src/apis/contacts/ContactsApi.ts

@@ -3,12 +3,22 @@ import type { ApiClient } from '../../core/ApiClient'
 import { BaseCrudApi } from '../../core/BaseCrudApi'
 import type { ListQuery, Paginated } from '../../core/types'
 import type {
+  BlockContactPayload,
+  BulkTransferTicketsPayload,
+  BulkTransferTicketsResult,
   Contact,
+  ContactMediaPage,
+  ContactMediaQuery,
+  ContactsSelection,
   CountContactsQuery,
   CountMediaResult,
   CreateContactPayload,
+  CreateManyContactsItem,
   ExistsContactsParams,
+  ExportCsvPayload,
   ExportTemplatePayload,
+  ImportContactsPayload,
+  SyncContactPayload,
   TransferTicketPayload,
   UpdateContactPayload,
 } from './types'
@@ -120,4 +130,122 @@ export class ContactsApi extends BaseCrudApi<Contact, CreateContactPayload, Upda
       headers,
     )
   }
+
+  /**
+   * Creates or updates several contacts in one call. Existing contacts (same service and
+   * number or e-mail) are updated; the others are created. Returns the resulting contacts.
+   * @permissions contacts.view OR contacts.update OR contacts.create
+   */
+  createMany(
+    body: CreateManyContactsItem[],
+    query?: ListQuery<Contact>,
+    headers?: Record<string, string>,
+  ): Promise<Contact[]> {
+    const queryString = this.toQueryString(query)
+    return this.client.post<Contact[], CreateManyContactsItem[]>(
+      `${this.basePath}/many${queryString}`,
+      body,
+      headers,
+    )
+  }
+
+  /**
+   * Deletes every contact of the account that matches the selection.
+   * @permissions contacts.view OR contacts.destroy
+   */
+  deleteMany(body: ContactsSelection, headers?: Record<string, string>): Promise<boolean> {
+    return this.client.request<boolean, ContactsSelection>(
+      'DELETE',
+      `${this.basePath}/many`,
+      body,
+      headers,
+    )
+  }
+
+  /**
+   * Exports the contacts that match the filter as CSV. Resolves to the CSV text.
+   * @permissions contacts.view AND contacts.export
+   */
+  exportCsv(body: ExportCsvPayload, headers?: Record<string, string>): Promise<string> {
+    return this.client.post<string, ExportCsvPayload>(`${this.basePath}/export/csv`, body, headers)
+  }
+
+  /**
+   * Starts the import of a CSV file previously uploaded through `FilesApi`. The import runs
+   * in the background; the header line is validated against the service type template.
+   * Resolves to `'OK'`.
+   * @permissions contacts.view OR contacts.update OR contacts.create
+   */
+  importCsv(body: ImportContactsPayload, headers?: Record<string, string>): Promise<string> {
+    return this.client.post<string, ImportContactsPayload>(
+      `${this.basePath}/import-contacts`,
+      body,
+      headers,
+    )
+  }
+
+  /**
+   * Marks the contact as read and, when needed, syncs it with the messaging service.
+   * Resolves to `'OK'`.
+   * @permissions contacts.view OR contacts.update
+   */
+  sync(id: string, body?: SyncContactPayload, headers?: Record<string, string>): Promise<string> {
+    return this.client.post<string, SyncContactPayload>(
+      `${this.basePath}/${id}/sync`,
+      body ?? {},
+      headers,
+    )
+  }
+
+  /**
+   * Blocks or unblocks a contact. Blocking closes the contact's open ticket. Requires the
+   * block list to be active on the account.
+   * @permissions contacts.block
+   */
+  block(id: string, body: BlockContactPayload, headers?: Record<string, string>): Promise<Contact> {
+    return this.client.post<Contact, BlockContactPayload>(
+      `${this.basePath}/${id}/block`,
+      body,
+      headers,
+    )
+  }
+
+  /**
+   * Resets the contact's unread counter. Resolves to `'OK'`.
+   * @permissions contacts.view OR contacts.update
+   */
+  markRead(id: string, headers?: Record<string, string>): Promise<string> {
+    return this.client.post<string>(`${this.basePath}/${id}/mark-read`, undefined, headers)
+  }
+
+  /**
+   * Returns the files and links exchanged with a contact, cursor-paginated.
+   * @permissions contacts.view
+   */
+  getMedia(
+    contactId: string,
+    query?: ContactMediaQuery,
+    headers?: Record<string, string>,
+  ): Promise<ContactMediaPage> {
+    const queryString = this.toQueryString(query)
+    return this.client.get<ContactMediaPage>(
+      `${this.basePath}/${contactId}/media${queryString}`,
+      headers,
+    )
+  }
+
+  /**
+   * Transfers several tickets at once to a department and/or user.
+   * @permissions tickets.transfer.all.bulk
+   */
+  bulkTransferTickets(
+    body: BulkTransferTicketsPayload,
+    headers?: Record<string, string>,
+  ): Promise<BulkTransferTicketsResult> {
+    return this.client.post<BulkTransferTicketsResult, BulkTransferTicketsPayload>(
+      `${this.basePath}/ticket/bulk-transfer`,
+      body,
+      headers,
+    )
+  }
 }

package/src/apis/contacts/types.ts

@@ -4,7 +4,7 @@ import type { Service } from '../services/types'
 import type { Tag } from '../tags/types'
 import type { Ticket } from '../tickets/types'
 import type { User } from '../users/types'
-import type { ListQuery } from '../../core/types'
+import type { IncludeItem, ListQuery, WhereClause } from '../../core/types'
 
 export type ContactStatus = 'online' | 'offline' | 'absent'
 export type ContactOrigin = 'api' | 'app' | 'campaign' | 'driver' | 'import' | 'web'
@@ -204,3 +204,156 @@ export type TransferTicketPayload = {
   kanbanCardSubject?: string
   initialMessage?: string
 }
+
+/**
+ * One item of `POST /contacts/many`. The backend matches existing contacts by service and
+ * number (or e-mail) and updates them; the others are created. Items repeating a number of
+ * the same batch are dropped (the first one wins).
+ */
+export type CreateManyContactsItem = {
+  serviceId: string
+  name: string
+  /** Phone number with country code, or the e-mail address for e-mail connections. */
+  number: string
+  internalName?: string
+  personId?: string
+  defaultDepartmentId?: string
+  defaultUserId?: string
+  tagIds?: string[]
+  /** When `true`, the given `tagIds` are merged into the existing ones instead of replacing them. */
+  mergeRelations?: boolean
+  /**
+   * Only `data.number` is read, as a fallback when `number` is empty; the backend rebuilds
+   * `data` from the number.
+   */
+  data?: {
+    number: string
+  }
+}
+
+/**
+ * Selects a set of contacts by filter. Used by `DELETE /contacts/many` and by the tag
+ * attach/detach routes. The backend always scopes the filter to the current account.
+ *
+ * `where` is required on purpose: the backend applies the operation to every contact the
+ * filter matches, so an empty filter would reach every contact of the account.
+ */
+export type ContactsSelection = {
+  where: WhereClause<Contact>
+  include?: IncludeItem<Contact>[]
+  customFilter?: Record<string, unknown>
+}
+
+/**
+ * CSV layout of the contact export and import, as in `exportTemplate`:
+ * - `'colon'`: `;` as the column delimiter (any other value uses `,`);
+ * - `'google'`: phone columns as DDI + Phone ("Telefone") instead of DDI + Number.
+ *
+ * E-mail and webchat connections ignore it for the contact columns (Email / Email + Number).
+ */
+export type ContactsCsvType = 'colon' | 'google' | (string & {})
+
+/** Body for `POST /contacts/export/csv`. */
+export type ExportCsvPayload = Omit<ListQuery<Contact>, 'page' | 'perPage'> & {
+  serviceType: string
+  type: ContactsCsvType
+}
+
+/**
+ * Body for `POST /contacts/import-contacts`. The CSV must be uploaded first (see `FilesApi`);
+ * the header line is checked against the template of the service type and language.
+ */
+export type ImportContactsPayload = {
+  service: Pick<Service, 'id' | 'accountId' | 'type'>
+  file: {
+    id: string
+    name: string
+    mimetype: string
+    /** Sent by the web app; the backend reads only `id`. */
+    urlToUpload?: string
+  }
+  csvHeaderLine: string[]
+  type: ContactsCsvType
+  tagsIds?: string[]
+  defaultDepartmentId?: string
+  defaultUserId?: string
+}
+
+/** Body for `POST /contacts/:id/block`. Blocking a contact closes its open ticket. */
+export type BlockContactPayload = {
+  block: boolean
+  byUserId?: string
+  description?: string
+}
+
+/** Body for `POST /contacts/:id/sync`. */
+export type SyncContactPayload = {
+  forceSync?: boolean
+}
+
+export type ContactMediaType = 'media' | 'document' | 'link'
+
+/**
+ * Query for `GET /contacts/:id/media`. Cursor-based: pass the previous page's `nextCursor`
+ * as `where.cursor`.
+ */
+export type ContactMediaQuery = {
+  where?: {
+    /** `'media'` = images and videos. Omitted = images, videos and documents. */
+    type?: ContactMediaType
+    /** Case-insensitive filter by file name (ignored for links). */
+    name?: string
+    cursor?: string
+  }
+  perPage?: number
+  order?: [string, 'ASC' | 'DESC' | 'asc' | 'desc'][]
+}
+
+/**
+ * One item of `GET /contacts/:id/media`. When the user cannot see the message, the
+ * identifying fields come as `'UNAUTHORIZED_MESSAGE'` and `isAuthorized` is `false`.
+ */
+export type ContactMediaItem = {
+  id: string
+  /** ID of the message that carries the file or link. */
+  attachedId: string
+  /** File name; absent for links. */
+  name?: string | null
+  /** Only for files. */
+  mimetype?: string
+  createdAt: string
+  updatedAt: string
+  accountId: string
+  url: string | null
+  /** Only for files (filled for videos). */
+  previewUrl?: string | null
+  isAuthorized: boolean
+  /** Only for `type: 'link'`. */
+  links?: string[]
+}
+
+export type ContactMediaPage = {
+  data: ContactMediaItem[]
+  limit: number
+  hasNextPage: boolean
+  nextCursor: string | null
+}
+
+/** Body for `POST /contacts/ticket/bulk-transfer`. */
+export type BulkTransferTicketsPayload = {
+  departmentId?: string
+  /** `null` removes the assigned user. */
+  userId?: string | null
+  comments?: string
+  /** IDs of the tickets to transfer. Ignored when `allContactsSelected` is `true`. */
+  ticketsSelectedId?: string[]
+  allContactsSelected?: boolean
+  /** Contact filter used with `allContactsSelected`. */
+  query?: ListQuery<Contact>
+}
+
+export type BulkTransferTicketsResult = {
+  message: string
+  /** IDs of the tickets actually transferred (the ones the target user can access). */
+  ticketsSelectedId: string[]
+}

package/src/apis/messages/MessagesApi.test.ts

@@ -85,7 +85,7 @@ describe('MessagesApi', () => {
     it('serializes query parameters', async () => {
       vi.mocked(client.get).mockResolvedValue(paginated)
       await api.getMany({ page: 2, perPage: 5 })
-      const url = vi.mocked(client.get).mock.calls[0][0] as string
+      const url = vi.mocked(client.get).mock.calls[0]?.[0] as string
       expect(url).toContain('/messages?')
       expect(decodeURIComponent(url)).toContain('"page":2')
       expect(decodeURIComponent(url)).toContain('"perPage":5')
@@ -382,7 +382,7 @@ describe('MessagesApi', () => {
     it('appends limit query parameter when provided', async () => {
       vi.mocked(client.get).mockResolvedValue({ outOfRange: true })
       await api.outOfRange('msg-1', 50)
-      const url = vi.mocked(client.get).mock.calls[0][0] as string
+      const url = vi.mocked(client.get).mock.calls[0]?.[0] as string
       expect(url).toContain('/messages/msg-1/out-of-range?')
       expect(url).toContain('limit=50')
     })
@@ -426,7 +426,7 @@ describe('MessagesApi', () => {
     it('appends limit query parameter when provided', async () => {
       vi.mocked(client.get).mockResolvedValue([])
       await api.around('msg-1', { limit: 10 })
-      const url = vi.mocked(client.get).mock.calls[0][0] as string
+      const url = vi.mocked(client.get).mock.calls[0]?.[0] as string
       expect(url).toContain('/messages/msg-1/around?')
       expect(url).toContain('limit=10')
     })

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

@@ -1,8 +1,11 @@
 import { expectError } from 'tsd'
 import type { ApiClient } from '../core/ApiClient'
+import { ContactsApi } from './contacts/ContactsApi'
 import { PersonalAccessTokensApi } from './personalAccessTokens/PersonalAccessTokensApi'
 import { RolesApi } from './roles/RolesApi'
+import { TagsApi } from './tags/TagsApi'
 import { TimetableApi } from './timetable/TimetableApi'
+import { UsersApi } from './users/UsersApi'
 
 declare const client: ApiClient
 
@@ -37,3 +40,26 @@ tokens.create({ name: 'CI', expiresIn: '90d' })
 expectError(tokens.create({ name: 'CI', accessTokenExpiresAt: '2030-01-01T00:00:00Z' }))
 expectError(tokens.create({ name: 'CI', expiresIn: '7d' }))
 expectError(tokens.updateById('t-1', { scope: '*' }))
+
+// ── users: the dedicated archive route takes a boolean, not a date ──
+
+const users = new UsersApi(client)
+users.archiveWithValidation('u-1', { archive: true })
+expectError(users.archiveWithValidation('u-1', { archivedAt: '2030-01-01T00:00:00Z' }))
+expectError(users.exportCsv({ filter: 'deleted' }))
+
+// ── contacts: /many takes an array, the bulk delete a selection ─────
+
+const contacts = new ContactsApi(client)
+contacts.createMany([{ serviceId: 's-1', name: 'Alice', number: '5511999990001' }])
+expectError(contacts.createMany({ serviceId: 's-1', name: 'Alice', number: '5511999990001' }))
+expectError(contacts.getMedia('c-1', { where: { type: 'audio' } }))
+
+// ── contact selections: an empty filter would reach every contact of the account ─
+
+contacts.deleteMany({ where: { id: 'c-1' } })
+expectError(contacts.deleteMany({}))
+const tags = new TagsApi(client)
+tags.attachContacts('t-1', { where: { id: { $in: ['c-1', 'c-2'] } } })
+expectError(tags.attachContacts('t-1', {}))
+expectError(tags.detachContacts('t-1', { include: ['tags'] }))

package/src/apis/queryFormat.test.ts

@@ -32,6 +32,8 @@ function createMockClient(queryFormat?: QueryFormat): ApiClient {
 
 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 }
 
 type Case = {
   name: string
@@ -69,6 +71,27 @@ const cases: Case[] = [
       return (f ? api.withQueryFormat(f) : api).count(listQuery)
     },
   },
+  {
+    name: 'ContactsApi.getMedia',
+    path: '/contacts/c1/media',
+    query: { where: { type: 'document' }, perPage: 10 },
+    call: (client, f) => {
+      const api = new ContactsApi(client)
+      return (f ? api.withQueryFormat(f) : api).getMedia('c1', {
+        where: { type: 'document' },
+        perPage: 10,
+      })
+    },
+  },
+  {
+    name: 'ContactsApi.createMany',
+    path: '/contacts/many',
+    query: { include: ['tags'] },
+    call: (client, f) => {
+      const api = new ContactsApi(client)
+      return (f ? api.withQueryFormat(f) : api).createMany([], { include: ['tags'] })
+    },
+  },
   {
     name: 'ContactsApi.forward',
     path: '/contacts/forward',
@@ -199,10 +222,10 @@ const cases: Case[] = [
   {
     name: 'PermissionsApi.getMany',
     path: '/permissions',
-    query: listQuery,
+    query: permissionsQuery,
     call: (client, f) => {
       const api = new PermissionsApi(client)
-      return (f ? api.withQueryFormat(f) : api).getMany(listQuery)
+      return (f ? api.withQueryFormat(f) : api).getMany(permissionsQuery)
     },
   },
   {
@@ -255,7 +278,8 @@ const cases: Case[] = [
 const jsonUrl = (path: string, query: object) =>
   `${path}?query=${encodeURIComponent(JSON.stringify(query))}`
 const qsUrl = (path: string, query: object) => `${path}?${qs.stringify(query)}`
-const calledUrl = (client: ApiClient) => vi.mocked(client.get).mock.calls.at(0)?.at(0)
+const calledUrl = (client: ApiClient) =>
+  vi.mocked(client.get).mock.calls.at(0)?.at(0) ?? vi.mocked(client.post).mock.calls.at(0)?.at(0)
 
 describe.each(cases)('$name', ({ path, query, call }) => {
   it("sends JSON with the default client format ('json')", async () => {