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(databases): add incoming webhooks that insert rows (#7867)
Wolf Mermelstein4ab20c6ba1ff
diff --git a/.github/workspace-dep-closures.json b/.github/workspace-dep-closures.jsonindex 28c4828e1c..efee42dda3 100644--- a/.github/workspace-dep-closures.json+++ b/.github/workspace-dep-closures.json@@ -4185,6 +4185,71 @@"crates/non_empty","crates/notification_state"],+ "database_webhooks": [+ "crates/activity",+ "crates/agent",+ "crates/ai_toolset",+ "crates/ai_usage",+ "crates/attachment",+ "crates/bot_id",+ "crates/bot_token",+ "crates/broadcast",+ "crates/channel_sender",+ "crates/connection_gateway_client",+ "crates/connection_gateway_models",+ "crates/cowlike",+ "crates/database_env_vars",+ "crates/database_sql",+ "crates/database_webhooks",+ "crates/databases",+ "crates/document_sub_type",+ "crates/entity_access",+ "crates/entity_access_db_utils",+ "crates/entity_mutation",+ "crates/filter_ast",+ "crates/genai_telemetry",+ "crates/harness_id",+ "crates/harness_token",+ "crates/invite_email",+ "crates/item_filters",+ "crates/kafka_util",+ "crates/last_online_tracker",+ "crates/macro_auth",+ "crates/macro_authorization",+ "crates/macro_entrypoint",+ "crates/macro_env",+ "crates/macro_env_var",+ "crates/macro_event_broker",+ "crates/macro_event_topics",+ "crates/macro_service_urls",+ "crates/macro_tower_layers",+ "crates/macro_user_id",+ "crates/macro_uuid",+ "crates/maybe_send",+ "crates/mention_utils",+ "crates/model",+ "crates/model-entity",+ "crates/model-error-response",+ "crates/model_file_type",+ "crates/model_notifications",+ "crates/model_owner",+ "crates/model_user",+ "crates/models_bulk_upload",+ "crates/models_databases",+ "crates/models_entity_access_management",+ "crates/models_pagination",+ "crates/models_permissions",+ "crates/models_properties",+ "crates/non_empty",+ "crates/notification",+ "crates/notification_state",+ "crates/prompt",+ "crates/properties",+ "crates/rate_limit",+ "crates/remote_env_var",+ "crates/system_properties",+ "crates/workspace-hack"+ ],"databases": ["crates/activity","crates/agent",@@ -4775,6 +4840,7 @@"crates/crm","crates/database_env_vars","crates/database_sql",+ "crates/database_webhooks","crates/databases","crates/databases_sql","crates/dictation",diff --git a/.sqlx/query-051a4bdb4cbdb8c0c538ec87ededd11433328825795280a2d5f534d032e94892.json b/.sqlx/query-051a4bdb4cbdb8c0c538ec87ededd11433328825795280a2d5f534d032e94892.jsonnew file mode 100644index 0000000000..997165bc27--- /dev/null+++ b/.sqlx/query-051a4bdb4cbdb8c0c538ec87ededd11433328825795280a2d5f534d032e94892.json@@ -0,0 +1,15 @@+{+ "db_name": "PostgreSQL",+ "query": "DELETE FROM database_webhooks WHERE id = $1 AND database_id = $2",+ "describe": {+ "columns": [],+ "parameters": {+ "Left": [+ "Uuid",+ "Uuid"+ ]+ },+ "nullable": []+ },+ "hash": "051a4bdb4cbdb8c0c538ec87ededd11433328825795280a2d5f534d032e94892"+}diff --git a/.sqlx/query-4ba76c178dde26d14355c31dc478abb9d63664c2ce022024d05072cfec9fd063.json b/.sqlx/query-4ba76c178dde26d14355c31dc478abb9d63664c2ce022024d05072cfec9fd063.jsonnew file mode 100644index 0000000000..5d301cf876--- /dev/null+++ b/.sqlx/query-4ba76c178dde26d14355c31dc478abb9d63664c2ce022024d05072cfec9fd063.json@@ -0,0 +1,57 @@+{+ "db_name": "PostgreSQL",+ "query": "\n INSERT INTO database_webhooks\n (id, database_id, table_id, created_by, token_hash, token_prefix)\n VALUES ($1, $2, $3, $4, $5, $6)\n RETURNING id, database_id, table_id, created_by, token_prefix, created_at\n ",+ "describe": {+ "columns": [+ {+ "ordinal": 0,+ "name": "id",+ "type_info": "Uuid"+ },+ {+ "ordinal": 1,+ "name": "database_id",+ "type_info": "Uuid"+ },+ {+ "ordinal": 2,+ "name": "table_id",+ "type_info": "Uuid"+ },+ {+ "ordinal": 3,+ "name": "created_by",+ "type_info": "Text"+ },+ {+ "ordinal": 4,+ "name": "token_prefix",+ "type_info": "Text"+ },+ {+ "ordinal": 5,+ "name": "created_at",+ "type_info": "Timestamptz"+ }+ ],+ "parameters": {+ "Left": [+ "Uuid",+ "Uuid",+ "Uuid",+ "Text",+ "Bytea",+ "Text"+ ]+ },+ "nullable": [+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ "hash": "4ba76c178dde26d14355c31dc478abb9d63664c2ce022024d05072cfec9fd063"+}diff --git a/.sqlx/query-98762db8f8883fd715727f3203a3697e1a1a632c61835a38278556f276c11c4d.json b/.sqlx/query-98762db8f8883fd715727f3203a3697e1a1a632c61835a38278556f276c11c4d.jsonnew file mode 100644index 0000000000..c348593a28--- /dev/null+++ b/.sqlx/query-98762db8f8883fd715727f3203a3697e1a1a632c61835a38278556f276c11c4d.json@@ -0,0 +1,52 @@+{+ "db_name": "PostgreSQL",+ "query": "\n SELECT id, database_id, table_id, created_by, token_prefix, created_at\n FROM database_webhooks\n WHERE database_id = $1\n ORDER BY created_at, id\n ",+ "describe": {+ "columns": [+ {+ "ordinal": 0,+ "name": "id",+ "type_info": "Uuid"+ },+ {+ "ordinal": 1,+ "name": "database_id",+ "type_info": "Uuid"+ },+ {+ "ordinal": 2,+ "name": "table_id",+ "type_info": "Uuid"+ },+ {+ "ordinal": 3,+ "name": "created_by",+ "type_info": "Text"+ },+ {+ "ordinal": 4,+ "name": "token_prefix",+ "type_info": "Text"+ },+ {+ "ordinal": 5,+ "name": "created_at",+ "type_info": "Timestamptz"+ }+ ],+ "parameters": {+ "Left": [+ "Uuid"+ ]+ },+ "nullable": [+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ "hash": "98762db8f8883fd715727f3203a3697e1a1a632c61835a38278556f276c11c4d"+}diff --git a/.sqlx/query-e78666e7baa61a8d55e320a630f4af525c31f3d9de55dcd21ce8162ab174ce5a.json b/.sqlx/query-e78666e7baa61a8d55e320a630f4af525c31f3d9de55dcd21ce8162ab174ce5a.jsonnew file mode 100644index 0000000000..282f4103e7--- /dev/null+++ b/.sqlx/query-e78666e7baa61a8d55e320a630f4af525c31f3d9de55dcd21ce8162ab174ce5a.json@@ -0,0 +1,52 @@+{+ "db_name": "PostgreSQL",+ "query": "\n SELECT id, database_id, table_id, created_by, token_prefix, created_at\n FROM database_webhooks\n WHERE token_hash = $1\n ",+ "describe": {+ "columns": [+ {+ "ordinal": 0,+ "name": "id",+ "type_info": "Uuid"+ },+ {+ "ordinal": 1,+ "name": "database_id",+ "type_info": "Uuid"+ },+ {+ "ordinal": 2,+ "name": "table_id",+ "type_info": "Uuid"+ },+ {+ "ordinal": 3,+ "name": "created_by",+ "type_info": "Text"+ },+ {+ "ordinal": 4,+ "name": "token_prefix",+ "type_info": "Text"+ },+ {+ "ordinal": 5,+ "name": "created_at",+ "type_info": "Timestamptz"+ }+ ],+ "parameters": {+ "Left": [+ "Bytea"+ ]+ },+ "nullable": [+ false,+ false,+ false,+ false,+ false,+ false+ ]+ },+ "hash": "e78666e7baa61a8d55e320a630f4af525c31f3d9de55dcd21ce8162ab174ce5a"+}diff --git a/Cargo.lock b/Cargo.lockindex 743563e23d..04fb03c118 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -5595,6 +5595,36 @@ dependencies = ["wasm-bindgen",]+[[package]]+name = "database_webhooks"+version = "0.1.0"+dependencies = [+ "axum",+ "chrono",+ "databases",+ "entity_access",+ "hex",+ "macro_authorization",+ "macro_db_migrator",+ "macro_event_broker",+ "macro_user_id",+ "macro_uuid",+ "model-error-response",+ "models_databases",+ "rand 0.9.4",+ "rootcause",+ "serde",+ "serde_json",+ "sha2 0.10.9",+ "sqlx",+ "thiserror 2.0.18",+ "tokio",+ "tracing",+ "utoipa",+ "uuid",+ "workspace-hack",+]+[[package]]name = "databases"version = "0.1.0"@@ -6267,6 +6297,7 @@ dependencies = ["cool_asserts","cowlike","crm",+ "database_webhooks","databases","dictation","document_sub_type",diff --git a/Cargo.toml b/Cargo.tomlindex 288b4df39a..a4dd7696fe 100644--- a/Cargo.toml+++ b/Cargo.toml@@ -38,6 +38,7 @@ members = ["crates/jev","crates/claude_cloud_agents","crates/database_sql",+ "crates/database_webhooks","crates/databases","crates/databases_sql","crates/models_databases",diff --git a/apps/web/src/features/block-database/component/WebhooksDialog.tsx b/apps/web/src/features/block-database/component/WebhooksDialog.tsxnew file mode 100644index 0000000000..e2ee802bc7--- /dev/null+++ b/apps/web/src/features/block-database/component/WebhooksDialog.tsx@@ -0,0 +1,196 @@+import CopyIcon from '@phosphor/copy.svg';+import TrashIcon from '@phosphor/trash-simple.svg';+import { databaseWebhookUrl } from '@service-storage/databases';+import type { DatabaseWebhookResponse } from '@service-storage/generated/schemas/databaseWebhookResponse';+import type { TableDetail } from '@service-storage/generated/schemas/tableDetail';+import { Button } from '@ui/components/Button';+import { CopyButton } from '@ui/components/CopyButton';+import { Dialog } from '@ui/components/Dialog';+import { Input } from '@ui/components/Input';+import { Panel } from '@ui/components/Panel';+import { createSignal, For, Show } from 'solid-js';+import { toast } from '../../../lib/core/component/Toast/Toast';+import { toViewColumn } from '../../database/queries/column-detail';+import { webhookCurl, webhookExamplePayload } from '../core/webhook-example';+import {+ createTableWebhook,+ deleteTableWebhook,+ useTableWebhooks,+} from '../queries/webhooks';++/** A webhook just created, with the token that is shown only now. */+type CreatedWebhook = { webhook: DatabaseWebhookResponse; token: string };++function copy(text: string) {+ return navigator.clipboard.writeText(text).catch(() => {+ toast.failure('Could not copy to the clipboard.');+ return false as const;+ });+}++/** Webhooks that insert rows into one table: create one, copy its URL, delete old ones. */+export function WebhooksDialog(props: {+ databaseId: string;+ table: TableDetail;+ onClose: () => void;+ returnFocus?: HTMLElement;+}) {+ const { webhooks, failed } = useTableWebhooks(+ () => props.databaseId,+ () => props.table.table.id+ );+ const [created, setCreated] = createSignal<CreatedWebhook>();+ const [pending, setPending] = createSignal(false);+ const example = () =>+ webhookExamplePayload(+ props.table.columns.map(toViewColumn),+ new Date().toISOString().slice(0, 10)+ );++ async function create() {+ if (pending()) return;+ setPending(true);+ const result = await createTableWebhook(+ props.databaseId,+ props.table.table.id+ );+ setPending(false);+ result.match(setCreated, () =>+ toast.failure('Could not create a webhook.')+ );+ }++ async function remove(webhook: DatabaseWebhookResponse) {+ const result = await deleteTableWebhook(props.databaseId, webhook.id);+ result.match(+ () => {+ if (created()?.webhook.id === webhook.id) setCreated(undefined);+ },+ () => toast.failure('Could not delete this webhook.')+ );+ }++ return (+ <Dialog+ open+ class="w-160 max-w-[calc(100vw-2rem)]"+ onOpenChange={(open) => !open && props.onClose()}+ onCloseAutoFocus={(event) => {+ if (props.returnFocus?.isConnected) {+ event.preventDefault();+ props.returnFocus.focus();+ }+ }}+ >+ <Panel>+ <Panel.Body>+ <div class="flex min-w-0 flex-col gap-4 p-5">+ <div>+ <Dialog.Title class="text-base font-semibold">+ Webhooks+ </Dialog.Title>+ <Dialog.Description class="mt-1 text-sm text-ink-muted">+ POST JSON to a webhook URL to add a row to “+ {props.table.table.name}”. Keys are column names; send an array+ to add several rows.+ </Dialog.Description>+ </div>+ <Show when={created()}>+ {(fresh) => {+ const url = () => databaseWebhookUrl(fresh().token);+ const curl = () => webhookCurl(url(), example());+ return (+ <div class="flex flex-col gap-3">+ <label class="flex flex-col gap-1.5 text-sm">+ Webhook URL+ <div class="flex gap-2">+ <Input+ readOnly+ value={url()}+ class="font-mono text-xs"+ onFocus={(event) => event.currentTarget.select()}+ />+ <CopyButton+ variant="outline"+ label="Copy webhook URL"+ onClick={() => copy(url())}+ >+ <CopyIcon />+ Copy+ </CopyButton>+ </div>+ </label>+ <p class="text-xs text-ink-muted">+ Copy it now; it won't be shown again. Anyone with this URL+ can add rows, writing as you.+ </p>+ <div class="flex flex-col gap-1.5 text-sm">+ <div class="flex items-center justify-between">+ Example+ <CopyButton+ size="sm"+ variant="ghost"+ label="Copy example"+ onClick={() => copy(curl())}+ >+ <CopyIcon />+ Copy+ </CopyButton>+ </div>+ <pre class="max-h-56 overflow-auto rounded-md border border-edge-muted bg-canvas-base p-3 text-xs">+ {curl()}+ </pre>+ </div>+ </div>+ );+ }}+ </Show>+ <Show when={failed()}>+ <p class="text-sm text-failure" role="alert">+ Could not load this table's webhooks.+ </p>+ </Show>+ <Show when={webhooks()?.length}>+ <ul class="flex flex-col divide-y divide-edge-muted rounded-md border border-edge-muted text-sm">+ <For each={webhooks()}>+ {(webhook) => (+ <li class="flex items-center gap-3 px-3 py-2">+ <span class="font-mono text-xs">+ {webhook.tokenPrefix}…+ </span>+ <span class="flex-1 text-xs text-ink-muted">+ Created{' '}+ {new Date(webhook.createdAt).toLocaleDateString()}+ </span>+ <Button+ variant="ghost"+ size="icon-sm"+ label="Delete webhook"+ onClick={() => void remove(webhook)}+ >+ <TrashIcon class="size-4" />+ </Button>+ </li>+ )}+ </For>+ </ul>+ </Show>+ <div class="flex justify-end gap-2">+ <Button type="button" variant="ghost" onClick={props.onClose}>+ Done+ </Button>+ <Button+ type="button"+ variant="accent"+ disabled={pending()}+ onClick={() => void create()}+ >+ {pending() ? 'Creating…' : 'Create webhook'}+ </Button>+ </div>+ </div>+ </Panel.Body>+ </Panel>+ </Dialog>+ );+}diff --git a/apps/web/src/features/block-database/core/webhook-example.test.ts b/apps/web/src/features/block-database/core/webhook-example.test.tsnew file mode 100644index 0000000000..73c8d46db9--- /dev/null+++ b/apps/web/src/features/block-database/core/webhook-example.test.ts@@ -0,0 +1,124 @@+import { describe, expect, it } from 'vitest';+import type { DatabaseViewColumn } from '../../database/core/database-view';+import { webhookCurl, webhookExamplePayload } from './webhook-example';++const meetings: DatabaseViewColumn[] = [+ {+ id: 'title',+ name: 'Title',+ dataType: 'STRING',+ isMultiSelect: false,+ options: [],+ writable: true,+ },+ {+ id: 'date',+ name: 'Date',+ dataType: 'DATE',+ isMultiSelect: false,+ options: [],+ writable: true,+ },+ {+ id: 'attendees',+ name: 'Attendees',+ dataType: 'SELECT_STRING',+ isMultiSelect: true,+ options: [+ { id: 'alice', label: 'Alice', color: null },+ { id: 'bob', label: 'Bob', color: null },+ ],+ writable: true,+ },+ {+ id: 'status',+ name: 'Status',+ dataType: 'SELECT_STRING',+ isMultiSelect: false,+ options: [{ id: 'scheduled', label: 'Scheduled', color: null }],+ writable: true,+ },+ {+ id: 'duration',+ name: 'Duration (min)',+ dataType: 'NUMBER',+ isMultiSelect: false,+ options: [],+ writable: true,+ },+ {+ id: 'recording',+ name: 'Recording',+ dataType: 'LINK',+ isMultiSelect: false,+ options: [],+ writable: true,+ },+ {+ id: 'follow-up',+ name: 'Needs follow-up',+ dataType: 'BOOLEAN',+ isMultiSelect: false,+ options: [],+ writable: true,+ },+ {+ id: 'owner',+ name: 'Owner',+ dataType: 'ENTITY',+ isMultiSelect: false,+ options: [],+ writable: true,+ specificEntityType: 'USER',+ },+ {+ id: 'account',+ name: 'Account',+ dataType: 'ENTITY',+ isMultiSelect: true,+ options: [],+ writable: true,+ relation: { databaseId: 'crm', tableId: 'accounts' },+ },+ {+ id: 'stage',+ name: 'Stage',+ dataType: 'SELECT_STRING',+ isMultiSelect: false,+ options: [],+ writable: true,+ },+];++describe('webhookExamplePayload', () => {+ it('names every column with a value of its type', () => {+ expect(webhookExamplePayload(meetings, '2026-10-09')).toEqual({+ Title: 'Text',+ Date: '2026-10-09',+ Attendees: ['Alice'],+ Status: 'Scheduled',+ 'Duration (min)': 1,+ Recording: 'https://example.com',+ 'Needs follow-up': true,+ Owner: null,+ Account: null,+ Stage: null,+ });+ });+});++describe('webhookCurl', () => {+ it('quotes the body for a shell, apostrophes included', () => {+ expect(+ webhookCurl('https://api.example/databases/webhooks/mdbw_x', {+ Title: "Alice's kickoff",+ })+ ).toBe(+ `curl -X POST 'https://api.example/databases/webhooks/mdbw_x' \\+ -H 'Content-Type: application/json' \\+ -d '{+ "Title": "Alice'\\''s kickoff"+}'`+ );+ });+});diff --git a/apps/web/src/features/block-database/core/webhook-example.ts b/apps/web/src/features/block-database/core/webhook-example.tsnew file mode 100644index 0000000000..edc3244f02--- /dev/null+++ b/apps/web/src/features/block-database/core/webhook-example.ts@@ -0,0 +1,44 @@+import { match } from 'ts-pattern';+import type { DatabaseViewColumn } from '../../database/core/database-view';++type ExampleValue = string | number | boolean | string[] | null;++/**+ * A payload a webhook would accept for the table: every column by name, with+ * a value of its type, or `null` where a real value needs an id the sender+ * has to supply (references and relations) or the column has no options yet.+ */+export function webhookExamplePayload(+ columns: DatabaseViewColumn[],+ today: string+): Record<string, ExampleValue> {+ return Object.fromEntries(+ columns.map((column) => [column.name, exampleValue(column, today)])+ );+}++function exampleValue(column: DatabaseViewColumn, today: string): ExampleValue {+ if (column.relation) return null;+ return match(column.dataType)+ .returnType<ExampleValue>()+ .with('STRING', () => 'Text')+ .with('NUMBER', () => 1)+ .with('BOOLEAN', () => true)+ .with('DATE', () => today)+ .with('LINK', () => 'https://example.com')+ .with('SELECT_STRING', 'SELECT_NUMBER', 'TAG', () => {+ const label = column.options[0]?.label;+ if (label === undefined) return null;+ return column.isMultiSelect || column.dataType === 'TAG'+ ? [label]+ : label;+ })+ .with('ENTITY', () => null)+ .exhaustive();+}++/** A `curl` that posts the payload to the webhook. */+export function webhookCurl(url: string, payload: object): string {+ const body = JSON.stringify(payload, null, 2).replaceAll("'", "'\\''");+ return `curl -X POST '${url}' \\\n -H 'Content-Type: application/json' \\\n -d '${body}'`;+}diff --git a/apps/web/src/features/block-database/queries/keys.ts b/apps/web/src/features/block-database/queries/keys.tsindex 7b5c13e728..ddb03d0ba9 100644--- a/apps/web/src/features/block-database/queries/keys.ts+++ b/apps/web/src/features/block-database/queries/keys.ts@@ -18,3 +18,8 @@ export const databaseColumnKeys = createQueryKeys('database-columns', {queryKey: [databaseId, tableId, columnId, version],}),});++export const databaseWebhookKeys = createQueryKeys('database-webhooks', {+ /** A database's webhooks. */+ list: (databaseId: string) => ({ queryKey: [databaseId] }),+});diff --git a/apps/web/src/features/block-database/queries/webhooks.ts b/apps/web/src/features/block-database/queries/webhooks.tsnew file mode 100644index 0000000000..b1d3a4b8f1--- /dev/null+++ b/apps/web/src/features/block-database/queries/webhooks.ts@@ -0,0 +1,72 @@+/** Webhooks that insert rows into a database's tables. */++import { throwOnErr } from '@core/util/result';+import { queryClient } from '@queries/client';+import { storageServiceClient } from '@service-storage/client';+import type { CreatedDatabaseWebhookResponse } from '@service-storage/generated/schemas/createdDatabaseWebhookResponse';+import type { DatabaseWebhookResponse } from '@service-storage/generated/schemas/databaseWebhookResponse';+import { useQuery } from '@tanstack/solid-query';+import type { ResultAsync } from 'neverthrow';+import type { Accessor } from 'solid-js';+import { databaseWebhookKeys } from './keys';++/** A table's webhooks; `undefined` until they are read. */+export function useTableWebhooks(+ databaseId: Accessor<string>,+ tableId: Accessor<string>+): {+ webhooks: Accessor<DatabaseWebhookResponse[] | undefined>;+ failed: Accessor<boolean>;+} {+ const query = useQuery(() => ({+ queryKey: databaseWebhookKeys.list(databaseId()).queryKey,+ queryFn: () =>+ throwOnErr(() =>+ storageServiceClient.databases.listWebhooks({ id: databaseId() })+ ),+ }));+ return {+ webhooks: () =>+ query.isSuccess+ ? query.data.webhooks.filter((webhook) => webhook.tableId === tableId())+ : undefined,+ failed: () => query.isError,+ };+}++function updateList(+ databaseId: string,+ update: (webhooks: DatabaseWebhookResponse[]) => DatabaseWebhookResponse[]+) {+ queryClient.setQueryData<{ webhooks: DatabaseWebhookResponse[] }>(+ databaseWebhookKeys.list(databaseId).queryKey,+ (current) => current && { webhooks: update(current.webhooks) }+ );+}++/** Create a webhook for the table; the answer holds the token, shown only now. */+export function createTableWebhook(+ databaseId: string,+ tableId: string+): ResultAsync<CreatedDatabaseWebhookResponse, unknown> {+ return storageServiceClient.databases+ .createWebhook({ id: databaseId, tableId })+ .map((created) => {+ updateList(databaseId, (webhooks) => [...webhooks, created.webhook]);+ return created;+ });+}++/** Delete a webhook; its URL stops working. */+export function deleteTableWebhook(+ databaseId: string,+ webhookId: string+): ResultAsync<void, unknown> {+ return storageServiceClient.databases+ .deleteWebhook({ id: databaseId, webhookId })+ .map(() =>+ updateList(databaseId, (webhooks) =>+ webhooks.filter((webhook) => webhook.id !== webhookId)+ )+ );+}diff --git a/apps/web/src/features/block-database/views/database-page-actions.tsx b/apps/web/src/features/block-database/views/database-page-actions.tsxindex 77224ea6cf..a09f2fe13c 100644--- a/apps/web/src/features/block-database/views/database-page-actions.tsx+++ b/apps/web/src/features/block-database/views/database-page-actions.tsx@@ -5,6 +5,7 @@ import DownloadIcon from '@phosphor/download-simple.svg';import PencilIcon from '@phosphor/pencil-line.svg';import TrashIcon from '@phosphor/trash-simple.svg';import UploadIcon from '@phosphor/upload-simple.svg';+import WebhookIcon from '@phosphor/webhooks-logo.svg';import type { DatabaseDetail } from '@service-storage/generated/schemas/databaseDetail';import type { ImportTable } from '@service-storage/generated/schemas/importTable';import type { TableDetail } from '@service-storage/generated/schemas/tableDetail';@@ -26,6 +27,7 @@ import {type DatabaseEntityFailure,databaseEntityMessage,} from '../../database/core/write-failure';+import { WebhooksDialog } from '../component/WebhooksDialog';import {exportDatabaseTableCsv,importDatabaseTable,@@ -47,6 +49,7 @@ export function DatabasePageActions(props: {const [deleting, setDeleting] = createSignal(false);const [deleteError, setDeleteError] = createSignal('');const [draft, setDraft] = createSignal<{ data: DatabaseCsv; name: string }>();+ const [webhooksOpen, setWebhooksOpen] = createSignal(false);let fileInput: HTMLInputElement | undefined;let menuButton: HTMLButtonElement | undefined;let focusTitleAfterClose = false;@@ -170,6 +173,13 @@ export function DatabasePageActions(props: {<UploadIcon class="size-4 shrink-0" />Import CSV</Dropdown.Item>+ <Dropdown.Item+ disabled={!props.table}+ onSelect={() => setWebhooksOpen(true)}+ >+ <WebhookIcon class="size-4 shrink-0" />+ Webhooks+ </Dropdown.Item></Show><Dropdown.Sub><Dropdown.SubTrigger disabled={exporting()}>@@ -214,6 +224,16 @@ export function DatabasePageActions(props: {/>)}</Show>+ <Show when={webhooksOpen() && props.table}>+ {(table) => (+ <WebhooksDialog+ databaseId={props.detail.database.id}+ table={table()}+ onClose={() => setWebhooksOpen(false)}+ returnFocus={menuButton}+ />+ )}+ </Show><DeleteDialogopen={confirmDelete()}onOpenChange={setConfirmDelete}diff --git a/apps/web/src/lib/service-clients/service-storage/databases.ts b/apps/web/src/lib/service-clients/service-storage/databases.tsindex 8a4145bfd9..31ae544147 100644--- a/apps/web/src/lib/service-clients/service-storage/databases.ts+++ b/apps/web/src/lib/service-clients/service-storage/databases.ts@@ -19,12 +19,14 @@ import type { Awareness } from './generated/schemas/awareness';import type { ColumnCast } from './generated/schemas/columnCast';import type { ColumnConversion } from './generated/schemas/columnConversion';import type { CreateDatabaseRequest } from './generated/schemas/createDatabaseRequest';+import type { CreatedDatabaseWebhookResponse } from './generated/schemas/createdDatabaseWebhookResponse';import type { Database } from './generated/schemas/database';import type { DatabaseDetail } from './generated/schemas/databaseDetail';import type { ErrorResponse } from './generated/schemas/errorResponse';import type { ImportTable } from './generated/schemas/importTable';import type { InferColumnTypeOutcome } from './generated/schemas/inferColumnTypeOutcome';import type { InferColumnTypeRequest } from './generated/schemas/inferColumnTypeRequest';+import type { ListDatabaseWebhooksResponse } from './generated/schemas/listDatabaseWebhooksResponse';import type { ListedDatabase } from './generated/schemas/listedDatabase';import type { OpRefusalResponse } from './generated/schemas/opRefusalResponse';import type { SharePermissionV2 } from './generated/schemas/sharePermissionV2';@@ -56,6 +58,11 @@ export type DatabaseColumnConversion = Omit<ColumnConversion, 'cells'> & {const documentStorageHost = SERVER_HOSTS['document-storage-service'];+/** The URL a webhook's token is POSTed to; the token is the whole credential. */+export function databaseWebhookUrl(token: string) {+ return `${documentStorageHost}/databases/webhooks/${token}`;+}+function isErrorResponse(body: unknown): body is ErrorResponse {return (!!body &&@@ -300,6 +307,29 @@ export const databasesClient = {);},+ /** The database's webhooks, oldest first; editors only. */+ listWebhooks({ id }: { id: string }) {+ return databasesFetch<ListDatabaseWebhooksResponse>(+ `/databases/${id}/webhooks`+ );+ },++ /** A webhook that inserts rows into the table. Its token is shown only in this response. */+ createWebhook({ id, tableId }: { id: string; tableId: string }) {+ return databasesFetch<CreatedDatabaseWebhookResponse>(+ `/databases/${id}/webhooks`,+ { method: 'POST', body: JSON.stringify({ tableId }) }+ );+ },++ /** Delete a webhook; its URL stops working. Responds 204. */+ deleteWebhook({ id, webhookId }: { id: string; webhookId: string }) {+ return databasesFetch<Record<string, never>>(+ `/databases/${id}/webhooks/${webhookId}`,+ { method: 'DELETE' }+ );+ },+/** Tell the database's other viewers where the caller is. Responds 204. */shareAwareness({ id, state }: { id: string; state: Awareness }) {return databasesFetch<Record<string, never>>(`/databases/${id}/awareness`, {diff --git a/apps/web/src/lib/service-clients/service-storage/generated/schemas/createDatabaseWebhookRequest.ts b/apps/web/src/lib/service-clients/service-storage/generated/schemas/createDatabaseWebhookRequest.tsnew file mode 100644index 0000000000..857db31186--- /dev/null+++ b/apps/web/src/lib/service-clients/service-storage/generated/schemas/createDatabaseWebhookRequest.ts@@ -0,0 +1,14 @@+/**+ * Generated by orval v7.21.0 🍺+ * Do not edit manually.+ * document_storage_service+ * OpenAPI spec version: 0.1.0+ */++/**+ * Which table a new webhook inserts rows into.+ */+export interface CreateDatabaseWebhookRequest {+ /** A table of the database. */+ tableId: string;+}diff --git a/apps/web/src/lib/service-clients/service-storage/generated/schemas/createdDatabaseWebhookResponse.ts b/apps/web/src/lib/service-clients/service-storage/generated/schemas/createdDatabaseWebhookResponse.tsnew file mode 100644index 0000000000..0bc7899df7--- /dev/null+++ b/apps/web/src/lib/service-clients/service-storage/generated/schemas/createdDatabaseWebhookResponse.ts@@ -0,0 +1,18 @@+/**+ * Generated by orval v7.21.0 🍺+ * Do not edit manually.+ * document_storage_service+ * OpenAPI spec version: 0.1.0+ */+import type { DatabaseWebhookResponse } from './databaseWebhookResponse';++/**+ * A new webhook, with the token its URL carries. The token is shown only+here.+ */+export interface CreatedDatabaseWebhookResponse {+ /** The secret: `POST /databases/webhooks/{token}` inserts rows. */+ token: string;+ /** The webhook. */+ webhook: DatabaseWebhookResponse;+}diff --git a/apps/web/src/lib/service-clients/service-storage/generated/schemas/databaseWebhookDeliveryResponse.ts b/apps/web/src/lib/service-clients/service-storage/generated/schemas/databaseWebhookDeliveryResponse.tsnew file mode 100644index 0000000000..5061499ae5--- /dev/null+++ b/apps/web/src/lib/service-clients/service-storage/generated/schemas/databaseWebhookDeliveryResponse.ts@@ -0,0 +1,18 @@+/**+ * Generated by orval v7.21.0 🍺+ * Do not edit manually.+ * document_storage_service+ * OpenAPI spec version: 0.1.0+ */++/**+ * The rows a webhook call inserted.+ */+export interface DatabaseWebhookDeliveryResponse {+ /** The database. */+ databaseId: string;+ /** The new rows, in the order the payload sent them. */+ rows: string[];+ /** The table. */+ tableId: string;+}diff --git a/apps/web/src/lib/service-clients/service-storage/generated/schemas/databaseWebhookPayloadProblem.ts b/apps/web/src/lib/service-clients/service-storage/generated/schemas/databaseWebhookPayloadProblem.tsnew file mode 100644index 0000000000..f033321a95--- /dev/null+++ b/apps/web/src/lib/service-clients/service-storage/generated/schemas/databaseWebhookPayloadProblem.ts@@ -0,0 +1,23 @@+/**+ * Generated by orval v7.21.0 🍺+ * Do not edit manually.+ * document_storage_service+ * OpenAPI spec version: 0.1.0+ */+import type { DatabaseWebhookPayloadProblemField } from './databaseWebhookPayloadProblemField';+import type { DatabaseWebhookPayloadProblemRow } from './databaseWebhookPayloadProblemRow';++/**+ * One thing wrong with a webhook payload.+ */+export interface DatabaseWebhookPayloadProblem {+ /** The key at fault, when one is. */+ field: DatabaseWebhookPayloadProblemField;+ /** What is wrong. */+ message: string;+ /**+ * The row's index, when the payload is an array of rows.+ * @minimum 0+ */+ row: DatabaseWebhookPayloadProblemRow;+}diff --git a/apps/web/src/lib/service-clients/service-storage/generated/schemas/databaseWebhookPayloadProblemField.ts b/apps/web/src/lib/service-clients/service-storage/generated/schemas/databaseWebhookPayloadProblemField.tsnew file mode 100644index 0000000000..77c145fe74--- /dev/null+++ b/apps/web/src/lib/service-clients/service-storage/generated/schemas/databaseWebhookPayloadProblemField.ts@@ -0,0 +1,11 @@+/**+ * Generated by orval v7.21.0 🍺+ * Do not edit manually.+ * document_storage_service+ * OpenAPI spec version: 0.1.0+ */++/**+ * The key at fault, when one is.+ */+export type DatabaseWebhookPayloadProblemField = string | null;diff --git a/apps/web/src/lib/service-clients/service-storage/generated/schemas/databaseWebhookPayloadProblemRow.ts b/apps/web/src/lib/service-clients/service-storage/generated/schemas/databaseWebhookPayloadProblemRow.tsnew file mode 100644index 0000000000..4ffc89e3d9--- /dev/null+++ b/apps/web/src/lib/service-clients/service-storage/generated/schemas/databaseWebhookPayloadProblemRow.ts@@ -0,0 +1,12 @@+/**+ * Generated by orval v7.21.0 🍺+ * Do not edit manually.+ * document_storage_service+ * OpenAPI spec version: 0.1.0+ */++/**+ * The row's index, when the payload is an array of rows.+ * @minimum 0+ */+export type DatabaseWebhookPayloadProblemRow = number | null;diff --git a/apps/web/src/lib/service-clients/service-storage/generated/schemas/databaseWebhookResponse.ts b/apps/web/src/lib/service-clients/service-storage/generated/schemas/databaseWebhookResponse.tsnew file mode 100644index 0000000000..331e54b101--- /dev/null+++ b/apps/web/src/lib/service-clients/service-storage/generated/schemas/databaseWebhookResponse.ts@@ -0,0 +1,24 @@+/**+ * Generated by orval v7.21.0 🍺+ * Do not edit manually.+ * document_storage_service+ * OpenAPI spec version: 0.1.0+ */++/**+ * A webhook of a database. Its token is never shown again after creation.+ */+export interface DatabaseWebhookResponse {+ /** Creation time. */+ createdAt: string;+ /** Who created it; its calls write with their access. */+ createdBy: string;+ /** The database. */+ databaseId: string;+ /** Identifier. */+ id: string;+ /** The table its calls insert rows into. */+ tableId: string;+ /** The token's first characters, to tell webhooks apart. */+ tokenPrefix: 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 6ed2435346..f5ab48ac03 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@@ -496,6 +496,7 @@ export * from './createChannelScopedBotResponse';export * from './createCrmCompanyRequest';export * from './createCrmContactRequest';export * from './createDatabaseRequest';+export * from './createDatabaseWebhookRequest';export * from './createDocument200';export * from './createDocument200DataOneOf';export * from './createDocument200DataOneOfAllOf';@@ -515,6 +516,7 @@ export * from './createDocumentRequestTeamId';export * from './createDocumentResponseData';export * from './createDocumentResponseDataAllOf';export * from './createDocumentResponseDataAllOfFileType';+export * from './createdDatabaseWebhookResponse';export * from './createdPairing';export * from './createdUserApiKey';export * from './createEntityMentionRequest';@@ -616,6 +618,11 @@ export * from './databaseOpOneOfThree';export * from './databaseOpOneOfThreeKind';export * from './databaseTrashedAt';export * from './databaseView';+export * from './databaseWebhookDeliveryResponse';+export * from './databaseWebhookPayloadProblem';+export * from './databaseWebhookPayloadProblemField';+export * from './databaseWebhookPayloadProblemRow';+export * from './databaseWebhookResponse';export * from './dataType';export * from './dateOperator';export * from './deleteEntityMentionResponse';@@ -1100,6 +1107,7 @@ export * from './initiativeList';export * from './initiativeSummary';export * from './inputReceivedMetadata';export * from './interactionReason';+export * from './invalidDatabaseWebhookPayloadResponse';export * from './inviteMeetingRequest';export * from './inviteMeetingUsersRequest';export * from './item';@@ -1137,6 +1145,7 @@ export * from './layoutProblemOneOfThree';export * from './layoutProblemOneOfThreeKind';export * from './leaveCallResponse';export * from './linkShare';+export * from './listDatabaseWebhooksResponse';export * from './listEmailRemindersParams';export * from './listedDatabase';export * from './listedForm';diff --git a/apps/web/src/lib/service-clients/service-storage/generated/schemas/invalidDatabaseWebhookPayloadResponse.ts b/apps/web/src/lib/service-clients/service-storage/generated/schemas/invalidDatabaseWebhookPayloadResponse.tsnew file mode 100644index 0000000000..504b9290cf--- /dev/null+++ b/apps/web/src/lib/service-clients/service-storage/generated/schemas/invalidDatabaseWebhookPayloadResponse.ts@@ -0,0 +1,17 @@+/**+ * Generated by orval v7.21.0 🍺+ * Do not edit manually.+ * document_storage_service+ * OpenAPI spec version: 0.1.0+ */+import type { DatabaseWebhookPayloadProblem } from './databaseWebhookPayloadProblem';++/**+ * Why a payload was refused. Nothing was written.+ */+export interface InvalidDatabaseWebhookPayloadResponse {+ /** A summary. */+ message: string;+ /** Every problem found. */+ problems: DatabaseWebhookPayloadProblem[];+}diff --git a/apps/web/src/lib/service-clients/service-storage/generated/schemas/listDatabaseWebhooksResponse.ts b/apps/web/src/lib/service-clients/service-storage/generated/schemas/listDatabaseWebhooksResponse.tsnew file mode 100644index 0000000000..7d05056392--- /dev/null+++ b/apps/web/src/lib/service-clients/service-storage/generated/schemas/listDatabaseWebhooksResponse.ts@@ -0,0 +1,15 @@+/**+ * Generated by orval v7.21.0 🍺+ * Do not edit manually.+ * document_storage_service+ * OpenAPI spec version: 0.1.0+ */+import type { DatabaseWebhookResponse } from './databaseWebhookResponse';++/**+ * A database's webhooks.+ */+export interface ListDatabaseWebhooksResponse {+ /** Oldest first. */+ webhooks: DatabaseWebhookResponse[];+}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 3446fd4512..6d1793f5db 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@@ -9466,6 +9466,19 @@ export const ensureStarterHandlerResponse = zod'Starter result. A missing database means the user already started or removed it.');+/**+ * @summary Insert rows through a webhook. The body is a JSON object, one row, or+an array of up to 100 objects, one row each. Keys name columns by name+(ignoring case) or id; `null` leaves a cell empty. Values may be loose:+`"45"` for a number, `"true"` for a checkbox, a label or labels for a+select, `2026-10-09` for a date. Nothing is written unless every row fits.+ */+export const deliverDatabaseWebhookParams = zod.object({+ token: zod.string().describe("The webhook's secret token"),+});++export const deliverDatabaseWebhookBody = zod.unknown();+/*** @summary Schema detail of one database.*/@@ -14761,6 +14774,64 @@ export const getDatabaseViewPositionsResponse = zod}).describe("Where a board's cards sit.");+/**+ * @summary The database's webhooks.+ */+export const listDatabaseWebhooksParams = zod.object({+ id: zod.uuid().describe('Database id'),+});++export const listDatabaseWebhooksResponse = zod+ .object({+ webhooks: zod+ .array(+ zod+ .object({+ createdAt: zod.iso.datetime({}).describe('Creation time.'),+ createdBy: zod+ .string()+ .describe('Who created it; its calls write with their access.'),+ databaseId: zod.uuid().describe('The database.'),+ id: zod.uuid().describe('Identifier.'),+ tableId: zod+ .uuid()+ .describe('The table its calls insert rows into.'),+ tokenPrefix: zod+ .string()+ .describe(+ "The token's first characters, to tell webhooks apart."+ ),+ })+ .describe(+ 'A webhook of a database. Its token is never shown again after creation.'+ )+ )+ .describe('Oldest first.'),+ })+ .describe("A database's webhooks.");++/**+ * @summary Create a webhook: a secret URL whose calls insert rows into one of the+database's tables, writing with the creator's access.+ */+export const createDatabaseWebhookParams = zod.object({+ id: zod.uuid().describe('Database id'),+});++export const createDatabaseWebhookBody = zod+ .object({+ tableId: zod.uuid().describe('A table of the database.'),+ })+ .describe('Which table a new webhook inserts rows into.');++/**+ * @summary Delete a webhook; its URL stops working.+ */+export const deleteDatabaseWebhookParams = zod.object({+ id: zod.uuid().describe('Database id'),+ webhook_id: zod.uuid().describe('Webhook id'),+});+/*** Available to every signed-in user on every plan; does not consume chatcredits. Audio and transcripts are never persisted.diff --git a/apps/web/src/lib/service-clients/service-storage/openapi.json b/apps/web/src/lib/service-clients/service-storage/openapi.jsonindex 733b898731..282dc27034 100644--- a/apps/web/src/lib/service-clients/service-storage/openapi.json+++ b/apps/web/src/lib/service-clients/service-storage/openapi.json@@ -6983,6 +6983,85 @@}}},+ "/databases/webhooks/{token}": {+ "post": {+ "tags": ["databases"],+ "summary": "Insert rows through a webhook. The body is a JSON object, one row, or\nan array of up to 100 objects, one row each. Keys name columns by name\n(ignoring case) or id; `null` leaves a cell empty. Values may be loose:\n`\"45\"` for a number, `\"true\"` for a checkbox, a label or labels for a\nselect, `2026-10-09` for a date. Nothing is written unless every row fits.",+ "operationId": "deliver_database_webhook",+ "parameters": [+ {+ "name": "token",+ "in": "path",+ "description": "The webhook's secret token",+ "required": true,+ "schema": {+ "type": "string"+ }+ }+ ],+ "requestBody": {+ "description": "A row, or an array of rows",+ "content": {+ "application/json": {+ "schema": {}+ }+ },+ "required": true+ },+ "responses": {+ "201": {+ "description": "",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/DatabaseWebhookDeliveryResponse"+ }+ }+ }+ },+ "400": {+ "description": "The payload does not fit the table; nothing was written",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/InvalidDatabaseWebhookPayloadResponse"+ }+ }+ }+ },+ "403": {+ "description": "The webhook's creator can no longer edit the database",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/ErrorResponse"+ }+ }+ }+ },+ "404": {+ "description": "No such webhook",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/ErrorResponse"+ }+ }+ }+ },+ "500": {+ "description": "",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/ErrorResponse"+ }+ }+ }+ }+ }+ }+ },"/databases/{id}": {"get": {"tags": ["databases"],@@ -8141,6 +8220,220 @@}}},+ "/databases/{id}/webhooks": {+ "get": {+ "tags": ["databases"],+ "summary": "The database's webhooks.",+ "operationId": "list_database_webhooks",+ "parameters": [+ {+ "name": "id",+ "in": "path",+ "description": "Database id",+ "required": true,+ "schema": {+ "type": "string",+ "format": "uuid"+ }+ }+ ],+ "responses": {+ "200": {+ "description": "",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/ListDatabaseWebhooksResponse"+ }+ }+ }+ },+ "401": {+ "description": "Missing or invalid credentials",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/ErrorResponse"+ }+ }+ }+ },+ "403": {+ "description": "No edit access to the database",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/ErrorResponse"+ }+ }+ }+ },+ "500": {+ "description": "",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/ErrorResponse"+ }+ }+ }+ }+ }+ },+ "post": {+ "tags": ["databases"],+ "summary": "Create a webhook: a secret URL whose calls insert rows into one of the\ndatabase's tables, writing with the creator's access.",+ "operationId": "create_database_webhook",+ "parameters": [+ {+ "name": "id",+ "in": "path",+ "description": "Database id",+ "required": true,+ "schema": {+ "type": "string",+ "format": "uuid"+ }+ }+ ],+ "requestBody": {+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/CreateDatabaseWebhookRequest"+ }+ }+ },+ "required": true+ },+ "responses": {+ "201": {+ "description": "",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/CreatedDatabaseWebhookResponse"+ }+ }+ }+ },+ "401": {+ "description": "Missing or invalid credentials",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/ErrorResponse"+ }+ }+ }+ },+ "403": {+ "description": "No edit access to the database",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/ErrorResponse"+ }+ }+ }+ },+ "404": {+ "description": "No such table in the database",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/ErrorResponse"+ }+ }+ }+ },+ "500": {+ "description": "",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/ErrorResponse"+ }+ }+ }+ }+ }+ }+ },+ "/databases/{id}/webhooks/{webhook_id}": {+ "delete": {+ "tags": ["databases"],+ "summary": "Delete a webhook; its URL stops working.",+ "operationId": "delete_database_webhook",+ "parameters": [+ {+ "name": "id",+ "in": "path",+ "description": "Database id",+ "required": true,+ "schema": {+ "type": "string",+ "format": "uuid"+ }+ },+ {+ "name": "webhook_id",+ "in": "path",+ "description": "Webhook id",+ "required": true,+ "schema": {+ "type": "string",+ "format": "uuid"+ }+ }+ ],+ "responses": {+ "204": {+ "description": ""+ },+ "401": {+ "description": "Missing or invalid credentials",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/ErrorResponse"+ }+ }+ }+ },+ "403": {+ "description": "No edit access to the database",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/ErrorResponse"+ }+ }+ }+ },+ "404": {+ "description": "",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/ErrorResponse"+ }+ }+ }+ },+ "500": {+ "description": "",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/ErrorResponse"+ }+ }+ }+ }+ }+ }+ },"/dictation/transcribe": {"post": {"tags": ["dictation"],@@ -23108,6 +23401,18 @@}}},+ "CreateDatabaseWebhookRequest": {+ "type": "object",+ "description": "Which table a new webhook inserts rows into.",+ "required": ["tableId"],+ "properties": {+ "tableId": {+ "type": "string",+ "format": "uuid",+ "description": "A table of the database."+ }+ }+ },"CreateDocumentRequest": {"type": "object","required": ["sha", "documentName"],@@ -23848,6 +24153,21 @@}}},+ "CreatedDatabaseWebhookResponse": {+ "type": "object",+ "description": "A new webhook, with the token its URL carries. The token is shown only\nhere.",+ "required": ["webhook", "token"],+ "properties": {+ "token": {+ "type": "string",+ "description": "The secret: `POST /databases/webhooks/{token}` inserts rows."+ },+ "webhook": {+ "$ref": "#/components/schemas/DatabaseWebhookResponse",+ "description": "The webhook."+ }+ }+ },"CreatedPairing": {"type": "object","description": "A pairing the daemon created, including its claim credential.\n\n`device_secret` is returned exactly once and never stored raw; the daemon\nkeeps it to claim the harness credential after approval.",@@ -24438,6 +24758,93 @@}}},+ "DatabaseWebhookDeliveryResponse": {+ "type": "object",+ "description": "The rows a webhook call inserted.",+ "required": ["databaseId", "tableId", "rows"],+ "properties": {+ "databaseId": {+ "type": "string",+ "format": "uuid",+ "description": "The database."+ },+ "rows": {+ "type": "array",+ "items": {+ "type": "string",+ "format": "uuid"+ },+ "description": "The new rows, in the order the payload sent them."+ },+ "tableId": {+ "type": "string",+ "format": "uuid",+ "description": "The table."+ }+ }+ },+ "DatabaseWebhookPayloadProblem": {+ "type": "object",+ "description": "One thing wrong with a webhook payload.",+ "required": ["row", "field", "message"],+ "properties": {+ "field": {+ "type": ["string", "null"],+ "description": "The key at fault, when one is."+ },+ "message": {+ "type": "string",+ "description": "What is wrong."+ },+ "row": {+ "type": ["integer", "null"],+ "description": "The row's index, when the payload is an array of rows.",+ "minimum": 0+ }+ }+ },+ "DatabaseWebhookResponse": {+ "type": "object",+ "description": "A webhook of a database. Its token is never shown again after creation.",+ "required": [+ "id",+ "databaseId",+ "tableId",+ "createdBy",+ "tokenPrefix",+ "createdAt"+ ],+ "properties": {+ "createdAt": {+ "type": "string",+ "format": "date-time",+ "description": "Creation time."+ },+ "createdBy": {+ "type": "string",+ "description": "Who created it; its calls write with their access."+ },+ "databaseId": {+ "type": "string",+ "format": "uuid",+ "description": "The database."+ },+ "id": {+ "type": "string",+ "format": "uuid",+ "description": "Identifier."+ },+ "tableId": {+ "type": "string",+ "format": "uuid",+ "description": "The table its calls insert rows into."+ },+ "tokenPrefix": {+ "type": "string",+ "description": "The token's first characters, to tell webhooks apart."+ }+ }+ },"DateOperator": {"type": "string","description": "How a date cell compares to a date-time.",@@ -30184,6 +30591,24 @@"description": "Why a document interaction was reported.","enum": ["edited", "first_join", "last_leave"]},+ "InvalidDatabaseWebhookPayloadResponse": {+ "type": "object",+ "description": "Why a payload was refused. Nothing was written.",+ "required": ["message", "problems"],+ "properties": {+ "message": {+ "type": "string",+ "description": "A summary."+ },+ "problems": {+ "type": "array",+ "items": {+ "$ref": "#/components/schemas/DatabaseWebhookPayloadProblem"+ },+ "description": "Every problem found."+ }+ }+ },"InviteMeetingRequest": {"type": "object","description": "A single email recipient for a call invitation.",@@ -30497,6 +30922,20 @@"description": "Defines who can access an item through its share link.","enum": ["PUBLIC", "TEAM"]},+ "ListDatabaseWebhooksResponse": {+ "type": "object",+ "description": "A database's webhooks.",+ "required": ["webhooks"],+ "properties": {+ "webhooks": {+ "type": "array",+ "items": {+ "$ref": "#/components/schemas/DatabaseWebhookResponse"+ },+ "description": "Oldest first."+ }+ }+ },"ListWebhooksResponse": {"type": "object","description": "Webhooks visible to the caller across their personal and team workspaces.\n\nClients deserialize this, so both derives are used.",diff --git a/crates/database_webhooks/Cargo.toml b/crates/database_webhooks/Cargo.tomlnew file mode 100644index 0000000000..2c048c95eb--- /dev/null+++ b/crates/database_webhooks/Cargo.toml@@ -0,0 +1,49 @@+[package]+edition = "2024"+name = "database_webhooks"+publish = false+version = "0.1.0"++[features]+default = []+# Axum HTTP router: managing a database's webhooks, and receiving one.+inbound = [+ "dep:axum",+ "dep:macro_authorization",+ "dep:model-error-response",+ "databases/inbound",+ "entity_access/inbound",+]+# Postgres persistence, and receipts minted through entity access.+postgres = ["dep:sqlx"]++[dependencies]+axum = { workspace = true, optional = true }+chrono = { workspace = true, features = ["serde"] }+databases = { path = "../databases", features = ["ports"] }+entity_access = { path = "../entity_access", default-features = false, features = ["ports"] }+hex = { workspace = true }+macro_authorization = { path = "../macro_authorization", optional = true, default-features = false, features = ["axum"] }+macro_user_id = { path = "../macro_user_id" }+macro_uuid = { path = "../macro_uuid" }+model-error-response = { path = "../model-error-response", optional = true }+models_databases = { path = "../models_databases" }+rand = { workspace = true }+rootcause = { workspace = true }+serde = { workspace = true }+serde_json = { workspace = true }+sha2 = { workspace = true }+sqlx = { workspace = true, optional = true }+thiserror = { workspace = true }+tracing = { workspace = true }+utoipa = { workspace = true }+uuid = { workspace = true }+workspace-hack = { version = "0.1", path = "../workspace-hack" }++[dev-dependencies]+# The real databases service and entity access, for the end-to-end test.+databases = { path = "../databases", features = ["postgres"] }+entity_access = { path = "../entity_access", default-features = false, features = ["outbound"] }+macro_db_migrator = { path = "../macro_db_migrator" }+macro_event_broker = { path = "../macro_event_broker", default-features = false }+tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }diff --git a/crates/database_webhooks/src/domain.rs b/crates/database_webhooks/src/domain.rsnew file mode 100644index 0000000000..0dc2d4514f--- /dev/null+++ b/crates/database_webhooks/src/domain.rs@@ -0,0 +1,7 @@+//! Domain layer: models, the payload mapping, ports and the service.++pub mod mapping;+pub mod models;+pub mod ports;+pub mod service;+pub mod token;diff --git a/crates/database_webhooks/src/domain/mapping.rs b/crates/database_webhooks/src/domain/mapping.rsnew file mode 100644index 0000000000..b9bbd100b3--- /dev/null+++ b/crates/database_webhooks/src/domain/mapping.rs@@ -0,0 +1,258 @@+//! A webhook payload as rows of a table: a JSON object per row, its keys+//! naming columns, its values loosely typed as JSON can carry them. The+//! mapping only shapes values into cells; the databases service still checks+//! every cell against its column, as it does for any insert.++#[cfg(test)]+mod test;++use chrono::{DateTime, NaiveDate, Utc};+use models_databases::{+ CellValue, CellWrite, ColumnId, ColumnKind, EntityKind, EntityRef, OptionRef, RowId,+};+use serde_json::{Map, Value};++use crate::domain::models::PayloadProblem;++/// The most rows one call may insert.+pub const MAX_ROWS: usize = 100;++/// A column a payload key may name.+#[derive(Debug, Clone, PartialEq)]+pub struct WebhookColumn {+ /// The column placement.+ pub id: ColumnId,+ /// Its name, matched without regard to case or surrounding spaces.+ pub name: String,+ /// Its type; `None` for a type no op can write.+ pub kind: Option<ColumnKind>,+}++/// The rows a payload inserts: an object is one row, an array of objects is+/// a row each. A key names a column by its name or its id; `null` leaves the+/// cell empty. Every problem is reported, not just the first.+pub fn rows_from_payload(+ columns: &[WebhookColumn],+ payload: &Value,+) -> Result<Vec<Vec<CellWrite>>, Vec<PayloadProblem>> {+ let objects: Vec<(Option<usize>, &Value)> = match payload {+ Value::Object(_) => vec![(None, payload)],+ Value::Array(rows) if rows.is_empty() => {+ return Err(vec![problem(None, None, "expected at least one row")]);+ }+ Value::Array(rows) if rows.len() > MAX_ROWS => {+ return Err(vec![problem(+ None,+ None,+ &format!("at most {MAX_ROWS} rows per call"),+ )]);+ }+ Value::Array(rows) => rows+ .iter()+ .enumerate()+ .map(|(i, row)| (Some(i), row))+ .collect(),+ _ => {+ return Err(vec![problem(+ None,+ None,+ "expected a JSON object, or an array of objects, one per row",+ )]);+ }+ };++ let mut rows = Vec::with_capacity(objects.len());+ let mut problems = Vec::new();+ for (index, object) in objects {+ let Value::Object(object) = object else {+ problems.push(problem(index, None, "expected a JSON object"));+ continue;+ };+ match row(columns, object) {+ Ok(cells) => rows.push(cells),+ Err(found) => {+ problems.extend(found.into_iter().map(|(field, message)| PayloadProblem {+ row: index,+ field: Some(field),+ message,+ }))+ }+ }+ }+ if problems.is_empty() {+ Ok(rows)+ } else {+ Err(problems)+ }+}++fn problem(row: Option<usize>, field: Option<String>, message: &str) -> PayloadProblem {+ PayloadProblem {+ row,+ field,+ message: message.to_string(),+ }+}++/// One object's cells, in the order its keys came; or each key's problem.+fn row(+ columns: &[WebhookColumn],+ object: &Map<String, Value>,+) -> Result<Vec<CellWrite>, Vec<(String, String)>> {+ let mut cells = Vec::new();+ let mut named: Vec<ColumnId> = Vec::new();+ let mut problems = Vec::new();+ for (key, value) in object {+ let column = match column_for(columns, key) {+ Ok(column) => column,+ Err(message) => {+ problems.push((key.clone(), message));+ continue;+ }+ };+ if named.contains(&column.id) {+ problems.push((key.clone(), format!("\"{}\" is named twice", column.name)));+ continue;+ }+ named.push(column.id);+ match cell(column, value) {+ Ok(Some(value)) => cells.push(CellWrite {+ column: column.id,+ value,+ }),+ Ok(None) => {}+ Err(message) => problems.push((key.clone(), message.to_string())),+ }+ }+ if problems.is_empty() {+ Ok(cells)+ } else {+ Err(problems)+ }+}++/// The column a key names: the one with that id, else the one with that+/// name, ignoring case and surrounding spaces.+fn column_for<'columns>(+ columns: &'columns [WebhookColumn],+ key: &str,+) -> Result<&'columns WebhookColumn, String> {+ if let Some(column) = columns+ .iter()+ .find(|column| column.id.as_uuid().to_string() == key.trim())+ {+ return Ok(column);+ }+ let wanted = name_key(key);+ let mut matches = columns+ .iter()+ .filter(|column| name_key(&column.name) == wanted);+ match (matches.next(), matches.next()) {+ (Some(column), None) => Ok(column),+ (Some(_), Some(_)) => Err(format!(+ "several columns are named \"{}\"; name it by its column id",+ key.trim()+ )),+ (None, _) => Err(format!("no column is named \"{}\"", key.trim())),+ }+}++fn name_key(name: &str) -> String {+ name.trim().to_lowercase()+}++/// A value as a cell of its column; `None` leaves the cell empty.+fn cell(column: &WebhookColumn, value: &Value) -> Result<Option<CellValue>, &'static str> {+ if value.is_null() || value.as_array().is_some_and(Vec::is_empty) {+ return Ok(None);+ }+ let Some(kind) = column.kind else {+ return Err("this column's type cannot be written");+ };+ let value = match kind {+ ColumnKind::Text => CellValue::Text(text(value).ok_or("expected text")?),+ ColumnKind::Number => CellValue::Number(number(value).ok_or("expected a number")?),+ ColumnKind::Boolean => CellValue::Boolean(boolean(value).ok_or("expected true or false")?),+ ColumnKind::Date => CellValue::Date(+ date(value)+ .ok_or("expected an ISO 8601 date, like 2026-10-09 or 2026-10-09T15:00:00Z")?,+ ),+ ColumnKind::Link => CellValue::Link(each(value, string).ok_or("expected URLs")?),+ ColumnKind::Select { .. } | ColumnKind::SelectNumber { .. } | ColumnKind::Tag => {+ CellValue::Options(+ each(value, |value| text(value).map(OptionRef::Label))+ .ok_or("expected option labels")?,+ )+ }+ ColumnKind::Entity { target, .. } => CellValue::Entities(+ each(value, |value| entity(target, value)).ok_or("expected entity ids")?,+ ),+ ColumnKind::Relation { .. } => CellValue::Rows(+ each(value, |value| {+ string(value)?.trim().parse().ok().map(RowId::from_uuid)+ })+ .ok_or("expected row ids")?,+ ),+ };+ Ok(Some(value))+}++/// One value, or each of an array's.+fn each<Item>(value: &Value, item: impl Fn(&Value) -> Option<Item>) -> Option<Vec<Item>> {+ match value {+ Value::Array(values) => values.iter().map(item).collect(),+ value => item(value).map(|item| vec![item]),+ }+}++fn string(value: &Value) -> Option<String> {+ value.as_str().map(str::to_string)+}++/// A scalar as text: a string as it is, a number or boolean as JSON writes it.+fn text(value: &Value) -> Option<String> {+ match value {+ Value::String(text) => Some(text.clone()),+ Value::Number(number) => Some(number.to_string()),+ Value::Bool(boolean) => Some(boolean.to_string()),+ _ => None,+ }+}++fn number(value: &Value) -> Option<f64> {+ let number = match value {+ Value::Number(number) => number.as_f64()?,+ Value::String(text) => text.trim().parse().ok()?,+ _ => return None,+ };+ number.is_finite().then_some(number)+}++fn boolean(value: &Value) -> Option<bool> {+ match value {+ Value::Bool(boolean) => Some(*boolean),+ Value::String(text) => match text.trim().to_lowercase().as_str() {+ "true" => Some(true),+ "false" => Some(false),+ _ => None,+ },+ _ => None,+ }+}++/// A date-time with an offset, or a bare date as its midnight in UTC.+fn date(value: &Value) -> Option<DateTime<Utc>> {+ let text = value.as_str()?.trim();+ if let Ok(at) = DateTime::parse_from_rfc3339(text) {+ return Some(at.with_timezone(&Utc));+ }+ let day = NaiveDate::parse_from_str(text, "%Y-%m-%d").ok()?;+ Some(day.and_hms_opt(0, 0, 0)?.and_utc())+}++fn entity(target: EntityKind, value: &Value) -> Option<EntityRef> {+ Some(EntityRef {+ entity_type: target,+ entity_id: string(value)?.trim().to_string(),+ })+}diff --git a/crates/database_webhooks/src/domain/mapping/test.rs b/crates/database_webhooks/src/domain/mapping/test.rsnew file mode 100644index 0000000000..668fd717d7--- /dev/null+++ b/crates/database_webhooks/src/domain/mapping/test.rs@@ -0,0 +1,448 @@+use chrono::{TimeZone, Utc};+use models_databases::{CellValue, EntityKind, EntityRef, OptionRef, RowId};+use serde_json::json;+use uuid::Uuid;++use super::*;++const TITLE: ColumnId = ColumnId::from_uuid(Uuid::from_u128(1));+const DATE: ColumnId = ColumnId::from_uuid(Uuid::from_u128(2));+const ATTENDEES: ColumnId = ColumnId::from_uuid(Uuid::from_u128(3));+const DURATION: ColumnId = ColumnId::from_uuid(Uuid::from_u128(4));+const RECORDING: ColumnId = ColumnId::from_uuid(Uuid::from_u128(5));+const FOLLOW_UP: ColumnId = ColumnId::from_uuid(Uuid::from_u128(6));+const OWNER: ColumnId = ColumnId::from_uuid(Uuid::from_u128(7));+const ACCOUNT: ColumnId = ColumnId::from_uuid(Uuid::from_u128(8));+const STATUS: ColumnId = ColumnId::from_uuid(Uuid::from_u128(9));++/// The meetings table a note-taker posts to: one column of each kind a+/// payload commonly fills.+fn meetings() -> Vec<WebhookColumn> {+ vec![+ WebhookColumn {+ id: TITLE,+ name: "Title".to_string(),+ kind: Some(ColumnKind::Text),+ },+ WebhookColumn {+ id: DATE,+ name: "Date".to_string(),+ kind: Some(ColumnKind::Date),+ },+ WebhookColumn {+ id: ATTENDEES,+ name: "Attendees".to_string(),+ kind: Some(ColumnKind::Select { multi: true }),+ },+ WebhookColumn {+ id: DURATION,+ name: "Duration (min)".to_string(),+ kind: Some(ColumnKind::Number),+ },+ WebhookColumn {+ id: RECORDING,+ name: "Recording".to_string(),+ kind: Some(ColumnKind::Link),+ },+ WebhookColumn {+ id: FOLLOW_UP,+ name: "Needs follow-up".to_string(),+ kind: Some(ColumnKind::Boolean),+ },+ WebhookColumn {+ id: OWNER,+ name: "Owner".to_string(),+ kind: Some(ColumnKind::Entity {+ target: EntityKind::User,+ multi: false,+ }),+ },+ WebhookColumn {+ id: ACCOUNT,+ name: "Account".to_string(),+ kind: Some(ColumnKind::Relation {+ database: models_databases::DatabaseId::from_uuid(Uuid::from_u128(100)),+ table: models_databases::TableId::from_uuid(Uuid::from_u128(101)),+ }),+ },+ WebhookColumn {+ id: STATUS,+ name: "Status".to_string(),+ kind: Some(ColumnKind::Select { multi: false }),+ },+ ]+}++#[test]+fn an_object_is_one_row_of_cells_by_column_name() {+ let payload = json!({+ "Title": "Acme kickoff",+ "Date": "2026-10-09T15:00:00Z",+ "Attendees": ["Alice", "Bob"],+ "Duration (min)": 45,+ "Recording": null,+ "Needs follow-up": true,+ "Owner": "macro|[email protected]",+ "Account": "00000000-0000-0000-0000-0000000000c8",+ "Status": "Scheduled"+ });++ let rows = rows_from_payload(&meetings(), &payload).unwrap();++ assert_eq!(+ rows,+ vec![vec![+ CellWrite {+ column: TITLE,+ value: CellValue::Text("Acme kickoff".to_string()),+ },+ CellWrite {+ column: DATE,+ value: CellValue::Date(Utc.with_ymd_and_hms(2026, 10, 9, 15, 0, 0).unwrap()),+ },+ CellWrite {+ column: ATTENDEES,+ value: CellValue::Options(vec![+ OptionRef::Label("Alice".to_string()),+ OptionRef::Label("Bob".to_string()),+ ]),+ },+ CellWrite {+ column: DURATION,+ value: CellValue::Number(45.0),+ },+ CellWrite {+ column: FOLLOW_UP,+ value: CellValue::Boolean(true),+ },+ CellWrite {+ column: OWNER,+ value: CellValue::Entities(vec![EntityRef {+ entity_type: EntityKind::User,+ entity_id: "macro|[email protected]".to_string(),+ }]),+ },+ CellWrite {+ column: ACCOUNT,+ value: CellValue::Rows(vec![RowId::from_uuid(Uuid::from_u128(200))]),+ },+ CellWrite {+ column: STATUS,+ value: CellValue::Options(vec![OptionRef::Label("Scheduled".to_string())]),+ },+ ]]+ );+}++#[test]+fn an_array_is_a_row_per_object_in_order() {+ let payload = json!([+ { "Title": "First" },+ { "Title": "Second", "Duration (min)": 30 }+ ]);++ let rows = rows_from_payload(&meetings(), &payload).unwrap();++ assert_eq!(+ rows,+ vec![+ vec![CellWrite {+ column: TITLE,+ value: CellValue::Text("First".to_string()),+ }],+ vec![+ CellWrite {+ column: TITLE,+ value: CellValue::Text("Second".to_string()),+ },+ CellWrite {+ column: DURATION,+ value: CellValue::Number(30.0),+ },+ ],+ ]+ );+}++#[test]+fn an_empty_object_is_an_empty_row() {+ assert_eq!(+ rows_from_payload(&meetings(), &json!({})).unwrap(),+ vec![Vec::<CellWrite>::new()]+ );+}++/// Keys find their column however a sender spells the name, or by id.+#[test]+fn keys_name_columns_loosely_or_by_id() {+ let cases = [+ json!({ "title": "x" }),+ json!({ "TITLE": "x" }),+ json!({ " Title ": "x" }),+ json!({ "00000000-0000-0000-0000-000000000001": "x" }),+ ];+ for payload in cases {+ assert_eq!(+ rows_from_payload(&meetings(), &payload).unwrap(),+ vec![vec![CellWrite {+ column: TITLE,+ value: CellValue::Text("x".to_string()),+ }]],+ "{payload}"+ );+ }+}++/// What senders send that is not quite the column's type, and the cell it+/// becomes.+#[test]+fn values_are_shaped_to_their_column() {+ let cases = [+ (+ json!({ "Title": 42 }),+ TITLE,+ CellValue::Text("42".to_string()),+ ),+ (+ json!({ "Title": false }),+ TITLE,+ CellValue::Text("false".to_string()),+ ),+ (+ json!({ "Duration (min)": "12.5" }),+ DURATION,+ CellValue::Number(12.5),+ ),+ (+ json!({ "Duration (min)": " 7 " }),+ DURATION,+ CellValue::Number(7.0),+ ),+ (+ json!({ "Needs follow-up": "TRUE" }),+ FOLLOW_UP,+ CellValue::Boolean(true),+ ),+ (+ json!({ "Needs follow-up": "false" }),+ FOLLOW_UP,+ CellValue::Boolean(false),+ ),+ (+ json!({ "Date": "2026-10-09" }),+ DATE,+ CellValue::Date(Utc.with_ymd_and_hms(2026, 10, 9, 0, 0, 0).unwrap()),+ ),+ (+ json!({ "Date": "2026-10-09T10:00:00-05:00" }),+ DATE,+ CellValue::Date(Utc.with_ymd_and_hms(2026, 10, 9, 15, 0, 0).unwrap()),+ ),+ (+ json!({ "Recording": "https://example.com/r/1" }),+ RECORDING,+ CellValue::Link(vec!["https://example.com/r/1".to_string()]),+ ),+ (+ json!({ "Recording": ["https://a.example", "https://b.example"] }),+ RECORDING,+ CellValue::Link(vec![+ "https://a.example".to_string(),+ "https://b.example".to_string(),+ ]),+ ),+ (+ json!({ "Attendees": "Alice" }),+ ATTENDEES,+ CellValue::Options(vec![OptionRef::Label("Alice".to_string())]),+ ),+ (+ json!({ "Status": 3 }),+ STATUS,+ CellValue::Options(vec![OptionRef::Label("3".to_string())]),+ ),+ (+ json!({ "Account": ["00000000-0000-0000-0000-0000000000c8"] }),+ ACCOUNT,+ CellValue::Rows(vec![RowId::from_uuid(Uuid::from_u128(200))]),+ ),+ ];+ for (payload, column, value) in cases {+ assert_eq!(+ rows_from_payload(&meetings(), &payload).unwrap(),+ vec![vec![CellWrite { column, value }]],+ "{payload}"+ );+ }+}++/// An empty value is no cell, as `null` is: the row starts with it empty.+#[test]+fn empty_values_leave_the_cell_empty() {+ let payload = json!({+ "Title": null,+ "Attendees": [],+ "Recording": []+ });+ assert_eq!(+ rows_from_payload(&meetings(), &payload).unwrap(),+ vec![Vec::<CellWrite>::new()]+ );+}++/// Every payload the mapping refuses, and each problem it reports.+#[test]+fn payloads_that_do_not_fit_are_refused_with_every_problem() {+ let cases = [+ (+ json!("Acme kickoff"),+ vec![PayloadProblem {+ row: None,+ field: None,+ message: "expected a JSON object, or an array of objects, one per row".to_string(),+ }],+ ),+ (+ json!([]),+ vec![PayloadProblem {+ row: None,+ field: None,+ message: "expected at least one row".to_string(),+ }],+ ),+ (+ json!([{ "Title": "ok" }, 7]),+ vec![PayloadProblem {+ row: Some(1),+ field: None,+ message: "expected a JSON object".to_string(),+ }],+ ),+ (+ json!({ "Titel": "x", "Duration (min)": "soon" }),+ vec![+ PayloadProblem {+ row: None,+ field: Some("Titel".to_string()),+ message: "no column is named \"Titel\"".to_string(),+ },+ PayloadProblem {+ row: None,+ field: Some("Duration (min)".to_string()),+ message: "expected a number".to_string(),+ },+ ],+ ),+ (+ json!({ "Title": "a", "title": "b" }),+ vec![PayloadProblem {+ row: None,+ field: Some("title".to_string()),+ message: "\"Title\" is named twice".to_string(),+ }],+ ),+ (+ json!({ "Title": { "text": "x" } }),+ vec![PayloadProblem {+ row: None,+ field: Some("Title".to_string()),+ message: "expected text".to_string(),+ }],+ ),+ (+ json!({ "Needs follow-up": "maybe" }),+ vec![PayloadProblem {+ row: None,+ field: Some("Needs follow-up".to_string()),+ message: "expected true or false".to_string(),+ }],+ ),+ (+ json!({ "Date": "next tuesday" }),+ vec![PayloadProblem {+ row: None,+ field: Some("Date".to_string()),+ message: "expected an ISO 8601 date, like 2026-10-09 or 2026-10-09T15:00:00Z"+ .to_string(),+ }],+ ),+ (+ json!({ "Attendees": [{ "name": "Alice" }] }),+ vec![PayloadProblem {+ row: None,+ field: Some("Attendees".to_string()),+ message: "expected option labels".to_string(),+ }],+ ),+ (+ json!({ "Account": "acme" }),+ vec![PayloadProblem {+ row: None,+ field: Some("Account".to_string()),+ message: "expected row ids".to_string(),+ }],+ ),+ ];+ for (payload, problems) in cases {+ assert_eq!(+ rows_from_payload(&meetings(), &payload),+ Err(problems),+ "{payload}"+ );+ }+}++#[test]+fn two_columns_with_one_name_must_be_named_by_id() {+ let mut columns = meetings();+ columns.push(WebhookColumn {+ id: ColumnId::from_uuid(Uuid::from_u128(11)),+ name: "title".to_string(),+ kind: Some(ColumnKind::Text),+ });++ assert_eq!(+ rows_from_payload(&columns, &json!({ "Title": "x" })),+ Err(vec![PayloadProblem {+ row: None,+ field: Some("Title".to_string()),+ message: "several columns are named \"Title\"; name it by its column id".to_string(),+ }])+ );+ assert_eq!(+ rows_from_payload(+ &columns,+ &json!({ "00000000-0000-0000-0000-00000000000b": "x" })+ ),+ Ok(vec![vec![CellWrite {+ column: ColumnId::from_uuid(Uuid::from_u128(11)),+ value: CellValue::Text("x".to_string()),+ }]])+ );+}++#[test]+fn a_problem_in_an_array_names_its_row() {+ let payload = json!([{ "Title": "ok" }, { "Nope": 1 }]);+ assert_eq!(+ rows_from_payload(&meetings(), &payload),+ Err(vec![PayloadProblem {+ row: Some(1),+ field: Some("Nope".to_string()),+ message: "no column is named \"Nope\"".to_string(),+ }])+ );+}++#[test]+fn at_most_a_hundred_rows_per_call() {+ let payload = Value::Array(vec![json!({}); MAX_ROWS + 1]);+ assert_eq!(+ rows_from_payload(&meetings(), &payload),+ Err(vec![PayloadProblem {+ row: None,+ field: None,+ message: "at most 100 rows per call".to_string(),+ }])+ );+}diff --git a/crates/database_webhooks/src/domain/models.rs b/crates/database_webhooks/src/domain/models.rsnew file mode 100644index 0000000000..3bfe1f9327--- /dev/null+++ b/crates/database_webhooks/src/domain/models.rs@@ -0,0 +1,94 @@+//! A webhook, and what creating and calling one answers.++use chrono::{DateTime, Utc};+use databases::domain::models::DatabaseError;+use models_databases::{DatabaseId, RowId, TableId};+use uuid::Uuid;++/// A webhook's id.+pub type WebhookId = Uuid;++/// A webhook: a secret URL whose calls insert rows into one table.+#[derive(Debug, Clone, PartialEq, Eq)]+pub struct DatabaseWebhook {+ /// Identifier.+ pub id: WebhookId,+ /// The database the table belongs to.+ pub database_id: DatabaseId,+ /// The table its calls insert rows into.+ pub table_id: TableId,+ /// Who created it; its writes act with their access.+ pub created_by: String,+ /// The token's first characters, to tell webhooks apart.+ pub token_prefix: String,+ /// Creation time.+ pub created_at: DateTime<Utc>,+}++/// A webhook as it is stored: the token only as its hash.+#[derive(Debug, Clone, PartialEq, Eq)]+pub struct NewWebhook {+ /// Identifier.+ pub id: WebhookId,+ /// The database the table belongs to.+ pub database_id: DatabaseId,+ /// The table its calls insert rows into.+ pub table_id: TableId,+ /// Who created it.+ pub created_by: String,+ /// SHA-256 of the token.+ pub token_hash: [u8; 32],+ /// The token's first characters.+ pub token_prefix: String,+}++/// A new webhook and its token, which is shown this once and never again.+#[derive(Debug, Clone, PartialEq, Eq)]+pub struct CreatedWebhook {+ /// The webhook.+ pub webhook: DatabaseWebhook,+ /// The secret its URL carries.+ pub token: String,+}++/// What a call to a webhook inserted.+#[derive(Debug, Clone, PartialEq, Eq)]+pub struct Delivery {+ /// The database.+ pub database_id: DatabaseId,+ /// The table.+ pub table_id: TableId,+ /// The new rows, in the order the payload sent them.+ pub rows: Vec<RowId>,+}++/// One thing wrong with a payload.+#[derive(Debug, Clone, PartialEq, Eq)]+pub struct PayloadProblem {+ /// The row's index when the payload is an array of rows.+ pub row: Option<usize>,+ /// The key at fault, when one is.+ pub field: Option<String>,+ /// What is wrong.+ pub message: String,+}++/// Why a webhook use case failed.+#[derive(Debug, thiserror::Error)]+pub enum DatabaseWebhookError {+ /// No such webhook, table or database, or none the caller can see.+ #[error("not found")]+ NotFound,+ /// The caller may not do this.+ #[error("{0}")]+ Forbidden(&'static str),+ /// The payload does not fit the table; nothing was written.+ #[error("the payload does not fit the table")]+ InvalidPayload(Vec<PayloadProblem>),+ /// The databases service refused or failed.+ #[error("{0}")]+ Database(DatabaseError),+ /// Persistence failure.+ #[error("repository error: {0}")]+ Repository(rootcause::Report),+}diff --git a/crates/database_webhooks/src/domain/ports.rs b/crates/database_webhooks/src/domain/ports.rsnew file mode 100644index 0000000000..eb96141be7--- /dev/null+++ b/crates/database_webhooks/src/domain/ports.rs@@ -0,0 +1,108 @@+//! What the webhooks service needs, and what it offers.++use databases::domain::models::{DatabaseError, Viewer};+use entity_access::domain::models::{EditAccessLevel, EntityAccessReceipt};+use macro_user_id::user_id::MacroUserIdStr;+use models_databases::{CellWrite, DatabaseId, RowId, TableId};+use serde_json::Value;++use crate::domain::mapping::WebhookColumn;+use crate::domain::models::{+ CreatedWebhook, DatabaseWebhook, DatabaseWebhookError, Delivery, NewWebhook, WebhookId,+};++/// The webhooks domain service.+pub trait DatabaseWebhooksService: Send + Sync + 'static {+ /// Create a webhook that inserts rows into one of the receipt's+ /// database's tables, acting with the creator's access.+ fn create_webhook(+ &self,+ receipt: EntityAccessReceipt<EditAccessLevel>,+ table_id: TableId,+ ) -> impl Future<Output = Result<CreatedWebhook, DatabaseWebhookError>> + Send;++ /// The receipt's database's webhooks, oldest first.+ fn list_webhooks(+ &self,+ receipt: EntityAccessReceipt<EditAccessLevel>,+ ) -> impl Future<Output = Result<Vec<DatabaseWebhook>, DatabaseWebhookError>> + Send;++ /// Delete one of the receipt's database's webhooks; its URL stops+ /// working.+ fn delete_webhook(+ &self,+ receipt: EntityAccessReceipt<EditAccessLevel>,+ webhook_id: WebhookId,+ ) -> impl Future<Output = Result<(), DatabaseWebhookError>> + Send;++ /// Insert the payload's rows through the webhook the token names. The+ /// token is the whole credential; the write acts as the webhook's+ /// creator, so it stops when they can no longer edit the database.+ fn deliver(+ &self,+ token: &str,+ payload: &Value,+ ) -> impl Future<Output = Result<Delivery, DatabaseWebhookError>> + Send;+}++/// Where webhooks are kept.+pub trait DatabaseWebhooksRepo: Send + Sync + 'static {+ /// Store a new webhook.+ fn insert_webhook(+ &self,+ webhook: NewWebhook,+ ) -> impl Future<Output = Result<DatabaseWebhook, rootcause::Report>> + Send;++ /// A database's webhooks, oldest first.+ fn database_webhooks(+ &self,+ database_id: DatabaseId,+ ) -> impl Future<Output = Result<Vec<DatabaseWebhook>, rootcause::Report>> + Send;++ /// Delete a webhook of the database; whether there was one.+ fn delete_webhook(+ &self,+ database_id: DatabaseId,+ webhook_id: WebhookId,+ ) -> impl Future<Output = Result<bool, rootcause::Report>> + Send;++ /// The webhook whose token hashes to `token_hash`.+ fn webhook_by_token_hash(+ &self,+ token_hash: [u8; 32],+ ) -> impl Future<Output = Result<Option<DatabaseWebhook>, rootcause::Report>> + Send;+}++/// The tables webhooks write, through the databases service.+pub trait WebhookTables: Send + Sync + 'static {+ /// The table's columns, in display order; `None` when the database is+ /// gone or trashed or has no such table.+ fn table_columns(+ &self,+ database_id: DatabaseId,+ table_id: TableId,+ ) -> impl Future<Output = Result<Option<Vec<WebhookColumn>>, DatabaseError>> + Send;++ /// Insert rows, as an ordinary insert by `viewer`; the new rows' ids in+ /// order.+ fn insert_rows(+ &self,+ receipt: EntityAccessReceipt<EditAccessLevel>,+ viewer: Viewer,+ table_id: TableId,+ rows: Vec<Vec<CellWrite>>,+ ) -> impl Future<Output = Result<Vec<RowId>, DatabaseError>> + Send;+}++/// Whether a webhook's creator can still edit its database.+pub trait CreatorAccess: Send + Sync + 'static {+ /// The creator's edit receipt for the database; `None` when they can no+ /// longer edit it.+ fn edit_receipt(+ &self,+ user_id: &MacroUserIdStr<'static>,+ database_id: DatabaseId,+ ) -> impl Future<+ Output = Result<Option<EntityAccessReceipt<EditAccessLevel>>, rootcause::Report>,+ > + Send;+}diff --git a/crates/database_webhooks/src/domain/service.rs b/crates/database_webhooks/src/domain/service.rsnew file mode 100644index 0000000000..fa995620a4--- /dev/null+++ b/crates/database_webhooks/src/domain/service.rs@@ -0,0 +1,211 @@+//! The webhooks service: every decision beyond the receipt its caller+//! minted, over its ports.++#[cfg(test)]+mod test;++use databases::domain::models::{DatabaseError, Viewer};+use entity_access::domain::models::{+ EditAccessLevel, EntityAccessReceipt, EntityType, RequiredPermission,+};+use macro_user_id::user_id::MacroUserIdStr;+use models_databases::{DatabaseId, TableId};+use serde_json::Value;++use crate::domain::mapping::{WebhookColumn, rows_from_payload};+use crate::domain::models::{+ CreatedWebhook, DatabaseWebhook, DatabaseWebhookError, Delivery, NewWebhook, PayloadProblem,+ WebhookId,+};+use crate::domain::ports::{+ CreatorAccess, DatabaseWebhooksRepo, DatabaseWebhooksService, WebhookTables,+};+use crate::domain::token;++/// The webhooks service over its ports.+#[derive(Debug, Clone)]+pub struct DatabaseWebhooksServiceImpl<Repository, Tables, Access> {+ repository: Repository,+ tables: Tables,+ access: Access,+}++impl<Repository, Tables, Access> DatabaseWebhooksServiceImpl<Repository, Tables, Access> {+ /// A service from its ports.+ pub fn new(repository: Repository, tables: Tables, access: Access) -> Self {+ Self {+ repository,+ tables,+ access,+ }+ }+}++/// The database a receipt was minted for.+fn receipt_database_id<Level: RequiredPermission>(+ receipt: &EntityAccessReceipt<Level>,+) -> Result<DatabaseId, DatabaseWebhookError> {+ let entity = receipt.entity();+ if entity.entity_type != EntityType::Database {+ return Err(DatabaseWebhookError::NotFound);+ }+ entity+ .entity_id+ .parse()+ .map_err(|_| DatabaseWebhookError::NotFound)+}++fn database_error(error: DatabaseError) -> DatabaseWebhookError {+ match error {+ DatabaseError::NotFound => DatabaseWebhookError::NotFound,+ other => DatabaseWebhookError::Database(other),+ }+}++/// A cell the databases service refused, as the payload's problem: its row+/// when the payload sent several, and its column by name.+fn refused_cell(+ error: DatabaseError,+ columns: &[WebhookColumn],+ several_rows: bool,+) -> DatabaseWebhookError {+ let DatabaseError::InvalidOp(refusal) = error else {+ return database_error(error);+ };+ let field = refusal.column.and_then(|refused| {+ columns+ .iter()+ .find(|column| column.id == refused)+ .map(|column| column.name.clone())+ });+ DatabaseWebhookError::InvalidPayload(vec![PayloadProblem {+ row: refusal.row.filter(|_| several_rows),+ field,+ message: refusal.reason,+ }])+}++impl<Repository, Tables, Access> DatabaseWebhooksService+ for DatabaseWebhooksServiceImpl<Repository, Tables, Access>+where+ Repository: DatabaseWebhooksRepo,+ Tables: WebhookTables,+ Access: CreatorAccess,+{+ #[tracing::instrument(skip(self, receipt), err)]+ async fn create_webhook(+ &self,+ receipt: EntityAccessReceipt<EditAccessLevel>,+ table_id: TableId,+ ) -> Result<CreatedWebhook, DatabaseWebhookError> {+ let database_id = receipt_database_id(&receipt)?;+ let Some(creator) = receipt.acting_user_id() else {+ return Err(DatabaseWebhookError::Forbidden(+ "only a signed-in person can create a webhook",+ ));+ };+ self.tables+ .table_columns(database_id, table_id)+ .await+ .map_err(database_error)?+ .ok_or(DatabaseWebhookError::NotFound)?;+ let token = token::generate();+ let webhook = self+ .repository+ .insert_webhook(NewWebhook {+ id: macro_uuid::generate_uuid_v7(),+ database_id,+ table_id,+ created_by: creator.to_string(),+ token_hash: token::hash(&token),+ token_prefix: token::prefix(&token),+ })+ .await+ .map_err(DatabaseWebhookError::Repository)?;+ Ok(CreatedWebhook { webhook, token })+ }++ #[tracing::instrument(skip(self, receipt), err)]+ async fn list_webhooks(+ &self,+ receipt: EntityAccessReceipt<EditAccessLevel>,+ ) -> Result<Vec<DatabaseWebhook>, DatabaseWebhookError> {+ let database_id = receipt_database_id(&receipt)?;+ self.repository+ .database_webhooks(database_id)+ .await+ .map_err(DatabaseWebhookError::Repository)+ }++ #[tracing::instrument(skip(self, receipt), err)]+ async fn delete_webhook(+ &self,+ receipt: EntityAccessReceipt<EditAccessLevel>,+ webhook_id: WebhookId,+ ) -> Result<(), DatabaseWebhookError> {+ let database_id = receipt_database_id(&receipt)?;+ let deleted = self+ .repository+ .delete_webhook(database_id, webhook_id)+ .await+ .map_err(DatabaseWebhookError::Repository)?;+ if deleted {+ Ok(())+ } else {+ Err(DatabaseWebhookError::NotFound)+ }+ }++ #[tracing::instrument(skip_all, err)]+ async fn deliver(+ &self,+ token: &str,+ payload: &Value,+ ) -> Result<Delivery, DatabaseWebhookError> {+ let webhook = self+ .repository+ .webhook_by_token_hash(token::hash(token))+ .await+ .map_err(DatabaseWebhookError::Repository)?+ .ok_or(DatabaseWebhookError::NotFound)?;+ let creator = MacroUserIdStr::try_from(webhook.created_by.clone()).map_err(|error| {+ DatabaseWebhookError::Repository(rootcause::report!(+ "stored webhook creator is not a user id: {error}"+ ))+ })?;+ let receipt = self+ .access+ .edit_receipt(&creator, webhook.database_id)+ .await+ .map_err(DatabaseWebhookError::Repository)?+ .ok_or(DatabaseWebhookError::Forbidden(+ "the webhook's creator can no longer edit this database",+ ))?;+ let columns = self+ .tables+ .table_columns(webhook.database_id, webhook.table_id)+ .await+ .map_err(database_error)?+ .ok_or(DatabaseWebhookError::NotFound)?;+ let rows =+ rows_from_payload(&columns, payload).map_err(DatabaseWebhookError::InvalidPayload)?;+ let rows = self+ .tables+ .insert_rows(+ receipt,+ Viewer {+ user_id: creator,+ acting_bot: None,+ },+ webhook.table_id,+ rows,+ )+ .await+ .map_err(|error| refused_cell(error, &columns, payload.is_array()))?;+ Ok(Delivery {+ database_id: webhook.database_id,+ table_id: webhook.table_id,+ rows,+ })+ }+}diff --git a/crates/database_webhooks/src/domain/service/test.rs b/crates/database_webhooks/src/domain/service/test.rsnew file mode 100644index 0000000000..31dd5d6b77--- /dev/null+++ b/crates/database_webhooks/src/domain/service/test.rs@@ -0,0 +1,310 @@+mod fakes;++use std::collections::HashMap;++use databases::domain::models::{DatabaseError, OpRefusal};+use entity_access::domain::models::{EntityAccessReceipt, EntityType};+use macro_user_id::user_id::MacroUserIdStr;+use models_databases::{CellValue, CellWrite, ColumnId, ColumnKind, DatabaseId, RowId, TableId};+use serde_json::json;+use uuid::Uuid;++use self::fakes::{FakeAccess, FakeRepo, FakeTables, Insert};+use super::*;+use crate::domain::mapping::WebhookColumn;+use crate::domain::models::{NewWebhook, PayloadProblem};+use crate::domain::token;++const ALICE: &str = "macro|[email protected]";+const DATABASE: DatabaseId = DatabaseId::from_uuid(Uuid::from_u128(1));+const OTHER_DATABASE: DatabaseId = DatabaseId::from_uuid(Uuid::from_u128(2));+const MEETINGS: TableId = TableId::from_uuid(Uuid::from_u128(10));+const TITLE: ColumnId = ColumnId::from_uuid(Uuid::from_u128(20));+const DURATION: ColumnId = ColumnId::from_uuid(Uuid::from_u128(21));++fn alice() -> MacroUserIdStr<'static> {+ MacroUserIdStr::parse_from_str(ALICE).unwrap()+}++fn alice_edits(database: DatabaseId) -> EntityAccessReceipt<EditAccessLevel> {+ EntityAccessReceipt::dangerously_assert_authenticated_user(+ alice(),+ &database.to_string(),+ EntityType::Database,+ )+}++/// A service over one database whose meetings table has a title and a+/// duration, which Alice can edit.+fn service() -> (+ DatabaseWebhooksServiceImpl<FakeRepo, FakeTables, FakeAccess>,+ FakeRepo,+ FakeTables,+ FakeAccess,+) {+ let repository = FakeRepo::default();+ let tables = FakeTables {+ tables: HashMap::from([(+ (DATABASE, MEETINGS),+ vec![+ WebhookColumn {+ id: TITLE,+ name: "Title".to_string(),+ kind: Some(ColumnKind::Text),+ },+ WebhookColumn {+ id: DURATION,+ name: "Duration".to_string(),+ kind: Some(ColumnKind::Number),+ },+ ],+ )]),+ ..FakeTables::default()+ };+ let access = FakeAccess::default();+ access+ .editors+ .lock()+ .unwrap()+ .push((ALICE.to_string(), DATABASE));+ (+ DatabaseWebhooksServiceImpl::new(repository.clone(), tables.clone(), access.clone()),+ repository,+ tables,+ access,+ )+}++#[tokio::test]+async fn creating_a_webhook_keeps_only_its_token_hash() {+ let (service, repository, _, _) = service();++ let created = service+ .create_webhook(alice_edits(DATABASE), MEETINGS)+ .await+ .unwrap();++ assert!(created.token.starts_with("mdbw_"));+ assert_eq!(created.webhook.database_id, DATABASE);+ assert_eq!(created.webhook.table_id, MEETINGS);+ assert_eq!(created.webhook.created_by, ALICE);+ assert_eq!(created.webhook.token_prefix, token::prefix(&created.token));+ assert_eq!(+ *repository.stored.lock().unwrap(),+ vec![NewWebhook {+ id: created.webhook.id,+ database_id: DATABASE,+ table_id: MEETINGS,+ created_by: ALICE.to_string(),+ token_hash: token::hash(&created.token),+ token_prefix: token::prefix(&created.token),+ }]+ );+}++#[tokio::test]+async fn a_webhook_is_for_a_table_of_the_receipts_database() {+ let (service, repository, _, _) = service();++ let refused = service+ .create_webhook(alice_edits(OTHER_DATABASE), MEETINGS)+ .await;++ assert!(matches!(refused, Err(DatabaseWebhookError::NotFound)));+ assert!(repository.stored.lock().unwrap().is_empty());+}++#[tokio::test]+async fn only_a_person_can_create_a_webhook() {+ let (service, _, _, _) = service();++ let refused = service+ .create_webhook(+ EntityAccessReceipt::dangerously_assert_internal_user(+ &DATABASE.to_string(),+ EntityType::Database,+ ),+ MEETINGS,+ )+ .await;++ assert!(matches!(refused, Err(DatabaseWebhookError::Forbidden(_))));+}++#[tokio::test]+async fn a_delivery_inserts_its_rows_as_the_creator() {+ let (service, _, tables, _) = service();+ let created = service+ .create_webhook(alice_edits(DATABASE), MEETINGS)+ .await+ .unwrap();++ let delivery = service+ .deliver(+ &created.token,+ &json!({ "Title": "Acme kickoff", "Duration": 45 }),+ )+ .await+ .unwrap();++ assert_eq!(+ delivery,+ Delivery {+ database_id: DATABASE,+ table_id: MEETINGS,+ rows: vec![RowId::from_uuid(Uuid::from_u128(1000))],+ }+ );+ assert_eq!(+ *tables.inserts.lock().unwrap(),+ vec![Insert {+ database_id: DATABASE.to_string(),+ viewer: ALICE.to_string(),+ table_id: MEETINGS,+ rows: vec![vec![+ CellWrite {+ column: TITLE,+ value: CellValue::Text("Acme kickoff".to_string()),+ },+ CellWrite {+ column: DURATION,+ value: CellValue::Number(45.0),+ },+ ]],+ }]+ );+}++#[tokio::test]+async fn an_unknown_token_is_not_found() {+ let (service, _, tables, _) = service();++ let refused = service+ .deliver(&token::generate(), &json!({ "Title": "x" }))+ .await;++ assert!(matches!(refused, Err(DatabaseWebhookError::NotFound)));+ assert!(tables.inserts.lock().unwrap().is_empty());+}++#[tokio::test]+async fn a_webhook_stops_when_its_creator_can_no_longer_edit() {+ let (service, _, tables, access) = service();+ let created = service+ .create_webhook(alice_edits(DATABASE), MEETINGS)+ .await+ .unwrap();+ access.editors.lock().unwrap().clear();++ let refused = service+ .deliver(&created.token, &json!({ "Title": "x" }))+ .await;++ assert!(matches!(refused, Err(DatabaseWebhookError::Forbidden(_))));+ assert!(tables.inserts.lock().unwrap().is_empty());+}++#[tokio::test]+async fn a_payload_that_does_not_fit_writes_nothing() {+ let (service, _, tables, _) = service();+ let created = service+ .create_webhook(alice_edits(DATABASE), MEETINGS)+ .await+ .unwrap();++ let refused = service+ .deliver(&created.token, &json!({ "Titel": "x" }))+ .await;++ match refused {+ Err(DatabaseWebhookError::InvalidPayload(problems)) => assert_eq!(+ problems,+ vec![PayloadProblem {+ row: None,+ field: Some("Titel".to_string()),+ message: "no column is named \"Titel\"".to_string(),+ }]+ ),+ other => panic!("expected an invalid payload, got {other:?}"),+ }+ assert!(tables.inserts.lock().unwrap().is_empty());+}++/// A cell the databases service refuses (an unknown option, a required+/// column left empty) is the payload's problem, named by its key.+#[tokio::test]+async fn a_refused_cell_is_reported_by_its_column_name() {+ let (service, _, tables, _) = service();+ let created = service+ .create_webhook(alice_edits(DATABASE), MEETINGS)+ .await+ .unwrap();+ *tables.refusal.lock().unwrap() = Some(DatabaseError::InvalidOp(OpRefusal {+ op: 0,+ row: Some(1),+ column: Some(DURATION),+ taken: None,+ reason: "\"Duration\" needs a value".to_string(),+ }));++ let refused = service+ .deliver(+ &created.token,+ &json!([{ "Title": "a", "Duration": 1 }, { "Title": "b" }]),+ )+ .await;++ match refused {+ Err(DatabaseWebhookError::InvalidPayload(problems)) => assert_eq!(+ problems,+ vec![PayloadProblem {+ row: Some(1),+ field: Some("Duration".to_string()),+ message: "\"Duration\" needs a value".to_string(),+ }]+ ),+ other => panic!("expected an invalid payload, got {other:?}"),+ }+}++#[tokio::test]+async fn webhooks_are_listed_and_deleted_within_their_database() {+ let (service, _, _, access) = service();+ access+ .editors+ .lock()+ .unwrap()+ .push((ALICE.to_string(), OTHER_DATABASE));+ let created = service+ .create_webhook(alice_edits(DATABASE), MEETINGS)+ .await+ .unwrap();++ assert_eq!(+ service.list_webhooks(alice_edits(DATABASE)).await.unwrap(),+ vec![created.webhook.clone()]+ );+ assert!(+ service+ .list_webhooks(alice_edits(OTHER_DATABASE))+ .await+ .unwrap()+ .is_empty()+ );+ assert!(matches!(+ service+ .delete_webhook(alice_edits(OTHER_DATABASE), created.webhook.id)+ .await,+ Err(DatabaseWebhookError::NotFound)+ ));++ service+ .delete_webhook(alice_edits(DATABASE), created.webhook.id)+ .await+ .unwrap();++ assert!(matches!(+ service.deliver(&created.token, &json!({})).await,+ Err(DatabaseWebhookError::NotFound)+ ));+}diff --git a/crates/database_webhooks/src/domain/service/test/fakes.rs b/crates/database_webhooks/src/domain/service/test/fakes.rsnew file mode 100644index 0000000000..b267f98400--- /dev/null+++ b/crates/database_webhooks/src/domain/service/test/fakes.rs@@ -0,0 +1,159 @@+//! In-memory stand-ins for the service's ports, recording what was written.++use std::collections::HashMap;+use std::sync::{Arc, Mutex};++use chrono::{TimeZone, Utc};+use databases::domain::models::{DatabaseError, Viewer};+use entity_access::domain::models::{EditAccessLevel, EntityAccessReceipt, EntityType};+use macro_user_id::user_id::MacroUserIdStr;+use models_databases::{CellWrite, DatabaseId, RowId, TableId};+use uuid::Uuid;++use crate::domain::mapping::WebhookColumn;+use crate::domain::models::{DatabaseWebhook, NewWebhook, WebhookId};+use crate::domain::ports::{CreatorAccess, DatabaseWebhooksRepo, WebhookTables};++/// Webhooks kept with their token hashes.+#[derive(Debug, Clone, Default)]+pub(crate) struct FakeRepo {+ pub(crate) stored: Arc<Mutex<Vec<NewWebhook>>>,+}++fn stored(webhook: &NewWebhook) -> DatabaseWebhook {+ DatabaseWebhook {+ id: webhook.id,+ database_id: webhook.database_id,+ table_id: webhook.table_id,+ created_by: webhook.created_by.clone(),+ token_prefix: webhook.token_prefix.clone(),+ created_at: Utc.with_ymd_and_hms(2026, 10, 9, 12, 0, 0).unwrap(),+ }+}++impl DatabaseWebhooksRepo for FakeRepo {+ async fn insert_webhook(+ &self,+ webhook: NewWebhook,+ ) -> Result<DatabaseWebhook, rootcause::Report> {+ let answer = stored(&webhook);+ self.stored.lock().unwrap().push(webhook);+ Ok(answer)+ }++ async fn database_webhooks(+ &self,+ database_id: DatabaseId,+ ) -> Result<Vec<DatabaseWebhook>, rootcause::Report> {+ Ok(self+ .stored+ .lock()+ .unwrap()+ .iter()+ .filter(|webhook| webhook.database_id == database_id)+ .map(stored)+ .collect())+ }++ async fn delete_webhook(+ &self,+ database_id: DatabaseId,+ webhook_id: WebhookId,+ ) -> Result<bool, rootcause::Report> {+ let mut webhooks = self.stored.lock().unwrap();+ let before = webhooks.len();+ webhooks+ .retain(|webhook| !(webhook.database_id == database_id && webhook.id == webhook_id));+ Ok(webhooks.len() != before)+ }++ async fn webhook_by_token_hash(+ &self,+ token_hash: [u8; 32],+ ) -> Result<Option<DatabaseWebhook>, rootcause::Report> {+ Ok(self+ .stored+ .lock()+ .unwrap()+ .iter()+ .find(|webhook| webhook.token_hash == token_hash)+ .map(stored))+ }+}++/// One insert the fake tables received.+#[derive(Debug, Clone, PartialEq)]+pub(crate) struct Insert {+ pub(crate) database_id: String,+ pub(crate) viewer: String,+ pub(crate) table_id: TableId,+ pub(crate) rows: Vec<Vec<CellWrite>>,+}++/// Tables by database, and every insert they took.+#[derive(Debug, Clone, Default)]+pub(crate) struct FakeTables {+ pub(crate) tables: HashMap<(DatabaseId, TableId), Vec<WebhookColumn>>,+ pub(crate) inserts: Arc<Mutex<Vec<Insert>>>,+ /// What the databases service refuses the next insert with.+ pub(crate) refusal: Arc<Mutex<Option<DatabaseError>>>,+}++impl WebhookTables for FakeTables {+ async fn table_columns(+ &self,+ database_id: DatabaseId,+ table_id: TableId,+ ) -> Result<Option<Vec<WebhookColumn>>, DatabaseError> {+ Ok(self.tables.get(&(database_id, table_id)).cloned())+ }++ async fn insert_rows(+ &self,+ receipt: EntityAccessReceipt<EditAccessLevel>,+ viewer: Viewer,+ table_id: TableId,+ rows: Vec<Vec<CellWrite>>,+ ) -> Result<Vec<RowId>, DatabaseError> {+ if let Some(refusal) = self.refusal.lock().unwrap().take() {+ return Err(refusal);+ }+ let ids = (0..rows.len())+ .map(|index| RowId::from_uuid(Uuid::from_u128(1000 + index as u128)))+ .collect();+ self.inserts.lock().unwrap().push(Insert {+ database_id: receipt.entity().entity_id.clone(),+ viewer: viewer.user_id.to_string(),+ table_id,+ rows,+ });+ Ok(ids)+ }+}++/// Who can edit which database.+#[derive(Debug, Clone, Default)]+pub(crate) struct FakeAccess {+ pub(crate) editors: Arc<Mutex<Vec<(String, DatabaseId)>>>,+}++impl CreatorAccess for FakeAccess {+ async fn edit_receipt(+ &self,+ user_id: &MacroUserIdStr<'static>,+ database_id: DatabaseId,+ ) -> Result<Option<EntityAccessReceipt<EditAccessLevel>>, rootcause::Report> {+ let can_edit = self+ .editors+ .lock()+ .unwrap()+ .contains(&(user_id.to_string(), database_id));+ Ok(can_edit.then(|| {+ EntityAccessReceipt::dangerously_assert_authenticated_user(+ user_id.clone(),+ &database_id.to_string(),+ EntityType::Database,+ )+ }))+ }+}diff --git a/crates/database_webhooks/src/domain/token.rs b/crates/database_webhooks/src/domain/token.rsnew file mode 100644index 0000000000..5ce5946107--- /dev/null+++ b/crates/database_webhooks/src/domain/token.rs@@ -0,0 +1,48 @@+//! Webhook tokens: `mdbw_<prefix>_<secret>`, kept only as a SHA-256.++use rand::RngCore;+use sha2::{Digest, Sha256};++const SECRET_BYTES: usize = 32;+const PREFIX_CHARS: usize = 12;++/// A fresh token. It is URL-path safe: ASCII letters, digits and `_`.+pub fn generate() -> String {+ let mut secret = [0_u8; SECRET_BYTES];+ rand::rng().fill_bytes(&mut secret);+ let secret = hex::encode(secret);+ format!("mdbw_{}_{secret}", &secret[..PREFIX_CHARS])+}++/// The SHA-256 a token is stored and looked up by.+pub fn hash(token: &str) -> [u8; 32] {+ Sha256::digest(token.as_bytes()).into()+}++/// The part of a token a list shows: `mdbw_<prefix>`.+pub fn prefix(token: &str) -> String {+ token.chars().take("mdbw_".len() + PREFIX_CHARS).collect()+}++#[cfg(test)]+mod test {+ use super::*;++ #[test]+ fn a_token_is_its_prefix_then_its_secret() {+ let token = generate();+ let parts: Vec<&str> = token.split('_').collect();++ assert_eq!(parts.len(), 3);+ assert_eq!(parts[0], "mdbw");+ assert_eq!(parts[1].len(), PREFIX_CHARS);+ assert_eq!(parts[2].len(), SECRET_BYTES * 2);+ assert!(parts[2].starts_with(parts[1]));+ assert_eq!(prefix(&token), format!("mdbw_{}", parts[1]));+ }++ #[test]+ fn two_tokens_differ() {+ assert_ne!(generate(), generate());+ }+}diff --git a/crates/database_webhooks/src/inbound.rs b/crates/database_webhooks/src/inbound.rsnew file mode 100644index 0000000000..6e7212014d--- /dev/null+++ b/crates/database_webhooks/src/inbound.rs@@ -0,0 +1,3 @@+//! Driving adapters: the Axum webhooks router.++pub mod axum_router;diff --git a/crates/database_webhooks/src/inbound/axum_router.rs b/crates/database_webhooks/src/inbound/axum_router.rsnew file mode 100644index 0000000000..1c96a25e16--- /dev/null+++ b/crates/database_webhooks/src/inbound/axum_router.rs@@ -0,0 +1,445 @@+//! Axum router for database webhooks, mounted beside the databases router at+//! `/databases`. Managing a database's webhooks takes edit access to it;+//! calling one takes only its token, which the URL carries.++#[cfg(test)]+mod test;++use std::sync::Arc;++use axum::body::Bytes;+use axum::extract::{FromRef, Path, State};+use axum::http::StatusCode;+use axum::response::IntoResponse;+use axum::routing::{delete, post};+use axum::{Json, Router};+use chrono::{DateTime, Utc};+use entity_access::domain::models::EditAccessLevel;+use entity_access::domain::ports::EntityAccessService;+use entity_access::inbound::axum_extractors::DatabaseAccessLevelExtractor;+use macro_authorization::{MacroAuthorizationService, MacroAuthorizationState};+use model_error_response::ErrorResponse;+use models_databases::{DatabaseId, RowId, TableId};+use serde::{Deserialize, Serialize};+use utoipa::OpenApi;+use uuid::Uuid;++use crate::domain::models::{+ CreatedWebhook, DatabaseWebhook, DatabaseWebhookError, Delivery, PayloadProblem, WebhookId,+};+use crate::domain::ports::DatabaseWebhooksService;++/// Router state for the webhooks endpoints.+pub struct DatabaseWebhooksRouterState<Service, EntityAccess, Authorization> {+ service: Arc<Service>,+ entity_access_service: Arc<EntityAccess>,+ authorization_state: MacroAuthorizationState<Authorization>,+}++impl<Service, EntityAccess, Authorization> Clone+ for DatabaseWebhooksRouterState<Service, EntityAccess, Authorization>+{+ fn clone(&self) -> Self {+ Self {+ service: self.service.clone(),+ entity_access_service: self.entity_access_service.clone(),+ authorization_state: self.authorization_state.clone(),+ }+ }+}++impl<Service, EntityAccess, Authorization>+ DatabaseWebhooksRouterState<Service, EntityAccess, Authorization>+{+ /// Router state from the webhooks service, entity access and+ /// authorization.+ pub fn new(+ service: Arc<Service>,+ entity_access_service: Arc<EntityAccess>,+ authorization_state: MacroAuthorizationState<Authorization>,+ ) -> Self {+ Self {+ service,+ entity_access_service,+ authorization_state,+ }+ }+}++impl<Service, EntityAccess, Authorization>+ FromRef<DatabaseWebhooksRouterState<Service, EntityAccess, Authorization>>+ for Arc<EntityAccess>+{+ fn from_ref(state: &DatabaseWebhooksRouterState<Service, EntityAccess, Authorization>) -> Self {+ state.entity_access_service.clone()+ }+}++impl<Service, EntityAccess, Authorization>+ FromRef<DatabaseWebhooksRouterState<Service, EntityAccess, Authorization>>+ for MacroAuthorizationState<Authorization>+{+ fn from_ref(state: &DatabaseWebhooksRouterState<Service, EntityAccess, Authorization>) -> Self {+ state.authorization_state.clone()+ }+}++/// Build the webhooks router, merged into the one mounted at `/databases`.+pub fn database_webhooks_router<Service, EntityAccess, Authorization, RouterState>(+ state: DatabaseWebhooksRouterState<Service, EntityAccess, Authorization>,+) -> Router<RouterState>+where+ Service: DatabaseWebhooksService,+ EntityAccess: EntityAccessService,+ Authorization: MacroAuthorizationService,+ RouterState: Send + Sync + 'static,+{+ Router::new()+ // Static segments win over `/{id}`, so this never reads as a database.+ .route(+ "/webhooks/{token}",+ post(deliver_handler::<Service, EntityAccess, Authorization>),+ )+ .route(+ "/{id}/webhooks",+ post(create_webhook_handler::<Service, EntityAccess, Authorization>)+ .get(list_webhooks_handler::<Service, EntityAccess, Authorization>),+ )+ .route(+ "/{id}/webhooks/{webhook_id}",+ delete(delete_webhook_handler::<Service, EntityAccess, Authorization>),+ )+ .with_state(state)+}++/// A webhook of a database. Its token is never shown again after creation.+#[derive(Debug, Serialize, utoipa::ToSchema)]+#[serde(rename_all = "camelCase")]+pub struct DatabaseWebhookResponse {+ /// Identifier.+ pub id: Uuid,+ /// The database.+ #[schema(value_type = Uuid)]+ pub database_id: DatabaseId,+ /// The table its calls insert rows into.+ #[schema(value_type = Uuid)]+ pub table_id: TableId,+ /// Who created it; its calls write with their access.+ pub created_by: String,+ /// The token's first characters, to tell webhooks apart.+ pub token_prefix: String,+ /// Creation time.+ pub created_at: DateTime<Utc>,+}++impl From<DatabaseWebhook> for DatabaseWebhookResponse {+ fn from(webhook: DatabaseWebhook) -> Self {+ Self {+ id: webhook.id,+ database_id: webhook.database_id,+ table_id: webhook.table_id,+ created_by: webhook.created_by,+ token_prefix: webhook.token_prefix,+ created_at: webhook.created_at,+ }+ }+}++/// Which table a new webhook inserts rows into.+#[derive(Debug, Deserialize, utoipa::ToSchema)]+#[serde(rename_all = "camelCase")]+pub struct CreateDatabaseWebhookRequest {+ /// A table of the database.+ #[schema(value_type = Uuid)]+ pub table_id: TableId,+}++/// A new webhook, with the token its URL carries. The token is shown only+/// here.+#[derive(Debug, Serialize, utoipa::ToSchema)]+#[serde(rename_all = "camelCase")]+pub struct CreatedDatabaseWebhookResponse {+ /// The webhook.+ pub webhook: DatabaseWebhookResponse,+ /// The secret: `POST /databases/webhooks/{token}` inserts rows.+ pub token: String,+}++impl From<CreatedWebhook> for CreatedDatabaseWebhookResponse {+ fn from(created: CreatedWebhook) -> Self {+ Self {+ webhook: created.webhook.into(),+ token: created.token,+ }+ }+}++/// A database's webhooks.+#[derive(Debug, Serialize, utoipa::ToSchema)]+#[serde(rename_all = "camelCase")]+pub struct ListDatabaseWebhooksResponse {+ /// Oldest first.+ pub webhooks: Vec<DatabaseWebhookResponse>,+}++/// The rows a webhook call inserted.+#[derive(Debug, Serialize, utoipa::ToSchema)]+#[serde(rename_all = "camelCase")]+pub struct DatabaseWebhookDeliveryResponse {+ /// The database.+ #[schema(value_type = Uuid)]+ pub database_id: DatabaseId,+ /// The table.+ #[schema(value_type = Uuid)]+ pub table_id: TableId,+ /// The new rows, in the order the payload sent them.+ #[schema(value_type = Vec<Uuid>)]+ pub rows: Vec<RowId>,+}++impl From<Delivery> for DatabaseWebhookDeliveryResponse {+ fn from(delivery: Delivery) -> Self {+ Self {+ database_id: delivery.database_id,+ table_id: delivery.table_id,+ rows: delivery.rows,+ }+ }+}++/// One thing wrong with a webhook payload.+#[derive(Debug, Serialize, utoipa::ToSchema)]+#[serde(rename_all = "camelCase")]+pub struct DatabaseWebhookPayloadProblem {+ /// The row's index, when the payload is an array of rows.+ #[schema(required = true)]+ pub row: Option<usize>,+ /// The key at fault, when one is.+ #[schema(required = true)]+ pub field: Option<String>,+ /// What is wrong.+ pub message: String,+}++impl From<PayloadProblem> for DatabaseWebhookPayloadProblem {+ fn from(problem: PayloadProblem) -> Self {+ Self {+ row: problem.row,+ field: problem.field,+ message: problem.message,+ }+ }+}++/// Why a payload was refused. Nothing was written.+#[derive(Debug, Serialize, utoipa::ToSchema)]+#[serde(rename_all = "camelCase")]+pub struct InvalidDatabaseWebhookPayloadResponse {+ /// A summary.+ pub message: String,+ /// Every problem found.+ pub problems: Vec<DatabaseWebhookPayloadProblem>,+}++impl IntoResponse for DatabaseWebhookError {+ fn into_response(self) -> axum::response::Response {+ let (status, message) = match self {+ DatabaseWebhookError::InvalidPayload(problems) => {+ return (+ StatusCode::BAD_REQUEST,+ Json(InvalidDatabaseWebhookPayloadResponse {+ message: "the payload does not fit the table; nothing was written"+ .to_string(),+ problems: problems.into_iter().map(Into::into).collect(),+ }),+ )+ .into_response();+ }+ DatabaseWebhookError::Database(error) => return error.into_response(),+ DatabaseWebhookError::NotFound => (StatusCode::NOT_FOUND, "not found".to_string()),+ DatabaseWebhookError::Forbidden(reason) => (StatusCode::FORBIDDEN, reason.to_string()),+ DatabaseWebhookError::Repository(ref report) => {+ tracing::error!(error = ?report, "database webhooks internal server error");+ (+ StatusCode::INTERNAL_SERVER_ERROR,+ "internal server error".to_string(),+ )+ }+ };+ (+ status,+ Json(ErrorResponse {+ message: message.into(),+ }),+ )+ .into_response()+ }+}++/// Create a webhook: a secret URL whose calls insert rows into one of the+/// database's tables, writing with the creator's access.+#[utoipa::path(+ post,+ tag = "databases",+ operation_id = "create_database_webhook",+ path = "/databases/{id}/webhooks",+ params(("id" = Uuid, Path, description = "Database id")),+ request_body = CreateDatabaseWebhookRequest,+ responses(+ (status = 201, body = CreatedDatabaseWebhookResponse),+ (status = 401, description = "Missing or invalid credentials", body = ErrorResponse),+ (status = 403, description = "No edit access to the database", body = ErrorResponse),+ (status = 404, description = "No such table in the database", body = ErrorResponse),+ (status = 500, body = ErrorResponse),+ )+)]+#[tracing::instrument(err, skip_all)]+pub async fn create_webhook_handler<Service, EntityAccess, Authorization>(+ access: DatabaseAccessLevelExtractor<EditAccessLevel, EntityAccess, Authorization>,+ State(state): State<DatabaseWebhooksRouterState<Service, EntityAccess, Authorization>>,+ Json(request): Json<CreateDatabaseWebhookRequest>,+) -> Result<(StatusCode, Json<CreatedDatabaseWebhookResponse>), DatabaseWebhookError>+where+ Service: DatabaseWebhooksService,+ EntityAccess: EntityAccessService,+ Authorization: MacroAuthorizationService,+{+ let created = state+ .service+ .create_webhook(access.entity_access_receipt, request.table_id)+ .await?;+ Ok((StatusCode::CREATED, Json(created.into())))+}++/// The database's webhooks.+#[utoipa::path(+ get,+ tag = "databases",+ operation_id = "list_database_webhooks",+ path = "/databases/{id}/webhooks",+ params(("id" = Uuid, Path, description = "Database id")),+ responses(+ (status = 200, body = ListDatabaseWebhooksResponse),+ (status = 401, description = "Missing or invalid credentials", body = ErrorResponse),+ (status = 403, description = "No edit access to the database", body = ErrorResponse),+ (status = 500, body = ErrorResponse),+ )+)]+#[tracing::instrument(err, skip_all)]+pub async fn list_webhooks_handler<Service, EntityAccess, Authorization>(+ access: DatabaseAccessLevelExtractor<EditAccessLevel, EntityAccess, Authorization>,+ State(state): State<DatabaseWebhooksRouterState<Service, EntityAccess, Authorization>>,+) -> Result<Json<ListDatabaseWebhooksResponse>, DatabaseWebhookError>+where+ Service: DatabaseWebhooksService,+ EntityAccess: EntityAccessService,+ Authorization: MacroAuthorizationService,+{+ let webhooks = state+ .service+ .list_webhooks(access.entity_access_receipt)+ .await?;+ Ok(Json(ListDatabaseWebhooksResponse {+ webhooks: webhooks.into_iter().map(Into::into).collect(),+ }))+}++/// Delete a webhook; its URL stops working.+#[utoipa::path(+ delete,+ tag = "databases",+ operation_id = "delete_database_webhook",+ path = "/databases/{id}/webhooks/{webhook_id}",+ params(+ ("id" = Uuid, Path, description = "Database id"),+ ("webhook_id" = Uuid, Path, description = "Webhook id"),+ ),+ responses(+ (status = 204),+ (status = 401, description = "Missing or invalid credentials", body = ErrorResponse),+ (status = 403, description = "No edit access to the database", body = ErrorResponse),+ (status = 404, body = ErrorResponse),+ (status = 500, body = ErrorResponse),+ )+)]+#[tracing::instrument(err, skip_all)]+pub async fn delete_webhook_handler<Service, EntityAccess, Authorization>(+ access: DatabaseAccessLevelExtractor<EditAccessLevel, EntityAccess, Authorization>,+ State(state): State<DatabaseWebhooksRouterState<Service, EntityAccess, Authorization>>,+ Path(path): Path<(Uuid, WebhookId)>,+) -> Result<StatusCode, DatabaseWebhookError>+where+ Service: DatabaseWebhooksService,+ EntityAccess: EntityAccessService,+ Authorization: MacroAuthorizationService,+{+ state+ .service+ .delete_webhook(access.entity_access_receipt, path.1)+ .await?;+ Ok(StatusCode::NO_CONTENT)+}++/// Insert rows through a webhook. The body is a JSON object, one row, or+/// an array of up to 100 objects, one row each. Keys name columns by name+/// (ignoring case) or id; `null` leaves a cell empty. Values may be loose:+/// `"45"` for a number, `"true"` for a checkbox, a label or labels for a+/// select, `2026-10-09` for a date. Nothing is written unless every row fits.+#[utoipa::path(+ post,+ tag = "databases",+ operation_id = "deliver_database_webhook",+ path = "/databases/webhooks/{token}",+ params(("token" = String, Path, description = "The webhook's secret token")),+ request_body(content = serde_json::Value, description = "A row, or an array of rows"),+ responses(+ (status = 201, body = DatabaseWebhookDeliveryResponse),+ (status = 400, description = "The payload does not fit the table; nothing was written", body = InvalidDatabaseWebhookPayloadResponse),+ (status = 403, description = "The webhook's creator can no longer edit the database", body = ErrorResponse),+ (status = 404, description = "No such webhook", body = ErrorResponse),+ (status = 500, body = ErrorResponse),+ )+)]+#[tracing::instrument(err, skip_all)]+pub async fn deliver_handler<Service, EntityAccess, Authorization>(+ State(state): State<DatabaseWebhooksRouterState<Service, EntityAccess, Authorization>>,+ Path(token): Path<String>,+ body: Bytes,+) -> Result<(StatusCode, Json<DatabaseWebhookDeliveryResponse>), DatabaseWebhookError>+where+ Service: DatabaseWebhooksService,+{+ // Senders differ in the content type they claim, so any body that+ // parses as JSON is taken.+ let payload: serde_json::Value = serde_json::from_slice(&body).map_err(|error| {+ DatabaseWebhookError::InvalidPayload(vec![PayloadProblem {+ row: None,+ field: None,+ message: format!("the body is not JSON: {error}"),+ }])+ })?;+ let delivery = state.service.deliver(&token, &payload).await?;+ Ok((StatusCode::CREATED, Json(delivery.into())))+}++/// The webhooks endpoints and their schemas, for the host's OpenAPI+/// document.+#[derive(OpenApi)]+#[openapi(+ paths(+ create_webhook_handler,+ list_webhooks_handler,+ delete_webhook_handler,+ deliver_handler,+ ),+ components(schemas(+ CreateDatabaseWebhookRequest,+ CreatedDatabaseWebhookResponse,+ DatabaseWebhookResponse,+ ListDatabaseWebhooksResponse,+ DatabaseWebhookDeliveryResponse,+ InvalidDatabaseWebhookPayloadResponse,+ DatabaseWebhookPayloadProblem,+ ))+)]+pub struct DatabaseWebhooksApi;diff --git a/crates/database_webhooks/src/inbound/axum_router/test.rs b/crates/database_webhooks/src/inbound/axum_router/test.rsnew file mode 100644index 0000000000..6ee09fb486--- /dev/null+++ b/crates/database_webhooks/src/inbound/axum_router/test.rs@@ -0,0 +1,166 @@+use std::sync::Mutex;++use axum::body::to_bytes;+use axum::response::Response;+use serde_json::{Value, json};++use super::*;++const DATABASE: DatabaseId = DatabaseId::from_uuid(Uuid::from_u128(1));+const MEETINGS: TableId = TableId::from_uuid(Uuid::from_u128(10));++/// Answers deliveries by token, and keeps the payloads it was handed.+#[derive(Default)]+struct FakeService {+ payloads: Mutex<Vec<Value>>,+}++impl DatabaseWebhooksService for FakeService {+ async fn create_webhook(+ &self,+ _receipt: entity_access::domain::models::EntityAccessReceipt<EditAccessLevel>,+ _table_id: TableId,+ ) -> Result<CreatedWebhook, DatabaseWebhookError> {+ unimplemented!("not routed in these tests")+ }++ async fn list_webhooks(+ &self,+ _receipt: entity_access::domain::models::EntityAccessReceipt<EditAccessLevel>,+ ) -> Result<Vec<DatabaseWebhook>, DatabaseWebhookError> {+ unimplemented!("not routed in these tests")+ }++ async fn delete_webhook(+ &self,+ _receipt: entity_access::domain::models::EntityAccessReceipt<EditAccessLevel>,+ _webhook_id: WebhookId,+ ) -> Result<(), DatabaseWebhookError> {+ unimplemented!("not routed in these tests")+ }++ async fn deliver(+ &self,+ token: &str,+ payload: &Value,+ ) -> Result<Delivery, DatabaseWebhookError> {+ self.payloads.lock().unwrap().push(payload.clone());+ match token {+ "mdbw_good" => Ok(Delivery {+ database_id: DATABASE,+ table_id: MEETINGS,+ rows: vec![RowId::from_uuid(Uuid::from_u128(100))],+ }),+ "mdbw_unfit" => Err(DatabaseWebhookError::InvalidPayload(vec![PayloadProblem {+ row: Some(1),+ field: Some("Titel".to_string()),+ message: "no column is named \"Titel\"".to_string(),+ }])),+ "mdbw_orphaned" => Err(DatabaseWebhookError::Forbidden(+ "the webhook's creator can no longer edit this database",+ )),+ _ => Err(DatabaseWebhookError::NotFound),+ }+ }+}++async fn deliver(+ service: &Arc<FakeService>,+ token: &str,+ body: &'static str,+) -> (StatusCode, Value) {+ let state = DatabaseWebhooksRouterState::new(+ service.clone(),+ Arc::new(()),+ MacroAuthorizationState::new(Arc::new(())),+ );+ let response: Response = deliver_handler::<FakeService, (), ()>(+ State(state),+ Path(token.to_string()),+ Bytes::from(body),+ )+ .await+ .into_response();+ let status = response.status();+ let body = to_bytes(response.into_body(), usize::MAX).await.unwrap();+ (status, serde_json::from_slice(&body).unwrap())+}++#[tokio::test]+async fn a_delivery_answers_created_with_its_new_rows() {+ let service = Arc::new(FakeService::default());++ let answer = deliver(&service, "mdbw_good", r#"{"Title": "Acme kickoff"}"#).await;++ assert_eq!(+ answer,+ (+ StatusCode::CREATED,+ json!({+ "databaseId": "00000000-0000-0000-0000-000000000001",+ "tableId": "00000000-0000-0000-0000-00000000000a",+ "rows": ["00000000-0000-0000-0000-000000000064"],+ })+ )+ );+ assert_eq!(+ *service.payloads.lock().unwrap(),+ vec![json!({"Title": "Acme kickoff"})]+ );+}++#[tokio::test]+async fn an_unfit_payload_answers_every_problem() {+ let service = Arc::new(FakeService::default());++ let answer = deliver(&service, "mdbw_unfit", r#"[{}, {"Titel": "x"}]"#).await;++ assert_eq!(+ answer,+ (+ StatusCode::BAD_REQUEST,+ json!({+ "message": "the payload does not fit the table; nothing was written",+ "problems": [{+ "row": 1,+ "field": "Titel",+ "message": "no column is named \"Titel\"",+ }],+ })+ )+ );+}++#[tokio::test]+async fn a_body_that_is_not_json_is_refused_before_the_service() {+ let service = Arc::new(FakeService::default());++ let (status, body) = deliver(&service, "mdbw_good", "Title=Acme").await;++ assert_eq!(status, StatusCode::BAD_REQUEST);+ assert_eq!(body["problems"][0]["field"], Value::Null);+ assert!(+ body["problems"][0]["message"]+ .as_str()+ .unwrap()+ .starts_with("the body is not JSON")+ );+ assert!(service.payloads.lock().unwrap().is_empty());+}++#[tokio::test]+async fn an_unknown_or_orphaned_webhook_answers_its_status() {+ let service = Arc::new(FakeService::default());++ assert_eq!(+ deliver(&service, "mdbw_unknown", "{}").await,+ (StatusCode::NOT_FOUND, json!({ "message": "not found" }))+ );+ assert_eq!(+ deliver(&service, "mdbw_orphaned", "{}").await,+ (+ StatusCode::FORBIDDEN,+ json!({ "message": "the webhook's creator can no longer edit this database" })+ )+ );+}diff --git a/crates/database_webhooks/src/lib.rs b/crates/database_webhooks/src/lib.rsnew file mode 100644index 0000000000..e5ffcdb1b5--- /dev/null+++ b/crates/database_webhooks/src/lib.rs@@ -0,0 +1,17 @@+#![deny(missing_docs)]+// The end-to-end test's future, over the real databases service, is deep.+#![cfg_attr(test, recursion_limit = "256")]+//! Incoming webhooks for Macro databases: a secret URL that inserts rows into+//! one table. A POSTed JSON object names cells by column; the domain turns it+//! into the same row insert the grid sends, through the databases service.++pub mod domain;++#[cfg(feature = "inbound")]+pub mod inbound;++#[cfg(feature = "postgres")]+pub mod outbound;++#[cfg(feature = "postgres")]+pub mod wiring;diff --git a/crates/database_webhooks/src/outbound.rs b/crates/database_webhooks/src/outbound.rsnew file mode 100644index 0000000000..3f98e7742b--- /dev/null+++ b/crates/database_webhooks/src/outbound.rs@@ -0,0 +1,6 @@+//! Driven adapters: Postgres for webhooks, the databases service for their+//! tables, and entity access for their creators' grants.++pub mod databases_tables;+pub mod entity_access_creators;+pub mod pg_webhooks_repo;diff --git a/crates/database_webhooks/src/outbound/databases_tables.rs b/crates/database_webhooks/src/outbound/databases_tables.rsnew file mode 100644index 0000000000..aac06ab6b5--- /dev/null+++ b/crates/database_webhooks/src/outbound/databases_tables.rs@@ -0,0 +1,107 @@+//! A webhook's table through the databases domain service, so its inserts+//! keep that service's validation, journal and events.++use std::sync::Arc;++use databases::domain::catalog::column_kind;+use databases::domain::models::{DatabaseError, OpBatch, Viewer};+use databases::domain::ports::DatabasesService;+use entity_access::domain::models::{+ EditAccessLevel, EntityAccessReceipt, EntityType, ViewAccessLevel,+};+use models_databases::{+ CellWrite, DatabaseId, DatabaseOp, OpResult, RowId, RowsChange, RowsResult, TableId,+};++use crate::domain::mapping::WebhookColumn;+use crate::domain::ports::WebhookTables;++/// [`WebhookTables`] over the databases service.+#[derive(Debug)]+pub struct DatabasesServiceTables<Databases> {+ databases: Arc<Databases>,+}++impl<Databases> Clone for DatabasesServiceTables<Databases> {+ fn clone(&self) -> Self {+ Self {+ databases: self.databases.clone(),+ }+ }+}++impl<Databases> DatabasesServiceTables<Databases> {+ /// Tables of the databases `databases` keeps.+ pub fn new(databases: Arc<Databases>) -> Self {+ Self { databases }+ }+}++impl<Databases: DatabasesService> WebhookTables for DatabasesServiceTables<Databases> {+ async fn table_columns(+ &self,+ database_id: DatabaseId,+ table_id: TableId,+ ) -> Result<Option<Vec<WebhookColumn>>, DatabaseError> {+ // The webhooks service has already decided the caller may use this+ // database; it reads the schema to shape a payload.+ let detail = match self+ .databases+ .get_database(+ EntityAccessReceipt::<ViewAccessLevel>::dangerously_assert_internal_user(+ &database_id.to_string(),+ EntityType::Database,+ ),+ )+ .await+ {+ Ok(detail) => detail,+ Err(DatabaseError::NotFound) => return Ok(None),+ Err(error) => return Err(error),+ };+ Ok(detail+ .tables+ .into_iter()+ .find(|table| table.table.id == table_id)+ .map(|table| {+ table+ .columns+ .iter()+ .map(|column| WebhookColumn {+ id: column.column.id,+ name: column.name().to_string(),+ kind: column_kind(&column.column, &column.definition),+ })+ .collect()+ }))+ }++ async fn insert_rows(+ &self,+ receipt: EntityAccessReceipt<EditAccessLevel>,+ viewer: Viewer,+ table_id: TableId,+ rows: Vec<Vec<CellWrite>>,+ ) -> Result<Vec<RowId>, DatabaseError> {+ let results = self+ .databases+ .apply_ops(+ receipt,+ viewer,+ OpBatch::from(vec![DatabaseOp::Rows {+ table: table_id,+ change: RowsChange::Insert { rows },+ }]),+ )+ .await?;+ match results.into_iter().next() {+ Some(OpResult::Rows {+ change: RowsResult::Inserted { rows },+ ..+ }) => Ok(rows),+ other => Err(DatabaseError::Repo(rootcause::report!(+ "a row insert answered {other:?}"+ ))),+ }+ }+}diff --git a/crates/database_webhooks/src/outbound/entity_access_creators.rs b/crates/database_webhooks/src/outbound/entity_access_creators.rsnew file mode 100644index 0000000000..db6796803d--- /dev/null+++ b/crates/database_webhooks/src/outbound/entity_access_creators.rs@@ -0,0 +1,62 @@+//! A webhook creator's current grant, asked of entity access on every call.++use std::sync::Arc;++use entity_access::domain::models::{+ AccessError, EditAccessLevel, EntityAccessReceipt, EntityType,+};+use entity_access::domain::ports::EntityAccessService;+use macro_user_id::user_id::MacroUserIdStr;+use models_databases::DatabaseId;++use crate::domain::ports::CreatorAccess;++/// [`CreatorAccess`] through entity access.+#[derive(Debug)]+pub struct EntityAccessCreators<EntityAccess> {+ entity_access: Arc<EntityAccess>,+}++impl<EntityAccess> Clone for EntityAccessCreators<EntityAccess> {+ fn clone(&self) -> Self {+ Self {+ entity_access: self.entity_access.clone(),+ }+ }+}++impl<EntityAccess> EntityAccessCreators<EntityAccess> {+ /// Creators' grants as `entity_access` reads them.+ pub fn new(entity_access: Arc<EntityAccess>) -> Self {+ Self { entity_access }+ }+}++impl<EntityAccess: EntityAccessService> CreatorAccess for EntityAccessCreators<EntityAccess> {+ async fn edit_receipt(+ &self,+ user_id: &MacroUserIdStr<'static>,+ database_id: DatabaseId,+ ) -> Result<Option<EntityAccessReceipt<EditAccessLevel>>, rootcause::Report> {+ match self+ .entity_access+ .generate_entity_access_receipt::<EditAccessLevel>(+ user_id,+ None,+ &database_id.to_string(),+ EntityType::Database,+ )+ .await+ {+ Ok(receipt) => Ok(Some(receipt)),+ Err(+ AccessError::Unauthorized+ | AccessError::UnauthorizedWithMessage(_)+ | AccessError::NotFound(_),+ ) => Ok(None),+ Err(error) => Err(rootcause::report!(+ "checking the webhook creator's access: {error}"+ )),+ }+ }+}diff --git a/crates/database_webhooks/src/outbound/pg_webhooks_repo.rs b/crates/database_webhooks/src/outbound/pg_webhooks_repo.rsnew file mode 100644index 0000000000..c135c831d4--- /dev/null+++ b/crates/database_webhooks/src/outbound/pg_webhooks_repo.rs@@ -0,0 +1,129 @@+//! Webhooks in Postgres, `database_webhooks`.++#[cfg(test)]+mod test;++use chrono::{DateTime, Utc};+use models_databases::{DatabaseId, TableId};+use sqlx::PgPool;+use uuid::Uuid;++use crate::domain::models::{DatabaseWebhook, NewWebhook, WebhookId};+use crate::domain::ports::DatabaseWebhooksRepo;++/// [`DatabaseWebhooksRepo`] over MacroDB.+#[derive(Debug, Clone)]+pub struct PgWebhooksRepo {+ pool: PgPool,+}++impl PgWebhooksRepo {+ /// Webhooks kept in `pool`.+ pub fn new(pool: PgPool) -> Self {+ Self { pool }+ }+}++struct WebhookRow {+ id: Uuid,+ database_id: Uuid,+ table_id: Uuid,+ created_by: String,+ token_prefix: String,+ created_at: DateTime<Utc>,+}++impl From<WebhookRow> for DatabaseWebhook {+ fn from(row: WebhookRow) -> Self {+ Self {+ id: row.id,+ database_id: DatabaseId::from_uuid(row.database_id),+ table_id: TableId::from_uuid(row.table_id),+ created_by: row.created_by,+ token_prefix: row.token_prefix,+ created_at: row.created_at,+ }+ }+}++impl DatabaseWebhooksRepo for PgWebhooksRepo {+ #[tracing::instrument(skip_all, err)]+ async fn insert_webhook(+ &self,+ webhook: NewWebhook,+ ) -> Result<DatabaseWebhook, rootcause::Report> {+ let row = sqlx::query_as!(+ WebhookRow,+ r#"+ INSERT INTO database_webhooks+ (id, database_id, table_id, created_by, token_hash, token_prefix)+ VALUES ($1, $2, $3, $4, $5, $6)+ RETURNING id, database_id, table_id, created_by, token_prefix, created_at+ "#,+ webhook.id,+ webhook.database_id.as_uuid(),+ webhook.table_id.as_uuid(),+ webhook.created_by,+ &webhook.token_hash[..],+ webhook.token_prefix,+ )+ .fetch_one(&self.pool)+ .await?;+ Ok(row.into())+ }++ #[tracing::instrument(skip(self), err)]+ async fn database_webhooks(+ &self,+ database_id: DatabaseId,+ ) -> Result<Vec<DatabaseWebhook>, rootcause::Report> {+ let rows = sqlx::query_as!(+ WebhookRow,+ r#"+ SELECT id, database_id, table_id, created_by, token_prefix, created_at+ FROM database_webhooks+ WHERE database_id = $1+ ORDER BY created_at, id+ "#,+ database_id.as_uuid(),+ )+ .fetch_all(&self.pool)+ .await?;+ Ok(rows.into_iter().map(Into::into).collect())+ }++ #[tracing::instrument(skip(self), err)]+ async fn delete_webhook(+ &self,+ database_id: DatabaseId,+ webhook_id: WebhookId,+ ) -> Result<bool, rootcause::Report> {+ let deleted = sqlx::query!(+ "DELETE FROM database_webhooks WHERE id = $1 AND database_id = $2",+ webhook_id,+ database_id.as_uuid(),+ )+ .execute(&self.pool)+ .await?;+ Ok(deleted.rows_affected() > 0)+ }++ #[tracing::instrument(skip_all, err)]+ async fn webhook_by_token_hash(+ &self,+ token_hash: [u8; 32],+ ) -> Result<Option<DatabaseWebhook>, rootcause::Report> {+ let row = sqlx::query_as!(+ WebhookRow,+ r#"+ SELECT id, database_id, table_id, created_by, token_prefix, created_at+ FROM database_webhooks+ WHERE token_hash = $1+ "#,+ &token_hash[..],+ )+ .fetch_optional(&self.pool)+ .await?;+ Ok(row.map(Into::into))+ }+}diff --git a/crates/database_webhooks/src/outbound/pg_webhooks_repo/test.rs b/crates/database_webhooks/src/outbound/pg_webhooks_repo/test.rsnew file mode 100644index 0000000000..608eb5c101--- /dev/null+++ b/crates/database_webhooks/src/outbound/pg_webhooks_repo/test.rs@@ -0,0 +1,165 @@+use macro_db_migrator::MACRO_DB_MIGRATIONS;++use super::*;++const ALICE: &str = "macro|[email protected]";++async fn insert_user(pool: &PgPool, user_id: &str) {+ let email = user_id.trim_start_matches("macro|");+ let macro_user_id = Uuid::now_v7();+ sqlx::query!(+ r#"INSERT INTO macro_user (id, username, email, stripe_customer_id) VALUES ($1, $2, $2, $3)"#,+ macro_user_id,+ email,+ format!("cus_{macro_user_id}"),+ )+ .execute(pool)+ .await+ .unwrap();+ sqlx::query!(+ r#"INSERT INTO "User" (id, email, macro_user_id) VALUES ($1, $2, $3)"#,+ user_id,+ email,+ macro_user_id,+ )+ .execute(pool)+ .await+ .unwrap();+}++/// A database entity owned by Alice, with one table.+async fn insert_database(pool: &PgPool) -> (DatabaseId, TableId) {+ let database = Uuid::now_v7();+ sqlx::query!(+ r#"WITH storage AS (INSERT INTO databases (id) VALUES ($1) RETURNING id)+ INSERT INTO database_entities (database_id, name, user_id) SELECT id, 'Meetings', $2 FROM storage"#,+ database,+ ALICE,+ )+ .execute(pool)+ .await+ .unwrap();+ let table = Uuid::now_v7();+ sqlx::query!(+ r#"INSERT INTO database_tables (id, database_id, name, position) VALUES ($1, $2, 'Meetings', 'a0')"#,+ table,+ database,+ )+ .execute(pool)+ .await+ .unwrap();+ (DatabaseId::from_uuid(database), TableId::from_uuid(table))+}++fn new_webhook(database_id: DatabaseId, table_id: TableId, token: &str) -> NewWebhook {+ NewWebhook {+ id: Uuid::now_v7(),+ database_id,+ table_id,+ created_by: ALICE.to_string(),+ token_hash: crate::domain::token::hash(token),+ token_prefix: crate::domain::token::prefix(token),+ }+}++#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]+async fn a_webhook_is_found_by_its_token_hash_and_listed_with_its_database(pool: PgPool) {+ insert_user(&pool, ALICE).await;+ let (database, table) = insert_database(&pool).await;+ let (other_database, other_table) = insert_database(&pool).await;+ let repository = PgWebhooksRepo::new(pool);+ let token = "mdbw_0123456789ab_secret";+ let new = new_webhook(database, table, token);++ let stored = repository.insert_webhook(new.clone()).await.unwrap();+ repository+ .insert_webhook(new_webhook(other_database, other_table, "mdbw_other"))+ .await+ .unwrap();++ assert_eq!(+ stored,+ DatabaseWebhook {+ id: new.id,+ database_id: database,+ table_id: table,+ created_by: ALICE.to_string(),+ token_prefix: "mdbw_0123456789ab".to_string(),+ created_at: stored.created_at,+ }+ );+ assert_eq!(+ repository+ .webhook_by_token_hash(crate::domain::token::hash(token))+ .await+ .unwrap(),+ Some(stored.clone())+ );+ assert_eq!(+ repository+ .webhook_by_token_hash(crate::domain::token::hash("mdbw_unknown"))+ .await+ .unwrap(),+ None+ );+ assert_eq!(+ repository.database_webhooks(database).await.unwrap(),+ vec![stored]+ );+}++#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]+async fn a_webhook_is_deleted_only_through_its_own_database(pool: PgPool) {+ insert_user(&pool, ALICE).await;+ let (database, table) = insert_database(&pool).await;+ let (other_database, _) = insert_database(&pool).await;+ let repository = PgWebhooksRepo::new(pool);+ let webhook = repository+ .insert_webhook(new_webhook(database, table, "mdbw_delete"))+ .await+ .unwrap();++ assert!(+ !repository+ .delete_webhook(other_database, webhook.id)+ .await+ .unwrap()+ );+ assert!(+ repository+ .delete_webhook(database, webhook.id)+ .await+ .unwrap()+ );+ assert!(+ repository+ .database_webhooks(database)+ .await+ .unwrap()+ .is_empty()+ );+}++#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]+async fn a_webhook_goes_with_its_table(pool: PgPool) {+ insert_user(&pool, ALICE).await;+ let (database, table) = insert_database(&pool).await;+ let repository = PgWebhooksRepo::new(pool.clone());+ repository+ .insert_webhook(new_webhook(database, table, "mdbw_table"))+ .await+ .unwrap();++ sqlx::query!("DELETE FROM database_tables WHERE id = $1", table.as_uuid())+ .execute(&pool)+ .await+ .unwrap();++ assert!(+ repository+ .database_webhooks(database)+ .await+ .unwrap()+ .is_empty()+ );+}diff --git a/crates/database_webhooks/src/wiring.rs b/crates/database_webhooks/src/wiring.rsnew file mode 100644index 0000000000..95e07091b3--- /dev/null+++ b/crates/database_webhooks/src/wiring.rs@@ -0,0 +1,41 @@+//! The one assembly of the webhooks service, over the host's databases+//! service and entity access.++#[cfg(test)]+mod test;++use std::sync::Arc;++use databases::domain::ports::DatabasesService;+use entity_access::domain::ports::EntityAccessService;+use sqlx::PgPool;++use crate::domain::service::DatabaseWebhooksServiceImpl;+use crate::outbound::databases_tables::DatabasesServiceTables;+use crate::outbound::entity_access_creators::EntityAccessCreators;+use crate::outbound::pg_webhooks_repo::PgWebhooksRepo;++/// The service as every host builds it.+pub type PgDatabaseWebhooksService<Databases, EntityAccess> = DatabaseWebhooksServiceImpl<+ PgWebhooksRepo,+ DatabasesServiceTables<Databases>,+ EntityAccessCreators<EntityAccess>,+>;++/// Build the webhooks service over `pool`, the host's databases service, and+/// its entity access.+pub fn build_service<Databases, EntityAccess>(+ pool: PgPool,+ databases: Arc<Databases>,+ entity_access: Arc<EntityAccess>,+) -> PgDatabaseWebhooksService<Databases, EntityAccess>+where+ Databases: DatabasesService,+ EntityAccess: EntityAccessService,+{+ DatabaseWebhooksServiceImpl::new(+ PgWebhooksRepo::new(pool),+ DatabasesServiceTables::new(databases),+ EntityAccessCreators::new(entity_access),+ )+}diff --git a/crates/database_webhooks/src/wiring/test.rs b/crates/database_webhooks/src/wiring/test.rsnew file mode 100644index 0000000000..541046cf7b--- /dev/null+++ b/crates/database_webhooks/src/wiring/test.rs@@ -0,0 +1,150 @@+//! The service as hosts build it, over the real databases service and entity+//! access in Postgres: a webhook's call becomes a row a reader sees.++use databases::domain::models::{CreateDatabase, TableId};+use databases::domain::ports::{DatabaseRowReads, DatabasesService};+use entity_access::domain::models::{EntityAccessReceipt, EntityType, ViewAccessLevel};+use entity_access::domain::service::EntityAccessServiceImpl;+use entity_access::outbound::PgAccessRepository;+use macro_db_migrator::MACRO_DB_MIGRATIONS;+use macro_event_broker::domain::service::NoopMacroEventBroker;+use macro_user_id::user_id::MacroUserIdStr;+use models_databases::{CellValue, CellWrite, DatabaseId, RowId};+use serde_json::json;++use super::*;+use crate::domain::models::{DatabaseWebhookError, PayloadProblem};+use crate::domain::ports::DatabaseWebhooksService;++/// Table events no one listens to.+struct Unheard;++impl databases::domain::ports::TableEventPublisher for Unheard {+ type Error = std::convert::Infallible;++ async fn database_changed(&self, _: DatabaseId) -> Result<(), Self::Error> {+ Ok(())+ }++ async fn table_changed(+ &self,+ _: DatabaseId,+ _: TableId,+ _: databases::domain::models::TableVersion,+ ) -> Result<(), Self::Error> {+ Ok(())+ }++ async fn awareness(+ &self,+ _: DatabaseId,+ _: &MacroUserIdStr<'_>,+ _: &databases::domain::models::Awareness,+ ) -> Result<(), Self::Error> {+ Ok(())+ }+}++/// A user id no other test in this process shares: entity access caches+/// answers process-wide.+fn unique_user() -> MacroUserIdStr<'static> {+ MacroUserIdStr::try_from(format!("macro|webhooks-{}@macro.com", uuid::Uuid::new_v4())).unwrap()+}++async fn insert_user(pool: &PgPool, user_id: &str) {+ let macro_user_id = macro_uuid::generate_uuid_v7();+ sqlx::query!(+ r#"INSERT INTO macro_user (id, username, email, stripe_customer_id) VALUES ($1, $2, $2, $2)"#,+ macro_user_id,+ user_id,+ )+ .execute(pool)+ .await+ .unwrap();+ sqlx::query!(+ r#"INSERT INTO "User" (id, email, macro_user_id) VALUES ($1, $1, $2)"#,+ user_id,+ macro_user_id,+ )+ .execute(pool)+ .await+ .unwrap();+}++#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]+async fn a_webhook_call_inserts_a_row_the_owner_reads(pool: PgPool) {+ let owner = unique_user();+ insert_user(&pool, owner.as_ref()).await;+ let entity_access = Arc::new(EntityAccessServiceImpl::new(PgAccessRepository::new(+ pool.clone(),+ )));+ let databases = Arc::new(databases::wiring::build_service(+ pool.clone(),+ entity_access.clone(),+ Unheard,+ NoopMacroEventBroker,+ ));+ let webhooks = build_service(pool.clone(), databases.clone(), entity_access);+ let database = databases+ .create_database(CreateDatabase {+ name: "Meetings".to_string(),+ owner_id: owner.clone(),+ acting_bot: None,+ })+ .await+ .unwrap();+ let view = || {+ EntityAccessReceipt::<ViewAccessLevel>::dangerously_assert_internal_user(+ &database.id.to_string(),+ EntityType::Database,+ )+ };+ let detail = databases.get_database(view()).await.unwrap();+ let table = &detail.tables[0];+ let name = &table.columns[0];+ assert_eq!(name.name(), "Name");++ let created = webhooks+ .create_webhook(+ EntityAccessReceipt::dangerously_assert_authenticated_user(+ owner.clone(),+ &database.id.to_string(),+ EntityType::Database,+ ),+ table.table.id,+ )+ .await+ .unwrap();+ let delivery = webhooks+ .deliver(&created.token, &json!({ "name": "Acme kickoff" }))+ .await+ .unwrap();+ let refused = webhooks+ .deliver(&created.token, &json!({ "Nmae": "typo" }))+ .await;++ let [row]: [RowId; 1] = delivery.rows.clone().try_into().unwrap();+ assert_eq!(+ databases+ .cells_of_rows(view(), table.table.id, &[row])+ .await+ .unwrap()+ .remove(&row),+ Some(vec![CellWrite {+ column: name.column.id,+ value: CellValue::Text("Acme kickoff".to_string()),+ }])+ );+ assert!(matches!(+ refused,+ Err(DatabaseWebhookError::InvalidPayload(problems)) if problems == vec![PayloadProblem {+ row: None,+ field: Some("Nmae".to_string()),+ message: "no column is named \"Nmae\"".to_string(),+ }]+ ));+ assert_eq!(+ databases.row_count(view(), table.table.id).await.unwrap(),+ 1+ );+}diff --git a/crates/macro_db_client/migrations/20261014153433_database_webhooks.down.sql b/crates/macro_db_client/migrations/20261014153433_database_webhooks.down.sqlnew file mode 100644index 0000000000..b1303ac9db--- /dev/null+++ b/crates/macro_db_client/migrations/20261014153433_database_webhooks.down.sql@@ -0,0 +1 @@+DROP TABLE database_webhooks;diff --git a/crates/macro_db_client/migrations/20261014153433_database_webhooks.up.sql b/crates/macro_db_client/migrations/20261014153433_database_webhooks.up.sqlnew file mode 100644index 0000000000..2caa0204a7--- /dev/null+++ b/crates/macro_db_client/migrations/20261014153433_database_webhooks.up.sql@@ -0,0 +1,18 @@+-- Incoming webhooks: a secret URL that inserts rows into one table of a+-- Macro database. Only the token's SHA-256 is kept; the raw token is shown+-- once, when the webhook is created. A webhook goes with its table, its+-- database entity, and the user who created it, whose access its writes use.+CREATE TABLE database_webhooks (+ id UUID PRIMARY KEY,+ database_id UUID NOT NULL REFERENCES database_entities(database_id) ON DELETE CASCADE,+ table_id UUID NOT NULL REFERENCES database_tables(id) ON DELETE CASCADE,+ created_by TEXT NOT NULL REFERENCES "User"(id) ON DELETE CASCADE ON UPDATE CASCADE,+ token_hash BYTEA NOT NULL UNIQUE,+ -- The token's first characters, so a list can tell webhooks apart+ -- without holding the secret.+ token_prefix TEXT NOT NULL,+ created_at TIMESTAMPTZ NOT NULL DEFAULT now()+);++CREATE INDEX database_webhooks_database_id_idx ON database_webhooks(database_id);+CREATE INDEX database_webhooks_table_id_idx ON database_webhooks(table_id);diff --git a/docs/AGENT_GUIDE/databases.md b/docs/AGENT_GUIDE/databases.mdindex c9d41d69bf..a40633681a 100644--- a/docs/AGENT_GUIDE/databases.md+++ b/docs/AGENT_GUIDE/databases.md@@ -546,7 +546,7 @@ link. **Share** and viewer avatars (other people currently looking at thedatabase) sit at the right of the split header, like other entities.The toolbar's **Database actions** (`…`) menu, beside **AI**, contains **Rename**,-**Import CSV**, **Download**, and owner-only **Delete**. Rename focuses the inline+**Import CSV**, **Webhooks**, **Download**, and owner-only **Delete**. Rename focuses the inlinetitle in the split header; Delete opens the standard confirmation dialog.**Download** offers **Current table as CSV**.Exports contain all records, regardless of the current filters. CSV uses column@@ -561,6 +561,15 @@ type menu afterward to convert it. The limit is 8 MB, 100 columns, and 10,000 roA failed response offers **Retry import** with the same request, so retrying acompleted import does not create a second table.+**Webhooks** (editors only) opens a dialog for the current table. **Create+webhook** shows its URL once, with a copy button and a `curl` example built from+the table's columns; the list below shows each webhook's token prefix and a+delete button. POSTing a JSON object to the URL inserts one row (an array inserts+one per object, up to 100). Keys name columns, ignoring case; `null` leaves a+cell empty; unknown keys or values that do not fit refuse the whole call with a+400 listing every problem. The row is written as the webhook's creator, and the+webhook stops working if they lose edit access.+## Side panel and activityThe split header's `Show Side Panel` toggle (or `]`) opens the shared floating details panel,diff --git a/packages/sdk/generated/storage/index.ts b/packages/sdk/generated/storage/index.tsindex f7f15d0dcb..8d64b3834f 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 { AccessiblePipeline, AccessLevel, 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, AgentMcpServer, AgentMcpServers, AgentPullRequestState, AgentSessionFilters, AgentSessionLifecycleEvent, Anchor, AnchorId, AnchorResponse, AnnotationIncrementalUpdate, Answer, ApiActivity, ApiAttachmentChannelReference, 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, BomPart, BookingTarget, Bot, BotChannel, BotChannelType, BotId, BotKind, BotOwner, BotOwnerProfile, BotSenderProfile, BotToken, BranchNameResponse, BTreeMap, BulkWakeupRequest, BulkWakeupResponse, BulkWakeupSyncServiceDocumentsData, BulkWakeupSyncServiceDocumentsErrors, BulkWakeupSyncServiceDocumentsResponse, BulkWakeupSyncServiceDocumentsResponses, CalendarAttendee, CalendarEvent, CalendarEventFilters, CalendarEventSourceContent, CalendarMentionEvent, CalendarMentionPreviewItem, CalendarMentionPreviewKind, CalendarMentionPreviewRequest, CalendarMentionPreviewRequestItem, CalendarMentionPreviewResponse, CalendarOccurrence, CalendarOccurrenceItem, CalendarOccurrenceResponse, CalendarSyncStatus, CallActiveResponse, CallFilters, CallRecord, CallRecordGuest, CallRecordParticipant, CallRecordPreview, CallRecordPreviewData, 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, 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, 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, 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, CreateDatabaseData, CreateDatabaseError, CreateDatabaseErrors, CreateDatabaseRequest, CreateDatabaseResponse, CreateDatabaseResponses, 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, CrmCompanyFilters, CrmCompanyResponse, CrmContactResponse, CrmDomainResponse, CrmPermissionRole, CrmStageInput, CrmStageResponse, CrmStagesResponse, CrmTeamSettingsResponse, CustomSpeakerAssignment, Database, DatabaseDetail, DatabaseOp, DatabaseView, DataType, DateOperator, 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, 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, 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, DocumentTopicEvent, DocumentUpdatedMetadata, 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, 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, EventReminderOverride, EventReminders, EventStatus, EventTime, EventTransparency, EventType, EventVisibility, ExcludedDefaultView, ExcludeDefaultViewHandlerData, ExcludeDefaultViewHandlerError, ExcludeDefaultViewHandlerErrors, ExcludeDefaultViewHandlerResponses, ExcludeDefaultViewRequest, ExportDocumentData, ExportDocumentError, ExportDocumentErrors, ExportDocumentResponse, ExportDocumentResponse2, ExportDocumentResponses, Favorite, FavoriteEntityRef, FavoritesList, FileChangeKindDto, FileSystemNodeWithIds, FileType, FileTypeUpdate, FilterCondition, FilterGroup, FilterNode, FilterTest, FinalizeSlackImportData, FinalizeSlackImportErrors, FinalizeSlackImportResponse, FinalizeSlackImportResponses, FolderItem, FollowupState, ForeignEntity, ForeignEntityFilters, Form, FormAccess, 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, GetCrmPipelineResponse, GetCrmPipelineResponses, GetCrmPipelineRowsData, GetCrmPipelineRowsResponse, GetCrmPipelineRowsResponses, GetCrmPipelineTableData, GetCrmPipelineTableResponse, GetCrmPipelineTableResponses, 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, 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, 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, GuestId, GuestJoinRequest, 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, 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, ListCrmPipelinesData, ListCrmPipelinesResponse, ListCrmPipelinesResponses, ListDatabaseColumnCastsData, ListDatabaseColumnCastsError, ListDatabaseColumnCastsErrors, ListDatabaseColumnCastsResponse, ListDatabaseColumnCastsResponses, ListDatabasesData, ListDatabasesError, ListDatabasesErrors, ListDatabasesResponse, ListDatabasesResponses, 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, 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, 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, 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, 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, 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, RequestedHarnessScope, RequestedLayout, ResetCrmTeamStagesData, ResetCrmTeamStagesError, ResetCrmTeamStagesErrors, ResetCrmTeamStagesResponse, ResetCrmTeamStagesResponses, ResponseStatus, ResponseSummary, 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, 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, SetDocumentTeamShareData, SetDocumentTeamShareError, SetDocumentTeamShareErrors, SetDocumentTeamShareRequest, SetDocumentTeamShareResponse, SetDocumentTeamShareResponses, SetEmailFollowupData, SetEmailFollowupError, SetEmailFollowupErrors, SetEmailFollowupResponse, SetEmailFollowupResponses, SetEmailSyncData, SetEmailSyncError, SetEmailSyncErrors, SetEmailSyncRequest, SetEmailSyncResponse, SetEmailSyncResponses, SetOperator, SetPropertyValue, Sha256Digest, ShareCrmPipelineData, ShareCrmPipelineResponse, ShareCrmPipelineResponses, ShareDatabaseAwarenessData, ShareDatabaseAwarenessError, ShareDatabaseAwarenessErrors, ShareDatabaseAwarenessResponse, ShareDatabaseAwarenessResponses, SharedEmailFilter, SharePermissionV2, SharePipeline, ShortIdResponse, SimpleMention, SimpleSaveData, SimpleSaveError, SimpleSaveErrors, SimpleSaveResponse, SimpleSaveResponses, 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, 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, TableResult, TableVersion, TagFilterMode, TakenId, TallyBucket, TallyValue, TaskFilters, 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, UndoChangeResponse, UndoDatabaseChangeData, UndoDatabaseChangeError, UndoDatabaseChangeErrors, UndoDatabaseChangeResponse, UndoDatabaseChangeResponses, UndoOutcome, UndoRefusal, UnlockedBooking, UpdateAgentData, UpdateAgentError, UpdateAgentErrors, UpdateAgentRequest, UpdateAgentResponse, UpdateAgentResponses, UpdateChannelSharePermission, 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, ViewLayout, ViewPatch, ViewPosition, ViewPositionsResponse, ViewQuery, ViewResult, ViewsResponse, WaitingForInputMetadata, Webhook, WebhookEvent, WebhookFilter, WebhookScope, WebhookStatus, WebhookValidationTestEvent, Widget, WithCallId, WithChannelId, WithDocumentId, WithProjectId } from './types.gen';+export type { AccessiblePipeline, AccessLevel, 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, AgentMcpServer, AgentMcpServers, AgentPullRequestState, AgentSessionFilters, AgentSessionLifecycleEvent, Anchor, AnchorId, AnchorResponse, AnnotationIncrementalUpdate, Answer, ApiActivity, ApiAttachmentChannelReference, 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, BomPart, BookingTarget, Bot, BotChannel, BotChannelType, BotId, BotKind, BotOwner, BotOwnerProfile, BotSenderProfile, BotToken, BranchNameResponse, BTreeMap, BulkWakeupRequest, BulkWakeupResponse, BulkWakeupSyncServiceDocumentsData, BulkWakeupSyncServiceDocumentsErrors, BulkWakeupSyncServiceDocumentsResponse, BulkWakeupSyncServiceDocumentsResponses, CalendarAttendee, CalendarEvent, CalendarEventFilters, CalendarEventSourceContent, CalendarMentionEvent, CalendarMentionPreviewItem, CalendarMentionPreviewKind, CalendarMentionPreviewRequest, CalendarMentionPreviewRequestItem, CalendarMentionPreviewResponse, CalendarOccurrence, CalendarOccurrenceItem, CalendarOccurrenceResponse, CalendarSyncStatus, CallActiveResponse, CallFilters, CallRecord, CallRecordGuest, CallRecordParticipant, CallRecordPreview, CallRecordPreviewData, 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, 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, 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, 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, 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, CrmCompanyFilters, CrmCompanyResponse, CrmContactResponse, CrmDomainResponse, CrmPermissionRole, CrmStageInput, CrmStageResponse, CrmStagesResponse, CrmTeamSettingsResponse, CustomSpeakerAssignment, Database, DatabaseDetail, DatabaseOp, DatabaseView, DatabaseWebhookDeliveryResponse, DatabaseWebhookPayloadProblem, DatabaseWebhookResponse, DataType, DateOperator, 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, 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, DocumentTopicEvent, DocumentUpdatedMetadata, 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, 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, EventReminderOverride, EventReminders, EventStatus, EventTime, EventTransparency, EventType, EventVisibility, ExcludedDefaultView, ExcludeDefaultViewHandlerData, ExcludeDefaultViewHandlerError, ExcludeDefaultViewHandlerErrors, ExcludeDefaultViewHandlerResponses, ExcludeDefaultViewRequest, ExportDocumentData, ExportDocumentError, ExportDocumentErrors, ExportDocumentResponse, ExportDocumentResponse2, ExportDocumentResponses, Favorite, FavoriteEntityRef, FavoritesList, FileChangeKindDto, FileSystemNodeWithIds, FileType, FileTypeUpdate, FilterCondition, FilterGroup, FilterNode, FilterTest, FinalizeSlackImportData, FinalizeSlackImportErrors, FinalizeSlackImportResponse, FinalizeSlackImportResponses, FolderItem, FollowupState, ForeignEntity, ForeignEntityFilters, Form, FormAccess, 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, GetCrmPipelineResponse, GetCrmPipelineResponses, GetCrmPipelineRowsData, GetCrmPipelineRowsResponse, GetCrmPipelineRowsResponses, GetCrmPipelineTableData, GetCrmPipelineTableResponse, GetCrmPipelineTableResponses, 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, 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, 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, GuestId, GuestJoinRequest, 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, 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, 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, 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, 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, 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, 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, RequestedHarnessScope, RequestedLayout, ResetCrmTeamStagesData, ResetCrmTeamStagesError, ResetCrmTeamStagesErrors, ResetCrmTeamStagesResponse, ResetCrmTeamStagesResponses, ResponseStatus, ResponseSummary, 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, 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, SetDocumentTeamShareData, SetDocumentTeamShareError, SetDocumentTeamShareErrors, SetDocumentTeamShareRequest, SetDocumentTeamShareResponse, SetDocumentTeamShareResponses, SetEmailFollowupData, SetEmailFollowupError, SetEmailFollowupErrors, SetEmailFollowupResponse, SetEmailFollowupResponses, SetEmailSyncData, SetEmailSyncError, SetEmailSyncErrors, SetEmailSyncRequest, SetEmailSyncResponse, SetEmailSyncResponses, SetOperator, SetPropertyValue, Sha256Digest, ShareCrmPipelineData, ShareCrmPipelineResponse, ShareCrmPipelineResponses, ShareDatabaseAwarenessData, ShareDatabaseAwarenessError, ShareDatabaseAwarenessErrors, ShareDatabaseAwarenessResponse, ShareDatabaseAwarenessResponses, SharedEmailFilter, SharePermissionV2, SharePipeline, ShortIdResponse, SimpleMention, SimpleSaveData, SimpleSaveError, SimpleSaveErrors, SimpleSaveResponse, SimpleSaveResponses, 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, 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, TableResult, TableVersion, TagFilterMode, TakenId, TallyBucket, TallyValue, TaskFilters, 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, UndoChangeResponse, UndoDatabaseChangeData, UndoDatabaseChangeError, UndoDatabaseChangeErrors, UndoDatabaseChangeResponse, UndoDatabaseChangeResponses, UndoOutcome, UndoRefusal, UnlockedBooking, UpdateAgentData, UpdateAgentError, UpdateAgentErrors, UpdateAgentRequest, UpdateAgentResponse, UpdateAgentResponses, UpdateChannelSharePermission, 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, ViewLayout, ViewPatch, ViewPosition, ViewPositionsResponse, ViewQuery, ViewResult, ViewsResponse, WaitingForInputMetadata, Webhook, WebhookEvent, WebhookFilter, WebhookScope, WebhookStatus, WebhookValidationTestEvent, 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 5999a84448..74faadb44c 100644--- a/packages/sdk/generated/storage/sdk.gen.ts+++ b/packages/sdk/generated/storage/sdk.gen.ts@@ -2,7 +2,7 @@import type { Client, ClientMeta, Options as Options2, RequestResult, ServerSentEventsResult, TDataShape } from './client';import { client } from './client.gen';-import type { AddFavoriteData, AddFavoriteErrors, AddFavoriteResponses, AddParticipantsData, AddParticipantsErrors, AddParticipantsResponses, AddPinHandlerData, AddPinHandlerErrors, AddPinHandlerResponses, ApplyCrmPipelineOpsData, ApplyCrmPipelineOpsResponses, ApplyDatabaseOpsData, ApplyDatabaseOpsErrors, ApplyDatabaseOpsResponses, ApproveHarnessPairingData, ApproveHarnessPairingErrors, ApproveHarnessPairingResponses, 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, CreateChannelData, CreateChannelErrors, CreateChannelLabelData, CreateChannelLabelErrors, CreateChannelLabelResponses, CreateChannelResponses, CreateChannelScopedBotData, CreateChannelScopedBotErrors, CreateChannelScopedBotResponses, CreateCollabSurfaceTokenData, CreateCollabSurfaceTokenErrors, CreateCollabSurfaceTokenResponses, CreateCrmCompanyData, CreateCrmCompanyErrors, CreateCrmCompanyResponses, CreateCrmContactData, CreateCrmContactErrors, CreateCrmContactResponses, CreateCrmPipelineData, CreateCrmPipelineResponses, CreateDatabaseData, CreateDatabaseErrors, CreateDatabaseResponses, 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, 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, EditAnchorData, EditAnchorErrors, EditAnchorResponses, EditCallRecordData, EditCallRecordErrors, EditCallRecordResponses, EditCallTranscriptData, EditCallTranscriptErrors, EditCallTranscriptResponses, EditDocumentData, EditDocumentErrors, EditDocumentResponses, 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, ExcludeDefaultViewHandlerData, ExcludeDefaultViewHandlerErrors, ExcludeDefaultViewHandlerResponses, ExportDocumentData, ExportDocumentErrors, ExportDocumentResponses, 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, GetCrmPipelineResponses, GetCrmPipelineRowsData, GetCrmPipelineRowsResponses, GetCrmPipelineTableData, GetCrmPipelineTableResponses, 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, 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, GetSlackImportData, GetSlackImportErrors, GetSlackImportResponses, GetSystemSkillsHandlerData, GetSystemSkillsHandlerErrors, GetSystemSkillsHandlerResponses, GetUserDocumentsHandlerData, GetUserDocumentsHandlerErrors, GetUserDocumentsHandlerResponses, GetUserDocumentViewLocationData, GetUserDocumentViewLocationErrors, GetUserDocumentViewLocationResponses, GetViewsHandlerData, GetViewsHandlerErrors, GetViewsHandlerResponses, GetWebhookData, GetWebhookErrors, GetWebhookResponses, 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, ListCrmPipelinesData, ListCrmPipelinesResponses, ListDatabaseColumnCastsData, ListDatabaseColumnCastsErrors, ListDatabaseColumnCastsResponses, ListDatabasesData, ListDatabasesErrors, ListDatabasesResponses, ListEmailRemindersData, ListEmailRemindersErrors, ListEmailRemindersResponses, ListFavoritesData, ListFavoritesErrors, ListFavoritesResponses, ListFormsData, ListFormsErrors, ListFormsResponses, ListHarnessAgentsData, ListHarnessAgentsErrors, ListHarnessAgentsResponses, ListHarnessesData, ListHarnessesErrors, ListHarnessesResponses, ListHarnessSessionsData, ListHarnessSessionsErrors, ListHarnessSessionsResponses, ListInitiativesData, ListInitiativesErrors, ListInitiativesResponses, 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, 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, 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, ShareCrmPipelineData, ShareCrmPipelineResponses, ShareDatabaseAwarenessData, ShareDatabaseAwarenessErrors, ShareDatabaseAwarenessResponses, SimpleSaveData, SimpleSaveErrors, SimpleSaveResponses, StreamEventsData, StreamEventsErrors, StreamEventsResponse, StreamEventsResponses, SubmitFormResponseData, SubmitFormResponseErrors, SubmitFormResponseResponses, ToggleShareWithTeamData, ToggleShareWithTeamErrors, ToggleShareWithTeamResponses, TranscribeDictationData, TranscribeDictationErrors, TranscribeDictationResponses, TrashCrmPipelineData, TrashCrmPipelineResponses, UndoDatabaseChangeData, UndoDatabaseChangeErrors, UndoDatabaseChangeResponses, UpdateAgentData, UpdateAgentErrors, UpdateAgentResponses, 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 } from './types.gen';+import type { AddFavoriteData, AddFavoriteErrors, AddFavoriteResponses, AddParticipantsData, AddParticipantsErrors, AddParticipantsResponses, AddPinHandlerData, AddPinHandlerErrors, AddPinHandlerResponses, ApplyCrmPipelineOpsData, ApplyCrmPipelineOpsResponses, ApplyDatabaseOpsData, ApplyDatabaseOpsErrors, ApplyDatabaseOpsResponses, ApproveHarnessPairingData, ApproveHarnessPairingErrors, ApproveHarnessPairingResponses, 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, CreateChannelData, CreateChannelErrors, CreateChannelLabelData, CreateChannelLabelErrors, CreateChannelLabelResponses, CreateChannelResponses, CreateChannelScopedBotData, CreateChannelScopedBotErrors, CreateChannelScopedBotResponses, CreateCollabSurfaceTokenData, CreateCollabSurfaceTokenErrors, CreateCollabSurfaceTokenResponses, CreateCrmCompanyData, CreateCrmCompanyErrors, CreateCrmCompanyResponses, CreateCrmContactData, CreateCrmContactErrors, CreateCrmContactResponses, CreateCrmPipelineData, CreateCrmPipelineResponses, 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, EditAnchorData, EditAnchorErrors, EditAnchorResponses, EditCallRecordData, EditCallRecordErrors, EditCallRecordResponses, EditCallTranscriptData, EditCallTranscriptErrors, EditCallTranscriptResponses, EditDocumentData, EditDocumentErrors, EditDocumentResponses, 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, ExcludeDefaultViewHandlerData, ExcludeDefaultViewHandlerErrors, ExcludeDefaultViewHandlerResponses, ExportDocumentData, ExportDocumentErrors, ExportDocumentResponses, 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, GetCrmPipelineResponses, GetCrmPipelineRowsData, GetCrmPipelineRowsResponses, GetCrmPipelineTableData, GetCrmPipelineTableResponses, 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, 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, GetSlackImportData, GetSlackImportErrors, GetSlackImportResponses, GetSystemSkillsHandlerData, GetSystemSkillsHandlerErrors, GetSystemSkillsHandlerResponses, GetUserDocumentsHandlerData, GetUserDocumentsHandlerErrors, GetUserDocumentsHandlerResponses, GetUserDocumentViewLocationData, GetUserDocumentViewLocationErrors, GetUserDocumentViewLocationResponses, GetViewsHandlerData, GetViewsHandlerErrors, GetViewsHandlerResponses, GetWebhookData, GetWebhookErrors, GetWebhookResponses, 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, 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, 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, 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, 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, ShareCrmPipelineData, ShareCrmPipelineResponses, ShareDatabaseAwarenessData, ShareDatabaseAwarenessErrors, ShareDatabaseAwarenessResponses, SimpleSaveData, SimpleSaveErrors, SimpleSaveResponses, StreamEventsData, StreamEventsErrors, StreamEventsResponse, StreamEventsResponses, SubmitFormResponseData, SubmitFormResponseErrors, SubmitFormResponseResponses, ToggleShareWithTeamData, ToggleShareWithTeamErrors, ToggleShareWithTeamResponses, TranscribeDictationData, TranscribeDictationErrors, TranscribeDictationResponses, TrashCrmPipelineData, TrashCrmPipelineResponses, UndoDatabaseChangeData, UndoDatabaseChangeErrors, UndoDatabaseChangeResponses, UpdateAgentData, UpdateAgentErrors, UpdateAgentResponses, 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 } from './types.gen';export type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown> = Options2<TData, ThrowOnError, TResponse> & {/**@@ -1308,6 +1308,24 @@ export class Sdk extends HeyApiClient {return (options?.client ?? this.client).post<EnsureStarterHandlerResponses, EnsureStarterHandlerErrors, ThrowOnError>({ url: '/databases/starter', ...options });}+ /**+ * Insert rows through a webhook. The body is a JSON object, one row, or+ * an array of up to 100 objects, one row each. Keys name columns by name+ * (ignoring case) or id; `null` leaves a cell empty. Values may be loose:+ * `"45"` for a number, `"true"` for a checkbox, a label or labels for a+ * select, `2026-10-09` for a date. Nothing is written unless every row fits.+ */+ public deliverDatabaseWebhook<ThrowOnError extends boolean = false>(options: Options<DeliverDatabaseWebhookData, ThrowOnError>): RequestResult<DeliverDatabaseWebhookResponses, DeliverDatabaseWebhookErrors, ThrowOnError> {+ return (options.client ?? this.client).post<DeliverDatabaseWebhookResponses, DeliverDatabaseWebhookErrors, ThrowOnError>({+ url: '/databases/webhooks/{token}',+ ...options,+ headers: {+ 'Content-Type': 'application/json',+ ...options.headers+ }+ });+ }+/*** Schema detail of one database.*/@@ -1469,6 +1487,35 @@ export class Sdk extends HeyApiClient {return (options.client ?? this.client).get<GetDatabaseViewPositionsResponses, GetDatabaseViewPositionsErrors, ThrowOnError>({ url: '/databases/{id}/views/{view_id}/positions', ...options });}+ /**+ * The database's webhooks.+ */+ public listDatabaseWebhooks<ThrowOnError extends boolean = false>(options: Options<ListDatabaseWebhooksData, ThrowOnError>): RequestResult<ListDatabaseWebhooksResponses, ListDatabaseWebhooksErrors, ThrowOnError> {+ return (options.client ?? this.client).get<ListDatabaseWebhooksResponses, ListDatabaseWebhooksErrors, ThrowOnError>({ url: '/databases/{id}/webhooks', ...options });+ }++ /**+ * Create a webhook: a secret URL whose calls insert rows into one of the+ * database's tables, writing with the creator's access.+ */+ public createDatabaseWebhook<ThrowOnError extends boolean = false>(options: Options<CreateDatabaseWebhookData, ThrowOnError>): RequestResult<CreateDatabaseWebhookResponses, CreateDatabaseWebhookErrors, ThrowOnError> {+ return (options.client ?? this.client).post<CreateDatabaseWebhookResponses, CreateDatabaseWebhookErrors, ThrowOnError>({+ url: '/databases/{id}/webhooks',+ ...options,+ headers: {+ 'Content-Type': 'application/json',+ ...options.headers+ }+ });+ }++ /**+ * Delete a webhook; its URL stops working.+ */+ public deleteDatabaseWebhook<ThrowOnError extends boolean = false>(options: Options<DeleteDatabaseWebhookData, ThrowOnError>): RequestResult<DeleteDatabaseWebhookResponses, DeleteDatabaseWebhookErrors, ThrowOnError> {+ return (options.client ?? this.client).delete<DeleteDatabaseWebhookResponses, DeleteDatabaseWebhookErrors, ThrowOnError>({ url: '/databases/{id}/webhooks/{webhook_id}', ...options });+ }+/*** Transcribe a transient recording with OpenAI Whisper.*diff --git a/packages/sdk/generated/storage/types.gen.ts b/packages/sdk/generated/storage/types.gen.tsindex f2d5ee43f6..641a5f0113 100644--- a/packages/sdk/generated/storage/types.gen.ts+++ b/packages/sdk/generated/storage/types.gen.ts@@ -3782,6 +3782,16 @@ export type CreateDatabaseRequest = {name: string;};+/**+ * Which table a new webhook inserts rows into.+ */+export type CreateDatabaseWebhookRequest = {+ /**+ * A table of the database.+ */+ tableId: string;+};+export type CreateDocumentRequest = {/*** The document id if the document is being branched.@@ -4355,6 +4365,21 @@ export type CreateWebhookResponse = {workspace_id: string;};+/**+ * A new webhook, with the token its URL carries. The token is shown only+ * here.+ */+export type CreatedDatabaseWebhookResponse = {+ /**+ * The secret: `POST /databases/webhooks/{token}` inserts rows.+ */+ token: string;+ /**+ * The webhook.+ */+ webhook: DatabaseWebhookResponse;+};+/*** A pairing the daemon created, including its claim credential.*@@ -4814,6 +4839,72 @@ export type DatabaseView = {updatedAt: string;};+/**+ * The rows a webhook call inserted.+ */+export type DatabaseWebhookDeliveryResponse = {+ /**+ * The database.+ */+ databaseId: string;+ /**+ * The new rows, in the order the payload sent them.+ */+ rows: Array<string>;+ /**+ * The table.+ */+ tableId: string;+};++/**+ * One thing wrong with a webhook payload.+ */+export type DatabaseWebhookPayloadProblem = {+ /**+ * The key at fault, when one is.+ */+ field: string | null;+ /**+ * What is wrong.+ */+ message: string;+ /**+ * The row's index, when the payload is an array of rows.+ */+ row: number | null;+};++/**+ * A webhook of a database. Its token is never shown again after creation.+ */+export type DatabaseWebhookResponse = {+ /**+ * Creation time.+ */+ createdAt: string;+ /**+ * Who created it; its calls write with their access.+ */+ createdBy: string;+ /**+ * The database.+ */+ databaseId: string;+ /**+ * Identifier.+ */+ id: string;+ /**+ * The table its calls insert rows into.+ */+ tableId: string;+ /**+ * The token's first characters, to tell webhooks apart.+ */+ tokenPrefix: string;+};+/*** How a date cell compares to a date-time.*/@@ -8209,6 +8300,20 @@ export type InputReceivedMetadata = {*/export type InteractionReason = 'edited' | 'first_join' | 'last_leave';+/**+ * Why a payload was refused. Nothing was written.+ */+export type InvalidDatabaseWebhookPayloadResponse = {+ /**+ * A summary.+ */+ message: string;+ /**+ * Every problem found.+ */+ problems: Array<DatabaseWebhookPayloadProblem>;+};+/*** A single email recipient for a call invitation.*/@@ -8363,6 +8468,16 @@ export type LeaveCallResponse = {*/export type LinkShare = 'PUBLIC' | 'TEAM';+/**+ * A database's webhooks.+ */+export type ListDatabaseWebhooksResponse = {+ /**+ * Oldest first.+ */+ webhooks: Array<DatabaseWebhookResponse>;+};+/*** Webhooks visible to the caller across their personal and team workspaces.*@@ -17478,6 +17593,45 @@ export type EnsureStarterHandlerResponses = {export type EnsureStarterHandlerResponse = EnsureStarterHandlerResponses[keyof EnsureStarterHandlerResponses];+export type DeliverDatabaseWebhookData = {+ /**+ * A row, or an array of rows+ */+ body: unknown;+ path: {+ /**+ * The webhook's secret token+ */+ token: string;+ };+ query?: never;+ url: '/databases/webhooks/{token}';+};++export type DeliverDatabaseWebhookErrors = {+ /**+ * The payload does not fit the table; nothing was written+ */+ 400: InvalidDatabaseWebhookPayloadResponse;+ /**+ * The webhook's creator can no longer edit the database+ */+ 403: ErrorResponse;+ /**+ * No such webhook+ */+ 404: ErrorResponse;+ 500: ErrorResponse;+};++export type DeliverDatabaseWebhookError = DeliverDatabaseWebhookErrors[keyof DeliverDatabaseWebhookErrors];++export type DeliverDatabaseWebhookResponses = {+ 201: DatabaseWebhookDeliveryResponse;+};++export type DeliverDatabaseWebhookResponse = DeliverDatabaseWebhookResponses[keyof DeliverDatabaseWebhookResponses];+export type GetDatabaseData = {body?: never;path: {@@ -17918,6 +18072,111 @@ export type GetDatabaseViewPositionsResponses = {export type GetDatabaseViewPositionsResponse = GetDatabaseViewPositionsResponses[keyof GetDatabaseViewPositionsResponses];+export type ListDatabaseWebhooksData = {+ body?: never;+ path: {+ /**+ * Database id+ */+ id: string;+ };+ query?: never;+ url: '/databases/{id}/webhooks';+};++export type ListDatabaseWebhooksErrors = {+ /**+ * Missing or invalid credentials+ */+ 401: ErrorResponse;+ /**+ * No edit access to the database+ */+ 403: ErrorResponse;+ 500: ErrorResponse;+};++export type ListDatabaseWebhooksError = ListDatabaseWebhooksErrors[keyof ListDatabaseWebhooksErrors];++export type ListDatabaseWebhooksResponses = {+ 200: ListDatabaseWebhooksResponse;+};++export type ListDatabaseWebhooksResponse2 = ListDatabaseWebhooksResponses[keyof ListDatabaseWebhooksResponses];++export type CreateDatabaseWebhookData = {+ body: CreateDatabaseWebhookRequest;+ path: {+ /**+ * Database id+ */+ id: string;+ };+ query?: never;+ url: '/databases/{id}/webhooks';+};++export type CreateDatabaseWebhookErrors = {+ /**+ * Missing or invalid credentials+ */+ 401: ErrorResponse;+ /**+ * No edit access to the database+ */+ 403: ErrorResponse;+ /**+ * No such table in the database+ */+ 404: ErrorResponse;+ 500: ErrorResponse;+};++export type CreateDatabaseWebhookError = CreateDatabaseWebhookErrors[keyof CreateDatabaseWebhookErrors];++export type CreateDatabaseWebhookResponses = {+ 201: CreatedDatabaseWebhookResponse;+};++export type CreateDatabaseWebhookResponse = CreateDatabaseWebhookResponses[keyof CreateDatabaseWebhookResponses];++export type DeleteDatabaseWebhookData = {+ body?: never;+ path: {+ /**+ * Database id+ */+ id: string;+ /**+ * Webhook id+ */+ webhook_id: string;+ };+ query?: never;+ url: '/databases/{id}/webhooks/{webhook_id}';+};++export type DeleteDatabaseWebhookErrors = {+ /**+ * Missing or invalid credentials+ */+ 401: ErrorResponse;+ /**+ * No edit access to the database+ */+ 403: ErrorResponse;+ 404: ErrorResponse;+ 500: ErrorResponse;+};++export type DeleteDatabaseWebhookError = DeleteDatabaseWebhookErrors[keyof DeleteDatabaseWebhookErrors];++export type DeleteDatabaseWebhookResponses = {+ 204: void;+};++export type DeleteDatabaseWebhookResponse = DeleteDatabaseWebhookResponses[keyof DeleteDatabaseWebhookResponses];+export type TranscribeDictationData = {/*** OpenAPI representation of the raw encoded audio body extracted as `Bytes`.diff --git a/packages/sdk/specs/storage.json b/packages/sdk/specs/storage.jsonindex 733b898731..282dc27034 100644--- a/packages/sdk/specs/storage.json+++ b/packages/sdk/specs/storage.json@@ -6983,6 +6983,85 @@}}},+ "/databases/webhooks/{token}": {+ "post": {+ "tags": ["databases"],+ "summary": "Insert rows through a webhook. The body is a JSON object, one row, or\nan array of up to 100 objects, one row each. Keys name columns by name\n(ignoring case) or id; `null` leaves a cell empty. Values may be loose:\n`\"45\"` for a number, `\"true\"` for a checkbox, a label or labels for a\nselect, `2026-10-09` for a date. Nothing is written unless every row fits.",+ "operationId": "deliver_database_webhook",+ "parameters": [+ {+ "name": "token",+ "in": "path",+ "description": "The webhook's secret token",+ "required": true,+ "schema": {+ "type": "string"+ }+ }+ ],+ "requestBody": {+ "description": "A row, or an array of rows",+ "content": {+ "application/json": {+ "schema": {}+ }+ },+ "required": true+ },+ "responses": {+ "201": {+ "description": "",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/DatabaseWebhookDeliveryResponse"+ }+ }+ }+ },+ "400": {+ "description": "The payload does not fit the table; nothing was written",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/InvalidDatabaseWebhookPayloadResponse"+ }+ }+ }+ },+ "403": {+ "description": "The webhook's creator can no longer edit the database",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/ErrorResponse"+ }+ }+ }+ },+ "404": {+ "description": "No such webhook",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/ErrorResponse"+ }+ }+ }+ },+ "500": {+ "description": "",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/ErrorResponse"+ }+ }+ }+ }+ }+ }+ },"/databases/{id}": {"get": {"tags": ["databases"],@@ -8141,6 +8220,220 @@}}},+ "/databases/{id}/webhooks": {+ "get": {+ "tags": ["databases"],+ "summary": "The database's webhooks.",+ "operationId": "list_database_webhooks",+ "parameters": [+ {+ "name": "id",+ "in": "path",+ "description": "Database id",+ "required": true,+ "schema": {+ "type": "string",+ "format": "uuid"+ }+ }+ ],+ "responses": {+ "200": {+ "description": "",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/ListDatabaseWebhooksResponse"+ }+ }+ }+ },+ "401": {+ "description": "Missing or invalid credentials",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/ErrorResponse"+ }+ }+ }+ },+ "403": {+ "description": "No edit access to the database",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/ErrorResponse"+ }+ }+ }+ },+ "500": {+ "description": "",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/ErrorResponse"+ }+ }+ }+ }+ }+ },+ "post": {+ "tags": ["databases"],+ "summary": "Create a webhook: a secret URL whose calls insert rows into one of the\ndatabase's tables, writing with the creator's access.",+ "operationId": "create_database_webhook",+ "parameters": [+ {+ "name": "id",+ "in": "path",+ "description": "Database id",+ "required": true,+ "schema": {+ "type": "string",+ "format": "uuid"+ }+ }+ ],+ "requestBody": {+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/CreateDatabaseWebhookRequest"+ }+ }+ },+ "required": true+ },+ "responses": {+ "201": {+ "description": "",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/CreatedDatabaseWebhookResponse"+ }+ }+ }+ },+ "401": {+ "description": "Missing or invalid credentials",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/ErrorResponse"+ }+ }+ }+ },+ "403": {+ "description": "No edit access to the database",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/ErrorResponse"+ }+ }+ }+ },+ "404": {+ "description": "No such table in the database",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/ErrorResponse"+ }+ }+ }+ },+ "500": {+ "description": "",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/ErrorResponse"+ }+ }+ }+ }+ }+ }+ },+ "/databases/{id}/webhooks/{webhook_id}": {+ "delete": {+ "tags": ["databases"],+ "summary": "Delete a webhook; its URL stops working.",+ "operationId": "delete_database_webhook",+ "parameters": [+ {+ "name": "id",+ "in": "path",+ "description": "Database id",+ "required": true,+ "schema": {+ "type": "string",+ "format": "uuid"+ }+ },+ {+ "name": "webhook_id",+ "in": "path",+ "description": "Webhook id",+ "required": true,+ "schema": {+ "type": "string",+ "format": "uuid"+ }+ }+ ],+ "responses": {+ "204": {+ "description": ""+ },+ "401": {+ "description": "Missing or invalid credentials",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/ErrorResponse"+ }+ }+ }+ },+ "403": {+ "description": "No edit access to the database",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/ErrorResponse"+ }+ }+ }+ },+ "404": {+ "description": "",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/ErrorResponse"+ }+ }+ }+ },+ "500": {+ "description": "",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/ErrorResponse"+ }+ }+ }+ }+ }+ }+ },"/dictation/transcribe": {"post": {"tags": ["dictation"],@@ -23108,6 +23401,18 @@}}},+ "CreateDatabaseWebhookRequest": {+ "type": "object",+ "description": "Which table a new webhook inserts rows into.",+ "required": ["tableId"],+ "properties": {+ "tableId": {+ "type": "string",+ "format": "uuid",+ "description": "A table of the database."+ }+ }+ },"CreateDocumentRequest": {"type": "object","required": ["sha", "documentName"],@@ -23848,6 +24153,21 @@}}},+ "CreatedDatabaseWebhookResponse": {+ "type": "object",+ "description": "A new webhook, with the token its URL carries. The token is shown only\nhere.",+ "required": ["webhook", "token"],+ "properties": {+ "token": {+ "type": "string",+ "description": "The secret: `POST /databases/webhooks/{token}` inserts rows."+ },+ "webhook": {+ "$ref": "#/components/schemas/DatabaseWebhookResponse",+ "description": "The webhook."+ }+ }+ },"CreatedPairing": {"type": "object","description": "A pairing the daemon created, including its claim credential.\n\n`device_secret` is returned exactly once and never stored raw; the daemon\nkeeps it to claim the harness credential after approval.",@@ -24438,6 +24758,93 @@}}},+ "DatabaseWebhookDeliveryResponse": {+ "type": "object",+ "description": "The rows a webhook call inserted.",+ "required": ["databaseId", "tableId", "rows"],+ "properties": {+ "databaseId": {+ "type": "string",+ "format": "uuid",+ "description": "The database."+ },+ "rows": {+ "type": "array",+ "items": {+ "type": "string",+ "format": "uuid"+ },+ "description": "The new rows, in the order the payload sent them."+ },+ "tableId": {+ "type": "string",+ "format": "uuid",+ "description": "The table."+ }+ }+ },+ "DatabaseWebhookPayloadProblem": {+ "type": "object",+ "description": "One thing wrong with a webhook payload.",+ "required": ["row", "field", "message"],+ "properties": {+ "field": {+ "type": ["string", "null"],+ "description": "The key at fault, when one is."+ },+ "message": {+ "type": "string",+ "description": "What is wrong."+ },+ "row": {+ "type": ["integer", "null"],+ "description": "The row's index, when the payload is an array of rows.",+ "minimum": 0+ }+ }+ },+ "DatabaseWebhookResponse": {+ "type": "object",+ "description": "A webhook of a database. Its token is never shown again after creation.",+ "required": [+ "id",+ "databaseId",+ "tableId",+ "createdBy",+ "tokenPrefix",+ "createdAt"+ ],+ "properties": {+ "createdAt": {+ "type": "string",+ "format": "date-time",+ "description": "Creation time."+ },+ "createdBy": {+ "type": "string",+ "description": "Who created it; its calls write with their access."+ },+ "databaseId": {+ "type": "string",+ "format": "uuid",+ "description": "The database."+ },+ "id": {+ "type": "string",+ "format": "uuid",+ "description": "Identifier."+ },+ "tableId": {+ "type": "string",+ "format": "uuid",+ "description": "The table its calls insert rows into."+ },+ "tokenPrefix": {+ "type": "string",+ "description": "The token's first characters, to tell webhooks apart."+ }+ }+ },"DateOperator": {"type": "string","description": "How a date cell compares to a date-time.",@@ -30184,6 +30591,24 @@"description": "Why a document interaction was reported.","enum": ["edited", "first_join", "last_leave"]},+ "InvalidDatabaseWebhookPayloadResponse": {+ "type": "object",+ "description": "Why a payload was refused. Nothing was written.",+ "required": ["message", "problems"],+ "properties": {+ "message": {+ "type": "string",+ "description": "A summary."+ },+ "problems": {+ "type": "array",+ "items": {+ "$ref": "#/components/schemas/DatabaseWebhookPayloadProblem"+ },+ "description": "Every problem found."+ }+ }+ },"InviteMeetingRequest": {"type": "object","description": "A single email recipient for a call invitation.",@@ -30497,6 +30922,20 @@"description": "Defines who can access an item through its share link.","enum": ["PUBLIC", "TEAM"]},+ "ListDatabaseWebhooksResponse": {+ "type": "object",+ "description": "A database's webhooks.",+ "required": ["webhooks"],+ "properties": {+ "webhooks": {+ "type": "array",+ "items": {+ "$ref": "#/components/schemas/DatabaseWebhookResponse"+ },+ "description": "Oldest first."+ }+ }+ },"ListWebhooksResponse": {"type": "object","description": "Webhooks visible to the caller across their personal and team workspaces.\n\nClients deserialize this, so both derives are used.",diff --git a/packages/sdk/src/coverage/skipped.ts b/packages/sdk/src/coverage/skipped.tsindex 4d2af6a84b..1b4e2c2997 100644--- a/packages/sdk/src/coverage/skipped.ts+++ b/packages/sdk/src/coverage/skipped.ts@@ -332,6 +332,9 @@ export const storageExcluded = ['deleteHistoryHandler','deleteUserDocumentViewLocation','deleteViewHandler',+ // Called by third parties holding a webhook's URL; its token, not the+ // SDK's credentials, authenticates it.+ 'deliverDatabaseWebhook',// Old numeric comment links resolve inside the web app only.'entityMessageLegacy','excludeDefaultViewHandler',diff --git a/packages/sdk/src/entities/databases/database.ts b/packages/sdk/src/entities/databases/database.tsindex 3ec35f4f40..129740226b 100644--- a/packages/sdk/src/entities/databases/database.ts+++ b/packages/sdk/src/entities/databases/database.ts@@ -8,6 +8,7 @@ import type {ColumnKind,DatabaseDetail,DatabaseOp,+ DatabaseWebhookResponse,EntityKind,ImportTable,InferColumnTypeOutcome,@@ -31,6 +32,7 @@ import { DatabaseColumn } from './column';import type { DatabaseRow } from './row';import { DatabaseTable } from './table';import type { DatabaseView } from './view';+import { DatabaseWebhook } from './webhook';/** A result naming what happened to its resource: every kind but a reorder of the database's tables. */type ChangedResult = Extract<OpResult, { change: unknown }>;@@ -200,7 +202,7 @@ function isResultOf<>(result: OpResult | undefined,kind: Kind,- change: Change+ change: Change,): result is OpResultOf<Kind, Change> {return (result?.kind === kind && 'change' in result && result.change.kind === change@@ -213,7 +215,7 @@ function resultName(result: OpResult): string {.with({ kind: 'reorder_tables' }, ({ kind }) => kind).with({ kind: P.union('table', 'column', 'rows', 'view') },- ({ kind, change }) => `${kind}.${change.kind}`+ ({ kind, change }) => `${kind}.${change.kind}`,).exhaustive();}@@ -226,7 +228,7 @@ function soleResult<const [result] = results;if (results.length !== 1 || !isResultOf(result, kind, change))throw new MacroError(- `expected one ${kind}.${change} result, got ${results.map(resultName).join(', ') || 'none'}`+ `expected one ${kind}.${change} result, got ${results.map(resultName).join(', ') || 'none'}`,);return result;}@@ -241,7 +243,7 @@ function soleResult<export class Database extends MacroEntity<DatabaseDetail> {protected async fetch(): Promise<DatabaseDetail> {return unwrap(- await this.client.storage.getDatabase({ path: { id: this.id } })+ await this.client.storage.getDatabase({ path: { id: this.id } }),);}@@ -258,10 +260,10 @@ export class Database extends MacroEntity<DatabaseDetail> {/** Create a database owned by the caller. */static async create(client: MacroClient,- options: { name: string }+ options: { name: string },): Promise<Database> {const record = unwrap(- await client.storage.createDatabase({ body: { name: options.name } })+ await client.storage.createDatabase({ body: { name: options.name } }),);return new Database(client, record.id);}@@ -285,19 +287,19 @@ export class Database extends MacroEntity<DatabaseDetail> {/** The user who owns the database. */readonly owner = this.mappedField('database', (record) =>- User.byId(this.client, record.owner_id)+ User.byId(this.client, record.owner_id),);/** When the database was created. */readonly createdAt = this.mappedField('database',- (record) => record.created_at+ (record) => record.created_at,);/** When the database was trashed, if it has been. */readonly trashedAt = this.mappedField('database',- (record) => record.trashed_at ?? undefined+ (record) => record.trashed_at ?? undefined,);/** The caller's access on the database. */@@ -305,7 +307,7 @@ export class Database extends MacroEntity<DatabaseDetail> {/** The database's tables, in tab order. */readonly tables = this.mappedField('tables', (tables) =>- tables.map((table) => DatabaseTable.byId(this, table.table.id))+ tables.map((table) => DatabaseTable.byId(this, table.table.id)),);/** The table with the given display name, or `undefined` if there is none. */@@ -326,7 +328,7 @@ export class Database extends MacroEntity<DatabaseDetail> {},]),'table',- 'created'+ 'created',);return DatabaseTable.byId(this, table);}@@ -343,14 +345,14 @@ export class Database extends MacroEntity<DatabaseDetail> {*/async applyOps(ops: DatabaseOp[],- options: ApplyOpsOptions = {}+ options: ApplyOpsOptions = {},): Promise<OpResult[]> {const body: ApplyOpsRequest = { ops };if (options.baseVersions !== undefined) {for (const { table } of options.baseVersions)this.assertOwns(`table ${table.id}`, table.database);body.baseVersions = Object.fromEntries(- options.baseVersions.map(({ table, version }) => [table.id, version])+ options.baseVersions.map(({ table, version }) => [table.id, version]),);}const { results } = await this.mutate(async (client) => {@@ -361,7 +363,7 @@ export class Database extends MacroEntity<DatabaseDetail> {if (outcome.error !== undefined && 'op' in outcome.error)throw new MacroOpRefusedError(outcome.response?.status ?? 0,- outcome.error+ outcome.error,);return outcome;});@@ -381,7 +383,7 @@ export class Database extends MacroEntity<DatabaseDetail> {const [reordered] = results;if (results.length !== 1 || reordered?.kind !== 'reorder_tables')throw new MacroError(- `expected one reorder_tables result, got ${results.map(resultName).join(', ') || 'none'}`+ `expected one reorder_tables result, got ${results.map(resultName).join(', ') || 'none'}`,);return reordered.tables.map(({ table }) => DatabaseTable.byId(this, table));}@@ -398,7 +400,7 @@ export class Database extends MacroEntity<DatabaseDetail> {{ kind: 'table', table: table.id, change: { kind: 'delete' } },]),'table',- 'deleted'+ 'deleted',);}@@ -411,7 +413,7 @@ export class Database extends MacroEntity<DatabaseDetail> {return unwrap(await this.client.storage.listDatabaseColumnCasts({path: { id: this.id, table_id: column.table.id, column_id: column.id },- })+ }),);}@@ -421,7 +423,7 @@ export class Database extends MacroEntity<DatabaseDetail> {const { positions } = unwrap(await this.client.storage.getDatabaseViewPositions({path: { id: this.id, view_id: view.id },- })+ }),);return positions;}@@ -435,7 +437,7 @@ export class Database extends MacroEntity<DatabaseDetail> {const { changes } = unwrap(await this.client.storage.getDatabaseRowHistory({path: { id: this.id, table_id: row.table.id, row_id: row.id },- })+ }),);return changes;}@@ -446,29 +448,74 @@ export class Database extends MacroEntity<DatabaseDetail> {client.storage.importDatabaseTable({path: { id: this.id },body: request,- })+ }),);return DatabaseTable.byId(this, table.id);}+ private webhookOf(record: DatabaseWebhookResponse): DatabaseWebhook {+ return DatabaseWebhook.fromRecord(+ DatabaseTable.byId(this, record.tableId),+ User.byId(this.client, record.createdBy),+ record,+ );+ }++ /** The database's webhooks, oldest first. Takes edit access. */+ async webhooks(): Promise<DatabaseWebhook[]> {+ const { webhooks } = unwrap(+ await this.client.storage.listDatabaseWebhooks({ path: { id: this.id } }),+ );+ return webhooks.map((record) => this.webhookOf(record));+ }++ /**+ * Create a webhook that inserts rows into `table`, writing with the+ * caller's access. POST a JSON object (one row) or an array of objects to+ * `/databases/webhooks/{token}` on the storage service; keys name columns.+ * The token is the whole credential and is answered only here.+ */+ async createWebhook(+ table: DatabaseTable,+ ): Promise<{ webhook: DatabaseWebhook; token: string }> {+ this.assertOwns('table', table.database);+ const created = unwrap(+ await this.client.storage.createDatabaseWebhook({+ path: { id: this.id },+ body: { tableId: table.id },+ }),+ );+ return { webhook: this.webhookOf(created.webhook), token: created.token };+ }++ /** Delete one of the database's webhooks; its URL stops working. */+ async deleteWebhook(webhook: DatabaseWebhook): Promise<void> {+ this.assertOwns('webhook', webhook.table.database);+ unwrap(+ await this.client.storage.deleteDatabaseWebhook({+ path: { id: this.id, webhook_id: webhook.id },+ }),+ );+ }+/** Read direct recipients. Only the database owner can manage sharing. */async sharePermissions(): Promise<SharePermissionV2> {return unwrap(await this.client.storage.getDatabasePermissions({path: { id: this.id },- })+ }),);}/** Add, replace, or remove recipient grants without transferring ownership. */updateSharePermissions(- request: UpdateSharePermissionRequestV2+ request: UpdateSharePermissionRequestV2,): Promise<SharePermissionV2> {return this.mutate((client) =>client.storage.updateDatabasePermissions({path: { id: this.id },body: request,- })+ }),);}@@ -480,7 +527,7 @@ export class Database extends MacroEntity<DatabaseDetail> {*/async changeColumnType(column: DatabaseColumn,- options: ChangeColumnTypeOptions+ options: ChangeColumnTypeOptions,): Promise<OpResultOf<'column', 'type_changed'>> {this.assertOwns(`column ${column.id}`, column.table.database);const version = await column.table.version();@@ -494,10 +541,10 @@ export class Database extends MacroEntity<DatabaseDetail> {change: { kind: 'change_type', to: columnKind(options.to) },},],- { baseVersions: [{ table: column.table, version }] }+ { baseVersions: [{ table: column.table, version }] },),'column',- 'type_changed'+ 'type_changed',);}@@ -508,14 +555,14 @@ export class Database extends MacroEntity<DatabaseDetail> {*/async columnConversion(column: DatabaseColumn,- to: ColumnType+ to: ColumnType,): Promise<ColumnConversion> {this.assertOwns(`column ${column.id}`, column.table.database);return unwrap(await this.client.storage.convertDatabaseColumn({path: { id: this.id, table_id: column.table.id, column_id: column.id },body: { to: columnKind(to) },- })+ }),);}@@ -527,7 +574,7 @@ export class Database extends MacroEntity<DatabaseDetail> {*/async convertColumnIntoNewColumn(column: DatabaseColumn,- options: ConvertIntoNewColumnOptions+ options: ConvertIntoNewColumnOptions,): Promise<DatabaseColumn> {const conversion = await this.columnConversion(column, options.to);const name =@@ -570,7 +617,7 @@ export class Database extends MacroEntity<DatabaseDetail> {});if (!isResultOf(created, 'column', 'created'))throw new MacroError(- `expected a column.created result, got ${created ? resultName(created) : 'none'}`+ `expected a column.created result, got ${created ? resultName(created) : 'none'}`,);return DatabaseColumn.byId(column.table, created.column);}@@ -592,10 +639,10 @@ export class Database extends MacroEntity<DatabaseDetail> {change: { kind: 'delete' },},],- { baseVersions: [{ table: column.table, version }] }+ { baseVersions: [{ table: column.table, version }] },),'column',- 'deleted'+ 'deleted',);return tableVersion;}@@ -607,13 +654,13 @@ export class Database extends MacroEntity<DatabaseDetail> {*/async reorderColumns(table: DatabaseTable,- columns: DatabaseColumn[]+ columns: DatabaseColumn[],): Promise<TableVersion> {this.assertOwns(`table ${table.id}`, table.database);for (const column of columns)if (column.table.id !== table.id)throw new MacroError(- `column ${column.id} does not belong to table ${table.id}`+ `column ${column.id} does not belong to table ${table.id}`,);const version = await table.version();const { tableVersion } = soleResult(@@ -628,14 +675,14 @@ export class Database extends MacroEntity<DatabaseDetail> {},},],- { baseVersions: [{ table, version }] }+ { baseVersions: [{ table, version }] },),'table',- 'columns_reordered'+ 'columns_reordered',);if (tableVersion === undefined)throw new MacroError(- `table ${table.id} reordered its columns without a version`+ `table ${table.id} reordered its columns without a version`,);return tableVersion;}@@ -656,7 +703,7 @@ export class Database extends MacroEntity<DatabaseDetail> {},]),'table',- 'renamed'+ 'renamed',);if (tableVersion === undefined)throw new MacroError(`table ${table.id} was renamed without a version`);@@ -670,7 +717,7 @@ export class Database extends MacroEntity<DatabaseDetail> {*/async renameColumn(column: DatabaseColumn,- name: string+ name: string,): Promise<TableVersion> {this.assertOwns(`column ${column.id}`, column.table.database);const previousName = await column.name();@@ -684,7 +731,7 @@ export class Database extends MacroEntity<DatabaseDetail> {},]),'column',- 'renamed'+ 'renamed',);return tableVersion;}@@ -692,7 +739,7 @@ export class Database extends MacroEntity<DatabaseDetail> {/** Adopt a first-value type only while the owned column is empty and inferable. */async inferColumnType(column: DatabaseColumn,- options: InferColumnTypeOptions+ options: InferColumnTypeOptions,): Promise<InferColumnTypeOutcome> {this.assertOwns(`column ${column.id}`, column.table.database);return this.mutate((client) =>@@ -705,7 +752,7 @@ export class Database extends MacroEntity<DatabaseDetail> {? { specificEntityType: options.specificEntityType }: {}),},- })+ }),);}@@ -715,12 +762,12 @@ export class Database extends MacroEntity<DatabaseDetail> {*/async addColumn(table: DatabaseTable,- options: AddColumnOptions+ options: AddColumnOptions,): Promise<DatabaseColumn> {this.assertOwns(`table ${table.id}`, table.database);if (options.after !== undefined && options.after.table.id !== table.id)throw new MacroError(- `column ${options.after.id} does not belong to table ${table.id}`+ `column ${options.after.id} does not belong to table ${table.id}`,);const definition: NewColumn ='property' in options@@ -750,7 +797,7 @@ export class Database extends MacroEntity<DatabaseDetail> {},]),'column',- 'created'+ 'created',);return DatabaseColumn.byId(table, column);}@@ -763,7 +810,7 @@ export class Database extends MacroEntity<DatabaseDetail> {*/async addColumnOptions(column: DatabaseColumn,- labels: string[]+ labels: string[],): Promise<OpResultOf<'column', 'options_added'>> {this.assertOwns(`column ${column.id}`, column.table.database);return soleResult(@@ -776,7 +823,7 @@ export class Database extends MacroEntity<DatabaseDetail> {},]),'column',- 'options_added'+ 'options_added',);}}diff --git a/packages/sdk/src/entities/databases/table.ts b/packages/sdk/src/entities/databases/table.tsindex b2112df359..f3c10740ab 100644--- a/packages/sdk/src/entities/databases/table.ts+++ b/packages/sdk/src/entities/databases/table.ts@@ -7,6 +7,7 @@ import { DatabaseColumn } from './column';import type { AddColumnOptions, Database } from './database';import { DatabaseRow } from './row';import { DatabaseView } from './view';+import type { DatabaseWebhook } from './webhook';/*** One table (tab) of a {@link Database}.@@ -20,7 +21,7 @@ export class DatabaseTable {/** The database this table belongs to. */readonly database: Database,/** Identifier of the table. */- readonly id: string+ readonly id: string,) {}/** A handle to a table by id, within a database. Details load on first access. */@@ -37,7 +38,7 @@ export class DatabaseTable {const found = tables.find((table) => table.table.id === this.id);if (!found) {throw new MacroNotFoundError(- `table ${this.id} is not in database ${this.database.id}`+ `table ${this.id} is not in database ${this.database.id}`,);}return found;@@ -97,6 +98,11 @@ export class DatabaseTable {return views.map((view) => DatabaseView.byId(this, view.id));}+ /** Create a webhook that inserts rows here. See {@link Database.createWebhook}. */+ createWebhook(): Promise<{ webhook: DatabaseWebhook; token: string }> {+ return this.database.createWebhook(this);+ }+/** Delete this table. See {@link Database.deleteTable}. */async delete(): Promise<void> {await this.database.deleteTable(this);diff --git a/packages/sdk/src/entities/databases/webhook.ts b/packages/sdk/src/entities/databases/webhook.tsnew file mode 100644index 0000000000..fbc2934179--- /dev/null+++ b/packages/sdk/src/entities/databases/webhook.ts@@ -0,0 +1,53 @@+import type { DatabaseWebhookResponse } from '../../../generated/storage/types.gen';+import type { User } from '../users/user';+import type { DatabaseTable } from './table';++/**+ * A webhook of a {@link DatabaseTable}: a secret URL that anyone holding it+ * can POST JSON to, each object becoming a row, written with the access of+ * the user who created it. Its token is shown only when it is created; see+ * {@link Database.createWebhook}.+ */+export class DatabaseWebhook {+ private constructor(+ /** The table its calls insert rows into. */+ readonly table: DatabaseTable,+ /** Identifier of the webhook. */+ readonly id: string,+ /** Who created it; its calls write with their access. */+ readonly createdBy: User,+ private readonly record: DatabaseWebhookResponse,+ ) {}++ /** A handle from the record the API answered. */+ static fromRecord(+ table: DatabaseTable,+ createdBy: User,+ record: DatabaseWebhookResponse,+ ): DatabaseWebhook {+ return new DatabaseWebhook(table, record.id, createdBy, record);+ }++ /** The token's first characters, to tell webhooks apart without the secret. */+ get tokenPrefix(): string {+ return this.record.tokenPrefix;+ }++ /** When it was created. */+ get createdAt(): string {+ return this.record.createdAt;+ }++ /** Delete the webhook; its URL stops working. */+ delete(): Promise<void> {+ return this.table.database.deleteWebhook(this);+ }++ toJSON(): { id: string; tableId: string; tokenPrefix: string } {+ return {+ id: this.id,+ tableId: this.table.id,+ tokenPrefix: this.tokenPrefix,+ };+ }+}diff --git a/packages/sdk/tests/databases.test.ts b/packages/sdk/tests/databases.test.tsindex 0511670ec6..7bd155ab5d 100644--- a/packages/sdk/tests/databases.test.ts+++ b/packages/sdk/tests/databases.test.ts@@ -76,11 +76,11 @@ const support: DatabaseDetail = {};function intercept(- respond: (request: Request) => Response | Promise<Response>+ respond: (request: Request) => Response | Promise<Response>,) {globalThis.fetch = (async (input) =>respond(- input instanceof Request ? input : new Request(input)+ input instanceof Request ? input : new Request(input),)) as typeof fetch;}@@ -210,7 +210,7 @@ describe('Database', () => {baseVersion: 7,});expect(requests[1]?.url).toBe(- `${host}/databases/${databaseId}/tables/${tableId}/columns/${columnId}/infer-type`+ `${host}/databases/${databaseId}/tables/${tableId}/columns/${columnId}/infer-type`,);await expect(requests[1]?.json()).resolves.toEqual({dataType: 'ENTITY',@@ -220,7 +220,7 @@ describe('Database', () => {await expect(macro.databases.byId('other')- .inferColumnType(column, { dataType: 'NUMBER', baseVersion: 7 })+ .inferColumnType(column, { dataType: 'NUMBER', baseVersion: 7 }),).rejects.toThrow('does not belong');expect(requests).toHaveLength(2);});@@ -337,7 +337,7 @@ describe('Database', () => {await database.schema();expect(reads).toBe(4);await expect(- client().databases.byId('other').deleteColumn(column)+ client().databases.byId('other').deleteColumn(column),).rejects.toThrow('does not belong');expect(writes).toHaveLength(3);});@@ -353,7 +353,7 @@ describe('Database', () => {if (request.method !== 'GET')writes.push({ url: request.url, body: await request.json() });return Response.json(- request.url.endsWith('/import') ? { id: tableId } : permissions+ request.url.endsWith('/import') ? { id: tableId } : permissions,);});const database = client().databases.byId(databaseId);@@ -386,6 +386,67 @@ describe('Database', () => {});});+ test("creates, lists and deletes a table's webhooks by handle", async () => {+ const webhookId = '0198a4cc-e138-7670-a308-a6b766602710';+ const record = {+ id: webhookId,+ databaseId,+ tableId,+ createdBy: 'macro|[email protected]',+ tokenPrefix: 'mdbw_0123456789ab',+ createdAt: '2026-10-09T12:00:00Z',+ };+ const writes: { method: string; url: string; body: unknown }[] = [];+ intercept(async (request) => {+ if (request.method === 'DELETE') {+ writes.push({ method: 'DELETE', url: request.url, body: undefined });+ return new Response(null, { status: 204 });+ }+ if (request.method === 'POST') {+ writes.push({+ method: 'POST',+ url: request.url,+ body: await request.json(),+ });+ return Response.json(+ { webhook: record, token: 'mdbw_0123456789ab_secret' },+ { status: 201 },+ );+ }+ return Response.json(+ request.url.endsWith('/webhooks') ? { webhooks: [record] } : support,+ );+ });+ const tickets = await client().databases.byId(databaseId).table('Tickets');+ if (!tickets) throw new Error('Missing fixture table');++ const created = await tickets.createWebhook();+ const [listed] = await tickets.database.webhooks();+ if (!listed) throw new Error('Missing listed webhook');+ await listed.delete();++ expect(created.token).toBe('mdbw_0123456789ab_secret');+ expect(created.webhook.toJSON()).toEqual({+ id: webhookId,+ tableId,+ tokenPrefix: 'mdbw_0123456789ab',+ });+ expect(listed.createdBy.id).toBe('macro|[email protected]');+ expect(listed.createdAt).toBe('2026-10-09T12:00:00Z');+ expect(writes).toEqual([+ {+ method: 'POST',+ url: `${host}/databases/${databaseId}/webhooks`,+ body: { tableId },+ },+ {+ method: 'DELETE',+ url: `${host}/databases/${databaseId}/webhooks/${webhookId}`,+ body: undefined,+ },+ ]);+ });+test('applies ops in one request and returns one result per op', async () => {const rowId = '0198a4cc-e138-7670-a308-a6b766602704';const writes: { url: string; method: string; body: unknown }[] = [];@@ -552,10 +613,10 @@ describe('Database', () => {]);expect(reads).toBe(3);await expect(- client().databases.byId('other').reorderTables([tickets])+ client().databases.byId('other').reorderTables([tickets]),).rejects.toThrow('does not belong');await expect(- client().databases.byId('other').deleteTable(tickets)+ client().databases.byId('other').deleteTable(tickets),).rejects.toThrow('does not belong');expect(writes).toHaveLength(2);});@@ -585,7 +646,7 @@ describe('Database', () => {{kind: 'table',table: expect.stringMatching(- /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/+ /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/,),change: { kind: 'create', name: 'Guests' },},@@ -817,7 +878,7 @@ describe('Database', () => {kind: 'column',table: tableId,column: expect.stringMatching(- /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/+ /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/,),change: {kind: 'create',@@ -865,7 +926,7 @@ describe('Database', () => {kind: 'column',table: tableId,column: expect.stringMatching(- /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/+ /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/,),change: {kind: 'create',@@ -916,7 +977,7 @@ describe('Database', () => {options: [{id: expect.stringMatching(- /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/+ /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/,),label: 'Maybe',},@@ -957,7 +1018,7 @@ describe('Database', () => {change: { kind: 'delete' },},],- { baseVersions: [{ table, version: 7 }] }+ { baseVersions: [{ table, version: 7 }] },);expect(opsBody).toEqual({ops: [@@ -987,7 +1048,7 @@ describe('Database', () => {column: null,taken: { kind: 'table', id: tableId },},- { status: 400 }+ { status: 400 },);});const database = client().databases.byId(databaseId);@@ -1032,7 +1093,7 @@ describe('Database', () => {if (!column) throw new Error('Missing fixture column');expect(await column.casts()).toEqual(casts);expect(urls[1]).toBe(- `${host}/databases/${databaseId}/tables/${tableId}/columns/${columnId}/casts`+ `${host}/databases/${databaseId}/tables/${tableId}/columns/${columnId}/casts`,);});diff --git a/services/document_storage_service/Cargo.toml b/services/document_storage_service/Cargo.tomlindex e0a9228845..332dc76716 100644--- a/services/document_storage_service/Cargo.toml+++ b/services/document_storage_service/Cargo.toml@@ -102,6 +102,10 @@ databases = { path = "../../crates/databases", features = ["inbound","postgres",] }+database_webhooks = { path = "../../crates/database_webhooks", features = [+ "inbound",+ "postgres",+] }forms = { path = "../../crates/forms", features = ["entity_mutation","gateway",diff --git a/services/document_storage_service/src/api.rs b/services/document_storage_service/src/api.rsindex 28f7755f31..c8939d3129 100644--- a/services/document_storage_service/src/api.rs+++ b/services/document_storage_service/src/api.rs@@ -277,11 +277,15 @@ fn api_router(state: ApiContext) -> Router {).nest("/databases",- databases::inbound::axum_router::databases_router(state.databases_state.clone()).merge(- databases::inbound::starter_router::starter_router(+ databases::inbound::axum_router::databases_router(state.databases_state.clone())+ .merge(databases::inbound::starter_router::starter_router(state.database_starter_state.clone(),+ ))+ .merge(+ database_webhooks::inbound::axum_router::database_webhooks_router(+ state.database_webhooks_state.clone(),+ ),),- ),).nest("/forms",diff --git a/services/document_storage_service/src/api/context.rs b/services/document_storage_service/src/api/context.rsindex c341bf2722..290f280bdb 100644--- a/services/document_storage_service/src/api/context.rs+++ b/services/document_storage_service/src/api/context.rs@@ -573,6 +573,18 @@ pub(crate) type DatabasesServiceType =pub(crate) type DssDatabasesState =DatabasesRouterState<DatabasesServiceType, EntityAccessService, AuthorizationService>;+/// Webhooks insert rows through the databases domain service, so they keep its validation and events.+pub(crate) type DatabaseWebhooksServiceType =+ database_webhooks::wiring::PgDatabaseWebhooksService<DatabasesServiceType, EntityAccessService>;++/// Webhooks use the same authentication and entity-access services as databases.+pub(crate) type DssDatabaseWebhooksState =+ database_webhooks::inbound::axum_router::DatabaseWebhooksRouterState<+ DatabaseWebhooksServiceType,+ EntityAccessService,+ AuthorizationService,+ >;+/// Forms compose the databases domain service, so row writes retain its validation and events.pub(crate) type FormsServiceType = forms::wiring::PgFormsService<DatabasesServiceType,@@ -836,6 +848,7 @@ pub(crate) struct ApiContext {pub graphql_initiative_entity_loader: graphql_initiative::InitiativeEntityLoader,pub graphql_agent_session_entity_loader: graphql_soup::AgentSessionEntityLoader,pub databases_state: DssDatabasesState,+ pub database_webhooks_state: DssDatabaseWebhooksState,pub forms_state: DssFormsState,pub database_starter_state: DssDatabaseStarterState,pub collab_surface_state: DssCollabSurfaceState,diff --git a/services/document_storage_service/src/api/swagger.rs b/services/document_storage_service/src/api/swagger.rsindex 8ef5e70130..6dd5e2f31e 100644--- a/services/document_storage_service/src/api/swagger.rs+++ b/services/document_storage_service/src/api/swagger.rs@@ -1011,6 +1011,7 @@ struct FormsApiAddon;impl utoipa::Modify for FormsApiAddon {fn modify(&self, openapi: &mut utoipa::openapi::OpenApi) {openapi.merge(forms::inbound::axum_router::FormsApi::openapi());+ openapi.merge(database_webhooks::inbound::axum_router::DatabaseWebhooksApi::openapi());}}diff --git a/services/document_storage_service/src/api/swagger/test.rs b/services/document_storage_service/src/api/swagger/test.rsindex 2c37c05167..e194384d8d 100644--- a/services/document_storage_service/src/api/swagger/test.rs+++ b/services/document_storage_service/src/api/swagger/test.rs@@ -25,3 +25,18 @@ fn dss_registers_all_forms_operations_and_schemas() {assert_eq!(&dss["components"]["schemas"][name], schema, "{name}");}}++#[test]+fn dss_registers_all_database_webhook_operations_and_schemas() {+ let dss = serde_json::to_value(ApiDoc::openapi()).unwrap();+ let webhooks = serde_json::to_value(+ database_webhooks::inbound::axum_router::DatabaseWebhooksApi::openapi(),+ )+ .unwrap();+ for (path, operations) in webhooks["paths"].as_object().unwrap() {+ assert_eq!(&dss["paths"][path], operations, "{path}");+ }+ for (name, schema) in webhooks["components"]["schemas"].as_object().unwrap() {+ assert_eq!(&dss["components"]["schemas"][name], schema, "{name}");+ }+}diff --git a/services/document_storage_service/src/server.rs b/services/document_storage_service/src/server.rsindex 5b2cc9ace2..e67f6352d5 100644--- a/services/document_storage_service/src/server.rs+++ b/services/document_storage_service/src/server.rs@@ -1494,6 +1494,12 @@ pub async fn run() -> anyhow::Result<()> {),));+ let database_webhooks_service = Arc::new(database_webhooks::wiring::build_service(+ db.clone(),+ databases_service.clone(),+ entity_access_service.clone(),+ ));+let forms_service = Arc::new(forms::wiring::build_service(db.clone(),databases_service.clone(),@@ -2056,6 +2062,12 @@ pub async fn run() -> anyhow::Result<()> {entity_access_service.clone(),authorization_state.clone(),),+ database_webhooks_state:+ database_webhooks::inbound::axum_router::DatabaseWebhooksRouterState::new(+ database_webhooks_service,+ entity_access_service.clone(),+ authorization_state.clone(),+ ),forms_state: forms::inbound::axum_router::FormsRouterState::new(forms_service,entity_access_service.clone(),