@ikatec/digisac-api-sdk 4.12.0 → 4.14.0

package/src/apis/knowledgeBase/types.ts

@@ -1,5 +1,6 @@
 import type { KnowledgeBaseItem } from '../knowledgeBaseItem/types'
 
+/** A knowledge base as the transformer answers it (`items` always comes: `[]` without the include). */
 export type KnowledgeBase = {
   id: string
   name: string
@@ -7,19 +8,78 @@ export type KnowledgeBase = {
   accountId: string
   createdAt: string
   updatedAt: string
-  deletedAt: string | null
+  /** @deprecated Not answered: the transformer of the backend does not send it. */
+  deletedAt?: string | null
   // relationships
   items?: KnowledgeBaseItem[]
+  account?: Record<string, unknown>
 }
 
-export type KnowledgeBaseRelationships = 'items'
+export type KnowledgeBaseRelationships = 'items' | 'account'
 
 export type CreateKnowledgeBasePayload = {
+  /** Up to 60 characters. */
   name: string
+  /** Up to 600 characters. */
   description?: string
 }
 
+/** The backend requires `name` on the update too (400 without it). */
 export type UpdateKnowledgeBasePayload = {
   name?: string
   description?: string | null
 }
+
+/**
+ * An item of `saveWithItems`. Any item VECTORIZES its content in the AI service (Haystack) on the save:
+ * `text` for `messages`, `url` for `urls` (the service fetches the page), `fileId` for `files`.
+ */
+export type SaveKnowledgeBaseItemInput = {
+  name: string
+  type: 'urls' | 'files' | 'messages'
+  url?: string
+  fileId?: string
+  text?: string
+}
+
+/** The body of `saveWithItems`: creates the base, or updates the one of `id`, with its items. */
+export type SaveKnowledgeBaseWithItemsPayload = {
+  /** 1 to 60 characters. */
+  name: string
+  /** Up to 600 characters. */
+  description?: string
+  /** The base to update (absent: a new base). */
+  id?: string
+  items?: SaveKnowledgeBaseItemInput[]
+  /** Items of the base to delete. */
+  deleteItemIds?: string[]
+}
+
+/** The stored base answered by `saveWithItems` (raw: with `synchronized`, without `items`). */
+export type SavedKnowledgeBase = Omit<KnowledgeBase, 'items' | 'account' | 'deletedAt'> & {
+  synchronized: boolean | null
+  deletedAt: string | null
+}
+
+/**
+ * What the suggestions answer: the suggested text, or a `message` code when nothing was suggested (e.g.
+ * `COPILOT_LIMIT_REACHED`, `COPILOT_TRANSCRIPTION_NOT_ENABLED`, `TRANSCRIBING_AUDIO_MESSAGES`).
+ */
+export type KnowledgeBaseSuggestion = {
+  message: string
+  hasAudioMessage?: boolean
+  hadEnoughCreditsToTranscribe?: boolean
+  [key: string]: unknown
+}
+
+export type SuggestByMessagePayload = {
+  messageId: string
+  /** Lets the AI answer beyond the knowledge base. */
+  outsideTheKnowledgeBase?: boolean
+}
+
+export type SuggestByTicketPayload = {
+  ticketId: string
+  /** Lets the AI answer beyond the knowledge base. */
+  outsideTheKnowledgeBase?: boolean
+}

package/src/apis/knowledgeBaseItem/KnowledgeBaseItemApi.test.ts

@@ -0,0 +1,57 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { KnowledgeBaseItemApi } from './KnowledgeBaseItemApi'
+import type { ApiClient } from '../../core/ApiClient'
+
+// ── Mock client factory ──────────────────────────────────────────────
+
+function createMockClient(): ApiClient {
+  return {
+    setAccessToken: vi.fn().mockReturnThis(),
+    request: vi.fn(),
+    requestRaw: vi.fn(),
+    get: vi.fn(),
+    post: vi.fn(),
+    put: vi.fn(),
+    patch: vi.fn(),
+    delete: vi.fn(),
+  }
+}
+
+// ── Tests ────────────────────────────────────────────────────────────
+
+describe('KnowledgeBaseItemApi', () => {
+  let client: ReturnType<typeof createMockClient>
+  let api: KnowledgeBaseItemApi
+
+  beforeEach(() => {
+    client = createMockClient()
+    api = new KnowledgeBaseItemApi(client)
+  })
+
+  it('fetchMany posts the ids to /knowledge-base-item/fetch-many', async () => {
+    vi.mocked(client.post).mockResolvedValue([])
+    await expect(api.fetchMany(['i-1'])).resolves.toEqual([])
+    expect(client.post).toHaveBeenCalledWith(
+      '/knowledge-base-item/fetch-many',
+      { ids: ['i-1'] },
+      undefined,
+    )
+  })
+
+  it('deleteMany sends DELETE /knowledge-base-item/many with the ids in the body', async () => {
+    vi.mocked(client.request).mockResolvedValue(true)
+    await expect(api.deleteMany(['i-1'])).resolves.toBe(true)
+    expect(client.request).toHaveBeenCalledWith(
+      'DELETE',
+      '/knowledge-base-item/many',
+      { ids: ['i-1'] },
+      undefined,
+    )
+  })
+
+  it('checkPdfText posts the file to /knowledge-base-item/check-pdf-text', async () => {
+    vi.mocked(client.post).mockResolvedValue({ hasText: false })
+    await expect(api.checkPdfText({})).resolves.toEqual({ hasText: false })
+    expect(client.post).toHaveBeenCalledWith('/knowledge-base-item/check-pdf-text', {}, undefined)
+  })
+})

package/src/apis/knowledgeBaseItem/KnowledgeBaseItemApi.ts

@@ -7,6 +7,10 @@ import type {
   UpdateKnowledgeBaseItemPayload,
 } from './types'
 
+/**
+ * Items of the knowledge bases. Creating an item VECTORIZES its content in the AI service; reading the
+ * `docs` (include, `fetchMany`) reads them from it.
+ */
 export class KnowledgeBaseItemApi extends BaseCrudApi<
   KnowledgeBaseItem,
   CreateKnowledgeBaseItemPayload,
@@ -26,4 +30,45 @@ export class KnowledgeBaseItemApi extends BaseCrudApi<
   override deleteById(id: string, headers?: Record<string, string>): Promise<false> {
     return super.deleteById(id, headers)
   }
+
+  /**
+   * Reads the items of `ids` with their documents (read from the AI service). Resolves the stored items, raw:
+   * unlike the other reads they carry `knowledgeBaseId`, `fileId` and `deletedAt`. An empty or absent `ids`
+   * answers 400 `Invalid knowledge base item ids`.
+   */
+  fetchMany(ids: string[], headers?: Record<string, string>): Promise<KnowledgeBaseItem[]> {
+    return this.client.post<KnowledgeBaseItem[], { ids: string[] }>(
+      `${this.basePath}/fetch-many`,
+      { ids },
+      headers,
+    )
+  }
+
+  /**
+   * Deletes the items of `ids` of the account (soft delete; their documents stay in the AI service).
+   * Resolves `true`; an empty or absent `ids` answers 400 `Invalid knowledge base item ids`.
+   */
+  deleteMany(ids: string[], headers?: Record<string, string>): Promise<true> {
+    return this.client.request<true, { ids: string[] }>(
+      'DELETE',
+      `${this.basePath}/many`,
+      { ids },
+      headers,
+    )
+  }
+
+  /**
+   * Tells whether the PDF of `fileId` has text to be vectorized (read locally, no AI). Without `fileId` it
+   * resolves `{ hasText: false }`.
+   */
+  checkPdfText(
+    body: { fileId?: string },
+    headers?: Record<string, string>,
+  ): Promise<{ hasText: boolean }> {
+    return this.client.post<{ hasText: boolean }, { fileId?: string }>(
+      `${this.basePath}/check-pdf-text`,
+      body,
+      headers,
+    )
+  }
 }

package/src/apis/knowledgeBaseItem/types.ts

@@ -1,35 +1,52 @@
 import type { File } from '../files/types'
 import type { KnowledgeBase } from '../knowledgeBase/types'
 
+/** An item as the transformer answers it (no `knowledgeBaseId`, `fileId` nor `deletedAt`). */
 export type KnowledgeBaseItem = {
   id: string
   name: string
-  type: string
+  type: 'urls' | 'files' | 'messages' | (string & {})
   sourceId: string | null
   url: string | null
   accountId: string
-  knowledgeBaseId: string
-  fileId: string | null
+  /** @deprecated Not answered: the transformer of the backend does not send it. */
+  knowledgeBaseId?: string
+  /** @deprecated Not answered: the transformer of the backend does not send it. */
+  fileId?: string | null
   createdAt: string
   updatedAt: string
-  deletedAt: string | null
+  /** @deprecated Not answered: the transformer of the backend does not send it. */
+  deletedAt?: string | null
   // relationships
+  /** @deprecated Not served: the include is dropped by the backend. */
   knowledgeBase?: KnowledgeBase
   file?: File | null
+  /** The vectorized documents (the include reads them from the AI service). */
+  docs?: Record<string, unknown>[]
+  account?: Record<string, unknown>
 }
 
-export type KnowledgeBaseItemRelationships = 'knowledgeBase' | 'file'
+export type KnowledgeBaseItemRelationships = 'knowledgeBase' | 'file' | 'docs' | 'account'
 
+/**
+ * Creates an item and VECTORIZES its content in the AI service right away: `text` (type `messages`), `url`
+ * (type `urls`, the service fetches the page) or `fileId` (type `files`). Without any of the three it
+ * answers 400 `You must provide fileId, text, or url`.
+ */
 export type CreateKnowledgeBaseItemPayload = {
   name: string
-  type: string
+  type: 'urls' | 'files' | 'messages' | (string & {})
   knowledgeBaseId: string
+  /** @deprecated Ignored by the backend. */
   sourceId?: string
+  text?: string
   url?: string
   fileId?: string
 }
 
+/** The backend requires `name`, `type` and `knowledgeBaseId` on the update too (400 without them). */
 export type UpdateKnowledgeBaseItemPayload = {
+  knowledgeBaseId?: string
   name?: string
   type?: string
   sourceId?: string | null

package/src/apis/me/MeApi.test.ts

@@ -296,7 +296,7 @@ describe('MeApi', () => {
   describe('registerToken', () => {
     it('calls client.post with /me/one-signal/register-token and body', async () => {
       vi.mocked(client.post).mockResolvedValue(undefined)
-      const body: RegisterTokenPayload = { token: 'abc123', platform: 'web' }
+      const body: RegisterTokenPayload = { data: { oneSignalToken: 'abc123' } }
       await api.registerToken(body)
       expect(client.post).toHaveBeenCalledWith('/me/one-signal/register-token', body, undefined)
     })

package/src/apis/notifications/NotificationsApi.test.ts

@@ -0,0 +1,74 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { NotificationsApi } from './NotificationsApi'
+import type { ApiClient } from '../../core/ApiClient'
+
+// ── Mock client factory ──────────────────────────────────────────────
+
+function createMockClient(): ApiClient {
+  return {
+    setAccessToken: vi.fn().mockReturnThis(),
+    request: vi.fn(),
+    requestRaw: vi.fn(),
+    get: vi.fn(),
+    post: vi.fn(),
+    put: vi.fn(),
+    patch: vi.fn(),
+    delete: vi.fn(),
+  }
+}
+
+// ── Tests ────────────────────────────────────────────────────────────
+
+describe('NotificationsApi', () => {
+  let client: ReturnType<typeof createMockClient>
+  let api: NotificationsApi
+
+  beforeEach(() => {
+    client = createMockClient()
+    api = new NotificationsApi(client)
+  })
+
+  it('count posts to /notifications/count and resolves the counts as text', async () => {
+    const counts = { count: { total: '3', read: '1', unread: '2' } }
+    vi.mocked(client.post).mockResolvedValue(counts)
+    await expect(api.count()).resolves.toEqual(counts)
+    expect(client.post).toHaveBeenCalledWith('/notifications/count', undefined, undefined)
+  })
+
+  it('read puts to /notifications/:id/read', async () => {
+    await api.read('n-1')
+    expect(client.put).toHaveBeenCalledWith('/notifications/n-1/read', undefined, undefined)
+  })
+
+  it('unread puts to /notifications/:id/unread', async () => {
+    await api.unread('n-1')
+    expect(client.put).toHaveBeenCalledWith('/notifications/n-1/unread', undefined, undefined)
+  })
+
+  it('readMany posts the ids as the body', async () => {
+    await api.readMany(['n-1', 'n-2'])
+    expect(client.post).toHaveBeenCalledWith('/notifications/read-many', ['n-1', 'n-2'], undefined)
+  })
+
+  it('readAll calls client.get with /notifications/read-all', async () => {
+    vi.mocked(client.get).mockResolvedValue({ total: 2, read: 2, unread: 0 })
+    await expect(api.readAll()).resolves.toEqual({ total: 2, read: 2, unread: 0 })
+    expect(client.get).toHaveBeenCalledWith('/notifications/read-all', undefined)
+  })
+
+  it('resetBadgeCount posts to /notifications/reset-badge-count', async () => {
+    vi.mocked(client.post).mockResolvedValue({ success: true })
+    await expect(api.resetBadgeCount()).resolves.toEqual({ success: true })
+    expect(client.post).toHaveBeenCalledWith(
+      '/notifications/reset-badge-count',
+      undefined,
+      undefined,
+    )
+  })
+
+  it('sendAll posts the announcement to /notifications/send-all', async () => {
+    const body = { text: 'Aviso', to: 'admin' as const }
+    await api.sendAll(body)
+    expect(client.post).toHaveBeenCalledWith('/notifications/send-all', body, undefined)
+  })
+})

package/src/apis/notifications/NotificationsApi.ts

@@ -1,8 +1,19 @@
 import type { ApiClient } from '../../core/ApiClient'
 import type { ListQuery } from '../../core/types'
 import { BaseCrudApi } from '../../core/BaseCrudApi'
-import type { Notification, CreateNotificationPayload, UpdateNotificationPayload } from './types'
+import type {
+  Notification,
+  CreateNotificationPayload,
+  UpdateNotificationPayload,
+  NotificationCountsResponse,
+  NotificationReadAllResponse,
+  SendAllNotificationsPayload,
+} from './types'
 
+/**
+ * Notifications of the current user (all of the account with `notification.view.all`). Some types open a modal in the web app as soon as they arrive (`announcement`, `credits-90`,
+ * `credits-100`, `smart-summary`, `warn-service-reconnect`).
+ */
 export class NotificationsApi extends BaseCrudApi<
   Notification,
   CreateNotificationPayload,
@@ -15,10 +26,84 @@ export class NotificationsApi extends BaseCrudApi<
   }
 
   /**
-   * Deletes a notification. Resolves the text `'OK'`; an unknown id answers 500. The route checks
-   * no permission.
+   * Deletes a notification. Resolves the text `'OK'`; an unknown id answers 500.
    */
   override deleteById(id: string, headers?: Record<string, string>): Promise<'OK'> {
     return super.deleteById(id, headers)
   }
+
+  /**
+   * Counts the notifications the user sees: `{ count: { total, read, unread } }`, as TEXT.
+   */
+  count(headers?: Record<string, string>): Promise<NotificationCountsResponse> {
+    return this.client.post<NotificationCountsResponse>(
+      `${this.basePath}/count`,
+      undefined,
+      headers,
+    )
+  }
+
+  /**
+   * Marks a notification as read for the current user and resolves the new counts. An unknown id answers
+   * 400 `Notification not found.`.
+   */
+  read(id: string, headers?: Record<string, string>): Promise<NotificationCountsResponse> {
+    return this.client.put<NotificationCountsResponse>(
+      `${this.basePath}/${id}/read`,
+      undefined,
+      headers,
+    )
+  }
+
+  /**
+   * Marks a notification as unread for the current user and resolves the new counts. An unknown id
+   * answers 400 `Notification not found.`.
+   */
+  unread(id: string, headers?: Record<string, string>): Promise<NotificationCountsResponse> {
+    return this.client.put<NotificationCountsResponse>(
+      `${this.basePath}/${id}/unread`,
+      undefined,
+      headers,
+    )
+  }
+
+  /**
+   * Marks the notifications of `ids` as read. Resolves with no body; a body that is not an array answers
+   * 500 `Body must be an array of notification IDs`.
+   */
+  readMany(ids: string[], headers?: Record<string, string>): Promise<void> {
+    return this.client.post<void, string[]>(`${this.basePath}/read-many`, ids, headers)
+  }
+
+  /**
+   * Marks every notification the user sees as read (a GET that writes: it recreates the read receipts of
+   * the user) and resolves the counts, as numbers.
+   */
+  readAll(headers?: Record<string, string>): Promise<NotificationReadAllResponse> {
+    return this.client.get<NotificationReadAllResponse>(`${this.basePath}/read-all`, headers)
+  }
+
+  /** Clears the push badge counter of the current user. Resolves `{ success: true }`. */
+  resetBadgeCount(headers?: Record<string, string>): Promise<{ success: true }> {
+    return this.client.post<{ success: true }>(
+      `${this.basePath}/reset-badge-count`,
+      undefined,
+      headers,
+    )
+  }
+
+  /**
+   * SENDS an announcement (`type: 'announcement'`, which opens a modal in the web app) to every user of
+   * the account, or only to the admins with `to: 'admin'`. Resolves `{ message: 'Notificações enviadas' }` before the notifications are created.
+   */
+  sendAll(
+    body: SendAllNotificationsPayload,
+    headers?: Record<string, string>,
+  ): Promise<{ message: string }> {
+    return this.client.post<{ message: string }, SendAllNotificationsPayload>(
+      `${this.basePath}/send-all`,
+      body,
+      headers,
+    )
+  }
 }

package/src/apis/notifications/types.ts

@@ -13,46 +13,107 @@ export type NotificationType =
   | 'undefined'
   | 'waba-health-warning'
   | 'waba-health-block'
+  | 'kanban-board-initialized'
+  | 'users-bulk-archive-blocked'
+  | 'user-import'
+  | 'credits-90'
+  | 'credits-100'
+  | 'smart-summary'
+  | 'warn-service-reconnect'
 
-/** Present on pipeline-related notifications. */
+/** Extra data of the notification; the pipeline notifications carry the pipeline ids. */
 export type NotificationConfig = {
-  pipelineId: string
-  pipelineAutomationId: string
+  pipelineId?: string
+  pipelineAutomationId?: string
+  [key: string]: unknown
+}
+
+/** The read receipt of a notification for the current user. */
+export type NotificationRead = {
+  id: string
+  notificationId: string
+  userId: string
+  readAt: string | null
+  createdAt: string
+  updatedAt: string
+}
+
+/**
+ * Counts of the notifications the user sees (all of the account with `notification.view.all`).
+ * They come as TEXT: the backend answers the `COUNT` of the database as is (e.g. `"43"`).
+ */
+export type NotificationCounts = {
+  total: string
+  read: string
+  unread: string
+}
+
+/** What `read`, `unread` and `count` answer. */
+export type NotificationCountsResponse = {
+  count: NotificationCounts
+}
+
+/** What `readAll` answers: the counts after marking everything as read, as numbers. */
+export type NotificationReadAllResponse = {
+  total: number
+  read: number
+  unread: number
+}
+
+/** The body of `sendAll`: `to: 'admin'` sends only to the admins; any other value sends to every user. */
+export type SendAllNotificationsPayload = {
+  /** Up to 255 characters. */
+  text: string
+  to: 'admin' | 'all' | (string & {})
+  image?: string
 }
 
 export type Notification = {
   id: string
   text: string
   type: NotificationType | null
-  read: boolean
+  /** `null` on the announcements of `sendAll` until they are read. */
+  read: boolean | null
   image: string | null
   label: string | null
   config: NotificationConfig | null
   attachedType: string | null
+  /** @deprecated Not answered: the model has no such column, so the transformer never sends it. */
+  attachedId?: string | null
+  /** @deprecated Not answered: the model has no such column, so the transformer never sends it. */
+  notificationReadId?: string | null
   contactId: string | null
   userId: string
   accountId: string
   scheduleId: string | null
   createdAt: string
   updatedAt: string
-  deletedAt: string | null
+  /** @deprecated Not answered: the transformer of the backend does not send it. */
+  deletedAt?: string | null
   // relationships
   user?: User
   schedule?: Schedule | null
+  /** @deprecated Not served: the model has no such association, so it never comes. */
   contact?: Contact | null
+  /** The read receipts of the notification (a list: `[]` while it was never read). */
+  notificationRead?: NotificationRead[]
 }
 
-export type NotificationRelationships = 'user' | 'schedule' | 'contact'
+/** The backend serves `user`, `schedule` and `notificationRead` (`contact` is never answered). */
+export type NotificationRelationships = 'user' | 'schedule' | 'contact' | 'notificationRead'
 
 export type CreateNotificationPayload = {
+  /** Up to 255 characters. */
   text: string
-  userId: string
+  /** Ignored: the backend creates the notification for the current user. */
+  userId?: string
   type?: NotificationType
   label?: string
   config?: NotificationConfig
   attachedType?: string
   contactId?: string
   scheduleId?: string
+  image?: string
 }
 
 export type UpdateNotificationPayload = {

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

@@ -71,6 +71,18 @@ import { KnowledgeBaseApi } from './knowledgeBase/KnowledgeBaseApi'
 import { KnowledgeBaseItemApi } from './knowledgeBaseItem/KnowledgeBaseItemApi'
 import { MessagesApi } from './messages/MessagesApi'
 import { NotificationsApi } from './notifications/NotificationsApi'
+import type {
+  Notification,
+  NotificationCountsResponse,
+  NotificationRead,
+} from './notifications/types'
+import { AbsenceApi } from './absence/AbsenceApi'
+import type { AbsenceReportItem, UnlockAbsenceResponse } from './absence/types'
+import { ActivityLogApi } from './activityLog/ActivityLogApi'
+import { CreditMovementsApi } from './creditMovements/CreditMovementsApi'
+import type { CreditBalances, CreditTotalServices } from './creditMovements/types'
+import { StickersApi } from './stickers/StickersApi'
+import type { Sticker } from './stickers/types'
 import { OrganizationsApi } from './organizations/OrganizationsApi'
 import { PeopleApi } from './people/PeopleApi'
 import { ServicesApi } from './services/ServicesApi'
@@ -703,3 +715,57 @@ expectAssignable<ApiClient>({
   patch: async <T>() => undefined as T,
   delete: async <T>() => undefined as T,
 })
+
+// ── QARC-1010: notifications, absence, log, knowledge base, credits, stickers ─────
+
+expectType<Promise<NotificationCountsResponse>>(new NotificationsApi(client).count())
+expectType<Promise<string>>(new NotificationsApi(client).count().then(({ count }) => count.total))
+expectError(new NotificationsApi(client).sendAll({ to: 'admin' }))
+expectType<Promise<void>>(new NotificationsApi(client).readMany(['n-1']))
+expectType<Promise<Paginated<AbsenceReportItem>>>(
+  new AbsenceApi(client).report({ filters: { reason: 'x' }, order: 'ASC' }),
+)
+expectType<Promise<UnlockAbsenceResponse>>(new AbsenceApi(client).unlock({}))
+expectError(new AbsenceApi(client).report({ sort: 'name' }))
+expectType<Promise<string>>(
+  new ActivityLogApi(client).exportCsv({ filters: { from: 'a', to: 'b' } }),
+)
+expectAssignable<Parameters<ActivityLogApi['create']>[0]>({
+  resourceType: 'contact',
+  event: 'update',
+})
+expectType<Promise<true>>(new KnowledgeBaseItemApi(client).deleteMany(['i-1']))
+expectError(
+  new KnowledgeBaseApi(client).saveWithItems({ name: 'qa', items: [{ name: 'x', type: 'pdf' }] }),
+)
+expectType<Promise<CreditBalances>>(new CreditMovementsApi(client).balances())
+expectType<Promise<number>>(new CreditMovementsApi(client).balance('sms-wavy'))
+expectType<Promise<CreditTotalServices | undefined>>(
+  new CreditMovementsApi(client).totalServices({
+    filters: { from: 'a', to: 'b', serviceType: 'summary' },
+    page: 1,
+  }),
+)
+expectType<Promise<ArrayBuffer>>(
+  new CreditMovementsApi(client).exportXlsx({ from: 'a', to: 'b', where: { $and: [] } }),
+)
+expectType<Promise<Sticker>>(new StickersApi(client).create({ base64: 'iVBOR', name: 'qa' }))
+expectError(new StickersApi(client).create({ type: 'created' }))
+expectType<Promise<'OK' | false>>(new StickersApi(client).remove('s-1'))
+expectAssignable<Parameters<StickersApi['getMany']>[0]>({ include: ['file'] })
+
+// ── QARC-1010 (4.13.1): the shapes observed on qa-rc ─────────────────
+
+declare const notification: Notification
+expectType<NotificationRead[] | undefined>(notification.notificationRead)
+expectType<string | null | undefined>(notification.attachedId)
+declare const sticker: Sticker
+expectAssignable<Sticker>({ ...sticker, originMessage: null })
+expectAssignable<Promise<{ message: string }>>(
+  new ServicesApi(client).accessManagement('s-1', { userIds: ['u-1'], deny: true }),
+)
+expectAssignable<Awaited<ReturnType<ServicesApi['accessManagement']>>>({
+  message: '2 users allowed access.',
+})
+expectNotAssignable<Awaited<ReturnType<ServicesApi['accessManagement']>>>({ message: 'denied' })
+expectError(new ServicesApi(client).accessManagement('s-1', { userIds: ['u-1'] }))

package/src/apis/serviceAccessManagement/ServiceAccessManagementApi.ts

@@ -6,7 +6,10 @@ export class ServiceAccessManagementApi
   extends BaseApi
   implements HasGetMany<ServiceAccessManagement>
 {
-  /** Returns a paginated list of which users have access to which services. */
+  /**
+   * The connections denied to each user (one row per user × connection, written by
+   * `POST /services/:id/access-management`), raw. Filter by the `serviceId` or `userId` you want.
+   */
   getMany(
     query: ListQuery<ServiceAccessManagement> & { paginate: false },
     headers?: Record<string, string>,

package/src/apis/serviceAccessManagement/types.ts

@@ -6,8 +6,11 @@ export type ServiceAccessManagement = {
   serviceId: string
   createdAt: string
   // relationships
+  /** @deprecated Not served: the backend drops every include of this route. */
   user?: User
+  /** @deprecated Not served: the backend drops every include of this route. */
   service?: Service
 }
 
+/** None is served: the backend drops every include of this route. */
 export type ServiceAccessManagementRelationships = 'user' | 'service'