@ikatec/digisac-api-sdk 4.4.1 → 4.5.1

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/payloads.test-d.ts

@@ -1,9 +1,15 @@
-import { expectError } from 'tsd'
+import { expectAssignable, expectError, expectNotAssignable, expectType } from 'tsd'
 import type { ApiClient } from '../core/ApiClient'
+import { CardsApi } from './cards/CardsApi'
 import { ContactsApi } from './contacts/ContactsApi'
+import { KanbanColumnsApi } from './kanbanColumns/KanbanColumnsApi'
+import { PipelineApi } from './pipeline/PipelineApi'
+import type { PermissionName } from './permissions/types'
 import { PersonalAccessTokensApi } from './personalAccessTokens/PersonalAccessTokensApi'
 import { RolesApi } from './roles/RolesApi'
 import { TagsApi } from './tags/TagsApi'
+import { TicketsApi } from './tickets/TicketsApi'
+import type { Ticket, TicketTransfer } from './tickets/types'
 import { TimetableApi } from './timetable/TimetableApi'
 import { UsersApi } from './users/UsersApi'
 
@@ -63,3 +69,49 @@ const tags = new TagsApi(client)
 tags.attachContacts('t-1', { where: { id: { $in: ['c-1', 'c-2'] } } })
 expectError(tags.attachContacts('t-1', {}))
 expectError(tags.detachContacts('t-1', { include: ['tags'] }))
+
+// ── pipelines: moving the cards of a deleted status needs the target ─
+
+const pipelines = new PipelineApi(client)
+pipelines.deleteStatus('st-1', { action: 'move-to-another', newStatusId: 'st-2' })
+pipelines.deleteStatus('st-1', { action: 'keep-without-status' })
+expectError(pipelines.deleteStatus('st-1', { action: 'move-to-another' }))
+expectError(pipelines.createAutomation({ pipelineId: 'p-1', type: 'email' }))
+expectError(pipelines.deleteStage('s-1', { typeAction: 'archive' }))
+
+// ── cards: getCards is not scoped by the backend and only answers the attributes asked ─
+
+const cards = new CardsApi(client)
+cards.getCards({
+  where: { accountId: 'a-1', pipelineId: 'p-1' },
+  attributes: ['id', 'title'],
+  order: [['contact.name', 'ASC']],
+})
+expectError(cards.getCards({ where: { pipelineId: 'p-1' }, attributes: ['id'] }))
+expectError(cards.getCards({ where: { accountId: 'a-1' } }))
+expectError(cards.saveComment({ comment: 'no card nor id' }))
+
+// ── kanban columns: the backend computes the position ───────────────
+
+const columns = new KanbanColumnsApi(client)
+columns.reorder('col-1', { beforeColumnId: 'col-0', afterColumnId: 'col-2' })
+expectError(columns.reorder('col-1', { position: 'M' }))
+
+// ── permissions: the kanban permissions were split by the migration 20260209144630 ──
+
+expectAssignable<PermissionName>('kanban.boards.view')
+expectAssignable<PermissionName>('kanban.cards.move')
+expectAssignable<PermissionName>('users.export')
+expectNotAssignable<PermissionName>('kanban.view')
+expectNotAssignable<PermissionName>('kanban.update')
+
+// ── tickets: the history of the ticket comes in the ticketTransfers include ──
+
+const tickets = new TicketsApi(client)
+tickets.getById('t-1', { include: ['ticketTransfers'] })
+tickets.getById('t-1', { include: [{ model: 'ticketTransfers', include: ['byUser'] }] })
+declare const ticket: Ticket
+expectType<TicketTransfer[] | undefined>(ticket.ticketTransfers)
+declare const transfer: TicketTransfer
+expectType<string | null>(transfer.byUserId)
+expectType<'opened' | 'transferred' | 'closed' | null>(transfer.action)

package/src/apis/permissions/types.ts

@@ -47,6 +47,7 @@ export type PermissionName =
   | 'users.create'
   | 'users.update'
   | 'users.archive'
+  | 'users.export'
   | 'roles.view'
   | 'roles.create'
   | 'roles.update'
@@ -205,10 +206,15 @@ export type PermissionName =
   | 'knowledgeBase.create'
   | 'knowledgeBase.update'
   | 'knowledgeBase.destroy'
-  | 'kanban.view'
-  | 'kanban.create'
-  | 'kanban.update'
-  | 'kanban.destroy'
+  // The migration 20260209144630 replaced kanban.view/create/update/destroy with the permissions below.
+  | 'kanban.boards.view'
+  | 'kanban.boards.create'
+  | 'kanban.boards.update'
+  | 'kanban.boards.destroy'
+  | 'kanban.columns.create'
+  | 'kanban.columns.update'
+  | 'kanban.columns.destroy'
+  | 'kanban.cards.move'
 
 /**
  * A permission, as `GET /permissions` answers it (the transformer only picks these fields).

package/src/apis/pipeline/PipelineApi.test.ts

@@ -0,0 +1,193 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type { ApiClient } from '../../core/ApiClient'
+import { PipelineApi } from './PipelineApi'
+
+// ── 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('PipelineApi', () => {
+  let client: ReturnType<typeof createMockClient>
+  let api: PipelineApi
+
+  beforeEach(() => {
+    client = createMockClient()
+    api = new PipelineApi(client)
+  })
+
+  describe('stages', () => {
+    const stage = { name: 'Proposta', pipelineId: 'p1', position: 2 }
+
+    it('createStage calls client.post with /pipelines/stage and body', async () => {
+      vi.mocked(client.post).mockResolvedValue({ id: 's1', ...stage })
+      const result = await api.createStage(stage)
+      expect(client.post).toHaveBeenCalledWith('/pipelines/stage', stage, undefined)
+      expect(result).toEqual({ id: 's1', ...stage })
+    })
+
+    it('createStage resolves to the refusal code the backend answers with 200', async () => {
+      vi.mocked(client.post).mockResolvedValue('STAGES_LIMIT')
+      await expect(api.createStage(stage)).resolves.toBe('STAGES_LIMIT')
+    })
+
+    it('updateStage calls client.put with /pipelines/stage/:id and body', async () => {
+      const body = { ...stage, id: 's1', statuses: [{ id: 'st1', name: 'Novo', position: 1 }] }
+      await api.updateStage('s1', body, headers)
+      expect(client.put).toHaveBeenCalledWith('/pipelines/stage/s1', body, headers)
+    })
+
+    it('deleteStage calls client.request with DELETE and the destination of the cards', async () => {
+      vi.mocked(client.request).mockResolvedValue('MESSAGE_STAGE_DELETED')
+      const body = { typeAction: 'move' as const, idNewStage: 's2', user: { id: 'u1' } }
+      const result = await api.deleteStage('s1', body)
+      expect(client.request).toHaveBeenCalledWith('DELETE', '/pipelines/stage/s1', body, undefined)
+      expect(result).toBe('MESSAGE_STAGE_DELETED')
+    })
+
+    it('deleteStage sends an empty body by default', async () => {
+      await api.deleteStage('s1')
+      expect(client.request).toHaveBeenCalledWith('DELETE', '/pipelines/stage/s1', {}, undefined)
+    })
+
+    it('getStageTotals calls client.post with /pipelines/stage-totals/:id and the filters', async () => {
+      const filters = { nameTitle: 'Acme', createdFrom: '01/09/2026' }
+      await api.getStageTotals('s1', filters)
+      expect(client.post).toHaveBeenCalledWith('/pipelines/stage-totals/s1', filters, undefined)
+    })
+
+    it('getStageTotals sends no filter by default', async () => {
+      await api.getStageTotals('s1')
+      expect(client.post).toHaveBeenCalledWith('/pipelines/stage-totals/s1', {}, undefined)
+    })
+  })
+
+  describe('statuses', () => {
+    it('getStatuses calls client.get with /pipelines/statuses/:pipelineId', async () => {
+      vi.mocked(client.get).mockResolvedValue([{ id: 'st1', name: 'Novo' }])
+      const result = await api.getStatuses('p1', headers)
+      expect(client.get).toHaveBeenCalledWith('/pipelines/statuses/p1', headers)
+      expect(result).toEqual([{ id: 'st1', name: 'Novo' }])
+    })
+
+    it('getStatus calls client.get with /pipelines/status/:id', async () => {
+      await api.getStatus('st1')
+      expect(client.get).toHaveBeenCalledWith('/pipelines/status/st1', undefined)
+    })
+
+    it('deleteStatus calls client.post with /pipelines/delete-status/:id and the action', async () => {
+      vi.mocked(client.post).mockResolvedValue('MESSAGE_STATUS_DELETED')
+      const body = { action: 'move-to-another' as const, newStatusId: 'st2' }
+      const result = await api.deleteStatus('st1', body)
+      expect(client.post).toHaveBeenCalledWith('/pipelines/delete-status/st1', body, undefined)
+      expect(result).toBe('MESSAGE_STATUS_DELETED')
+    })
+
+    it('renameStatus posts only newStatusName to the delete-status route', async () => {
+      vi.mocked(client.post).mockResolvedValue('MESSAGE_STATUS_RENAMED')
+      const result = await api.renameStatus('st1', 'Qualificado', headers)
+      expect(client.post).toHaveBeenCalledWith(
+        '/pipelines/delete-status/st1',
+        { newStatusName: 'Qualificado' },
+        headers,
+      )
+      expect(result).toBe('MESSAGE_STATUS_RENAMED')
+    })
+  })
+
+  describe('automations', () => {
+    const body = {
+      pipelineId: 'p1',
+      type: 'notification' as const,
+      config: { notify: 'high' as const },
+    }
+
+    it('createAutomation calls client.post with /pipelines/automations and body', async () => {
+      await api.createAutomation(body)
+      expect(client.post).toHaveBeenCalledWith('/pipelines/automations', body, undefined)
+    })
+
+    it('updateAutomation calls client.put with /pipelines/automations/:id and body', async () => {
+      await api.updateAutomation('a1', body, headers)
+      expect(client.put).toHaveBeenCalledWith('/pipelines/automations/a1', body, headers)
+    })
+
+    it('deleteAutomation calls client.delete with /pipelines/automations/:id', async () => {
+      await api.deleteAutomation('a1')
+      expect(client.delete).toHaveBeenCalledWith('/pipelines/automations/a1', undefined)
+    })
+
+    it('getAutomation calls client.get with /pipelines/automations/:pipelineId', async () => {
+      vi.mocked(client.get).mockResolvedValue([])
+      const result = await api.getAutomation('p1')
+      expect(client.get).toHaveBeenCalledWith('/pipelines/automations/p1', undefined)
+      expect(result).toEqual([])
+    })
+  })
+
+  describe('pipeline actions', () => {
+    it('duplicate calls client.post with /pipelines/duplicate/:pipelineId and no body', async () => {
+      await api.duplicate('p1', headers)
+      expect(client.post).toHaveBeenCalledWith('/pipelines/duplicate/p1', undefined, headers)
+    })
+
+    it('archive posts archive: true to /pipelines/:id/archive', async () => {
+      await api.archive('p1')
+      expect(client.post).toHaveBeenCalledWith(
+        '/pipelines/p1/archive',
+        { archive: true },
+        undefined,
+      )
+    })
+
+    it('unarchive posts archive: false to /pipelines/:id/archive', async () => {
+      await api.unarchive('p1')
+      expect(client.post).toHaveBeenCalledWith(
+        '/pipelines/p1/archive',
+        { archive: false },
+        undefined,
+      )
+    })
+
+    it('exportCsv calls client.post with /pipelines/:id/export and resolves to the CSV text', async () => {
+      vi.mocked(client.post).mockResolvedValue('Funil;\n')
+      const body = { createdAtInit: '2026-09-01 00:00:00', createdAtFinal: '2026-09-30 23:59:59' }
+      const result = await api.exportCsv('p1', body)
+      expect(client.post).toHaveBeenCalledWith('/pipelines/p1/export', body, undefined)
+      expect(result).toBe('Funil;\n')
+    })
+
+    it('getManyWithTotals serializes the query on /pipelines/withTotals', async () => {
+      await api.getManyWithTotals({ archive: true })
+      const expected = `/pipelines/withTotals?query=${encodeURIComponent(JSON.stringify({ archive: true }))}`
+      expect(client.get).toHaveBeenCalledWith(expected, undefined)
+    })
+
+    it('getManyWithTotals sends no query string without a query', async () => {
+      await api.getManyWithTotals()
+      expect(client.get).toHaveBeenCalledWith('/pipelines/withTotals', undefined)
+    })
+  })
+
+  describe('error propagation', () => {
+    it('propagates errors from createStage', async () => {
+      vi.mocked(client.post).mockRejectedValue(new Error('Validation failed'))
+      await expect(api.createStage({ name: 'x', pipelineId: 'p1', position: 1 })).rejects.toThrow(
+        'Validation failed',
+      )
+    })
+  })
+})