@ikatec/digisac-api-sdk 4.4.0 → 4.5.0

package/src/apis/cards/CardsApi.test.ts

@@ -0,0 +1,128 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type { ApiClient } from '../../core/ApiClient'
+import { CardsApi } from './CardsApi'
+
+// ── 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('CardsApi', () => {
+  let client: ReturnType<typeof createMockClient>
+  let api: CardsApi
+
+  beforeEach(() => {
+    client = createMockClient()
+    api = new CardsApi(client)
+  })
+
+  describe('bulkMove', () => {
+    it('calls client.put with /cards/bulk-move and body', async () => {
+      vi.mocked(client.put).mockResolvedValue({ movedCount: 2, ignoredCount: 0 })
+      const body = {
+        ids: ['c1', 'c2'],
+        originPipelineStageId: 's1',
+        pipelineId: 'p1',
+        pipelineStageId: 's2',
+      }
+      const result = await api.bulkMove(body, headers)
+      expect(client.put).toHaveBeenCalledWith('/cards/bulk-move', body, headers)
+      expect(result).toEqual({ movedCount: 2, ignoredCount: 0 })
+    })
+  })
+
+  describe('updateOrder', () => {
+    it('calls client.put with /cards/order/:id and the order', async () => {
+      await api.updateOrder('c1', 3)
+      expect(client.put).toHaveBeenCalledWith('/cards/order/c1', { order: 3 }, undefined)
+    })
+  })
+
+  describe('products', () => {
+    it('saveProduct calls client.post with /cards/product and body', async () => {
+      vi.mocked(client.post).mockResolvedValue({ message: 'Operação realizada com sucesso.' })
+      const body = { cardId: 'c1', name: 'Plano', ammount: 2, value: 99.9 }
+      const result = await api.saveProduct(body)
+      expect(client.post).toHaveBeenCalledWith('/cards/product', body, undefined)
+      expect(result).toEqual({ message: 'Operação realizada com sucesso.' })
+    })
+
+    it('deleteProduct calls client.delete with /cards/product/:id', async () => {
+      await api.deleteProduct('pr1', headers)
+      expect(client.delete).toHaveBeenCalledWith('/cards/product/pr1', headers)
+    })
+  })
+
+  describe('comments', () => {
+    it('saveComment calls client.post with /cards/comment and body', async () => {
+      const body = { cardId: 'c1', comment: 'Ligar amanhã' }
+      await api.saveComment(body)
+      expect(client.post).toHaveBeenCalledWith('/cards/comment', body, undefined)
+    })
+
+    it('saveComment edits by id', async () => {
+      const body = { id: 'cm1', comment: 'Ligar hoje', removedFileIds: ['f1'] }
+      await api.saveComment(body, headers)
+      expect(client.post).toHaveBeenCalledWith('/cards/comment', body, headers)
+    })
+
+    it('deleteComment calls client.delete with /cards/comment/:id', async () => {
+      await api.deleteComment('cm1')
+      expect(client.delete).toHaveBeenCalledWith('/cards/comment/cm1', undefined)
+    })
+  })
+
+  describe('reads', () => {
+    it('getOwners calls client.post with /cards/owners and no body', async () => {
+      vi.mocked(client.post).mockResolvedValue([{ id: 'u1', name: 'Ana', disabled: false }])
+      const result = await api.getOwners()
+      expect(client.post).toHaveBeenCalledWith('/cards/owners', undefined, undefined)
+      expect(result).toEqual([{ id: 'u1', name: 'Ana', disabled: false }])
+    })
+
+    it('getCards calls client.post with /cards/getCards and the query', async () => {
+      const body = {
+        where: { accountId: 'a1', pipelineStageId: 's1' },
+        attributes: ['id', 'title'] as ('id' | 'title')[],
+        order: [['contact.name', 'ASC']] as ['contact.name', 'ASC'][],
+        limit: 20,
+      }
+      await api.getCards(body)
+      expect(client.post).toHaveBeenCalledWith('/cards/getCards', body, undefined)
+    })
+
+    it('getContactTotals calls client.post with /cards/contact-totals/:contactId', async () => {
+      vi.mocked(client.post).mockResolvedValue({ totalOpen: 1 })
+      const result = await api.getContactTotals('ct1', headers)
+      expect(client.post).toHaveBeenCalledWith('/cards/contact-totals/ct1', undefined, headers)
+      expect(result).toEqual({ totalOpen: 1 })
+    })
+  })
+
+  describe('error propagation', () => {
+    it('propagates errors from bulkMove', async () => {
+      vi.mocked(client.put).mockRejectedValue(new Error('At least one card id is required.'))
+      await expect(
+        api.bulkMove({
+          ids: [],
+          originPipelineStageId: 's1',
+          pipelineId: 'p1',
+          pipelineStageId: 's2',
+        }),
+      ).rejects.toThrow('At least one card id is required.')
+    })
+  })
+})

package/src/apis/cards/CardsApi.ts

@@ -1,9 +1,132 @@
 import type { ApiClient } from '../../core/ApiClient'
 import { BaseCrudApi } from '../../core/BaseCrudApi'
-import type { Card, CreateCardPayload, UpdateCardPayload } from './types'
+import type {
+  BulkMoveCardsPayload,
+  BulkMoveCardsResult,
+  Card,
+  CardContactTotals,
+  CardOperationResult,
+  CardOwner,
+  CreateCardPayload,
+  GetCardsPayload,
+  SaveCardCommentPayload,
+  SaveCardProductPayload,
+  UpdateCardPayload,
+} from './types'
 
 export class CardsApi extends BaseCrudApi<Card, CreateCardPayload, UpdateCardPayload> {
   constructor(client: ApiClient) {
     super(client, '/cards')
   }
+
+  /**
+   * Moves several cards of one stage to another stage (of the same or another pipeline),
+   * clearing their status/reason unless given. Cards outside the account or not in
+   * `originPipelineStageId` are skipped and counted in `ignoredCount`.
+   * @permissions pipelines.opportunity.update
+   */
+  bulkMove(
+    body: BulkMoveCardsPayload,
+    headers?: Record<string, string>,
+  ): Promise<BulkMoveCardsResult> {
+    return this.client.put<BulkMoveCardsResult, BulkMoveCardsPayload>(
+      `${this.basePath}/bulk-move`,
+      body,
+      headers,
+    )
+  }
+
+  /**
+   * Moves a card to the `order` position of its stage, shifting the cards in between. Resolves
+   * to the card as stored. The backend refuses `0` (400 `required`), although the first card of
+   * a stage has order 0.
+   * @permissions pipelines.opportunity.update
+   */
+  updateOrder(id: string, order: number, headers?: Record<string, string>): Promise<Card> {
+    return this.client.put<Card, { order: number }>(
+      `${this.basePath}/order/${id}`,
+      { order },
+      headers,
+    )
+  }
+
+  /**
+   * Adds a product to a card, or updates the product of `body.id`.
+   * @permissions pipelines.opportunity.update
+   */
+  saveProduct(
+    body: SaveCardProductPayload,
+    headers?: Record<string, string>,
+  ): Promise<CardOperationResult> {
+    return this.client.post<CardOperationResult, SaveCardProductPayload>(
+      `${this.basePath}/product`,
+      body,
+      headers,
+    )
+  }
+
+  /**
+   * Deletes a product of a card. An unknown id also resolves with 200, with the message
+   * `'Produto não encontrado'`.
+   * @permissions pipelines.opportunity.update
+   */
+  deleteProduct(id: string, headers?: Record<string, string>): Promise<CardOperationResult> {
+    return this.client.delete<CardOperationResult>(`${this.basePath}/product/${id}`, headers)
+  }
+
+  /**
+   * Adds a comment to a card, or edits the comment of `body.id`. Resolves to a message, not to
+   * the comment — read it back through `getById(cardId, { include: ['comments'] })`. A card or
+   * comment of another account fails with 404.
+   * @permissions pipelines.opportunity.update
+   */
+  saveComment(
+    body: SaveCardCommentPayload,
+    headers?: Record<string, string>,
+  ): Promise<CardOperationResult> {
+    return this.client.post<CardOperationResult, SaveCardCommentPayload>(
+      `${this.basePath}/comment`,
+      body,
+      headers,
+    )
+  }
+
+  /**
+   * Deletes a comment of a card. Resolves with no content; unknown → 404.
+   * @permissions pipelines.opportunity.update
+   */
+  deleteComment(id: string, headers?: Record<string, string>): Promise<void> {
+    return this.client.delete<void>(`${this.basePath}/comment/${id}`, headers)
+  }
+
+  /**
+   * Lists the users of the account that can own a card, sorted by name.
+   * @permissions pipelines.opportunity.view
+   */
+  getOwners(headers?: Record<string, string>): Promise<CardOwner[]> {
+    return this.client.post<CardOwner[]>(`${this.basePath}/owners`, undefined, headers)
+  }
+
+  /**
+   * Lists cards with the board query of the UI. Resolves to a plain array (no pagination).
+   * @permissions pipelines.opportunity.view
+   */
+  getCards(body: GetCardsPayload, headers?: Record<string, string>): Promise<Card[]> {
+    return this.client.post<Card[], GetCardsPayload>(`${this.basePath}/getCards`, body, headers)
+  }
+
+  /**
+   * Counts the open cards of a contact visible to the caller.
+   * @permissions pipelines.opportunity.view
+   */
+  getContactTotals(
+    contactId: string,
+    headers?: Record<string, string>,
+  ): Promise<CardContactTotals> {
+    return this.client.post<CardContactTotals>(
+      `${this.basePath}/contact-totals/${contactId}`,
+      undefined,
+      headers,
+    )
+  }
 }

package/src/apis/cards/types.ts

@@ -1,3 +1,4 @@
+import type { ListQuery, WhereClause } from '../../core/types'
 import type { Contact } from '../contacts/types'
 import type {
   Pipeline,
@@ -98,6 +99,8 @@ export type Card = {
   lastMessage?: unknown
   /** Only on getMany/getById answers: sum of the products (`ammount * value`). */
   totalValue?: number
+  /** Only on `getCards` answers. */
+  contactName?: string
   // relationships
   contact?: Contact | null
   owner?: User | null
@@ -158,3 +161,81 @@ export type UpdateCardPayload = {
   success?: boolean | null
   finishedAt?: string | null
 }
+
+/** Answer of the product and comment writes — the entity itself is not returned. */
+export type CardOperationResult = { message: string }
+
+export type BulkMoveCardsPayload = {
+  /** At least one; ids outside the account or not in `originPipelineStageId` are ignored. */
+  ids: string[]
+  originPipelineStageId: string
+  /** Destination pipeline; `pipelineStageId` must be one of its stages. */
+  pipelineId: string
+  pipelineStageId: string
+  /** Must be a status of the destination stage, unless it is the last stage. */
+  statusId?: string
+  /** Kept only when the destination is the last stage (then `finishedAt` is set). */
+  success?: boolean
+  reasonId?: string
+}
+
+export type BulkMoveCardsResult = { movedCount: number; ignoredCount: number }
+
+/**
+ * Creates a product of a card, or updates the product of `id`. No validation on the backend:
+ * a missing `name`/`ammount`/`value` fails with 500.
+ */
+export type SaveCardProductPayload = {
+  id?: string
+  cardId: string
+  name: string
+  /** Quantity — integer (the backend column is spelled `ammount`). */
+  ammount: number
+  value: number
+}
+
+/**
+ * Creates a comment on `cardId`, or edits the comment of `id`. It needs text or at least one
+ * file. `files` are references to files already uploaded (see `FilesApi`) — `.pdf`, `.txt`,
+ * `.html` or `.md`, up to 10 files of 10 MB.
+ */
+export type SaveCardCommentPayload =
+  | { id?: undefined; cardId: string; comment?: string; files?: { id: string }[] }
+  | {
+      id: string
+      cardId?: string
+      comment?: string
+      files?: { id: string }[]
+      removedFileIds?: string[]
+    }
+
+export type CardOwner = {
+  id: string
+  /** Suffixed with " - Sem permissão" (in the caller's language) when `disabled`. */
+  name: string
+  /** `true` for users without `pipelines.opportunity.update`. */
+  disabled: boolean
+}
+
+/**
+ * Body of `POST /cards/getCards`: Sequelize options sent as-is. The route does **not** scope the
+ * query by account — without `where.accountId` it answers cards of other accounts. `order`
+ * accepts card fields and `contact.name`.
+ */
+export type GetCardsPayload = Omit<
+  ListQuery<Card>,
+  'page' | 'perPage' | 'paginate' | 'where' | 'order' | 'attributes'
+> & {
+  where: WhereClause<Card> & { accountId: string }
+  /**
+   * The card columns to answer. Required in practice: the backend selects only these (plus the
+   * computed `contactName` and `totalValue`), so without them each card has no other field.
+   */
+  attributes: (keyof Card & string)[]
+  order?: [(keyof Card & string) | 'contact.name', 'ASC' | 'DESC'][]
+}
+
+export type CardContactTotals = {
+  /** Open cards of the contact (not archived, not finished, in a pipeline that exists). */
+  totalOpen: number
+}

package/src/apis/kanbanBoards/types.ts

@@ -1,14 +1,32 @@
 import type { Department } from '../departments/types'
 import type { KanbanColumn } from '../kanbanColumns/types'
 
+export type KanbanBoardVisibleTickets = 'mine' | 'all' | 'mine-and-not-assigned'
+
+export type KanbanBoardClosedMaxTimeUnit = 'minutes' | 'hours' | 'days' | 'weeks' | 'months'
+
+/** Card fields shown on the board. */
+export type KanbanBoardSettings = {
+  lastMessage: boolean
+  departmentAndUser: boolean
+  tags: boolean
+  createdAtDate: boolean
+  newInteractions: boolean
+  timeoutAlert: boolean
+}
+
 export type KanbanBoard = {
   id: string
   name: string
-  timeoutAlertEnabled: boolean
   accountId: string
+  visibleTickets: KanbanBoardVisibleTickets | null
+  closedMaxTime: number | null
+  closedMaxTimeUnit: KanbanBoardClosedMaxTimeUnit | null
+  /** `'initializing'` while the cards of the open tickets are being created. */
+  status: 'initializing' | 'ready'
+  settings: KanbanBoardSettings
   createdAt: string
   updatedAt: string
-  deletedAt: string | null
   // relationships
   departments?: Department[]
   columns?: KanbanColumn[]
@@ -18,12 +36,26 @@ export type KanbanBoardRelationships = 'departments' | 'columns'
 
 export type CreateKanbanBoardPayload = {
   name: string
-  timeoutAlertEnabled?: boolean
   /** Department IDs to link to the board. Required by the backend on creation. */
   departmentIds: string[]
+  visibleTickets?: KanbanBoardVisibleTickets
+  /** Greater than 0. */
+  closedMaxTime?: number
+  closedMaxTimeUnit?: KanbanBoardClosedMaxTimeUnit
+  settings?: Partial<KanbanBoardSettings>
 }
 
 export type UpdateKanbanBoardPayload = {
   name?: string
-  timeoutAlertEnabled?: boolean
+  /**
+   * Replaces the departments of the board (at least one): removing a department deletes the
+   * cards of its tickets, adding one creates cards for its open tickets.
+   */
+  departmentIds?: string[]
+  visibleTickets?: KanbanBoardVisibleTickets
+  /** Greater than 0. */
+  closedMaxTime?: number
+  closedMaxTimeUnit?: KanbanBoardClosedMaxTimeUnit
+  /** Merged into the current settings — send only the keys to change. */
+  settings?: Partial<KanbanBoardSettings>
 }

package/src/apis/kanbanCards/KanbanCardsApi.test.ts

@@ -0,0 +1,46 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type { ApiClient } from '../../core/ApiClient'
+import { KanbanCardsApi } from './KanbanCardsApi'
+
+// ── 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('KanbanCardsApi', () => {
+  let client: ReturnType<typeof createMockClient>
+  let api: KanbanCardsApi
+
+  beforeEach(() => {
+    client = createMockClient()
+    api = new KanbanCardsApi(client)
+  })
+
+  describe('reorder', () => {
+    it('calls client.patch with /kanban-cards/:id/reorder and body', async () => {
+      vi.mocked(client.patch).mockResolvedValue({ id: 'kc1', position: 'N' })
+      const body = { columnId: 'col2', moveTo: 'end' as const }
+      const result = await api.reorder('kc1', body, headers)
+      expect(client.patch).toHaveBeenCalledWith('/kanban-cards/kc1/reorder', body, headers)
+      expect(result).toEqual({ id: 'kc1', position: 'N' })
+    })
+
+    it('propagates errors', async () => {
+      vi.mocked(client.patch).mockRejectedValue(new Error('Invalid reorder operation.'))
+      await expect(api.reorder('kc1', {})).rejects.toThrow('Invalid reorder operation.')
+    })
+  })
+})

package/src/apis/kanbanCards/KanbanCardsApi.ts

@@ -1,6 +1,11 @@
 import type { ApiClient } from '../../core/ApiClient'
 import { BaseCrudApi } from '../../core/BaseCrudApi'
-import type { KanbanCard, CreateKanbanCardPayload, UpdateKanbanCardPayload } from './types'
+import type {
+  KanbanCard,
+  CreateKanbanCardPayload,
+  ReorderKanbanCardPayload,
+  UpdateKanbanCardPayload,
+} from './types'
 
 export class KanbanCardsApi extends BaseCrudApi<
   KanbanCard,
@@ -10,4 +15,21 @@ export class KanbanCardsApi extends BaseCrudApi<
   constructor(client: ApiClient) {
     super(client, '/kanban-cards')
   }
+
+  /**
+   * Moves a card within its column or to another column (see {@link ReorderKanbanCardPayload}).
+   * Resolves to the card with its new `position` and `columnId`.
+   * @permissions kanban.cards.move
+   */
+  reorder(
+    id: string,
+    body: ReorderKanbanCardPayload,
+    headers?: Record<string, string>,
+  ): Promise<KanbanCard> {
+    return this.client.patch<KanbanCard, ReorderKanbanCardPayload>(
+      `${this.basePath}/${id}/reorder`,
+      body,
+      headers,
+    )
+  }
 }

package/src/apis/kanbanCards/types.ts

@@ -3,7 +3,6 @@ import type { Ticket } from '../tickets/types'
 
 export type KanbanCard = {
   id: string
-  ticketSubject: string | null
   position: string
   columnId: string
   ticketId: string
@@ -12,10 +11,9 @@ export type KanbanCard = {
   lastColumnChangeAt: string | null
   createdAt: string
   updatedAt: string
-  deletedAt: string | null
   // relationships
-  column?: KanbanColumn
-  ticket?: Ticket
+  column?: KanbanColumn | null
+  ticket?: Ticket | null
 }
 
 export type KanbanCardRelationships = 'column' | 'ticket'
@@ -29,5 +27,20 @@ export type CreateKanbanCardPayload = {
 export type UpdateKanbanCardPayload = {
   columnId?: string
   position?: string
-  ticketSubject?: string | null
+  /** The caller must share a department with the ticket (or transfer to all / be admin). */
+  ticketId?: string
+}
+
+/**
+ * Where the card goes. The target column is `columnId`, else the column of the neighbours, else
+ * the current one; `moveTo` puts it first/last of the target column. Moving into the `'final'`
+ * column closes the ticket, moving out of it reopens the ticket.
+ */
+export type ReorderKanbanCardPayload = {
+  /** The card that ends up above. Must be in the same column as `afterCardId`. */
+  beforeCardId?: string
+  /** The card that ends up below. */
+  afterCardId?: string
+  columnId?: string
+  moveTo?: 'start' | 'end'
 }

package/src/apis/kanbanColumns/KanbanColumnsApi.test.ts

@@ -0,0 +1,46 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type { ApiClient } from '../../core/ApiClient'
+import { KanbanColumnsApi } from './KanbanColumnsApi'
+
+// ── 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('KanbanColumnsApi', () => {
+  let client: ReturnType<typeof createMockClient>
+  let api: KanbanColumnsApi
+
+  beforeEach(() => {
+    client = createMockClient()
+    api = new KanbanColumnsApi(client)
+  })
+
+  describe('reorder', () => {
+    it('calls client.patch with /kanban-columns/:id/reorder and body', async () => {
+      vi.mocked(client.patch).mockResolvedValue({ id: 'col1', position: 'N' })
+      const body = { beforeColumnId: 'col0', afterColumnId: 'col2' }
+      const result = await api.reorder('col1', body, headers)
+      expect(client.patch).toHaveBeenCalledWith('/kanban-columns/col1/reorder', body, headers)
+      expect(result).toEqual({ id: 'col1', position: 'N' })
+    })
+
+    it('propagates errors', async () => {
+      vi.mocked(client.patch).mockRejectedValue(new Error('Invalid reorder operation.'))
+      await expect(api.reorder('col1', {})).rejects.toThrow('Invalid reorder operation.')
+    })
+  })
+})

package/src/apis/kanbanColumns/KanbanColumnsApi.ts

@@ -1,6 +1,11 @@
 import type { ApiClient } from '../../core/ApiClient'
 import { BaseCrudApi } from '../../core/BaseCrudApi'
-import type { KanbanColumn, CreateKanbanColumnPayload, UpdateKanbanColumnPayload } from './types'
+import type {
+  KanbanColumn,
+  CreateKanbanColumnPayload,
+  ReorderKanbanColumnPayload,
+  UpdateKanbanColumnPayload,
+} from './types'
 
 export class KanbanColumnsApi extends BaseCrudApi<
   KanbanColumn,
@@ -10,4 +15,22 @@ export class KanbanColumnsApi extends BaseCrudApi<
   constructor(client: ApiClient) {
     super(client, '/kanban-columns')
   }
+
+  /**
+   * Moves a column between two neighbours of the same board. Both the column and a neighbour
+   * must be draggable; swapped neighbours (`before` after `after`) fail with 500. Resolves to the
+   * column with its new `position`.
+   * @permissions kanban.columns.update
+   */
+  reorder(
+    id: string,
+    body: ReorderKanbanColumnPayload,
+    headers?: Record<string, string>,
+  ): Promise<KanbanColumn> {
+    return this.client.patch<KanbanColumn, ReorderKanbanColumnPayload>(
+      `${this.basePath}/${id}/reorder`,
+      body,
+      headers,
+    )
+  }
 }

package/src/apis/kanbanColumns/types.ts

@@ -14,18 +14,22 @@ export type KanbanColumn = {
   accountId: string
   createdAt: string
   updatedAt: string
-  deletedAt: string | null
   // relationships
-  kanbanBoard?: KanbanBoard
+  board?: KanbanBoard | null
   cards?: KanbanCard[]
 }
 
-export type KanbanColumnRelationships = 'kanbanBoard' | 'cards'
+export type KanbanColumnRelationships = 'cards'
 
 export type CreateKanbanColumnPayload = {
   name: string
   kanbanBoardId: string
+  /** A board has one `'initial'` and one `'final'` column (a second one fails). */
   role?: KanbanColumnRole
+  /**
+   * @deprecated Ignored by the backend: the position is computed (`'initial'` first, `'final'`
+   * last, other columns just before the final one). Use `reorder` to move a column.
+   */
   position?: string
   ticketWaitTimeMinutes?: number
   isDraggable?: boolean
@@ -38,3 +42,11 @@ export type UpdateKanbanColumnPayload = {
   ticketWaitTimeMinutes?: number | null
   isDraggable?: boolean
 }
+
+/** Neighbours of the column after the move (omit both to move it to the middle, `'M'`). */
+export type ReorderKanbanColumnPayload = {
+  /** The column that ends up on the left. */
+  beforeColumnId?: string
+  /** The column that ends up on the right. */
+  afterColumnId?: string
+}

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

@@ -34,15 +34,15 @@ const user: User = {
   email: 'alice@example.com',
   phoneNumber: null,
   branch: null,
-  isSuperAdmin: false,
   isClientUser: false,
-  active: true,
   language: 'en',
   isFirstLogin: false,
   status: 'online',
   clientsStatus: null,
-  offlineAt: null,
   isActiveInternalChat: true,
+  internalChatToken: null,
+  noteReference: false,
+  data: {},
   passwordExpiresAt: null,
   otpAuthActive: false,
   preferences: {},