Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
feat(crm): require fields before entering pipeline stages (#8850)
gbirmane19ad1033cd8
diff --git a/.sqlx/query-4554a9b04ca5377a8e5875d7314effe7a8fddae5de6256248df5b68e92844c6a.json b/.sqlx/query-4554a9b04ca5377a8e5875d7314effe7a8fddae5de6256248df5b68e92844c6a.jsonnew file mode 100644index 0000000000..0ce6ee421e--- /dev/null+++ b/.sqlx/query-4554a9b04ca5377a8e5875d7314effe7a8fddae5de6256248df5b68e92844c6a.json@@ -0,0 +1,12 @@+{+ "db_name": "PostgreSQL",+ "query": "SET LOCAL lock_timeout = '5s'",+ "describe": {+ "columns": [],+ "parameters": {+ "Left": []+ },+ "nullable": []+ },+ "hash": "4554a9b04ca5377a8e5875d7314effe7a8fddae5de6256248df5b68e92844c6a"+}diff --git a/.sqlx/query-58abb3bd86cd8b0efdc4a4e46927c209520c9c38af388662ea9a63ee24c0f081.json b/.sqlx/query-58abb3bd86cd8b0efdc4a4e46927c209520c9c38af388662ea9a63ee24c0f081.jsonnew file mode 100644index 0000000000..8868890f8f--- /dev/null+++ b/.sqlx/query-58abb3bd86cd8b0efdc4a4e46927c209520c9c38af388662ea9a63ee24c0f081.json@@ -0,0 +1,34 @@+{+ "db_name": "PostgreSQL",+ "query": "SELECT stage_column_id, stage_id, required_column_id FROM crm_pipeline_stage_requirements WHERE pipeline_id = $1 ORDER BY stage_column_id, stage_id, required_column_id",+ "describe": {+ "columns": [+ {+ "ordinal": 0,+ "name": "stage_column_id",+ "type_info": "Uuid"+ },+ {+ "ordinal": 1,+ "name": "stage_id",+ "type_info": "Uuid"+ },+ {+ "ordinal": 2,+ "name": "required_column_id",+ "type_info": "Uuid"+ }+ ],+ "parameters": {+ "Left": [+ "Uuid"+ ]+ },+ "nullable": [+ false,+ false,+ false+ ]+ },+ "hash": "58abb3bd86cd8b0efdc4a4e46927c209520c9c38af388662ea9a63ee24c0f081"+}diff --git a/.sqlx/query-67e87c4faab552955606cea17b909ab104fa87774b8fdcd2ba18bf9b112d9ea1.json b/.sqlx/query-67e87c4faab552955606cea17b909ab104fa87774b8fdcd2ba18bf9b112d9ea1.jsonnew file mode 100644index 0000000000..665c99b9b6--- /dev/null+++ b/.sqlx/query-67e87c4faab552955606cea17b909ab104fa87774b8fdcd2ba18bf9b112d9ea1.json@@ -0,0 +1,16 @@+{+ "db_name": "PostgreSQL",+ "query": "DELETE FROM crm_pipeline_stage_requirements WHERE pipeline_id = $1 AND stage_column_id = $2 AND stage_id = $3",+ "describe": {+ "columns": [],+ "parameters": {+ "Left": [+ "Uuid",+ "Uuid",+ "Uuid"+ ]+ },+ "nullable": []+ },+ "hash": "67e87c4faab552955606cea17b909ab104fa87774b8fdcd2ba18bf9b112d9ea1"+}diff --git a/.sqlx/query-9399a2cc93291f0b42593dbc5e2280b3f361e2c9df2faf40790197d6ead6e45d.json b/.sqlx/query-9399a2cc93291f0b42593dbc5e2280b3f361e2c9df2faf40790197d6ead6e45d.jsonnew file mode 100644index 0000000000..cae05655f2--- /dev/null+++ b/.sqlx/query-9399a2cc93291f0b42593dbc5e2280b3f361e2c9df2faf40790197d6ead6e45d.json@@ -0,0 +1,22 @@+{+ "db_name": "PostgreSQL",+ "query": "SELECT id FROM crm_pipeline_entities WHERE id = $1 AND trashed_at IS NULL FOR NO KEY UPDATE",+ "describe": {+ "columns": [+ {+ "ordinal": 0,+ "name": "id",+ "type_info": "Uuid"+ }+ ],+ "parameters": {+ "Left": [+ "Uuid"+ ]+ },+ "nullable": [+ false+ ]+ },+ "hash": "9399a2cc93291f0b42593dbc5e2280b3f361e2c9df2faf40790197d6ead6e45d"+}diff --git a/.sqlx/query-bad5e9278f7012f19f59200fc9eef562f622bc2a3d244a9ea355b5e0f1f652e2.json b/.sqlx/query-bad5e9278f7012f19f59200fc9eef562f622bc2a3d244a9ea355b5e0f1f652e2.jsonnew file mode 100644index 0000000000..31db8cba43--- /dev/null+++ b/.sqlx/query-bad5e9278f7012f19f59200fc9eef562f622bc2a3d244a9ea355b5e0f1f652e2.json@@ -0,0 +1,17 @@+{+ "db_name": "PostgreSQL",+ "query": "INSERT INTO crm_pipeline_stage_requirements (pipeline_id, stage_column_id, stage_id, required_column_id) SELECT $1, $2, $3, unnest($4::uuid[]) ON CONFLICT DO NOTHING",+ "describe": {+ "columns": [],+ "parameters": {+ "Left": [+ "Uuid",+ "Uuid",+ "Uuid",+ "UuidArray"+ ]+ },+ "nullable": []+ },+ "hash": "bad5e9278f7012f19f59200fc9eef562f622bc2a3d244a9ea355b5e0f1f652e2"+}diff --git a/apps/web/src/features/block-database/browser-test/api.tsx b/apps/web/src/features/block-database/browser-test/api.tsxindex 380ac3e72f..356e2c07a3 100644--- a/apps/web/src/features/block-database/browser-test/api.tsx+++ b/apps/web/src/features/block-database/browser-test/api.tsx@@ -1,14 +1,19 @@import '@app/index.css';import type { OpResult } from '@core/database-sql/generated/types';+import type { CardPosition } from '@service-storage/generated/schemas/cardPosition';import { QueryClient, QueryClientProvider } from '@tanstack/solid-query';-import { errAsync, okAsync, ResultAsync } from 'neverthrow';+import { err, errAsync, okAsync, ResultAsync } from 'neverthrow';import { createSignal } from 'solid-js';import { render } from 'solid-js/web';import { DatabaseTitle } from '../../database/components/database-title';import { DatabaseProvider } from '../../database/context/database';import type { DatabaseApi, DatabaseTableSchema } from '../../database/core/api';import type { DatabaseRow } from '../../database/core/table';-import type { DatabaseViewState } from '../../database/core/view-state';+import type {+ CardMoved,+ DatabaseViewState,+} from '../../database/core/view-state';+import type { DatabaseOpFailure } from '../../database/core/write-failure';import { DatabaseRecords } from '../../database/views/database-records';const tableId = '00000000-0000-0000-0000-000000000001';@@ -17,6 +22,20 @@ const statusId = '00000000-0000-0000-0000-000000000003';const optionId = '00000000-0000-0000-0000-000000000004';function ApiFixture() {+ const boardHost = new URLSearchParams(location.search).get('boardHost');+ const [positions, setPositions] = createSignal<CardPosition[]>([+ {+ row: '00000000-0000-0000-0000-000000000010',+ lane: { kind: 'option', id: optionId },+ position: '8180',+ },+ {+ row: '00000000-0000-0000-0000-000000000011',+ lane: { kind: 'option', id: optionId },+ position: '80',+ },+ ]);+ const [refuseMove, setRefuseMove] = createSignal<() => void>();const [name, setName] = createSignal('Untitled database');let editTitle: (() => void) | undefined;const [editable, setEditable] = createSignal(true);@@ -49,7 +68,18 @@ function ApiFixture() {dataType: 'SELECT_STRING',isMultiSelect: false,writable: true,- options: [{ id: optionId, label: 'Open', color: null }],+ options: [+ { id: optionId, label: 'Open', color: null },+ ...(boardHost+ ? [+ {+ id: '00000000-0000-0000-0000-000000000005',+ label: 'Negotiation',+ color: null,+ },+ ]+ : []),+ ],},],};@@ -185,7 +215,7 @@ function ApiFixture() {}><main class="flex h-screen flex-col bg-panel text-ink">- <div class="flex gap-4 p-4">+ <div class="flex flex-wrap gap-4 p-4"><DatabaseTitlename={name()}canEdit={editable()}@@ -216,6 +246,16 @@ function ApiFixture() {Show board</button><output aria-label="API writes">{writes()}</output>+ {boardHost && (+ <>+ <output aria-label="Saved positions" class="sr-only">+ {JSON.stringify(positions())}+ </output>+ <button disabled={!refuseMove()} onClick={() => refuseMove()?.()}>+ Refuse move+ </button>+ </>+ )}<buttontype="button"onMouseDown={(event) => event.preventDefault()}@@ -233,6 +273,34 @@ function ApiFixture() {<DatabaseRecordsview={view()}stored={false}+ boardPositions={+ boardHost+ ? {+ state: () => ({ kind: 'ready', positions: positions() }),+ setPositions:+ boardHost === 'setter' ? setPositions : undefined,+ move: () =>+ new ResultAsync<CardMoved, DatabaseOpFailure>(+ new Promise((resolve) => {+ setRefuseMove(+ () => () =>+ resolve(+ err({+ kind: 'ops',+ error: {+ code: 'INVALID_OP',+ refusal: null,+ message:+ 'Fill in Amount before entering Negotiation.',+ },+ })+ )+ );+ })+ ),+ }+ : undefined+ }onViewChange={(change) =>setView((view) => ({ ...view, ...change }))}diff --git a/apps/web/src/features/block-database/browser-test/board-refusal.browser.e2e.ts b/apps/web/src/features/block-database/browser-test/board-refusal.browser.e2e.tsnew file mode 100644index 0000000000..bfe5b2c7a5--- /dev/null+++ b/apps/web/src/features/block-database/browser-test/board-refusal.browser.e2e.ts@@ -0,0 +1,76 @@+import { expect, test } from '@playwright/test';+import { openFixture } from './open-fixture';++for (const host of ['setter', 'query']) {+ for (const width of [1280, 390]) {+ test.describe(`${host} positions at ${width}px`, () => {+ test.use({+ viewport: { width, height: 844 },+ isMobile: width === 390,+ hasTouch: width === 390,+ });+ test('a refused stage move restores the saved card order', async ({+ page,+ }) => {+ await page.route('https://**', (route) => route.abort());+ await page.route('**/__macro_dev/**', (route) => route.abort());+ await openFixture(+ page,+ `/src/features/block-database/browser-test/api.html?boardHost=${host}`+ );+ await page+ .getByRole('button', { name: 'Show board', exact: true })+ .click();+ const open = page.locator('[data-kanban-lane][aria-label="Open lane"]');+ const order = [+ '00000000-0000-0000-0000-000000000011',+ '00000000-0000-0000-0000-000000000010',+ ];+ await expect+ .poll(() =>+ open+ .locator('[data-row-id]')+ .evaluateAll((cards) =>+ cards.map((card) => card.getAttribute('data-row-id'))+ )+ )+ .toEqual(order);+ const saved = await page.getByLabel('Saved positions').textContent();+ const move = page.getByRole('button', {+ name: 'Move First',+ exact: true,+ });+ if (width === 390) await move.tap();+ else {+ await open.locator('[data-row-id]').last().hover();+ await move.click();+ }+ const destination = page.getByRole('menuitem', {+ name: 'Negotiation',+ exact: true,+ });+ if (width === 390) await destination.tap();+ else await destination.click();+ await expect(+ page.locator(+ '[data-kanban-lane][aria-label="Negotiation lane"] [data-row-id]'+ )+ ).toHaveCount(1);+ await expect(page.getByLabel('Saved positions')).toHaveText(saved!);+ await page+ .getByRole('button', { name: 'Refuse move', exact: true })+ .click();+ await expect+ .poll(() =>+ open+ .locator('[data-row-id]')+ .evaluateAll((cards) =>+ cards.map((card) => card.getAttribute('data-row-id'))+ )+ )+ .toEqual(order);+ await expect(page.getByLabel('Saved positions')).toHaveText(saved!);+ });+ });+ }+}diff --git a/apps/web/src/features/crm/README.md b/apps/web/src/features/crm/README.mdindex 39d7c73023..4c32962a73 100644--- a/apps/web/src/features/crm/README.md+++ b/apps/web/src/features/crm/README.md@@ -226,3 +226,15 @@ When changing behavior, test the responsible primitive or pure function. Whenmoving behavior, retain query keys, persistence keys, mutation ordering, loadingboundaries, routes, and markup. Run CRM tests plus affected shared collection anduser-card tests, TypeScript checking, `just check`, and the real CRM browser flows.++Pipeline stage requirements are CRM policy over the shared database editor.+Remove a required field's rules before deleting its options, since option+deletion clears values even on rows outside the submitted operation batch.+`queries/stage-requirements.ts` adapts the pipeline-authorized rules; the toolbar+opens the shared-control dialog, and Add deal derives its required fields from+stable option/column IDs. Keep drafts on a refused save. The server is authoritative+for table, board, timeline, agent and import writes. Board and timeline creation+use the host composer so stage and date-range defaults reach Add deal. CSV writes split refused batches,+commit valid entries, and show record-specific failures; option labels enter the+local cache only after their batch commits. The backend-free regression is+`bunx playwright test --config src/features/crm/browser-test/playwright.config.ts stage-requirements.browser.e2e.ts`.diff --git a/apps/web/src/features/crm/browser-test/stage-requirements.browser.e2e.ts b/apps/web/src/features/crm/browser-test/stage-requirements.browser.e2e.tsnew file mode 100644index 0000000000..82e6a8b4c7--- /dev/null+++ b/apps/web/src/features/crm/browser-test/stage-requirements.browser.e2e.ts@@ -0,0 +1,121 @@+import { expect, test } from '@playwright/test';++for (const viewport of [+ { width: 1280, height: 800 },+ { width: 390, height: 844 },+]) {+ test.describe(`${viewport.width}px`, () => {+ test.use({+ viewport,+ hasTouch: viewport.width === 390,+ isMobile: viewport.width === 390,+ });+ test(`configure requirements and retain a rejected deal at ${viewport.width}px`, async ({+ page,+ }) => {+ const activate = viewport.width === 390 ? 'tap' : 'click';+ await page.routeWebSocket('**', (socket) => socket.close());+ await page.route('https://**', (route) => route.abort());+ await page.route('**/__macro_dev/**', (route) => route.abort());+ await page.goto(+ '/src/features/crm/browser-test/stage-requirements.html',+ {+ waitUntil: 'domcontentloaded',+ }+ );+ await page+ .getByRole('button', { name: 'Stage requirements', exact: true })+ [activate]();+ let dialog = page.getByRole('dialog');+ await dialog.getByRole('button', { name: 'Required stage' })[activate]();+ await page+ .getByRole('menuitemradio', { name: 'Negotiation', exact: true })+ [activate]();+ await dialog.getByText('Amount', { exact: true })[activate]();+ await expect(+ dialog.getByRole('checkbox', { name: 'Amount' })+ ).toBeChecked();+ await page.screenshot({+ path: `/tmp/crm-3928-requirements-${viewport.width}.png`,+ });+ await dialog+ .getByRole('button', { name: 'Save requirements' })+ [activate]();+ await expect(dialog).not.toBeVisible();+ await page.getByRole('button', { name: 'Reject next save' })[activate]();+ await page+ .getByRole('button', { name: 'Add deal', exact: true })+ [activate]();+ dialog = page.getByRole('dialog');+ await dialog+ .getByRole('combobox', { name: 'Find or add a company' })+ .fill('Acme');+ await page.getByRole('option', { name: 'Acme', exact: true })[activate]();+ await dialog.getByRole('button', { name: /^Add deal/ })[activate]();+ await expect(dialog.getByRole('alert')).toContainText('Amount');+ await expect(dialog.getByText('acme.com')).toBeVisible();+ await page.screenshot({+ path: `/tmp/crm-3928-required-deal-${viewport.width}.png`,+ });+ await dialog.getByRole('button', { name: /Amount/ })[activate]();+ await dialog.getByRole('textbox', { name: 'Edit Amount' }).fill('2500');+ await dialog.getByRole('textbox', { name: 'Edit Amount' }).press('Enter');+ await dialog.getByRole('button', { name: /^Add deal/ })[activate]();+ await expect(dialog.getByRole('alert')).toContainText('Could not add');+ await expect(+ dialog.getByRole('button', { name: /Amount/ })+ ).toContainText('2,500');+ await dialog.getByRole('button', { name: /^Add deal/ })[activate]();+ await expect(dialog).not.toBeVisible();+ await expect(page.getByLabel('Saved deal')).toContainText('2500');+ });++ test('timeline creation keeps its dates and stage in the required-field form', async ({+ page,+ }) => {+ const activate = viewport.width === 390 ? 'tap' : 'click';+ await page.routeWebSocket('**', (socket) => socket.close());+ await page.route('https://**', (route) => route.abort());+ await page.route('**/__macro_dev/**', (route) => route.abort());+ await page.goto('/src/features/crm/browser-test/stage-requirements.html');+ await page.getByRole('button', { name: 'Open timeline' })[activate]();+ const row = page+ .locator('[data-timeline-group="option:negotiation"]')+ .first();+ await expect(row).toBeVisible();+ const box = await row.boundingBox();+ expect(box).not.toBeNull();+ await row.click({+ button: 'right',+ position: {+ x: Math.min(box!.width - 8, viewport.width - box!.x - 8),+ y: box!.height / 2,+ },+ });+ await page.getByRole('menuitem', { name: 'New record here' })[activate]();+ const dialog = page.getByRole('dialog');+ await expect(dialog.getByRole('button', { name: /Stage/ })).toContainText(+ 'Negotiation'+ );+ await expect(+ dialog.getByRole('button', { name: /Schedule/ })+ ).not.toContainText('Empty');+ await dialog+ .getByRole('combobox', { name: 'Find or add a company' })+ .fill('Acme');+ await page.getByRole('option', { name: 'Acme', exact: true })[activate]();+ await dialog.getByRole('button', { name: /^Add deal/ })[activate]();+ await expect(dialog.getByRole('alert')).toContainText('Amount');+ await dialog.getByRole('button', { name: /Amount/ })[activate]();+ await dialog.getByRole('textbox', { name: 'Edit Amount' }).fill('100');+ await dialog.getByRole('textbox', { name: 'Edit Amount' }).press('Enter');+ await dialog.getByRole('button', { name: /^Add deal/ })[activate]();+ await expect(dialog).not.toBeVisible();+ const saved = JSON.parse(+ (await page.getByLabel('Saved deal').textContent())!+ );+ expect(saved).toMatchObject({ stage: 'Negotiation', amount: 100 });+ expect(saved.schedule).toMatch(/^\d{4}-.*Z\/\d{4}-.*Z$/);+ });+ });+}diff --git a/apps/web/src/features/crm/browser-test/stage-requirements.html b/apps/web/src/features/crm/browser-test/stage-requirements.htmlnew file mode 100644index 0000000000..041e1137f8--- /dev/null+++ b/apps/web/src/features/crm/browser-test/stage-requirements.html@@ -0,0 +1,2 @@+<!doctype html>+<html lang="en"><head><meta charset="utf-8" /><meta name="viewport" content="width=device-width, initial-scale=1" /><title>Pipeline stage requirements</title></head><body><div id="root"></div><script type="module" src="./stage-requirements.tsx"></script></body></html>diff --git a/apps/web/src/features/crm/browser-test/stage-requirements.tsx b/apps/web/src/features/crm/browser-test/stage-requirements.tsxnew file mode 100644index 0000000000..dabb38ef9c--- /dev/null+++ b/apps/web/src/features/crm/browser-test/stage-requirements.tsx@@ -0,0 +1,254 @@+import '@app/index.css';+import { Button } from '@ui';+import { createSignal, Show } from 'solid-js';+import { render } from 'solid-js/web';+import type {+ DatabaseCellValue,+ DatabaseViewColumn,+} from '../../database/core/database-view';+import { DatabaseTimelineView } from '../../database/views/database-timeline-view';+import { StageRequirementsDialog } from '../components/stage-requirements-dialog';+import { type CrmContext, CrmProvider } from '../context/crm-context';+import type { StageRequirement } from '../core/stage-requirements';+import { AddPipelineRecordDialog } from '../views/add-pipeline-record';++const unused = (): never => {+ throw new Error('Unused fixture capability');+};+const context: CrmContext = {+ createPipelines: unused,+ createDatabases: unused,+ openCreateItem: unused,+ openEmailComposer: unused,+ PipelineEditor: unused,+ PipelineEntries: unused,+ PipelineSharing: unused,+ createPipelineTransfer: unused,+ downloadCsv: unused,+ createContactPhoto: unused,+ contactInitials: unused,+ userEmail: unused,+ copyViewLink: unused,+ copyPipelineLink: unused,+ copyRecordLink: unused,+ createNavigation: unused,+ listsEnabled: unused,+ pipelinesEnabled: unused,+ createCompanyEmails: unused,+ createContactEmails: unused,+ createActivity: unused,+ createActivityState: unused,+ createActivityFilters: unused,+ ActivityTasks: unused,+ openTaskComposer: unused,+ registerTaskComposerRecord: unused,+ createRecordFiles: unused,+ createRecordCalls: unused,+ createRecordReferences: unused,+ RecordTasks: unused,+ createPropertyCommands: unused,+ hydrateCompany: unused,+ createSettingsCommands: unused,+ createReplaceStages: unused,+ createResetStages: unused,+ createExportDefinitions: unused,+ exportCompanies: unused,+ createDisplayOptions: unused,+ openCreateCompany: unused,+ openCreateContact: unused,+ userId: unused,+ isTeamAdmin: unused,+ createCompanySource: unused,+ createContactSource: unused,+ createTeamSource: unused,+ createTeamConfigSource: unused,+ createCapabilities: unused,+ createDealStages: unused,+ createPersonalViews: unused,+ createTeamViews: unused,+ createLists: unused,+ createCompanyImporter: unused,+ createBlockedDomains: unused,+ renameCompany: unused,+ renameContact: unused,+ hideCompany: unused,+ hideContact: unused,+ setEmailSync: unused,+ feedback: { success: unused, failure: unused },+ createCompany: () => ({+ isPending: false,+ mutate: unused,+ mutateAsync: async () => ({ id: 'new-company' }),+ }),+ createContact: () => ({+ isPending: false,+ mutate: unused,+ mutateAsync: async () => ({ id: 'new-contact' }),+ }),+ createCompanySuggestions: () => ({+ companies: () => [+ { id: 'acme', name: 'Acme', domains: [{ domain: 'acme.com' }] },+ ],+ query: { isLoading: false },+ }),+ createContactSuggestions: () => ({+ contacts: () => [],+ query: { isLoading: false },+ }),+};+const columns: DatabaseViewColumn[] = [+ {+ id: 'company',+ name: 'Company',+ dataType: 'ENTITY',+ specificEntityType: 'COMPANY',+ primary: true,+ isMultiSelect: false,+ writable: true,+ options: [],+ },+ {+ id: 'stage',+ name: 'Stage',+ dataType: 'SELECT_STRING',+ isMultiSelect: false,+ writable: true,+ options: [+ { id: 'lead', label: 'Lead', color: null },+ { id: 'negotiation', label: 'Negotiation', color: null },+ ],+ },+ {+ id: 'amount',+ name: 'Amount',+ dataType: 'NUMBER',+ isMultiSelect: false,+ writable: true,+ options: [],+ },+ {+ id: 'schedule',+ name: 'Schedule',+ dataType: 'DATE_RANGE',+ isMultiSelect: false,+ writable: true,+ options: [],+ },+];+function Fixture() {+ const [rules, setRules] = createSignal<StageRequirement[]>([]);+ const [configuring, setConfiguring] = createSignal(false);+ const [adding, setAdding] = createSignal(false);+ const [fail, setFail] = createSignal(false);+ const [saved, setSaved] = createSignal('');+ const [timeline, setTimeline] = createSignal(false);+ const [initialValues, setInitialValues] = createSignal<+ Record<string, DatabaseCellValue>+ >({ stage: 'Negotiation' });+ return (+ <CrmProvider value={context}>+ <main class="min-h-screen bg-canvas-base p-4 text-ink">+ <h1 class="mb-4 text-xl">Sales pipeline</h1>+ <div class="flex flex-wrap gap-2">+ <Button onClick={() => setConfiguring(true)}>+ Stage requirements+ </Button>+ <Button+ onClick={() => {+ setInitialValues({ stage: 'Negotiation' });+ setAdding(true);+ }}+ >+ Add deal+ </Button>+ <Button+ onClick={() => {+ setRules([+ {+ columnId: 'stage',+ optionId: 'negotiation',+ fields: ['amount'],+ },+ ]);+ setTimeline(true);+ }}+ >+ Open timeline+ </Button>+ <Button onClick={() => setFail(true)}>Reject next save</Button>+ </div>+ <output aria-label="Saved deal">{saved()}</output>+ <Show when={timeline()}>+ <div class="mt-4 flex h-[500px] min-w-0 flex-col">+ <DatabaseTimelineView+ view={{+ query: { filter: null, sort: [] },+ layout: {+ kind: 'timeline',+ range: 'schedule',+ title: 'company',+ groupBy: 'stage',+ colorBy: null,+ },+ }}+ rows={[+ {+ rowId: 'existing',+ cells: {+ stage: 'Negotiation',+ schedule:+ '2026-10-26T00:00:00.000Z/2026-10-28T00:00:00.000Z',+ },+ },+ ]}+ columns={columns}+ canEdit+ filtered={false}+ rowPending={() => false}+ onOpen={unused}+ onWrite={unused}+ onCreate={unused}+ onCompose={(values) => {+ setInitialValues(values);+ setAdding(true);+ }}+ />+ </div>+ </Show>+ <Show when={configuring()}>+ <StageRequirementsDialog+ columns={columns}+ rules={rules()}+ onClose={() => setConfiguring(false)}+ onSave={async (rule) => {+ if (fail()) {+ setFail(false);+ throw new Error('Failed');+ }+ setRules([rule]);+ }}+ />+ </Show>+ <Show when={adding()}>+ <AddPipelineRecordDialog+ pipeline={{ name: 'Sales', recordType: 'company' }}+ columns={columns}+ requirements={rules()}+ initialValues={initialValues()}+ onClose={() => setAdding(false)}+ onCreate={async (creation) => {+ if (fail()) {+ setFail(false);+ return false;+ }+ setSaved(JSON.stringify(creation.values));+ return true;+ }}+ />+ </Show>+ </main>+ </CrmProvider>+ );+}+const root = document.getElementById('root');+if (root) render(Fixture, root);diff --git a/apps/web/src/features/crm/components/pipeline-import-failures.tsx b/apps/web/src/features/crm/components/pipeline-import-failures.tsxnew file mode 100644index 0000000000..72d7b508bd--- /dev/null+++ b/apps/web/src/features/crm/components/pipeline-import-failures.tsx@@ -0,0 +1,29 @@+import { For, Show } from 'solid-js';++/** Rejected entries remain identifiable without discarding successful imports. */+export function PipelineImportFailures(props: {+ addLabel: 'Add deal' | 'Add contact';+ failures?: { entry: number; key: string; reason: string }[];+}) {+ return (+ <Show when={props.failures?.length}>+ <div class="text-sm" role="alert">+ <p>+ {props.failures?.length.toLocaleString()}{' '}+ {props.failures?.length === 1 ? 'entry' : 'entries'} could not be+ added. Use {props.addLabel} to add these entries with the listed+ fields filled in.+ </p>+ <ul class="mt-2 max-h-48 overflow-y-auto space-y-1 text-failure">+ <For each={props.failures}>+ {(failure) => (+ <li>+ Entry {failure.entry} ({failure.key}): {failure.reason}+ </li>+ )}+ </For>+ </ul>+ </div>+ </Show>+ );+}diff --git a/apps/web/src/features/crm/components/stage-requirements-dialog.test.tsx b/apps/web/src/features/crm/components/stage-requirements-dialog.test.tsxnew file mode 100644index 0000000000..fce6697b98--- /dev/null+++ b/apps/web/src/features/crm/components/stage-requirements-dialog.test.tsx@@ -0,0 +1,75 @@+import {+ cleanup,+ fireEvent,+ render,+ screen,+ waitFor,+} from '@solidjs/testing-library';+import { createSignal } from 'solid-js';+import { afterEach, beforeEach, expect, it, vi } from 'vitest';+import type { DatabaseViewColumn } from '../../database/core/database-view';+import { StageRequirementsDialog } from './stage-requirements-dialog';++beforeEach(() => {+ vi.spyOn(window, 'scrollTo').mockImplementation(() => {});+});+afterEach(() => {+ cleanup();+ vi.restoreAllMocks();+});++it('drops deleted fields from a draft while retaining its surviving selections', async () => {+ const columns: DatabaseViewColumn[] = [+ {+ id: 'stage',+ name: 'Stage',+ dataType: 'SELECT_STRING',+ isMultiSelect: false,+ options: [{ id: 'negotiation', label: 'Negotiation', color: null }],+ writable: true,+ },+ {+ id: 'amount',+ name: 'Amount',+ dataType: 'NUMBER',+ isMultiSelect: false,+ options: [],+ writable: true,+ },+ {+ id: 'owner',+ name: 'Owner',+ dataType: 'STRING',+ isMultiSelect: false,+ options: [],+ writable: true,+ },+ ];+ const save = vi.fn(async () => {});+ let removeAmount = () => {};+ render(() => {+ const [current, setCurrent] = createSignal(columns);+ removeAmount = () =>+ setCurrent((before) => before.filter((column) => column.id !== 'amount'));+ return (+ <StageRequirementsDialog+ columns={current()}+ rules={[]}+ onSave={save}+ onClose={() => {}}+ />+ );+ });+ fireEvent.click(screen.getByLabelText('Amount'));+ fireEvent.click(screen.getByLabelText('Owner'));+ removeAmount();+ expect(screen.queryByLabelText('Amount')).toBeNull();+ fireEvent.click(screen.getByRole('button', { name: /^Save requirements/ }));+ await waitFor(() =>+ expect(save).toHaveBeenCalledWith({+ columnId: 'stage',+ optionId: 'negotiation',+ fields: ['owner'],+ })+ );+});diff --git a/apps/web/src/features/crm/components/stage-requirements-dialog.tsx b/apps/web/src/features/crm/components/stage-requirements-dialog.tsxnew file mode 100644index 0000000000..66c43c195f--- /dev/null+++ b/apps/web/src/features/crm/components/stage-requirements-dialog.tsx@@ -0,0 +1,214 @@+import { t } from '@app/lib/i18n';+import { fireAndForget } from '@core/util/fireAndForget';+import XIcon from '@icon/system/regular/x.svg';+import { Button, Checkbox, Dialog, Dropdown, EntityComposer, Panel } from '@ui';+import { createSignal, For, Show } from 'solid-js';+import type { DatabaseViewColumn } from '../../database/core/database-view';+import { canEditCell } from '../../database/core/table';+import type { StageRequirement } from '../core/stage-requirements';++/** Configure one stage at a time so saving cannot overwrite another stage's rules. */+export function StageRequirementsDialog(props: {+ columns: DatabaseViewColumn[];+ rules: StageRequirement[];+ onSave(rule: StageRequirement): Promise<void>;+ onClose(): void;+}) {+ const stages = () =>+ props.columns.filter(+ (column) => column.dataType === 'SELECT_STRING' && !column.isMultiSelect+ );+ const [columnId, setStageColumnId] = createSignal(+ stages().find((column) => column.name === 'Stage')?.id ?? stages()[0]?.id+ );+ const stageColumn = () => stages().find((column) => column.id === columnId());+ const [optionId, setStageId] = createSignal(stageColumn()?.options[0]?.id);+ const stage = () =>+ stageColumn()?.options.find((option) => option.id === optionId());+ const saved = () =>+ props.rules.find(+ (rule) => rule.columnId === columnId() && rule.optionId === optionId()+ );+ const [draft, setDraft] = createSignal<string[]>();+ const required = () => draft() ?? saved()?.fields ?? [];+ const [pending, setPending] = createSignal(false);+ const [failed, setFailed] = createSignal(false);+ const fields = () =>+ props.columns.filter(+ (column) =>+ column.id !== columnId() &&+ !column.primary &&+ canEditCell(column) &&+ !column.relation+ );+ const selectStage = (id: string) => {+ setStageId(id);+ setDraft(undefined);+ setFailed(false);+ };+ const selectColumn = (id: string) => {+ setStageColumnId(id);+ setStageId(stageColumn()?.options[0]?.id);+ setDraft(undefined);+ setFailed(false);+ };+ async function save() {+ const column = columnId();+ const option = optionId();+ if (!column || !option || !stage() || pending()) return;+ setPending(true);+ setFailed(false);+ try {+ await props.onSave({+ columnId: column,+ optionId: option,+ fields: required().filter((id) =>+ fields().some((field) => field.id === id)+ ),+ });+ props.onClose();+ } catch {+ setFailed(true);+ } finally {+ setPending(false);+ }+ }+ const close = () => !pending() && props.onClose();+ return (+ <Dialog open onOpenChange={(open) => !open && close()}>+ <Panel hideBorder class="bg-transparent rounded-[inherit] *:max-h-[80vh]">+ <Panel.Body>+ <form+ class="h-full min-h-0"+ onSubmit={(event) => {+ event.preventDefault();+ fireAndForget(save(), 'crm');+ }}+ >+ <EntityComposer.Root>+ <EntityComposer.Header>+ <Dialog.Title class="flex-1 text-base font-semibold">+ {t('crm.stageRequirements')}+ </Dialog.Title>+ <Button+ size="icon-md"+ aria-label={t('common.close')}+ disabled={pending()}+ onClick={close}+ >+ <XIcon />+ </Button>+ </EntityComposer.Header>+ <EntityComposer.Main class="gap-4 overflow-y-auto">+ <p class="text-sm text-ink-muted">+ {t('crm.stageRequirementsDescription')}+ </p>+ <div class="flex flex-wrap gap-2">+ <Dropdown>+ <Dropdown.Trigger+ disabled={pending()}+ aria-label={t('crm.stageField')}+ >+ {stageColumn()?.name ?? t('crm.chooseStageField')}+ </Dropdown.Trigger>+ <Dropdown.Content>+ <Dropdown.RadioGroup+ value={columnId()}+ onChange={selectColumn}+ >+ <For each={stages()}>+ {(column) => (+ <Dropdown.RadioItem value={column.id} closeOnSelect>+ {column.name}+ </Dropdown.RadioItem>+ )}+ </For>+ </Dropdown.RadioGroup>+ </Dropdown.Content>+ </Dropdown>+ <Dropdown>+ <Dropdown.Trigger+ disabled={pending()}+ aria-label={t('crm.requiredStage')}+ >+ {stage()?.label ?? t('crm.chooseStage')}+ </Dropdown.Trigger>+ <Dropdown.Content>+ <Dropdown.RadioGroup+ value={optionId()}+ onChange={selectStage}+ >+ <For each={stageColumn()?.options ?? []}>+ {(option) => (+ <Dropdown.RadioItem value={option.id} closeOnSelect>+ {option.label}+ </Dropdown.RadioItem>+ )}+ </For>+ </Dropdown.RadioGroup>+ </Dropdown.Content>+ </Dropdown>+ </div>+ <Show+ when={stage()}+ fallback={+ <p class="text-sm text-ink-muted">+ {t('crm.stageOptionRequired')}+ </p>+ }+ >+ <div class="flex flex-col gap-3">+ <For each={fields()}>+ {(column) => (+ <Checkbox+ checked={required().includes(column.id)}+ disabled={pending()}+ onChange={(checked) =>+ setDraft(+ checked+ ? [...required(), column.id]+ : required().filter((id) => id !== column.id)+ )+ }+ >+ <Checkbox.Control />+ <Checkbox.Label>{column.name}</Checkbox.Label>+ </Checkbox>+ )}+ </For>+ </div>+ </Show>+ <p class="text-xs text-ink-muted">+ {t('crm.stageRequirementsLifecycle')}+ </p>+ <Show when={failed()}>+ <p role="alert" class="text-sm text-failure">+ {t('crm.stageRequirementsSaveFailed')}+ </p>+ </Show>+ </EntityComposer.Main>+ <EntityComposer.Footer class="justify-end">+ <Button+ variant="secondary"+ disabled={pending()}+ onClick={close}+ >+ {t('common.cancel')}+ </Button>+ <EntityComposer.Submit+ type="submit"+ hasContent={!!stage()}+ disabled={pending() || !stage()}+ >+ {pending()+ ? t('crm.savingRequirements')+ : t('crm.saveRequirements')}+ </EntityComposer.Submit>+ </EntityComposer.Footer>+ </EntityComposer.Root>+ </form>+ </Panel.Body>+ </Panel>+ </Dialog>+ );+}diff --git a/apps/web/src/features/crm/context/pipelines.ts b/apps/web/src/features/crm/context/pipelines.tsindex 11d3c20d1d..38acfacaa0 100644--- a/apps/web/src/features/crm/context/pipelines.ts+++ b/apps/web/src/features/crm/context/pipelines.ts@@ -39,7 +39,8 @@ export type PipelineTransfer = {/** Appends rows, first adding the select options they name that columns lack. */insertRows(rows: readonly CellWrite[][],- columns: readonly DatabaseViewColumn[]+ columns: readonly DatabaseViewColumn[],+ onRejected?: (row: number, reason: string) => void): Promise<void>;/** Shows the new rows and records everywhere they appear. */refresh(): Promise<void>;diff --git a/apps/web/src/features/crm/core/pipeline-csv.ts b/apps/web/src/features/crm/core/pipeline-csv.tsindex 3600d015d4..470f5365c6 100644--- a/apps/web/src/features/crm/core/pipeline-csv.ts+++ b/apps/web/src/features/crm/core/pipeline-csv.ts@@ -310,3 +310,6 @@ export function companyPipelineCsv(fields: fields.map((index) => csv.columns[index].trim()),};}++/** An import write was refused and the user can correct its values. */+export class PipelineImportRefusal extends Error {}diff --git a/apps/web/src/features/crm/core/stage-requirements.test.ts b/apps/web/src/features/crm/core/stage-requirements.test.tsnew file mode 100644index 0000000000..6e5d3a8cec--- /dev/null+++ b/apps/web/src/features/crm/core/stage-requirements.test.ts@@ -0,0 +1,79 @@+import { describe, expect, it } from 'vitest';+import type { DatabaseViewColumn } from '../../database/core/database-view';+import { missingStageFields, requiredStageFields } from './stage-requirements';++const columns: DatabaseViewColumn[] = [+ {+ id: 'stage',+ name: 'Milestone',+ dataType: 'SELECT_STRING',+ isMultiSelect: false,+ writable: true,+ options: [{ id: 'negotiation', label: 'New label', color: null }],+ },+ {+ id: 'amount',+ name: 'Renamed amount',+ dataType: 'NUMBER',+ isMultiSelect: false,+ writable: true,+ options: [],+ },+ {+ id: 'checked',+ name: 'Approval',+ dataType: 'BOOLEAN',+ isMultiSelect: false,+ writable: true,+ options: [],+ },+ {+ id: 'notes',+ name: 'Notes',+ dataType: 'STRING',+ isMultiSelect: false,+ writable: true,+ options: [],+ },+ {+ id: 'people',+ name: 'Owners',+ dataType: 'ENTITY',+ isMultiSelect: true,+ writable: true,+ options: [],+ },+];+describe('stage requirement drafts', () => {+ it('keeps identity through field and stage renames and ignores deleted fields', () => {+ const rules = [+ {+ columnId: 'stage',+ optionId: 'negotiation',+ fields: ['amount', 'deleted'],+ },+ ];+ expect(requiredStageFields(columns, rules, { stage: 'New label' })).toEqual(+ [columns[1]]+ );+ expect(requiredStageFields(columns, rules, { stage: null })).toEqual([]);+ });+ it('distinguishes absent values from zero and false', () => {+ expect(+ missingStageFields(columns.slice(1), {+ amount: 0,+ checked: 0,+ notes: ' ',+ people: '[]',+ }).map((column) => column.id)+ ).toEqual(['notes', 'people']);+ expect(+ missingStageFields(columns.slice(1), {+ amount: 0,+ checked: 0,+ notes: 'A note',+ people: '["person"]',+ })+ ).toEqual([]);+ });+});diff --git a/apps/web/src/features/crm/core/stage-requirements.ts b/apps/web/src/features/crm/core/stage-requirements.tsnew file mode 100644index 0000000000..5a3844db82--- /dev/null+++ b/apps/web/src/features/crm/core/stage-requirements.ts@@ -0,0 +1,44 @@+import {+ type DatabaseCellValue,+ type DatabaseViewColumn,+ databaseCellValues,+} from '../../database/core/database-view';++/** A pipeline policy, expressed in stable editor identities. */+export type StageRequirement = {+ columnId: string;+ optionId: string;+ fields: string[];+};++/** Resolve stage identities from the shared editor's option labels. */+export function requiredStageFields(+ columns: DatabaseViewColumn[],+ rules: StageRequirement[],+ values: Record<string, DatabaseCellValue>+): DatabaseViewColumn[] {+ const required = new Set<string>();+ for (const rule of rules) {+ const stage = columns.find((column) => column.id === rule.columnId);+ const selected = stage?.options.find(+ (option) => option.label === values[rule.columnId]+ );+ if (selected?.id === rule.optionId)+ for (const id of rule.fields) required.add(id);+ }+ return columns.filter((column) => required.has(column.id));+}++/** Empty text and empty selections are absent; zero and false are values. */+export function missingStageFields(+ required: DatabaseViewColumn[],+ values: Record<string, DatabaseCellValue>+): DatabaseViewColumn[] {+ return required.filter((column) => {+ const entries = databaseCellValues(values[column.id] ?? null, column);+ return !entries.some(+ (value) =>+ value !== null && (typeof value !== 'string' || value.trim() !== '')+ );+ });+}diff --git a/apps/web/src/features/crm/pipeline-adapter.tsx b/apps/web/src/features/crm/pipeline-adapter.tsxindex 854359f0fb..407f366035 100644--- a/apps/web/src/features/crm/pipeline-adapter.tsx+++ b/apps/web/src/features/crm/pipeline-adapter.tsx@@ -45,6 +45,7 @@ import type { BoardPositions } from '../database/views/database-board-view';import { DatabaseRecords } from '../database/views/database-records';import type { DatabaseRecordsActions } from '../database/views/database-records-view';import { CrmListSkeleton } from './components/list-state';+import { StageRequirementsDialog } from './components/stage-requirements-dialog';import type { Pipeline } from './core/pipeline';import { createPipelineApi } from './queries/pipeline-data';import {@@ -53,6 +54,7 @@ import {usePipelinePositionsQuery,usePipelineTableQuery,} from './queries/pipeline-views';+import { useStageRequirements } from './queries/stage-requirements';import { AddPipelineRecordDialog } from './views/add-pipeline-record';/** Pipelines supply their own identity and owner to the existing share dialog. */@@ -245,6 +247,11 @@ function PipelineToolbar(props: {pipelineActions?: JSX.Element;}) {const database = useDatabase();+ const requirements = useStageRequirements(+ { storage: storageServiceClient, client: useQueryClient() },+ props.pipeline.id+ );+ const [configuring, setConfiguring] = createSignal(false);const columns = () => database.data.rows.columns();// A column added with a board shows once the table is read again.const refreshColumns = () => {@@ -308,6 +315,25 @@ function PipelineToolbar(props: {actions={<><Show when={props.canEdit}>+ <Button+ variant="secondary"+ disabled={!queryReadyGate(requirements.query)}+ onClick={() => setConfiguring(true)}+ >+ Stage requirements+ </Button>+ <Show when={configuring()}>+ <StageRequirementsDialog+ columns={columns()}+ rules={+ queryReadyGate(requirements.query)+ ? requirements.query.data+ : []+ }+ onSave={requirements.save}+ onClose={() => setConfiguring(false)}+ />+ </Show><Button variant="secondary" onClick={() => props.onCompose({})}><PlusIcon class="size-4" />{props.pipeline.recordType === 'company'@@ -321,6 +347,16 @@ function PipelineToolbar(props: {pipeline={props.pipeline}columns={columns()}initialValues={initialValues}+ requirements={+ queryReadyGate(requirements.query)+ ? requirements.query.data+ : undefined+ }+ requirementsLoading={requirements.query.isPending}+ requirementsError={+ !queryReadyGate(requirements.query) &&+ requirements.query.isError+ }onCreate={props.actions.createRow}onClose={() => props.onCompose(undefined)}renderTextEditor={(editor) => (diff --git a/apps/web/src/features/crm/primitives/pipeline-transfer.test.ts b/apps/web/src/features/crm/primitives/pipeline-transfer.test.tsindex 9d77386c80..357a097e5d 100644--- a/apps/web/src/features/crm/primitives/pipeline-transfer.test.ts+++ b/apps/web/src/features/crm/primitives/pipeline-transfer.test.ts@@ -4,7 +4,10 @@ import { describe, expect, it, vi } from 'vitest';import type { DatabaseViewColumn } from '../../database/core/database-view';import type { PipelineTransfer } from '../context/pipelines';import type { Pipeline } from '../core/pipeline';-import type { PipelineCsvRow } from '../core/pipeline-csv';+import {+ type PipelineCsvRow,+ PipelineImportRefusal,+} from '../core/pipeline-csv';import {createPipelineExport,createPipelineImport,@@ -117,6 +120,54 @@ describe('pipeline import', () => {dispose();});+ it('reports a rejected deal separately from a valid deal for the same company', async () => {+ const { transfer } = fakeTransfer([]);+ const { state, dispose } = createRoot((dispose) => ({+ state: createPipelineImport(pipeline, {+ ...transfer,+ insertRows: async (rows, _columns, rejected) => {+ expect(rows).toHaveLength(2);+ rejected?.(0, 'Fill in Amount before entering Lead.');+ },+ }),+ dispose,+ }));+ await state.read(+ file('Company,Domain,Stage\nAcme,acme.com,Lead\nAcme,acme.com,Won\n')+ );+ await state.run();+ expect(state.result()).toEqual({+ added: 1,+ present: 0,+ unresolved: 0,+ invalid: [+ {+ entry: 1,+ key: 'acme.com',+ reason: 'Fill in Amount before entering Lead.',+ },+ ],+ });+ dispose();+ });++ it('keeps the import plan and shows a stage requirement refusal', async () => {+ const { transfer } = fakeTransfer([]);+ transfer.insertRows.mockRejectedValueOnce(+ new PipelineImportRefusal('Fill in Revenue before entering Lead.')+ );+ const { state, dispose } = createRoot((dispose) => ({+ state: createPipelineImport(pipeline, transfer),+ dispose,+ }));+ await state.read(file('Company,Domain,Stage\nAcme,acme.com,Lead\n'));+ await state.run();+ expect(state.error()).toContain('Revenue');+ expect(state.plan()?.rows).toHaveLength(1);+ expect(state.result()).toBeUndefined();+ dispose();+ });+it('exports each entry with its company name and domain', async () => {const { transfer } = fakeTransfer([{ cells: { company: 'acme-id', stage: 'Lead' } },diff --git a/apps/web/src/features/crm/primitives/pipeline-transfer.ts b/apps/web/src/features/crm/primitives/pipeline-transfer.tsindex 9e4f2c91be..61b1b5b39a 100644--- a/apps/web/src/features/crm/primitives/pipeline-transfer.ts+++ b/apps/web/src/features/crm/primitives/pipeline-transfer.ts@@ -13,6 +13,7 @@ import {encodePipelineCsv,type PipelineCsvRow,type PipelineImportPlan,+ PipelineImportRefusal,pipelineImportMessage,pipelineRecordCell,planPipelineImport,@@ -95,6 +96,8 @@ export type PipelineImportResult = {present: number;/** Records that could not be found or created, such as gmail.com companies. */unresolved: number;+ /** Refused entries, identified by record and position in the import. */+ invalid?: { entry: number; key: string; reason: string }[];};/**@@ -121,17 +124,24 @@ export async function addPipelineRows(input: {);const present = recordIds(pipeline, table.rows);const rows: CellWrite[][] = [];+ const entries: { entry: number; key: string }[] = [];const outcome: PipelineImportResult = { added: 0, present: 0, unresolved: 0 };- for (const row of plan.rows) {+ for (const [index, row] of plan.rows.entries()) {const id = ids.get(row.record.key);if (!id) outcome.unresolved++;else if (present.has(id)) outcome.present++;- else rows.push([pipelineRecordCell(pipeline, id), ...row.cells]);+ else {+ rows.push([pipelineRecordCell(pipeline, id), ...row.cells]);+ entries.push({ entry: index + 1, key: row.record.key });+ }}await span.span('crm.pipeline.insert_rows', () =>- transfer.insertRows(rows, table.columns)+ transfer.insertRows(rows, table.columns, (index, reason) => {+ outcome.invalid ??= [];+ outcome.invalid.push({ ...entries[index], reason });+ }));- outcome.added = rows.length;+ outcome.added = rows.length - (outcome.invalid?.length ?? 0);return outcome;}@@ -214,7 +224,9 @@ export function createPipelineImport(} catch (cause) {span.error(cause);setError(- 'Could not finish the import. Retry to add the rows that are still missing.'+ cause instanceof PipelineImportRefusal+ ? cause.message+ : 'Could not finish the import. Retry to add the rows that are still missing.');}try {diff --git a/apps/web/src/features/crm/queries/keys.ts b/apps/web/src/features/crm/queries/keys.tsindex 59cecb00cc..b749c4cdc5 100644--- a/apps/web/src/features/crm/queries/keys.ts+++ b/apps/web/src/features/crm/queries/keys.ts@@ -4,6 +4,7 @@ export const crmKeys = createQueryKeys('crm', {lists: null,pipelines: (teamId: string | undefined) => [teamId],pipelineTable: (id: string) => [id],+ stageRequirements: (id: string) => [id],pipelinePositions: (id: string, viewId: string | undefined) => [id, viewId],pipelineRows: (id: string) => [id],company: (companyId: string) => [companyId],diff --git a/apps/web/src/features/crm/queries/pipeline-transfer.test.ts b/apps/web/src/features/crm/queries/pipeline-transfer.test.tsindex 98693751e6..d77f2c0d52 100644--- a/apps/web/src/features/crm/queries/pipeline-transfer.test.ts+++ b/apps/web/src/features/crm/queries/pipeline-transfer.test.ts@@ -55,9 +55,16 @@ function setup(recordType: Pipeline['recordType'] = 'company') {ok({ id: `${email}-id` })),applyCrmPipelineOps: vi.fn(- async (_id: string, request: { ops: DatabaseOp[] }) => {+ async (+ _id: string,+ request: { ops: DatabaseOp[] }+ ): Promise<+ Awaited<+ ReturnType<CrmRecordDependencies['storage']['applyCrmPipelineOps']>+ >+ > => {applied.push(request.ops);- return ok({ results: [] });+ return ok({ results: [], changes: [] });}),};@@ -73,6 +80,60 @@ function setup(recordType: Pipeline['recordType'] = 'company') {}describe('pipeline transfer', () => {+ it('isolates refused entries and only remembers options from committed writes', async () => {+ const { transfer, storage } = setup();+ const saved: DatabaseOp[][] = [];+ storage.applyCrmPipelineOps.mockImplementation(async (_id, request) => {+ const insert = request.ops.find((op) => op.kind === 'rows');+ if (insert?.kind !== 'rows' || insert.change.kind !== 'insert')+ throw new Error('Missing insert');+ if (+ insert.change.rows.some((row) =>+ row.some((cell) => cell.column === 'bad')+ )+ )+ return err([+ {+ code: 'INVALID_OP',+ refusal: null,+ message: 'Fill in Amount before entering Lead.',+ },+ ]);+ saved.push(request.ops);+ return ok({ results: [], changes: [] });+ });+ const stageCell = {+ column: 'stage',+ value: { type: 'options' as const, value: [{ label: 'Negotiation' }] },+ };+ const rejected = vi.fn();+ await transfer.insertRows(+ [+ [stageCell, { column: 'bad', value: { type: 'clear' } }],+ [stageCell],+ [stageCell],+ ],+ [stage],+ rejected+ );+ expect(rejected).toHaveBeenCalledExactlyOnceWith(+ 0,+ 'Fill in Amount before entering Lead.'+ );+ expect(+ saved.flatMap((ops) => ops.filter((op) => op.kind === 'column'))+ ).toHaveLength(1);+ expect(+ saved.flatMap((ops) =>+ ops.flatMap((op) =>+ op.kind === 'rows' && op.change.kind === 'insert'+ ? op.change.rows+ : []+ )+ )+ ).toHaveLength(2);+ });+it('matches companies by domain and creates the missing ones once', async () => {const { transfer, storage } = setup();const ids = await transfer.resolveRecords(diff --git a/apps/web/src/features/crm/queries/pipeline-transfer.ts b/apps/web/src/features/crm/queries/pipeline-transfer.tsindex d33040dd27..77f23676e3 100644--- a/apps/web/src/features/crm/queries/pipeline-transfer.ts+++ b/apps/web/src/features/crm/queries/pipeline-transfer.ts@@ -1,4 +1,4 @@-import type { DatabaseOp } from '@core/database-sql/generated/types';+import type { CellWrite, DatabaseOp } from '@core/database-sql/generated/types';import { ThrownResultError, throwOnErr } from '@core/util/result';import { soupKeys } from '@queries/soup/keys';import { v7 as uuidv7 } from 'uuid';@@ -7,7 +7,10 @@ import { toViewColumn } from '../../database/queries/column-detail';import type { PipelineTransfer } from '../context/pipelines';import { importedDomain } from '../core/import-companies';import type { Pipeline } from '../core/pipeline';-import type { PipelineCsvRecord } from '../core/pipeline-csv';+import {+ type PipelineCsvRecord,+ PipelineImportRefusal,+} from '../core/pipeline-csv';import { runConcurrently } from '../core/run-concurrently';import type { CrmRecordDependencies } from './dependencies';import { fetchCrmExportCompanies } from './export';@@ -151,28 +154,28 @@ export function createPipelineTransfer(});return ids;},- async insertRows(rows, columns) {+ async insertRows(rows, columns, onRejected) {const labels = new Map(columns.map((column) => [column.id,column.options.map((option) => option.label),]));- for (let start = 0; start < rows.length; start += INSERT_BATCH) {+ async function write(+ batch: readonly CellWrite[][],+ start: number+ ): Promise<void> {const insert: DatabaseOp = {kind: 'rows',table: pipeline.tableId,- change: {- kind: 'insert',- rows: rows.slice(start, start + INSERT_BATCH),- },+ change: { kind: 'insert', rows: [...batch] },};- const options: DatabaseOp[] = missingOptionLabels(+ const additions = missingOptionLabels(insert,(id) => labels.get(id) ?? []- ).map(({ column, labels: added }) => {- labels.set(column, [...(labels.get(column) ?? []), ...added]);- return {+ );+ const options: DatabaseOp[] = additions.map(+ ({ column, labels: added }) => ({kind: 'column',table: pipeline.tableId,column,@@ -180,13 +183,33 @@ export function createPipelineTransfer(kind: 'add_options',options: added.map((label) => ({ id: uuidv7(), label })),},- };- });+ })+ );const applied = await storage.applyCrmPipelineOps(pipeline.id, {ops: [...options, insert],});- if (applied.isErr()) throw new ThrownResultError(applied.error);+ if (applied.isErr()) {+ const refusal = applied.error.find(+ (error) => error.code === 'INVALID_OP'+ );+ if (!refusal) throw new ThrownResultError(applied.error);+ if (!onRejected) throw new PipelineImportRefusal(refusal.message);+ // A refusal rolls back the entire batch, including new options. Split+ // only refused batches so valid rows still commit with their options.+ if (batch.length === 1) {+ onRejected(start, refusal.message);+ return;+ }+ const middle = Math.floor(batch.length / 2);+ await write(batch.slice(0, middle), start);+ await write(batch.slice(middle), start + middle);+ return;+ }+ for (const { column, labels: added } of additions)+ labels.set(column, [...(labels.get(column) ?? []), ...added]);}+ for (let start = 0; start < rows.length; start += INSERT_BATCH)+ await write(rows.slice(start, start + INSERT_BATCH), start);},async refresh() {await Promise.all([diff --git a/apps/web/src/features/crm/queries/stage-requirements.ts b/apps/web/src/features/crm/queries/stage-requirements.tsnew file mode 100644index 0000000000..0cffef41d4--- /dev/null+++ b/apps/web/src/features/crm/queries/stage-requirements.ts@@ -0,0 +1,64 @@+import { throwOnErr } from '@core/util/result';+import { Telemetry } from '@macro-inc/observability';+import { useQuery } from '@tanstack/solid-query';+import type { StageRequirement } from '../core/stage-requirements';+import type { CrmRecordDependencies } from './dependencies';+import { crmKeys } from './keys';++function stageRequirementsOptions(+ storage: CrmRecordDependencies['storage'],+ pipelineId: string+) {+ return {+ queryKey: crmKeys.stageRequirements(pipelineId).queryKey,+ queryFn: async () =>+ (+ await throwOnErr(() =>+ storage.getCrmPipelineStageRequirements(pipelineId)+ )+ ).map(+ (rule): StageRequirement => ({+ columnId: rule.stageColumnId,+ optionId: rule.stageId,+ fields: rule.requiredColumnIds,+ })+ ),+ refetchInterval: 5000,+ };+}++/** Pipeline policy is fetched separately from the host-independent table schema. */+export function useStageRequirements(+ deps: CrmRecordDependencies,+ pipelineId: string+) {+ const queryKey = crmKeys.stageRequirements(pipelineId).queryKey;+ const query = useQuery(+ () => stageRequirementsOptions(deps.storage, pipelineId),+ () => deps.client+ );+ return {+ query,+ save: (rule: StageRequirement) =>+ Telemetry.span('crm.stage-requirements.save', async (span) => {+ span.setAttr('pipeline.id', pipelineId);+ await deps.client.cancelQueries({ queryKey });+ await throwOnErr(() =>+ deps.storage.setCrmPipelineStageRequirement(pipelineId, {+ stageColumnId: rule.columnId,+ stageId: rule.optionId,+ requiredColumnIds: rule.fields,+ })+ );+ // Update the committed rule immediately, even if the subsequent refresh fails.+ deps.client.setQueryData<StageRequirement[]>(queryKey, (current) => [+ ...(current ?? []).filter(+ (item) =>+ item.columnId !== rule.columnId || item.optionId !== rule.optionId+ ),+ ...(rule.fields.length ? [rule] : []),+ ]);+ await deps.client.invalidateQueries({ queryKey });+ }),+ };+}diff --git a/apps/web/src/features/crm/views/add-pipeline-record.test.tsx b/apps/web/src/features/crm/views/add-pipeline-record.test.tsxindex 1aa1a3f0b6..9c8d155ceb 100644--- a/apps/web/src/features/crm/views/add-pipeline-record.test.tsx+++ b/apps/web/src/features/crm/views/add-pipeline-record.test.tsx@@ -6,6 +6,7 @@ import {waitFor,} from '@solidjs/testing-library';import userEvent from '@testing-library/user-event';+import { createSignal } from 'solid-js';import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';import type { DatabaseViewColumn } from '../../database/core/database-view';import { AddPipelineRecordDialog } from './add-pipeline-record';@@ -62,14 +63,19 @@ const columns: DatabaseViewColumn[] = [},];-function setup() {+function setup(required = false, currentColumns = () => columns) {const onCreate = vi.fn(async () => true);const onClose = vi.fn();render(() => (<AddPipelineRecordDialogpipeline={{ name: 'Sales', recordType: 'company' }}- columns={columns}+ columns={currentColumns()}initialValues={{ stage: 'Won' }}+ requirements={+ required+ ? [{ columnId: 'stage', optionId: 'won', fields: ['amount'] }]+ : []+ }onCreate={onCreate}onClose={onClose}/>@@ -87,6 +93,89 @@ afterEach(() => {});describe('AddPipelineRecordDialog', () => {+ it('follows a renamed stage identity and refuses a deleted selected stage', async () => {+ const [current, setCurrent] = createSignal(columns);+ const { onCreate } = setup(true, current);+ await userEvent.type(+ screen.getByRole('combobox', { name: 'Find or add a company' }),+ 'acme'+ );+ await userEvent.click(await screen.findByRole('option', { name: /Acme/ }));+ setCurrent((before) =>+ before.map((column) =>+ column.id === 'stage'+ ? {+ ...column,+ options: column.options.map((option) =>+ option.id === 'won'+ ? { ...option, label: 'Negotiation' }+ : option+ ),+ }+ : column+ )+ );+ expect(+ screen.getByRole('button', { name: /Stage:/ }).textContent+ ).toContain('Negotiation');+ fireEvent.click(screen.getByRole('button', { name: /^Add deal/ }));+ expect(screen.getByRole('alert').textContent).toContain('Amount');+ await userEvent.click(screen.getByRole('button', { name: /Amount/ }));+ fireEvent.input(screen.getByRole('textbox', { name: 'Edit Amount' }), {+ target: { value: '100' },+ });+ fireEvent.keyDown(screen.getByRole('textbox', { name: 'Edit Amount' }), {+ key: 'Enter',+ });+ setCurrent((before) =>+ before.map((column) =>+ column.id === 'stage' ? { ...column, options: [] } : column+ )+ );+ fireEvent.click(screen.getByRole('button', { name: /^Add deal/ }));+ expect(screen.getByRole('alert').textContent).toContain(+ 'Stage option was deleted'+ );+ expect(onCreate).not.toHaveBeenCalled();+ expect(+ screen.getByRole('button', { name: /Amount/ }).textContent+ ).toContain('100');+ // Deleting the entire field removes its stale value but keeps other edits.+ setCurrent((before) => before.filter((column) => column.id !== 'stage'));+ fireEvent.click(screen.getByRole('button', { name: /^Add deal/ }));+ await waitFor(() =>+ expect(onCreate).toHaveBeenCalledWith(+ expect.objectContaining({ values: { company: 'acme', amount: 100 } })+ )+ );+ });++ it('preserves the draft after missing stage fields and submits after they are filled', async () => {+ const { onCreate, onClose } = setup(true);+ await userEvent.type(+ screen.getByRole('combobox', { name: 'Find or add a company' }),+ 'acme'+ );+ await userEvent.click(await screen.findByRole('option', { name: /Acme/ }));+ fireEvent.click(screen.getByRole('button', { name: /^Add deal/ }));+ expect(screen.getByRole('alert').textContent).toContain('Amount');+ expect(onCreate).not.toHaveBeenCalled();+ expect(onClose).not.toHaveBeenCalled();+ expect(screen.getByText('acme.com')).toBeTruthy();+ await userEvent.click(screen.getByRole('button', { name: /Amount/ }));+ const input = screen.getByRole('textbox', { name: 'Edit Amount' });+ fireEvent.input(input, { target: { value: '0' } });+ fireEvent.keyDown(input, { key: 'Enter' });+ fireEvent.click(screen.getByRole('button', { name: /^Add deal/ }));+ await waitFor(() =>+ expect(onCreate).toHaveBeenCalledExactlyOnceWith(+ expect.objectContaining({+ values: { company: 'acme', stage: 'Won', amount: 0 },+ })+ )+ );+ });+it('waits for a company, then creates one row with the lane stage and every field', async () => {const { onCreate, onClose } = setup();const submit = screen.getByRole('button', { name: /^Add deal/ });diff --git a/apps/web/src/features/crm/views/add-pipeline-record.tsx b/apps/web/src/features/crm/views/add-pipeline-record.tsxindex d9255c4608..ca891aeae6 100644--- a/apps/web/src/features/crm/views/add-pipeline-record.tsx+++ b/apps/web/src/features/crm/views/add-pipeline-record.tsx@@ -45,6 +45,11 @@ import {recordChoiceProblem,recordDetail,} from '../core/pipeline-record';+import {+ missingStageFields,+ requiredStageFields,+ type StageRequirement,+} from '../core/stage-requirements';import { companyCreationError } from './create-company';import { contactCreationError } from './create-contact';import {@@ -67,6 +72,9 @@ export function AddPipelineRecordDialog(props: CellRenderers & {pipeline: Pick<Pipeline, 'name' | 'recordType'>;columns: DatabaseViewColumn[];+ requirements?: StageRequirement[];+ requirementsLoading?: boolean;+ requirementsError?: boolean;/** Values the row starts with, such as the stage of the board lane it was added in. */initialValues: Record<string, DatabaseCellValue>;onCreate: (creation: RecordCreation) => Promise<boolean>;@@ -109,7 +117,35 @@ export function AddPipelineRecordDialog(// One intent per dialog, so submitting again never adds a second row.const intentId = `pipeline-record:${createUniqueId()}`;const [choice, setChoice] = createSignal<RecordChoice>();- const [values, setValues] = createSignal(props.initialValues);+ const [draftValues, setDraftValues] = createSignal(props.initialValues);+ const [selectedOptions, setSelectedOptions] = createSignal<+ Record<string, string>+ >(+ Object.fromEntries(+ props.columns.flatMap((column) => {+ if (column.dataType !== 'SELECT_STRING' || column.isMultiSelect)+ return [];+ const option = column.options.find(+ (option) => option.label === props.initialValues[column.id]+ );+ return option ? [[column.id, option.id]] : [];+ })+ )+ );+ // Keep selections tied to option identities while schema polling renames labels.+ // Deleted columns leave the submitted row; surviving drafts retain their edits.+ const values = createMemo<Record<string, DatabaseCellValue>>(() =>+ Object.fromEntries(+ props.columns.flatMap((column) => {+ const value = draftValues()[column.id];+ if (value === undefined) return [];+ const selected = selectedOptions()[column.id];+ const option =+ selected && column.options.find((option) => option.id === selected);+ return [[column.id, option ? option.label : value]];+ })+ )+ );const [newOption, setNewOption] = createSignal<string>();const [pending, setPending] = createSignal(false);const [error, setError] = createSignal<string>();@@ -121,6 +157,8 @@ export function AddPipelineRecordDialog((column) =>column.id !== title()?.id && !column.relation && canEditCell(column));+ const required = () =>+ requiredStageFields(props.columns, props.requirements ?? [], values());const noun = company ? 'deal' : 'contact';const submitLabel = company ? 'Add deal' : 'Add contact';const existing = () => {@@ -144,7 +182,19 @@ export function AddPipelineRecordDialog(setError(undefined);};const write = (columnId: string, value: DatabaseCellValue) => {- setValues((current) => ({ ...current, [columnId]: value }));+ setDraftValues((current) => ({ ...current, [columnId]: value }));+ setSelectedOptions((current) => {+ const next = { ...current };+ const column = props.columns.find((column) => column.id === columnId);+ const option =+ column?.dataType === 'SELECT_STRING' && !column.isMultiSelect+ ? column.options.find((option) => option.label === value)+ : undefined;+ if (option) next[columnId] = option.id;+ else delete next[columnId];+ return next;+ });+ setError(undefined);return Promise.resolve(true);};@@ -204,7 +254,39 @@ export function AddPipelineRecordDialog(editing.blur();const current = choice();const titleField = title();- if (pending() || !current || !titleField) return;+ if (+ pending() ||+ props.requirementsLoading ||+ props.requirementsError ||+ !current ||+ !titleField+ )+ return;+ const deleted = props.columns.find(+ (column) =>+ column.dataType === 'SELECT_STRING' &&+ !column.isMultiSelect &&+ selectedOptions()[column.id] &&+ !column.options.some(+ (option) => option.id === selectedOptions()[column.id]+ )+ );+ if (deleted) {+ setError(+ `The selected ${deleted.name} option was deleted. Choose another value.`+ );+ return;+ }+ const missing = missingStageFields(+ required().filter((column) => column.id !== titleField.id),+ values()+ );+ if (missing.length) {+ setError(+ `Fill in ${missing.map((column) => column.name).join(', ')} for the selected stage.`+ );+ return;+ }const problem = recordChoiceProblem(current, domainCompanies());if (problem) {setError(problem);@@ -442,12 +524,26 @@ export function AddPipelineRecordDialog(<div ref={fieldList} class="flex flex-col gap-5"><Key each={fields()} by="id">{(column) => (- <StackedField column={column()}>+ <StackedField+ column={column()}+ required={required().some(+ (field) => field.id === column().id+ )}+ ><div class={FIELD_BOX}>{cell(column)}</div></StackedField>)}</Key></div>+ <Show+ when={props.requirementsLoading || props.requirementsError}+ >+ <p role="status" class="text-sm text-ink-muted">+ {props.requirementsError+ ? 'Could not load stage requirements. Reopen this form to retry.'+ : 'Loading stage requirements…'}+ </p>+ </Show><Show when={error()}>{(message) => (<p role="alert" class="text-sm text-failure">@@ -469,7 +565,12 @@ export function AddPipelineRecordDialog(<EntityComposer.Submittype="submit"hasContent={!!choice()}- disabled={!choice() || pending()}+ disabled={+ !choice() ||+ pending() ||+ props.requirementsLoading ||+ props.requirementsError+ }>{pending() ? 'Adding…' : submitLabel}</EntityComposer.Submit>@@ -488,6 +589,7 @@ const FIELD_BOX =/** A field with its label stacked above the input. */function StackedField(props: {column: DatabaseViewColumn | undefined;+ required?: boolean;children: JSX.Element;}) {return (@@ -501,6 +603,9 @@ function StackedField(props: {entityType={column().specificEntityType}/><span class="truncate">{column().name}</span>+ <Show when={props.required}>+ <span class="text-accent">Required</span>+ </Show></div>)}</Show>diff --git a/apps/web/src/features/crm/views/import-companies.tsx b/apps/web/src/features/crm/views/import-companies.tsxindex d661b5ae21..050036776e 100644--- a/apps/web/src/features/crm/views/import-companies.tsx+++ b/apps/web/src/features/crm/views/import-companies.tsx@@ -2,6 +2,7 @@ import { fireAndForget } from '@core/util/fireAndForget';import UploadIcon from '@icon/system/regular/upload-simple.svg';import { Button, Dialog, Panel, Select } from '@ui';import { createSignal, For, Show } from 'solid-js';+import { PipelineImportFailures } from '../components/pipeline-import-failures';import type { CompanyImportPipelines } from '../context/pipelines';import {createCompanyImport,@@ -213,6 +214,10 @@ export function CrmImport(props: {</p>)}</Show>+ <PipelineImportFailures+ addLabel="Add deal"+ failures={pipeline()?.invalid}+ /><Show when={error()}><p role="alert" class="text-sm text-failure">{error()}diff --git a/apps/web/src/features/crm/views/pipeline-import.tsx b/apps/web/src/features/crm/views/pipeline-import.tsxindex 55a0a285c3..01c7521b02 100644--- a/apps/web/src/features/crm/views/pipeline-import.tsx+++ b/apps/web/src/features/crm/views/pipeline-import.tsx@@ -1,6 +1,7 @@import { fireAndForget } from '@core/util/fireAndForget';import { Button, Dialog, Panel } from '@ui';import { Show } from 'solid-js';+import { PipelineImportFailures } from '../components/pipeline-import-failures';import type { PipelineTransfer } from '../context/pipelines';import type { Pipeline } from '../core/pipeline';import { pipelineRecordHeaders } from '../core/pipeline-csv';@@ -92,6 +93,14 @@ export function PipelineImport(props: {</p>)}</Show>+ <PipelineImportFailures+ addLabel={+ props.pipeline.recordType === 'company'+ ? 'Add deal'+ : 'Add contact'+ }+ failures={result()?.invalid}+ /><Show when={error()}><p role="alert" class="text-sm text-failure">{error()}diff --git a/apps/web/src/features/database/README.md b/apps/web/src/features/database/README.mdindex 63fb907ee6..3307d909e7 100644--- a/apps/web/src/features/database/README.md+++ b/apps/web/src/features/database/README.md@@ -53,10 +53,16 @@ to the host's API/service; UI capabilities only determine which controls appear.## Host capabilities+`onComposeRecord` lets a host collect required fields for board and timeline+creation. It receives the selected lane/group and date-range values before any+row is written; hosts without a composer retain direct row creation.+`editRows` and `editColumns` enable their respective controls. Optional record-viewprops supply persisted board positions, conversion previews, relationships,presence, and stored-view changes. Omit an unsupported action. A board can renderwithout a position writer; it cannot offer card moves that pretend to persist.+Pending card moves use the board overlay; update saved positions only after a+successful response so refusals preserve the prior order and other pending moves.Hosts load saved positions for the selected view before enabling moves and keepthe position cache scoped to that view. Hosts that switch boards supply a stable`BoardPositions.viewId` so pending visual moves and sort prompts retire when thediff --git a/apps/web/src/features/database/views/database-board-pending-moves.test.tsx b/apps/web/src/features/database/views/database-board-pending-moves.test.tsxnew file mode 100644index 0000000000..f09995b219--- /dev/null+++ b/apps/web/src/features/database/views/database-board-pending-moves.test.tsx@@ -0,0 +1,295 @@+import '../tests/board-layout';+import type { CardPosition } from '@service-storage/generated/schemas/cardPosition';+import type { DatabaseView } from '@service-storage/generated/schemas/databaseView';+import {+ cleanup,+ fireEvent,+ render,+ screen,+ waitFor,+} from '@solidjs/testing-library';+import { err, ok, okAsync, type Result, ResultAsync } from 'neverthrow';+import { createSignal } from 'solid-js';+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';+import type {+ Board,+ Catalog,+ Outcome,+} from '../../../lib/core/database-sql/generated/types';+import type { CardMoved } from '../core/view-state';+import type { DatabaseOpFailure } from '../core/write-failure';+import { DatabaseBoardView } from './database-board-view';++const engine = vi.hoisted(() => ({+ board:+ vi.fn<+ (+ catalog: Catalog,+ view: DatabaseView,+ outcome: Outcome,+ positions: CardPosition[]+ ) => Board+ >(),+ keyBetween: vi.fn<(before: string | null, after: string | null) => string>(),+}));+const toastFailure = vi.hoisted(() => vi.fn());+const loadEngine = vi.hoisted(() =>+ vi.fn(async () => ({+ board: engine.board,+ keyBetween: engine.keyBetween,+ }))+);++vi.mock('../../../lib/core/database-sql/wasm-module', () => ({+ loadDatabaseSqlWasm: loadEngine,+}));+vi.mock('../../../lib/core/component/Toast/Toast', () => ({+ toast: { failure: toastFailure },+}));++// Lanes sit side by side, Done at 0 and To do at 300; each lane's cards stack+// from y = 60, 100 apart and 80 tall.+beforeEach(() => {+ vi.spyOn(window, 'scrollTo').mockImplementation(() => {});+ vi.spyOn(HTMLElement.prototype, 'getBoundingClientRect').mockImplementation(+ function (this: HTMLElement) {+ if (this.hasAttribute('data-kanban-board-viewport'))+ return new DOMRect(0, 0, 880, 500);+ const lane = this.closest('[data-kanban-lane]');+ const x = lane?.getAttribute('aria-label') === 'To do lane' ? 300 : 0;+ const card = this.hasAttribute('data-kanban-card-layout')+ ? this.querySelector('[data-kanban-card]')+ : this;+ const cardIndex = lane+ ? Array.from(lane.querySelectorAll('[data-kanban-card]')).indexOf(card!)+ : 0;+ return this.hasAttribute('data-row-id') ||+ this.hasAttribute('data-kanban-card-layout')+ ? new DOMRect(x + 8, 60 + Math.max(0, cardIndex) * 100, 264, 80)+ : new DOMRect(x, 0, 280, 500);+ }+ );+});+afterEach(() => {+ cleanup();+ vi.restoreAllMocks();+ engine.board.mockReset();+ engine.keyBetween.mockReset();+ toastFailure.mockReset();+});++// Reads the lane by its label: a closing dialog still hides the board from role queries.+const cardsIn = (lane: string) =>+ Array.from(+ document.querySelectorAll(+ `[data-kanban-lane][aria-label="${lane} lane"] [data-row-id]`+ ),+ (card) => card.getAttribute('data-row-id')+ );++describe('pending board moves', () => {+ it.each([true, false])(+ 'preserves saved order when a move is refused and the later move succeeds=%s',+ async (laterSucceeds) => {+ const view: DatabaseView = {+ id: 'view',+ databaseId: 'database',+ tableId: 'table',+ name: 'Board',+ position: 'a0',+ query: { filter: null, sort: [] },+ layout: {+ kind: 'board',+ title: 'name',+ groupBy: 'stage',+ lanes: [],+ cardFields: [],+ hideEmptyLanes: false,+ },+ createdAt: '2026-09-01T00:00:00Z',+ updatedAt: '2026-09-01T00:00:00Z',+ };+ const outcome: Outcome = {+ columns: [],+ rows: [],+ rowIds: ['first', 'moving'],+ readTables: ['table'],+ truncated: false,+ insertedRowIds: [],+ changesApplied: 0,+ };+ engine.board.mockReturnValue({+ lanes: [+ {+ key: { kind: 'option', id: 'done' },+ hidden: false,+ cards: ['first'],+ },+ {+ key: { kind: 'option', id: 'todo' },+ hidden: false,+ cards: ['moving'],+ },+ ],+ });+ engine.keyBetween.mockReturnValue('a1');+ const [positions, setPositions] = createSignal<CardPosition[]>([+ { row: 'first', lane: { kind: 'option', id: 'done' }, position: 'a0' },+ { row: 'moving', lane: { kind: 'option', id: 'todo' }, position: 'a2' },+ ]);+ const replies: ((reply: Result<CardMoved, DatabaseOpFailure>) => void)[] =+ [];+ const move = vi.fn(+ () =>+ new ResultAsync<CardMoved, DatabaseOpFailure>(+ new Promise((resolve) => replies.push(resolve))+ )+ );+ render(() => (+ <DatabaseBoardView+ view={view}+ source={{+ columns: () => [],+ snapshot: () => undefined,+ read: () => ({ outcome, catalog: { tables: [] }, view }),+ loading: () => false,+ refreshing: () => false,+ error: () => undefined,+ refresh: () => okAsync(undefined),+ write: () => okAsync({ insertedRowIds: [], version: undefined }),+ addOption: () => okAsync(undefined),+ retain: () => {},+ }}+ rows={[+ { rowId: 'first', cells: { name: 'First card', stage: 'Done' } },+ { rowId: 'moving', cells: { name: 'Moving card', stage: 'To do' } },+ ]}+ columns={[+ {+ id: 'name',+ name: 'Name',+ dataType: 'STRING',+ isMultiSelect: false,+ options: [],+ writable: true,+ },+ {+ id: 'stage',+ name: 'Stage',+ dataType: 'SELECT_STRING',+ isMultiSelect: false,+ options: [+ { id: 'done', label: 'Done', color: null },+ { id: 'todo', label: 'To do', color: null },+ ],+ writable: true,+ },+ ]}+ positions={{+ state: () => ({ kind: 'ready', positions: positions() }),+ setPositions,+ move,+ }}+ canEdit+ onViewChange={vi.fn()}+ rowPending={() => false}+ createPending={() => false}+ createComplete={() => false}+ onOpen={vi.fn()}+ onCreate={vi.fn(async () => true)}+ />+ ));+ const trigger = await screen.findByRole('button', {+ name: 'Move Moving card',+ });+ trigger.focus();+ fireEvent.keyDown(trigger, { key: 'Enter' });+ fireEvent.keyDown(await screen.findByRole('menuitem', { name: 'Done' }), {+ key: 'Enter',+ });+ await waitFor(() =>+ expect(move).toHaveBeenCalledWith({+ row: 'moving',+ lane: { kind: 'option', id: 'done' },+ before: 'first',+ after: null,+ })+ );+ expect(positions()).toEqual([+ { row: 'first', lane: { kind: 'option', id: 'done' }, position: 'a0' },+ { row: 'moving', lane: { kind: 'option', id: 'todo' }, position: 'a2' },+ ]);+ expect(cardsIn('Done')).toEqual(['first', 'moving']);+ const nextTrigger = screen.getByRole('button', {+ name: 'Move First card',+ });+ nextTrigger.focus();+ fireEvent.keyDown(nextTrigger, { key: 'Enter' });+ fireEvent.keyDown(+ await screen.findByRole('menuitem', { name: 'To do' }),+ {+ key: 'Enter',+ }+ );+ await waitFor(() => expect(move).toHaveBeenCalledTimes(2));+ expect(cardsIn('Done')).toEqual(['moving']);+ expect(cardsIn('To do')).toEqual(['first']);++ replies[0](err({ kind: 'unexpected-result' }));+ await waitFor(() => expect(toastFailure).toHaveBeenCalledTimes(1));+ expect(cardsIn('Done')).toEqual([]);+ expect(cardsIn('To do')).toEqual(['moving', 'first']);+ expect(positions()).toEqual([+ { row: 'first', lane: { kind: 'option', id: 'done' }, position: 'a0' },+ { row: 'moving', lane: { kind: 'option', id: 'todo' }, position: 'a2' },+ ]);++ if (laterSucceeds) {+ replies[1](+ ok({+ positions: [+ {+ row: 'first',+ lane: { kind: 'option', id: 'todo' },+ position: 'a3',+ },+ ],+ tableVersion: 8,+ })+ );+ await waitFor(() =>+ expect(positions()).toEqual([+ {+ row: 'moving',+ lane: { kind: 'option', id: 'todo' },+ position: 'a2',+ },+ {+ row: 'first',+ lane: { kind: 'option', id: 'todo' },+ position: 'a3',+ },+ ])+ );+ expect(cardsIn('To do')).toEqual(['moving', 'first']);+ } else {+ replies[1](err({ kind: 'unexpected-result' }));+ await waitFor(() => expect(toastFailure).toHaveBeenCalledTimes(2));+ expect(cardsIn('To do')).toEqual(['moving']);+ expect(cardsIn('Done')).toEqual(['first']);+ expect(positions()).toEqual([+ {+ row: 'first',+ lane: { kind: 'option', id: 'done' },+ position: 'a0',+ },+ {+ row: 'moving',+ lane: { kind: 'option', id: 'todo' },+ position: 'a2',+ },+ ]);+ }+ }+ );+});diff --git a/apps/web/src/features/database/views/database-board-view.test.tsx b/apps/web/src/features/database/views/database-board-view.test.tsxindex acb4b89a33..ad0941d846 100644--- a/apps/web/src/features/database/views/database-board-view.test.tsx+++ b/apps/web/src/features/database/views/database-board-view.test.tsx@@ -9,7 +9,7 @@ import {waitFor,within,} from '@solidjs/testing-library';-import { errAsync, ok, okAsync, ResultAsync } from 'neverthrow';+import { ok, okAsync, ResultAsync } from 'neverthrow';import { createSignal } from 'solid-js';import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';import type {@@ -224,11 +224,10 @@ describe('database board view', () => {before: 'first',after: 'last',});- expect(engine.keyBetween).toHaveBeenCalledWith('a0', 'a1');expect(positions()).toEqual([{ row: 'first', lane: { kind: 'option', id: 'done' }, position: 'a0' },{ row: 'last', lane: { kind: 'option', id: 'done' }, position: 'a1' },- { row: 'moving', lane: { kind: 'option', id: 'done' }, position: 'a0V' },+ { row: 'moving', lane: { kind: 'option', id: 'todo' }, position: 'a0' },]);expect(cardsIn('Done')).toEqual(['first', 'moving', 'last']);expect(cardsIn('To do')).toEqual([]);@@ -430,136 +429,6 @@ describe('database board view', () => {expect(cardsIn('To do')).toEqual([]);});- it('puts a card back where it was when the move is refused', async () => {- const view: DatabaseView = {- id: 'view',- databaseId: 'database',- tableId: 'table',- name: 'Board',- position: 'a0',- query: { filter: null, sort: [] },- layout: {- kind: 'board',- title: 'name',- groupBy: 'stage',- lanes: [],- cardFields: [],- hideEmptyLanes: false,- },- createdAt: '2026-09-01T00:00:00Z',- updatedAt: '2026-09-01T00:00:00Z',- };- const outcome: Outcome = {- columns: [],- rows: [],- rowIds: ['first', 'moving'],- readTables: ['table'],- truncated: false,- insertedRowIds: [],- changesApplied: 0,- };- engine.board.mockReturnValue({- lanes: [- {- key: { kind: 'option', id: 'done' },- hidden: false,- cards: ['first'],- },- {- key: { kind: 'option', id: 'todo' },- hidden: false,- cards: ['moving'],- },- ],- });- engine.keyBetween.mockReturnValue('a1');- const [positions, setPositions] = createSignal<CardPosition[]>([- { row: 'first', lane: { kind: 'option', id: 'done' }, position: 'a0' },- ]);- const move = vi.fn(() =>- errAsync<CardMoved, DatabaseOpFailure>({- kind: 'unexpected-result',- })- );- render(() => (- <DatabaseBoardView- view={view}- source={{- columns: () => [],- snapshot: () => undefined,- read: () => ({ outcome, catalog: { tables: [] }, view }),- loading: () => false,- refreshing: () => false,- error: () => undefined,- refresh: () => okAsync(undefined),- write: () => okAsync({ insertedRowIds: [], version: undefined }),- addOption: () => okAsync(undefined),- retain: () => {},- }}- rows={[- { rowId: 'first', cells: { name: 'First card', stage: 'Done' } },- { rowId: 'moving', cells: { name: 'Moving card', stage: 'To do' } },- ]}- columns={[- {- id: 'name',- name: 'Name',- dataType: 'STRING',- isMultiSelect: false,- options: [],- writable: true,- },- {- id: 'stage',- name: 'Stage',- dataType: 'SELECT_STRING',- isMultiSelect: false,- options: [- { id: 'done', label: 'Done', color: null },- { id: 'todo', label: 'To do', color: null },- ],- writable: true,- },- ]}- positions={{- state: () => ({ kind: 'ready', positions: positions() }),- setPositions,- move,- }}- canEdit- onViewChange={vi.fn()}- rowPending={() => false}- createPending={() => false}- createComplete={() => false}- onOpen={vi.fn()}- onCreate={vi.fn(async () => true)}- />- ));- const trigger = await screen.findByRole('button', {- name: 'Move Moving card',- });- trigger.focus();- fireEvent.keyDown(trigger, { key: 'Enter' });- fireEvent.keyDown(await screen.findByRole('menuitem', { name: 'Done' }), {- key: 'Enter',- });- await waitFor(() =>- expect(move).toHaveBeenCalledWith({- row: 'moving',- lane: { kind: 'option', id: 'done' },- before: 'first',- after: null,- })- );- await waitFor(() =>- expect(toastFailure).toHaveBeenCalledWith(- 'The database answered the change with something else.'- )- );- expect(cardsIn('To do')).toEqual(['moving']);- expect(cardsIn('Done')).toEqual(['first']);- });-it('asks to remove the sort before moving a card, then clears the sort and moves it', async () => {const view: DatabaseView = {id: 'view',diff --git a/apps/web/src/features/database/views/database-board-view.tsx b/apps/web/src/features/database/views/database-board-view.tsxindex 5fb88d9ef7..7aed27cede 100644--- a/apps/web/src/features/database/views/database-board-view.tsx+++ b/apps/web/src/features/database/views/database-board-view.tsx@@ -1,3 +1,4 @@+import { fireAndForget } from '@core/util/fireAndForget';import type { DatabaseOpsError } from '@service-storage/databases';import type { CardPosition } from '@service-storage/generated/schemas/cardPosition';import type { ViewLayout } from '@service-storage/generated/schemas/viewLayout';@@ -31,8 +32,6 @@ import {type CardMove,cardMove,cardsOf,- laneCards,- placeCard,withMovedCards,withPositions,} from '../core/board-moves';@@ -240,31 +239,23 @@ function GroupedBoard(function write(move: CardMove) {const persist = props.positions.move;if (!persist) return;- // Both capabilities belong to the view where the move started.+ // Capture the setter for the view where this move started.const setPositions = props.positions.setPositions;- const ready = state();- const shown = board();- // A move the shown lane has no place for writes no early places; the server's answer settles them.- const placed =- ready.kind === 'ready' && shown- ? placeCard(- laneCards(shown, ready.positions, move.lane, move.row),- move,- ready.engine.keyBetween- )- : undefined;- if (placed?.isOk())- setPositions?.((current) => withPositions(current, placed.value));+ // Pending moves supply visual optimism; saved positions change only on success.+ // A refusal then reveals the original order without overwriting a later move.setMoves((current) => [...current, { move }]);- void persist(move)- .map(({ positions, tableVersion }) => {- setPositions?.((current) => withPositions(current, positions));- taken(move, tableVersion);- })- .mapErr((failure) => {- forget(move);- toast.failure(databaseOpMessage(failure, 'this card'));- });+ fireAndForget(+ persist(move)+ .map(({ positions, tableVersion }) => {+ setPositions?.((current) => withPositions(current, positions));+ taken(move, tableVersion);+ })+ .mapErr((failure) => {+ forget(move);+ toast.failure(databaseOpMessage(failure, 'this card'));+ }),+ 'database'+ );}function drop(row: string, lane: LaneKey, next?: string) {const shown = board();diff --git a/apps/web/src/features/database/views/database-records-view.tsx b/apps/web/src/features/database/views/database-records-view.tsxindex ade2b33f42..6dac641492 100644--- a/apps/web/src/features/database/views/database-records-view.tsx+++ b/apps/web/src/features/database/views/database-records-view.tsx@@ -573,6 +573,7 @@ export function DatabaseRecordsView(props: DatabaseRecordsViewProps) {onOpen={records.open}onCreate={records.createRow}onWrite={writeRowCell}+ onCompose={props.onComposeRecord}onDuplicate={records.duplicateRow}onRequestDelete={records.requestDelete}renderMentionValue={props.renderMentionValue}diff --git a/apps/web/src/features/database/views/database-timeline-view.test.tsx b/apps/web/src/features/database/views/database-timeline-view.test.tsxindex 2536f6e84a..7fcd27e0d5 100644--- a/apps/web/src/features/database/views/database-timeline-view.test.tsx+++ b/apps/web/src/features/database/views/database-timeline-view.test.tsx@@ -93,6 +93,56 @@ afterEach(() => {vi.restoreAllMocks();});+it.each([true, false])(+ 'keeps the timeline range and stage when creating with a host composer: %s',+ async (composed) => {+ const onCompose = vi.fn();+ const onCreate = vi.fn(async () => true);+ const { container } = render(() => (+ <DatabaseTimelineView+ view={{+ query: { filter: null, sort: [] },+ layout: {+ kind: 'timeline',+ range: 'dates',+ title: 'name',+ groupBy: 'stage',+ colorBy: null,+ },+ }}+ rows={rows}+ columns={[name, dates, stage]}+ canEdit+ filtered={false}+ rowPending={() => false}+ onOpen={() => {}}+ onCreate={onCreate}+ onCompose={composed ? onCompose : undefined}+ onWrite={async () => true}+ />+ ));+ const group = container.querySelector<HTMLElement>(+ '[data-timeline-group="option:build"]'+ );+ expect(group).not.toBeNull();+ fireEvent.contextMenu(group!, { clientX: 800, clientY: 200 });+ await selectMenu('New record here');+ const values = {+ dates: expect.stringMatching(/^\d{4}-.*Z\/\d{4}-.*Z$/),+ stage: 'Build',+ };+ if (composed) {+ await waitFor(() => expect(onCompose).toHaveBeenCalledWith(values));+ expect(onCreate).not.toHaveBeenCalled();+ } else {+ await waitFor(() =>+ expect(onCreate).toHaveBeenCalledWith({ values, open: true })+ );+ expect(onCompose).not.toHaveBeenCalled();+ }+ }+);+it('draws a bar for each dated record and a chip for each undated one, opening either, with the drawer closed', () => {const onOpen = vi.fn();render(() => (diff --git a/apps/web/src/features/database/views/database-timeline-view.tsx b/apps/web/src/features/database/views/database-timeline-view.tsxindex 6034d6fc4d..d65cac7b57 100644--- a/apps/web/src/features/database/views/database-timeline-view.tsx+++ b/apps/web/src/features/database/views/database-timeline-view.tsx@@ -77,6 +77,8 @@ type DatabaseTimelineViewProps = {rowPending: (rowId: string) => boolean;onOpen: (rowId: string) => void;onCreate: (creation: RecordCreation) => Promise<boolean>;+ /** Lets the host gather required fields before creating a record. */+ onCompose?: (values: Record<string, DatabaseCellValue>) => void;/** Writes one cell of a saved record; resolves whether it was saved. */onWrite: (rowId: string,@@ -230,16 +232,17 @@ function TimelineChart(}const writeRange = (rowId: string, value: DatabaseCellValue) =>props.onWrite(rowId, props.rangeColumn.id, value);+ const createRecord = (values: Record<string, DatabaseCellValue>) => {+ if (props.onCompose) {+ props.onCompose(values);+ return;+ }+ fireAndForget(props.onCreate({ values, open: true }), 'database');+ };const create = () =>canSchedule()? (range: GanttCreation) =>- fireAndForget(- props.onCreate({- values: { [props.rangeColumn.id]: toCellTimeRange(range) },- open: true,- }),- 'database'- )+ createRecord({ [props.rangeColumn.id]: toCellTimeRange(range) }): undefined;/** A new record at a chart position, in the group whose row it was asked from. */function createAt(position: number, timed: boolean, group: string) {@@ -247,20 +250,14 @@ function TimelineChart(const lane = group ? groupOf(group)?.lane : undefined;const groupValue =column?.writable && lane ? laneValue(column, lane) : undefined;- fireAndForget(- props.onCreate({- values: {- [props.rangeColumn.id]: toCellTimeRange(- ganttPlacedRange(position, timed)- ),- ...(column && groupValue !== undefined- ? { [column.id]: groupValue }- : {}),- },- open: true,- }),- 'database'- );+ createRecord({+ [props.rangeColumn.id]: toCellTimeRange(+ ganttPlacedRange(position, timed)+ ),+ ...(column && groupValue !== undefined+ ? { [column.id]: groupValue }+ : {}),+ });}/** Focus a record's bar or chip again, as after its menu or an editor closes. */function focusRecord(rowId: string) {diff --git a/apps/web/src/lib/i18n/locales/en.ts b/apps/web/src/lib/i18n/locales/en.tsindex 78342b6509..eb4485215e 100644--- a/apps/web/src/lib/i18n/locales/en.ts+++ b/apps/web/src/lib/i18n/locales/en.ts@@ -8,6 +8,7 @@ import commandMenu from './en/command-menu';import commands from './en/commands';import common from './en/common';import create from './en/create';+import crm from './en/crm';import entityActions from './en/entity-actions';import localRuntime from './en/local-runtime';import mobile from './en/mobile';@@ -34,6 +35,7 @@ export default {commands,common,create,+ crm,entityActions,localRuntime,mobile,diff --git a/apps/web/src/lib/i18n/locales/en/crm.ts b/apps/web/src/lib/i18n/locales/en/crm.tsnew file mode 100644index 0000000000..1afff1658f--- /dev/null+++ b/apps/web/src/lib/i18n/locales/en/crm.ts@@ -0,0 +1,16 @@+export default {+ stageRequirements: 'Stage requirements',+ stageRequirementsDescription:+ 'Choose fields that must be filled before a deal enters a stage.',+ stageField: 'Stage field',+ chooseStageField: 'Choose stage field',+ requiredStage: 'Required stage',+ chooseStage: 'Choose stage',+ stageOptionRequired: 'Add a stage option to a single-select field first.',+ stageRequirementsLifecycle:+ 'Renaming keeps requirements. Deleting a stage or field removes its requirements. Existing deals stay in their stage.',+ stageRequirementsSaveFailed:+ 'Could not save requirements. Your selections are kept; try again.',+ savingRequirements: 'Saving…',+ saveRequirements: 'Save requirements',+};diff --git a/apps/web/src/lib/service-clients/service-storage/client.ts b/apps/web/src/lib/service-clients/service-storage/client.tsindex 5014119292..a196ccfc48 100644--- a/apps/web/src/lib/service-clients/service-storage/client.ts+++ b/apps/web/src/lib/service-clients/service-storage/client.ts@@ -171,6 +171,7 @@ import type { SlackCreateRequest } from './generated/schemas/slackCreateRequest'import type { SlackRegisterRequest } from './generated/schemas/slackRegisterRequest';import type { SmartTagPreview } from './generated/schemas/smartTagPreview';import type { SoupPage } from './generated/schemas/soupPage';+import type { StageRequirement } from './generated/schemas/stageRequirement';import type { StorageRows } from './generated/schemas/storageRows';import type { StorageRowsQuery } from './generated/schemas/storageRowsQuery';import type { StoredGithubPullRequest } from './generated/schemas/storedGithubPullRequest';@@ -438,6 +439,15 @@ export const storageServiceClient = {dssFetch<PipelineResponse[]>('/crm/pipelines', { method: 'GET' }),getCrmPipeline: (id: string) =>dssFetch<PipelineResponse>(`/crm/pipelines/${id}`, { method: 'GET' }),+ getCrmPipelineStageRequirements: (id: string) =>+ dssFetch<StageRequirement[]>(`/crm/pipelines/${id}/stage-requirements`, {+ method: 'GET',+ }),+ setCrmPipelineStageRequirement: (id: string, rule: StageRequirement) =>+ dssFetch(`/crm/pipelines/${id}/stage-requirements`, {+ method: 'PUT',+ body: JSON.stringify(rule),+ }),getCrmPipelineTable: (id: string) =>dssFetch<TableDetail>(`/crm/pipelines/${id}/table`, { method: 'GET' }),getCrmPipelineViewPositions: (id: string, viewId: string) =>diff --git a/apps/web/src/lib/service-clients/service-storage/generated/schemas/index.ts b/apps/web/src/lib/service-clients/service-storage/generated/schemas/index.tsindex da4a9e1c92..5d57f0102d 100644--- a/apps/web/src/lib/service-clients/service-storage/generated/schemas/index.ts+++ b/apps/web/src/lib/service-clients/service-storage/generated/schemas/index.ts@@ -2099,6 +2099,7 @@ export * from './sqlStatementOneOfSeven';export * from './sqlStatementOneOfSevenKind';export * from './sqlStatementOneOfThree';export * from './sqlStatementOneOfThreeKind';+export * from './stageRequirement';export * from './starterDatabase';export * from './starterDatabaseDatabaseId';export * from './starterDatabaseTableId';diff --git a/apps/web/src/lib/service-clients/service-storage/generated/schemas/stageRequirement.ts b/apps/web/src/lib/service-clients/service-storage/generated/schemas/stageRequirement.tsnew file mode 100644index 0000000000..096aa641ab--- /dev/null+++ b/apps/web/src/lib/service-clients/service-storage/generated/schemas/stageRequirement.ts@@ -0,0 +1,18 @@+/**+ * Generated by orval v7.21.0 🍺+ * Do not edit manually.+ * document_storage_service+ * OpenAPI spec version: 0.1.0+ */++/**+ * Fields required when a deal enters a particular option of a stage column.+ */+export interface StageRequirement {+ /** Fields that must be present. Empty removes the rule for this stage. */+ requiredColumnIds: string[];+ /** Single-select column identifying the stage, independent of its name. */+ stageColumnId: string;+ /** Stable option identity; renaming the stage preserves the rule. */+ stageId: string;+}diff --git a/apps/web/src/lib/service-clients/service-storage/generated/zod.ts b/apps/web/src/lib/service-clients/service-storage/generated/zod.tsindex 3670e3c79c..f837237359 100644--- a/apps/web/src/lib/service-clients/service-storage/generated/zod.ts+++ b/apps/web/src/lib/service-clients/service-storage/generated/zod.ts@@ -9541,6 +9541,67 @@ export const shareCrmPipelineBody = zod}).describe('Sharing input.');+/**+ * @summary Read requirements by stable stage and field identities.+ */+export const getCrmPipelineStageRequirementsParams = zod.object({+ id: zod.uuid(),+});++export const getCrmPipelineStageRequirementsResponseItem = zod+ .object({+ requiredColumnIds: zod+ .array(zod.uuid())+ .describe(+ 'Fields that must be present. Empty removes the rule for this stage.'+ ),+ stageColumnId: zod+ .uuid()+ .describe(+ 'Single-select column identifying the stage, independent of its name.'+ ),+ stageId: zod+ .uuid()+ .describe(+ 'Stable option identity; renaming the stage preserves the rule.'+ ),+ })+ .describe(+ 'Fields required when a deal enters a particular option of a stage column.'+ );+export const getCrmPipelineStageRequirementsResponse = zod.array(+ getCrmPipelineStageRequirementsResponseItem+);++/**+ * @summary Replace the required fields for one stage. An empty list removes its rule.+ */+export const setCrmPipelineStageRequirementParams = zod.object({+ id: zod.uuid(),+});++export const setCrmPipelineStageRequirementBody = zod+ .object({+ requiredColumnIds: zod+ .array(zod.uuid())+ .describe(+ 'Fields that must be present. Empty removes the rule for this stage.'+ ),+ stageColumnId: zod+ .uuid()+ .describe(+ 'Single-select column identifying the stage, independent of its name.'+ ),+ stageId: zod+ .uuid()+ .describe(+ 'Stable option identity; renaming the stage preserves the rule.'+ ),+ })+ .describe(+ 'Fields required when a deal enters a particular option of a stage column.'+ );+/*** @summary Read the host-owned table schema.*/diff --git a/apps/web/src/lib/service-clients/service-storage/openapi.json b/apps/web/src/lib/service-clients/service-storage/openapi.jsonindex 8e4e1b83d0..8a8b5f6f85 100644--- a/apps/web/src/lib/service-clients/service-storage/openapi.json+++ b/apps/web/src/lib/service-clients/service-storage/openapi.json@@ -7052,6 +7052,70 @@}}},+ "/crm/pipelines/{id}/stage-requirements": {+ "get": {+ "tags": ["crm::inbound::pipelines"],+ "summary": "Read requirements by stable stage and field identities.",+ "operationId": "get_crm_pipeline_stage_requirements",+ "parameters": [+ {+ "name": "id",+ "in": "path",+ "required": true,+ "schema": {+ "type": "string",+ "format": "uuid"+ }+ }+ ],+ "responses": {+ "200": {+ "description": "",+ "content": {+ "application/json": {+ "schema": {+ "type": "array",+ "items": {+ "$ref": "#/components/schemas/StageRequirement"+ }+ }+ }+ }+ }+ }+ },+ "put": {+ "tags": ["crm::inbound::pipelines"],+ "summary": "Replace the required fields for one stage. An empty list removes its rule.",+ "operationId": "set_crm_pipeline_stage_requirement",+ "parameters": [+ {+ "name": "id",+ "in": "path",+ "required": true,+ "schema": {+ "type": "string",+ "format": "uuid"+ }+ }+ ],+ "requestBody": {+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/StageRequirement"+ }+ }+ },+ "required": true+ },+ "responses": {+ "204": {+ "description": ""+ }+ }+ }+ },"/crm/pipelines/{id}/table": {"get": {"tags": ["crm::inbound::pipelines"],@@ -43576,6 +43640,32 @@],"description": "The statement that ran: a read, or the table (and for a type change, the\ncolumn) it wrote."},+ "StageRequirement": {+ "type": "object",+ "description": "Fields required when a deal enters a particular option of a stage column.",+ "required": ["stageColumnId", "stageId", "requiredColumnIds"],+ "properties": {+ "requiredColumnIds": {+ "type": "array",+ "items": {+ "type": "string",+ "format": "uuid"+ },+ "description": "Fields that must be present. Empty removes the rule for this stage."+ },+ "stageColumnId": {+ "type": "string",+ "format": "uuid",+ "description": "Single-select column identifying the stage, independent of its name."+ },+ "stageId": {+ "type": "string",+ "format": "uuid",+ "description": "Stable option identity; renaming the stage preserves the rule."+ }+ },+ "additionalProperties": false+ },"StarterDatabase": {"type": "object","description": "Starter result. A missing database means the user already started or removed it.",diff --git a/crates/complete_graph/src/schema/test/crm_record.rs b/crates/complete_graph/src/schema/test/crm_record.rsindex caa327d08e..f1ae5df728 100644--- a/crates/complete_graph/src/schema/test/crm_record.rs+++ b/crates/complete_graph/src/schema/test/crm_record.rs@@ -18,6 +18,19 @@ struct RecordingPipelines {}impl PipelineService for RecordingPipelines {+ async fn stage_requirements(+ &self,+ _: EntityAccessReceipt<ViewAccessLevel>,+ ) -> Result<Vec<requirements::StageRequirement>, PipelineError> {+ unimplemented!()+ }+ async fn set_stage_requirement(+ &self,+ _: EntityAccessReceipt<EditAccessLevel>,+ _: requirements::StageRequirement,+ ) -> Result<(), PipelineError> {+ unimplemented!()+ }async fn view_positions(&self,_: EntityAccessReceipt<ViewAccessLevel>,diff --git a/crates/crm/AGENTS.md b/crates/crm/AGENTS.mdindex 6cc27f4ec2..325a017f94 100644--- a/crates/crm/AGENTS.md+++ b/crates/crm/AGENTS.md@@ -9,6 +9,9 @@ tools/HTTP/GraphQL surfaces over them.## Start here- `src/domain/service.rs`, `src/domain/pipelines.rs`: core use cases.+- `src/domain/pipelines/requirements.rs`: stage-entry rules keyed by column and+ option IDs. `apply_ops` validates every pipeline write under the pipeline write+ guard; agent/CSV workflows use the same service. Deletions cascade rules.- `src/domain/pipeline_workflows/`: pipeline entry/field/record ops built onthe shared `databases` engine (Sales pipelines are a `databases` consumer).- `src/domain/crm_csv.rs`, `src/domain/crm_transfer.rs`: CSV import/export for@@ -79,6 +82,8 @@ tools/HTTP/GraphQL surfaces over them.- Keep CRM write locks ordered: domain advisory locks, parent team `KEY SHARE`,settings `SHARE`, then company/contact rows. Hold them through commit sodisable/purge and team deletion cannot race creation.+- Bound pipeline read- and write-guard waits with a transaction-local five-second+ timeout so waiters release pool connections needed by the holder's storage work.- When depopulating an email, prefer its domain-linked contact over a manualunfiled record so mailbox-source teardown reaches the synced contact.- Serialize domain visibility updates on the owning company row before readingdiff --git a/crates/crm/src/domain/pipeline_workflows.rs b/crates/crm/src/domain/pipeline_workflows.rsindex 0fc06aa817..c65b0f7149 100644--- a/crates/crm/src/domain/pipeline_workflows.rs+++ b/crates/crm/src/domain/pipeline_workflows.rs@@ -300,7 +300,16 @@ wherelet applied = self.pipelines.apply_ops(receipt, viewer.acting_bot, batch)- .await?;+ .await+ .map_err(|error| match error {+ // Treat a refused row as a caller-correctable workflow error.+ // CSV import retries these individually and reports invalid rows+ // while still accepting the valid rows in the same batch.+ super::pipelines::PipelineError::Database(+ databases::domain::models::DatabaseError::InvalidOp(refusal),+ ) => WorkflowError::Invalid(refusal.reason),+ other => other.into(),+ })?;let version = applied.results.iter()diff --git a/crates/crm/src/domain/pipelines.rs b/crates/crm/src/domain/pipelines.rsindex 75b2fd6c58..7c725963ba 100644--- a/crates/crm/src/domain/pipelines.rs+++ b/crates/crm/src/domain/pipelines.rs@@ -1,8 +1,16 @@//! Company/contact pipelines: CRM policy over reusable database storage.+mod references;+mod sharing;+use sharing::{requested_channel_grants, share_permission};+pub mod requirements;+use references::primary_references;+#[cfg(test)]mod test;+use requirements::StageRequirement;+use super::{auth::CrmTeamReceipt, stages::StageDefinitionStore};use bot_id::BotId;use chrono::{DateTime, Utc};@@ -210,6 +218,22 @@ pub trait PipelineRepo: Send + Sync + 'static {&self,id: Uuid,) -> impl Future<Output = Result<Option<Self::Guard>, Self::Error>> + Send;+ /// Serialize policy changes and row writes for one live pipeline.+ fn lock_write(+ &self,+ id: Uuid,+ ) -> impl Future<Output = Result<Option<Self::Guard>, Self::Error>> + Send;+ /// Read stage rules, keyed by stable column and option identities.+ fn stage_requirements(+ &self,+ id: Uuid,+ ) -> impl Future<Output = Result<Vec<StageRequirement>, Self::Error>> + Send;+ /// Replace the required fields for one stage; an empty list removes its rule.+ fn set_stage_requirement(+ &self,+ id: Uuid,+ rule: &StageRequirement,+ ) -> impl Future<Output = Result<(), Self::Error>> + Send;/// Rename pipeline metadata.fn rename(&self, id: Uuid, name: &str) -> impl Future<Output = Result<(), Self::Error>> + Send;/// Update pipeline lifecycle metadata.@@ -329,6 +353,17 @@ pub trait PipelineService: Send + Sync + 'static {acting_bot: Option<BotId>,batch: OpBatch,) -> impl Future<Output = Result<AppliedOps, PipelineError>> + Send;+ /// Read the rules visible to anyone with pipeline read access.+ fn stage_requirements(+ &self,+ receipt: EntityAccessReceipt<ViewAccessLevel>,+ ) -> impl Future<Output = Result<Vec<StageRequirement>, PipelineError>> + Send;+ /// Set required fields for one stage with pipeline edit access.+ fn set_stage_requirement(+ &self,+ receipt: EntityAccessReceipt<EditAccessLevel>,+ rule: StageRequirement,+ ) -> impl Future<Output = Result<(), PipelineError>> + Send;/// Rename pipeline metadata.fn rename(&self,@@ -393,58 +428,6 @@ fn name(input: &str) -> Result<String, PipelineError> {Ok(input.to_string())}-/// Most channel grants one request may change.-const MAX_CHANNEL_GRANTS_PER_UPDATE: usize = 100;--/// The channel grants of a sharing request. Pipelines have no share link, and-/// team access changes only through [`PipelineService::share`].-fn requested_channel_grants(- request: UpdateSharePermissionRequestV2,-) -> Result<Vec<UpdateChannelSharePermission>, PipelineError> {- if request.link_share.is_some()- || request.link_share_access_level.is_some()- || request.team_share_access_level.is_some()- {- return Err(PipelineError::Invalid(- "Share a pipeline with people and channels; only its owner changes team access",- ));- }- let grants = request.channel_share_permissions.unwrap_or_default();- if grants.len() > MAX_CHANNEL_GRANTS_PER_UPDATE {- return Err(PipelineError::Invalid(- "Share with at most 100 channels at a time",- ));- }- let mut channels = std::collections::HashSet::new();- for grant in &grants {- if !channels.insert(&grant.channel_id)- || Uuid::parse_str(&grant.channel_id).is_err()- || grant.access_level == Some(AccessLevel::Owner)- || (grant.operation != UpdateOperation::Remove && grant.access_level.is_none())- {- return Err(PipelineError::Invalid(- "Give each channel once, with view, comment or edit access",- ));- }- }- Ok(grants)-}--fn share_permission(- pipeline: &Pipeline,- channels: Vec<ChannelSharePermission>,-) -> SharePermissionV2 {- SharePermissionV2 {- id: pipeline.id.to_string(),- owner: pipeline.user_id.clone(),- link_share: None,- link_share_access_level: None,- team_share_access_level: (pipeline.sharing == PipelineSharing::Team)- .then_some(AccessLevel::Edit),- channel_share_permissions: Some(channels),- }-}-impl<R: PipelineRepo, D, A, S> PipelineServiceImpl<R, D, A, S> {/// Compose the service from domain capabilities.pub fn new(repo: R, databases: Arc<D>, access: Arc<A>, stages: S) -> Self {@@ -732,6 +715,51 @@ whereOk(AccessiblePipeline { pipeline, grant })}+ async fn stage_requirements(+ &self,+ receipt: EntityAccessReceipt<ViewAccessLevel>,+ ) -> Result<Vec<StageRequirement>, PipelineError> {+ let pipeline = self.pipeline(&receipt).await?;+ let _guard = self+ .repo+ .lock_live(pipeline.id)+ .await+ .map_err(storage)?+ .ok_or(PipelineError::NotFound)?;+ self.repo+ .stage_requirements(pipeline.id)+ .await+ .map_err(storage)+ }++ #[tracing::instrument(skip_all, fields(pipeline_id = tracing::field::Empty, stage_column_id = %rule.stage_column_id, stage_id = %rule.stage_id), err)]+ async fn set_stage_requirement(+ &self,+ receipt: EntityAccessReceipt<EditAccessLevel>,+ rule: StageRequirement,+ ) -> Result<(), PipelineError> {+ let pipeline = self.pipeline(&receipt).await?;+ tracing::Span::current().record("pipeline_id", pipeline.id.to_string());+ let _guard = self+ .repo+ .lock_write(pipeline.id)+ .await+ .map_err(storage)?+ .ok_or(PipelineError::NotFound)?;+ let table = self+ .databases+ .storage_tables(pipeline.database_id)+ .await?+ .into_iter()+ .find(|table| table.table.id == pipeline.table_id)+ .ok_or(PipelineError::NotFound)?;+ requirements::validate_rule(&table, &rule)?;+ self.repo+ .set_stage_requirement(pipeline.id, &rule)+ .await+ .map_err(storage)+ }+async fn rename(&self,receipt: EntityAccessReceipt<EditAccessLevel>,@@ -926,7 +954,7 @@ where&self,receipt: EntityAccessReceipt<EditAccessLevel>,acting_bot: Option<BotId>,- batch: OpBatch,+ mut batch: OpBatch,) -> Result<AppliedOps, PipelineError> {use models_databases::{DatabaseOp, TableChange};let pipeline = self.pipeline(&receipt).await?;@@ -969,71 +997,15 @@ where}let _guard = self.repo- .lock_live(pipeline.id)+ .lock_write(pipeline.id).await.map_err(storage)?.ok_or(PipelineError::NotFound)?;+ self.validate_stage_requirements(&pipeline, &mut batch)+ .await?;Ok(self.databases.apply_storage_ops(pipeline.database_id, viewer, batch).await?)}}--/// Distinct primary records explicitly written by this batch. Other cells and-/// unchanged references do not require the editor to reselect the record.-fn primary_references(- pipeline: &Pipeline,- batch: &OpBatch,-) -> Result<std::collections::BTreeSet<Uuid>, PipelineError> {- use models_databases::{CellValue, CellWrite, DatabaseOp, RowChanges, RowsChange};- let mut references = std::collections::BTreeSet::new();- for op in &batch.ops {- let cells: Vec<&CellWrite> = match op {- DatabaseOp::Rows {- change: RowsChange::Insert { rows },- ..- } => rows.iter().flatten().collect(),- DatabaseOp::Rows {- change:- RowsChange::Update {- changes: RowChanges::Uniform { cells, .. },- },- ..- } => cells.iter().collect(),- DatabaseOp::Rows {- change:- RowsChange::Update {- changes: RowChanges::PerRow { rows },- },- ..- } => rows.iter().flat_map(|row| &row.cells).collect(),- _ => continue,- };- for cell in cells {- if cell.column != pipeline.primary_column_id {- continue;- }- if let CellValue::Entities(values) = &cell.value {- for value in values {- let expected = match pipeline.record_type {- PipelineRecordType::Company => models_databases::EntityKind::Company,- PipelineRecordType::Contact => models_databases::EntityKind::Contact,- };- if value.entity_type != expected {- return Err(PipelineError::Invalid(- "Choose the required CRM record type",- ));- }- references.insert(- value- .entity_id- .parse()- .map_err(|_| PipelineError::Invalid("Choose a valid CRM record"))?,- );- }- }- }- }- Ok(references)-}diff --git a/crates/crm/src/domain/pipelines/references.rs b/crates/crm/src/domain/pipelines/references.rsnew file mode 100644index 0000000000..e9048d3548--- /dev/null+++ b/crates/crm/src/domain/pipelines/references.rs@@ -0,0 +1,59 @@+use super::*;++/// Distinct primary records explicitly written by this batch. Other cells and+/// unchanged references do not require the editor to reselect the record.+pub(super) fn primary_references(+ pipeline: &Pipeline,+ batch: &OpBatch,+) -> Result<std::collections::BTreeSet<Uuid>, PipelineError> {+ use models_databases::{CellValue, CellWrite, DatabaseOp, RowChanges, RowsChange};+ let mut references = std::collections::BTreeSet::new();+ for op in &batch.ops {+ let cells: Vec<&CellWrite> = match op {+ DatabaseOp::Rows {+ change: RowsChange::Insert { rows },+ ..+ } => rows.iter().flatten().collect(),+ DatabaseOp::Rows {+ change:+ RowsChange::Update {+ changes: RowChanges::Uniform { cells, .. },+ },+ ..+ } => cells.iter().collect(),+ DatabaseOp::Rows {+ change:+ RowsChange::Update {+ changes: RowChanges::PerRow { rows },+ },+ ..+ } => rows.iter().flat_map(|row| &row.cells).collect(),+ _ => continue,+ };+ for cell in cells {+ if cell.column != pipeline.primary_column_id {+ continue;+ }+ if let CellValue::Entities(values) = &cell.value {+ for value in values {+ let expected = match pipeline.record_type {+ PipelineRecordType::Company => models_databases::EntityKind::Company,+ PipelineRecordType::Contact => models_databases::EntityKind::Contact,+ };+ if value.entity_type != expected {+ return Err(PipelineError::Invalid(+ "Choose the required CRM record type",+ ));+ }+ references.insert(+ value+ .entity_id+ .parse()+ .map_err(|_| PipelineError::Invalid("Choose a valid CRM record"))?,+ );+ }+ }+ }+ }+ Ok(references)+}diff --git a/crates/crm/src/domain/pipelines/requirements.rs b/crates/crm/src/domain/pipelines/requirements.rsnew file mode 100644index 0000000000..221b6a1aed--- /dev/null+++ b/crates/crm/src/domain/pipelines/requirements.rs@@ -0,0 +1,502 @@+//! Stage-entry policy over the shared operation protocol. The pipeline write+//! guard serializes rule changes and writes; the table version also fences+//! changes made by the underlying storage domain.++use super::*;+use models_databases::{+ CellValue, CellWrite, ColumnChange, DatabaseOp, OptionId, OptionRef, RowChanges, RowsChange,+ ViewChange, ViewId,+ views::{RequestedLayout, ViewLayout},+};+use std::collections::{BTreeMap, HashSet};++/// Fields required when a deal enters a particular option of a stage column.+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, utoipa::ToSchema)]+#[serde(rename_all = "camelCase", deny_unknown_fields)]+pub struct StageRequirement {+ /// Single-select column identifying the stage, independent of its name.+ #[schema(value_type = Uuid)]+ pub stage_column_id: ColumnId,+ /// Stable option identity; renaming the stage preserves the rule.+ #[schema(value_type = Uuid)]+ pub stage_id: OptionId,+ /// Fields that must be present. Empty removes the rule for this stage.+ #[schema(value_type = Vec<Uuid>)]+ pub required_column_ids: Vec<ColumnId>,+}++pub(super) fn validate_rule(+ table: &TableDetail,+ rule: &StageRequirement,+) -> Result<(), PipelineError> {+ let stage = table+ .columns+ .iter()+ .find(|c| c.column.id == rule.stage_column_id)+ .ok_or(PipelineError::Invalid("Choose an existing stage field"))?;+ if stage.definition.definition.data_type != DataType::SelectString+ || stage.definition.definition.is_multi_select+ || !stage+ .definition+ .property_options+ .iter()+ .any(|o| o.id == rule.stage_id.into_uuid())+ {+ return Err(PipelineError::Invalid(+ "Choose an existing stage in a single-select field",+ ));+ }+ let mut seen = HashSet::new();+ for id in &rule.required_column_ids {+ let column = table+ .columns+ .iter()+ .find(|c| c.column.id == *id)+ .ok_or(PipelineError::Invalid("Choose an existing required field"))?;+ if *id == rule.stage_column_id+ || !seen.insert(*id)+ || !column.writable+ || column.column.formula().is_some()+ || column.column.is_relation()+ {+ return Err(PipelineError::Invalid(+ "Choose each editable required field once, excluding the stage field",+ ));+ }+ }+ Ok(())+}++impl<R: PipelineRepo, D: DatabaseStorageService, A, S> PipelineServiceImpl<R, D, A, S> {+ #[tracing::instrument(skip_all, fields(pipeline_id = %pipeline.id), err)]+ pub(super) async fn validate_stage_requirements(+ &self,+ pipeline: &Pipeline,+ batch: &mut OpBatch,+ ) -> Result<(), PipelineError> {+ let rules = self+ .repo+ .stage_requirements(pipeline.id)+ .await+ .map_err(storage)?;+ if rules.is_empty() {+ return Ok(());+ }+ let table = self+ .databases+ .storage_tables(pipeline.database_id)+ .await?+ .into_iter()+ .find(|t| t.table.id == pipeline.table_id)+ .ok_or(PipelineError::NotFound)?;+ let version = batch+ .base_versions+ .entry(pipeline.table_id)+ .or_insert(table.table.version);+ if *version != table.table.version {+ return Err(databases::domain::models::DatabaseError::VersionConflict.into());+ }+ let ids = affected_rows(&batch.ops);+ if ids.len() > 10_000 {+ return Err(PipelineError::Invalid(+ "Change at most 10000 entries at a time",+ ));+ }+ let rows = if ids.is_empty() {+ Vec::new()+ } else {+ self.databases+ .storage_row_cells(pipeline.database_id, pipeline.table_id, &ids)+ .await?+ };+ validate_batch(&table, &rules, rows, &batch.ops)+ }+}++fn affected_rows(ops: &[DatabaseOp]) -> Vec<RowId> {+ let mut ids = HashSet::new();+ for op in ops {+ match op {+ DatabaseOp::Rows {+ change:+ RowsChange::Update {+ changes: RowChanges::Uniform { rows, .. },+ },+ ..+ }+ | DatabaseOp::Rows {+ change: RowsChange::Delete { rows },+ ..+ } => ids.extend(rows),+ DatabaseOp::Rows {+ change:+ RowsChange::Update {+ changes: RowChanges::PerRow { rows },+ },+ ..+ } => ids.extend(rows.iter().map(|r| &r.row)),+ DatabaseOp::View {+ change: ViewChange::MoveCard { row, .. },+ ..+ } => {+ ids.insert(*row);+ }+ _ => {}+ }+ }+ ids.into_iter().collect()+}++#[derive(Clone, Default)]+struct Value {+ present: bool,+ options: Vec<OptionId>,+}++impl Value {+ fn stored(value: &PropertyValue) -> Self {+ let present = match value {+ PropertyValue::Str(s) => !s.trim().is_empty(),+ PropertyValue::SelectOption(v) => !v.is_empty(),+ PropertyValue::EntityRef(v) => !v.is_empty(),+ PropertyValue::Link(v) => !v.is_empty(),+ _ => true,+ };+ Self {+ present,+ options: match value {+ PropertyValue::SelectOption(ids) => {+ ids.iter().copied().map(OptionId::from_uuid).collect()+ }+ _ => vec![],+ },+ }+ }++ fn written(value: &CellValue, labels: Option<&BTreeMap<OptionId, String>>) -> Self {+ let present = match value {+ CellValue::Clear => false,+ CellValue::Text(s) => !s.trim().is_empty(),+ CellValue::Options(v) => !v.is_empty(),+ CellValue::Entities(v) => !v.is_empty(),+ CellValue::Rows(v) => !v.is_empty(),+ CellValue::Link(v) => !v.is_empty(),+ _ => true,+ };+ let options = match value {+ CellValue::Options(options) => options+ .iter()+ .filter_map(|option| match option {+ OptionRef::Id(id) => Some(*id),+ OptionRef::Label(label) => labels?+ .iter()+ .find(|(_, text)| text.trim().to_lowercase() == label.trim().to_lowercase())+ .map(|(id, _)| *id),+ })+ .collect(),+ _ => vec![],+ };+ Self { present, options }+ }+}++struct Draft {+ cells: HashMap<ColumnId, Value>,+ original: HashMap<ColumnId, Value>,+ touched: HashSet<ColumnId>,+ inserted: bool,+ op: usize,+ row: Option<usize>,+}++impl Draft {+ fn write(+ &mut self,+ cells: &[CellWrite],+ labels: &HashMap<ColumnId, BTreeMap<OptionId, String>>,+ op: usize,+ row: Option<usize>,+ ) {+ for cell in cells {+ self.cells.insert(+ cell.column,+ Value::written(&cell.value, labels.get(&cell.column)),+ );+ self.touched.insert(cell.column);+ }+ self.op = op;+ self.row = row;+ }+}++fn refuse(op: usize, row: Option<usize>, column: ColumnId, reason: String) -> PipelineError {+ databases::domain::models::DatabaseError::InvalidOp(databases::domain::models::OpRefusal {+ op,+ row,+ column: Some(column),+ reason,+ taken: None,+ })+ .into()+}++fn validate_batch(+ table: &TableDetail,+ rules: &[StageRequirement],+ rows: Vec<StorageRow>,+ ops: &[DatabaseOp],+) -> Result<(), PipelineError> {+ let mut drafts: HashMap<RowId, Draft> = rows+ .into_iter()+ .map(|row| {+ let cells: HashMap<_, _> = row+ .cells+ .iter()+ .map(|(id, value)| (*id, Value::stored(value)))+ .collect();+ (+ row.row_id,+ Draft {+ original: cells.clone(),+ cells,+ touched: HashSet::new(),+ inserted: false,+ op: 0,+ row: None,+ },+ )+ })+ .collect();+ let mut inserted = Vec::new();+ let mut rules = rules.to_vec();+ let mut names: HashMap<_, _> = table+ .columns+ .iter()+ .map(|c| (c.column.id, c.column.name(&c.definition).to_owned()))+ .collect();+ let mut labels: HashMap<_, BTreeMap<_, _>> = table+ .columns+ .iter()+ .map(|c| {+ (+ c.column.id,+ c.definition+ .property_options+ .iter()+ .filter_map(|o| match &o.value {+ PropertyOptionValue::String(label) => {+ Some((OptionId::from_uuid(o.id), label.clone()))+ }+ _ => None,+ })+ .collect(),+ )+ })+ .collect();+ let mut groups: HashMap<ViewId, ColumnId> = table+ .views+ .iter()+ .filter_map(|v| match v.layout {+ ViewLayout::Board { group_by, .. } => Some((v.id, group_by)),+ _ => None,+ })+ .collect();+ for (op_index, op) in ops.iter().enumerate() {+ match op {+ DatabaseOp::Column { column, change, .. } => match change {+ ColumnChange::Rename { name, .. } => {+ names.insert(*column, name.clone());+ }+ ColumnChange::Delete => {+ rules.retain(|r| r.stage_column_id != *column);+ for rule in &mut rules {+ rule.required_column_ids.retain(|id| id != column);+ }+ rules.retain(|rule| !rule.required_column_ids.is_empty());+ }+ ColumnChange::DeleteOption { option } => {+ rules.retain(|r| r.stage_column_id != *column || r.stage_id != *option);+ // Deletion also clears cells of rows not otherwise in this batch.+ // Keep that schema change explicit without scanning the whole pipeline.+ if rules.iter().any(|r| r.required_column_ids.contains(column)) {+ return Err(refuse(+ op_index,+ None,+ *column,+ "Remove this field's stage requirements before deleting its options"+ .into(),+ ));+ }+ if let Some(options) = labels.get_mut(column) {+ options.remove(option);+ }+ for draft in drafts.values_mut().chain(inserted.iter_mut()) {+ if let Some(value) = draft.cells.get_mut(column)+ && value.options.contains(option)+ {+ value.options.retain(|id| id != option);+ value.present = !value.options.is_empty();+ }+ }+ }+ ColumnChange::UpdateOption {+ option,+ label: Some(label),+ ..+ } => {+ labels+ .entry(*column)+ .or_default()+ .insert(*option, label.clone());+ }+ ColumnChange::AddOptions { options } => {+ for option in options {+ let existing = labels.entry(*column).or_default();+ if !existing.values().any(|label| {+ label.trim().to_lowercase() == option.label.trim().to_lowercase()+ }) {+ existing.insert(option.id, option.label.trim().to_owned());+ }+ }+ }+ ColumnChange::ChangeType { .. } | ColumnChange::SetFormula { .. }+ if rules.iter().any(|r| {+ r.stage_column_id == *column || r.required_column_ids.contains(column)+ }) =>+ {+ return Err(refuse(+ op_index,+ None,+ *column,+ "Remove this field's stage requirements before changing its type".into(),+ ));+ }+ _ => {}+ },+ DatabaseOp::Rows { change, .. } => match change {+ RowsChange::Insert { rows } => {+ for (row_index, cells) in rows.iter().enumerate() {+ let mut draft = Draft {+ cells: HashMap::new(),+ original: HashMap::new(),+ touched: HashSet::new(),+ inserted: true,+ op: op_index,+ row: Some(row_index),+ };+ draft.write(cells, &labels, op_index, Some(row_index));+ inserted.push(draft);+ }+ }+ RowsChange::Update {+ changes: RowChanges::Uniform { rows, cells },+ } => {+ for (row_index, id) in rows.iter().enumerate() {+ if let Some(draft) = drafts.get_mut(id) {+ draft.write(cells, &labels, op_index, Some(row_index));+ }+ }+ }+ RowsChange::Update {+ changes: RowChanges::PerRow { rows },+ } => {+ for (row_index, row) in rows.iter().enumerate() {+ if let Some(draft) = drafts.get_mut(&row.row) {+ draft.write(&row.cells, &labels, op_index, Some(row_index));+ }+ }+ }+ RowsChange::Delete { rows } => {+ for id in rows {+ drafts.remove(id);+ }+ }+ },+ DatabaseOp::View { view, change, .. } => match change {+ ViewChange::Create { view: new } => update_group(&mut groups, *view, &new.layout),+ ViewChange::Update {+ layout: Some(layout),+ ..+ } => update_group(&mut groups, *view, layout),+ ViewChange::Delete => {+ groups.remove(view);+ }+ ViewChange::MoveCard { row, lane, .. } => {+ if let (Some(column), Some(draft)) = (groups.get(view), drafts.get_mut(row)) {+ draft.write(+ &[CellWrite {+ column: *column,+ value: lane.cell(),+ }],+ &labels,+ op_index,+ None,+ );+ }+ }+ _ => {}+ },+ _ => {}+ }+ }+ for draft in drafts.values().chain(&inserted) {+ for rule in &rules {+ if !draft+ .cells+ .get(&rule.stage_column_id)+ .is_some_and(|v| v.options.contains(&rule.stage_id))+ {+ continue;+ }+ let entering = draft.inserted+ || !draft+ .original+ .get(&rule.stage_column_id)+ .is_some_and(|v| v.options.contains(&rule.stage_id));+ let editing_required = rule+ .required_column_ids+ .iter()+ .any(|id| draft.touched.contains(id));+ if !entering && !editing_required {+ continue;+ }+ let missing: Vec<_> = rule+ .required_column_ids+ .iter()+ .filter(|id| !draft.cells.get(id).is_some_and(|v| v.present))+ .collect();+ if let Some(column) = missing.first() {+ let stage = labels+ .get(&rule.stage_column_id)+ .and_then(|options| options.get(&rule.stage_id))+ .cloned()+ .unwrap_or_else(|| rule.stage_id.to_string());+ let fields = missing+ .iter()+ .map(|id| names.get(id).cloned().unwrap_or_else(|| id.to_string()))+ .collect::<Vec<_>>()+ .join(", ");+ return Err(refuse(+ draft.op,+ draft.row,+ **column,+ format!(+ "Fill in {fields} before entering {stage}. Your changes were not saved."+ ),+ ));+ }+ }+ }+ Ok(())+}++fn update_group(groups: &mut HashMap<ViewId, ColumnId>, view: ViewId, layout: &RequestedLayout) {+ match layout {+ RequestedLayout::Board { group_by, .. } => {+ groups.insert(view, *group_by);+ }+ RequestedLayout::Table { .. } | RequestedLayout::Timeline { .. } => {+ groups.remove(&view);+ }+ }+}diff --git a/crates/crm/src/domain/pipelines/sharing.rs b/crates/crm/src/domain/pipelines/sharing.rsnew file mode 100644index 0000000000..00767b3350--- /dev/null+++ b/crates/crm/src/domain/pipelines/sharing.rs@@ -0,0 +1,55 @@+//! Pipeline channel-sharing request policy.++use super::*;++/// Most channel grants one request may change.+const MAX_CHANNEL_GRANTS_PER_UPDATE: usize = 100;++/// The channel grants of a sharing request. Pipelines have no share link, and+/// team access changes only through [`PipelineService::share`].+pub(super) fn requested_channel_grants(+ request: UpdateSharePermissionRequestV2,+) -> Result<Vec<UpdateChannelSharePermission>, PipelineError> {+ if request.link_share.is_some()+ || request.link_share_access_level.is_some()+ || request.team_share_access_level.is_some()+ {+ return Err(PipelineError::Invalid(+ "Share a pipeline with people and channels; only its owner changes team access",+ ));+ }+ let grants = request.channel_share_permissions.unwrap_or_default();+ if grants.len() > MAX_CHANNEL_GRANTS_PER_UPDATE {+ return Err(PipelineError::Invalid(+ "Share with at most 100 channels at a time",+ ));+ }+ let mut channels = std::collections::HashSet::new();+ for grant in &grants {+ if !channels.insert(&grant.channel_id)+ || Uuid::parse_str(&grant.channel_id).is_err()+ || grant.access_level == Some(AccessLevel::Owner)+ || (grant.operation != UpdateOperation::Remove && grant.access_level.is_none())+ {+ return Err(PipelineError::Invalid(+ "Give each channel once, with view, comment or edit access",+ ));+ }+ }+ Ok(grants)+}++pub(super) fn share_permission(+ pipeline: &Pipeline,+ channels: Vec<ChannelSharePermission>,+) -> SharePermissionV2 {+ SharePermissionV2 {+ id: pipeline.id.to_string(),+ owner: pipeline.user_id.clone(),+ link_share: None,+ link_share_access_level: None,+ team_share_access_level: (pipeline.sharing == PipelineSharing::Team)+ .then_some(AccessLevel::Edit),+ channel_share_permissions: Some(channels),+ }+}diff --git a/crates/crm/src/inbound/pipelines.rs b/crates/crm/src/inbound/pipelines.rsindex d7970252f5..1d7e5e92b2 100644--- a/crates/crm/src/inbound/pipelines.rs+++ b/crates/crm/src/inbound/pipelines.rs@@ -1,5 +1,6 @@//! Thin HTTP adapters for pipeline creation, navigation, sharing and lifecycle.+use crate::domain::pipelines::requirements::StageRequirement;use crate::domain::{auth::CrmTeamReceipt,pipelines::{@@ -82,6 +83,10 @@ whereget(rows::<P, E, A>).post(query_rows::<P, E, A>),).route("/{id}/ops", post(apply_ops::<P, E, A>))+ .route(+ "/{id}/stage-requirements",+ get(stage_requirements::<P, E, A>).put(set_stage_requirement::<P, E, A>),+ ).route("/{id}/name", put(rename::<P, E, A>)).route("/{id}/sharing", put(share::<P, E, A>)).route(@@ -270,6 +275,49 @@ pub async fn apply_ops<P: PipelineService, E: EntityAccessService, A: MacroAutho))}+/// Read requirements by stable stage and field identities.+#[utoipa::path(get, path = "/crm/pipelines/{id}/stage-requirements", operation_id = "get_crm_pipeline_stage_requirements",+ params(("id" = Uuid, Path)), responses((status = 200, body = Vec<StageRequirement>)))]+pub async fn stage_requirements<+ P: PipelineService,+ E: EntityAccessService,+ A: MacroAuthorizationService,+>(+ auth: MacroAuthorizationExtractor<A, UserOrInternal>,+ State(state): State<PipelineRouterState<P, E, A>>,+ Path(id): Path<Uuid>,+) -> Result<Json<Vec<StageRequirement>>, PipelineError> {+ Ok(Json(+ state+ .service+ .stage_requirements(receipt::<ViewAccessLevel, _, _>(&*state.access, auth, id).await?)+ .await?,+ ))+}++/// Replace the required fields for one stage. An empty list removes its rule.+#[utoipa::path(put, path = "/crm/pipelines/{id}/stage-requirements", operation_id = "set_crm_pipeline_stage_requirement", request_body = StageRequirement,+ params(("id" = Uuid, Path)), responses((status = 204)))]+pub async fn set_stage_requirement<+ P: PipelineService,+ E: EntityAccessService,+ A: MacroAuthorizationService,+>(+ auth: MacroAuthorizationExtractor<A, UserOrInternal>,+ State(state): State<PipelineRouterState<P, E, A>>,+ Path(id): Path<Uuid>,+ Json(rule): Json<StageRequirement>,+) -> Result<StatusCode, PipelineError> {+ state+ .service+ .set_stage_requirement(+ receipt::<EditAccessLevel, _, _>(&*state.access, auth, id).await?,+ rule,+ )+ .await?;+ Ok(StatusCode::NO_CONTENT)+}+/// Rename input.#[derive(Deserialize, utoipa::ToSchema)]#[serde(deny_unknown_fields)]diff --git a/crates/crm/src/outbound/pipelines.rs b/crates/crm/src/outbound/pipelines.rsindex bc96980de6..3ad4d0c2bb 100644--- a/crates/crm/src/outbound/pipelines.rs+++ b/crates/crm/src/outbound/pipelines.rs@@ -1,11 +1,13 @@//! Pipeline metadata and grants, composed with the database domain's writer.+use crate::domain::pipelines::requirements::StageRequirement;use crate::domain::pipelines::{Pipeline, PipelineBlueprint, PipelineRecordType, PipelineReference, PipelineRepo,PipelineSharing,};use databases::domain::provisioning::DatabaseStorageProvisioner;use entity_access_db_utils::{AccessLevel, EntityAccessSourceType, EntityType};+use models_databases::OptionId;use models_databases::{ColumnId, DatabaseId, RowId, TableId};use models_permissions::share_permission::channel_share_permission::{ChannelSharePermission, UpdateChannelSharePermission,@@ -183,6 +185,10 @@ whereasync fn lock_live(&self, id: Uuid) -> Result<Option<Self::Guard>, Self::Error> {let mut tx = self.pool.begin().await?;+ // Readers queued behind a writer also need to release pool connections.+ sqlx::query!("SET LOCAL lock_timeout = '5s'")+ .execute(&mut *tx)+ .await?;let row = sqlx::query!("SELECT id FROM crm_pipeline_entities WHERE id = $1 AND trashed_at IS NULL FOR SHARE",id@@ -192,6 +198,53 @@ whereOk(row.map(|_| tx))}+ async fn lock_write(&self, id: Uuid) -> Result<Option<Self::Guard>, Self::Error> {+ let mut tx = self.pool.begin().await?;+ // Queued writers must release connections so the holder can use storage.+ sqlx::query!("SET LOCAL lock_timeout = '5s'")+ .execute(&mut *tx)+ .await?;+ // Allows foreign-key checks from the storage transaction while serializing+ // all pipeline writers and holding the pipeline against trash/deletion.+ let row = sqlx::query!("SELECT id FROM crm_pipeline_entities WHERE id = $1 AND trashed_at IS NULL FOR NO KEY UPDATE", id).fetch_optional(&mut *tx).await?;+ Ok(row.map(|_| tx))+ }++ async fn stage_requirements(&self, id: Uuid) -> Result<Vec<StageRequirement>, Self::Error> {+ let rows = sqlx::query!("SELECT stage_column_id, stage_id, required_column_id FROM crm_pipeline_stage_requirements WHERE pipeline_id = $1 ORDER BY stage_column_id, stage_id, required_column_id", id).fetch_all(&self.pool).await?;+ let mut rules = Vec::new();+ for group in+ rows.chunk_by(|a, b| a.stage_column_id == b.stage_column_id && a.stage_id == b.stage_id)+ {+ rules.push(StageRequirement {+ stage_column_id: ColumnId::from_uuid(group[0].stage_column_id),+ stage_id: OptionId::from_uuid(group[0].stage_id),+ required_column_ids: group+ .iter()+ .map(|row| ColumnId::from_uuid(row.required_column_id))+ .collect(),+ });+ }+ Ok(rules)+ }++ async fn set_stage_requirement(+ &self,+ id: Uuid,+ rule: &StageRequirement,+ ) -> Result<(), Self::Error> {+ let mut tx = self.pool.begin().await?;+ sqlx::query!("DELETE FROM crm_pipeline_stage_requirements WHERE pipeline_id = $1 AND stage_column_id = $2 AND stage_id = $3", id, rule.stage_column_id.into_uuid(), rule.stage_id.into_uuid()).execute(&mut *tx).await?;+ let fields: Vec<_> = rule+ .required_column_ids+ .iter()+ .map(|id| id.into_uuid())+ .collect();+ sqlx::query!("INSERT INTO crm_pipeline_stage_requirements (pipeline_id, stage_column_id, stage_id, required_column_id) SELECT $1, $2, $3, unnest($4::uuid[]) ON CONFLICT DO NOTHING", id, rule.stage_column_id.into_uuid(), rule.stage_id.into_uuid(), &fields).execute(&mut *tx).await?;+ tx.commit().await?;+ Ok(())+ }+async fn rename(&self, id: Uuid, name: &str) -> Result<(), Self::Error> {sqlx::query!("UPDATE crm_pipeline_entities SET name = $2, updated_at = now() WHERE id = $1 AND trashed_at IS NULL", id, name).execute(&self.pool).await?;diff --git a/crates/crm/tests/pipeline_workflows.rs b/crates/crm/tests/pipeline_workflows.rsindex 5b8c269cfc..524a395fb0 100644--- a/crates/crm/tests/pipeline_workflows.rs+++ b/crates/crm/tests/pipeline_workflows.rs@@ -681,3 +681,6 @@ async fn pipelines_are_created_with_stages_and_edited_by_name(pool: PgPool) {.is_err());}++#[path = "pipeline_workflows/requirements.rs"]+mod requirements;diff --git a/crates/crm/tests/pipeline_workflows/requirements.rs b/crates/crm/tests/pipeline_workflows/requirements.rsnew file mode 100644index 0000000000..8ca6d85596--- /dev/null+++ b/crates/crm/tests/pipeline_workflows/requirements.rs@@ -0,0 +1,60 @@+use super::*;+use crm::domain::crm_transfer::{+ CrmTransferRecords, CrmTransferService, CrmTransferServiceImpl, CsvFile, CsvFiles, CsvInput,+ TransferError,+};++struct TextOnly;+impl CsvFiles for TextOnly {+ async fn read(&self, _: &Viewer, _: Uuid) -> Result<CsvFile, TransferError> {+ panic!("text import does not read a file")+ }+ async fn save(&self, _: &Viewer, _: &str, _: String) -> Result<Uuid, TransferError> {+ panic!("import does not save a file")+ }+}++#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]+async fn agent_add_and_csv_import_enforce_stage_rules_and_report_invalid_rows(pool: PgPool) {+ let Fixture {+ workflows, acme, ..+ } = fixture(&pool).await;+ let owner = viewer(OWNER);+ let overview = sales(&workflows, PipelineSharing::Private).await;+ let pipeline = overview.pipeline.pipeline.id;+ let stage = overview.field("Stage").unwrap();+ let stage_id = stage.options[0].0;+ let amount = overview.field("Revenue").unwrap().id;+ sqlx::query!("INSERT INTO crm_pipeline_stage_requirements (pipeline_id, stage_column_id, stage_id, required_column_id) VALUES ($1, $2, $3, $4)", pipeline, stage.id.into_uuid(), stage_id.into_uuid(), amount.into_uuid()).execute(&pool).await.unwrap();+ let error = workflows+ .add(+ &owner,+ pipeline,+ vec![EntryAddition {+ record: RecordTarget::Id(acme),+ set: vec![set("Stage", "Prospect")],+ }],+ true,+ )+ .await+ .unwrap_err();+ assert!(+ matches!(&error, WorkflowError::Invalid(message) if message.contains("Revenue") && message.contains("Prospect")),+ "{error:?}"+ );+ let access = Arc::new(Access::new(PgAccessRepository::new(pool.clone())));+ let crm = Arc::new(Crm::new(+ CompaniesRepositoryImpl::new(pool.clone()),+ NoOpCompanyMetadataResolver,+ ));+ let importer = CrmTransferServiceImpl::new(+ Arc::new(workflows),+ CrmTransferRecords::new(crm, access),+ TextOnly,+ );+ let result = importer.import_to_pipeline(&owner, pipeline, CsvInput::Text("Company,Domain,Stage,Revenue\nAcme,acme.com,Prospect,\nGlobex,globex.com,Prospect,100\n".into())).await.unwrap();+ assert_eq!(result.added, 1);+ assert_eq!(result.invalid.len(), 1);+ assert_eq!(result.invalid[0].key, "acme.com");+ assert!(result.invalid[0].reason.contains("Revenue"));+}diff --git a/crates/crm/tests/pipelines.rs b/crates/crm/tests/pipelines.rsindex 17b2f06199..117a567896 100644--- a/crates/crm/tests/pipelines.rs+++ b/crates/crm/tests/pipelines.rs@@ -676,6 +676,11 @@ async fn migration_rollback_preserves_records_and_grants(pool: PgPool) {).await.unwrap();+ // Remove later dependent schema before exercising the older rollback.+ sqlx::raw_sql("DROP TABLE crm_pipeline_stage_requirements")+ .execute(&pool)+ .await+ .unwrap();// Execute the actual rollback DDL in this disposable test database.sqlx::raw_sql(include_str!("../../macro_db_client/migrations/20261007172434_crm_pipeline_entities.down.sql"@@ -1419,6 +1424,9 @@ async fn editors_share_with_people_and_only_the_owner_changes_team_access(pool:));}+#[path = "pipelines/requirements.rs"]+mod requirements;+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]async fn board_positions_survive_reads_and_stay_with_the_authorized_pipeline(pool: PgPool) {use databases::domain::storage::DatabaseStorageService;diff --git a/crates/crm/tests/pipelines/requirements.rs b/crates/crm/tests/pipelines/requirements.rsnew file mode 100644index 0000000000..69322664c1--- /dev/null+++ b/crates/crm/tests/pipelines/requirements.rs@@ -0,0 +1,844 @@+use super::*;+use crm::domain::pipelines::requirements::StageRequirement;+use models_properties::service::property_value::PropertyValue;++#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]+async fn deleting_required_options_is_refused_until_the_rule_is_removed(pool: PgPool) {+ let (s, _db, a, team, company) = fixture(&pool).await;+ let p = create(&s, team, PipelineRecordType::Company).await;+ let detail = s+ .table(access(&a, p.id, EntityType::CrmPipeline, OWNER).await)+ .await+ .unwrap();+ let stage = detail.columns[1].column.id;+ let won = OptionId::from_uuid(detail.columns[1].definition.property_options[1].id);+ let approval = ColumnId::new();+ let approved = OptionId::new();+ write(+ &s,+ &a,+ &p,+ vec![+ serde_json::from_value(json!({+ "kind": "column", "table": p.table_id, "column": approval,+ "change": {"kind": "create", "definition": {+ "source": "new", "name": "Approval",+ "type": {"type": "select", "multi": false}+ }}+ }))+ .unwrap(),+ DatabaseOp::Column {+ table: p.table_id,+ column: approval,+ change: ColumnChange::AddOptions {+ options: vec![NewOption {+ id: approved,+ label: "Approved".into(),+ }],+ },+ },+ ],+ )+ .await+ .unwrap();+ let mut rule = StageRequirement {+ stage_column_id: stage,+ stage_id: won,+ required_column_ids: vec![approval],+ };+ s.set_stage_requirement(+ access(&a, p.id, EntityType::CrmPipeline, OWNER).await,+ rule.clone(),+ )+ .await+ .unwrap();+ let mut addition = insert(&p, company);+ if let DatabaseOp::Rows {+ change: RowsChange::Insert { rows },+ ..+ } = &mut addition+ {+ rows[0].extend([+ CellWrite {+ column: stage,+ value: CellValue::Options(vec![OptionRef::Id(won)]),+ },+ CellWrite {+ column: approval,+ value: CellValue::Options(vec![OptionRef::Id(approved)]),+ },+ ]);+ }+ let row = inserted(&write(&s, &a, &p, vec![addition]).await.unwrap());+ let delete = DatabaseOp::Column {+ table: p.table_id,+ column: approval,+ change: ColumnChange::DeleteOption { option: approved },+ };+ // No row operation accompanies the schema edit, so affected_rows is empty.+ let error = write(&s, &a, &p, vec![delete.clone()])+ .await+ .unwrap_err()+ .to_string();+ assert!(error.contains("before deleting its options"), "{error}");+ let saved = s+ .read_rows(+ access(&a, p.id, EntityType::CrmPipeline, OWNER).await,+ &[row],+ )+ .await+ .unwrap();+ assert_eq!(+ saved[0].cells[&approval],+ PropertyValue::SelectOption(vec![approved.into_uuid()])+ );+ rule.required_column_ids.clear();+ s.set_stage_requirement(access(&a, p.id, EntityType::CrmPipeline, OWNER).await, rule)+ .await+ .unwrap();+ write(&s, &a, &p, vec![delete]).await.unwrap();+ let table = s+ .table(access(&a, p.id, EntityType::CrmPipeline, OWNER).await)+ .await+ .unwrap();+ assert!(+ table+ .columns+ .iter()+ .find(|c| c.column.id == approval)+ .unwrap()+ .definition+ .property_options+ .is_empty()+ );+}++#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]+async fn stage_requirements_reject_atomically_and_allow_combined_edits(pool: PgPool) {+ let (s, _db, a, team, company) = fixture(&pool).await;+ let p = create(&s, team, PipelineRecordType::Company).await;+ let detail = s+ .table(access(&a, p.id, EntityType::CrmPipeline, OWNER).await)+ .await+ .unwrap();+ let stage = detail.columns[1].column.id;+ let won = OptionId::from_uuid(detail.columns[1].definition.property_options[1].id);+ let amount = detail.columns[3].column.id;+ s.set_stage_requirement(+ access(&a, p.id, EntityType::CrmPipeline, OWNER).await,+ StageRequirement {+ stage_column_id: stage,+ stage_id: won,+ required_column_ids: vec![amount],+ },+ )+ .await+ .unwrap();+ let mut addition = insert(&p, company);+ if let DatabaseOp::Rows {+ change: RowsChange::Insert { rows },+ ..+ } = &mut addition+ {+ rows[0].push(CellWrite {+ column: stage,+ value: CellValue::Options(vec![OptionRef::Label("Won".into())]),+ });+ }+ let error = write(&s, &a, &p, vec![addition.clone()])+ .await+ .unwrap_err()+ .to_string();+ assert!(+ error.contains("Revenue") && error.contains("Won"),+ "{error}"+ );+ assert!(+ s.rows(access(&a, p.id, EntityType::CrmPipeline, OWNER).await, None)+ .await+ .unwrap()+ .rows+ .is_empty()+ );+ if let DatabaseOp::Rows {+ change: RowsChange::Insert { rows },+ ..+ } = &mut addition+ {+ rows[0].push(CellWrite {+ column: amount,+ value: CellValue::Number(0.0),+ });+ }+ let row = inserted(&write(&s, &a, &p, vec![addition]).await.unwrap());+ let clear = DatabaseOp::Rows {+ table: p.table_id,+ change: RowsChange::Update {+ changes: RowChanges::Uniform {+ rows: vec![row],+ cells: vec![CellWrite {+ column: amount,+ value: CellValue::Clear,+ }],+ },+ },+ };+ assert!(write(&s, &a, &p, vec![clear.clone()]).await.is_err());+ let saved = s+ .read_rows(+ access(&a, p.id, EntityType::CrmPipeline, OWNER).await,+ &[row],+ )+ .await+ .unwrap();+ assert_eq!(saved[0].cells[&amount], PropertyValue::Num(0.0));+ let leave = DatabaseOp::Rows {+ table: p.table_id,+ change: RowsChange::Update {+ changes: RowChanges::Uniform {+ rows: vec![row],+ cells: vec![CellWrite {+ column: stage,+ value: CellValue::Clear,+ }],+ },+ },+ };+ write(&s, &a, &p, vec![clear, leave]).await.unwrap();+ let enter = DatabaseOp::Rows {+ table: p.table_id,+ change: RowsChange::Update {+ changes: RowChanges::PerRow {+ rows: vec![RowChange {+ row,+ cells: vec![CellWrite {+ column: stage,+ value: CellValue::Options(vec![OptionRef::Id(won)]),+ }],+ }],+ },+ },+ };+ assert!(write(&s, &a, &p, vec![enter.clone()]).await.is_err());+ let fill = DatabaseOp::Rows {+ table: p.table_id,+ change: RowsChange::Update {+ changes: RowChanges::Uniform {+ rows: vec![row],+ cells: vec![CellWrite {+ column: amount,+ value: CellValue::Number(500.0),+ }],+ },+ },+ };+ write(&s, &a, &p, vec![enter, fill]).await.unwrap();+ let saved = s+ .read_rows(+ access(&a, p.id, EntityType::CrmPipeline, OWNER).await,+ &[row],+ )+ .await+ .unwrap();+ assert_eq!(saved[0].cells[&amount], PropertyValue::Num(500.0));+ assert_eq!(+ saved[0].cells[&stage],+ PropertyValue::SelectOption(vec![won.into_uuid()])+ );+}++#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]+async fn rejected_required_input_edits_preserve_materialized_formulas(pool: PgPool) {+ let (s, _db, a, team, company) = fixture(&pool).await;+ let p = create(&s, team, PipelineRecordType::Company).await;+ let detail = s+ .table(access(&a, p.id, EntityType::CrmPipeline, OWNER).await)+ .await+ .unwrap();+ let stage = detail.columns[1].column.id;+ let won = OptionId::from_uuid(detail.columns[1].definition.property_options[1].id);+ let amount = detail.columns[3].column.id;+ let doubled = ColumnId::new();+ write(+ &s,+ &a,+ &p,+ vec![DatabaseOp::Column {+ table: p.table_id,+ column: doubled,+ change: ColumnChange::Create {+ definition: NewColumn::Derived {+ name: "Double revenue".into(),+ formula: Formula::Binary {+ operator: Operator::Multiply,+ left: Box::new(Formula::Column { column: amount }),+ right: Box::new(Formula::Number { value: 2.0 }),+ },+ },+ after: None,+ },+ }],+ )+ .await+ .unwrap();+ let rule = StageRequirement {+ stage_column_id: stage,+ stage_id: won,+ required_column_ids: vec![amount],+ };+ s.set_stage_requirement(+ access(&a, p.id, EntityType::CrmPipeline, OWNER).await,+ rule.clone(),+ )+ .await+ .unwrap();+ let mut addition = insert(&p, company);+ if let DatabaseOp::Rows {+ change: RowsChange::Insert { rows },+ ..+ } = &mut addition+ {+ rows[0].extend([+ CellWrite {+ column: stage,+ value: CellValue::Options(vec![OptionRef::Id(won)]),+ },+ CellWrite {+ column: amount,+ value: CellValue::Number(50.0),+ },+ ]);+ }+ let row = inserted(&write(&s, &a, &p, vec![addition]).await.unwrap());+ let before = s+ .read_rows(+ access(&a, p.id, EntityType::CrmPipeline, OWNER).await,+ &[row],+ )+ .await+ .unwrap();+ assert_eq!(before[0].cells[&amount], PropertyValue::Num(50.0));+ assert_eq!(before[0].cells[&doubled], PropertyValue::Num(100.0));+ assert!(+ write(+ &s,+ &a,+ &p,+ vec![DatabaseOp::Rows {+ table: p.table_id,+ change: RowsChange::Update {+ changes: RowChanges::Uniform {+ rows: vec![row],+ cells: vec![CellWrite {+ column: amount,+ value: CellValue::Clear,+ }],+ },+ },+ }],+ )+ .await+ .is_err()+ );+ let after = s+ .read_rows(+ access(&a, p.id, EntityType::CrmPipeline, OWNER).await,+ &[row],+ )+ .await+ .unwrap();+ assert_eq!(after[0].cells, before[0].cells);+ assert!(+ s.set_stage_requirement(+ access(&a, p.id, EntityType::CrmPipeline, OWNER).await,+ StageRequirement {+ required_column_ids: vec![doubled],+ ..rule.clone()+ },+ )+ .await+ .is_err()+ );+ assert_eq!(+ s.stage_requirements(access(&a, p.id, EntityType::CrmPipeline, OWNER).await)+ .await+ .unwrap(),+ vec![rule]+ );+}++#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]+async fn board_moves_share_stage_validation_and_keep_failed_moves_unchanged(pool: PgPool) {+ let (s, _db, a, team, company) = fixture(&pool).await;+ let p = create(&s, team, PipelineRecordType::Company).await;+ let detail = s+ .table(access(&a, p.id, EntityType::CrmPipeline, OWNER).await)+ .await+ .unwrap();+ let stage = detail.columns[1].column.id;+ let won = OptionId::from_uuid(detail.columns[1].definition.property_options[1].id);+ let amount = detail.columns[3].column.id;+ s.set_stage_requirement(+ access(&a, p.id, EntityType::CrmPipeline, OWNER).await,+ StageRequirement {+ stage_column_id: stage,+ stage_id: won,+ required_column_ids: vec![amount],+ },+ )+ .await+ .unwrap();+ let row = inserted(&write(&s, &a, &p, vec![insert(&p, company)]).await.unwrap());+ let view = ViewId::new();+ let create_view: DatabaseOp = serde_json::from_value(json!({+ "kind":"view", "table":p.table_id, "view":view,+ "change":{"kind":"create", "view":{"name":"Stages", "query":{"filter":null,"sort":[]}, "layout":{"kind":"board", "groupBy":stage,"title":p.primary_column_id,"lanes":[],"cardFields":[],"hideEmptyLanes":false}}}+ })).unwrap();+ let moving = DatabaseOp::View {+ table: p.table_id,+ view,+ change: ViewChange::MoveCard {+ row,+ lane: views::LaneKey::Option(won),+ before: None,+ after: None,+ },+ };+ // A view created in this batch must use its new grouping column too.+ assert!(+ write(&s, &a, &p, vec![create_view.clone(), moving.clone()])+ .await+ .unwrap_err()+ .to_string()+ .contains("Revenue")+ );+ assert!(+ s.table(access(&a, p.id, EntityType::CrmPipeline, OWNER).await)+ .await+ .unwrap()+ .views+ .iter()+ .all(|stored| stored.id != view)+ );+ write(&s, &a, &p, vec![create_view]).await.unwrap();+ assert!(+ write(&s, &a, &p, vec![moving.clone()])+ .await+ .unwrap_err()+ .to_string()+ .contains("Revenue")+ );+ let saved = s+ .read_rows(+ access(&a, p.id, EntityType::CrmPipeline, OWNER).await,+ &[row],+ )+ .await+ .unwrap();+ assert!(!saved[0].cells.contains_key(&stage));+ // A board changed to a timeline in this batch no longer supplies a lane+ // column. Storage must reject the card move without inventing a stage edit.+ let range = ColumnId::new();+ let create_range = DatabaseOp::Column {+ table: p.table_id,+ column: range,+ change: ColumnChange::Create {+ definition: models_databases::NewColumn::New {+ name: "Schedule".into(),+ kind: models_databases::ColumnKind::DateRange,+ options: vec![],+ infer_type: false,+ },+ after: None,+ },+ };+ let timeline: DatabaseOp = serde_json::from_value(json!({+ "kind":"view", "table":p.table_id, "view":view,+ "change":{"kind":"update", "layout":{"kind":"timeline", "range":range,+ "title":p.primary_column_id, "groupBy":stage, "barFields":[], "colorBy":null}}+ }))+ .unwrap();+ let error = write(&s, &a, &p, vec![create_range, timeline, moving.clone()])+ .await+ .unwrap_err()+ .to_string();+ assert!(error.contains("only a board's cards move"), "{error}");+ let fill = DatabaseOp::Rows {+ table: p.table_id,+ change: RowsChange::Update {+ changes: RowChanges::Uniform {+ rows: vec![row],+ cells: vec![CellWrite {+ column: amount,+ value: CellValue::Number(10.0),+ }],+ },+ },+ };+ write(&s, &a, &p, vec![fill, moving]).await.unwrap();+}++#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]+async fn rule_ids_survive_renames_and_cascade_on_explicit_deletion(pool: PgPool) {+ let (s, _db, a, team, company) = fixture(&pool).await;+ let p = create(&s, team, PipelineRecordType::Company).await;+ let detail = s+ .table(access(&a, p.id, EntityType::CrmPipeline, OWNER).await)+ .await+ .unwrap();+ let stage = detail.columns[1].column.id;+ let won = OptionId::from_uuid(detail.columns[1].definition.property_options[1].id);+ let amount = detail.columns[3].column.id;+ let rule = StageRequirement {+ stage_column_id: stage,+ stage_id: won,+ required_column_ids: vec![amount],+ };+ s.set_stage_requirement(+ access(&a, p.id, EntityType::CrmPipeline, OWNER).await,+ rule.clone(),+ )+ .await+ .unwrap();+ write(+ &s,+ &a,+ &p,+ vec![+ DatabaseOp::Column {+ table: p.table_id,+ column: stage,+ change: ColumnChange::Rename {+ name: "Milestone".into(),+ previous_name: None,+ },+ },+ DatabaseOp::Column {+ table: p.table_id,+ column: stage,+ change: ColumnChange::UpdateOption {+ option: won,+ label: Some("Negotiation".into()),+ color: None,+ },+ },+ DatabaseOp::Column {+ table: p.table_id,+ column: amount,+ change: ColumnChange::Rename {+ name: "Amount".into(),+ previous_name: None,+ },+ },+ ],+ )+ .await+ .unwrap();+ assert_eq!(+ s.stage_requirements(access(&a, p.id, EntityType::CrmPipeline, OWNER).await)+ .await+ .unwrap(),+ vec![rule]+ );+ let mut addition = insert(&p, company);+ if let DatabaseOp::Rows {+ change: RowsChange::Insert { rows },+ ..+ } = &mut addition+ {+ rows[0].push(CellWrite {+ column: stage,+ value: CellValue::Options(vec![OptionRef::Label("Negotiation".into())]),+ });+ }+ let error = write(&s, &a, &p, vec![addition.clone()])+ .await+ .unwrap_err()+ .to_string();+ assert!(+ error.contains("Amount") && error.contains("Negotiation"),+ "{error}"+ );+ write(+ &s,+ &a,+ &p,+ vec![DatabaseOp::Column {+ table: p.table_id,+ column: amount,+ change: ColumnChange::Delete,+ }],+ )+ .await+ .unwrap();+ assert!(+ s.stage_requirements(access(&a, p.id, EntityType::CrmPipeline, OWNER).await)+ .await+ .unwrap()+ .is_empty()+ );+ write(&s, &a, &p, vec![addition]).await.unwrap();+ s.set_stage_requirement(+ access(&a, p.id, EntityType::CrmPipeline, OWNER).await,+ StageRequirement {+ stage_column_id: stage,+ stage_id: won,+ required_column_ids: vec![detail.columns[2].column.id],+ },+ )+ .await+ .unwrap();+ write(+ &s,+ &a,+ &p,+ vec![DatabaseOp::Column {+ table: p.table_id,+ column: stage,+ change: ColumnChange::DeleteOption { option: won },+ }],+ )+ .await+ .unwrap();+ assert!(+ s.stage_requirements(access(&a, p.id, EntityType::CrmPipeline, OWNER).await)+ .await+ .unwrap()+ .is_empty()+ );+}++#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]+async fn requirements_refuse_foreign_columns_and_non_stage_fields(pool: PgPool) {+ let (s, _db, a, team, _) = fixture(&pool).await;+ let p = create(&s, team, PipelineRecordType::Company).await;+ let other = create(&s, team, PipelineRecordType::Company).await;+ let detail = s+ .table(access(&a, p.id, EntityType::CrmPipeline, OWNER).await)+ .await+ .unwrap();+ let stage = detail.columns[1].column.id;+ let won = OptionId::from_uuid(detail.columns[1].definition.property_options[1].id);+ for rule in [+ StageRequirement {+ stage_column_id: stage,+ stage_id: won,+ required_column_ids: vec![other.primary_column_id],+ },+ StageRequirement {+ stage_column_id: detail.columns[3].column.id,+ stage_id: won,+ required_column_ids: vec![stage],+ },+ StageRequirement {+ stage_column_id: stage,+ stage_id: OptionId::new(),+ required_column_ids: vec![detail.columns[3].column.id],+ },+ ] {+ assert!(+ s.set_stage_requirement(access(&a, p.id, EntityType::CrmPipeline, OWNER).await, rule)+ .await+ .is_err()+ );+ }+ assert!(+ s.stage_requirements(access(&a, p.id, EntityType::CrmPipeline, OWNER).await)+ .await+ .unwrap()+ .is_empty()+ );+}++#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]+async fn stage_label_case_and_duplicate_option_requests_cannot_bypass_rules(pool: PgPool) {+ let (s, _db, a, team, company) = fixture(&pool).await;+ let p = create(&s, team, PipelineRecordType::Company).await;+ let detail = s+ .table(access(&a, p.id, EntityType::CrmPipeline, OWNER).await)+ .await+ .unwrap();+ let stage = detail.columns[1].column.id;+ let option = OptionId::from_uuid(detail.columns[1].definition.property_options[1].id);+ write(+ &s,+ &a,+ &p,+ vec![DatabaseOp::Column {+ table: p.table_id,+ column: stage,+ change: ColumnChange::UpdateOption {+ option,+ label: Some("Étape".into()),+ color: None,+ },+ }],+ )+ .await+ .unwrap();+ s.set_stage_requirement(+ access(&a, p.id, EntityType::CrmPipeline, OWNER).await,+ StageRequirement {+ stage_column_id: stage,+ stage_id: option,+ required_column_ids: vec![detail.columns[3].column.id],+ },+ )+ .await+ .unwrap();+ let mut addition = insert(&p, company);+ if let DatabaseOp::Rows {+ change: RowsChange::Insert { rows },+ ..+ } = &mut addition+ {+ rows[0].push(CellWrite {+ column: stage,+ value: CellValue::Options(vec![OptionRef::Label(" ÉTAPE ".into())]),+ });+ }+ let error = write(+ &s,+ &a,+ &p,+ vec![+ DatabaseOp::Column {+ table: p.table_id,+ column: stage,+ change: ColumnChange::AddOptions {+ options: vec![NewOption {+ id: OptionId::new(),+ label: "étape".into(),+ }],+ },+ },+ addition,+ ],+ )+ .await+ .unwrap_err()+ .to_string();+ assert!(error.contains("Revenue"), "{error}");+}++#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]+async fn concurrent_stage_entry_and_required_field_clear_cannot_both_commit(pool: PgPool) {+ let (s, _db, a, team, company) = fixture(&pool).await;+ let p = create(&s, team, PipelineRecordType::Company).await;+ let detail = s+ .table(access(&a, p.id, EntityType::CrmPipeline, OWNER).await)+ .await+ .unwrap();+ let stage = detail.columns[1].column.id;+ let option = OptionId::from_uuid(detail.columns[1].definition.property_options[1].id);+ let amount = detail.columns[3].column.id;+ s.set_stage_requirement(+ access(&a, p.id, EntityType::CrmPipeline, OWNER).await,+ StageRequirement {+ stage_column_id: stage,+ stage_id: option,+ required_column_ids: vec![amount],+ },+ )+ .await+ .unwrap();+ let mut addition = insert(&p, company);+ if let DatabaseOp::Rows {+ change: RowsChange::Insert { rows },+ ..+ } = &mut addition+ {+ rows[0].push(CellWrite {+ column: amount,+ value: CellValue::Number(10.0),+ });+ }+ let row = inserted(&write(&s, &a, &p, vec![addition]).await.unwrap());+ let entering = vec![DatabaseOp::Rows {+ table: p.table_id,+ change: RowsChange::Update {+ changes: RowChanges::Uniform {+ rows: vec![row],+ cells: vec![CellWrite {+ column: stage,+ value: CellValue::Options(vec![OptionRef::Id(option)]),+ }],+ },+ },+ }];+ let clearing = vec![DatabaseOp::Rows {+ table: p.table_id,+ change: RowsChange::Update {+ changes: RowChanges::Uniform {+ rows: vec![row],+ cells: vec![CellWrite {+ column: amount,+ value: CellValue::Clear,+ }],+ },+ },+ }];+ let (entered, cleared) = tokio::join!(write(&s, &a, &p, entering), write(&s, &a, &p, clearing));+ assert_ne!(entered.is_ok(), cleared.is_ok(), "{entered:?}; {cleared:?}");+ let saved = s+ .read_rows(+ access(&a, p.id, EntityType::CrmPipeline, OWNER).await,+ &[row],+ )+ .await+ .unwrap();+ if saved[0].cells.contains_key(&stage) {+ assert_eq!(saved[0].cells[&amount], PropertyValue::Num(10.0));+ }+}++#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]+async fn contended_pipeline_guards_release_pool_connections(pool: PgPool) {+ use crm::outbound::pipelines::PipelineRepoError;+ use sqlx::postgres::PgPoolOptions;+ use std::time::Duration;++ let (service, _, _, team, _) = fixture(&pool).await;+ let pipeline = create(&service, team, PipelineRecordType::Company).await;+ let bounded = PgPoolOptions::new()+ .max_connections(2)+ .acquire_timeout(Duration::from_secs(2))+ .connect_with(pool.connect_options().as_ref().clone())+ .await+ .unwrap();+ let repo = PgPipelineRepo::new(+ bounded.clone(),+ PgCellStore::new(bounded.clone(), PropertiesPgRepo::new(bounded.clone())),+ );+ let holder = repo.lock_write(pipeline.id).await.unwrap().unwrap();++ // The waiter uses the only remaining connection. It must release that+ // connection while the holder still owns the row lock, so storage can run.+ for reader in [false, true] {+ let waiting = async {+ if reader {+ repo.lock_live(pipeline.id).await+ } else {+ repo.lock_write(pipeline.id).await+ }+ };+ let failure = tokio::time::timeout(Duration::from_secs(10), waiting)+ .await+ .expect("a queued guard must not exhaust the pool indefinitely")+ .unwrap_err();+ let PipelineRepoError::Sqlx(failure) = failure else {+ panic!("expected a PostgreSQL lock timeout");+ };+ assert_eq!(+ failure+ .as_database_error()+ .and_then(|error| error.code())+ .as_deref(),+ Some("55P03")+ );+ let connection = bounded.acquire().await.unwrap();+ drop(connection);+ }+ holder.rollback().await.unwrap();+ assert!(repo.lock_write(pipeline.id).await.unwrap().is_some());+}diff --git a/crates/macro_db_client/AGENTS.md b/crates/macro_db_client/AGENTS.mdindex 1fb57caeae..7e2bf18bb7 100644--- a/crates/macro_db_client/AGENTS.md+++ b/crates/macro_db_client/AGENTS.md@@ -112,6 +112,10 @@ The import ledger accepts Jira Cloud sources with `jira_issue`, `jira_project`and `jira_epic` kinds. Jira has its own concurrent partial team-claim index; sourceand kind constraints expand without rewriting existing rows and validate separately.+`crm_pipeline_stage_requirements` stores pipeline-owned rules keyed by stage+column, option and required column IDs. Foreign-key cascades remove rules when+any referenced stage, field or pipeline is explicitly deleted; renames preserve them.+`mcp_oauth_*` tables hold the public MCP OAuth broker's state (registrations,refresh token bindings, pending authorizations, issued codes); their queries andexpiry sweep belong to `mcp_auth_proxy`. Rows carry `expires_at` and have nodiff --git a/crates/macro_db_client/migrations/20261102203842_crm_pipeline_stage_requirements.sql b/crates/macro_db_client/migrations/20261102203842_crm_pipeline_stage_requirements.sqlnew file mode 100644index 0000000000..e913d39061--- /dev/null+++ b/crates/macro_db_client/migrations/20261102203842_crm_pipeline_stage_requirements.sql@@ -0,0 +1,12 @@+-- Requirements belong to a pipeline; names and labels remain editable.+CREATE TABLE crm_pipeline_stage_requirements (+ pipeline_id UUID NOT NULL REFERENCES crm_pipeline_entities(id) ON DELETE CASCADE,+ stage_column_id UUID NOT NULL REFERENCES database_columns(id) ON DELETE CASCADE,+ stage_id UUID NOT NULL REFERENCES property_options(id) ON DELETE CASCADE,+ required_column_id UUID NOT NULL REFERENCES database_columns(id) ON DELETE CASCADE,+ PRIMARY KEY (pipeline_id, stage_column_id, stage_id, required_column_id),+ CHECK (stage_column_id <> required_column_id)+);+CREATE INDEX ON crm_pipeline_stage_requirements (stage_column_id);+CREATE INDEX ON crm_pipeline_stage_requirements (stage_id);+CREATE INDEX ON crm_pipeline_stage_requirements (required_column_id);diff --git a/docs/agent-guide/crm.md b/docs/agent-guide/crm.mdindex 3e68d1055c..900b78cb8e 100644--- a/docs/agent-guide/crm.md+++ b/docs/agent-guide/crm.md@@ -436,7 +436,7 @@ tabs. Its header shows the name, edited in place by editors, a **Pipelineactions** menu (**Rename** and **Import CSV** for editors, **Export CSV** foranyone who can open it, **Trash pipeline** for the owner) and **Share**. Thetoolbar below has **All records**, the pipeline's stored views and **New view**-(Table or Board), plus Group by (boards), Filter and Sort, then **Add deal**+(Table, Board, or Timeline), plus Group by (boards), Filter and Sort, then **Add deal**(company pipelines) or **Add contact** (contact pipelines) for editors. It opensa dialog titled **Add deal** (or **Add contact**) with the pipeline's name in achip beside it and Close. Below the header, each field has its label stacked@@ -453,8 +453,29 @@ different company before submitting. Editing the email keeps that explicit choicFocusing the suggestion reveals its full name; Enter accepts it without submittingthe form, and closes the tooltip without a browser error.**Add deal** stays disabled until a record is chosen, and Command-Enter submits.+Use **Stage requirements** in the toolbar to choose a single-select stage field,+a stage, and the fields required to enter it. Save one stage at a time; unchecking+all fields removes that rule. Renaming a field or stage keeps the rule. Deleting+one removes its corresponding requirements. Remove requirements before changing+a referenced field's type or deleting options from a required field. Existing+deals stay in place when a rule is added;+entering that stage or editing its required fields validates the final values.++The Add deal form marks the selected stage's required fields **Required** and+names missing fields on submit. Empty text and empty selections are missing;+zero and an unchecked checkbox are valid values. The record and field edits stay+in the form after a refusal. An open form follows stage renames by identity; if+its selected stage is deleted, it asks for another value while keeping other edits.+Deleted fields leave the draft submission. Board moves, timeline group moves, table edits, agent tools and CSV imports+use the same server rule; a rejected operation batch saves none of its edits.+Verify by requiring Revenue for Negotiation, trying a move with no Revenue,+filling Revenue, then retrying; also rename the field/stage and repeat. Check the+form on desktop and mobile, including correction after a rejected submit.+The form makes one row with every value set. A board lane's **New record** opens-the same dialog with the lane's stage filled in. The table's blank row at the+the same dialog with the lane's stage filled in. A timeline's **New record here**+or range-drawing gesture also opens the form, preserving the chosen date range+and the group stage when one was selected. The table's blank row at thebottom still adds a row inline. On mobile the dialog is a bottom drawer. To verifythe person picker, choose an **Owner** in the dialog: its menu must accept theclick.@@ -485,7 +506,12 @@ pipeline columns of the same name, adding missing select options. A recordthe pipeline already had is not added again, so retrying an interrupted importadds only what is missing; several rows for one new record add separate entries(deals), as an export of such a pipeline lists them. Relation and non-person entity columns are skipped,-and a value that does not fit its column is left empty.+and a value that does not fit its column is left empty. Stage-validation refusals+are isolated to individual entries: valid rows continue importing, and the result+lists each refused entry by its import position, domain or email, and missing fields.+Use **Add deal** or **Add contact** to correct and add a refused entry, including a+second deal for a company whose valid entry was imported. Reimporting skips records+already present in the pipeline.Agent CSV imports report ambiguous contact emails as unresolved records with anactionable reason and continue the valid rows. They never create another contactdiff --git a/docs/agent-guide/databases.md b/docs/agent-guide/databases.mdindex 6973384f16..eee7c5c524 100644--- a/docs/agent-guide/databases.md+++ b/docs/agent-guide/databases.md@@ -479,6 +479,8 @@ horizontally to reach more lanes; each lane scrolls vertically on its own. A caror lane being dragged stays mounted while scrolling. After a card move, itsdestination is revealed. Starting a new card reveals the lane's draft at thebottom and focuses its title, including after the lane was offscreen.+If a move is refused, the card returns to its saved lane and order; other pending+moves stay visible until their own responses arrive.Lane headers show a color or type icon, a name, and an adjacent record count.Cards use the Tasks board's header, with wrapping titles and each configured field'sdiff --git a/packages/sdk/AGENTS.md b/packages/sdk/AGENTS.mdindex b1c5c94242..1f1abd0da5 100644--- a/packages/sdk/AGENTS.md+++ b/packages/sdk/AGENTS.md@@ -121,6 +121,9 @@ the existing gateway prefixes.that as `false`. A 204 from `GET /team` (no team) parses as an emptyobject, not `undefined`.- Keep access-request resolution snapshots: resolved requests leave pending lists.+- `CrmPipeline.stageRequirements()` and `setStageRequirements()` use pipeline+ column and option handles; `PipelineColumn.options()` supplies stable options.+ Stage requirements are enforced on every pipeline operation batch.- Pipeline schema reads share the parent's cache; successful op batches clear it.- Email sends and other writes against hosted data are real actions; use mocksfor automated SDK mutation tests.diff --git a/packages/sdk/generated/storage/index.ts b/packages/sdk/generated/storage/index.tsindex b04c8815b5..b729703d89 100644--- a/packages/sdk/generated/storage/index.ts+++ b/packages/sdk/generated/storage/index.ts@@ -1,4 +1,4 @@// This file is auto-generated by @hey-api/openapi-tsexport { type Options, Sdk } from './sdk.gen';-export type { AccentColor, AccessiblePipeline, AccessLevel, AccessRequest, AccessRequestsCancelData, AccessRequestsCancelErrors, AccessRequestsCancelResponses, AccessRequestsDirectData, AccessRequestsDirectErrors, AccessRequestsDirectResponse, AccessRequestsDirectResponses, AccessRequestsRemoveDirectData, AccessRequestsRemoveDirectErrors, AccessRequestsRemoveDirectResponses, AccessRequestsResolveData, AccessRequestsResolveErrors, AccessRequestsResolveResponse, AccessRequestsResolveResponses, AccessRequestsSetDirectData, AccessRequestsSetDirectErrors, AccessRequestsSetDirectResponses, AccessRequestsStateData, AccessRequestsStateErrors, AccessRequestsStateResponse, AccessRequestsStateResponses, AccessRequestsSubmitData, AccessRequestsSubmitErrors, AccessRequestsSubmitResponse, AccessRequestsSubmitResponses, AccessRequestState, ActiveCallsResponse, ActiveCallSummary, ActiveMeeting, ActiveMeetingsResponse, ActivityType, AddFavoriteData, AddFavoriteError, AddFavoriteErrors, AddFavoriteRequest, AddFavoriteResponse, AddFavoriteResponses, AddParticipantsData, AddParticipantsError, AddParticipantsErrors, AddParticipantsRequest, AddParticipantsResponses, AddPinHandlerData, AddPinHandlerError, AddPinHandlerErrors, AddPinHandlerResponse, AddPinHandlerResponses, AddPinRequest, Agent, AgentActionId, AgentChannelScope, AgentDmProfile, AgentMcpServer, AgentMcpServers, AgentPullRequestState, AgentSessionArchiveCause, AgentSessionFilters, AgentSessionLifecycleEvent, AgentSessionSource, AgentSessionVisibility, AgentTyping, AgentTypingPhase, AiAdmissionErrorBody, Anchor, AnchorId, AnchorResponse, AnnotationIncrementalUpdate, Answer, ApiActivity, ApiAttachmentChannelReference, ApiAttachmentCommentReference, ApiAttachmentEntityReference, ApiAttachmentGenericReference, ApiChannelAttachment, ApiChannelAttachmentsPage, ApiChannelDetail, ApiChannelListMessage, ApiChannelListPage, ApiChannelListParticipant, ApiChannelListType, ApiChannelParticipant, ApiChannelWithLatest, ApiEntityFilterAst, ApiGroupByField, ApiGroupMeta, ApiParticipantListRole, ApiParticipantRole, ApiPropertyEntityType, AppliedOps, ApplyCrmPipelineOpsData, ApplyCrmPipelineOpsResponse, ApplyCrmPipelineOpsResponses, ApplyDatabaseOpsData, ApplyDatabaseOpsError, ApplyDatabaseOpsErrors, ApplyDatabaseOpsResponse, ApplyDatabaseOpsResponses, ApplyOpsRequest, ApplyOpsResponse, ApproveHarnessPairingData, ApproveHarnessPairingError, ApproveHarnessPairingErrors, ApproveHarnessPairingResponse, ApproveHarnessPairingResponses, ApprovePairingRequest, AttachmentChange, AttendeeResponseStatus, Audience, Awareness, AwarenessRelay, BasicDocument, BasicDocumentSubType, BlockCrmDomainData, BlockCrmDomainError, BlockCrmDomainErrors, BlockCrmDomainResponse, BlockCrmDomainResponses, BomPart, BookingTarget, Bot, BotChannel, BotChannelType, BotId, BotKind, BotOwner, BotOwnerProfile, BotSenderProfile, BotToken, BranchNameResponse, BTreeMap, BulkWakeupRequest, BulkWakeupResponse, BulkWakeupSyncServiceDocumentsData, BulkWakeupSyncServiceDocumentsErrors, BulkWakeupSyncServiceDocumentsResponse, BulkWakeupSyncServiceDocumentsResponses, CalendarAttendee, CalendarEvent, CalendarEventFilters, CalendarEventSourceContent, CalendarJoinRequest, CalendarJoinRequestApiError, CalendarJoinRequestErrorCode, CalendarJoinRequestsResponse, CalendarJoinRequestStatus, CalendarMentionEvent, CalendarMentionPreviewItem, CalendarMentionPreviewKind, CalendarMentionPreviewRequest, CalendarMentionPreviewRequestItem, CalendarMentionPreviewResponse, CalendarMentionViewerCopy, CalendarOccurrence, CalendarOccurrenceItem, CalendarOccurrenceResponse, CalendarSyncStatus, CallActiveResponse, CallFilters, CallProvider, CallRecord, CallRecordGuest, CallRecordParticipant, CallRecordPreview, CallRecordPreviewData, CallRecordSource, CallRecordTranscriptSegment, CallStatus, CallTokenResponse, CallWebhookData, CallWebhookError, CallWebhookErrors, CallWebhookResponses, CancelSlackImportData, CancelSlackImportErrors, CancelSlackImportResponse, CancelSlackImportResponses, CardPosition, CastVerdict, CellValue, CellWrite, ChangedFileDto, ChangesetDto, ChangesetSourceDto, Channel, ChannelCreatedMetadata, ChannelDeletedMetadata, ChannelFilters, ChannelJoinCodeResponse, ChannelLabel, ChannelLabelRule, ChannelLabelScopeSelection, ChannelLabelsList, ChannelMessage, ChannelParticipant, ChannelParticipantAddedMetadata, ChannelParticipantRemovedMetadata, ChannelPictureChangedMetadata, ChannelPreview, ChannelPreviewData, ChannelSender, ChannelSharePermission, ChannelThreadFilters, ChannelTopicEvent, ChannelType, ChannelUpdatedMetadata, ChannelWebhookRequest, ChannelWebhookResponse, ChannelWithParticipants, Chat, ChatFilters, CheckActiveCallData, CheckActiveCallError, CheckActiveCallErrors, CheckActiveCallResponse, CheckActiveCallResponses, ClaimedPairing, ClaimHarnessPairingData, ClaimHarnessPairingError, ClaimHarnessPairingErrors, ClaimHarnessPairingResponse, ClaimHarnessPairingResponses, ClaimPairingRequest, ClientOptions, CloudStorageItemType, CollaborateFormData, CollaborateFormError, CollaborateFormErrors, CollaborateFormResponse, CollaborateFormResponses, CollabSurfaceResponse, CollabSurfaceTokenResponse, Column, ColumnCast, ColumnChange, ColumnChangeKind, ColumnConfig, ColumnConversion, ColumnConversionRequest, ColumnDetail, ColumnId, ColumnKind, ColumnProtection, ColumnResult, CommandFailure, CommandRejectedMetadata, CommittedChange, CompleteSlackImportUploadsData, CompleteSlackImportUploadsErrors, CompleteSlackImportUploadsResponse, CompleteSlackImportUploadsResponses, CompleteUploads, ConferenceProvider, Conjunction, ConversationId, ConversationKind, ConversationMetadata, ConversationProgress, ConversationSeal, ConversationStatus, ConvertDatabaseColumnData, ConvertDatabaseColumnError, ConvertDatabaseColumnErrors, ConvertDatabaseColumnResponse, ConvertDatabaseColumnResponses, ConvertedCell, CopyDocumentData, CopyDocumentError, CopyDocumentErrors, CopyDocumentQueryParams, CopyDocumentRequest, CopyDocumentResponse, CopyDocumentResponse2, CopyDocumentResponses, CountedReaction, CreateAgentData, CreateAgentError, CreateAgentErrors, CreateAgentRequest, CreateAgentResponse, CreateAgentResponses, CreateAnchorData, CreateAnchorError, CreateAnchorErrors, CreateAnchorResponse, CreateAnchorResponses, CreateBotRequest, CreateBulkDocumentResponse, CreateBulkDocumentResponseData, CreateCanvasDocumentRequest, CreateCanvasDocumentResponse, CreateCanvasHandlerData, CreateCanvasHandlerError, CreateCanvasHandlerErrors, CreateCanvasHandlerResponse, CreateCanvasHandlerResponses, CreateChannelData, CreateChannelError, CreateChannelErrors, CreateChannelLabelData, CreateChannelLabelError, CreateChannelLabelErrors, CreateChannelLabelRequest, CreateChannelLabelResponse, CreateChannelLabelResponses, CreateChannelRequest, CreateChannelResponse, CreateChannelResponse2, CreateChannelResponses, CreateChannelScopedBotData, CreateChannelScopedBotError, CreateChannelScopedBotErrors, CreateChannelScopedBotRequest, CreateChannelScopedBotResponse, CreateChannelScopedBotResponse2, CreateChannelScopedBotResponses, CreateCollabSurfaceTokenData, CreateCollabSurfaceTokenError, CreateCollabSurfaceTokenErrors, CreateCollabSurfaceTokenResponse, CreateCollabSurfaceTokenResponses, CreateCrmCompanyData, CreateCrmCompanyError, CreateCrmCompanyErrors, CreateCrmCompanyRequest, CreateCrmCompanyResponse, CreateCrmCompanyResponses, CreateCrmContactData, CreateCrmContactError, CreateCrmContactErrors, CreateCrmContactRequest, CreateCrmContactResponse, CreateCrmContactResponses, CreateCrmPipelineData, CreateCrmPipelineResponse, CreateCrmPipelineResponses, CreateCrmTeamContactData, CreateCrmTeamContactError, CreateCrmTeamContactErrors, CreateCrmTeamContactRequest, CreateCrmTeamContactResponse, CreateCrmTeamContactResponses, CreateDatabaseData, CreateDatabaseError, CreateDatabaseErrors, CreateDatabaseRequest, CreateDatabaseResponse, CreateDatabaseResponses, CreateDatabaseWebhookData, CreateDatabaseWebhookError, CreateDatabaseWebhookErrors, CreateDatabaseWebhookRequest, CreateDatabaseWebhookResponse, CreateDatabaseWebhookResponses, CreatedDatabaseWebhookResponse, CreateDocumentData, CreateDocumentError, CreateDocumentErrors, CreateDocumentRequest, CreateDocumentResponse, CreateDocumentResponseData, CreateDocumentResponses, CreatedPairing, CreatedUserApiKey, CreateEntityMentionData, CreateEntityMentionError, CreateEntityMentionErrors, CreateEntityMentionRequest, CreateEntityMentionResponse, CreateEntityMentionResponse2, CreateEntityMentionResponses, CreateForm, CreateFormData, CreateFormError, CreateFormErrors, CreateFormResponse, CreateFormResponses, CreateHarnessPairingData, CreateHarnessPairingError, CreateHarnessPairingErrors, CreateHarnessPairingResponse, CreateHarnessPairingResponses, CreateImport, CreateInitiativeData, CreateInitiativeError, CreateInitiativeErrors, CreateInitiativeRequest, CreateInitiativeResponse, CreateInitiativeResponses, CreateInstructionsDocumentResponse, CreateInstructionsHandlerData, CreateInstructionsHandlerError, CreateInstructionsHandlerErrors, CreateInstructionsHandlerResponse, CreateInstructionsHandlerResponses, CreateMarkdownDocumentRequest, CreateMarkdownDocumentResponse, CreateMarkdownHandlerData, CreateMarkdownHandlerError, CreateMarkdownHandlerErrors, CreateMarkdownHandlerResponse, CreateMarkdownHandlerResponses, CreateMeetingRequest, CreatePairingRequest, CreatePipeline, CreateProjectHandlerData, CreateProjectHandlerError, CreateProjectHandlerErrors, CreateProjectHandlerResponse, CreateProjectHandlerResponses, CreateProjectRequest, CreateProjectResponse, CreateSkillHandlerData, CreateSkillHandlerError, CreateSkillHandlerErrors, CreateSkillHandlerResponse, CreateSkillHandlerResponses, CreateSkillRequest, CreateSkillResponse, CreateSlackImportData, CreateSlackImportErrors, CreateSlackImportResponse, CreateSlackImportResponses, CreateSnippetHandlerData, CreateSnippetHandlerError, CreateSnippetHandlerErrors, CreateSnippetHandlerResponse, CreateSnippetHandlerResponses, CreateSnippetRequest, CreateSnippetResponse, CreateTaskHandlerData, CreateTaskHandlerError, CreateTaskHandlerErrors, CreateTaskHandlerResponse, CreateTaskHandlerResponses, CreateTaskRequest, CreateTaskResponse, CreateToken, CreateUnthreadedAnchorRequest, CreateUnthreadedAnchorResponse, CreateUnthreadedPdfAnchorRequest, CreateUserApiKeyData, CreateUserApiKeyError, CreateUserApiKeyErrors, CreateUserApiKeyRequest, CreateUserApiKeyResponse, CreateUserApiKeyResponses, CreateViewHandlerData, CreateViewHandlerError, CreateViewHandlerErrors, CreateViewHandlerResponse, CreateViewHandlerResponses, CreateViewRequest, CreateWebhookData, CreateWebhookError, CreateWebhookErrors, CreateWebhookRequest, CreateWebhookResponse, CreateWebhookResponse2, CreateWebhookResponses, CrmAssociation, CrmBlockedDomainResponse, CrmCompanyFilters, CrmCompanyResponse, CrmContactResponse, CrmDomainResponse, CrmPermissionRole, CrmStageInput, CrmStageResponse, CrmStagesResponse, CrmTeamSettingsResponse, CustomSpeakerAssignment, Database, DatabaseDetail, DatabaseId, DatabaseOp, DatabaseQueryRequest, DatabaseView, DatabaseWebhookDeliveryResponse, DatabaseWebhookPayloadProblem, DatabaseWebhookResponse, DataType, DateOperator, DateRange, DateRangeOperator, DeclineCallData, DeclineCallError, DeclineCallErrors, DeclineCallResponse, DeclineCallResponses, DeclineRingData, DeclineRingError, DeclineRingErrors, DeclineRingResponse, DeclineRingResponses, DeleteAnchorData, DeleteAnchorError, DeleteAnchorErrors, DeleteAnchorResponse, DeleteAnchorResponses, DeleteCallRecordData, DeleteCallRecordError, DeleteCallRecordErrors, DeleteCallRecordResponse, DeleteCallRecordResponses, DeleteChannelData, DeleteChannelError, DeleteChannelErrors, DeleteChannelLabelData, DeleteChannelLabelError, DeleteChannelLabelErrors, DeleteChannelLabelResponse, DeleteChannelLabelResponses, DeleteChannelResponse, DeleteChannelResponses, DeleteCollabSurfaceData, DeleteCollabSurfaceError, DeleteCollabSurfaceErrors, DeleteCollabSurfaceResponse, DeleteCollabSurfaceResponses, DeleteDatabaseWebhookData, DeleteDatabaseWebhookError, DeleteDatabaseWebhookErrors, DeleteDatabaseWebhookResponse, DeleteDatabaseWebhookResponses, DeleteDocumentData, DeleteDocumentError, DeleteDocumentErrors, DeleteDocumentResponse, DeleteDocumentResponses, DeleteEntityMentionData, DeleteEntityMentionError, DeleteEntityMentionErrors, DeleteEntityMentionResponse, DeleteEntityMentionResponse2, DeleteEntityMentionResponses, DeleteHarnessData, DeleteHarnessError, DeleteHarnessErrors, DeleteHarnessResponse, DeleteHarnessResponses, DeleteHistoryHandlerData, DeleteHistoryHandlerError, DeleteHistoryHandlerErrors, DeleteHistoryHandlerResponse, DeleteHistoryHandlerResponses, DeleteInitiativeData, DeleteInitiativeError, DeleteInitiativeErrors, DeleteInitiativeResponse, DeleteInitiativeResponses, DeleteProjectHandlerData, DeleteProjectHandlerError, DeleteProjectHandlerErrors, DeleteProjectHandlerResponse, DeleteProjectHandlerResponses, DeleteSelfHarnessData, DeleteSelfHarnessError, DeleteSelfHarnessErrors, DeleteSelfHarnessResponse, DeleteSelfHarnessResponses, DeleteUnthreadedAnchorRequest, DeleteUnthreadedAnchorResponse, DeleteUnthreadedPdfAnchorRequest, DeleteUserApiKeyData, DeleteUserApiKeyError, DeleteUserApiKeyErrors, DeleteUserApiKeyResponse, DeleteUserApiKeyResponses, DeleteUserDocumentViewLocationData, DeleteUserDocumentViewLocationError, DeleteUserDocumentViewLocationErrors, DeleteUserDocumentViewLocationResponse, DeleteUserDocumentViewLocationResponses, DeleteViewHandlerData, DeleteViewHandlerError, DeleteViewHandlerErrors, DeleteViewHandlerResponses, DeleteWebhookData, DeleteWebhookError, DeleteWebhookErrors, DeleteWebhookResponse, DeleteWebhookResponses, DeliverDatabaseWebhookData, DeliverDatabaseWebhookError, DeliverDatabaseWebhookErrors, DeliverDatabaseWebhookResponse, DeliverDatabaseWebhookResponses, DirectAccess, DocumentAiEdited, DocumentAiEditFailed, DocumentAiEditFailedCode, DocumentAiEditRefused, DocumentAiEditRefusedCode, DocumentAiEditRequest, DocumentBasic, DocumentContent, DocumentContentLocation, DocumentContentState, DocumentContentUploadedMetadata, DocumentCopiedMetadata, DocumentCreatedMetadata, DocumentDeletedMetadata, DocumentFilters, DocumentId, DocumentInteractionMetadata, DocumentMetadata, DocumentMetadataWithContent, DocumentPermissionsToken, DocumentPermissionsTokenRequest, DocumentPermissionsTokenResponse, DocumentPreview, DocumentPreviewData, DocumentPreviewDataSubType, DocumentPurgedMetadata, DocumentResponse, DocumentResponseMetadata, DocumentResponseMetadataWithContent, DocumentStorageServiceApiVersion, DocumentSubType, DocumentSyncContentUpdatedMetadata, DocumentSyncEditor, DocumentTeamShareResponse, DocumentTextContent, DocumentTopicEvent, DocumentUpdatedMetadata, DuplicateDatabaseData, DuplicateDatabaseError, DuplicateDatabaseErrors, DuplicateDatabaseRequest, DuplicateDatabaseResponse, DuplicateDatabaseResponses, EditAnchorData, EditAnchorError, EditAnchorErrors, EditAnchorRequest, EditAnchorResponse, EditAnchorResponse2, EditAnchorResponses, EditCallRecordData, EditCallRecordError, EditCallRecordErrors, EditCallRecordRequest, EditCallRecordResponse, EditCallRecordResponses, EditCallTranscriptData, EditCallTranscriptError, EditCallTranscriptErrors, EditCallTranscriptRequest, EditCallTranscriptResponse, EditCallTranscriptResponses, EditDocumentData, EditDocumentError, EditDocumentErrors, EditDocumentResponse, EditDocumentResponse2, EditDocumentResponses, EditDocumentServiceArgs, EditDocumentWithAiData, EditDocumentWithAiError, EditDocumentWithAiErrors, EditDocumentWithAiResponse, EditDocumentWithAiResponses, EditMyFormResponseData, EditMyFormResponseError, EditMyFormResponseErrors, EditMyFormResponseResponse, EditMyFormResponseResponses, EditPdfAnchorRequest, EditPdfPlaceableCommentAnchorRequest, EditProjectV2Data, EditProjectV2Error, EditProjectV2Errors, EditProjectV2Response, EditProjectV2Responses, EditThreadV2Data, EditThreadV2Error, EditThreadV2Errors, EditThreadV2Response, EditThreadV2Responses, EmailFilters, EmailFollowup, EmailFollowupCommand, EmailFollowupResponse, EmailReminderCondition, EmailReminderPage, EmailReminderSummary, EmptyResponse, EnsureCollabSurfaceData, EnsureCollabSurfaceError, EnsureCollabSurfaceErrors, EnsureCollabSurfaceRequest, EnsureCollabSurfaceResponse, EnsureCollabSurfaceResponses, EnsureStarterHandlerData, EnsureStarterHandlerErrors, EnsureStarterHandlerResponse, EnsureStarterHandlerResponses, EntityFilters, EntityKind, EntityMessageCreateData, EntityMessageCreateResponse, EntityMessageCreateResponses, EntityMessageDeleteMessageData, EntityMessageDeleteMessageResponse, EntityMessageDeleteMessageResponses, EntityMessageDeleteThreadData, EntityMessageDeleteThreadResponse, EntityMessageDeleteThreadResponses, EntityMessageEditData, EntityMessageEditResponse, EntityMessageEditResponses, EntityMessageGetMessageData, EntityMessageGetMessageResponse, EntityMessageGetMessageResponses, EntityMessageGetThreadData, EntityMessageGetThreadResponse, EntityMessageGetThreadResponses, EntityMessageLegacyData, EntityMessageLegacyResponse, EntityMessageLegacyResponses, EntityMessagePatchThreadData, EntityMessagePatchThreadResponse, EntityMessagePatchThreadResponses, EntityMessageReactData, EntityMessageReactResponse, EntityMessageReactResponses, EntityMessageTypingData, EntityMessageTypingResponse, EntityMessageTypingResponses, EntityPermission, EntityPermissionResponse, EntityRef, EntityReference, EntityType, ErrorResponse, EventIcsData, EventIcsErrors, EventIcsResponse, EventIcsResponses, EventReminderOverride, EventReminders, EventStatus, EventTime, EventTransparency, EventType, EventVisibility, ExcludedDefaultView, ExcludeDefaultViewHandlerData, ExcludeDefaultViewHandlerError, ExcludeDefaultViewHandlerErrors, ExcludeDefaultViewHandlerResponses, ExcludeDefaultViewRequest, ExportDocumentData, ExportDocumentError, ExportDocumentErrors, ExportDocumentResponse, ExportDocumentResponse2, ExportDocumentResponses, ExternalChatAdd, ExternalChatAddData, ExternalChatAdded, ExternalChatAddResponse, ExternalChatAddResponses, ExternalChatAttachment, ExternalChatAttachmentState, ExternalChatBackfill, ExternalChatBackfillState, ExternalChatCall, ExternalChatCallOutcome, ExternalChatCapabilities, ExternalChatCommunity, ExternalChatContactCard, ExternalChatContacts, ExternalChatData, ExternalChatDeliveryData, ExternalChatDeliveryResponse, ExternalChatDeliveryResponses, ExternalChatDeliveryState, ExternalChatDetail, ExternalChatEvent, ExternalChatKind, ExternalChatLocation, ExternalChatMediaKind, ExternalChatMediaPresentation, ExternalChatMembers, ExternalChatMention, ExternalChatMessage, ExternalChatMessageAttachments, ExternalChatMessageAttachmentsData, ExternalChatMessageAttachmentsResponse, ExternalChatMessageAttachmentsResponses, ExternalChatMessageData, ExternalChatMessageKind, ExternalChatMessageResponse, ExternalChatMessageResponses, ExternalChatMessages, ExternalChatMessagesData, ExternalChatMessagesResponse, ExternalChatMessagesResponses, ExternalChatMutation, ExternalChatParticipant, ExternalChatPermissionsData, ExternalChatPermissionsResponse, ExternalChatPermissionsResponses, ExternalChatPersonRef, ExternalChatPoll, ExternalChatPollOption, ExternalChatProvider, ExternalChatReaction, ExternalChatReadData, ExternalChatReadResponse, ExternalChatReadResponses, ExternalChatReference, ExternalChatRemoveData, ExternalChatRemoveResponse, ExternalChatRemoveResponses, ExternalChatReplyBlock, ExternalChatReplyContent, ExternalChatResponse, ExternalChatResponses, ExternalChatRichContent, ExternalChatsData, ExternalChatSendData, ExternalChatSender, ExternalChatSendErrors, ExternalChatSendProgress, ExternalChatSendReply, ExternalChatSendResponse, ExternalChatSendResponses, ExternalChatSendsData, ExternalChatSendsResponse, ExternalChatSendsResponses, ExternalChatsResponse, ExternalChatsResponses, ExternalChatSummary, ExternalChatSystemAction, ExternalChatSystemLine, ExternalChatUpdatePermissionsData, ExternalChatUpdatePermissionsResponse, ExternalChatUpdatePermissionsResponses, ExternalChatUploadData, ExternalChatUploadedAttachment, ExternalChatUploadRequest, ExternalChatUploadResponse, ExternalChatUploadResponses, Favorite, FavoriteEntityRef, FavoritesList, FileChangeKindDto, FileSystemNodeWithIds, FileType, FileTypeUpdate, FilterCondition, FilterGroup, FilterNode, FilterTest, FinalizeSlackImportData, FinalizeSlackImportErrors, FinalizeSlackImportResponse, FinalizeSlackImportResponses, FolderItem, FollowupState, ForeignEntity, ForeignEntityFilters, Form, FormAccess, FormBranding, FormCollaboration, FormDetail, FormErrorCode, FormErrorResponse, FormLayout, FormPublicationProblem, FormQuestionDetail, FormResponse, FormSection, FormSectionDetail, FormSource, FormStatus, FormTally, Formula, GenericErrorResponse, GenericResponse, GenericSuccessResponse, GetActiveCallsData, GetActiveCallsError, GetActiveCallsErrors, GetActiveCallsResponse, GetActiveCallsResponses, GetActivityData, GetActivityError, GetActivityErrors, GetActivityResponse, GetActivityResponses, GetAttachmentReferencesData, GetAttachmentReferencesError, GetAttachmentReferencesErrors, GetAttachmentReferencesResponse, GetAttachmentReferencesResponse2, GetAttachmentReferencesResponses, GetBatchCallRecordPreviewData, GetBatchCallRecordPreviewError, GetBatchCallRecordPreviewErrors, GetBatchCallRecordPreviewRequest, GetBatchCallRecordPreviewResponse, GetBatchCallRecordPreviewResponse2, GetBatchCallRecordPreviewResponses, GetBatchChannelPreviewData, GetBatchChannelPreviewError, GetBatchChannelPreviewErrors, GetBatchChannelPreviewRequest, GetBatchChannelPreviewResponse, GetBatchChannelPreviewResponse2, GetBatchChannelPreviewResponses, GetBatchPreviewHandlerData, GetBatchPreviewHandlerError, GetBatchPreviewHandlerErrors, GetBatchPreviewHandlerResponse, GetBatchPreviewHandlerResponses, GetBatchPreviewRequest, GetBatchPreviewResponse, GetBatchProjectPreviewData, GetBatchProjectPreviewError, GetBatchProjectPreviewErrors, GetBatchProjectPreviewRequest, GetBatchProjectPreviewResponse, GetBatchProjectPreviewResponse2, GetBatchProjectPreviewResponses, GetBotOwnerProfilesData, GetBotOwnerProfilesError, GetBotOwnerProfilesErrors, GetBotOwnerProfilesResponse, GetBotOwnerProfilesResponses, GetCallRecordData, GetCallRecordError, GetCallRecordErrors, GetCallRecordResponse, GetCallRecordResponses, GetChannelAttachmentsData, GetChannelAttachmentsError, GetChannelAttachmentsErrors, GetChannelAttachmentsResponse, GetChannelAttachmentsResponses, GetChannelData, GetChannelError, GetChannelErrors, GetChannelJoinLinkData, GetChannelJoinLinkError, GetChannelJoinLinkErrors, GetChannelJoinLinkResponse, GetChannelJoinLinkResponses, GetChannelParticipantsData, GetChannelParticipantsError, GetChannelParticipantsErrors, GetChannelParticipantsResponse, GetChannelParticipantsResponses, GetChannelResponse, GetChannelResponses, GetChannelsData, GetChannelsError, GetChannelsErrors, GetChannelsResponse, GetChannelsResponses, GetCollabSurfaceData, GetCollabSurfaceError, GetCollabSurfaceErrors, GetCollabSurfaceResponse, GetCollabSurfaceResponses, GetCompanyData, GetCompanyError, GetCompanyErrors, GetCompanyResponse, GetCompanyResponses, GetContactByEmailData, GetContactByEmailError, GetContactByEmailErrors, GetContactByEmailResponse, GetContactByEmailResponse2, GetContactByEmailResponses, GetContactData, GetContactError, GetContactErrors, GetContactResponse, GetContactResponses, GetCrmPipelineData, GetCrmPipelinePermissionsData, GetCrmPipelinePermissionsResponse, GetCrmPipelinePermissionsResponses, GetCrmPipelineResponse, GetCrmPipelineResponses, GetCrmPipelineRowsData, GetCrmPipelineRowsResponse, GetCrmPipelineRowsResponses, GetCrmPipelineTableData, GetCrmPipelineTableResponse, GetCrmPipelineTableResponses, GetCrmPipelineViewPositionsData, GetCrmPipelineViewPositionsResponse, GetCrmPipelineViewPositionsResponses, GetCrmTeamSettingsData, GetCrmTeamSettingsError, GetCrmTeamSettingsErrors, GetCrmTeamSettingsResponse, GetCrmTeamSettingsResponses, GetDatabaseData, GetDatabaseError, GetDatabaseErrors, GetDatabasePermissionsData, GetDatabasePermissionsError, GetDatabasePermissionsErrors, GetDatabasePermissionsResponse, GetDatabasePermissionsResponses, GetDatabaseQueryData, GetDatabaseQueryError, GetDatabaseQueryErrors, GetDatabaseQueryResponse, GetDatabaseQueryResponses, GetDatabaseResponse, GetDatabaseResponses, GetDatabaseRowHistoryData, GetDatabaseRowHistoryError, GetDatabaseRowHistoryErrors, GetDatabaseRowHistoryResponse, GetDatabaseRowHistoryResponses, GetDatabaseTableChangesData, GetDatabaseTableChangesError, GetDatabaseTableChangesErrors, GetDatabaseTableChangesResponse, GetDatabaseTableChangesResponses, GetDatabaseViewPositionsData, GetDatabaseViewPositionsError, GetDatabaseViewPositionsErrors, GetDatabaseViewPositionsResponse, GetDatabaseViewPositionsResponses, GetDocumentAnchorsData, GetDocumentAnchorsError, GetDocumentAnchorsErrors, GetDocumentAnchorsResponse, GetDocumentAnchorsResponses, GetDocumentBranchNameData, GetDocumentBranchNameError, GetDocumentBranchNameErrors, GetDocumentBranchNameResponse, GetDocumentBranchNameResponses, GetDocumentByTeamSlugData, GetDocumentByTeamSlugError, GetDocumentByTeamSlugErrors, GetDocumentByTeamSlugResponse, GetDocumentByTeamSlugResponses, GetDocumentData, GetDocumentError, GetDocumentErrors, GetDocumentGithubPullRequestsData, GetDocumentGithubPullRequestsError, GetDocumentGithubPullRequestsErrors, GetDocumentGithubPullRequestsResponse, GetDocumentGithubPullRequestsResponses, GetDocumentKeyResponse, GetDocumentKeyResponseData, GetDocumentListHandlerData, GetDocumentListHandlerError, GetDocumentListHandlerErrors, GetDocumentListHandlerResponse, GetDocumentListHandlerResponses, GetDocumentListResult, GetDocumentLocationV3Data, GetDocumentLocationV3Error, GetDocumentLocationV3Errors, GetDocumentLocationV3Response, GetDocumentLocationV3Responses, GetDocumentPermissionsResponseDataV2, GetDocumentPermissionsTokenData, GetDocumentPermissionsTokenError, GetDocumentPermissionsTokenErrors, GetDocumentPermissionsTokenResponse, GetDocumentPermissionsTokenResponses, GetDocumentPermissionsV2Data, GetDocumentPermissionsV2Error, GetDocumentPermissionsV2Errors, GetDocumentPermissionsV2Response, GetDocumentPermissionsV2Responses, GetDocumentProcessingResult, GetDocumentProcessingResultData, GetDocumentProcessingResultError, GetDocumentProcessingResultErrors, GetDocumentProcessingResultResponse, GetDocumentProcessingResultResponse2, GetDocumentProcessingResultResponses, GetDocumentResponse, GetDocumentResponse2, GetDocumentResponseData, GetDocumentResponses, GetDocumentSearchResponse, GetDocumentShortIdData, GetDocumentShortIdError, GetDocumentShortIdErrors, GetDocumentShortIdResponse, GetDocumentShortIdResponses, GetDocumentsResponse, GetDocumentTeamShareData, GetDocumentTeamShareError, GetDocumentTeamShareErrors, GetDocumentTeamShareResponse, GetDocumentTeamShareResponses, GetDocumentTextContentData, GetDocumentTextContentErrors, GetDocumentTextContentResponse, GetDocumentTextContentResponses, GetDocumentUserAccessLevelResponse, GetDocumentVersionData, GetDocumentVersionError, GetDocumentVersionErrors, GetDocumentVersionResponse, GetDocumentVersionResponses, GetDocumentViewsHandlerData, GetDocumentViewsHandlerError, GetDocumentViewsHandlerErrors, GetDocumentViewsHandlerResponse, GetDocumentViewsHandlerResponses, GetEmailFollowupData, GetEmailFollowupError, GetEmailFollowupErrors, GetEmailFollowupResponse, GetEmailFollowupResponses, GetEntityPermissionData, GetEntityPermissionErrors, GetEntityPermissionResponse, GetEntityPermissionResponses, GetForeignEntityBySourceData, GetForeignEntityBySourceError, GetForeignEntityBySourceErrors, GetForeignEntityBySourceResponse, GetForeignEntityBySourceResponses, GetForeignEntityData, GetForeignEntityError, GetForeignEntityErrors, GetForeignEntityResponse, GetForeignEntityResponses, GetFormData, GetFormError, GetFormErrors, GetFormPermissionsData, GetFormPermissionsError, GetFormPermissionsErrors, GetFormPermissionsResponse, GetFormPermissionsResponses, GetFormResponse, GetFormResponses, GetFormResponseSummaryData, GetFormResponseSummaryError, GetFormResponseSummaryErrors, GetFormResponseSummaryResponse, GetFormResponseSummaryResponses, GetFormTallyData, GetFormTallyError, GetFormTallyErrors, GetFormTallyResponse, GetFormTallyResponses, GetGithubPullRequestChangesData, GetGithubPullRequestChangesError, GetGithubPullRequestChangesErrors, GetGithubPullRequestChangesPatchData, GetGithubPullRequestChangesPatchError, GetGithubPullRequestChangesPatchErrors, GetGithubPullRequestChangesPatchResponse, GetGithubPullRequestChangesPatchResponses, GetGithubPullRequestChangesResponse, GetGithubPullRequestChangesResponses, GetGithubPullRequestData, GetGithubPullRequestError, GetGithubPullRequestErrors, GetGithubPullRequestFacetsData, GetGithubPullRequestFacetsError, GetGithubPullRequestFacetsErrors, GetGithubPullRequestFacetsResponse, GetGithubPullRequestFacetsResponses, GetGithubPullRequestResponse, GetGithubPullRequestResponses, GetGithubPullRequestTasksData, GetGithubPullRequestTasksError, GetGithubPullRequestTasksErrors, GetGithubPullRequestTasksResponse, GetGithubPullRequestTasksResponses, GetHarnessPairingData, GetHarnessPairingError, GetHarnessPairingErrors, GetHarnessPairingResponse, GetHarnessPairingResponses, GetHistoryHandlerData, GetHistoryHandlerError, GetHistoryHandlerErrors, GetHistoryHandlerResponse, GetHistoryHandlerResponses, GetInitiativeData, GetInitiativeError, GetInitiativeErrors, GetInitiativeResponse, GetInitiativeResponses, GetInstructionsDocumentResponse, GetInstructionsHandlerData, GetInstructionsHandlerError, GetInstructionsHandlerErrors, GetInstructionsHandlerResponse, GetInstructionsHandlerResponses, GetItemsSoupData, GetItemsSoupError, GetItemsSoupErrors, GetItemsSoupResponse, GetItemsSoupResponses, GetLocationHandlerData, GetLocationHandlerError, GetLocationHandlerErrors, GetLocationHandlerResponse, GetLocationHandlerResponses, GetMyFormResponseData, GetMyFormResponseError, GetMyFormResponseErrors, GetMyFormResponseResponse, GetMyFormResponseResponses, GetOrCreateAction, GetOrCreateCallData, GetOrCreateCallError, GetOrCreateCallErrors, GetOrCreateCallResponse, GetOrCreateCallResponses, GetOrCreateChannelResponse, GetOrCreateDmData, GetOrCreateDmError, GetOrCreateDmErrors, GetOrCreateDmRequest, GetOrCreateDmResponse, GetOrCreateDmResponses, GetOrCreatePrivateData, GetOrCreatePrivateError, GetOrCreatePrivateErrors, GetOrCreatePrivateRequest, GetOrCreatePrivateResponse, GetOrCreatePrivateResponses, GetPendingProjectsHandlerData, GetPendingProjectsHandlerError, GetPendingProjectsHandlerErrors, GetPendingProjectsHandlerResponse, GetPendingProjectsHandlerResponses, GetPinsHandlerData, GetPinsHandlerError, GetPinsHandlerErrors, GetPinsHandlerResponse, GetPinsHandlerResponses, GetPinsResponse, GetProjectContentHandlerData, GetProjectContentHandlerError, GetProjectContentHandlerErrors, GetProjectContentHandlerResponse, GetProjectContentHandlerResponses, GetProjectContentResponse, GetProjectHandlerData, GetProjectHandlerError, GetProjectHandlerErrors, GetProjectHandlerResponse, GetProjectHandlerResponses, GetProjectPermissionsV2Data, GetProjectPermissionsV2Error, GetProjectPermissionsV2Errors, GetProjectPermissionsV2Response, GetProjectPermissionsV2Responses, GetProjectResponse, GetProjectResponseData, GetProjectsHandlerData, GetProjectsHandlerError, GetProjectsHandlerErrors, GetProjectsHandlerResponse, GetProjectsHandlerResponses, GetProjectsResponse, GetProjectUserAccessLevelData, GetProjectUserAccessLevelError, GetProjectUserAccessLevelErrors, GetProjectUserAccessLevelResponse, GetProjectUserAccessLevelResponses, GetRingStatusData, GetRingStatusError, GetRingStatusErrors, GetRingStatusResponse, GetRingStatusResponses, GetSelfBotData, GetSelfBotError, GetSelfBotErrors, GetSelfBotResponse, GetSelfBotResponses, GetSelfHarnessData, GetSelfHarnessError, GetSelfHarnessErrors, GetSelfHarnessResponse, GetSelfHarnessResponses, GetSkillDescriptionData, GetSkillDescriptionError, GetSkillDescriptionErrors, GetSkillDescriptionResponse, GetSkillDescriptionResponses, GetSlackImportData, GetSlackImportErrors, GetSlackImportResponse, GetSlackImportResponses, GetSystemSkillsHandlerData, GetSystemSkillsHandlerError, GetSystemSkillsHandlerErrors, GetSystemSkillsHandlerResponse, GetSystemSkillsHandlerResponses, GetUserDocumentsHandlerData, GetUserDocumentsHandlerError, GetUserDocumentsHandlerErrors, GetUserDocumentsHandlerResponse, GetUserDocumentsHandlerResponses, GetUserDocumentViewLocationData, GetUserDocumentViewLocationError, GetUserDocumentViewLocationErrors, GetUserDocumentViewLocationResponse, GetUserDocumentViewLocationResponses, GetUserHistoryResponse, GetViewsHandlerData, GetViewsHandlerError, GetViewsHandlerErrors, GetViewsHandlerResponse, GetViewsHandlerResponses, GetWebhookData, GetWebhookError, GetWebhookErrors, GetWebhookResponse, GetWebhookResponses, GithubLabelFacet, GithubPullRequest, GithubPullRequestChangesPatchResponse, GithubPullRequestChangesResponse, GithubPullRequestCheckRun, GithubPullRequestComment, GithubPullRequestFacets, GithubPullRequestLabel, GithubPullRequestReview, GithubPullRequestReviewDecision, GithubPullRequestReviewState, GithubPullRequestsResponse, GithubPullRequestTasks, GithubPullRequestTasksRequest, GithubPullRequestTasksResponse, GithubPullRequestUser, GithubRepositoryFacet, GithubUserFacet, GitRefDto, GroupedInitialParams, GroupedPageParams, GroupedSoupGroupPage, GroupedSoupInitialPage, GroupedSoupPage, GroupedSoupSort, GuestCallChatPostData, GuestCallChatPostErrors, GuestCallChatPostResponse, GuestCallChatPostResponses, GuestCallChatReadData, GuestCallChatReadErrors, GuestCallChatReadResponse, GuestCallChatReadResponses, GuestChatMessage, GuestChatPage, GuestChatPost, GuestId, GuestJoinRequest, GuestPolicy, HandlerData, HandlerError, HandlerErrors, HandlerResponse, HandlerResponses, Harness, HarnessAgent, HarnessId, HarnessOwner, HarnessSession, HashMap, HealthHandlerData, HealthHandlerResponse, HealthHandlerResponses, HighlightType, ImportCounters, ImportDatabaseTableData, ImportDatabaseTableError, ImportDatabaseTableErrors, ImportDatabaseTableResponse, ImportDatabaseTableResponses, ImportedAuthor, ImportError, ImportLimits, ImportPage, ImportProgress, ImportTable, ImportWarning, InferColumnTypeOutcome, InferColumnTypeRequest, InferDatabaseColumnTypeData, InferDatabaseColumnTypeError, InferDatabaseColumnTypeErrors, InferDatabaseColumnTypeResponse, InferDatabaseColumnTypeResponses, InFlightTurnSummary, IngestTranscriptData, IngestTranscriptError, IngestTranscriptErrors, IngestTranscriptResponses, InitializeUserDocumentsData, InitializeUserDocumentsError, InitializeUserDocumentsErrors, InitializeUserDocumentsResponse, InitializeUserDocumentsResponses, InitialPropertyValue, InitiativeDetail, InitiativeFilters, InitiativeId, InitiativeList, InitiativeSummary, InputReceivedMetadata, InstallSyncData, InstallSyncErrors, InteractionReason, InvalidDatabaseWebhookPayloadResponse, InviteMeetingRequest, InviteMeetingUsersRequest, Item, ItemWithUserAccessLevel, JobId, JobProcessingResultHandlerData, JobProcessingResultHandlerError, JobProcessingResultHandlerErrors, JobProcessingResultHandlerResponse, JobProcessingResultHandlerResponses, JobStatus, JoinChannelByCodeData, JoinChannelByCodeError, JoinChannelByCodeErrors, JoinChannelByCodeResponses, JoinChannelData, JoinChannelError, JoinChannelErrors, JoinChannelResponses, KeySegment, Lane, LaneKey, LatestMessage, LayoutProblem, LeaveCallResponse, LeaveChannelData, LeaveChannelError, LeaveChannelErrors, LeaveChannelResponses, LeaveOrEndCallData, LeaveOrEndCallError, LeaveOrEndCallErrors, LeaveOrEndCallResponse, LeaveOrEndCallResponses, LinkShare, ListAccessibleFormsData, ListAccessibleFormsError, ListAccessibleFormsErrors, ListAccessibleFormsResponse, ListAccessibleFormsResponses, ListAgentsData, ListAgentsError, ListAgentsErrors, ListAgentsResponse, ListAgentsResponses, ListBotChannelsData, ListBotChannelsError, ListBotChannelsErrors, ListBotChannelsResponse, ListBotChannelsResponses, ListChannelLabelsData, ListChannelLabelsError, ListChannelLabelsErrors, ListChannelLabelsResponse, ListChannelLabelsResponses, ListCompanyContactsData, ListCompanyContactsError, ListCompanyContactsErrors, ListCompanyContactsResponse, ListCompanyContactsResponses, ListCrmBlockedDomainsData, ListCrmBlockedDomainsError, ListCrmBlockedDomainsErrors, ListCrmBlockedDomainsResponse, ListCrmBlockedDomainsResponses, ListCrmPipelinesData, ListCrmPipelinesResponse, ListCrmPipelinesResponses, ListDatabaseColumnCastsData, ListDatabaseColumnCastsError, ListDatabaseColumnCastsErrors, ListDatabaseColumnCastsResponse, ListDatabaseColumnCastsResponses, ListDatabasesData, ListDatabasesError, ListDatabasesErrors, ListDatabasesResponse, ListDatabasesResponses, ListDatabaseWebhooksData, ListDatabaseWebhooksError, ListDatabaseWebhooksErrors, ListDatabaseWebhooksResponse, ListDatabaseWebhooksResponse2, ListDatabaseWebhooksResponses, ListedDatabase, ListedForm, ListEmailRemindersData, ListEmailRemindersError, ListEmailRemindersErrors, ListEmailRemindersResponse, ListEmailRemindersResponses, ListFavoritesData, ListFavoritesError, ListFavoritesErrors, ListFavoritesResponse, ListFavoritesResponses, ListFormsData, ListFormsError, ListFormsErrors, ListFormsResponse, ListFormsResponses, ListHarnessAgentsData, ListHarnessAgentsError, ListHarnessAgentsErrors, ListHarnessAgentsResponse, ListHarnessAgentsResponses, ListHarnessesData, ListHarnessesError, ListHarnessesErrors, ListHarnessesResponse, ListHarnessesResponses, ListHarnessSessionsData, ListHarnessSessionsError, ListHarnessSessionsErrors, ListHarnessSessionsResponse, ListHarnessSessionsResponses, ListInitiativesData, ListInitiativesError, ListInitiativesErrors, ListInitiativesResponse, ListInitiativesResponses, ListJoinRequestsData, ListJoinRequestsError, ListJoinRequestsErrors, ListJoinRequestsResponse, ListJoinRequestsResponses, ListOccurrencesData, ListOccurrencesErrors, ListOccurrencesResponse, ListOccurrencesResponses, ListSlackImportsData, ListSlackImportsResponse, ListSlackImportsResponses, ListTeamCalendarData, ListTeamCalendarResponse, ListTeamCalendarResponses, ListTeamOutOfOfficeData, ListTeamOutOfOfficeErrors, ListTeamOutOfOfficeResponse, ListTeamOutOfOfficeResponses, ListUserApiKeysData, ListUserApiKeysError, ListUserApiKeysErrors, ListUserApiKeysResponse, ListUserApiKeysResponses, ListWebhooksData, ListWebhooksError, ListWebhooksErrors, ListWebhooksResponse, ListWebhooksResponse2, ListWebhooksResponses, LocationResponseData, LocationResponseV3, MacroUserIdStr, MarkRead, Meeting, MeetingCancelData, MeetingCancelError, MeetingCancelErrors, MeetingCancelPreparationData, MeetingCancelPreparationError, MeetingCancelPreparationErrors, MeetingCancelPreparationResponse, MeetingCancelPreparationResponses, MeetingCancelResponse, MeetingCancelResponses, MeetingCreateData, MeetingCreateError, MeetingCreateErrors, MeetingCreateResponse, MeetingCreateResponses, MeetingGuestJoinData, MeetingGuestJoinError, MeetingGuestJoinErrors, MeetingGuestJoinResponse, MeetingGuestJoinResponses, MeetingGuestParticipantsData, MeetingGuestParticipantsError, MeetingGuestParticipantsErrors, MeetingGuestParticipantsResponse, MeetingGuestParticipantsResponses, MeetingInviteData, MeetingInviteError, MeetingInviteErrors, MeetingInvitePermissions, MeetingInvitePermissionsData, MeetingInvitePermissionsError, MeetingInvitePermissionsErrors, MeetingInvitePermissionsResponse, MeetingInvitePermissionsResponses, MeetingInviteResponse, MeetingInviteResponses, MeetingInviteUsersData, MeetingInviteUsersError, MeetingInviteUsersErrors, MeetingInviteUsersResponse, MeetingInviteUsersResponses, MeetingJoinData, MeetingJoinError, MeetingJoinErrors, MeetingJoinResponse, MeetingJoinResponses, MeetingLeaveData, MeetingLeaveError, MeetingLeaveErrors, MeetingLeaveResponse, MeetingLeaveResponses, MeetingListActiveData, MeetingListActiveError, MeetingListActiveErrors, MeetingListActiveResponse, MeetingListActiveResponses, MeetingListData, MeetingListError, MeetingListErrors, MeetingListResponse, MeetingListResponses, MeetingLookupData, MeetingLookupError, MeetingLookupErrors, MeetingLookupResponse, MeetingLookupResponses, MeetingParticipant, MeetingParticipants, MeetingParticipantsData, MeetingParticipantsError, MeetingParticipantsErrors, MeetingParticipantsResponse, MeetingParticipantsResponses, MeetingPreparation, MeetingPrepareData, MeetingPrepareError, MeetingPrepareErrors, MeetingPrepareResponse, MeetingPrepareResponses, MeetingShareData, MeetingShareError, MeetingShareErrors, MeetingShareResponse, MeetingShareResponses, MeetingsResponse, MeetingToken, MeetingUpdateData, MeetingUpdateError, MeetingUpdateErrors, MeetingUpdateResponse, MeetingUpdateResponses, MentionPreviewsData, MentionPreviewsErrors, MentionPreviewsResponse, MentionPreviewsResponses, Message, MessageAttachment, MessageAttachmentCreatedMetadata, MessageAttachmentRemovedMetadata, MessageChange, MessageCursor, MessageDeletedMetadata, MessageDirection, MessageEvent, MessageEventAttachment, MessageListItem, MessageMentionedMetadata, MessagePage, MessageParent, MessagePatch, MessagePatchedMetadata, MessagePostedMetadata, MessageThread, MessageThreadPreview, MessageTimelineData, MessageTimelineEntriesData, MessageTimelineEntriesResponse, MessageTimelineEntriesResponses, MessageTimelineEntry, MessageTimelinePage, MessageTimelineQuery, MessageTimelineResponse, MessageTimelineResponses, MessageTopicEvent, MyResponse, NewAttachment, NewColumn, NewOption, NewThreadAnchor, NewView, NotificationFilters, NotificationState, NumberOperator, OpBatch, Operator, OpRefusalResponse, OpResult, OptionId, OptionRef, PairingDetails, Params, ParticipantRole, PatchBotRequest, PatchChannelData, PatchChannelError, PatchChannelErrors, PatchChannelRequest, PatchChannelResponse, PatchChannelResponses, PatchMessageNotificationPolicy, PatchProjectRequestV2, PatchThreadRequestV2, PatchViewHandlerData, PatchViewHandlerError, PatchViewHandlerErrors, PatchViewHandlerResponses, PatchWebhookData, PatchWebhookError, PatchWebhookErrors, PatchWebhookRequest, PatchWebhookResponse, PatchWebhookResponses, PdfAnchor, PdfAnchorId, PdfHighlightAnchor, PdfHighlightAnchorRequest, PdfHighlightRect, PdfHighlightRectAnchorRequest, PdfPlaceableCommentAnchor, PendingClaimResponse, PermanentlyDeleteDocumentData, PermanentlyDeleteDocumentError, PermanentlyDeleteDocumentErrors, PermanentlyDeleteDocumentResponse, PermanentlyDeleteDocumentResponses, PermanentlyDeleteProjectData, PermanentlyDeleteProjectError, PermanentlyDeleteProjectErrors, PermanentlyDeleteProjectResponse, PermanentlyDeleteProjectResponses, PinnedItem, PinRequest, Pipeline, PipelineRecordType, PipelineSharing, PostActivityData, PostActivityError, PostActivityErrors, PostActivityRequest, PostActivityResponse, PostActivityResponses, PostChannelBotWebhookData, PostChannelBotWebhookError, PostChannelBotWebhookErrors, PostChannelBotWebhookResponse, PostChannelBotWebhookResponses, PostGroupedSoupAstGroupPageRequest, PostGroupedSoupAstInitialRequest, PostGroupedSoupAstRequest, PostItemsSoupAstData, PostItemsSoupAstError, PostItemsSoupAstErrors, PostItemsSoupAstGroupedData, PostItemsSoupAstGroupedError, PostItemsSoupAstGroupedErrors, PostItemsSoupAstGroupedResponse, PostItemsSoupAstGroupedResponses, PostItemsSoupAstResponse, PostItemsSoupAstResponses, PostItemsSoupData, PostItemsSoupError, PostItemsSoupErrors, PostItemsSoupResponse, PostItemsSoupResponses, PostMessage, PostMessageNotificationPolicy, PostSoupAstRequest, PostSoupRequest, PresaveDocumentHandlerData, PresaveDocumentHandlerError, PresaveDocumentHandlerErrors, PresaveDocumentHandlerResponse, PresaveDocumentHandlerResponses, PreSaveDocumentRequest, PreSaveDocumentResponse, PreSaveDocumentResponseData, PresenceOperator, PresignedUrl, PreviewSmartTagData, PreviewSmartTagError, PreviewSmartTagErrors, PreviewSmartTagResponse, PreviewSmartTagResponses, Project, ProjectDeleteResponseData, ProjectDocumentStatus, ProjectFilters, ProjectPreview, ProjectPreviewData, PropertyBucketing, PropertyDateFilterRange, PropertyDateRange, PropertyDateRanges, PropertyDefinition, PropertyDefinitionWithOptions, PropertyFilter, PropertyInput, PropertyOption, PropertyOptionValue, PropertyOwner, PropertyValue, PutCrmTeamSettingsData, PutCrmTeamSettingsError, PutCrmTeamSettingsErrors, PutCrmTeamSettingsResponse, PutCrmTeamSettingsResponses, PutCrmTeamStagesData, PutCrmTeamStagesError, PutCrmTeamStagesErrors, PutCrmTeamStagesResponse, PutCrmTeamStagesResponses, PutFormLayoutData, PutFormLayoutError, PutFormLayoutErrors, PutFormLayoutResponse, PutFormLayoutResponses, QueryCrmPipelineRowsData, QueryCrmPipelineRowsResponse, QueryCrmPipelineRowsResponses, QueryDatabasesData, QueryDatabasesError, QueryDatabasesErrors, QueryDatabasesResponse, QueryDatabasesResponses, QueryDefinition, QuestionLayout, QuestionOption, QuestionTally, ReactionInput, RecentlyDeletedData, RecentlyDeletedError, RecentlyDeletedErrors, RecentlyDeletedResponse, RecentlyDeletedResponseData, RecentlyDeletedResponses, RegisterSlackImportUploadsData, RegisterSlackImportUploadsErrors, RegisterSlackImportUploadsResponse, RegisterSlackImportUploadsResponses, RegisterUploads, RemoveBotFromChannelByBotData, RemoveBotFromChannelByBotError, RemoveBotFromChannelByBotErrors, RemoveBotFromChannelByBotResponse, RemoveBotFromChannelByBotResponses, RemoveFavoriteByEntityData, RemoveFavoriteByEntityError, RemoveFavoriteByEntityErrors, RemoveFavoriteByEntityResponses, RemoveParticipantsData, RemoveParticipantsError, RemoveParticipantsErrors, RemoveParticipantsRequest, RemoveParticipantsResponses, RemovePinHandlerData, RemovePinHandlerError, RemovePinHandlerErrors, RemovePinHandlerResponse, RemovePinHandlerResponses, RenameChannelLabelData, RenameChannelLabelError, RenameChannelLabelErrors, RenameChannelLabelRequest, RenameChannelLabelResponse, RenameChannelLabelResponses, RenameCrmPipelineData, RenameCrmPipelineResponse, RenameCrmPipelineResponses, RenamePipeline, ReorderFavoritesData, ReorderFavoritesError, ReorderFavoritesErrors, ReorderFavoritesRequest, ReorderFavoritesResponses, ReorderPinRequest, ReorderPinsHandlerData, ReorderPinsHandlerError, ReorderPinsHandlerErrors, ReorderPinsHandlerResponse, ReorderPinsHandlerResponses, ReplaceCrmStagesRequest, RequestAccess, RequestedHarnessScope, RequestedLayout, RequestStatus, RequestToJoinData, RequestToJoinError, RequestToJoinErrors, RequestToJoinResponse, RequestToJoinResponses, ResetCrmTeamStagesData, ResetCrmTeamStagesError, ResetCrmTeamStagesErrors, ResetCrmTeamStagesResponse, ResetCrmTeamStagesResponses, ResolveRequest, ResponseStatus, ResponseSummary, ResultColumn, ResultSet, RevertDeleteDocumentData, RevertDeleteDocumentError, RevertDeleteDocumentErrors, RevertDeleteDocumentResponse, RevertDeleteDocumentResponses, RevertDeleteProjectData, RevertDeleteProjectError, RevertDeleteProjectErrors, RevertDeleteProjectResponse, RevertDeleteProjectResponses, RingStatus, RingStatusResponse, RowChange, RowChangeKind, RowChanges, RowHistoryEntry, RowHistoryResponse, RowId, RowsChange, RowsResult, S3ObjectInfo, SaveBomPart, SaveDatabaseQueryData, SaveDatabaseQueryError, SaveDatabaseQueryErrors, SaveDatabaseQueryResponse, SaveDatabaseQueryResponses, SaveDocumentHandlerData, SaveDocumentHandlerError, SaveDocumentHandlerErrors, SaveDocumentHandlerResponse, SaveDocumentHandlerResponses, SaveDocumentRequest, SaveDocumentResponse, SaveDocumentResponseData, SavedQuery, SaveQueryRequest, SearchContactsData, SearchContactsError, SearchContactsErrors, SearchContactsResponse, SearchContactsResponse2, SearchContactsResponses, SearchState, SectionCount, SessionDeletedMetadata, SessionIdentity, SessionMentionedMetadata, SessionOpenedMetadata, SessionRenamedMetadata, SessionSettledMetadata, SessionSource, SessionStoppedMetadata, SetChannelLabelData, SetChannelLabelError, SetChannelLabelErrors, SetChannelLabelRequest, SetChannelLabelResponse, SetChannelLabelResponses, SetChannelPictureData, SetChannelPictureError, SetChannelPictureErrors, SetChannelPictureRequest, SetChannelPictureResponse, SetChannelPictureResponses, SetCompanyHiddenData, SetCompanyHiddenError, SetCompanyHiddenErrors, SetCompanyHiddenRequest, SetCompanyHiddenResponse, SetCompanyHiddenResponses, SetCompanyNameRequest, SetContactHiddenData, SetContactHiddenError, SetContactHiddenErrors, SetContactHiddenRequest, SetContactHiddenResponse, SetContactHiddenResponses, SetContactNameRequest, SetCrmCompanyNameData, SetCrmCompanyNameError, SetCrmCompanyNameErrors, SetCrmCompanyNameResponse, SetCrmCompanyNameResponses, SetCrmContactNameData, SetCrmContactNameError, SetCrmContactNameErrors, SetCrmContactNameResponse, SetCrmContactNameResponses, SetDirectAccess, SetDocumentTeamShareData, SetDocumentTeamShareError, SetDocumentTeamShareErrors, SetDocumentTeamShareRequest, SetDocumentTeamShareResponse, SetDocumentTeamShareResponses, SetEmailFollowupData, SetEmailFollowupError, SetEmailFollowupErrors, SetEmailFollowupResponse, SetEmailFollowupResponses, SetEmailSyncData, SetEmailSyncError, SetEmailSyncErrors, SetEmailSyncRequest, SetEmailSyncResponse, SetEmailSyncResponses, SetOperator, SetPropertyValue, SetSkillDescriptionData, SetSkillDescriptionError, SetSkillDescriptionErrors, SetSkillDescriptionRequest, SetSkillDescriptionResponse, SetSkillDescriptionResponses, Sha256Digest, ShareCrmPipelineData, ShareCrmPipelineResponse, ShareCrmPipelineResponses, ShareDatabaseAwarenessData, ShareDatabaseAwarenessError, ShareDatabaseAwarenessErrors, ShareDatabaseAwarenessResponse, ShareDatabaseAwarenessResponses, SharedEmailFilter, SharedExternalChatReference, ShareEntity, ShareEntityType, SharePermissionV2, SharePipeline, ShortIdResponse, SimpleMention, SimpleSaveData, SimpleSaveError, SimpleSaveErrors, SimpleSaveResponse, SimpleSaveResponses, SkillDescriptionBody, SkippedCell, SlackCompleteRequest, SlackCreateRequest, SlackRegisterRequest, SlackTimestamp, SlackUserId, SmartTagChannelMatch, SmartTagPreview, SortDirection, SortKey, SoupAgentSessionSoupPropertiesField, SoupApiItem, SoupApiSort, SoupApiSortDirection, SoupAttachment, SoupCalendarEventSoupPropertiesField, SoupCalendarEventTime, SoupCallRecordGuest, SoupCallRecordParticipant, SoupCallRecordSoupPropertiesField, SoupChannel, SoupChannelThread, SoupChatSoupPropertiesField, SoupContact, SoupCountedReaction, SoupCrmCompanySoupPropertiesField, SoupCrmContactSoupPropertiesField, SoupCrmDomain, SoupDatabaseRowSoupPropertiesField, SoupDocumentSoupPropertiesField, SoupDocumentSubType, SoupEmailThreadPreview, SoupEnrichedEmailThreadPreviewSoupPropertiesField, SoupForeignEntity, SoupInitiativeSoupPropertiesField, SoupItem, SoupLabel, SoupLabelListVisibility, SoupLabelType, SoupMessageAttachment, SoupMessageListVisibility, SoupMessageSender, SoupMessageSenderType, SoupPage, SoupProjectSoupPropertiesField, SoupPropertiesField, SoupProperty, SoupThreadInfo, SoupThreadReply, SourceBinding, SourceId, SourceIdentity, SqlCell, SqlEntityKind, SqlOutcome, SqlOutcomeKind, SqlSelectOption, SqlStatement, StarterDatabase, StarterDocumentsResponse, StorageRow, StorageRows, StorageRowsQuery, StoredGithubPullRequest, StreamEventsData, StreamEventsError, StreamEventsErrors, StreamEventsResponse, StreamEventsResponses, String, Submission, SubmissionOutcome, SubmitFormResponseData, SubmitFormResponseError, SubmitFormResponseErrors, SubmitFormResponseResponse, SubmitFormResponseResponses, SuccessResponse, SurfaceState, SyncServiceVersionId, SystemSkillSummary, Table, TableChange, TableChanged, TableChanges, TableDetail, TableId, TableResult, TableVersion, TagFilterMode, TakenId, TallyBucket, TallyValue, TaskFilters, TaskSimilarityResult, TaskSimilaritySearchHandlerData, TaskSimilaritySearchHandlerError, TaskSimilaritySearchHandlerErrors, TaskSimilaritySearchHandlerResponse, TaskSimilaritySearchHandlerResponses, TaskSimilaritySearchRequest, TaskSimilaritySearchResponse, TeamCalendarContent, TeamCalendarCoverage, TeamCalendarDetails, TeamCalendarItem, TeamCalendarMember, TeamCalendarPage, TeamCalendarSharing, TeamOutOfOfficeItem, TeamOutOfOfficeResponse, TeamRole, TextOperator, ThreadAnchor, ThreadOrigin, ThreadPatch, ThreadState, TimelineActivity, ToggleShareWithTeamData, ToggleShareWithTeamError, ToggleShareWithTeamErrors, ToggleShareWithTeamResponse, ToggleShareWithTeamResponses, TouchedColumn, TouchedRow, TranscribeDictationData, TranscribeDictationError, TranscribeDictationErrors, TranscribeDictationResponse, TranscribeDictationResponses, TranscribeResponse, TranscriptSegmentRequest, TrashCrmPipelineData, TrashCrmPipelineResponse, TrashCrmPipelineResponses, TrashPipeline, TurnEndedMetadata, TurnStartedMetadata, TurnSummary, TypedSuccessResponse, TypedSuccessResponseGetDocumentResponseData, TypingInput, UnblockCrmDomainData, UnblockCrmDomainError, UnblockCrmDomainErrors, UnblockCrmDomainResponse, UnblockCrmDomainResponses, UndoChangeResponse, UndoDatabaseChangeData, UndoDatabaseChangeError, UndoDatabaseChangeErrors, UndoDatabaseChangeResponse, UndoDatabaseChangeResponses, UndoOutcome, UndoRefusal, UnlockedBooking, UpdateAgentData, UpdateAgentError, UpdateAgentErrors, UpdateAgentRequest, UpdateAgentResponse, UpdateAgentResponses, UpdateChannelSharePermission, UpdateCrmPipelinePermissionsData, UpdateCrmPipelinePermissionsResponse, UpdateCrmPipelinePermissionsResponses, UpdateCrmTeamSettingsRequest, UpdateDatabasePermissionsData, UpdateDatabasePermissionsError, UpdateDatabasePermissionsErrors, UpdateDatabasePermissionsResponse, UpdateDatabasePermissionsResponses, UpdateForm, UpdateFormData, UpdateFormError, UpdateFormErrors, UpdateFormPermissionsData, UpdateFormPermissionsError, UpdateFormPermissionsErrors, UpdateFormPermissionsResponse, UpdateFormPermissionsResponses, UpdateFormResponse, UpdateFormResponses, UpdateInitiativeData, UpdateInitiativeError, UpdateInitiativeErrors, UpdateInitiativeRequest, UpdateInitiativeResponse, UpdateInitiativeResponses, UpdateMeetingRequest, UpdateOperation, UpdateSharePermissionRequestV2, UploadDescriptor, UploadDocumentStatus, UploadExtractFolderHandlerData, UploadExtractFolderHandlerError, UploadExtractFolderHandlerErrors, UploadExtractFolderHandlerResponse, UploadExtractFolderHandlerResponses, UploadExtractFolderRequest, UploadFolderHandlerData, UploadFolderHandlerError, UploadFolderHandlerErrors, UploadFolderHandlerResponse, UploadFolderHandlerResponses, UploadFolderRequest, UploadGrant, UploadId, UpsertHistoryHandlerData, UpsertHistoryHandlerError, UpsertHistoryHandlerErrors, UpsertHistoryHandlerResponse, UpsertHistoryHandlerResponses, UpsertUserDocumentViewLocationData, UpsertUserDocumentViewLocationError, UpsertUserDocumentViewLocationErrors, UpsertUserDocumentViewLocationRequest, UpsertUserDocumentViewLocationResponse, UpsertUserDocumentViewLocationResponses, UserApiKeyId, UserApiKeyInfo, UserApiKeysList, UserDocumentsResponse, UserDocumentViewLocation, UserDocumentViewLocationResponse, UserPinsResponse, UserViewsResponse, ValidateDocumentPermissionsTokenData, ValidateDocumentPermissionsTokenError, ValidateDocumentPermissionsTokenErrors, ValidateDocumentPermissionsTokenResponse, ValidateDocumentPermissionsTokenResponses, ValidateWebhookData, ValidateWebhookError, ValidateWebhookErrors, ValidateWebhookResponse, ValidateWebhookResponse2, ValidateWebhookResponses, Vec, VersionedTable, View, ViewChange, ViewColumn, ViewerCapabilities, ViewLayout, ViewPatch, ViewPosition, ViewPositionsResponse, ViewQuery, ViewResult, ViewsResponse, WaitingForInputMetadata, Webhook, WebhookEvent, WebhookFilter, WebhookScope, WebhookStatus, WebhookValidationTestEvent, WhatsAppAccount, WhatsappAccountData, WhatsappAccountResponse, WhatsappAccountResponses, WhatsAppAccountState, WhatsAppAccountView, WhatsappCancelPairingData, WhatsappCancelPairingResponse, WhatsappCancelPairingResponses, WhatsAppCannotAdd, WhatsAppChat, WhatsAppChats, WhatsappChatsData, WhatsappChatsResponse, WhatsappChatsResponses, WhatsAppConnect, WhatsappConnectData, WhatsappConnectResponse, WhatsappConnectResponses, WhatsAppDisconnect, WhatsappDisconnectData, WhatsAppDisconnectRequest, WhatsappDisconnectResponse, WhatsappDisconnectResponses, WhatsAppHistoryImport, WhatsappImportHistoryData, WhatsappImportHistoryResponse, WhatsappImportHistoryResponses, WhatsAppLookup, WhatsappLookupData, WhatsAppLookupRequest, WhatsappLookupResponse, WhatsappLookupResponses, WhatsAppLookupState, WhatsAppPairing, WhatsappPairingData, WhatsappPairingResponse, WhatsappPairingResponses, WhatsAppPairingState, WhatsAppPairState, WhatsappPasskeyData, WhatsappPasskeyResponse, WhatsappPasskeyResponses, WhatsappStartLookupData, WhatsappStartLookupResponse, WhatsappStartLookupResponses, Widget, WithCallId, WithChannelId, WithDocumentId, WithProjectId } from './types.gen';+export type { AccentColor, AccessiblePipeline, AccessLevel, AccessRequest, AccessRequestsCancelData, AccessRequestsCancelErrors, AccessRequestsCancelResponses, AccessRequestsDirectData, AccessRequestsDirectErrors, AccessRequestsDirectResponse, AccessRequestsDirectResponses, AccessRequestsRemoveDirectData, AccessRequestsRemoveDirectErrors, AccessRequestsRemoveDirectResponses, AccessRequestsResolveData, AccessRequestsResolveErrors, AccessRequestsResolveResponse, AccessRequestsResolveResponses, AccessRequestsSetDirectData, AccessRequestsSetDirectErrors, AccessRequestsSetDirectResponses, AccessRequestsStateData, AccessRequestsStateErrors, AccessRequestsStateResponse, AccessRequestsStateResponses, AccessRequestsSubmitData, AccessRequestsSubmitErrors, AccessRequestsSubmitResponse, AccessRequestsSubmitResponses, AccessRequestState, ActiveCallsResponse, ActiveCallSummary, ActiveMeeting, ActiveMeetingsResponse, ActivityType, AddFavoriteData, AddFavoriteError, AddFavoriteErrors, AddFavoriteRequest, AddFavoriteResponse, AddFavoriteResponses, AddParticipantsData, AddParticipantsError, AddParticipantsErrors, AddParticipantsRequest, AddParticipantsResponses, AddPinHandlerData, AddPinHandlerError, AddPinHandlerErrors, AddPinHandlerResponse, AddPinHandlerResponses, AddPinRequest, Agent, AgentActionId, AgentChannelScope, AgentDmProfile, AgentMcpServer, AgentMcpServers, AgentPullRequestState, AgentSessionArchiveCause, AgentSessionFilters, AgentSessionLifecycleEvent, AgentSessionSource, AgentSessionVisibility, AgentTyping, AgentTypingPhase, AiAdmissionErrorBody, Anchor, AnchorId, AnchorResponse, AnnotationIncrementalUpdate, Answer, ApiActivity, ApiAttachmentChannelReference, ApiAttachmentCommentReference, ApiAttachmentEntityReference, ApiAttachmentGenericReference, ApiChannelAttachment, ApiChannelAttachmentsPage, ApiChannelDetail, ApiChannelListMessage, ApiChannelListPage, ApiChannelListParticipant, ApiChannelListType, ApiChannelParticipant, ApiChannelWithLatest, ApiEntityFilterAst, ApiGroupByField, ApiGroupMeta, ApiParticipantListRole, ApiParticipantRole, ApiPropertyEntityType, AppliedOps, ApplyCrmPipelineOpsData, ApplyCrmPipelineOpsResponse, ApplyCrmPipelineOpsResponses, ApplyDatabaseOpsData, ApplyDatabaseOpsError, ApplyDatabaseOpsErrors, ApplyDatabaseOpsResponse, ApplyDatabaseOpsResponses, ApplyOpsRequest, ApplyOpsResponse, ApproveHarnessPairingData, ApproveHarnessPairingError, ApproveHarnessPairingErrors, ApproveHarnessPairingResponse, ApproveHarnessPairingResponses, ApprovePairingRequest, AttachmentChange, AttendeeResponseStatus, Audience, Awareness, AwarenessRelay, BasicDocument, BasicDocumentSubType, BlockCrmDomainData, BlockCrmDomainError, BlockCrmDomainErrors, BlockCrmDomainResponse, BlockCrmDomainResponses, BomPart, BookingTarget, Bot, BotChannel, BotChannelType, BotId, BotKind, BotOwner, BotOwnerProfile, BotSenderProfile, BotToken, BranchNameResponse, BTreeMap, BulkWakeupRequest, BulkWakeupResponse, BulkWakeupSyncServiceDocumentsData, BulkWakeupSyncServiceDocumentsErrors, BulkWakeupSyncServiceDocumentsResponse, BulkWakeupSyncServiceDocumentsResponses, CalendarAttendee, CalendarEvent, CalendarEventFilters, CalendarEventSourceContent, CalendarJoinRequest, CalendarJoinRequestApiError, CalendarJoinRequestErrorCode, CalendarJoinRequestsResponse, CalendarJoinRequestStatus, CalendarMentionEvent, CalendarMentionPreviewItem, CalendarMentionPreviewKind, CalendarMentionPreviewRequest, CalendarMentionPreviewRequestItem, CalendarMentionPreviewResponse, CalendarMentionViewerCopy, CalendarOccurrence, CalendarOccurrenceItem, CalendarOccurrenceResponse, CalendarSyncStatus, CallActiveResponse, CallFilters, CallProvider, CallRecord, CallRecordGuest, CallRecordParticipant, CallRecordPreview, CallRecordPreviewData, CallRecordSource, CallRecordTranscriptSegment, CallStatus, CallTokenResponse, CallWebhookData, CallWebhookError, CallWebhookErrors, CallWebhookResponses, CancelSlackImportData, CancelSlackImportErrors, CancelSlackImportResponse, CancelSlackImportResponses, CardPosition, CastVerdict, CellValue, CellWrite, ChangedFileDto, ChangesetDto, ChangesetSourceDto, Channel, ChannelCreatedMetadata, ChannelDeletedMetadata, ChannelFilters, ChannelJoinCodeResponse, ChannelLabel, ChannelLabelRule, ChannelLabelScopeSelection, ChannelLabelsList, ChannelMessage, ChannelParticipant, ChannelParticipantAddedMetadata, ChannelParticipantRemovedMetadata, ChannelPictureChangedMetadata, ChannelPreview, ChannelPreviewData, ChannelSender, ChannelSharePermission, ChannelThreadFilters, ChannelTopicEvent, ChannelType, ChannelUpdatedMetadata, ChannelWebhookRequest, ChannelWebhookResponse, ChannelWithParticipants, Chat, ChatFilters, CheckActiveCallData, CheckActiveCallError, CheckActiveCallErrors, CheckActiveCallResponse, CheckActiveCallResponses, ClaimedPairing, ClaimHarnessPairingData, ClaimHarnessPairingError, ClaimHarnessPairingErrors, ClaimHarnessPairingResponse, ClaimHarnessPairingResponses, ClaimPairingRequest, ClientOptions, CloudStorageItemType, CollaborateFormData, CollaborateFormError, CollaborateFormErrors, CollaborateFormResponse, CollaborateFormResponses, CollabSurfaceResponse, CollabSurfaceTokenResponse, Column, ColumnCast, ColumnChange, ColumnChangeKind, ColumnConfig, ColumnConversion, ColumnConversionRequest, ColumnDetail, ColumnId, ColumnKind, ColumnProtection, ColumnResult, CommandFailure, CommandRejectedMetadata, CommittedChange, CompleteSlackImportUploadsData, CompleteSlackImportUploadsErrors, CompleteSlackImportUploadsResponse, CompleteSlackImportUploadsResponses, CompleteUploads, ConferenceProvider, Conjunction, ConversationId, ConversationKind, ConversationMetadata, ConversationProgress, ConversationSeal, ConversationStatus, ConvertDatabaseColumnData, ConvertDatabaseColumnError, ConvertDatabaseColumnErrors, ConvertDatabaseColumnResponse, ConvertDatabaseColumnResponses, ConvertedCell, CopyDocumentData, CopyDocumentError, CopyDocumentErrors, CopyDocumentQueryParams, CopyDocumentRequest, CopyDocumentResponse, CopyDocumentResponse2, CopyDocumentResponses, CountedReaction, CreateAgentData, CreateAgentError, CreateAgentErrors, CreateAgentRequest, CreateAgentResponse, CreateAgentResponses, CreateAnchorData, CreateAnchorError, CreateAnchorErrors, CreateAnchorResponse, CreateAnchorResponses, CreateBotRequest, CreateBulkDocumentResponse, CreateBulkDocumentResponseData, CreateCanvasDocumentRequest, CreateCanvasDocumentResponse, CreateCanvasHandlerData, CreateCanvasHandlerError, CreateCanvasHandlerErrors, CreateCanvasHandlerResponse, CreateCanvasHandlerResponses, CreateChannelData, CreateChannelError, CreateChannelErrors, CreateChannelLabelData, CreateChannelLabelError, CreateChannelLabelErrors, CreateChannelLabelRequest, CreateChannelLabelResponse, CreateChannelLabelResponses, CreateChannelRequest, CreateChannelResponse, CreateChannelResponse2, CreateChannelResponses, CreateChannelScopedBotData, CreateChannelScopedBotError, CreateChannelScopedBotErrors, CreateChannelScopedBotRequest, CreateChannelScopedBotResponse, CreateChannelScopedBotResponse2, CreateChannelScopedBotResponses, CreateCollabSurfaceTokenData, CreateCollabSurfaceTokenError, CreateCollabSurfaceTokenErrors, CreateCollabSurfaceTokenResponse, CreateCollabSurfaceTokenResponses, CreateCrmCompanyData, CreateCrmCompanyError, CreateCrmCompanyErrors, CreateCrmCompanyRequest, CreateCrmCompanyResponse, CreateCrmCompanyResponses, CreateCrmContactData, CreateCrmContactError, CreateCrmContactErrors, CreateCrmContactRequest, CreateCrmContactResponse, CreateCrmContactResponses, CreateCrmPipelineData, CreateCrmPipelineResponse, CreateCrmPipelineResponses, CreateCrmTeamContactData, CreateCrmTeamContactError, CreateCrmTeamContactErrors, CreateCrmTeamContactRequest, CreateCrmTeamContactResponse, CreateCrmTeamContactResponses, CreateDatabaseData, CreateDatabaseError, CreateDatabaseErrors, CreateDatabaseRequest, CreateDatabaseResponse, CreateDatabaseResponses, CreateDatabaseWebhookData, CreateDatabaseWebhookError, CreateDatabaseWebhookErrors, CreateDatabaseWebhookRequest, CreateDatabaseWebhookResponse, CreateDatabaseWebhookResponses, CreatedDatabaseWebhookResponse, CreateDocumentData, CreateDocumentError, CreateDocumentErrors, CreateDocumentRequest, CreateDocumentResponse, CreateDocumentResponseData, CreateDocumentResponses, CreatedPairing, CreatedUserApiKey, CreateEntityMentionData, CreateEntityMentionError, CreateEntityMentionErrors, CreateEntityMentionRequest, CreateEntityMentionResponse, CreateEntityMentionResponse2, CreateEntityMentionResponses, CreateForm, CreateFormData, CreateFormError, CreateFormErrors, CreateFormResponse, CreateFormResponses, CreateHarnessPairingData, CreateHarnessPairingError, CreateHarnessPairingErrors, CreateHarnessPairingResponse, CreateHarnessPairingResponses, CreateImport, CreateInitiativeData, CreateInitiativeError, CreateInitiativeErrors, CreateInitiativeRequest, CreateInitiativeResponse, CreateInitiativeResponses, CreateInstructionsDocumentResponse, CreateInstructionsHandlerData, CreateInstructionsHandlerError, CreateInstructionsHandlerErrors, CreateInstructionsHandlerResponse, CreateInstructionsHandlerResponses, CreateMarkdownDocumentRequest, CreateMarkdownDocumentResponse, CreateMarkdownHandlerData, CreateMarkdownHandlerError, CreateMarkdownHandlerErrors, CreateMarkdownHandlerResponse, CreateMarkdownHandlerResponses, CreateMeetingRequest, CreatePairingRequest, CreatePipeline, CreateProjectHandlerData, CreateProjectHandlerError, CreateProjectHandlerErrors, CreateProjectHandlerResponse, CreateProjectHandlerResponses, CreateProjectRequest, CreateProjectResponse, CreateSkillHandlerData, CreateSkillHandlerError, CreateSkillHandlerErrors, CreateSkillHandlerResponse, CreateSkillHandlerResponses, CreateSkillRequest, CreateSkillResponse, CreateSlackImportData, CreateSlackImportErrors, CreateSlackImportResponse, CreateSlackImportResponses, CreateSnippetHandlerData, CreateSnippetHandlerError, CreateSnippetHandlerErrors, CreateSnippetHandlerResponse, CreateSnippetHandlerResponses, CreateSnippetRequest, CreateSnippetResponse, CreateTaskHandlerData, CreateTaskHandlerError, CreateTaskHandlerErrors, CreateTaskHandlerResponse, CreateTaskHandlerResponses, CreateTaskRequest, CreateTaskResponse, CreateToken, CreateUnthreadedAnchorRequest, CreateUnthreadedAnchorResponse, CreateUnthreadedPdfAnchorRequest, CreateUserApiKeyData, CreateUserApiKeyError, CreateUserApiKeyErrors, CreateUserApiKeyRequest, CreateUserApiKeyResponse, CreateUserApiKeyResponses, CreateViewHandlerData, CreateViewHandlerError, CreateViewHandlerErrors, CreateViewHandlerResponse, CreateViewHandlerResponses, CreateViewRequest, CreateWebhookData, CreateWebhookError, CreateWebhookErrors, CreateWebhookRequest, CreateWebhookResponse, CreateWebhookResponse2, CreateWebhookResponses, CrmAssociation, CrmBlockedDomainResponse, CrmCompanyFilters, CrmCompanyResponse, CrmContactResponse, CrmDomainResponse, CrmPermissionRole, CrmStageInput, CrmStageResponse, CrmStagesResponse, CrmTeamSettingsResponse, CustomSpeakerAssignment, Database, DatabaseDetail, DatabaseId, DatabaseOp, DatabaseQueryRequest, DatabaseView, DatabaseWebhookDeliveryResponse, DatabaseWebhookPayloadProblem, DatabaseWebhookResponse, DataType, DateOperator, DateRange, DateRangeOperator, DeclineCallData, DeclineCallError, DeclineCallErrors, DeclineCallResponse, DeclineCallResponses, DeclineRingData, DeclineRingError, DeclineRingErrors, DeclineRingResponse, DeclineRingResponses, DeleteAnchorData, DeleteAnchorError, DeleteAnchorErrors, DeleteAnchorResponse, DeleteAnchorResponses, DeleteCallRecordData, DeleteCallRecordError, DeleteCallRecordErrors, DeleteCallRecordResponse, DeleteCallRecordResponses, DeleteChannelData, DeleteChannelError, DeleteChannelErrors, DeleteChannelLabelData, DeleteChannelLabelError, DeleteChannelLabelErrors, DeleteChannelLabelResponse, DeleteChannelLabelResponses, DeleteChannelResponse, DeleteChannelResponses, DeleteCollabSurfaceData, DeleteCollabSurfaceError, DeleteCollabSurfaceErrors, DeleteCollabSurfaceResponse, DeleteCollabSurfaceResponses, DeleteDatabaseWebhookData, DeleteDatabaseWebhookError, DeleteDatabaseWebhookErrors, DeleteDatabaseWebhookResponse, DeleteDatabaseWebhookResponses, DeleteDocumentData, DeleteDocumentError, DeleteDocumentErrors, DeleteDocumentResponse, DeleteDocumentResponses, DeleteEntityMentionData, DeleteEntityMentionError, DeleteEntityMentionErrors, DeleteEntityMentionResponse, DeleteEntityMentionResponse2, DeleteEntityMentionResponses, DeleteHarnessData, DeleteHarnessError, DeleteHarnessErrors, DeleteHarnessResponse, DeleteHarnessResponses, DeleteHistoryHandlerData, DeleteHistoryHandlerError, DeleteHistoryHandlerErrors, DeleteHistoryHandlerResponse, DeleteHistoryHandlerResponses, DeleteInitiativeData, DeleteInitiativeError, DeleteInitiativeErrors, DeleteInitiativeResponse, DeleteInitiativeResponses, DeleteProjectHandlerData, DeleteProjectHandlerError, DeleteProjectHandlerErrors, DeleteProjectHandlerResponse, DeleteProjectHandlerResponses, DeleteSelfHarnessData, DeleteSelfHarnessError, DeleteSelfHarnessErrors, DeleteSelfHarnessResponse, DeleteSelfHarnessResponses, DeleteUnthreadedAnchorRequest, DeleteUnthreadedAnchorResponse, DeleteUnthreadedPdfAnchorRequest, DeleteUserApiKeyData, DeleteUserApiKeyError, DeleteUserApiKeyErrors, DeleteUserApiKeyResponse, DeleteUserApiKeyResponses, DeleteUserDocumentViewLocationData, DeleteUserDocumentViewLocationError, DeleteUserDocumentViewLocationErrors, DeleteUserDocumentViewLocationResponse, DeleteUserDocumentViewLocationResponses, DeleteViewHandlerData, DeleteViewHandlerError, DeleteViewHandlerErrors, DeleteViewHandlerResponses, DeleteWebhookData, DeleteWebhookError, DeleteWebhookErrors, DeleteWebhookResponse, DeleteWebhookResponses, DeliverDatabaseWebhookData, DeliverDatabaseWebhookError, DeliverDatabaseWebhookErrors, DeliverDatabaseWebhookResponse, DeliverDatabaseWebhookResponses, DirectAccess, DocumentAiEdited, DocumentAiEditFailed, DocumentAiEditFailedCode, DocumentAiEditRefused, DocumentAiEditRefusedCode, DocumentAiEditRequest, DocumentBasic, DocumentContent, DocumentContentLocation, DocumentContentState, DocumentContentUploadedMetadata, DocumentCopiedMetadata, DocumentCreatedMetadata, DocumentDeletedMetadata, DocumentFilters, DocumentId, DocumentInteractionMetadata, DocumentMetadata, DocumentMetadataWithContent, DocumentPermissionsToken, DocumentPermissionsTokenRequest, DocumentPermissionsTokenResponse, DocumentPreview, DocumentPreviewData, DocumentPreviewDataSubType, DocumentPurgedMetadata, DocumentResponse, DocumentResponseMetadata, DocumentResponseMetadataWithContent, DocumentStorageServiceApiVersion, DocumentSubType, DocumentSyncContentUpdatedMetadata, DocumentSyncEditor, DocumentTeamShareResponse, DocumentTextContent, DocumentTopicEvent, DocumentUpdatedMetadata, DuplicateDatabaseData, DuplicateDatabaseError, DuplicateDatabaseErrors, DuplicateDatabaseRequest, DuplicateDatabaseResponse, DuplicateDatabaseResponses, EditAnchorData, EditAnchorError, EditAnchorErrors, EditAnchorRequest, EditAnchorResponse, EditAnchorResponse2, EditAnchorResponses, EditCallRecordData, EditCallRecordError, EditCallRecordErrors, EditCallRecordRequest, EditCallRecordResponse, EditCallRecordResponses, EditCallTranscriptData, EditCallTranscriptError, EditCallTranscriptErrors, EditCallTranscriptRequest, EditCallTranscriptResponse, EditCallTranscriptResponses, EditDocumentData, EditDocumentError, EditDocumentErrors, EditDocumentResponse, EditDocumentResponse2, EditDocumentResponses, EditDocumentServiceArgs, EditDocumentWithAiData, EditDocumentWithAiError, EditDocumentWithAiErrors, EditDocumentWithAiResponse, EditDocumentWithAiResponses, EditMyFormResponseData, EditMyFormResponseError, EditMyFormResponseErrors, EditMyFormResponseResponse, EditMyFormResponseResponses, EditPdfAnchorRequest, EditPdfPlaceableCommentAnchorRequest, EditProjectV2Data, EditProjectV2Error, EditProjectV2Errors, EditProjectV2Response, EditProjectV2Responses, EditThreadV2Data, EditThreadV2Error, EditThreadV2Errors, EditThreadV2Response, EditThreadV2Responses, EmailFilters, EmailFollowup, EmailFollowupCommand, EmailFollowupResponse, EmailReminderCondition, EmailReminderPage, EmailReminderSummary, EmptyResponse, EnsureCollabSurfaceData, EnsureCollabSurfaceError, EnsureCollabSurfaceErrors, EnsureCollabSurfaceRequest, EnsureCollabSurfaceResponse, EnsureCollabSurfaceResponses, EnsureStarterHandlerData, EnsureStarterHandlerErrors, EnsureStarterHandlerResponse, EnsureStarterHandlerResponses, EntityFilters, EntityKind, EntityMessageCreateData, EntityMessageCreateResponse, EntityMessageCreateResponses, EntityMessageDeleteMessageData, EntityMessageDeleteMessageResponse, EntityMessageDeleteMessageResponses, EntityMessageDeleteThreadData, EntityMessageDeleteThreadResponse, EntityMessageDeleteThreadResponses, EntityMessageEditData, EntityMessageEditResponse, EntityMessageEditResponses, EntityMessageGetMessageData, EntityMessageGetMessageResponse, EntityMessageGetMessageResponses, EntityMessageGetThreadData, EntityMessageGetThreadResponse, EntityMessageGetThreadResponses, EntityMessageLegacyData, EntityMessageLegacyResponse, EntityMessageLegacyResponses, EntityMessagePatchThreadData, EntityMessagePatchThreadResponse, EntityMessagePatchThreadResponses, EntityMessageReactData, EntityMessageReactResponse, EntityMessageReactResponses, EntityMessageTypingData, EntityMessageTypingResponse, EntityMessageTypingResponses, EntityPermission, EntityPermissionResponse, EntityRef, EntityReference, EntityType, ErrorResponse, EventIcsData, EventIcsErrors, EventIcsResponse, EventIcsResponses, EventReminderOverride, EventReminders, EventStatus, EventTime, EventTransparency, EventType, EventVisibility, ExcludedDefaultView, ExcludeDefaultViewHandlerData, ExcludeDefaultViewHandlerError, ExcludeDefaultViewHandlerErrors, ExcludeDefaultViewHandlerResponses, ExcludeDefaultViewRequest, ExportDocumentData, ExportDocumentError, ExportDocumentErrors, ExportDocumentResponse, ExportDocumentResponse2, ExportDocumentResponses, ExternalChatAdd, ExternalChatAddData, ExternalChatAdded, ExternalChatAddResponse, ExternalChatAddResponses, ExternalChatAttachment, ExternalChatAttachmentState, ExternalChatBackfill, ExternalChatBackfillState, ExternalChatCall, ExternalChatCallOutcome, ExternalChatCapabilities, ExternalChatCommunity, ExternalChatContactCard, ExternalChatContacts, ExternalChatData, ExternalChatDeliveryData, ExternalChatDeliveryResponse, ExternalChatDeliveryResponses, ExternalChatDeliveryState, ExternalChatDetail, ExternalChatEvent, ExternalChatKind, ExternalChatLocation, ExternalChatMediaKind, ExternalChatMediaPresentation, ExternalChatMembers, ExternalChatMention, ExternalChatMessage, ExternalChatMessageAttachments, ExternalChatMessageAttachmentsData, ExternalChatMessageAttachmentsResponse, ExternalChatMessageAttachmentsResponses, ExternalChatMessageData, ExternalChatMessageKind, ExternalChatMessageResponse, ExternalChatMessageResponses, ExternalChatMessages, ExternalChatMessagesData, ExternalChatMessagesResponse, ExternalChatMessagesResponses, ExternalChatMutation, ExternalChatParticipant, ExternalChatPermissionsData, ExternalChatPermissionsResponse, ExternalChatPermissionsResponses, ExternalChatPersonRef, ExternalChatPoll, ExternalChatPollOption, ExternalChatProvider, ExternalChatReaction, ExternalChatReadData, ExternalChatReadResponse, ExternalChatReadResponses, ExternalChatReference, ExternalChatRemoveData, ExternalChatRemoveResponse, ExternalChatRemoveResponses, ExternalChatReplyBlock, ExternalChatReplyContent, ExternalChatResponse, ExternalChatResponses, ExternalChatRichContent, ExternalChatsData, ExternalChatSendData, ExternalChatSender, ExternalChatSendErrors, ExternalChatSendProgress, ExternalChatSendReply, ExternalChatSendResponse, ExternalChatSendResponses, ExternalChatSendsData, ExternalChatSendsResponse, ExternalChatSendsResponses, ExternalChatsResponse, ExternalChatsResponses, ExternalChatSummary, ExternalChatSystemAction, ExternalChatSystemLine, ExternalChatUpdatePermissionsData, ExternalChatUpdatePermissionsResponse, ExternalChatUpdatePermissionsResponses, ExternalChatUploadData, ExternalChatUploadedAttachment, ExternalChatUploadRequest, ExternalChatUploadResponse, ExternalChatUploadResponses, Favorite, FavoriteEntityRef, FavoritesList, FileChangeKindDto, FileSystemNodeWithIds, FileType, FileTypeUpdate, FilterCondition, FilterGroup, FilterNode, FilterTest, FinalizeSlackImportData, FinalizeSlackImportErrors, FinalizeSlackImportResponse, FinalizeSlackImportResponses, FolderItem, FollowupState, ForeignEntity, ForeignEntityFilters, Form, FormAccess, FormBranding, FormCollaboration, FormDetail, FormErrorCode, FormErrorResponse, FormLayout, FormPublicationProblem, FormQuestionDetail, FormResponse, FormSection, FormSectionDetail, FormSource, FormStatus, FormTally, Formula, GenericErrorResponse, GenericResponse, GenericSuccessResponse, GetActiveCallsData, GetActiveCallsError, GetActiveCallsErrors, GetActiveCallsResponse, GetActiveCallsResponses, GetActivityData, GetActivityError, GetActivityErrors, GetActivityResponse, GetActivityResponses, GetAttachmentReferencesData, GetAttachmentReferencesError, GetAttachmentReferencesErrors, GetAttachmentReferencesResponse, GetAttachmentReferencesResponse2, GetAttachmentReferencesResponses, GetBatchCallRecordPreviewData, GetBatchCallRecordPreviewError, GetBatchCallRecordPreviewErrors, GetBatchCallRecordPreviewRequest, GetBatchCallRecordPreviewResponse, GetBatchCallRecordPreviewResponse2, GetBatchCallRecordPreviewResponses, GetBatchChannelPreviewData, GetBatchChannelPreviewError, GetBatchChannelPreviewErrors, GetBatchChannelPreviewRequest, GetBatchChannelPreviewResponse, GetBatchChannelPreviewResponse2, GetBatchChannelPreviewResponses, GetBatchPreviewHandlerData, GetBatchPreviewHandlerError, GetBatchPreviewHandlerErrors, GetBatchPreviewHandlerResponse, GetBatchPreviewHandlerResponses, GetBatchPreviewRequest, GetBatchPreviewResponse, GetBatchProjectPreviewData, GetBatchProjectPreviewError, GetBatchProjectPreviewErrors, GetBatchProjectPreviewRequest, GetBatchProjectPreviewResponse, GetBatchProjectPreviewResponse2, GetBatchProjectPreviewResponses, GetBotOwnerProfilesData, GetBotOwnerProfilesError, GetBotOwnerProfilesErrors, GetBotOwnerProfilesResponse, GetBotOwnerProfilesResponses, GetCallRecordData, GetCallRecordError, GetCallRecordErrors, GetCallRecordResponse, GetCallRecordResponses, GetChannelAttachmentsData, GetChannelAttachmentsError, GetChannelAttachmentsErrors, GetChannelAttachmentsResponse, GetChannelAttachmentsResponses, GetChannelData, GetChannelError, GetChannelErrors, GetChannelJoinLinkData, GetChannelJoinLinkError, GetChannelJoinLinkErrors, GetChannelJoinLinkResponse, GetChannelJoinLinkResponses, GetChannelParticipantsData, GetChannelParticipantsError, GetChannelParticipantsErrors, GetChannelParticipantsResponse, GetChannelParticipantsResponses, GetChannelResponse, GetChannelResponses, GetChannelsData, GetChannelsError, GetChannelsErrors, GetChannelsResponse, GetChannelsResponses, GetCollabSurfaceData, GetCollabSurfaceError, GetCollabSurfaceErrors, GetCollabSurfaceResponse, GetCollabSurfaceResponses, GetCompanyData, GetCompanyError, GetCompanyErrors, GetCompanyResponse, GetCompanyResponses, GetContactByEmailData, GetContactByEmailError, GetContactByEmailErrors, GetContactByEmailResponse, GetContactByEmailResponse2, GetContactByEmailResponses, GetContactData, GetContactError, GetContactErrors, GetContactResponse, GetContactResponses, GetCrmPipelineData, GetCrmPipelinePermissionsData, GetCrmPipelinePermissionsResponse, GetCrmPipelinePermissionsResponses, GetCrmPipelineResponse, GetCrmPipelineResponses, GetCrmPipelineRowsData, GetCrmPipelineRowsResponse, GetCrmPipelineRowsResponses, GetCrmPipelineStageRequirementsData, GetCrmPipelineStageRequirementsResponse, GetCrmPipelineStageRequirementsResponses, GetCrmPipelineTableData, GetCrmPipelineTableResponse, GetCrmPipelineTableResponses, GetCrmPipelineViewPositionsData, GetCrmPipelineViewPositionsResponse, GetCrmPipelineViewPositionsResponses, GetCrmTeamSettingsData, GetCrmTeamSettingsError, GetCrmTeamSettingsErrors, GetCrmTeamSettingsResponse, GetCrmTeamSettingsResponses, GetDatabaseData, GetDatabaseError, GetDatabaseErrors, GetDatabasePermissionsData, GetDatabasePermissionsError, GetDatabasePermissionsErrors, GetDatabasePermissionsResponse, GetDatabasePermissionsResponses, GetDatabaseQueryData, GetDatabaseQueryError, GetDatabaseQueryErrors, GetDatabaseQueryResponse, GetDatabaseQueryResponses, GetDatabaseResponse, GetDatabaseResponses, GetDatabaseRowHistoryData, GetDatabaseRowHistoryError, GetDatabaseRowHistoryErrors, GetDatabaseRowHistoryResponse, GetDatabaseRowHistoryResponses, GetDatabaseTableChangesData, GetDatabaseTableChangesError, GetDatabaseTableChangesErrors, GetDatabaseTableChangesResponse, GetDatabaseTableChangesResponses, GetDatabaseViewPositionsData, GetDatabaseViewPositionsError, GetDatabaseViewPositionsErrors, GetDatabaseViewPositionsResponse, GetDatabaseViewPositionsResponses, GetDocumentAnchorsData, GetDocumentAnchorsError, GetDocumentAnchorsErrors, GetDocumentAnchorsResponse, GetDocumentAnchorsResponses, GetDocumentBranchNameData, GetDocumentBranchNameError, GetDocumentBranchNameErrors, GetDocumentBranchNameResponse, GetDocumentBranchNameResponses, GetDocumentByTeamSlugData, GetDocumentByTeamSlugError, GetDocumentByTeamSlugErrors, GetDocumentByTeamSlugResponse, GetDocumentByTeamSlugResponses, GetDocumentData, GetDocumentError, GetDocumentErrors, GetDocumentGithubPullRequestsData, GetDocumentGithubPullRequestsError, GetDocumentGithubPullRequestsErrors, GetDocumentGithubPullRequestsResponse, GetDocumentGithubPullRequestsResponses, GetDocumentKeyResponse, GetDocumentKeyResponseData, GetDocumentListHandlerData, GetDocumentListHandlerError, GetDocumentListHandlerErrors, GetDocumentListHandlerResponse, GetDocumentListHandlerResponses, GetDocumentListResult, GetDocumentLocationV3Data, GetDocumentLocationV3Error, GetDocumentLocationV3Errors, GetDocumentLocationV3Response, GetDocumentLocationV3Responses, GetDocumentPermissionsResponseDataV2, GetDocumentPermissionsTokenData, GetDocumentPermissionsTokenError, GetDocumentPermissionsTokenErrors, GetDocumentPermissionsTokenResponse, GetDocumentPermissionsTokenResponses, GetDocumentPermissionsV2Data, GetDocumentPermissionsV2Error, GetDocumentPermissionsV2Errors, GetDocumentPermissionsV2Response, GetDocumentPermissionsV2Responses, GetDocumentProcessingResult, GetDocumentProcessingResultData, GetDocumentProcessingResultError, GetDocumentProcessingResultErrors, GetDocumentProcessingResultResponse, GetDocumentProcessingResultResponse2, GetDocumentProcessingResultResponses, GetDocumentResponse, GetDocumentResponse2, GetDocumentResponseData, GetDocumentResponses, GetDocumentSearchResponse, GetDocumentShortIdData, GetDocumentShortIdError, GetDocumentShortIdErrors, GetDocumentShortIdResponse, GetDocumentShortIdResponses, GetDocumentsResponse, GetDocumentTeamShareData, GetDocumentTeamShareError, GetDocumentTeamShareErrors, GetDocumentTeamShareResponse, GetDocumentTeamShareResponses, GetDocumentTextContentData, GetDocumentTextContentErrors, GetDocumentTextContentResponse, GetDocumentTextContentResponses, GetDocumentUserAccessLevelResponse, GetDocumentVersionData, GetDocumentVersionError, GetDocumentVersionErrors, GetDocumentVersionResponse, GetDocumentVersionResponses, GetDocumentViewsHandlerData, GetDocumentViewsHandlerError, GetDocumentViewsHandlerErrors, GetDocumentViewsHandlerResponse, GetDocumentViewsHandlerResponses, GetEmailFollowupData, GetEmailFollowupError, GetEmailFollowupErrors, GetEmailFollowupResponse, GetEmailFollowupResponses, GetEntityPermissionData, GetEntityPermissionErrors, GetEntityPermissionResponse, GetEntityPermissionResponses, GetForeignEntityBySourceData, GetForeignEntityBySourceError, GetForeignEntityBySourceErrors, GetForeignEntityBySourceResponse, GetForeignEntityBySourceResponses, GetForeignEntityData, GetForeignEntityError, GetForeignEntityErrors, GetForeignEntityResponse, GetForeignEntityResponses, GetFormData, GetFormError, GetFormErrors, GetFormPermissionsData, GetFormPermissionsError, GetFormPermissionsErrors, GetFormPermissionsResponse, GetFormPermissionsResponses, GetFormResponse, GetFormResponses, GetFormResponseSummaryData, GetFormResponseSummaryError, GetFormResponseSummaryErrors, GetFormResponseSummaryResponse, GetFormResponseSummaryResponses, GetFormTallyData, GetFormTallyError, GetFormTallyErrors, GetFormTallyResponse, GetFormTallyResponses, GetGithubPullRequestChangesData, GetGithubPullRequestChangesError, GetGithubPullRequestChangesErrors, GetGithubPullRequestChangesPatchData, GetGithubPullRequestChangesPatchError, GetGithubPullRequestChangesPatchErrors, GetGithubPullRequestChangesPatchResponse, GetGithubPullRequestChangesPatchResponses, GetGithubPullRequestChangesResponse, GetGithubPullRequestChangesResponses, GetGithubPullRequestData, GetGithubPullRequestError, GetGithubPullRequestErrors, GetGithubPullRequestFacetsData, GetGithubPullRequestFacetsError, GetGithubPullRequestFacetsErrors, GetGithubPullRequestFacetsResponse, GetGithubPullRequestFacetsResponses, GetGithubPullRequestResponse, GetGithubPullRequestResponses, GetGithubPullRequestTasksData, GetGithubPullRequestTasksError, GetGithubPullRequestTasksErrors, GetGithubPullRequestTasksResponse, GetGithubPullRequestTasksResponses, GetHarnessPairingData, GetHarnessPairingError, GetHarnessPairingErrors, GetHarnessPairingResponse, GetHarnessPairingResponses, GetHistoryHandlerData, GetHistoryHandlerError, GetHistoryHandlerErrors, GetHistoryHandlerResponse, GetHistoryHandlerResponses, GetInitiativeData, GetInitiativeError, GetInitiativeErrors, GetInitiativeResponse, GetInitiativeResponses, GetInstructionsDocumentResponse, GetInstructionsHandlerData, GetInstructionsHandlerError, GetInstructionsHandlerErrors, GetInstructionsHandlerResponse, GetInstructionsHandlerResponses, GetItemsSoupData, GetItemsSoupError, GetItemsSoupErrors, GetItemsSoupResponse, GetItemsSoupResponses, GetLocationHandlerData, GetLocationHandlerError, GetLocationHandlerErrors, GetLocationHandlerResponse, GetLocationHandlerResponses, GetMyFormResponseData, GetMyFormResponseError, GetMyFormResponseErrors, GetMyFormResponseResponse, GetMyFormResponseResponses, GetOrCreateAction, GetOrCreateCallData, GetOrCreateCallError, GetOrCreateCallErrors, GetOrCreateCallResponse, GetOrCreateCallResponses, GetOrCreateChannelResponse, GetOrCreateDmData, GetOrCreateDmError, GetOrCreateDmErrors, GetOrCreateDmRequest, GetOrCreateDmResponse, GetOrCreateDmResponses, GetOrCreatePrivateData, GetOrCreatePrivateError, GetOrCreatePrivateErrors, GetOrCreatePrivateRequest, GetOrCreatePrivateResponse, GetOrCreatePrivateResponses, GetPendingProjectsHandlerData, GetPendingProjectsHandlerError, GetPendingProjectsHandlerErrors, GetPendingProjectsHandlerResponse, GetPendingProjectsHandlerResponses, GetPinsHandlerData, GetPinsHandlerError, GetPinsHandlerErrors, GetPinsHandlerResponse, GetPinsHandlerResponses, GetPinsResponse, GetProjectContentHandlerData, GetProjectContentHandlerError, GetProjectContentHandlerErrors, GetProjectContentHandlerResponse, GetProjectContentHandlerResponses, GetProjectContentResponse, GetProjectHandlerData, GetProjectHandlerError, GetProjectHandlerErrors, GetProjectHandlerResponse, GetProjectHandlerResponses, GetProjectPermissionsV2Data, GetProjectPermissionsV2Error, GetProjectPermissionsV2Errors, GetProjectPermissionsV2Response, GetProjectPermissionsV2Responses, GetProjectResponse, GetProjectResponseData, GetProjectsHandlerData, GetProjectsHandlerError, GetProjectsHandlerErrors, GetProjectsHandlerResponse, GetProjectsHandlerResponses, GetProjectsResponse, GetProjectUserAccessLevelData, GetProjectUserAccessLevelError, GetProjectUserAccessLevelErrors, GetProjectUserAccessLevelResponse, GetProjectUserAccessLevelResponses, GetRingStatusData, GetRingStatusError, GetRingStatusErrors, GetRingStatusResponse, GetRingStatusResponses, GetSelfBotData, GetSelfBotError, GetSelfBotErrors, GetSelfBotResponse, GetSelfBotResponses, GetSelfHarnessData, GetSelfHarnessError, GetSelfHarnessErrors, GetSelfHarnessResponse, GetSelfHarnessResponses, GetSkillDescriptionData, GetSkillDescriptionError, GetSkillDescriptionErrors, GetSkillDescriptionResponse, GetSkillDescriptionResponses, GetSlackImportData, GetSlackImportErrors, GetSlackImportResponse, GetSlackImportResponses, GetSystemSkillsHandlerData, GetSystemSkillsHandlerError, GetSystemSkillsHandlerErrors, GetSystemSkillsHandlerResponse, GetSystemSkillsHandlerResponses, GetUserDocumentsHandlerData, GetUserDocumentsHandlerError, GetUserDocumentsHandlerErrors, GetUserDocumentsHandlerResponse, GetUserDocumentsHandlerResponses, GetUserDocumentViewLocationData, GetUserDocumentViewLocationError, GetUserDocumentViewLocationErrors, GetUserDocumentViewLocationResponse, GetUserDocumentViewLocationResponses, GetUserHistoryResponse, GetViewsHandlerData, GetViewsHandlerError, GetViewsHandlerErrors, GetViewsHandlerResponse, GetViewsHandlerResponses, GetWebhookData, GetWebhookError, GetWebhookErrors, GetWebhookResponse, GetWebhookResponses, GithubLabelFacet, GithubPullRequest, GithubPullRequestChangesPatchResponse, GithubPullRequestChangesResponse, GithubPullRequestCheckRun, GithubPullRequestComment, GithubPullRequestFacets, GithubPullRequestLabel, GithubPullRequestReview, GithubPullRequestReviewDecision, GithubPullRequestReviewState, GithubPullRequestsResponse, GithubPullRequestTasks, GithubPullRequestTasksRequest, GithubPullRequestTasksResponse, GithubPullRequestUser, GithubRepositoryFacet, GithubUserFacet, GitRefDto, GroupedInitialParams, GroupedPageParams, GroupedSoupGroupPage, GroupedSoupInitialPage, GroupedSoupPage, GroupedSoupSort, GuestCallChatPostData, GuestCallChatPostErrors, GuestCallChatPostResponse, GuestCallChatPostResponses, GuestCallChatReadData, GuestCallChatReadErrors, GuestCallChatReadResponse, GuestCallChatReadResponses, GuestChatMessage, GuestChatPage, GuestChatPost, GuestId, GuestJoinRequest, GuestPolicy, HandlerData, HandlerError, HandlerErrors, HandlerResponse, HandlerResponses, Harness, HarnessAgent, HarnessId, HarnessOwner, HarnessSession, HashMap, HealthHandlerData, HealthHandlerResponse, HealthHandlerResponses, HighlightType, ImportCounters, ImportDatabaseTableData, ImportDatabaseTableError, ImportDatabaseTableErrors, ImportDatabaseTableResponse, ImportDatabaseTableResponses, ImportedAuthor, ImportError, ImportLimits, ImportPage, ImportProgress, ImportTable, ImportWarning, InferColumnTypeOutcome, InferColumnTypeRequest, InferDatabaseColumnTypeData, InferDatabaseColumnTypeError, InferDatabaseColumnTypeErrors, InferDatabaseColumnTypeResponse, InferDatabaseColumnTypeResponses, InFlightTurnSummary, IngestTranscriptData, IngestTranscriptError, IngestTranscriptErrors, IngestTranscriptResponses, InitializeUserDocumentsData, InitializeUserDocumentsError, InitializeUserDocumentsErrors, InitializeUserDocumentsResponse, InitializeUserDocumentsResponses, InitialPropertyValue, InitiativeDetail, InitiativeFilters, InitiativeId, InitiativeList, InitiativeSummary, InputReceivedMetadata, InstallSyncData, InstallSyncErrors, InteractionReason, InvalidDatabaseWebhookPayloadResponse, InviteMeetingRequest, InviteMeetingUsersRequest, Item, ItemWithUserAccessLevel, JobId, JobProcessingResultHandlerData, JobProcessingResultHandlerError, JobProcessingResultHandlerErrors, JobProcessingResultHandlerResponse, JobProcessingResultHandlerResponses, JobStatus, JoinChannelByCodeData, JoinChannelByCodeError, JoinChannelByCodeErrors, JoinChannelByCodeResponses, JoinChannelData, JoinChannelError, JoinChannelErrors, JoinChannelResponses, KeySegment, Lane, LaneKey, LatestMessage, LayoutProblem, LeaveCallResponse, LeaveChannelData, LeaveChannelError, LeaveChannelErrors, LeaveChannelResponses, LeaveOrEndCallData, LeaveOrEndCallError, LeaveOrEndCallErrors, LeaveOrEndCallResponse, LeaveOrEndCallResponses, LinkShare, ListAccessibleFormsData, ListAccessibleFormsError, ListAccessibleFormsErrors, ListAccessibleFormsResponse, ListAccessibleFormsResponses, ListAgentsData, ListAgentsError, ListAgentsErrors, ListAgentsResponse, ListAgentsResponses, ListBotChannelsData, ListBotChannelsError, ListBotChannelsErrors, ListBotChannelsResponse, ListBotChannelsResponses, ListChannelLabelsData, ListChannelLabelsError, ListChannelLabelsErrors, ListChannelLabelsResponse, ListChannelLabelsResponses, ListCompanyContactsData, ListCompanyContactsError, ListCompanyContactsErrors, ListCompanyContactsResponse, ListCompanyContactsResponses, ListCrmBlockedDomainsData, ListCrmBlockedDomainsError, ListCrmBlockedDomainsErrors, ListCrmBlockedDomainsResponse, ListCrmBlockedDomainsResponses, ListCrmPipelinesData, ListCrmPipelinesResponse, ListCrmPipelinesResponses, ListDatabaseColumnCastsData, ListDatabaseColumnCastsError, ListDatabaseColumnCastsErrors, ListDatabaseColumnCastsResponse, ListDatabaseColumnCastsResponses, ListDatabasesData, ListDatabasesError, ListDatabasesErrors, ListDatabasesResponse, ListDatabasesResponses, ListDatabaseWebhooksData, ListDatabaseWebhooksError, ListDatabaseWebhooksErrors, ListDatabaseWebhooksResponse, ListDatabaseWebhooksResponse2, ListDatabaseWebhooksResponses, ListedDatabase, ListedForm, ListEmailRemindersData, ListEmailRemindersError, ListEmailRemindersErrors, ListEmailRemindersResponse, ListEmailRemindersResponses, ListFavoritesData, ListFavoritesError, ListFavoritesErrors, ListFavoritesResponse, ListFavoritesResponses, ListFormsData, ListFormsError, ListFormsErrors, ListFormsResponse, ListFormsResponses, ListHarnessAgentsData, ListHarnessAgentsError, ListHarnessAgentsErrors, ListHarnessAgentsResponse, ListHarnessAgentsResponses, ListHarnessesData, ListHarnessesError, ListHarnessesErrors, ListHarnessesResponse, ListHarnessesResponses, ListHarnessSessionsData, ListHarnessSessionsError, ListHarnessSessionsErrors, ListHarnessSessionsResponse, ListHarnessSessionsResponses, ListInitiativesData, ListInitiativesError, ListInitiativesErrors, ListInitiativesResponse, ListInitiativesResponses, ListJoinRequestsData, ListJoinRequestsError, ListJoinRequestsErrors, ListJoinRequestsResponse, ListJoinRequestsResponses, ListOccurrencesData, ListOccurrencesErrors, ListOccurrencesResponse, ListOccurrencesResponses, ListSlackImportsData, ListSlackImportsResponse, ListSlackImportsResponses, ListTeamCalendarData, ListTeamCalendarResponse, ListTeamCalendarResponses, ListTeamOutOfOfficeData, ListTeamOutOfOfficeErrors, ListTeamOutOfOfficeResponse, ListTeamOutOfOfficeResponses, ListUserApiKeysData, ListUserApiKeysError, ListUserApiKeysErrors, ListUserApiKeysResponse, ListUserApiKeysResponses, ListWebhooksData, ListWebhooksError, ListWebhooksErrors, ListWebhooksResponse, ListWebhooksResponse2, ListWebhooksResponses, LocationResponseData, LocationResponseV3, MacroUserIdStr, MarkRead, Meeting, MeetingCancelData, MeetingCancelError, MeetingCancelErrors, MeetingCancelPreparationData, MeetingCancelPreparationError, MeetingCancelPreparationErrors, MeetingCancelPreparationResponse, MeetingCancelPreparationResponses, MeetingCancelResponse, MeetingCancelResponses, MeetingCreateData, MeetingCreateError, MeetingCreateErrors, MeetingCreateResponse, MeetingCreateResponses, MeetingGuestJoinData, MeetingGuestJoinError, MeetingGuestJoinErrors, MeetingGuestJoinResponse, MeetingGuestJoinResponses, MeetingGuestParticipantsData, MeetingGuestParticipantsError, MeetingGuestParticipantsErrors, MeetingGuestParticipantsResponse, MeetingGuestParticipantsResponses, MeetingInviteData, MeetingInviteError, MeetingInviteErrors, MeetingInvitePermissions, MeetingInvitePermissionsData, MeetingInvitePermissionsError, MeetingInvitePermissionsErrors, MeetingInvitePermissionsResponse, MeetingInvitePermissionsResponses, MeetingInviteResponse, MeetingInviteResponses, MeetingInviteUsersData, MeetingInviteUsersError, MeetingInviteUsersErrors, MeetingInviteUsersResponse, MeetingInviteUsersResponses, MeetingJoinData, MeetingJoinError, MeetingJoinErrors, MeetingJoinResponse, MeetingJoinResponses, MeetingLeaveData, MeetingLeaveError, MeetingLeaveErrors, MeetingLeaveResponse, MeetingLeaveResponses, MeetingListActiveData, MeetingListActiveError, MeetingListActiveErrors, MeetingListActiveResponse, MeetingListActiveResponses, MeetingListData, MeetingListError, MeetingListErrors, MeetingListResponse, MeetingListResponses, MeetingLookupData, MeetingLookupError, MeetingLookupErrors, MeetingLookupResponse, MeetingLookupResponses, MeetingParticipant, MeetingParticipants, MeetingParticipantsData, MeetingParticipantsError, MeetingParticipantsErrors, MeetingParticipantsResponse, MeetingParticipantsResponses, MeetingPreparation, MeetingPrepareData, MeetingPrepareError, MeetingPrepareErrors, MeetingPrepareResponse, MeetingPrepareResponses, MeetingShareData, MeetingShareError, MeetingShareErrors, MeetingShareResponse, MeetingShareResponses, MeetingsResponse, MeetingToken, MeetingUpdateData, MeetingUpdateError, MeetingUpdateErrors, MeetingUpdateResponse, MeetingUpdateResponses, MentionPreviewsData, MentionPreviewsErrors, MentionPreviewsResponse, MentionPreviewsResponses, Message, MessageAttachment, MessageAttachmentCreatedMetadata, MessageAttachmentRemovedMetadata, MessageChange, MessageCursor, MessageDeletedMetadata, MessageDirection, MessageEvent, MessageEventAttachment, MessageListItem, MessageMentionedMetadata, MessagePage, MessageParent, MessagePatch, MessagePatchedMetadata, MessagePostedMetadata, MessageThread, MessageThreadPreview, MessageTimelineData, MessageTimelineEntriesData, MessageTimelineEntriesResponse, MessageTimelineEntriesResponses, MessageTimelineEntry, MessageTimelinePage, MessageTimelineQuery, MessageTimelineResponse, MessageTimelineResponses, MessageTopicEvent, MyResponse, NewAttachment, NewColumn, NewOption, NewThreadAnchor, NewView, NotificationFilters, NotificationState, NumberOperator, OpBatch, Operator, OpRefusalResponse, OpResult, OptionId, OptionRef, PairingDetails, Params, ParticipantRole, PatchBotRequest, PatchChannelData, PatchChannelError, PatchChannelErrors, PatchChannelRequest, PatchChannelResponse, PatchChannelResponses, PatchMessageNotificationPolicy, PatchProjectRequestV2, PatchThreadRequestV2, PatchViewHandlerData, PatchViewHandlerError, PatchViewHandlerErrors, PatchViewHandlerResponses, PatchWebhookData, PatchWebhookError, PatchWebhookErrors, PatchWebhookRequest, PatchWebhookResponse, PatchWebhookResponses, PdfAnchor, PdfAnchorId, PdfHighlightAnchor, PdfHighlightAnchorRequest, PdfHighlightRect, PdfHighlightRectAnchorRequest, PdfPlaceableCommentAnchor, PendingClaimResponse, PermanentlyDeleteDocumentData, PermanentlyDeleteDocumentError, PermanentlyDeleteDocumentErrors, PermanentlyDeleteDocumentResponse, PermanentlyDeleteDocumentResponses, PermanentlyDeleteProjectData, PermanentlyDeleteProjectError, PermanentlyDeleteProjectErrors, PermanentlyDeleteProjectResponse, PermanentlyDeleteProjectResponses, PinnedItem, PinRequest, Pipeline, PipelineRecordType, PipelineSharing, PostActivityData, PostActivityError, PostActivityErrors, PostActivityRequest, PostActivityResponse, PostActivityResponses, PostChannelBotWebhookData, PostChannelBotWebhookError, PostChannelBotWebhookErrors, PostChannelBotWebhookResponse, PostChannelBotWebhookResponses, PostGroupedSoupAstGroupPageRequest, PostGroupedSoupAstInitialRequest, PostGroupedSoupAstRequest, PostItemsSoupAstData, PostItemsSoupAstError, PostItemsSoupAstErrors, PostItemsSoupAstGroupedData, PostItemsSoupAstGroupedError, PostItemsSoupAstGroupedErrors, PostItemsSoupAstGroupedResponse, PostItemsSoupAstGroupedResponses, PostItemsSoupAstResponse, PostItemsSoupAstResponses, PostItemsSoupData, PostItemsSoupError, PostItemsSoupErrors, PostItemsSoupResponse, PostItemsSoupResponses, PostMessage, PostMessageNotificationPolicy, PostSoupAstRequest, PostSoupRequest, PresaveDocumentHandlerData, PresaveDocumentHandlerError, PresaveDocumentHandlerErrors, PresaveDocumentHandlerResponse, PresaveDocumentHandlerResponses, PreSaveDocumentRequest, PreSaveDocumentResponse, PreSaveDocumentResponseData, PresenceOperator, PresignedUrl, PreviewSmartTagData, PreviewSmartTagError, PreviewSmartTagErrors, PreviewSmartTagResponse, PreviewSmartTagResponses, Project, ProjectDeleteResponseData, ProjectDocumentStatus, ProjectFilters, ProjectPreview, ProjectPreviewData, PropertyBucketing, PropertyDateFilterRange, PropertyDateRange, PropertyDateRanges, PropertyDefinition, PropertyDefinitionWithOptions, PropertyFilter, PropertyInput, PropertyOption, PropertyOptionValue, PropertyOwner, PropertyValue, PutCrmTeamSettingsData, PutCrmTeamSettingsError, PutCrmTeamSettingsErrors, PutCrmTeamSettingsResponse, PutCrmTeamSettingsResponses, PutCrmTeamStagesData, PutCrmTeamStagesError, PutCrmTeamStagesErrors, PutCrmTeamStagesResponse, PutCrmTeamStagesResponses, PutFormLayoutData, PutFormLayoutError, PutFormLayoutErrors, PutFormLayoutResponse, PutFormLayoutResponses, QueryCrmPipelineRowsData, QueryCrmPipelineRowsResponse, QueryCrmPipelineRowsResponses, QueryDatabasesData, QueryDatabasesError, QueryDatabasesErrors, QueryDatabasesResponse, QueryDatabasesResponses, QueryDefinition, QuestionLayout, QuestionOption, QuestionTally, ReactionInput, RecentlyDeletedData, RecentlyDeletedError, RecentlyDeletedErrors, RecentlyDeletedResponse, RecentlyDeletedResponseData, RecentlyDeletedResponses, RegisterSlackImportUploadsData, RegisterSlackImportUploadsErrors, RegisterSlackImportUploadsResponse, RegisterSlackImportUploadsResponses, RegisterUploads, RemoveBotFromChannelByBotData, RemoveBotFromChannelByBotError, RemoveBotFromChannelByBotErrors, RemoveBotFromChannelByBotResponse, RemoveBotFromChannelByBotResponses, RemoveFavoriteByEntityData, RemoveFavoriteByEntityError, RemoveFavoriteByEntityErrors, RemoveFavoriteByEntityResponses, RemoveParticipantsData, RemoveParticipantsError, RemoveParticipantsErrors, RemoveParticipantsRequest, RemoveParticipantsResponses, RemovePinHandlerData, RemovePinHandlerError, RemovePinHandlerErrors, RemovePinHandlerResponse, RemovePinHandlerResponses, RenameChannelLabelData, RenameChannelLabelError, RenameChannelLabelErrors, RenameChannelLabelRequest, RenameChannelLabelResponse, RenameChannelLabelResponses, RenameCrmPipelineData, RenameCrmPipelineResponse, RenameCrmPipelineResponses, RenamePipeline, ReorderFavoritesData, ReorderFavoritesError, ReorderFavoritesErrors, ReorderFavoritesRequest, ReorderFavoritesResponses, ReorderPinRequest, ReorderPinsHandlerData, ReorderPinsHandlerError, ReorderPinsHandlerErrors, ReorderPinsHandlerResponse, ReorderPinsHandlerResponses, ReplaceCrmStagesRequest, RequestAccess, RequestedHarnessScope, RequestedLayout, RequestStatus, RequestToJoinData, RequestToJoinError, RequestToJoinErrors, RequestToJoinResponse, RequestToJoinResponses, ResetCrmTeamStagesData, ResetCrmTeamStagesError, ResetCrmTeamStagesErrors, ResetCrmTeamStagesResponse, ResetCrmTeamStagesResponses, ResolveRequest, ResponseStatus, ResponseSummary, ResultColumn, ResultSet, RevertDeleteDocumentData, RevertDeleteDocumentError, RevertDeleteDocumentErrors, RevertDeleteDocumentResponse, RevertDeleteDocumentResponses, RevertDeleteProjectData, RevertDeleteProjectError, RevertDeleteProjectErrors, RevertDeleteProjectResponse, RevertDeleteProjectResponses, RingStatus, RingStatusResponse, RowChange, RowChangeKind, RowChanges, RowHistoryEntry, RowHistoryResponse, RowId, RowsChange, RowsResult, S3ObjectInfo, SaveBomPart, SaveDatabaseQueryData, SaveDatabaseQueryError, SaveDatabaseQueryErrors, SaveDatabaseQueryResponse, SaveDatabaseQueryResponses, SaveDocumentHandlerData, SaveDocumentHandlerError, SaveDocumentHandlerErrors, SaveDocumentHandlerResponse, SaveDocumentHandlerResponses, SaveDocumentRequest, SaveDocumentResponse, SaveDocumentResponseData, SavedQuery, SaveQueryRequest, SearchContactsData, SearchContactsError, SearchContactsErrors, SearchContactsResponse, SearchContactsResponse2, SearchContactsResponses, SearchState, SectionCount, SessionDeletedMetadata, SessionIdentity, SessionMentionedMetadata, SessionOpenedMetadata, SessionRenamedMetadata, SessionSettledMetadata, SessionSource, SessionStoppedMetadata, SetChannelLabelData, SetChannelLabelError, SetChannelLabelErrors, SetChannelLabelRequest, SetChannelLabelResponse, SetChannelLabelResponses, SetChannelPictureData, SetChannelPictureError, SetChannelPictureErrors, SetChannelPictureRequest, SetChannelPictureResponse, SetChannelPictureResponses, SetCompanyHiddenData, SetCompanyHiddenError, SetCompanyHiddenErrors, SetCompanyHiddenRequest, SetCompanyHiddenResponse, SetCompanyHiddenResponses, SetCompanyNameRequest, SetContactHiddenData, SetContactHiddenError, SetContactHiddenErrors, SetContactHiddenRequest, SetContactHiddenResponse, SetContactHiddenResponses, SetContactNameRequest, SetCrmCompanyNameData, SetCrmCompanyNameError, SetCrmCompanyNameErrors, SetCrmCompanyNameResponse, SetCrmCompanyNameResponses, SetCrmContactNameData, SetCrmContactNameError, SetCrmContactNameErrors, SetCrmContactNameResponse, SetCrmContactNameResponses, SetCrmPipelineStageRequirementData, SetCrmPipelineStageRequirementResponse, SetCrmPipelineStageRequirementResponses, SetDirectAccess, SetDocumentTeamShareData, SetDocumentTeamShareError, SetDocumentTeamShareErrors, SetDocumentTeamShareRequest, SetDocumentTeamShareResponse, SetDocumentTeamShareResponses, SetEmailFollowupData, SetEmailFollowupError, SetEmailFollowupErrors, SetEmailFollowupResponse, SetEmailFollowupResponses, SetEmailSyncData, SetEmailSyncError, SetEmailSyncErrors, SetEmailSyncRequest, SetEmailSyncResponse, SetEmailSyncResponses, SetOperator, SetPropertyValue, SetSkillDescriptionData, SetSkillDescriptionError, SetSkillDescriptionErrors, SetSkillDescriptionRequest, SetSkillDescriptionResponse, SetSkillDescriptionResponses, Sha256Digest, ShareCrmPipelineData, ShareCrmPipelineResponse, ShareCrmPipelineResponses, ShareDatabaseAwarenessData, ShareDatabaseAwarenessError, ShareDatabaseAwarenessErrors, ShareDatabaseAwarenessResponse, ShareDatabaseAwarenessResponses, SharedEmailFilter, SharedExternalChatReference, ShareEntity, ShareEntityType, SharePermissionV2, SharePipeline, ShortIdResponse, SimpleMention, SimpleSaveData, SimpleSaveError, SimpleSaveErrors, SimpleSaveResponse, SimpleSaveResponses, SkillDescriptionBody, SkippedCell, SlackCompleteRequest, SlackCreateRequest, SlackRegisterRequest, SlackTimestamp, SlackUserId, SmartTagChannelMatch, SmartTagPreview, SortDirection, SortKey, SoupAgentSessionSoupPropertiesField, SoupApiItem, SoupApiSort, SoupApiSortDirection, SoupAttachment, SoupCalendarEventSoupPropertiesField, SoupCalendarEventTime, SoupCallRecordGuest, SoupCallRecordParticipant, SoupCallRecordSoupPropertiesField, SoupChannel, SoupChannelThread, SoupChatSoupPropertiesField, SoupContact, SoupCountedReaction, SoupCrmCompanySoupPropertiesField, SoupCrmContactSoupPropertiesField, SoupCrmDomain, SoupDatabaseRowSoupPropertiesField, SoupDocumentSoupPropertiesField, SoupDocumentSubType, SoupEmailThreadPreview, SoupEnrichedEmailThreadPreviewSoupPropertiesField, SoupForeignEntity, SoupInitiativeSoupPropertiesField, SoupItem, SoupLabel, SoupLabelListVisibility, SoupLabelType, SoupMessageAttachment, SoupMessageListVisibility, SoupMessageSender, SoupMessageSenderType, SoupPage, SoupProjectSoupPropertiesField, SoupPropertiesField, SoupProperty, SoupThreadInfo, SoupThreadReply, SourceBinding, SourceId, SourceIdentity, SqlCell, SqlEntityKind, SqlOutcome, SqlOutcomeKind, SqlSelectOption, SqlStatement, StageRequirement, StarterDatabase, StarterDocumentsResponse, StorageRow, StorageRows, StorageRowsQuery, StoredGithubPullRequest, StreamEventsData, StreamEventsError, StreamEventsErrors, StreamEventsResponse, StreamEventsResponses, String, Submission, SubmissionOutcome, SubmitFormResponseData, SubmitFormResponseError, SubmitFormResponseErrors, SubmitFormResponseResponse, SubmitFormResponseResponses, SuccessResponse, SurfaceState, SyncServiceVersionId, SystemSkillSummary, Table, TableChange, TableChanged, TableChanges, TableDetail, TableId, TableResult, TableVersion, TagFilterMode, TakenId, TallyBucket, TallyValue, TaskFilters, TaskSimilarityResult, TaskSimilaritySearchHandlerData, TaskSimilaritySearchHandlerError, TaskSimilaritySearchHandlerErrors, TaskSimilaritySearchHandlerResponse, TaskSimilaritySearchHandlerResponses, TaskSimilaritySearchRequest, TaskSimilaritySearchResponse, TeamCalendarContent, TeamCalendarCoverage, TeamCalendarDetails, TeamCalendarItem, TeamCalendarMember, TeamCalendarPage, TeamCalendarSharing, TeamOutOfOfficeItem, TeamOutOfOfficeResponse, TeamRole, TextOperator, ThreadAnchor, ThreadOrigin, ThreadPatch, ThreadState, TimelineActivity, ToggleShareWithTeamData, ToggleShareWithTeamError, ToggleShareWithTeamErrors, ToggleShareWithTeamResponse, ToggleShareWithTeamResponses, TouchedColumn, TouchedRow, TranscribeDictationData, TranscribeDictationError, TranscribeDictationErrors, TranscribeDictationResponse, TranscribeDictationResponses, TranscribeResponse, TranscriptSegmentRequest, TrashCrmPipelineData, TrashCrmPipelineResponse, TrashCrmPipelineResponses, TrashPipeline, TurnEndedMetadata, TurnStartedMetadata, TurnSummary, TypedSuccessResponse, TypedSuccessResponseGetDocumentResponseData, TypingInput, UnblockCrmDomainData, UnblockCrmDomainError, UnblockCrmDomainErrors, UnblockCrmDomainResponse, UnblockCrmDomainResponses, UndoChangeResponse, UndoDatabaseChangeData, UndoDatabaseChangeError, UndoDatabaseChangeErrors, UndoDatabaseChangeResponse, UndoDatabaseChangeResponses, UndoOutcome, UndoRefusal, UnlockedBooking, UpdateAgentData, UpdateAgentError, UpdateAgentErrors, UpdateAgentRequest, UpdateAgentResponse, UpdateAgentResponses, UpdateChannelSharePermission, UpdateCrmPipelinePermissionsData, UpdateCrmPipelinePermissionsResponse, UpdateCrmPipelinePermissionsResponses, UpdateCrmTeamSettingsRequest, UpdateDatabasePermissionsData, UpdateDatabasePermissionsError, UpdateDatabasePermissionsErrors, UpdateDatabasePermissionsResponse, UpdateDatabasePermissionsResponses, UpdateForm, UpdateFormData, UpdateFormError, UpdateFormErrors, UpdateFormPermissionsData, UpdateFormPermissionsError, UpdateFormPermissionsErrors, UpdateFormPermissionsResponse, UpdateFormPermissionsResponses, UpdateFormResponse, UpdateFormResponses, UpdateInitiativeData, UpdateInitiativeError, UpdateInitiativeErrors, UpdateInitiativeRequest, UpdateInitiativeResponse, UpdateInitiativeResponses, UpdateMeetingRequest, UpdateOperation, UpdateSharePermissionRequestV2, UploadDescriptor, UploadDocumentStatus, UploadExtractFolderHandlerData, UploadExtractFolderHandlerError, UploadExtractFolderHandlerErrors, UploadExtractFolderHandlerResponse, UploadExtractFolderHandlerResponses, UploadExtractFolderRequest, UploadFolderHandlerData, UploadFolderHandlerError, UploadFolderHandlerErrors, UploadFolderHandlerResponse, UploadFolderHandlerResponses, UploadFolderRequest, UploadGrant, UploadId, UpsertHistoryHandlerData, UpsertHistoryHandlerError, UpsertHistoryHandlerErrors, UpsertHistoryHandlerResponse, UpsertHistoryHandlerResponses, UpsertUserDocumentViewLocationData, UpsertUserDocumentViewLocationError, UpsertUserDocumentViewLocationErrors, UpsertUserDocumentViewLocationRequest, UpsertUserDocumentViewLocationResponse, UpsertUserDocumentViewLocationResponses, UserApiKeyId, UserApiKeyInfo, UserApiKeysList, UserDocumentsResponse, UserDocumentViewLocation, UserDocumentViewLocationResponse, UserPinsResponse, UserViewsResponse, ValidateDocumentPermissionsTokenData, ValidateDocumentPermissionsTokenError, ValidateDocumentPermissionsTokenErrors, ValidateDocumentPermissionsTokenResponse, ValidateDocumentPermissionsTokenResponses, ValidateWebhookData, ValidateWebhookError, ValidateWebhookErrors, ValidateWebhookResponse, ValidateWebhookResponse2, ValidateWebhookResponses, Vec, VersionedTable, View, ViewChange, ViewColumn, ViewerCapabilities, ViewLayout, ViewPatch, ViewPosition, ViewPositionsResponse, ViewQuery, ViewResult, ViewsResponse, WaitingForInputMetadata, Webhook, WebhookEvent, WebhookFilter, WebhookScope, WebhookStatus, WebhookValidationTestEvent, WhatsAppAccount, WhatsappAccountData, WhatsappAccountResponse, WhatsappAccountResponses, WhatsAppAccountState, WhatsAppAccountView, WhatsappCancelPairingData, WhatsappCancelPairingResponse, WhatsappCancelPairingResponses, WhatsAppCannotAdd, WhatsAppChat, WhatsAppChats, WhatsappChatsData, WhatsappChatsResponse, WhatsappChatsResponses, WhatsAppConnect, WhatsappConnectData, WhatsappConnectResponse, WhatsappConnectResponses, WhatsAppDisconnect, WhatsappDisconnectData, WhatsAppDisconnectRequest, WhatsappDisconnectResponse, WhatsappDisconnectResponses, WhatsAppHistoryImport, WhatsappImportHistoryData, WhatsappImportHistoryResponse, WhatsappImportHistoryResponses, WhatsAppLookup, WhatsappLookupData, WhatsAppLookupRequest, WhatsappLookupResponse, WhatsappLookupResponses, WhatsAppLookupState, WhatsAppPairing, WhatsappPairingData, WhatsappPairingResponse, WhatsappPairingResponses, WhatsAppPairingState, WhatsAppPairState, WhatsappPasskeyData, WhatsappPasskeyResponse, WhatsappPasskeyResponses, WhatsappStartLookupData, WhatsappStartLookupResponse, WhatsappStartLookupResponses, Widget, WithCallId, WithChannelId, WithDocumentId, WithProjectId } from './types.gen';diff --git a/packages/sdk/generated/storage/sdk.gen.ts b/packages/sdk/generated/storage/sdk.gen.tsindex 9db9247d80..33ad196add 100644--- a/packages/sdk/generated/storage/sdk.gen.ts+++ b/packages/sdk/generated/storage/sdk.gen.ts@@ -2,7 +2,7 @@import { type Client, type ClientMeta, formDataBodySerializer, type Options as Options2, type RequestResult, type ServerSentEventsResult, type TDataShape } from './client';import { client } from './client.gen';-import type { AccessRequestsCancelData, AccessRequestsCancelErrors, AccessRequestsCancelResponses, AccessRequestsDirectData, AccessRequestsDirectErrors, AccessRequestsDirectResponses, AccessRequestsRemoveDirectData, AccessRequestsRemoveDirectErrors, AccessRequestsRemoveDirectResponses, AccessRequestsResolveData, AccessRequestsResolveErrors, AccessRequestsResolveResponses, AccessRequestsSetDirectData, AccessRequestsSetDirectErrors, AccessRequestsSetDirectResponses, AccessRequestsStateData, AccessRequestsStateErrors, AccessRequestsStateResponses, AccessRequestsSubmitData, AccessRequestsSubmitErrors, AccessRequestsSubmitResponses, AddFavoriteData, AddFavoriteErrors, AddFavoriteResponses, AddParticipantsData, AddParticipantsErrors, AddParticipantsResponses, AddPinHandlerData, AddPinHandlerErrors, AddPinHandlerResponses, ApplyCrmPipelineOpsData, ApplyCrmPipelineOpsResponses, ApplyDatabaseOpsData, ApplyDatabaseOpsErrors, ApplyDatabaseOpsResponses, ApproveHarnessPairingData, ApproveHarnessPairingErrors, ApproveHarnessPairingResponses, BlockCrmDomainData, BlockCrmDomainErrors, BlockCrmDomainResponses, BulkWakeupSyncServiceDocumentsData, BulkWakeupSyncServiceDocumentsErrors, BulkWakeupSyncServiceDocumentsResponses, CallWebhookData, CallWebhookErrors, CallWebhookResponses, CancelSlackImportData, CancelSlackImportErrors, CancelSlackImportResponses, CheckActiveCallData, CheckActiveCallErrors, CheckActiveCallResponses, ClaimHarnessPairingData, ClaimHarnessPairingErrors, ClaimHarnessPairingResponses, CollaborateFormData, CollaborateFormErrors, CollaborateFormResponses, CompleteSlackImportUploadsData, CompleteSlackImportUploadsErrors, CompleteSlackImportUploadsResponses, ConvertDatabaseColumnData, ConvertDatabaseColumnErrors, ConvertDatabaseColumnResponses, CopyDocumentData, CopyDocumentErrors, CopyDocumentResponses, CreateAgentData, CreateAgentErrors, CreateAgentResponses, CreateAnchorData, CreateAnchorErrors, CreateAnchorResponses, CreateCanvasHandlerData, CreateCanvasHandlerErrors, CreateCanvasHandlerResponses, CreateChannelData, CreateChannelErrors, CreateChannelLabelData, CreateChannelLabelErrors, CreateChannelLabelResponses, CreateChannelResponses, CreateChannelScopedBotData, CreateChannelScopedBotErrors, CreateChannelScopedBotResponses, CreateCollabSurfaceTokenData, CreateCollabSurfaceTokenErrors, CreateCollabSurfaceTokenResponses, CreateCrmCompanyData, CreateCrmCompanyErrors, CreateCrmCompanyResponses, CreateCrmContactData, CreateCrmContactErrors, CreateCrmContactResponses, CreateCrmPipelineData, CreateCrmPipelineResponses, CreateCrmTeamContactData, CreateCrmTeamContactErrors, CreateCrmTeamContactResponses, CreateDatabaseData, CreateDatabaseErrors, CreateDatabaseResponses, CreateDatabaseWebhookData, CreateDatabaseWebhookErrors, CreateDatabaseWebhookResponses, CreateDocumentData, CreateDocumentErrors, CreateDocumentResponses, CreateEntityMentionData, CreateEntityMentionErrors, CreateEntityMentionResponses, CreateFormData, CreateFormErrors, CreateFormResponses, CreateHarnessPairingData, CreateHarnessPairingErrors, CreateHarnessPairingResponses, CreateInitiativeData, CreateInitiativeErrors, CreateInitiativeResponses, CreateInstructionsHandlerData, CreateInstructionsHandlerErrors, CreateInstructionsHandlerResponses, CreateMarkdownHandlerData, CreateMarkdownHandlerErrors, CreateMarkdownHandlerResponses, CreateProjectHandlerData, CreateProjectHandlerErrors, CreateProjectHandlerResponses, CreateSkillHandlerData, CreateSkillHandlerErrors, CreateSkillHandlerResponses, CreateSlackImportData, CreateSlackImportErrors, CreateSlackImportResponses, CreateSnippetHandlerData, CreateSnippetHandlerErrors, CreateSnippetHandlerResponses, CreateTaskHandlerData, CreateTaskHandlerErrors, CreateTaskHandlerResponses, CreateUserApiKeyData, CreateUserApiKeyErrors, CreateUserApiKeyResponses, CreateViewHandlerData, CreateViewHandlerErrors, CreateViewHandlerResponses, CreateWebhookData, CreateWebhookErrors, CreateWebhookResponses, DeclineCallData, DeclineCallErrors, DeclineCallResponses, DeclineRingData, DeclineRingErrors, DeclineRingResponses, DeleteAnchorData, DeleteAnchorErrors, DeleteAnchorResponses, DeleteCallRecordData, DeleteCallRecordErrors, DeleteCallRecordResponses, DeleteChannelData, DeleteChannelErrors, DeleteChannelLabelData, DeleteChannelLabelErrors, DeleteChannelLabelResponses, DeleteChannelResponses, DeleteCollabSurfaceData, DeleteCollabSurfaceErrors, DeleteCollabSurfaceResponses, DeleteDatabaseWebhookData, DeleteDatabaseWebhookErrors, DeleteDatabaseWebhookResponses, DeleteDocumentData, DeleteDocumentErrors, DeleteDocumentResponses, DeleteEntityMentionData, DeleteEntityMentionErrors, DeleteEntityMentionResponses, DeleteHarnessData, DeleteHarnessErrors, DeleteHarnessResponses, DeleteHistoryHandlerData, DeleteHistoryHandlerErrors, DeleteHistoryHandlerResponses, DeleteInitiativeData, DeleteInitiativeErrors, DeleteInitiativeResponses, DeleteProjectHandlerData, DeleteProjectHandlerErrors, DeleteProjectHandlerResponses, DeleteSelfHarnessData, DeleteSelfHarnessErrors, DeleteSelfHarnessResponses, DeleteUserApiKeyData, DeleteUserApiKeyErrors, DeleteUserApiKeyResponses, DeleteUserDocumentViewLocationData, DeleteUserDocumentViewLocationErrors, DeleteUserDocumentViewLocationResponses, DeleteViewHandlerData, DeleteViewHandlerErrors, DeleteViewHandlerResponses, DeleteWebhookData, DeleteWebhookErrors, DeleteWebhookResponses, DeliverDatabaseWebhookData, DeliverDatabaseWebhookErrors, DeliverDatabaseWebhookResponses, DuplicateDatabaseData, DuplicateDatabaseErrors, DuplicateDatabaseResponses, EditAnchorData, EditAnchorErrors, EditAnchorResponses, EditCallRecordData, EditCallRecordErrors, EditCallRecordResponses, EditCallTranscriptData, EditCallTranscriptErrors, EditCallTranscriptResponses, EditDocumentData, EditDocumentErrors, EditDocumentResponses, EditDocumentWithAiData, EditDocumentWithAiErrors, EditDocumentWithAiResponses, EditMyFormResponseData, EditMyFormResponseErrors, EditMyFormResponseResponses, EditProjectV2Data, EditProjectV2Errors, EditProjectV2Responses, EditThreadV2Data, EditThreadV2Errors, EditThreadV2Responses, EnsureCollabSurfaceData, EnsureCollabSurfaceErrors, EnsureCollabSurfaceResponses, EnsureStarterHandlerData, EnsureStarterHandlerErrors, EnsureStarterHandlerResponses, EntityMessageCreateData, EntityMessageCreateResponses, EntityMessageDeleteMessageData, EntityMessageDeleteMessageResponses, EntityMessageDeleteThreadData, EntityMessageDeleteThreadResponses, EntityMessageEditData, EntityMessageEditResponses, EntityMessageGetMessageData, EntityMessageGetMessageResponses, EntityMessageGetThreadData, EntityMessageGetThreadResponses, EntityMessageLegacyData, EntityMessageLegacyResponses, EntityMessagePatchThreadData, EntityMessagePatchThreadResponses, EntityMessageReactData, EntityMessageReactResponses, EntityMessageTypingData, EntityMessageTypingResponses, EventIcsData, EventIcsErrors, EventIcsResponses, ExcludeDefaultViewHandlerData, ExcludeDefaultViewHandlerErrors, ExcludeDefaultViewHandlerResponses, ExportDocumentData, ExportDocumentErrors, ExportDocumentResponses, ExternalChatAddData, ExternalChatAddResponses, ExternalChatData, ExternalChatDeliveryData, ExternalChatDeliveryResponses, ExternalChatMessageAttachmentsData, ExternalChatMessageAttachmentsResponses, ExternalChatMessageData, ExternalChatMessageResponses, ExternalChatMessagesData, ExternalChatMessagesResponses, ExternalChatPermissionsData, ExternalChatPermissionsResponses, ExternalChatReadData, ExternalChatReadResponses, ExternalChatRemoveData, ExternalChatRemoveResponses, ExternalChatResponses, ExternalChatsData, ExternalChatSendData, ExternalChatSendErrors, ExternalChatSendResponses, ExternalChatSendsData, ExternalChatSendsResponses, ExternalChatsResponses, ExternalChatUpdatePermissionsData, ExternalChatUpdatePermissionsResponses, ExternalChatUploadData, ExternalChatUploadResponses, FinalizeSlackImportData, FinalizeSlackImportErrors, FinalizeSlackImportResponses, GetActiveCallsData, GetActiveCallsErrors, GetActiveCallsResponses, GetActivityData, GetActivityErrors, GetActivityResponses, GetAttachmentReferencesData, GetAttachmentReferencesErrors, GetAttachmentReferencesResponses, GetBatchCallRecordPreviewData, GetBatchCallRecordPreviewErrors, GetBatchCallRecordPreviewResponses, GetBatchChannelPreviewData, GetBatchChannelPreviewErrors, GetBatchChannelPreviewResponses, GetBatchPreviewHandlerData, GetBatchPreviewHandlerErrors, GetBatchPreviewHandlerResponses, GetBatchProjectPreviewData, GetBatchProjectPreviewErrors, GetBatchProjectPreviewResponses, GetBotOwnerProfilesData, GetBotOwnerProfilesErrors, GetBotOwnerProfilesResponses, GetCallRecordData, GetCallRecordErrors, GetCallRecordResponses, GetChannelAttachmentsData, GetChannelAttachmentsErrors, GetChannelAttachmentsResponses, GetChannelData, GetChannelErrors, GetChannelJoinLinkData, GetChannelJoinLinkErrors, GetChannelJoinLinkResponses, GetChannelParticipantsData, GetChannelParticipantsErrors, GetChannelParticipantsResponses, GetChannelResponses, GetChannelsData, GetChannelsErrors, GetChannelsResponses, GetCollabSurfaceData, GetCollabSurfaceErrors, GetCollabSurfaceResponses, GetCompanyData, GetCompanyErrors, GetCompanyResponses, GetContactByEmailData, GetContactByEmailErrors, GetContactByEmailResponses, GetContactData, GetContactErrors, GetContactResponses, GetCrmPipelineData, GetCrmPipelinePermissionsData, GetCrmPipelinePermissionsResponses, GetCrmPipelineResponses, GetCrmPipelineRowsData, GetCrmPipelineRowsResponses, GetCrmPipelineTableData, GetCrmPipelineTableResponses, GetCrmPipelineViewPositionsData, GetCrmPipelineViewPositionsResponses, GetCrmTeamSettingsData, GetCrmTeamSettingsErrors, GetCrmTeamSettingsResponses, GetDatabaseData, GetDatabaseErrors, GetDatabasePermissionsData, GetDatabasePermissionsErrors, GetDatabasePermissionsResponses, GetDatabaseQueryData, GetDatabaseQueryErrors, GetDatabaseQueryResponses, GetDatabaseResponses, GetDatabaseRowHistoryData, GetDatabaseRowHistoryErrors, GetDatabaseRowHistoryResponses, GetDatabaseTableChangesData, GetDatabaseTableChangesErrors, GetDatabaseTableChangesResponses, GetDatabaseViewPositionsData, GetDatabaseViewPositionsErrors, GetDatabaseViewPositionsResponses, GetDocumentAnchorsData, GetDocumentAnchorsErrors, GetDocumentAnchorsResponses, GetDocumentBranchNameData, GetDocumentBranchNameErrors, GetDocumentBranchNameResponses, GetDocumentByTeamSlugData, GetDocumentByTeamSlugErrors, GetDocumentByTeamSlugResponses, GetDocumentData, GetDocumentErrors, GetDocumentGithubPullRequestsData, GetDocumentGithubPullRequestsErrors, GetDocumentGithubPullRequestsResponses, GetDocumentListHandlerData, GetDocumentListHandlerErrors, GetDocumentListHandlerResponses, GetDocumentLocationV3Data, GetDocumentLocationV3Errors, GetDocumentLocationV3Responses, GetDocumentPermissionsTokenData, GetDocumentPermissionsTokenErrors, GetDocumentPermissionsTokenResponses, GetDocumentPermissionsV2Data, GetDocumentPermissionsV2Errors, GetDocumentPermissionsV2Responses, GetDocumentProcessingResultData, GetDocumentProcessingResultErrors, GetDocumentProcessingResultResponses, GetDocumentResponses, GetDocumentShortIdData, GetDocumentShortIdErrors, GetDocumentShortIdResponses, GetDocumentTeamShareData, GetDocumentTeamShareErrors, GetDocumentTeamShareResponses, GetDocumentTextContentData, GetDocumentTextContentErrors, GetDocumentTextContentResponses, GetDocumentVersionData, GetDocumentVersionErrors, GetDocumentVersionResponses, GetDocumentViewsHandlerData, GetDocumentViewsHandlerErrors, GetDocumentViewsHandlerResponses, GetEmailFollowupData, GetEmailFollowupErrors, GetEmailFollowupResponses, GetEntityPermissionData, GetEntityPermissionErrors, GetEntityPermissionResponses, GetForeignEntityBySourceData, GetForeignEntityBySourceErrors, GetForeignEntityBySourceResponses, GetForeignEntityData, GetForeignEntityErrors, GetForeignEntityResponses, GetFormData, GetFormErrors, GetFormPermissionsData, GetFormPermissionsErrors, GetFormPermissionsResponses, GetFormResponses, GetFormResponseSummaryData, GetFormResponseSummaryErrors, GetFormResponseSummaryResponses, GetFormTallyData, GetFormTallyErrors, GetFormTallyResponses, GetGithubPullRequestChangesData, GetGithubPullRequestChangesErrors, GetGithubPullRequestChangesPatchData, GetGithubPullRequestChangesPatchErrors, GetGithubPullRequestChangesPatchResponses, GetGithubPullRequestChangesResponses, GetGithubPullRequestData, GetGithubPullRequestErrors, GetGithubPullRequestFacetsData, GetGithubPullRequestFacetsErrors, GetGithubPullRequestFacetsResponses, GetGithubPullRequestResponses, GetGithubPullRequestTasksData, GetGithubPullRequestTasksErrors, GetGithubPullRequestTasksResponses, GetHarnessPairingData, GetHarnessPairingErrors, GetHarnessPairingResponses, GetHistoryHandlerData, GetHistoryHandlerErrors, GetHistoryHandlerResponses, GetInitiativeData, GetInitiativeErrors, GetInitiativeResponses, GetInstructionsHandlerData, GetInstructionsHandlerErrors, GetInstructionsHandlerResponses, GetItemsSoupData, GetItemsSoupErrors, GetItemsSoupResponses, GetLocationHandlerData, GetLocationHandlerErrors, GetLocationHandlerResponses, GetMyFormResponseData, GetMyFormResponseErrors, GetMyFormResponseResponses, GetOrCreateCallData, GetOrCreateCallErrors, GetOrCreateCallResponses, GetOrCreateDmData, GetOrCreateDmErrors, GetOrCreateDmResponses, GetOrCreatePrivateData, GetOrCreatePrivateErrors, GetOrCreatePrivateResponses, GetPendingProjectsHandlerData, GetPendingProjectsHandlerErrors, GetPendingProjectsHandlerResponses, GetPinsHandlerData, GetPinsHandlerErrors, GetPinsHandlerResponses, GetProjectContentHandlerData, GetProjectContentHandlerErrors, GetProjectContentHandlerResponses, GetProjectHandlerData, GetProjectHandlerErrors, GetProjectHandlerResponses, GetProjectPermissionsV2Data, GetProjectPermissionsV2Errors, GetProjectPermissionsV2Responses, GetProjectsHandlerData, GetProjectsHandlerErrors, GetProjectsHandlerResponses, GetProjectUserAccessLevelData, GetProjectUserAccessLevelErrors, GetProjectUserAccessLevelResponses, GetRingStatusData, GetRingStatusErrors, GetRingStatusResponses, GetSelfBotData, GetSelfBotErrors, GetSelfBotResponses, GetSelfHarnessData, GetSelfHarnessErrors, GetSelfHarnessResponses, GetSkillDescriptionData, GetSkillDescriptionErrors, GetSkillDescriptionResponses, GetSlackImportData, GetSlackImportErrors, GetSlackImportResponses, GetSystemSkillsHandlerData, GetSystemSkillsHandlerErrors, GetSystemSkillsHandlerResponses, GetUserDocumentsHandlerData, GetUserDocumentsHandlerErrors, GetUserDocumentsHandlerResponses, GetUserDocumentViewLocationData, GetUserDocumentViewLocationErrors, GetUserDocumentViewLocationResponses, GetViewsHandlerData, GetViewsHandlerErrors, GetViewsHandlerResponses, GetWebhookData, GetWebhookErrors, GetWebhookResponses, GuestCallChatPostData, GuestCallChatPostErrors, GuestCallChatPostResponses, GuestCallChatReadData, GuestCallChatReadErrors, GuestCallChatReadResponses, HandlerData, HandlerErrors, HandlerResponses, HealthHandlerData, HealthHandlerResponses, ImportDatabaseTableData, ImportDatabaseTableErrors, ImportDatabaseTableResponses, InferDatabaseColumnTypeData, InferDatabaseColumnTypeErrors, InferDatabaseColumnTypeResponses, IngestTranscriptData, IngestTranscriptErrors, IngestTranscriptResponses, InitializeUserDocumentsData, InitializeUserDocumentsErrors, InitializeUserDocumentsResponses, InstallSyncData, InstallSyncErrors, JobProcessingResultHandlerData, JobProcessingResultHandlerErrors, JobProcessingResultHandlerResponses, JoinChannelByCodeData, JoinChannelByCodeErrors, JoinChannelByCodeResponses, JoinChannelData, JoinChannelErrors, JoinChannelResponses, LeaveChannelData, LeaveChannelErrors, LeaveChannelResponses, LeaveOrEndCallData, LeaveOrEndCallErrors, LeaveOrEndCallResponses, ListAccessibleFormsData, ListAccessibleFormsErrors, ListAccessibleFormsResponses, ListAgentsData, ListAgentsErrors, ListAgentsResponses, ListBotChannelsData, ListBotChannelsErrors, ListBotChannelsResponses, ListChannelLabelsData, ListChannelLabelsErrors, ListChannelLabelsResponses, ListCompanyContactsData, ListCompanyContactsErrors, ListCompanyContactsResponses, ListCrmBlockedDomainsData, ListCrmBlockedDomainsErrors, ListCrmBlockedDomainsResponses, ListCrmPipelinesData, ListCrmPipelinesResponses, ListDatabaseColumnCastsData, ListDatabaseColumnCastsErrors, ListDatabaseColumnCastsResponses, ListDatabasesData, ListDatabasesErrors, ListDatabasesResponses, ListDatabaseWebhooksData, ListDatabaseWebhooksErrors, ListDatabaseWebhooksResponses, ListEmailRemindersData, ListEmailRemindersErrors, ListEmailRemindersResponses, ListFavoritesData, ListFavoritesErrors, ListFavoritesResponses, ListFormsData, ListFormsErrors, ListFormsResponses, ListHarnessAgentsData, ListHarnessAgentsErrors, ListHarnessAgentsResponses, ListHarnessesData, ListHarnessesErrors, ListHarnessesResponses, ListHarnessSessionsData, ListHarnessSessionsErrors, ListHarnessSessionsResponses, ListInitiativesData, ListInitiativesErrors, ListInitiativesResponses, ListJoinRequestsData, ListJoinRequestsErrors, ListJoinRequestsResponses, ListOccurrencesData, ListOccurrencesErrors, ListOccurrencesResponses, ListSlackImportsData, ListSlackImportsResponses, ListTeamCalendarData, ListTeamCalendarResponses, ListTeamOutOfOfficeData, ListTeamOutOfOfficeErrors, ListTeamOutOfOfficeResponses, ListUserApiKeysData, ListUserApiKeysErrors, ListUserApiKeysResponses, ListWebhooksData, ListWebhooksErrors, ListWebhooksResponses, MeetingCancelData, MeetingCancelErrors, MeetingCancelPreparationData, MeetingCancelPreparationErrors, MeetingCancelPreparationResponses, MeetingCancelResponses, MeetingCreateData, MeetingCreateErrors, MeetingCreateResponses, MeetingGuestJoinData, MeetingGuestJoinErrors, MeetingGuestJoinResponses, MeetingGuestParticipantsData, MeetingGuestParticipantsErrors, MeetingGuestParticipantsResponses, MeetingInviteData, MeetingInviteErrors, MeetingInvitePermissionsData, MeetingInvitePermissionsErrors, MeetingInvitePermissionsResponses, MeetingInviteResponses, MeetingInviteUsersData, MeetingInviteUsersErrors, MeetingInviteUsersResponses, MeetingJoinData, MeetingJoinErrors, MeetingJoinResponses, MeetingLeaveData, MeetingLeaveErrors, MeetingLeaveResponses, MeetingListActiveData, MeetingListActiveErrors, MeetingListActiveResponses, MeetingListData, MeetingListErrors, MeetingListResponses, MeetingLookupData, MeetingLookupErrors, MeetingLookupResponses, MeetingParticipantsData, MeetingParticipantsErrors, MeetingParticipantsResponses, MeetingPrepareData, MeetingPrepareErrors, MeetingPrepareResponses, MeetingShareData, MeetingShareErrors, MeetingShareResponses, MeetingUpdateData, MeetingUpdateErrors, MeetingUpdateResponses, MentionPreviewsData, MentionPreviewsErrors, MentionPreviewsResponses, MessageTimelineData, MessageTimelineEntriesData, MessageTimelineEntriesResponses, MessageTimelineResponses, PatchChannelData, PatchChannelErrors, PatchChannelResponses, PatchViewHandlerData, PatchViewHandlerErrors, PatchViewHandlerResponses, PatchWebhookData, PatchWebhookErrors, PatchWebhookResponses, PermanentlyDeleteDocumentData, PermanentlyDeleteDocumentErrors, PermanentlyDeleteDocumentResponses, PermanentlyDeleteProjectData, PermanentlyDeleteProjectErrors, PermanentlyDeleteProjectResponses, PostActivityData, PostActivityErrors, PostActivityResponses, PostChannelBotWebhookData, PostChannelBotWebhookErrors, PostChannelBotWebhookResponses, PostItemsSoupAstData, PostItemsSoupAstErrors, PostItemsSoupAstGroupedData, PostItemsSoupAstGroupedErrors, PostItemsSoupAstGroupedResponses, PostItemsSoupAstResponses, PostItemsSoupData, PostItemsSoupErrors, PostItemsSoupResponses, PresaveDocumentHandlerData, PresaveDocumentHandlerErrors, PresaveDocumentHandlerResponses, PreviewSmartTagData, PreviewSmartTagErrors, PreviewSmartTagResponses, PutCrmTeamSettingsData, PutCrmTeamSettingsErrors, PutCrmTeamSettingsResponses, PutCrmTeamStagesData, PutCrmTeamStagesErrors, PutCrmTeamStagesResponses, PutFormLayoutData, PutFormLayoutErrors, PutFormLayoutResponses, QueryCrmPipelineRowsData, QueryCrmPipelineRowsResponses, QueryDatabasesData, QueryDatabasesErrors, QueryDatabasesResponses, RecentlyDeletedData, RecentlyDeletedErrors, RecentlyDeletedResponses, RegisterSlackImportUploadsData, RegisterSlackImportUploadsErrors, RegisterSlackImportUploadsResponses, RemoveBotFromChannelByBotData, RemoveBotFromChannelByBotErrors, RemoveBotFromChannelByBotResponses, RemoveFavoriteByEntityData, RemoveFavoriteByEntityErrors, RemoveFavoriteByEntityResponses, RemoveParticipantsData, RemoveParticipantsErrors, RemoveParticipantsResponses, RemovePinHandlerData, RemovePinHandlerErrors, RemovePinHandlerResponses, RenameChannelLabelData, RenameChannelLabelErrors, RenameChannelLabelResponses, RenameCrmPipelineData, RenameCrmPipelineResponses, ReorderFavoritesData, ReorderFavoritesErrors, ReorderFavoritesResponses, ReorderPinsHandlerData, ReorderPinsHandlerErrors, ReorderPinsHandlerResponses, RequestToJoinData, RequestToJoinErrors, RequestToJoinResponses, ResetCrmTeamStagesData, ResetCrmTeamStagesErrors, ResetCrmTeamStagesResponses, RevertDeleteDocumentData, RevertDeleteDocumentErrors, RevertDeleteDocumentResponses, RevertDeleteProjectData, RevertDeleteProjectErrors, RevertDeleteProjectResponses, SaveDatabaseQueryData, SaveDatabaseQueryErrors, SaveDatabaseQueryResponses, SaveDocumentHandlerData, SaveDocumentHandlerErrors, SaveDocumentHandlerResponses, SearchContactsData, SearchContactsErrors, SearchContactsResponses, SetChannelLabelData, SetChannelLabelErrors, SetChannelLabelResponses, SetChannelPictureData, SetChannelPictureErrors, SetChannelPictureResponses, SetCompanyHiddenData, SetCompanyHiddenErrors, SetCompanyHiddenResponses, SetContactHiddenData, SetContactHiddenErrors, SetContactHiddenResponses, SetCrmCompanyNameData, SetCrmCompanyNameErrors, SetCrmCompanyNameResponses, SetCrmContactNameData, SetCrmContactNameErrors, SetCrmContactNameResponses, SetDocumentTeamShareData, SetDocumentTeamShareErrors, SetDocumentTeamShareResponses, SetEmailFollowupData, SetEmailFollowupErrors, SetEmailFollowupResponses, SetEmailSyncData, SetEmailSyncErrors, SetEmailSyncResponses, SetSkillDescriptionData, SetSkillDescriptionErrors, SetSkillDescriptionResponses, ShareCrmPipelineData, ShareCrmPipelineResponses, ShareDatabaseAwarenessData, ShareDatabaseAwarenessErrors, ShareDatabaseAwarenessResponses, SimpleSaveData, SimpleSaveErrors, SimpleSaveResponses, StreamEventsData, StreamEventsErrors, StreamEventsResponse, StreamEventsResponses, SubmitFormResponseData, SubmitFormResponseErrors, SubmitFormResponseResponses, TaskSimilaritySearchHandlerData, TaskSimilaritySearchHandlerErrors, TaskSimilaritySearchHandlerResponses, ToggleShareWithTeamData, ToggleShareWithTeamErrors, ToggleShareWithTeamResponses, TranscribeDictationData, TranscribeDictationErrors, TranscribeDictationResponses, TrashCrmPipelineData, TrashCrmPipelineResponses, UnblockCrmDomainData, UnblockCrmDomainErrors, UnblockCrmDomainResponses, UndoDatabaseChangeData, UndoDatabaseChangeErrors, UndoDatabaseChangeResponses, UpdateAgentData, UpdateAgentErrors, UpdateAgentResponses, UpdateCrmPipelinePermissionsData, UpdateCrmPipelinePermissionsResponses, UpdateDatabasePermissionsData, UpdateDatabasePermissionsErrors, UpdateDatabasePermissionsResponses, UpdateFormData, UpdateFormErrors, UpdateFormPermissionsData, UpdateFormPermissionsErrors, UpdateFormPermissionsResponses, UpdateFormResponses, UpdateInitiativeData, UpdateInitiativeErrors, UpdateInitiativeResponses, UploadExtractFolderHandlerData, UploadExtractFolderHandlerErrors, UploadExtractFolderHandlerResponses, UploadFolderHandlerData, UploadFolderHandlerErrors, UploadFolderHandlerResponses, UpsertHistoryHandlerData, UpsertHistoryHandlerErrors, UpsertHistoryHandlerResponses, UpsertUserDocumentViewLocationData, UpsertUserDocumentViewLocationErrors, UpsertUserDocumentViewLocationResponses, ValidateDocumentPermissionsTokenData, ValidateDocumentPermissionsTokenErrors, ValidateDocumentPermissionsTokenResponses, ValidateWebhookData, ValidateWebhookErrors, ValidateWebhookResponses, WhatsappAccountData, WhatsappAccountResponses, WhatsappCancelPairingData, WhatsappCancelPairingResponses, WhatsappChatsData, WhatsappChatsResponses, WhatsappConnectData, WhatsappConnectResponses, WhatsappDisconnectData, WhatsappDisconnectResponses, WhatsappImportHistoryData, WhatsappImportHistoryResponses, WhatsappLookupData, WhatsappLookupResponses, WhatsappPairingData, WhatsappPairingResponses, WhatsappPasskeyData, WhatsappPasskeyResponses, WhatsappStartLookupData, WhatsappStartLookupResponses } from './types.gen';+import type { AccessRequestsCancelData, AccessRequestsCancelErrors, AccessRequestsCancelResponses, AccessRequestsDirectData, AccessRequestsDirectErrors, AccessRequestsDirectResponses, AccessRequestsRemoveDirectData, AccessRequestsRemoveDirectErrors, AccessRequestsRemoveDirectResponses, AccessRequestsResolveData, AccessRequestsResolveErrors, AccessRequestsResolveResponses, AccessRequestsSetDirectData, AccessRequestsSetDirectErrors, AccessRequestsSetDirectResponses, AccessRequestsStateData, AccessRequestsStateErrors, AccessRequestsStateResponses, AccessRequestsSubmitData, AccessRequestsSubmitErrors, AccessRequestsSubmitResponses, AddFavoriteData, AddFavoriteErrors, AddFavoriteResponses, AddParticipantsData, AddParticipantsErrors, AddParticipantsResponses, AddPinHandlerData, AddPinHandlerErrors, AddPinHandlerResponses, ApplyCrmPipelineOpsData, ApplyCrmPipelineOpsResponses, ApplyDatabaseOpsData, ApplyDatabaseOpsErrors, ApplyDatabaseOpsResponses, ApproveHarnessPairingData, ApproveHarnessPairingErrors, ApproveHarnessPairingResponses, BlockCrmDomainData, BlockCrmDomainErrors, BlockCrmDomainResponses, BulkWakeupSyncServiceDocumentsData, BulkWakeupSyncServiceDocumentsErrors, BulkWakeupSyncServiceDocumentsResponses, CallWebhookData, CallWebhookErrors, CallWebhookResponses, CancelSlackImportData, CancelSlackImportErrors, CancelSlackImportResponses, CheckActiveCallData, CheckActiveCallErrors, CheckActiveCallResponses, ClaimHarnessPairingData, ClaimHarnessPairingErrors, ClaimHarnessPairingResponses, CollaborateFormData, CollaborateFormErrors, CollaborateFormResponses, CompleteSlackImportUploadsData, CompleteSlackImportUploadsErrors, CompleteSlackImportUploadsResponses, ConvertDatabaseColumnData, ConvertDatabaseColumnErrors, ConvertDatabaseColumnResponses, CopyDocumentData, CopyDocumentErrors, CopyDocumentResponses, CreateAgentData, CreateAgentErrors, CreateAgentResponses, CreateAnchorData, CreateAnchorErrors, CreateAnchorResponses, CreateCanvasHandlerData, CreateCanvasHandlerErrors, CreateCanvasHandlerResponses, CreateChannelData, CreateChannelErrors, CreateChannelLabelData, CreateChannelLabelErrors, CreateChannelLabelResponses, CreateChannelResponses, CreateChannelScopedBotData, CreateChannelScopedBotErrors, CreateChannelScopedBotResponses, CreateCollabSurfaceTokenData, CreateCollabSurfaceTokenErrors, CreateCollabSurfaceTokenResponses, CreateCrmCompanyData, CreateCrmCompanyErrors, CreateCrmCompanyResponses, CreateCrmContactData, CreateCrmContactErrors, CreateCrmContactResponses, CreateCrmPipelineData, CreateCrmPipelineResponses, CreateCrmTeamContactData, CreateCrmTeamContactErrors, CreateCrmTeamContactResponses, CreateDatabaseData, CreateDatabaseErrors, CreateDatabaseResponses, CreateDatabaseWebhookData, CreateDatabaseWebhookErrors, CreateDatabaseWebhookResponses, CreateDocumentData, CreateDocumentErrors, CreateDocumentResponses, CreateEntityMentionData, CreateEntityMentionErrors, CreateEntityMentionResponses, CreateFormData, CreateFormErrors, CreateFormResponses, CreateHarnessPairingData, CreateHarnessPairingErrors, CreateHarnessPairingResponses, CreateInitiativeData, CreateInitiativeErrors, CreateInitiativeResponses, CreateInstructionsHandlerData, CreateInstructionsHandlerErrors, CreateInstructionsHandlerResponses, CreateMarkdownHandlerData, CreateMarkdownHandlerErrors, CreateMarkdownHandlerResponses, CreateProjectHandlerData, CreateProjectHandlerErrors, CreateProjectHandlerResponses, CreateSkillHandlerData, CreateSkillHandlerErrors, CreateSkillHandlerResponses, CreateSlackImportData, CreateSlackImportErrors, CreateSlackImportResponses, CreateSnippetHandlerData, CreateSnippetHandlerErrors, CreateSnippetHandlerResponses, CreateTaskHandlerData, CreateTaskHandlerErrors, CreateTaskHandlerResponses, CreateUserApiKeyData, CreateUserApiKeyErrors, CreateUserApiKeyResponses, CreateViewHandlerData, CreateViewHandlerErrors, CreateViewHandlerResponses, CreateWebhookData, CreateWebhookErrors, CreateWebhookResponses, DeclineCallData, DeclineCallErrors, DeclineCallResponses, DeclineRingData, DeclineRingErrors, DeclineRingResponses, DeleteAnchorData, DeleteAnchorErrors, DeleteAnchorResponses, DeleteCallRecordData, DeleteCallRecordErrors, DeleteCallRecordResponses, DeleteChannelData, DeleteChannelErrors, DeleteChannelLabelData, DeleteChannelLabelErrors, DeleteChannelLabelResponses, DeleteChannelResponses, DeleteCollabSurfaceData, DeleteCollabSurfaceErrors, DeleteCollabSurfaceResponses, DeleteDatabaseWebhookData, DeleteDatabaseWebhookErrors, DeleteDatabaseWebhookResponses, DeleteDocumentData, DeleteDocumentErrors, DeleteDocumentResponses, DeleteEntityMentionData, DeleteEntityMentionErrors, DeleteEntityMentionResponses, DeleteHarnessData, DeleteHarnessErrors, DeleteHarnessResponses, DeleteHistoryHandlerData, DeleteHistoryHandlerErrors, DeleteHistoryHandlerResponses, DeleteInitiativeData, DeleteInitiativeErrors, DeleteInitiativeResponses, DeleteProjectHandlerData, DeleteProjectHandlerErrors, DeleteProjectHandlerResponses, DeleteSelfHarnessData, DeleteSelfHarnessErrors, DeleteSelfHarnessResponses, DeleteUserApiKeyData, DeleteUserApiKeyErrors, DeleteUserApiKeyResponses, DeleteUserDocumentViewLocationData, DeleteUserDocumentViewLocationErrors, DeleteUserDocumentViewLocationResponses, DeleteViewHandlerData, DeleteViewHandlerErrors, DeleteViewHandlerResponses, DeleteWebhookData, DeleteWebhookErrors, DeleteWebhookResponses, DeliverDatabaseWebhookData, DeliverDatabaseWebhookErrors, DeliverDatabaseWebhookResponses, DuplicateDatabaseData, DuplicateDatabaseErrors, DuplicateDatabaseResponses, EditAnchorData, EditAnchorErrors, EditAnchorResponses, EditCallRecordData, EditCallRecordErrors, EditCallRecordResponses, EditCallTranscriptData, EditCallTranscriptErrors, EditCallTranscriptResponses, EditDocumentData, EditDocumentErrors, EditDocumentResponses, EditDocumentWithAiData, EditDocumentWithAiErrors, EditDocumentWithAiResponses, EditMyFormResponseData, EditMyFormResponseErrors, EditMyFormResponseResponses, EditProjectV2Data, EditProjectV2Errors, EditProjectV2Responses, EditThreadV2Data, EditThreadV2Errors, EditThreadV2Responses, EnsureCollabSurfaceData, EnsureCollabSurfaceErrors, EnsureCollabSurfaceResponses, EnsureStarterHandlerData, EnsureStarterHandlerErrors, EnsureStarterHandlerResponses, EntityMessageCreateData, EntityMessageCreateResponses, EntityMessageDeleteMessageData, EntityMessageDeleteMessageResponses, EntityMessageDeleteThreadData, EntityMessageDeleteThreadResponses, EntityMessageEditData, EntityMessageEditResponses, EntityMessageGetMessageData, EntityMessageGetMessageResponses, EntityMessageGetThreadData, EntityMessageGetThreadResponses, EntityMessageLegacyData, EntityMessageLegacyResponses, EntityMessagePatchThreadData, EntityMessagePatchThreadResponses, EntityMessageReactData, EntityMessageReactResponses, EntityMessageTypingData, EntityMessageTypingResponses, EventIcsData, EventIcsErrors, EventIcsResponses, ExcludeDefaultViewHandlerData, ExcludeDefaultViewHandlerErrors, ExcludeDefaultViewHandlerResponses, ExportDocumentData, ExportDocumentErrors, ExportDocumentResponses, ExternalChatAddData, ExternalChatAddResponses, ExternalChatData, ExternalChatDeliveryData, ExternalChatDeliveryResponses, ExternalChatMessageAttachmentsData, ExternalChatMessageAttachmentsResponses, ExternalChatMessageData, ExternalChatMessageResponses, ExternalChatMessagesData, ExternalChatMessagesResponses, ExternalChatPermissionsData, ExternalChatPermissionsResponses, ExternalChatReadData, ExternalChatReadResponses, ExternalChatRemoveData, ExternalChatRemoveResponses, ExternalChatResponses, ExternalChatsData, ExternalChatSendData, ExternalChatSendErrors, ExternalChatSendResponses, ExternalChatSendsData, ExternalChatSendsResponses, ExternalChatsResponses, ExternalChatUpdatePermissionsData, ExternalChatUpdatePermissionsResponses, ExternalChatUploadData, ExternalChatUploadResponses, FinalizeSlackImportData, FinalizeSlackImportErrors, FinalizeSlackImportResponses, GetActiveCallsData, GetActiveCallsErrors, GetActiveCallsResponses, GetActivityData, GetActivityErrors, GetActivityResponses, GetAttachmentReferencesData, GetAttachmentReferencesErrors, GetAttachmentReferencesResponses, GetBatchCallRecordPreviewData, GetBatchCallRecordPreviewErrors, GetBatchCallRecordPreviewResponses, GetBatchChannelPreviewData, GetBatchChannelPreviewErrors, GetBatchChannelPreviewResponses, GetBatchPreviewHandlerData, GetBatchPreviewHandlerErrors, GetBatchPreviewHandlerResponses, GetBatchProjectPreviewData, GetBatchProjectPreviewErrors, GetBatchProjectPreviewResponses, GetBotOwnerProfilesData, GetBotOwnerProfilesErrors, GetBotOwnerProfilesResponses, GetCallRecordData, GetCallRecordErrors, GetCallRecordResponses, GetChannelAttachmentsData, GetChannelAttachmentsErrors, GetChannelAttachmentsResponses, GetChannelData, GetChannelErrors, GetChannelJoinLinkData, GetChannelJoinLinkErrors, GetChannelJoinLinkResponses, GetChannelParticipantsData, GetChannelParticipantsErrors, GetChannelParticipantsResponses, GetChannelResponses, GetChannelsData, GetChannelsErrors, GetChannelsResponses, GetCollabSurfaceData, GetCollabSurfaceErrors, GetCollabSurfaceResponses, GetCompanyData, GetCompanyErrors, GetCompanyResponses, GetContactByEmailData, GetContactByEmailErrors, GetContactByEmailResponses, GetContactData, GetContactErrors, GetContactResponses, GetCrmPipelineData, GetCrmPipelinePermissionsData, GetCrmPipelinePermissionsResponses, GetCrmPipelineResponses, GetCrmPipelineRowsData, GetCrmPipelineRowsResponses, GetCrmPipelineStageRequirementsData, GetCrmPipelineStageRequirementsResponses, GetCrmPipelineTableData, GetCrmPipelineTableResponses, GetCrmPipelineViewPositionsData, GetCrmPipelineViewPositionsResponses, GetCrmTeamSettingsData, GetCrmTeamSettingsErrors, GetCrmTeamSettingsResponses, GetDatabaseData, GetDatabaseErrors, GetDatabasePermissionsData, GetDatabasePermissionsErrors, GetDatabasePermissionsResponses, GetDatabaseQueryData, GetDatabaseQueryErrors, GetDatabaseQueryResponses, GetDatabaseResponses, GetDatabaseRowHistoryData, GetDatabaseRowHistoryErrors, GetDatabaseRowHistoryResponses, GetDatabaseTableChangesData, GetDatabaseTableChangesErrors, GetDatabaseTableChangesResponses, GetDatabaseViewPositionsData, GetDatabaseViewPositionsErrors, GetDatabaseViewPositionsResponses, GetDocumentAnchorsData, GetDocumentAnchorsErrors, GetDocumentAnchorsResponses, GetDocumentBranchNameData, GetDocumentBranchNameErrors, GetDocumentBranchNameResponses, GetDocumentByTeamSlugData, GetDocumentByTeamSlugErrors, GetDocumentByTeamSlugResponses, GetDocumentData, GetDocumentErrors, GetDocumentGithubPullRequestsData, GetDocumentGithubPullRequestsErrors, GetDocumentGithubPullRequestsResponses, GetDocumentListHandlerData, GetDocumentListHandlerErrors, GetDocumentListHandlerResponses, GetDocumentLocationV3Data, GetDocumentLocationV3Errors, GetDocumentLocationV3Responses, GetDocumentPermissionsTokenData, GetDocumentPermissionsTokenErrors, GetDocumentPermissionsTokenResponses, GetDocumentPermissionsV2Data, GetDocumentPermissionsV2Errors, GetDocumentPermissionsV2Responses, GetDocumentProcessingResultData, GetDocumentProcessingResultErrors, GetDocumentProcessingResultResponses, GetDocumentResponses, GetDocumentShortIdData, GetDocumentShortIdErrors, GetDocumentShortIdResponses, GetDocumentTeamShareData, GetDocumentTeamShareErrors, GetDocumentTeamShareResponses, GetDocumentTextContentData, GetDocumentTextContentErrors, GetDocumentTextContentResponses, GetDocumentVersionData, GetDocumentVersionErrors, GetDocumentVersionResponses, GetDocumentViewsHandlerData, GetDocumentViewsHandlerErrors, GetDocumentViewsHandlerResponses, GetEmailFollowupData, GetEmailFollowupErrors, GetEmailFollowupResponses, GetEntityPermissionData, GetEntityPermissionErrors, GetEntityPermissionResponses, GetForeignEntityBySourceData, GetForeignEntityBySourceErrors, GetForeignEntityBySourceResponses, GetForeignEntityData, GetForeignEntityErrors, GetForeignEntityResponses, GetFormData, GetFormErrors, GetFormPermissionsData, GetFormPermissionsErrors, GetFormPermissionsResponses, GetFormResponses, GetFormResponseSummaryData, GetFormResponseSummaryErrors, GetFormResponseSummaryResponses, GetFormTallyData, GetFormTallyErrors, GetFormTallyResponses, GetGithubPullRequestChangesData, GetGithubPullRequestChangesErrors, GetGithubPullRequestChangesPatchData, GetGithubPullRequestChangesPatchErrors, GetGithubPullRequestChangesPatchResponses, GetGithubPullRequestChangesResponses, GetGithubPullRequestData, GetGithubPullRequestErrors, GetGithubPullRequestFacetsData, GetGithubPullRequestFacetsErrors, GetGithubPullRequestFacetsResponses, GetGithubPullRequestResponses, GetGithubPullRequestTasksData, GetGithubPullRequestTasksErrors, GetGithubPullRequestTasksResponses, GetHarnessPairingData, GetHarnessPairingErrors, GetHarnessPairingResponses, GetHistoryHandlerData, GetHistoryHandlerErrors, GetHistoryHandlerResponses, GetInitiativeData, GetInitiativeErrors, GetInitiativeResponses, GetInstructionsHandlerData, GetInstructionsHandlerErrors, GetInstructionsHandlerResponses, GetItemsSoupData, GetItemsSoupErrors, GetItemsSoupResponses, GetLocationHandlerData, GetLocationHandlerErrors, GetLocationHandlerResponses, GetMyFormResponseData, GetMyFormResponseErrors, GetMyFormResponseResponses, GetOrCreateCallData, GetOrCreateCallErrors, GetOrCreateCallResponses, GetOrCreateDmData, GetOrCreateDmErrors, GetOrCreateDmResponses, GetOrCreatePrivateData, GetOrCreatePrivateErrors, GetOrCreatePrivateResponses, GetPendingProjectsHandlerData, GetPendingProjectsHandlerErrors, GetPendingProjectsHandlerResponses, GetPinsHandlerData, GetPinsHandlerErrors, GetPinsHandlerResponses, GetProjectContentHandlerData, GetProjectContentHandlerErrors, GetProjectContentHandlerResponses, GetProjectHandlerData, GetProjectHandlerErrors, GetProjectHandlerResponses, GetProjectPermissionsV2Data, GetProjectPermissionsV2Errors, GetProjectPermissionsV2Responses, GetProjectsHandlerData, GetProjectsHandlerErrors, GetProjectsHandlerResponses, GetProjectUserAccessLevelData, GetProjectUserAccessLevelErrors, GetProjectUserAccessLevelResponses, GetRingStatusData, GetRingStatusErrors, GetRingStatusResponses, GetSelfBotData, GetSelfBotErrors, GetSelfBotResponses, GetSelfHarnessData, GetSelfHarnessErrors, GetSelfHarnessResponses, GetSkillDescriptionData, GetSkillDescriptionErrors, GetSkillDescriptionResponses, GetSlackImportData, GetSlackImportErrors, GetSlackImportResponses, GetSystemSkillsHandlerData, GetSystemSkillsHandlerErrors, GetSystemSkillsHandlerResponses, GetUserDocumentsHandlerData, GetUserDocumentsHandlerErrors, GetUserDocumentsHandlerResponses, GetUserDocumentViewLocationData, GetUserDocumentViewLocationErrors, GetUserDocumentViewLocationResponses, GetViewsHandlerData, GetViewsHandlerErrors, GetViewsHandlerResponses, GetWebhookData, GetWebhookErrors, GetWebhookResponses, GuestCallChatPostData, GuestCallChatPostErrors, GuestCallChatPostResponses, GuestCallChatReadData, GuestCallChatReadErrors, GuestCallChatReadResponses, HandlerData, HandlerErrors, HandlerResponses, HealthHandlerData, HealthHandlerResponses, ImportDatabaseTableData, ImportDatabaseTableErrors, ImportDatabaseTableResponses, InferDatabaseColumnTypeData, InferDatabaseColumnTypeErrors, InferDatabaseColumnTypeResponses, IngestTranscriptData, IngestTranscriptErrors, IngestTranscriptResponses, InitializeUserDocumentsData, InitializeUserDocumentsErrors, InitializeUserDocumentsResponses, InstallSyncData, InstallSyncErrors, JobProcessingResultHandlerData, JobProcessingResultHandlerErrors, JobProcessingResultHandlerResponses, JoinChannelByCodeData, JoinChannelByCodeErrors, JoinChannelByCodeResponses, JoinChannelData, JoinChannelErrors, JoinChannelResponses, LeaveChannelData, LeaveChannelErrors, LeaveChannelResponses, LeaveOrEndCallData, LeaveOrEndCallErrors, LeaveOrEndCallResponses, ListAccessibleFormsData, ListAccessibleFormsErrors, ListAccessibleFormsResponses, ListAgentsData, ListAgentsErrors, ListAgentsResponses, ListBotChannelsData, ListBotChannelsErrors, ListBotChannelsResponses, ListChannelLabelsData, ListChannelLabelsErrors, ListChannelLabelsResponses, ListCompanyContactsData, ListCompanyContactsErrors, ListCompanyContactsResponses, ListCrmBlockedDomainsData, ListCrmBlockedDomainsErrors, ListCrmBlockedDomainsResponses, ListCrmPipelinesData, ListCrmPipelinesResponses, ListDatabaseColumnCastsData, ListDatabaseColumnCastsErrors, ListDatabaseColumnCastsResponses, ListDatabasesData, ListDatabasesErrors, ListDatabasesResponses, ListDatabaseWebhooksData, ListDatabaseWebhooksErrors, ListDatabaseWebhooksResponses, ListEmailRemindersData, ListEmailRemindersErrors, ListEmailRemindersResponses, ListFavoritesData, ListFavoritesErrors, ListFavoritesResponses, ListFormsData, ListFormsErrors, ListFormsResponses, ListHarnessAgentsData, ListHarnessAgentsErrors, ListHarnessAgentsResponses, ListHarnessesData, ListHarnessesErrors, ListHarnessesResponses, ListHarnessSessionsData, ListHarnessSessionsErrors, ListHarnessSessionsResponses, ListInitiativesData, ListInitiativesErrors, ListInitiativesResponses, ListJoinRequestsData, ListJoinRequestsErrors, ListJoinRequestsResponses, ListOccurrencesData, ListOccurrencesErrors, ListOccurrencesResponses, ListSlackImportsData, ListSlackImportsResponses, ListTeamCalendarData, ListTeamCalendarResponses, ListTeamOutOfOfficeData, ListTeamOutOfOfficeErrors, ListTeamOutOfOfficeResponses, ListUserApiKeysData, ListUserApiKeysErrors, ListUserApiKeysResponses, ListWebhooksData, ListWebhooksErrors, ListWebhooksResponses, MeetingCancelData, MeetingCancelErrors, MeetingCancelPreparationData, MeetingCancelPreparationErrors, MeetingCancelPreparationResponses, MeetingCancelResponses, MeetingCreateData, MeetingCreateErrors, MeetingCreateResponses, MeetingGuestJoinData, MeetingGuestJoinErrors, MeetingGuestJoinResponses, MeetingGuestParticipantsData, MeetingGuestParticipantsErrors, MeetingGuestParticipantsResponses, MeetingInviteData, MeetingInviteErrors, MeetingInvitePermissionsData, MeetingInvitePermissionsErrors, MeetingInvitePermissionsResponses, MeetingInviteResponses, MeetingInviteUsersData, MeetingInviteUsersErrors, MeetingInviteUsersResponses, MeetingJoinData, MeetingJoinErrors, MeetingJoinResponses, MeetingLeaveData, MeetingLeaveErrors, MeetingLeaveResponses, MeetingListActiveData, MeetingListActiveErrors, MeetingListActiveResponses, MeetingListData, MeetingListErrors, MeetingListResponses, MeetingLookupData, MeetingLookupErrors, MeetingLookupResponses, MeetingParticipantsData, MeetingParticipantsErrors, MeetingParticipantsResponses, MeetingPrepareData, MeetingPrepareErrors, MeetingPrepareResponses, MeetingShareData, MeetingShareErrors, MeetingShareResponses, MeetingUpdateData, MeetingUpdateErrors, MeetingUpdateResponses, MentionPreviewsData, MentionPreviewsErrors, MentionPreviewsResponses, MessageTimelineData, MessageTimelineEntriesData, MessageTimelineEntriesResponses, MessageTimelineResponses, PatchChannelData, PatchChannelErrors, PatchChannelResponses, PatchViewHandlerData, PatchViewHandlerErrors, PatchViewHandlerResponses, PatchWebhookData, PatchWebhookErrors, PatchWebhookResponses, PermanentlyDeleteDocumentData, PermanentlyDeleteDocumentErrors, PermanentlyDeleteDocumentResponses, PermanentlyDeleteProjectData, PermanentlyDeleteProjectErrors, PermanentlyDeleteProjectResponses, PostActivityData, PostActivityErrors, PostActivityResponses, PostChannelBotWebhookData, PostChannelBotWebhookErrors, PostChannelBotWebhookResponses, PostItemsSoupAstData, PostItemsSoupAstErrors, PostItemsSoupAstGroupedData, PostItemsSoupAstGroupedErrors, PostItemsSoupAstGroupedResponses, PostItemsSoupAstResponses, PostItemsSoupData, PostItemsSoupErrors, PostItemsSoupResponses, PresaveDocumentHandlerData, PresaveDocumentHandlerErrors, PresaveDocumentHandlerResponses, PreviewSmartTagData, PreviewSmartTagErrors, PreviewSmartTagResponses, PutCrmTeamSettingsData, PutCrmTeamSettingsErrors, PutCrmTeamSettingsResponses, PutCrmTeamStagesData, PutCrmTeamStagesErrors, PutCrmTeamStagesResponses, PutFormLayoutData, PutFormLayoutErrors, PutFormLayoutResponses, QueryCrmPipelineRowsData, QueryCrmPipelineRowsResponses, QueryDatabasesData, QueryDatabasesErrors, QueryDatabasesResponses, RecentlyDeletedData, RecentlyDeletedErrors, RecentlyDeletedResponses, RegisterSlackImportUploadsData, RegisterSlackImportUploadsErrors, RegisterSlackImportUploadsResponses, RemoveBotFromChannelByBotData, RemoveBotFromChannelByBotErrors, RemoveBotFromChannelByBotResponses, RemoveFavoriteByEntityData, RemoveFavoriteByEntityErrors, RemoveFavoriteByEntityResponses, RemoveParticipantsData, RemoveParticipantsErrors, RemoveParticipantsResponses, RemovePinHandlerData, RemovePinHandlerErrors, RemovePinHandlerResponses, RenameChannelLabelData, RenameChannelLabelErrors, RenameChannelLabelResponses, RenameCrmPipelineData, RenameCrmPipelineResponses, ReorderFavoritesData, ReorderFavoritesErrors, ReorderFavoritesResponses, ReorderPinsHandlerData, ReorderPinsHandlerErrors, ReorderPinsHandlerResponses, RequestToJoinData, RequestToJoinErrors, RequestToJoinResponses, ResetCrmTeamStagesData, ResetCrmTeamStagesErrors, ResetCrmTeamStagesResponses, RevertDeleteDocumentData, RevertDeleteDocumentErrors, RevertDeleteDocumentResponses, RevertDeleteProjectData, RevertDeleteProjectErrors, RevertDeleteProjectResponses, SaveDatabaseQueryData, SaveDatabaseQueryErrors, SaveDatabaseQueryResponses, SaveDocumentHandlerData, SaveDocumentHandlerErrors, SaveDocumentHandlerResponses, SearchContactsData, SearchContactsErrors, SearchContactsResponses, SetChannelLabelData, SetChannelLabelErrors, SetChannelLabelResponses, SetChannelPictureData, SetChannelPictureErrors, SetChannelPictureResponses, SetCompanyHiddenData, SetCompanyHiddenErrors, SetCompanyHiddenResponses, SetContactHiddenData, SetContactHiddenErrors, SetContactHiddenResponses, SetCrmCompanyNameData, SetCrmCompanyNameErrors, SetCrmCompanyNameResponses, SetCrmContactNameData, SetCrmContactNameErrors, SetCrmContactNameResponses, SetCrmPipelineStageRequirementData, SetCrmPipelineStageRequirementResponses, SetDocumentTeamShareData, SetDocumentTeamShareErrors, SetDocumentTeamShareResponses, SetEmailFollowupData, SetEmailFollowupErrors, SetEmailFollowupResponses, SetEmailSyncData, SetEmailSyncErrors, SetEmailSyncResponses, SetSkillDescriptionData, SetSkillDescriptionErrors, SetSkillDescriptionResponses, ShareCrmPipelineData, ShareCrmPipelineResponses, ShareDatabaseAwarenessData, ShareDatabaseAwarenessErrors, ShareDatabaseAwarenessResponses, SimpleSaveData, SimpleSaveErrors, SimpleSaveResponses, StreamEventsData, StreamEventsErrors, StreamEventsResponse, StreamEventsResponses, SubmitFormResponseData, SubmitFormResponseErrors, SubmitFormResponseResponses, TaskSimilaritySearchHandlerData, TaskSimilaritySearchHandlerErrors, TaskSimilaritySearchHandlerResponses, ToggleShareWithTeamData, ToggleShareWithTeamErrors, ToggleShareWithTeamResponses, TranscribeDictationData, TranscribeDictationErrors, TranscribeDictationResponses, TrashCrmPipelineData, TrashCrmPipelineResponses, UnblockCrmDomainData, UnblockCrmDomainErrors, UnblockCrmDomainResponses, UndoDatabaseChangeData, UndoDatabaseChangeErrors, UndoDatabaseChangeResponses, UpdateAgentData, UpdateAgentErrors, UpdateAgentResponses, UpdateCrmPipelinePermissionsData, UpdateCrmPipelinePermissionsResponses, UpdateDatabasePermissionsData, UpdateDatabasePermissionsErrors, UpdateDatabasePermissionsResponses, UpdateFormData, UpdateFormErrors, UpdateFormPermissionsData, UpdateFormPermissionsErrors, UpdateFormPermissionsResponses, UpdateFormResponses, UpdateInitiativeData, UpdateInitiativeErrors, UpdateInitiativeResponses, UploadExtractFolderHandlerData, UploadExtractFolderHandlerErrors, UploadExtractFolderHandlerResponses, UploadFolderHandlerData, UploadFolderHandlerErrors, UploadFolderHandlerResponses, UpsertHistoryHandlerData, UpsertHistoryHandlerErrors, UpsertHistoryHandlerResponses, UpsertUserDocumentViewLocationData, UpsertUserDocumentViewLocationErrors, UpsertUserDocumentViewLocationResponses, ValidateDocumentPermissionsTokenData, ValidateDocumentPermissionsTokenErrors, ValidateDocumentPermissionsTokenResponses, ValidateWebhookData, ValidateWebhookErrors, ValidateWebhookResponses, WhatsappAccountData, WhatsappAccountResponses, WhatsappCancelPairingData, WhatsappCancelPairingResponses, WhatsappChatsData, WhatsappChatsResponses, WhatsappConnectData, WhatsappConnectResponses, WhatsappDisconnectData, WhatsappDisconnectResponses, WhatsappImportHistoryData, WhatsappImportHistoryResponses, WhatsappLookupData, WhatsappLookupResponses, WhatsappPairingData, WhatsappPairingResponses, WhatsappPasskeyData, WhatsappPasskeyResponses, WhatsappStartLookupData, WhatsappStartLookupResponses } from './types.gen';export type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown> = Options2<TData, ThrowOnError, TResponse> & {/**@@ -1299,6 +1299,27 @@ export class Sdk extends HeyApiClient {});}+ /**+ * Read requirements by stable stage and field identities.+ */+ public getCrmPipelineStageRequirements<ThrowOnError extends boolean = false>(options: Options<GetCrmPipelineStageRequirementsData, ThrowOnError>): RequestResult<GetCrmPipelineStageRequirementsResponses, unknown, ThrowOnError> {+ return (options.client ?? this.client).get<GetCrmPipelineStageRequirementsResponses, unknown, ThrowOnError>({ url: '/crm/pipelines/{id}/stage-requirements', ...options });+ }++ /**+ * Replace the required fields for one stage. An empty list removes its rule.+ */+ public setCrmPipelineStageRequirement<ThrowOnError extends boolean = false>(options: Options<SetCrmPipelineStageRequirementData, ThrowOnError>): RequestResult<SetCrmPipelineStageRequirementResponses, unknown, ThrowOnError> {+ return (options.client ?? this.client).put<SetCrmPipelineStageRequirementResponses, unknown, ThrowOnError>({+ url: '/crm/pipelines/{id}/stage-requirements',+ ...options,+ headers: {+ 'Content-Type': 'application/json',+ ...options.headers+ }+ });+ }+/*** Read the host-owned table schema.*/diff --git a/packages/sdk/generated/storage/types.gen.ts b/packages/sdk/generated/storage/types.gen.tsindex d9006d265c..84a2edc86c 100644--- a/packages/sdk/generated/storage/types.gen.ts+++ b/packages/sdk/generated/storage/types.gen.ts@@ -14822,6 +14822,24 @@ export type SqlStatement = {to: string;};+/**+ * Fields required when a deal enters a particular option of a stage column.+ */+export type StageRequirement = {+ /**+ * Fields that must be present. Empty removes the rule for this stage.+ */+ requiredColumnIds: Array<string>;+ /**+ * Single-select column identifying the stage, independent of its name.+ */+ stageColumnId: string;+ /**+ * Stable option identity; renaming the stage preserves the rule.+ */+ stageId: string;+};+/*** Starter result. A missing database means the user already started or removed it.*/@@ -20072,6 +20090,36 @@ export type ShareCrmPipelineResponses = {export type ShareCrmPipelineResponse = ShareCrmPipelineResponses[keyof ShareCrmPipelineResponses];+export type GetCrmPipelineStageRequirementsData = {+ body?: never;+ path: {+ id: string;+ };+ query?: never;+ url: '/crm/pipelines/{id}/stage-requirements';+};++export type GetCrmPipelineStageRequirementsResponses = {+ 200: Array<StageRequirement>;+};++export type GetCrmPipelineStageRequirementsResponse = GetCrmPipelineStageRequirementsResponses[keyof GetCrmPipelineStageRequirementsResponses];++export type SetCrmPipelineStageRequirementData = {+ body: StageRequirement;+ path: {+ id: string;+ };+ query?: never;+ url: '/crm/pipelines/{id}/stage-requirements';+};++export type SetCrmPipelineStageRequirementResponses = {+ 204: void;+};++export type SetCrmPipelineStageRequirementResponse = SetCrmPipelineStageRequirementResponses[keyof SetCrmPipelineStageRequirementResponses];+export type GetCrmPipelineTableData = {body?: never;path: {diff --git a/packages/sdk/specs/storage.json b/packages/sdk/specs/storage.jsonindex 8e4e1b83d0..8a8b5f6f85 100644--- a/packages/sdk/specs/storage.json+++ b/packages/sdk/specs/storage.json@@ -7052,6 +7052,70 @@}}},+ "/crm/pipelines/{id}/stage-requirements": {+ "get": {+ "tags": ["crm::inbound::pipelines"],+ "summary": "Read requirements by stable stage and field identities.",+ "operationId": "get_crm_pipeline_stage_requirements",+ "parameters": [+ {+ "name": "id",+ "in": "path",+ "required": true,+ "schema": {+ "type": "string",+ "format": "uuid"+ }+ }+ ],+ "responses": {+ "200": {+ "description": "",+ "content": {+ "application/json": {+ "schema": {+ "type": "array",+ "items": {+ "$ref": "#/components/schemas/StageRequirement"+ }+ }+ }+ }+ }+ }+ },+ "put": {+ "tags": ["crm::inbound::pipelines"],+ "summary": "Replace the required fields for one stage. An empty list removes its rule.",+ "operationId": "set_crm_pipeline_stage_requirement",+ "parameters": [+ {+ "name": "id",+ "in": "path",+ "required": true,+ "schema": {+ "type": "string",+ "format": "uuid"+ }+ }+ ],+ "requestBody": {+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/StageRequirement"+ }+ }+ },+ "required": true+ },+ "responses": {+ "204": {+ "description": ""+ }+ }+ }+ },"/crm/pipelines/{id}/table": {"get": {"tags": ["crm::inbound::pipelines"],@@ -43576,6 +43640,32 @@],"description": "The statement that ran: a read, or the table (and for a type change, the\ncolumn) it wrote."},+ "StageRequirement": {+ "type": "object",+ "description": "Fields required when a deal enters a particular option of a stage column.",+ "required": ["stageColumnId", "stageId", "requiredColumnIds"],+ "properties": {+ "requiredColumnIds": {+ "type": "array",+ "items": {+ "type": "string",+ "format": "uuid"+ },+ "description": "Fields that must be present. Empty removes the rule for this stage."+ },+ "stageColumnId": {+ "type": "string",+ "format": "uuid",+ "description": "Single-select column identifying the stage, independent of its name."+ },+ "stageId": {+ "type": "string",+ "format": "uuid",+ "description": "Stable option identity; renaming the stage preserves the rule."+ }+ },+ "additionalProperties": false+ },"StarterDatabase": {"type": "object","description": "Starter result. A missing database means the user already started or removed it.",diff --git a/packages/sdk/src/entities/crm/pipeline.ts b/packages/sdk/src/entities/crm/pipeline.tsindex fab2f4e8d7..c63bdac8ba 100644--- a/packages/sdk/src/entities/crm/pipeline.ts+++ b/packages/sdk/src/entities/crm/pipeline.ts@@ -13,6 +13,7 @@ import type {import { Lazy, MacroNotFoundError, paginate, unwrap } from '../../utils';import type { MacroClient } from '../../utils/client';import { MacroEntity } from '../entity';+import { PropertyOption } from '../properties/property-option';import {type SharePermissionOptions,sharePermissionBody,@@ -20,6 +21,13 @@ import {import { Team } from '../teams/team';import { User } from '../users/user';+/** Required fields for one option of a pipeline stage column. */+export type PipelineStageRequirement = {+ stageColumn: PipelineColumn;+ stage: PropertyOption;+ requiredFields: PipelineColumn[];+};+/** A CRM pipeline with its own sharing boundary and backing table. */export class CrmPipeline extends MacroEntity<AccessiblePipeline> {private readonly tableDetail = new Lazy(async () =>@@ -107,6 +115,78 @@ export class CrmPipeline extends MacroEntity<AccessiblePipeline> {);}+ /** Read stage rules with column and option handles that survive renames. */+ async stageRequirements(): Promise<PipelineStageRequirement[]> {+ const rules = unwrap(+ await this.client.storage.getCrmPipelineStageRequirements({+ path: { id: this.id },+ }),+ );+ // Rules are read fresh; resolve their identities against a fresh schema too.+ this.tableDetail.clear();+ const table = await this.table();+ const detail = await this.tableRecord();+ const column = (id: string) => {+ const record = detail.columns.find((entry) => entry.column.id === id);+ if (!record)+ throw new MacroNotFoundError(+ 'A required field was deleted; reload the pipeline',+ );+ return PipelineColumn.from(this.client, table, record);+ };+ return rules.map((rule) => {+ const record = detail.columns.find(+ (entry) => entry.column.id === rule.stageColumnId,+ );+ const option = record?.definition.property_options.find(+ (entry) => entry.id === rule.stageId,+ );+ if (!record || !option)+ throw new MacroNotFoundError(+ 'A required stage was deleted; reload the pipeline',+ );+ return {+ stageColumn: column(rule.stageColumnId),+ stage: PropertyOption.from(+ this.client,+ record.definition.definition.id,+ option,+ ),+ requiredFields: rule.requiredColumnIds.map(column),+ };+ });+ }++ /** Require fields when entering a stage; an empty list removes that stage's rule. */+ async setStageRequirements(+ stageColumn: PipelineColumn,+ stage: PropertyOption,+ requiredFields: PipelineColumn[],+ ): Promise<void> {+ if (+ [stageColumn, ...requiredFields].some(+ (column) => column.table.pipeline.id !== this.id,+ )+ )+ throw new Error('Fields belong to another pipeline');+ this.tableDetail.clear();+ const column = (await this.tableRecord()).columns.find(+ (entry) => entry.column.id === stageColumn.id,+ );+ if (!column || column.definition.definition.id !== stage.definitionId)+ throw new Error('The stage option belongs to another field');+ await this.mutate((client) =>+ client.storage.setCrmPipelineStageRequirement({+ path: { id: this.id },+ body: {+ stageColumnId: stageColumn.id,+ stageId: stage.id,+ requiredColumnIds: requiredFields.map((field) => field.id),+ },+ }),+ );+ }+/** Read the backing table through the pipeline's authorization boundary. */async table(): Promise<PipelineTable> {return PipelineTable.from(this.client, this, await this.tableRecord());@@ -385,6 +465,14 @@ export class PipelineColumn extends MacroEntity<ColumnDetail> {return record;}+ /** Selectable options, including stable stage identities for requirement rules. */+ async options(): Promise<PropertyOption[]> {+ const column = await this.fetch();+ return column.definition.property_options.map((option) =>+ PropertyOption.from(this.client, column.definition.definition.id, option),+ );+ }+/** Whether the caller can write this column. */async writable(): Promise<boolean> {return (await this.fetch()).writable;diff --git a/packages/sdk/src/macro.ts b/packages/sdk/src/macro.tsindex b70bfbfe8b..6f5a137803 100644--- a/packages/sdk/src/macro.ts+++ b/packages/sdk/src/macro.ts@@ -283,6 +283,7 @@ export {CrmPipeline,PipelineColumn,PipelineRow,+ type PipelineStageRequirement,PipelineTable,PipelineView,} from './entities/crm/pipeline';diff --git a/packages/sdk/tests/pipeline-stage-requirements.test.ts b/packages/sdk/tests/pipeline-stage-requirements.test.tsnew file mode 100644index 0000000000..9587d37029--- /dev/null+++ b/packages/sdk/tests/pipeline-stage-requirements.test.ts@@ -0,0 +1,127 @@+import { afterEach, expect, test } from 'bun:test';+import type { ColumnDetail, TableDetail } from '../generated/storage/types.gen';+import { Macro } from '../src/macro';++const originalFetch = globalThis.fetch;+afterEach(() => {+ globalThis.fetch = originalFetch;+});++function column(id: string, name: string, stage = false): ColumnDetail {+ return {+ column: {+ id,+ table_id: 'table',+ property_definition_id: `${id}-definition`,+ display_name: null,+ position: id,+ infer_type: false,+ config: null,+ },+ definition: {+ definition: {+ id: `${id}-definition`,+ display_name: name,+ data_type: stage ? 'SELECT_STRING' : 'NUMBER',+ is_multi_select: false,+ specific_entity_type: null,+ is_metadata: false,+ is_system: false,+ owner: { scope: 'database', database_id: 'database' },+ created_at: '2026-10-01T00:00:00Z',+ updated_at: '2026-10-01T00:00:00Z',+ },+ property_options: stage+ ? [+ {+ id: 'negotiation',+ property_definition_id: `${id}-definition`,+ value: { type: 'string', value: 'Negotiation' },+ display_order: 0,+ color: null,+ created_at: '2026-10-01T00:00:00Z',+ updated_at: '2026-10-01T00:00:00Z',+ },+ ]+ : [],+ },+ shared_outside_database: false,+ sql_name: id,+ writable: true,+ };+}+const table: TableDetail = {+ table: {+ id: 'table',+ database_id: 'database',+ name: 'Sales',+ position: 'a',+ version: 1,+ },+ columns: [+ column('stage', 'Sales phase', true),+ column('amount', 'Deal amount'),+ ],+ views: [],+ sql_name: 'sales',+};++test('stage rules use stable handles and reject fields from another pipeline before writing', async () => {+ const writes: unknown[] = [];+ let currentTable: TableDetail = { ...table, columns: [] };+ globalThis.fetch = Object.assign(+ async (input: RequestInfo | URL) => {+ const request = input instanceof Request ? input : new Request(input);+ if (request.url.endsWith('/table')) return Response.json(currentTable);+ expect(new URL(request.url).pathname).toBe(+ '/crm/pipelines/sales/stage-requirements',+ );+ if (request.method === 'PUT') {+ writes.push(await request.json());+ return new Response(null, { status: 204 });+ }+ return Response.json([+ {+ stageColumnId: 'stage',+ stageId: 'negotiation',+ requiredColumnIds: ['amount'],+ },+ ]);+ },+ { preconnect: originalFetch.preconnect },+ );+ const macro = new Macro({+ token: 'token',+ hosts: { storage: 'https://storage.test' },+ });+ const pipeline = macro.crm.pipelines.byId('sales');+ await pipeline.table();+ currentTable = table;+ const [rule] = await pipeline.stageRequirements();+ expect(await rule.stageColumn.name()).toBe('Sales phase');+ expect(await rule.requiredFields[0].name()).toBe('Deal amount');+ expect((await rule.stageColumn.options())[0].id).toBe(rule.stage.id);+ await pipeline.setStageRequirements(+ rule.stageColumn,+ rule.stage,+ rule.requiredFields,+ );+ await pipeline.setStageRequirements(rule.stageColumn, rule.stage, []);+ expect(writes).toEqual([+ {+ stageColumnId: 'stage',+ stageId: 'negotiation',+ requiredColumnIds: ['amount'],+ },+ { stageColumnId: 'stage', stageId: 'negotiation', requiredColumnIds: [] },+ ]);+ await expect(+ macro.crm.pipelines+ .byId('other')+ .setStageRequirements(rule.stageColumn, rule.stage, rule.requiredFields),+ ).rejects.toThrow('another pipeline');+ await expect(+ pipeline.setStageRequirements(rule.requiredFields[0], rule.stage, []),+ ).rejects.toThrow('another field');+ expect(writes).toHaveLength(2);+});diff --git a/services/document_storage_service/src/api/swagger.rs b/services/document_storage_service/src/api/swagger.rsindex 065b9b1108..c689d32281 100644--- a/services/document_storage_service/src/api/swagger.rs+++ b/services/document_storage_service/src/api/swagger.rs@@ -563,6 +563,8 @@ use utoipa::OpenApi;crm::inbound::pipelines::rows,crm::inbound::pipelines::query_rows,crm::inbound::pipelines::apply_ops,+ crm::inbound::pipelines::stage_requirements,+ crm::inbound::pipelines::set_stage_requirement,crm::inbound::pipelines::rename,crm::inbound::pipelines::share,crm::inbound::pipelines::permissions,