@ikatec/digisac-api-sdk 4.10.0 → 4.12.0

package/src/apis/distribution/types.ts

@@ -11,7 +11,8 @@ export type Distribution = {
   distributeQueue: boolean
   accountId: string
   archivedAt: string | null
-  deletedAt: string | null
+  /** Only in the answer of `updateById` (the stored model, not transformed). */
+  deletedAt?: string | null
   createdAt: string
   updatedAt: string
   // relationships
@@ -21,6 +22,9 @@ export type Distribution = {
 
 export type DistributionRelationships = 'departments' | 'roles'
 
+/** A department or a role linked to a distribution (only the id is read). */
+export type DistributionLink = { id: string }
+
 export type CreateDistributionPayload = {
   name: string
   maxNum: number
@@ -28,8 +32,17 @@ export type CreateDistributionPayload = {
   timeToRedistribute?: number
   redistributeAssignedTickets?: boolean
   distributeQueue?: boolean
+  /** An archived distribution is skipped by the distribution crons. */
+  archivedAt?: string | null
+  /** Departments to distribute; a department has at most one distribution. */
+  departments?: DistributionLink[]
+  roles?: DistributionLink[]
 }
 
+/**
+ * The update replaces the links: send `departments` and `roles` again to keep them — omitting them
+ * clears them.
+ */
 export type UpdateDistributionPayload = {
   name?: string
   maxNum?: number
@@ -37,4 +50,7 @@ export type UpdateDistributionPayload = {
   timeToRedistribute?: number
   redistributeAssignedTickets?: boolean
   distributeQueue?: boolean
+  archivedAt?: string | null
+  departments?: DistributionLink[]
+  roles?: DistributionLink[]
 }

package/src/apis/integrations/IntegrationsApi.test.ts

@@ -0,0 +1,42 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { IntegrationsApi } from './IntegrationsApi'
+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(),
+  }
+}
+
+// ── Tests ────────────────────────────────────────────────────────────
+
+describe('IntegrationsApi', () => {
+  let client: ReturnType<typeof createMockClient>
+  let api: IntegrationsApi
+
+  beforeEach(() => {
+    client = createMockClient()
+    api = new IntegrationsApi(client)
+  })
+
+  it('create posts to /integrations and resolves the empty object the route answers', async () => {
+    vi.mocked(client.post).mockResolvedValue({})
+    const body = { type: 'menu_button', url: 'https://example.com', icon: '', text: 'QA' }
+    await expect(api.create(body)).resolves.toEqual({})
+    expect(client.post).toHaveBeenCalledWith('/integrations', body, undefined)
+  })
+
+  it('updateById puts to /integrations/:id and resolves the empty object', async () => {
+    vi.mocked(client.put).mockResolvedValue({})
+    await expect(api.updateById('int-1', { text: 'QA 2' })).resolves.toEqual({})
+    expect(client.put).toHaveBeenCalledWith('/integrations/int-1', { text: 'QA 2' }, undefined)
+  })
+})

package/src/apis/integrations/IntegrationsApi.ts

@@ -1,19 +1,52 @@
 import type { ApiClient } from '../../core/ApiClient'
 import type { ListQuery } from '../../core/types'
 import { BaseCrudApi } from '../../core/BaseCrudApi'
-import type { Integration, CreateIntegrationPayload, UpdateIntegrationPayload } from './types'
+import type {
+  Integration,
+  CreateIntegrationPayload,
+  UpdateIntegrationPayload,
+  IntegrationWriteResponse,
+} from './types'
 
+/** Integrations of the account (buttons and events of the UI). `getById` answers `null` for an unknown id. */
 export class IntegrationsApi extends BaseCrudApi<
   Integration,
   CreateIntegrationPayload,
   UpdateIntegrationPayload,
   ListQuery<Integration>,
-  'OK'
+  'OK',
+  IntegrationWriteResponse,
+  IntegrationWriteResponse
 > {
   constructor(client: ApiClient) {
     super(client, '/integrations')
   }
 
+  /**
+   * Creates an integration. Resolves `{}` — also when the type is unique (`event_ticket_transfer`,
+   * `event_ticket_closed`), already exists in the account and nothing is created. Find the integration with
+   * `getMany` (e.g. by `text`).
+   * @permissions integrations.create
+   */
+  override create(
+    body: CreateIntegrationPayload,
+    headers?: Record<string, string>,
+  ): Promise<IntegrationWriteResponse> {
+    return super.create(body, headers)
+  }
+
+  /**
+   * Updates an integration. Resolves `{}`; read it again with `getById`. An unknown id answers 500.
+   * @permissions integrations.view OR integrations.update
+   */
+  override updateById(
+    id: string,
+    body: UpdateIntegrationPayload,
+    headers?: Record<string, string>,
+  ): Promise<IntegrationWriteResponse> {
+    return super.updateById(id, body, headers)
+  }
+
   /**
    * Deletes an integration. Resolves the text `'OK'`; an unknown id answers 500.
    * @permissions integrations.view OR integrations.destroy

package/src/apis/integrations/types.ts

@@ -1,27 +1,46 @@
+/**
+ * The types the UI shows: buttons (`menu_button` in the header, `context_menu_button_*` in the contact and
+ * message menus) and events that open the integration when a ticket is transferred or closed (unique per
+ * account). The backend accepts any string.
+ */
+export type IntegrationType =
+  | 'menu_button'
+  | 'context_menu_button_contact_modal'
+  | 'context_menu_button_contact_side_list'
+  | 'context_menu_button_message'
+  | 'event_ticket_transfer'
+  | 'event_ticket_closed'
+  | (string & {})
+
+export type IntegrationSize = 'sm' | 'md' | 'lg' | (string & {})
+
 export type Integration = {
   id: string
-  type: string
+  type: IntegrationType
   url: string | null
   icon: string | null
   text: string | null
-  size: string | null
+  size: IntegrationSize | null
   accountId: string
   createdAt: string
   updatedAt: string
 }
 
+/** What `create` and `updateById` resolve to: an empty object. */
+export type IntegrationWriteResponse = Record<string, never>
+
 export type CreateIntegrationPayload = {
-  type: string
+  type: IntegrationType
   url?: string
   icon?: string
   text?: string
-  size?: string
+  size?: IntegrationSize
 }
 
 export type UpdateIntegrationPayload = {
-  type?: string
+  type?: IntegrationType
   url?: string | null
   icon?: string | null
   text?: string | null
-  size?: string | null
+  size?: IntegrationSize | null
 }

package/src/apis/interactiveMessages/InteractiveMessagesApi.test.ts

@@ -0,0 +1,59 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { InteractiveMessagesApi } from './InteractiveMessagesApi'
+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(),
+  }
+}
+
+// ── Tests ────────────────────────────────────────────────────────────
+
+describe('InteractiveMessagesApi', () => {
+  let client: ReturnType<typeof createMockClient>
+  let api: InteractiveMessagesApi
+
+  beforeEach(() => {
+    client = createMockClient()
+    api = new InteractiveMessagesApi(client)
+  })
+
+  describe('count', () => {
+    it('calls client.get with /interactive-messages/count when no query is provided', async () => {
+      vi.mocked(client.get).mockResolvedValue({ count: 4 })
+      await expect(api.count()).resolves.toEqual({ count: 4 })
+      expect(client.get).toHaveBeenCalledWith('/interactive-messages/count', undefined)
+    })
+
+    it('serializes the query', async () => {
+      vi.mocked(client.get).mockResolvedValue({ count: 1 })
+      await api.count({ where: { name: 'QA' } })
+      const url = vi.mocked(client.get).mock.calls[0]?.[0] as string
+      expect(url).toContain('/interactive-messages/count?')
+      expect(url).toContain('where')
+    })
+  })
+
+  it('create posts the message to /interactive-messages', async () => {
+    const body = {
+      name: 'QA',
+      interactive: {
+        type: 'button' as const,
+        body: 'Oi',
+        action: { buttons: [{ type: 'reply' as const, reply: { id: '1', title: 'Sim' } }] },
+      },
+    }
+    vi.mocked(client.post).mockResolvedValue({ id: 'im-1' })
+    await api.create(body)
+    expect(client.post).toHaveBeenCalledWith('/interactive-messages', body, undefined)
+  })
+})

package/src/apis/interactiveMessages/InteractiveMessagesApi.ts

@@ -18,6 +18,32 @@ export class InteractiveMessagesApi extends BaseCrudApi<
     super(client, '/interactive-messages')
   }
 
+  /**
+   * Counts the interactive messages matching the query.
+   * @permissions interactive-messages.view OR interactive-messages.management.all.departments
+   */
+  count(
+    query?: ListQuery<InteractiveMessage>,
+    headers?: Record<string, string>,
+  ): Promise<{ count: number }> {
+    return this.client.get<{ count: number }>(
+      `${this.basePath}/count${this.toQueryString(query)}`,
+      headers,
+    )
+  }
+
+  /**
+   * Creates an interactive message. Only `cta_url` is validated by the backend (the other types are stored as
+   * sent). The answer has no `departments` nor `file`: read them with `getById` and `include`.
+   * @permissions interactive-messages.create OR interactive-messages.management.all.departments
+   */
+  override create(
+    body: CreateInteractiveMessagePayload,
+    headers?: Record<string, string>,
+  ): Promise<InteractiveMessage> {
+    return super.create(body, headers)
+  }
+
   /**
    * Deletes an interactive message. Resolves the text `'OK'`; an unknown id answers 500.
    * @permissions interactive-messages.destroy OR interactive-messages.management.all.departments

package/src/apis/interactiveMessages/types.ts

@@ -169,7 +169,8 @@ type InteractiveMessageFilePayload =
 export type InteractiveMessage = {
   id: string
   name: string
-  type: 'list' | 'button' | 'cta_url' | 'request_contact_info'
+  /** @deprecated Not a field of the backend (no such column): the type is `interactive.type`. */
+  type?: 'list' | 'button' | 'cta_url' | 'request_contact_info'
   interactive: InteractiveMessageContent
   archivedAt: string | null
   accountId: string
@@ -179,9 +180,10 @@ export type InteractiveMessage = {
   // relationships
   file?: File | null
   departments?: Department[]
+  account?: Record<string, unknown>
 }
 
-export type InteractiveMessageRelationships = 'file' | 'departments'
+export type InteractiveMessageRelationships = 'file' | 'departments' | 'account'
 
 export type CreateInteractiveMessagePayload = {
   name: string
@@ -191,6 +193,10 @@ export type CreateInteractiveMessagePayload = {
   file?: InteractiveMessageFilePayload
 }
 
+/**
+ * The backend requires `name` and `interactive` on the update too. It replaces the departments: omitting
+ * `departmentIds`/`departments` clears them. Only `file.base64Url` is read (a `file.id` is ignored).
+ */
 export type UpdateInteractiveMessagePayload = {
   name?: string
   interactive?: InteractiveMessageContentInput

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

@@ -110,6 +110,50 @@ describe('MeApi', () => {
     })
   })
 
+  describe('getMe with a query', () => {
+    it('serializes the include and keeps the headers', async () => {
+      vi.mocked(client.get).mockResolvedValue(user)
+      const headers = { 'X-Custom': 'h' }
+      await api.getMe({ include: ['roles', 'account'] }, headers)
+      const [url, sent] = vi.mocked(client.get).mock.calls[0] ?? []
+      expect(url).toMatch(/^\/me\?/)
+      expect(url).toContain('include')
+      expect(sent).toBe(headers)
+    })
+  })
+
+  describe('getAccount with where.id', () => {
+    it('serializes the id of the account', async () => {
+      vi.mocked(client.get).mockResolvedValue(account)
+      await api.getAccount({ where: { id: 'acc-1' } })
+      const url = vi.mocked(client.get).mock.calls[0]?.[0] as string
+      expect(url).toMatch(/^\/me\/account\?/)
+      expect(url).toContain('acc-1')
+    })
+  })
+
+  describe('getAccountAmounts with a filter', () => {
+    it('sends the filter as a comma-separated list', async () => {
+      vi.mocked(client.get).mockResolvedValue({ accountId: 'acc-1' })
+      await api.getAccountAmounts({ filter: ['services.amounts', 'users.amounts'] })
+      const url = vi.mocked(client.get).mock.calls[0]?.[0] as string
+      expect(url).toMatch(/^\/me\/get-account-amounts\?/)
+      expect(decodeURIComponent(url)).toContain('services.amounts,users.amounts')
+    })
+
+    it('keeps the headers-only call', async () => {
+      const headers = { 'X-Custom': 'h' }
+      await api.getAccountAmounts(headers)
+      expect(client.get).toHaveBeenCalledWith('/me/get-account-amounts', headers)
+    })
+
+    it('keeps a header that comes as undefined at runtime as a header', async () => {
+      const headers = { Authorization: undefined } as unknown as Record<string, string>
+      await api.getAccountAmounts(headers)
+      expect(client.get).toHaveBeenCalledWith('/me/get-account-amounts', headers)
+    })
+  })
+
   // ── getAccount ───────────────────────────────────────────────────
 
   describe('getAccount', () => {

package/src/apis/me/MeApi.ts

@@ -2,6 +2,11 @@ import { BaseApi } from '../../core/BaseApi'
 import type { Account } from '../accounts/types'
 import type { User } from '../users/types'
 import type {
+  AccountAmounts,
+  AccountAmountsQuery,
+  MeAccountQuery,
+  MeQuery,
+  MeStatusResponse,
   RegisterTokenPayload,
   SetOtpSecretKeyPayload,
   TakeoverPayload,
@@ -10,30 +15,74 @@ import type {
   UpdateMeStatusPayload,
 } from './types'
 
+/**
+ * A query object always has an array or an object among its values; the headers only have strings (a header that
+ * comes as `undefined` at runtime stays a header). That tells the two apart in the methods that took only the
+ * headers before and now take a query first.
+ */
+function splitQueryAndHeaders<TQuery extends object>(
+  queryOrHeaders: TQuery | Record<string, string> | undefined,
+  headers: Record<string, string> | undefined,
+): [TQuery | undefined, Record<string, string> | undefined] {
+  const isQuery =
+    !!queryOrHeaders &&
+    Object.values(queryOrHeaders).some((value) => typeof value === 'object' && value !== null)
+  return isQuery
+    ? [queryOrHeaders as TQuery, headers]
+    : [undefined, queryOrHeaders as Record<string, string> | undefined]
+}
+
 export class MeApi extends BaseApi {
   /**
-   * Returns the currently authenticated user, including their roles, departments, and timetable.
+   * Returns the currently authenticated user. Without `include`, the user comes without relations (roles,
+   * departments, timetable, account).
    * @permissions users.view
    */
-  getMe(headers?: Record<string, string>): Promise<User> {
-    return this.client.get<User>('/me', headers)
+  getMe(headers?: Record<string, string>): Promise<User>
+  getMe(query: MeQuery, headers?: Record<string, string>): Promise<User>
+  getMe(
+    queryOrHeaders?: MeQuery | Record<string, string>,
+    headers?: Record<string, string>,
+  ): Promise<User> {
+    const [query, sent] = splitQueryAndHeaders<MeQuery>(queryOrHeaders, headers)
+    return this.client.get<User>(`/me${this.toQueryString(query)}`, sent)
   }
 
-  /** Returns the account associated with the currently authenticated user. */
-  getAccount(headers?: Record<string, string>): Promise<Account> {
-    return this.client.get<Account>('/me/account', headers)
+  /**
+   * Returns the account of the current user. Send `where.id` with the `accountId` of the user (what the web app
+   * does): without it, the route answers 500.
+   */
+  getAccount(headers?: Record<string, string>): Promise<Account>
+  getAccount(query: MeAccountQuery, headers?: Record<string, string>): Promise<Account>
+  getAccount(
+    queryOrHeaders?: MeAccountQuery | Record<string, string>,
+    headers?: Record<string, string>,
+  ): Promise<Account> {
+    const [query, sent] = splitQueryAndHeaders<MeAccountQuery>(queryOrHeaders, headers)
+    return this.client.get<Account>(`/me/account${this.toQueryString(query)}`, sent)
   }
 
   /**
-   * Returns credit and usage amounts for the current account.
-   * Excludes Digisac's own internal credit amounts.
+   * Returns the amounts of the current account named in `filter` (services and/or users). The credit amounts are
+   * never answered here. An account without credits control answers 400.
    */
-  getAccountAmounts(headers?: Record<string, string>): Promise<Record<string, unknown>> {
-    return this.client.get<Record<string, unknown>>('/me/get-account-amounts', headers)
+  getAccountAmounts(headers?: Record<string, string>): Promise<AccountAmounts>
+  getAccountAmounts(
+    query: AccountAmountsQuery,
+    headers?: Record<string, string>,
+  ): Promise<AccountAmounts>
+  getAccountAmounts(
+    queryOrHeaders?: AccountAmountsQuery | Record<string, string>,
+    headers?: Record<string, string>,
+  ): Promise<AccountAmounts> {
+    const [query, sent] = splitQueryAndHeaders<AccountAmountsQuery>(queryOrHeaders, headers)
+    const queryString = query ? this.toQueryString({ filter: query.filter.join(',') }) : ''
+    return this.client.get<AccountAmounts>(`/me/get-account-amounts${queryString}`, sent)
   }
 
   /**
-   * Returns a URL to the Agnus billing/plan management page for the current account.
+   * Returns a URL to the Agnus billing/plan management page for the current account. Calls Agnus (an external
+   * service) and, for accounts without credits control, reports the consumption to it first.
    * @permissions myAccount.myPlan
    */
   getAgnusMyPlanUrl(headers?: Record<string, string>): Promise<{ url: string }> {
@@ -41,39 +90,45 @@ export class MeApi extends BaseApi {
   }
 
   /**
-   * Updates the current user's profile fields such as name, language, and preferences.
-   * If a new password is provided, it is validated against the last 6 password history entries
-   * and all existing access tokens for the user are revoked.
+   * Updates the current user's profile fields such as name, language, and preferences (`data` and `preferences`
+   * replace the stored objects). A new `password` needs `currentPassword` and a recent login, is validated against
+   * the last 6 passwords, and revokes the access tokens with an expiration — including the one of this request.
    */
   updateMe(body: UpdateMePayload, headers?: Record<string, string>): Promise<User> {
     return this.client.put<User, UpdateMePayload>('/me', body, headers)
   }
 
-  /** Updates account-level settings such as name, settings object, wizard progress, and default department. */
+  /**
+   * Updates account-level settings such as name, settings object, wizard progress, and default department. It
+   * applies to the whole account; the default department is required while the tickets are enabled.
+   */
   updateAccount(body: UpdateMeAccountPayload, headers?: Record<string, string>): Promise<Account> {
     return this.client.put<Account, UpdateMeAccountPayload>('/me/account', body, headers)
   }
 
   /**
-   * Updates the presence status of the current user (`online`, `offline`, or `away`).
+   * Updates the presence status of the current user (`online`, `offline`, or `away`) for a `client`.
    * If setting to `online`, validates the user's timetable first — if outside working hours,
-   * the status is set to `offline` instead.
+   * the status is set to `offline` instead. Resolves the status fields of the user.
    */
-  updateStatus(body: UpdateMeStatusPayload, headers?: Record<string, string>): Promise<User> {
-    return this.client.put<User, UpdateMeStatusPayload>('/me/status', body, headers)
+  updateStatus(
+    body: UpdateMeStatusPayload,
+    headers?: Record<string, string>,
+  ): Promise<MeStatusResponse> {
+    return this.client.put<MeStatusResponse, UpdateMeStatusPayload>('/me/status', body, headers)
   }
 
   /**
-   * Extends the grace period for the current account when it has expired or is about to expire.
-   * Returns the updated account.
+   * Extends the grace period for the current account when it has expired or is about to expire, and notifies the
+   * billing webhook. Returns the updated account; an account not in a grace period answers 400.
    */
   extendAccountGracePeriod(headers?: Record<string, string>): Promise<Account> {
     return this.client.post<Account>('/me/account/extend-grace-period', undefined, headers)
   }
 
   /**
-   * Registers a OneSignal push notification token for the current user.
-   * Used to enable push notifications on mobile/web clients.
+   * Registers the push notification tokens of the current user (`data` replaces the whole `data` of the user).
+   * Resolves with no body.
    */
   registerToken(body: RegisterTokenPayload, headers?: Record<string, string>): Promise<void> {
     return this.client.post<void, RegisterTokenPayload>(
@@ -89,8 +144,8 @@ export class MeApi extends BaseApi {
   }
 
   /**
-   * Sets the current user's status to `online` for the given client and emits a takeover event,
-   * which signals other connected sessions to yield control to this one.
+   * Sets the current user's status to `online` for the given client (`'web'` by default) and emits a takeover
+   * event, which signals other connected sessions to yield control to this one. Resolves with no body.
    */
   takeover(body?: TakeoverPayload, headers?: Record<string, string>): Promise<void> {
     return this.client.post<void, TakeoverPayload>('/me/takeover', body, headers)
@@ -107,9 +162,9 @@ export class MeApi extends BaseApi {
   /**
    * Activates OTP (two-factor) authentication for the current user.
    * Requires the `x-digisac-otp` header with a valid TOTP token generated from the secret key
-   * previously set via `setOtpSecretKey`.
+   * previously set via `setOtpSecretKey`. Resolves the text `'OK'`.
    */
-  activateOtpAuth(headers?: Record<string, string>): Promise<boolean> {
-    return this.client.post<boolean>('/me/activate-otp-auth', undefined, headers)
+  activateOtpAuth(headers?: Record<string, string>): Promise<'OK'> {
+    return this.client.post<'OK'>('/me/activate-otp-auth', undefined, headers)
   }
 }

package/src/apis/me/types.ts

@@ -2,9 +2,68 @@ import type { AccountSettings } from '../accounts/types'
 import type { UserPreferences } from '../users/types'
 import type { UserStatus } from '../users/types'
 
+/** The client of the session that sets the status: the web app or the mobile app. */
+export type MeClient = 'web' | 'app'
+
+/** Query of `GET /me`: without `include`, the user comes without relations. */
+export type MeQuery = {
+  include?: (
+    | 'roles'
+    | 'departments'
+    | 'timetable'
+    | 'account'
+    | 'permissions'
+    | 'organizations'
+    | (string & {})
+  )[]
+  attributes?: string[]
+}
+
+/** Query of `GET /me/account`: `where.id` is the id of the account of the user (`accountId` of `getMe`). */
+export type MeAccountQuery = {
+  where: { id: string }
+  include?: string[]
+  attributes?: string[]
+}
+
+export type AccountAmountsFilter = 'services.amounts' | 'users.amounts'
+
+/** Query of `GET /me/get-account-amounts`: which amounts to answer (the credit amounts are never answered). */
+export type AccountAmountsQuery = {
+  filter: AccountAmountsFilter[]
+}
+
+export type UsersAmounts = {
+  planBase: number
+  additional: number
+  totalContracted: number
+  planBaseConsumed: number
+  additionalConsumed: number
+  totalConsumed: number
+  available: number
+}
+
+export type AccountAmounts = {
+  accountId: string
+  servicesAmounts?: Record<string, unknown>
+  usersAmounts?: UsersAmounts
+}
+
+/** What `updateStatus` answers: the status fields of the user, not the whole user. */
+export type MeStatusResponse = {
+  id: string
+  updatedAt: string
+  status: UserStatus
+  clientsStatus: Partial<Record<MeClient, UserStatus>>
+  language: string
+  account?: unknown
+}
+
 export type UpdateMePayload = {
   name?: string
   password?: string
+  /** Required with `password`: the current password of the user. */
+  currentPassword?: string
   language?: string
   preferences?: UserPreferences
   otpAuthActive?: boolean
@@ -14,22 +73,34 @@ export type UpdateMePayload = {
 
 export type UpdateMeStatusPayload = {
   status: UserStatus
-  client?: string
+  /** Required by the backend (400 without it). */
+  client?: MeClient
 }
 
+/**
+ * Merged over the account. The default department is required while the tickets are enabled
+ * (`settings.ticketsEnabled`; 400 `DEFAULT_DEPARTMENT_REQUIRED`).
+ */
 export type UpdateMeAccountPayload = {
   name?: string
   settings?: Partial<AccountSettings>
-  wizardProgress?: string
+  wizardProgress?: 'notStarted' | 'started' | 'finished' | (string & {})
   defaultDepartmentId?: string
+  defaultDepartment?: { id: string }
 }
 
 export type TakeoverPayload = {
-  client?: string
+  /** Defaults to `'web'`. */
+  client?: MeClient
 }
 
 export type SetOtpSecretKeyPayload = {
   secretKey: string
 }
 
-export type RegisterTokenPayload = Record<string, unknown>
+/** The push tokens of the user. `data` REPLACES the whole `data` of the user (it is not merged). */
+export type RegisterTokenPayload = {
+  data?: { oneSignalToken?: string; expoPushToken?: string | null; fromApp?: boolean }
+  /** The backend ignores the call when it is `true`. */
+  isClientUser?: boolean
+}