@ikatec/digisac-api-sdk 4.3.0 → 4.4.0

package/src/apis/serviceAccessManagement/ServiceAccessManagementApi.test.ts

@@ -61,7 +61,7 @@ describe('ServiceAccessManagementApi', () => {
     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('/service-access-management?')
       expect(decodeURIComponent(url)).toContain('"page":2')
     })
@@ -76,7 +76,7 @@ describe('ServiceAccessManagementApi', () => {
     it('returns unpaginated array when paginate: false', async () => {
       vi.mocked(client.get).mockResolvedValue([record])
       const result = await api.getMany({ paginate: false })
-      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(decodeURIComponent(url)).toContain('"paginate":false')
       expect(result).toEqual([record])
     })

package/src/apis/services/ServicesApi.test.ts

@@ -0,0 +1,49 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { ServicesApi } from './ServicesApi'
+import type { ApiClient } from '../../core/ApiClient'
+import type { ServiceLimits } 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(),
+  }
+}
+
+// ── Tests ────────────────────────────────────────────────────────────
+
+describe('ServicesApi', () => {
+  let client: ReturnType<typeof createMockClient>
+  let api: ServicesApi
+
+  beforeEach(() => {
+    client = createMockClient()
+    api = new ServicesApi(client)
+  })
+
+  describe('getLimits', () => {
+    it('calls client.get with /services/limits', async () => {
+      const limits: ServiceLimits = {
+        whatsapp: { used: 1, total: 80, available: 79 },
+        telegram: { used: 0, total: 0, available: 0 },
+      }
+      vi.mocked(client.get).mockResolvedValue(limits)
+      const result = await api.getLimits()
+      expect(client.get).toHaveBeenCalledWith('/services/limits', undefined)
+      expect(result).toEqual(limits)
+    })
+
+    it('forwards custom headers', async () => {
+      const headers = { 'X-Custom': 'value' }
+      await api.getLimits(headers)
+      expect(client.get).toHaveBeenCalledWith('/services/limits', headers)
+    })
+  })
+})

package/src/apis/services/ServicesApi.ts

@@ -1,6 +1,6 @@
 import type { ApiClient } from '../../core/ApiClient'
 import { ArchivableCrudApi } from '../../core/ArchivableCrudApi'
-import type { Service, CreateServicePayload, UpdateServicePayload } from './types'
+import type { Service, CreateServicePayload, ServiceLimits, UpdateServicePayload } from './types'
 
 export class ServicesApi extends ArchivableCrudApi<
   Service,
@@ -10,4 +10,13 @@ export class ServicesApi extends ArchivableCrudApi<
   constructor(client: ApiClient) {
     super(client, '/services')
   }
+
+  /**
+   * Returns, for each connection type of the account plan, how many connections are used,
+   * allowed and still available.
+   * @permissions services.view
+   */
+  getLimits(headers?: Record<string, string>): Promise<ServiceLimits> {
+    return this.client.get<ServiceLimits>(`${this.basePath}/limits`, headers)
+  }
 }

package/src/apis/services/types.ts

@@ -221,3 +221,12 @@ export type UpdateServicePayload = {
   botId?: string | null
   archivedAt?: string | null
 }
+
+export type ServiceLimit = {
+  used: number
+  total: number
+  available: number
+}
+
+/** Connections used and allowed by the account plan, by connection type. */
+export type ServiceLimits = Partial<Record<ServiceType, ServiceLimit>>

package/src/apis/stickerUsers/StickerUsersApi.test.ts

@@ -64,7 +64,7 @@ describe('StickerUsersApi', () => {
     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('/sticker-users?')
       expect(decodeURIComponent(url)).toContain('"page":2')
     })

package/src/apis/tags/TagsApi.test.ts

@@ -0,0 +1,79 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { TagsApi } from './TagsApi'
+import type { ApiClient } from '../../core/ApiClient'
+
+// ── 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('TagsApi', () => {
+  let client: ReturnType<typeof createMockClient>
+  let api: TagsApi
+
+  beforeEach(() => {
+    client = createMockClient()
+    api = new TagsApi(client)
+  })
+
+  describe('attachContacts', () => {
+    it('calls client.post with /tags/:id/contacts and the selection', async () => {
+      vi.mocked(client.post).mockResolvedValue('OK')
+      const body = { where: { id: { $in: ['c1', 'c2'] } } }
+      const result = await api.attachContacts('t1', body)
+      expect(client.post).toHaveBeenCalledWith('/tags/t1/contacts', body, undefined)
+      expect(result).toBe('OK')
+    })
+
+    it('forwards custom headers', async () => {
+      await api.attachContacts('t1', { where: { id: 'c1' } }, headers)
+      expect(client.post).toHaveBeenCalledWith(
+        '/tags/t1/contacts',
+        { where: { id: 'c1' } },
+        headers,
+      )
+    })
+  })
+
+  describe('detachContacts', () => {
+    it('calls client.request with DELETE /tags/:id/contacts and the selection', async () => {
+      vi.mocked(client.request).mockResolvedValue('OK')
+      const body = { where: { id: 'c1' } }
+      const result = await api.detachContacts('t1', body, headers)
+      expect(client.request).toHaveBeenCalledWith('DELETE', '/tags/t1/contacts', body, headers)
+      expect(result).toBe('OK')
+    })
+  })
+
+  describe('attachManyToDepartments', () => {
+    it('calls client.post with /tags/attach-many-departments and body', async () => {
+      vi.mocked(client.post).mockResolvedValue('OK')
+      const body = { ids: ['t1', 't2'], departmentIds: ['d1'] }
+      const result = await api.attachManyToDepartments(body)
+      expect(client.post).toHaveBeenCalledWith('/tags/attach-many-departments', body, undefined)
+      expect(result).toBe('OK')
+    })
+  })
+
+  describe('error propagation', () => {
+    it('propagates errors from attachManyToDepartments', async () => {
+      vi.mocked(client.post).mockRejectedValue(new Error('Invalid tag ids'))
+      await expect(api.attachManyToDepartments({ ids: [], departmentIds: [] })).rejects.toThrow(
+        'Invalid tag ids',
+      )
+    })
+  })
+})

package/src/apis/tags/TagsApi.ts

@@ -1,9 +1,65 @@
 import type { ApiClient } from '../../core/ApiClient'
 import { BaseCrudApi } from '../../core/BaseCrudApi'
-import type { Tag, CreateTagPayload, UpdateTagPayload } from './types'
+import type { ContactsSelection } from '../contacts/types'
+import type {
+  AttachTagsToDepartmentsPayload,
+  CreateTagPayload,
+  Tag,
+  UpdateTagPayload,
+} from './types'
 
 export class TagsApi extends BaseCrudApi<Tag, CreateTagPayload, UpdateTagPayload> {
   constructor(client: ApiClient) {
     super(client, '/tags')
   }
+
+  /**
+   * Adds the tag to every contact of the account that matches the selection. Resolves to `'OK'`.
+   * @permissions tags.view
+   */
+  attachContacts(
+    id: string,
+    body: ContactsSelection,
+    headers?: Record<string, string>,
+  ): Promise<string> {
+    return this.client.post<string, ContactsSelection>(
+      `${this.basePath}/${id}/contacts`,
+      body,
+      headers,
+    )
+  }
+
+  /**
+   * Removes the tag from every contact of the account that matches the selection. Resolves to
+   * `'OK'`.
+   * @permissions tags.view OR tags.destroy
+   */
+  detachContacts(
+    id: string,
+    body: ContactsSelection,
+    headers?: Record<string, string>,
+  ): Promise<string> {
+    return this.client.request<string, ContactsSelection>(
+      'DELETE',
+      `${this.basePath}/${id}/contacts`,
+      body,
+      headers,
+    )
+  }
+
+  /**
+   * Links several tags to the given departments. Resolves to `'OK'`. A tag without departments
+   * is already available to all of them and is left unchanged.
+   * @permissions tags.view
+   */
+  attachManyToDepartments(
+    body: AttachTagsToDepartmentsPayload,
+    headers?: Record<string, string>,
+  ): Promise<string> {
+    return this.client.post<string, AttachTagsToDepartmentsPayload>(
+      `${this.basePath}/attach-many-departments`,
+      body,
+      headers,
+    )
+  }
 }

package/src/apis/tags/types.ts

@@ -27,3 +27,12 @@ export type UpdateTagPayload = {
   label?: string
   backgroundColor?: string | null
 }
+
+/**
+ * Body for `POST /tags/attach-many-departments`. An empty `departmentIds` makes the tags
+ * available to every department.
+ */
+export type AttachTagsToDepartmentsPayload = {
+  ids: string[]
+  departmentIds: string[]
+}

package/src/apis/terms/TermsApi.test.ts

@@ -66,7 +66,7 @@ describe('TermsApi', () => {
     it('serializes the query', async () => {
       vi.mocked(client.get).mockResolvedValue(term)
       await api.getById('term-1', { attributes: ['id', 'version'] })
-      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('/terms/term-1?')
       expect(url).toContain('attributes')
     })

package/src/apis/users/UsersApi.test.ts

@@ -0,0 +1,228 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { UsersApi } from './UsersApi'
+import type { ApiClient } from '../../core/ApiClient'
+import type {
+  BulkUsersStatusPreview,
+  BulkUsersStatusResult,
+  ImportUsersResult,
+  User,
+  UserImportFile,
+  ValidateUserImportResult,
+} 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(),
+  }
+}
+
+// ── Fixtures ─────────────────────────────────────────────────────────
+
+const user: User = {
+  id: 'usr-1',
+  name: 'Alice',
+  email: 'alice@example.com',
+  phoneNumber: null,
+  branch: null,
+  isSuperAdmin: false,
+  isClientUser: false,
+  active: true,
+  language: 'pt-BR',
+  isFirstLogin: false,
+  status: 'offline',
+  clientsStatus: { web: 'offline', app: 'offline' },
+  offlineAt: null,
+  isActiveInternalChat: false,
+  passwordExpiresAt: null,
+  otpAuthActive: false,
+  preferences: {},
+  archivedAt: null,
+  accountId: 'acc-1',
+  timetableId: null,
+  createdAt: '2024-01-01T00:00:00Z',
+  updatedAt: '2024-01-01T00:00:00Z',
+  deletedAt: null,
+}
+
+const file: UserImportFile = { id: 'f1', name: 'users.csv', mimetype: 'text/csv' }
+const headers = { 'X-Custom': 'value' }
+
+// ── Tests ────────────────────────────────────────────────────────────
+
+describe('UsersApi', () => {
+  let client: ReturnType<typeof createMockClient>
+  let api: UsersApi
+
+  beforeEach(() => {
+    client = createMockClient()
+    api = new UsersApi(client)
+  })
+
+  describe('archive (ArchivableCrudApi)', () => {
+    it('keeps the plain PUT { archivedAt } used by the cleanup of the test suites', async () => {
+      await api.archive('usr-1')
+      const [url, body] = vi.mocked(client.put).mock.calls[0] ?? []
+      expect(url).toBe('/users/usr-1')
+      expect(body).toEqual({ archivedAt: expect.any(String) })
+    })
+  })
+
+  describe('archiveWithValidation', () => {
+    it('calls client.post with /users/:id/archive and { archive: true }', async () => {
+      const archived = { ...user, archivedAt: '2026-01-01T00:00:00Z' }
+      vi.mocked(client.post).mockResolvedValue(archived)
+      const result = await api.archiveWithValidation('usr-1', { archive: true })
+      expect(client.post).toHaveBeenCalledWith('/users/usr-1/archive', { archive: true }, undefined)
+      expect(result).toEqual(archived)
+    })
+
+    it('restores with { archive: false } and forwards custom headers', async () => {
+      await api.archiveWithValidation('usr-1', { archive: false }, headers)
+      expect(client.post).toHaveBeenCalledWith('/users/usr-1/archive', { archive: false }, headers)
+    })
+  })
+
+  describe('previewBulkStatus', () => {
+    it('calls client.post with /users/bulk-status/preview and body', async () => {
+      const preview: BulkUsersStatusPreview = {
+        scenario: 'allEligible',
+        totalSelected: 1,
+        noop: 0,
+        eligible: 1,
+        blocked: 0,
+        blockedSelf: false,
+        planSlotsAvailable: 10,
+      }
+      vi.mocked(client.post).mockResolvedValue(preview)
+      const body = { ids: ['usr-1'], archive: false }
+      const result = await api.previewBulkStatus(body)
+      expect(client.post).toHaveBeenCalledWith('/users/bulk-status/preview', body, undefined)
+      expect(result).toEqual(preview)
+    })
+  })
+
+  describe('bulkStatus', () => {
+    it('calls client.post with /users/bulk-status and body', async () => {
+      const response: BulkUsersStatusResult = {
+        changed: 1,
+        noop: 0,
+        blocked: 0,
+        failed: 0,
+        changedIds: ['usr-1'],
+        missingIds: [],
+      }
+      vi.mocked(client.post).mockResolvedValue(response)
+      const body = { ids: ['usr-1'], archive: true }
+      const result = await api.bulkStatus(body, headers)
+      expect(client.post).toHaveBeenCalledWith('/users/bulk-status', body, headers)
+      expect(result).toEqual(response)
+    })
+  })
+
+  describe('exportCsv', () => {
+    it('calls client.post with /users/export and resolves to the CSV text', async () => {
+      const csv = 'Nome,E-mail\nAlice,alice@example.com\n'
+      vi.mocked(client.post).mockResolvedValue(csv)
+      const result = await api.exportCsv({ filter: 'active' })
+      expect(client.post).toHaveBeenCalledWith('/users/export', { filter: 'active' }, undefined)
+      expect(result).toBe(csv)
+    })
+  })
+
+  describe('validateImport', () => {
+    it('calls client.post with /users/import/validate and the file', async () => {
+      const response: ValidateUserImportResult = {
+        licenses: { requestedRows: 1, available: 5, exceeded: false },
+        columns: {
+          required: [{ name: 'Nome', found: true }],
+          missingRequired: [],
+          optionalFound: [],
+        },
+        rows: { total: 1, valid: 1, invalid: 0, hasInvalid: false },
+        rowsWithOptionalColumns: { total: 1, valid: 1, invalid: 0, hasInvalid: false },
+      }
+      vi.mocked(client.post).mockResolvedValue(response)
+      const result = await api.validateImport({ file })
+      expect(client.post).toHaveBeenCalledWith('/users/import/validate', { file }, undefined)
+      expect(result).toEqual(response)
+    })
+  })
+
+  describe('startImport', () => {
+    it('calls client.post with /users/import and body', async () => {
+      const response: ImportUsersResult = { importId: 'imp-1' }
+      vi.mocked(client.post).mockResolvedValue(response)
+      const body = { file, useOptionalColumns: true }
+      const result = await api.startImport(body, headers)
+      expect(client.post).toHaveBeenCalledWith('/users/import', body, headers)
+      expect(result).toEqual(response)
+    })
+  })
+
+  describe('disableOtpAuth', () => {
+    it('calls client.post with /users/:id/disable-otp-auth and no body', async () => {
+      vi.mocked(client.post).mockResolvedValue(user)
+      const result = await api.disableOtpAuth('usr-1')
+      expect(client.post).toHaveBeenCalledWith(
+        '/users/usr-1/disable-otp-auth',
+        undefined,
+        undefined,
+      )
+      expect(result).toEqual(user)
+    })
+  })
+
+  describe('enableAccess', () => {
+    it('calls client.post with /users/:id/enable-access and no body', async () => {
+      const response = { success: true, message: 'User access enabled successfully' }
+      vi.mocked(client.post).mockResolvedValue(response)
+      const result = await api.enableAccess('usr-1', headers)
+      expect(client.post).toHaveBeenCalledWith('/users/usr-1/enable-access', undefined, headers)
+      expect(result).toEqual(response)
+    })
+  })
+
+  describe('getPinnedContacts', () => {
+    it('calls client.get with /users/pin', async () => {
+      vi.mocked(client.get).mockResolvedValue([])
+      const result = await api.getPinnedContacts()
+      expect(client.get).toHaveBeenCalledWith('/users/pin', undefined)
+      expect(result).toEqual([])
+    })
+  })
+
+  describe('togglePinContact', () => {
+    it('calls client.patch with /users/pin and resolves to the link rows when pinning', async () => {
+      const links = [
+        { userId: 'usr-1', contactId: 'c1', createdAt: '2026-01-01', updatedAt: '2026-01-01' },
+      ]
+      vi.mocked(client.patch).mockResolvedValue(links)
+      const result = await api.togglePinContact({ contactId: 'c1' })
+      expect(client.patch).toHaveBeenCalledWith('/users/pin', { contactId: 'c1' }, undefined)
+      expect(result).toEqual(links)
+    })
+
+    it('resolves to the number of removed links when unpinning', async () => {
+      vi.mocked(client.patch).mockResolvedValue(1)
+      await expect(api.togglePinContact({ contactId: 'c1' }, headers)).resolves.toBe(1)
+      expect(client.patch).toHaveBeenCalledWith('/users/pin', { contactId: 'c1' }, headers)
+    })
+  })
+
+  describe('error propagation', () => {
+    it('propagates errors from archiveWithValidation', async () => {
+      vi.mocked(client.post).mockRejectedValue(new Error('Bad request'))
+      await expect(api.archiveWithValidation('usr-1', { archive: true })).rejects.toThrow(
+        'Bad request',
+      )
+    })
+  })
+})

package/src/apis/users/UsersApi.ts

@@ -1,9 +1,160 @@
 import type { ApiClient } from '../../core/ApiClient'
 import { ArchivableCrudApi } from '../../core/ArchivableCrudApi'
-import type { User, CreateUserPayload, UpdateUserPayload } from './types'
+import type { Contact } from '../contacts/types'
+import type {
+  ArchiveUserPayload,
+  BulkUsersStatusPayload,
+  BulkUsersStatusPreview,
+  BulkUsersStatusResult,
+  CreateUserPayload,
+  EnableUserAccessResult,
+  ExportUsersPayload,
+  ImportUsersPayload,
+  ImportUsersResult,
+  TogglePinContactPayload,
+  TogglePinContactResult,
+  UpdateUserPayload,
+  User,
+  ValidateUserImportPayload,
+  ValidateUserImportResult,
+} from './types'
 
 export class UsersApi extends ArchivableCrudApi<User, CreateUserPayload, UpdateUserPayload> {
   constructor(client: ApiClient) {
     super(client, '/users')
   }
+
+  /**
+   * Archives or restores a user through the dedicated route used by the UI, which also
+   * sets the user offline and ends its sessions. The route enforces the business rules that
+   * {@link archive}/{@link unarchive} (a plain `PUT { archivedAt }`) skip:
+   * - archiving refuses (403) a user referenced by a bot or with open tickets;
+   * - restoring refuses (402) when the plan has no free user slot.
+   * @permissions users.view OR users.archive
+   */
+  archiveWithValidation(
+    id: string,
+    body: ArchiveUserPayload,
+    headers?: Record<string, string>,
+  ): Promise<User> {
+    return this.client.post<User, ArchiveUserPayload>(
+      `${this.basePath}/${id}/archive`,
+      body,
+      headers,
+    )
+  }
+
+  /**
+   * Previews a bulk archive/unarchive without changing anything.
+   * @permissions users.archive
+   */
+  previewBulkStatus(
+    body: BulkUsersStatusPayload,
+    headers?: Record<string, string>,
+  ): Promise<BulkUsersStatusPreview> {
+    return this.client.post<BulkUsersStatusPreview, BulkUsersStatusPayload>(
+      `${this.basePath}/bulk-status/preview`,
+      body,
+      headers,
+    )
+  }
+
+  /**
+   * Archives or unarchives up to 100 users at once.
+   * @permissions users.archive
+   */
+  bulkStatus(
+    body: BulkUsersStatusPayload,
+    headers?: Record<string, string>,
+  ): Promise<BulkUsersStatusResult> {
+    return this.client.post<BulkUsersStatusResult, BulkUsersStatusPayload>(
+      `${this.basePath}/bulk-status`,
+      body,
+      headers,
+    )
+  }
+
+  /**
+   * Exports the users of the account as CSV. Resolves to the CSV text.
+   * @permissions users.export
+   */
+  exportCsv(body: ExportUsersPayload, headers?: Record<string, string>): Promise<string> {
+    return this.client.post<string, ExportUsersPayload>(`${this.basePath}/export`, body, headers)
+  }
+
+  /**
+   * Validates a CSV file previously uploaded through `FilesApi` before importing it.
+   * @permissions users.create
+   */
+  validateImport(
+    body: ValidateUserImportPayload,
+    headers?: Record<string, string>,
+  ): Promise<ValidateUserImportResult> {
+    return this.client.post<ValidateUserImportResult, ValidateUserImportPayload>(
+      `${this.basePath}/import/validate`,
+      body,
+      headers,
+    )
+  }
+
+  /**
+   * Starts the import of a CSV file previously uploaded through `FilesApi`. The import runs
+   * in the background (the route answers `202 Accepted`).
+   * @permissions users.create
+   */
+  startImport(
+    body: ImportUsersPayload,
+    headers?: Record<string, string>,
+  ): Promise<ImportUsersResult> {
+    return this.client.post<ImportUsersResult, ImportUsersPayload>(
+      `${this.basePath}/import`,
+      body,
+      headers,
+    )
+  }
+
+  /**
+   * Turns off the two-factor authentication (OTP) of a user.
+   * @permissions users.update AND myAccount.update
+   */
+  disableOtpAuth(id: string, headers?: Record<string, string>): Promise<User> {
+    return this.client.post<User>(`${this.basePath}/${id}/disable-otp-auth`, undefined, headers)
+  }
+
+  /**
+   * Clears the login throttling of a user blocked by too many failed attempts.
+   * @permissions users.update
+   */
+  enableAccess(id: string, headers?: Record<string, string>): Promise<EnableUserAccessResult> {
+    return this.client.post<EnableUserAccessResult>(
+      `${this.basePath}/${id}/enable-access`,
+      undefined,
+      headers,
+    )
+  }
+
+  /**
+   * Returns the contacts pinned by the logged user.
+   * @permissions contacts.pin
+   */
+  getPinnedContacts(headers?: Record<string, string>): Promise<Contact[]> {
+    return this.client.get<Contact[]>(`${this.basePath}/pin`, headers)
+  }
+
+  /**
+   * Pins the contact for the logged user, or unpins it when already pinned. A user can pin
+   * up to 3 contacts. Resolves to the created link rows when pinning, or to the number of
+   * removed links when unpinning.
+   * @permissions contacts.pin
+   */
+  togglePinContact(
+    body: TogglePinContactPayload,
+    headers?: Record<string, string>,
+  ): Promise<TogglePinContactResult> {
+    return this.client.patch<TogglePinContactResult, TogglePinContactPayload>(
+      `${this.basePath}/pin`,
+      body,
+      headers,
+    )
+  }
 }