@alvera-ai/platform-sdk 0.7.3 → 0.9.0

package/src/generated/sdk.gen.ts

@@ -22,29 +22,37 @@ export type Options<TData extends TDataShape = TDataShape, ThrowOnError extends
 };
 
 /**
- * Resolve a short URL token to a page
- *
- * Given a connected app slug and a Puid short URL token, resolves the token to
- * the pre-stored route path and MDM subject ID. The Cloudflare app calls this
- * endpoint when a customer clicks a short URL, forwarding the original client
- * headers (user-agent, IP, country) in the request body.
- *
- * When the page token is linked to a message (via workflow action execution),
- * the regulated message details (raw body, channel, status) are included in
- * the response.
+ * List tools
  *
- * **Requires X-API-Key authentication.**
+ * Returns a paginated list of tools for the authenticated tenant.
+ */
+export const platformApiToolControllerIndex = <ThrowOnError extends boolean = false>(options: Options<PlatformApiToolControllerIndexData, ThrowOnError>) => (options.client ?? client).get<PlatformApiToolControllerIndexResponses, PlatformApiToolControllerIndexErrors, ThrowOnError>({
+    querySerializer: { parameters: { filters: { array: { style: 'deepObject' } } } },
+    requestValidator: async (data: unknown) => await v.parseAsync(v.object({
+        body: v.optional(v.never()),
+        path: vPlatformApiToolControllerIndexPath,
+        query: v.optional(vPlatformApiToolControllerIndexQuery)
+    }), data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiToolControllerIndexResponse, data),
+    security: [{ name: 'X-API-Key', type: 'apiKey' }],
+    url: '/api/v1/tenants/{tenant_slug}/tools',
+    ...options
+});
+
+/**
+ * Create a tool
  *
+ * Creates a new tool for the authenticated tenant.
  */
-export const platformApiConnectedAppControllerResolvePage = <ThrowOnError extends boolean = false>(options: Options<PlatformApiConnectedAppControllerResolvePageData, ThrowOnError>) => (options.client ?? client).post<PlatformApiConnectedAppControllerResolvePageResponses, PlatformApiConnectedAppControllerResolvePageErrors, ThrowOnError>({
+export const platformApiToolControllerCreate = <ThrowOnError extends boolean = false>(options: Options<PlatformApiToolControllerCreateData, ThrowOnError>) => (options.client ?? client).post<PlatformApiToolControllerCreateResponses, PlatformApiToolControllerCreateErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: vPlatformApiConnectedAppControllerResolvePageBody,
-        path: vPlatformApiConnectedAppControllerResolvePagePath,
+        body: v.optional(vPlatformApiToolControllerCreateBody),
+        path: vPlatformApiToolControllerCreatePath,
         query: v.optional(v.never())
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiConnectedAppControllerResolvePageResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiToolControllerCreateResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/connected-apps/{slug}/resolve-page',
+    url: '/api/v1/tenants/{tenant_slug}/tools',
     ...options,
     headers: {
         'Content-Type': 'application/json',
@@ -53,60 +61,53 @@ export const platformApiConnectedAppControllerResolvePage = <ThrowOnError extend
 });
 
 /**
- * Run a contract against a payload (sandbox)
+ * Delete a data activation client
  *
- * Runs the contract's `filter → transform → mdm_input` pipeline against the supplied JSON row. Stateless — no DB writes. Use for template authoring/testing.
+ * Deletes a DAC. Returns 422 if the DAC is a platform default (is_default=true). Returns 409 if referenced by other resources.
  */
-export const platformApiInteroperabilityContractControllerRun = <ThrowOnError extends boolean = false>(options: Options<PlatformApiInteroperabilityContractControllerRunData, ThrowOnError>) => (options.client ?? client).post<PlatformApiInteroperabilityContractControllerRunResponses, PlatformApiInteroperabilityContractControllerRunErrors, ThrowOnError>({
-    querySerializer: { parameters: { filters: { array: { style: 'deepObject' } } } },
+export const platformApiDataActivationClientControllerDelete = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDataActivationClientControllerDeleteData, ThrowOnError>) => (options.client ?? client).delete<PlatformApiDataActivationClientControllerDeleteResponses, PlatformApiDataActivationClientControllerDeleteErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: vPlatformApiInteroperabilityContractControllerRunBody,
-        path: vPlatformApiInteroperabilityContractControllerRunPath,
-        query: v.optional(vPlatformApiInteroperabilityContractControllerRunQuery)
+        body: v.optional(v.never()),
+        path: vPlatformApiDataActivationClientControllerDeletePath,
+        query: v.optional(v.never())
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiInteroperabilityContractControllerRunResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDataActivationClientControllerDeleteResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/interoperability-contracts/{slug}/run',
-    ...options,
-    headers: {
-        'Content-Type': 'application/json',
-        ...options.headers
-    }
+    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/data-activation-clients/{slug}',
+    ...options
 });
 
 /**
- * List action status updaters
+ * Get a data activation client
  *
- * Returns a paginated list of action status updaters for the authenticated tenant.
+ * Returns a single DAC by datalake-scoped slug.
  */
-export const platformApiActionStatusUpdaterControllerIndex = <ThrowOnError extends boolean = false>(options: Options<PlatformApiActionStatusUpdaterControllerIndexData, ThrowOnError>) => (options.client ?? client).get<PlatformApiActionStatusUpdaterControllerIndexResponses, PlatformApiActionStatusUpdaterControllerIndexErrors, ThrowOnError>({
-    querySerializer: { parameters: { filters: { array: { style: 'deepObject' } } } },
+export const platformApiDataActivationClientControllerShow = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDataActivationClientControllerShowData, ThrowOnError>) => (options.client ?? client).get<PlatformApiDataActivationClientControllerShowResponses, PlatformApiDataActivationClientControllerShowErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
         body: v.optional(v.never()),
-        path: vPlatformApiActionStatusUpdaterControllerIndexPath,
-        query: v.optional(vPlatformApiActionStatusUpdaterControllerIndexQuery)
+        path: vPlatformApiDataActivationClientControllerShowPath,
+        query: v.optional(v.never())
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiActionStatusUpdaterControllerIndexResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDataActivationClientControllerShowResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/action-status-updaters',
+    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/data-activation-clients/{slug}',
     ...options
 });
 
 /**
- * Create an action status updater
+ * Replace a data activation client
  *
- * Creates a new action status updater for the authenticated tenant.
+ * Replaces a DAC with the full resource body. PUT semantics — all required fields must be present. `slug` is immutable.
  */
-export const platformApiActionStatusUpdaterControllerCreate = <ThrowOnError extends boolean = false>(options: Options<PlatformApiActionStatusUpdaterControllerCreateData, ThrowOnError>) => (options.client ?? client).post<PlatformApiActionStatusUpdaterControllerCreateResponses, PlatformApiActionStatusUpdaterControllerCreateErrors, ThrowOnError>({
-    querySerializer: { parameters: { filters: { array: { style: 'deepObject' } } } },
+export const platformApiDataActivationClientControllerUpdate = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDataActivationClientControllerUpdateData, ThrowOnError>) => (options.client ?? client).put<PlatformApiDataActivationClientControllerUpdateResponses, PlatformApiDataActivationClientControllerUpdateErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: v.optional(vPlatformApiActionStatusUpdaterControllerCreateBody),
-        path: vPlatformApiActionStatusUpdaterControllerCreatePath,
-        query: v.optional(vPlatformApiActionStatusUpdaterControllerCreateQuery)
+        body: v.optional(vPlatformApiDataActivationClientControllerUpdateBody),
+        path: vPlatformApiDataActivationClientControllerUpdatePath,
+        query: v.optional(v.never())
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiActionStatusUpdaterControllerCreateResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDataActivationClientControllerUpdateResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/action-status-updaters',
+    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/data-activation-clients/{slug}',
     ...options,
     headers: {
         'Content-Type': 'application/json',
@@ -115,118 +116,97 @@ export const platformApiActionStatusUpdaterControllerCreate = <ThrowOnError exte
 });
 
 /**
- * List batch run logs
+ * Enqueue datalake migrations
+ *
+ * Enqueues a `DatalakeMigrationWorker` Oban job that brings the datalake's
+ * per-tenant database to the current schema version. Required after
+ * `POST /datalakes`, which only persists the metadata row — it does NOT
+ * run migrations against the per-tenant DB. Without this step, every
+ * downstream resource that touches per-datalake tables
+ * (`data_activation_logs`, MDM tables, dataset tables) will fail with
+ * `relation … does not exist`.
+ *
+ * Asynchronous: returns 202 Accepted as soon as the job is enqueued.
+ * Callers poll `GET /datalakes/:id` and watch for `status: :ready`.
+ * Idempotent at the job level — re-enqueueing on a migrated datalake
+ * is a no-op once the worker completes.
+ *
+ * The LiveView "Migrate Datalake" button calls the same migrator
+ * synchronously inside the LiveView process.
+ *
+ * Requires a tenant-scoped Bearer with membership role `admin`.
  *
- * Returns a paginated list of batch-level workflow run logs.
  */
-export const platformApiAgenticWorkflowOperationsControllerBatchLogsIndex = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAgenticWorkflowOperationsControllerBatchLogsIndexData, ThrowOnError>) => (options.client ?? client).get<PlatformApiAgenticWorkflowOperationsControllerBatchLogsIndexResponses, PlatformApiAgenticWorkflowOperationsControllerBatchLogsIndexErrors, ThrowOnError>({
-    querySerializer: { parameters: { filters: { array: { style: 'deepObject' } } } },
+export const platformApiDatalakeControllerMigrate = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDatalakeControllerMigrateData, ThrowOnError>) => (options.client ?? client).post<PlatformApiDatalakeControllerMigrateResponses, PlatformApiDatalakeControllerMigrateErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
         body: v.optional(v.never()),
-        path: vPlatformApiAgenticWorkflowOperationsControllerBatchLogsIndexPath,
-        query: v.optional(vPlatformApiAgenticWorkflowOperationsControllerBatchLogsIndexQuery)
+        path: vPlatformApiDatalakeControllerMigratePath,
+        query: v.optional(v.never())
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAgenticWorkflowOperationsControllerBatchLogsIndexResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDatalakeControllerMigrateResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/agentic-workflows/{workflow_slug}/batch-logs',
+    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/migrate',
     ...options
 });
 
 /**
- * Create and execute a SQL search for a dataset
+ * Verify current session
  *
- * Creates a `UserSearch` row, runs `INSERT INTO search_results SELECT ... WHERE <search_query>` against the regulated schema, and returns the `UserSearch` resource (including `status`, `results_count`, and `error_message`). The session's `data_access_mode` controls which schema is queried.
- */
-export const platformApiDatasetControllerCreateUserSearch = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDatasetControllerCreateUserSearchData, ThrowOnError>) => (options.client ?? client).post<PlatformApiDatasetControllerCreateUserSearchResponses, PlatformApiDatasetControllerCreateUserSearchErrors, ThrowOnError>({
-    requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: v.optional(vPlatformApiDatasetControllerCreateUserSearchBody),
-        path: vPlatformApiDatasetControllerCreateUserSearchPath,
-        query: v.optional(vPlatformApiDatasetControllerCreateUserSearchQuery)
-    }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDatasetControllerCreateUserSearchResponse, data),
-    security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/datasets/{dataset}/user-searches',
-    ...options,
-    headers: {
-        'Content-Type': 'application/json',
-        ...options.headers
-    }
-});
-
-/**
- * Page results from a UserSearch — outer SQL chunk + inner resource Flop
+ * Returns the current session's tenant, role, and identity information.
  *
- * Two-tier pagination at two layers:
+ * Works with both authentication methods:
+ * - `X-API-Key` header (M2M)
+ * - `Authorization: Bearer <session_token>` (human sessions)
  *
- * * **Outer** — `outer_pagination[page]` / `outer_pagination[page_size]`
- * (defaults `1` / `1000`, max `1000`) pages cached IDs from
- * `search_results`. The cap is dictated by Postgres' `WHERE id IN (^ids)`
- * plan — past ~1k parameters the planner regresses.
- * * **Inner** — `inner_search[page]`, `inner_search[page_size]` (defaults
- * `1` / `20`), `inner_search[order_direction]` (sort on the schema's
- * `:global_search` compound), `inner_search[global_search]` (single
- * ILIKE-OR text-search knob).
+ * Use this as a "who am I" endpoint to confirm credentials are valid and
+ * inspect the resolved tenant, role, and identity.
  *
- * Response carries both metas under `meta.sql` and `meta.flop`. A caller
- * that only drives the inner page sees `meta.sql.has_next_page=true` when
- * the SQL search isn't exhausted; advancing `outer_pagination[page]`
- * fetches the next chunk.
+ * **Requires authentication** (X-API-Key or Bearer token).
  *
  */
-export const platformApiDatasetControllerSearch = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDatasetControllerSearchData, ThrowOnError>) => (options.client ?? client).get<PlatformApiDatasetControllerSearchResponses, PlatformApiDatasetControllerSearchErrors, ThrowOnError>({
+export const platformApiSessionControllerVerify = <ThrowOnError extends boolean = false>(options?: Options<PlatformApiSessionControllerVerifyData, ThrowOnError>) => (options?.client ?? client).get<PlatformApiSessionControllerVerifyResponses, PlatformApiSessionControllerVerifyErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
         body: v.optional(v.never()),
-        path: vPlatformApiDatasetControllerSearchPath,
-        query: v.optional(vPlatformApiDatasetControllerSearchQuery)
+        path: v.optional(v.never()),
+        query: v.optional(v.never())
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDatasetControllerSearchResponse, data),
-    security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/datasets/{dataset}/search',
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiSessionControllerVerifyResponse, data),
+    security: [{ name: 'X-API-Key', type: 'apiKey' }, { scheme: 'bearer', type: 'http' }],
+    url: '/api/v1/sessions/verify',
     ...options
 });
 
 /**
- * List workflow execution logs
+ * Download execution context
  *
- * Returns a paginated list of per-event execution logs for a workflow.
+ * Returns a presigned URL for downloading the execution context JSON from R2.
  */
-export const platformApiAgenticWorkflowOperationsControllerWorkflowLogsIndex = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAgenticWorkflowOperationsControllerWorkflowLogsIndexData, ThrowOnError>) => (options.client ?? client).get<PlatformApiAgenticWorkflowOperationsControllerWorkflowLogsIndexResponses, PlatformApiAgenticWorkflowOperationsControllerWorkflowLogsIndexErrors, ThrowOnError>({
-    querySerializer: { parameters: { filters: { array: { style: 'deepObject' } } } },
+export const platformApiAgenticWorkflowOperationsControllerWorkflowLogDownload = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAgenticWorkflowOperationsControllerWorkflowLogDownloadData, ThrowOnError>) => (options.client ?? client).get<PlatformApiAgenticWorkflowOperationsControllerWorkflowLogDownloadResponses, PlatformApiAgenticWorkflowOperationsControllerWorkflowLogDownloadErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
         body: v.optional(v.never()),
-        path: vPlatformApiAgenticWorkflowOperationsControllerWorkflowLogsIndexPath,
-        query: v.optional(vPlatformApiAgenticWorkflowOperationsControllerWorkflowLogsIndexQuery)
+        path: vPlatformApiAgenticWorkflowOperationsControllerWorkflowLogDownloadPath,
+        query: v.optional(v.never())
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAgenticWorkflowOperationsControllerWorkflowLogsIndexResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAgenticWorkflowOperationsControllerWorkflowLogDownloadResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/agentic-workflows/{workflow_slug}/workflow-logs',
+    url: '/api/v1/tenants/{tenant_slug}/agentic-workflows/{workflow_slug}/workflow-logs/{id}/download',
     ...options
 });
 
 /**
- * Invite a user to the tenant
- *
- * Creates a `tenant_admin`-issued invitation. Mirrors the LiveView flow at
- * `/app/team` → "Invite new member". Wraps `Tenants.send_tenant_invitation/3`
- * verbatim, including the email send.
- *
- * The `role` enum is **membership-level** (`member`, `researcher`, `admin`),
- * NOT the platform-wide `User.role` enum — privilege-escalation safe by
- * construction.
- *
- * Requires a tenant-scoped Bearer with membership role `:admin`
- * (`current_role.name == "tenant_admin"`).
+ * Create datalake download link
  *
+ * Returns a presigned GET URL for an object stored in one of the datalake's cloud storage buckets (regulated or unregulated). Typical use: read a `DACRawLogFile.object_key` (`s3://bucket/key`) off a data-activation log row, split it into `bucket` and `key`, then POST here to obtain a short-lived download URL.
  */
-export const platformApiInvitationControllerCreate = <ThrowOnError extends boolean = false>(options: Options<PlatformApiInvitationControllerCreateData, ThrowOnError>) => (options.client ?? client).post<PlatformApiInvitationControllerCreateResponses, PlatformApiInvitationControllerCreateErrors, ThrowOnError>({
+export const platformApiDatalakeControllerCreateDownloadLink = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDatalakeControllerCreateDownloadLinkData, ThrowOnError>) => (options.client ?? client).post<PlatformApiDatalakeControllerCreateDownloadLinkResponses, PlatformApiDatalakeControllerCreateDownloadLinkErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: vPlatformApiInvitationControllerCreateBody,
-        path: vPlatformApiInvitationControllerCreatePath,
+        body: vPlatformApiDatalakeControllerCreateDownloadLinkBody,
+        path: vPlatformApiDatalakeControllerCreateDownloadLinkPath,
         query: v.optional(v.never())
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiInvitationControllerCreateResponse, data),
-    security: [{ scheme: 'bearer', type: 'http' }],
-    url: '/api/v1/tenants/{tenant_slug}/invitations',
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDatalakeControllerCreateDownloadLinkResponse, data),
+    security: [{ name: 'X-API-Key', type: 'apiKey' }],
+    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/download-link',
     ...options,
     headers: {
         'Content-Type': 'application/json',
@@ -235,36 +215,37 @@ export const platformApiInvitationControllerCreate = <ThrowOnError extends boole
 });
 
 /**
- * Get a connected app
+ * Get a datalake
  *
- * Returns a single connected app by ID.
+ * Returns a single datalake by ID (non-sensitive metadata only).
  */
-export const platformApiConnectedAppMgmtControllerShow = <ThrowOnError extends boolean = false>(options: Options<PlatformApiConnectedAppMgmtControllerShowData, ThrowOnError>) => (options.client ?? client).get<PlatformApiConnectedAppMgmtControllerShowResponses, PlatformApiConnectedAppMgmtControllerShowErrors, ThrowOnError>({
+export const platformApiDatalakeControllerShow = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDatalakeControllerShowData, ThrowOnError>) => (options.client ?? client).get<PlatformApiDatalakeControllerShowResponses, PlatformApiDatalakeControllerShowErrors, ThrowOnError>({
+    querySerializer: { parameters: { filters: { array: { style: 'deepObject' } } } },
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
         body: v.optional(v.never()),
-        path: vPlatformApiConnectedAppMgmtControllerShowPath,
-        query: v.optional(v.never())
+        path: vPlatformApiDatalakeControllerShowPath,
+        query: v.optional(vPlatformApiDatalakeControllerShowQuery)
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiConnectedAppMgmtControllerShowResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDatalakeControllerShowResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/connected-apps/{id}',
+    url: '/api/v1/tenants/{tenant_slug}/datalakes/{id}',
     ...options
 });
 
 /**
- * Replace a connected app
+ * Test invoke a tool
  *
- * Replaces a connected app with the full resource body. PUT semantics — all required fields must be present.
+ * Manually invokes a tool with caller-supplied parameters — the API equivalent of the 'Try It' panel in the tool form. Records a `ManualToolInvocation` for audit and returns the provider response (or error). Does not access tenant datasets, so no capability ceiling check is applied.
  */
-export const platformApiConnectedAppMgmtControllerUpdate = <ThrowOnError extends boolean = false>(options: Options<PlatformApiConnectedAppMgmtControllerUpdateData, ThrowOnError>) => (options.client ?? client).put<PlatformApiConnectedAppMgmtControllerUpdateResponses, PlatformApiConnectedAppMgmtControllerUpdateErrors, ThrowOnError>({
+export const platformApiToolControllerTestInvocation = <ThrowOnError extends boolean = false>(options: Options<PlatformApiToolControllerTestInvocationData, ThrowOnError>) => (options.client ?? client).post<PlatformApiToolControllerTestInvocationResponses, PlatformApiToolControllerTestInvocationErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: v.optional(vPlatformApiConnectedAppMgmtControllerUpdateBody),
-        path: vPlatformApiConnectedAppMgmtControllerUpdatePath,
+        body: v.optional(vPlatformApiToolControllerTestInvocationBody),
+        path: vPlatformApiToolControllerTestInvocationPath,
         query: v.optional(v.never())
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiConnectedAppMgmtControllerUpdateResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiToolControllerTestInvocationResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/connected-apps/{id}',
+    url: '/api/v1/tenants/{tenant_slug}/tools/{id}/test-invocation',
     ...options,
     headers: {
         'Content-Type': 'application/json',
@@ -273,60 +254,72 @@ export const platformApiConnectedAppMgmtControllerUpdate = <ThrowOnError extends
 });
 
 /**
- * Verify subject identity
- *
- * Verify a subject's identity against their master record using fuzzy matching.
+ * Get schema metadata for a specific dataset type
  *
- * Supports verification by:
- * - **family_name** — Jaro distance >= 0.85
- * - **given_name** — Jaro distance >= 0.80
- * - **birth_date** — Fuzzy component matching >= 0.80
- * - **identifiers** — Exact (system, value) match
+ * Returns a markdown document describing the fields available on a dataset type. For standard datasets (patient, appointment, etc.) returns the schema moduledoc. For generic tables, pass the generic_table_id query parameter.
+ */
+export const platformApiDatasetControllerDatasetMetadata = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDatasetControllerDatasetMetadataData, ThrowOnError>) => (options.client ?? client).get<PlatformApiDatasetControllerDatasetMetadataResponses, PlatformApiDatasetControllerDatasetMetadataErrors, ThrowOnError>({
+    requestValidator: async (data: unknown) => await v.parseAsync(v.object({
+        body: v.optional(v.never()),
+        path: vPlatformApiDatasetControllerDatasetMetadataPath,
+        query: v.optional(vPlatformApiDatasetControllerDatasetMetadataQuery)
+    }), data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDatasetControllerDatasetMetadataResponse, data),
+    security: [{ name: 'X-API-Key', type: 'apiKey' }],
+    url: '/api/v1/datasets/{dataset_type}/metadata',
+    ...options
+});
+
+/**
+ * List accessible tenants
  *
- * At least one verification field is required.
+ * Returns a paginated list of tenants accessible to the authenticated identity.
  *
- * **Requires X-API-Key authentication.**
+ * - **Bearer token**: returns all tenants the user has membership in.
+ * - **X-API-Key**: returns the single tenant the API key is scoped to.
  *
  */
-export const platformApiMdmControllerVerify = <ThrowOnError extends boolean = false>(options: Options<PlatformApiMdmControllerVerifyData, ThrowOnError>) => (options.client ?? client).post<PlatformApiMdmControllerVerifyResponses, PlatformApiMdmControllerVerifyErrors, ThrowOnError>({
+export const platformApiTenantControllerIndex = <ThrowOnError extends boolean = false>(options?: Options<PlatformApiTenantControllerIndexData, ThrowOnError>) => (options?.client ?? client).get<PlatformApiTenantControllerIndexResponses, PlatformApiTenantControllerIndexErrors, ThrowOnError>({
+    querySerializer: { parameters: { filters: { array: { style: 'deepObject' } } } },
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: vPlatformApiMdmControllerVerifyBody,
-        path: vPlatformApiMdmControllerVerifyPath,
-        query: v.optional(v.never())
+        body: v.optional(v.never()),
+        path: v.optional(v.never()),
+        query: v.optional(vPlatformApiTenantControllerIndexQuery)
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiMdmControllerVerifyResponse, data),
-    security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/mdm/verify',
-    ...options,
-    headers: {
-        'Content-Type': 'application/json',
-        ...options.headers
-    }
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiTenantControllerIndexResponse, data),
+    security: [{ name: 'X-API-Key', type: 'apiKey' }, { scheme: 'bearer', type: 'http' }],
+    url: '/api/v1/tenants',
+    ...options
 });
 
 /**
- * Sign up a new user
+ * Create a tenant
  *
- * Register a new user account. Mirrors the `/auth/register` LiveView form
- * submission shape — wraps `Accounts.register_user/2` verbatim with no
- * business-logic divergence.
+ * Creates a new tenant and an `:admin` membership for the authenticated user.
+ * Wraps `Platform.Tenants.create_tenant/3` verbatim — same primitive that
+ * backs the `/app/tenants/new` LiveView.
  *
- * The created user is **unconfirmed** and has **no tenant memberships**. To
- * obtain a Bearer token, the user must first be confirmed (via the email
- * confirmation flow in production, or via `PUT /api/v1/admin/users/:id/confirm`
- * in test bootstrap), then exchange credentials at `POST /api/v1/sessions`.
+ * On success returns a regular `SessionResponse` carrying a freshly-minted
+ * **tenant-scoped Bearer** (`session_token`), the new tenant, and the
+ * membership role. Callers swap their tenant-less Bearer for this token
+ * and proceed with tenant-scoped work — no second sign-in round-trip.
  *
- * No authentication required — this endpoint is the entry point for new users.
+ * The user must be confirmed (`confirmed_at IS NOT NULL`); unconfirmed
+ * callers receive 403. Duplicate tenant names (slug collision) return 422.
+ *
+ * Requires `Authorization: Bearer <token>` (X-API-Key cannot create tenants —
+ * it carries no platform-user identity to bind the membership to).
  *
  */
-export const platformApiAuthControllerSignUp = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAuthControllerSignUpData, ThrowOnError>) => (options.client ?? client).post<PlatformApiAuthControllerSignUpResponses, PlatformApiAuthControllerSignUpErrors, ThrowOnError>({
+export const platformApiTenantControllerCreate = <ThrowOnError extends boolean = false>(options: Options<PlatformApiTenantControllerCreateData, ThrowOnError>) => (options.client ?? client).post<PlatformApiTenantControllerCreateResponses, PlatformApiTenantControllerCreateErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: vPlatformApiAuthControllerSignUpBody,
+        body: vPlatformApiTenantControllerCreateBody,
         path: v.optional(v.never()),
         query: v.optional(v.never())
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAuthControllerSignUpResponse, data),
-    url: '/api/v1/auth/sign-up',
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiTenantControllerCreateResponse, data),
+    security: [{ name: 'X-API-Key', type: 'apiKey' }, { scheme: 'bearer', type: 'http' }],
+    url: '/api/v1/tenants',
     ...options,
     headers: {
         'Content-Type': 'application/json',
@@ -335,37 +328,37 @@ export const platformApiAuthControllerSignUp = <ThrowOnError extends boolean = f
 });
 
 /**
- * List data activation clients
+ * List generic tables
  *
- * Returns a paginated list of DACs for the datalake in the path.
+ * Returns a paginated list of generic tables for the datalake (custom tables + system tables for the data domain).
  */
-export const platformApiDataActivationClientControllerIndex = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDataActivationClientControllerIndexData, ThrowOnError>) => (options.client ?? client).get<PlatformApiDataActivationClientControllerIndexResponses, PlatformApiDataActivationClientControllerIndexErrors, ThrowOnError>({
+export const platformApiGenericTableControllerIndex = <ThrowOnError extends boolean = false>(options: Options<PlatformApiGenericTableControllerIndexData, ThrowOnError>) => (options.client ?? client).get<PlatformApiGenericTableControllerIndexResponses, PlatformApiGenericTableControllerIndexErrors, ThrowOnError>({
     querySerializer: { parameters: { filters: { array: { style: 'deepObject' } } } },
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
         body: v.optional(v.never()),
-        path: vPlatformApiDataActivationClientControllerIndexPath,
-        query: v.optional(vPlatformApiDataActivationClientControllerIndexQuery)
+        path: vPlatformApiGenericTableControllerIndexPath,
+        query: v.optional(vPlatformApiGenericTableControllerIndexQuery)
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDataActivationClientControllerIndexResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiGenericTableControllerIndexResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/data-activation-clients',
+    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/generic-tables',
     ...options
 });
 
 /**
- * Create a data activation client
+ * Create a generic table
  *
- * Creates a new DAC. `slug` is auto-generated from `name`. `tool_call` is a polymorphic object whose shape depends on the `tool_call_type` discriminator — see `tool_call_type` enum for valid variants (RESTCall, SQLQueryCall, SFTPCall, SharePointExcelCall, AWSLambdaCall, ManualUploadCall, S3Call).
+ * Creates a new custom generic table within the datalake.
  */
-export const platformApiDataActivationClientControllerCreate = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDataActivationClientControllerCreateData, ThrowOnError>) => (options.client ?? client).post<PlatformApiDataActivationClientControllerCreateResponses, PlatformApiDataActivationClientControllerCreateErrors, ThrowOnError>({
+export const platformApiGenericTableControllerCreate = <ThrowOnError extends boolean = false>(options: Options<PlatformApiGenericTableControllerCreateData, ThrowOnError>) => (options.client ?? client).post<PlatformApiGenericTableControllerCreateResponses, PlatformApiGenericTableControllerCreateErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: v.optional(vPlatformApiDataActivationClientControllerCreateBody),
-        path: vPlatformApiDataActivationClientControllerCreatePath,
+        body: v.optional(vPlatformApiGenericTableControllerCreateBody),
+        path: vPlatformApiGenericTableControllerCreatePath,
         query: v.optional(v.never())
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDataActivationClientControllerCreateResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiGenericTableControllerCreateResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/data-activation-clients',
+    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/generic-tables',
     ...options,
     headers: {
         'Content-Type': 'application/json',
@@ -374,109 +367,146 @@ export const platformApiDataActivationClientControllerCreate = <ThrowOnError ext
 });
 
 /**
- * Sync routes
+ * List the authenticated user's pending invitations
+ *
+ * Returns invitations addressed to the authenticated user that have not
+ * yet been accepted. Mirrors the LiveView at `/app/users/tenant-invitations`
+ * that recipients see after sign-in. Wraps `Tenants.list_invitations_by_user/1`
+ * verbatim — always filtered to the current user, never accepts a query
+ * parameter that could leak another user's invitations.
+ *
+ * Requires any Bearer (tenant-less is fine — recipients typically don't
+ * have tenant scope yet at this point in the bootstrap flow).
  *
- * Enqueues a background job to fetch routes from the connected app's `/.well-known/routes.json` endpoint and update the stored routes.
  */
-export const platformApiConnectedAppMgmtControllerSyncRoutes = <ThrowOnError extends boolean = false>(options: Options<PlatformApiConnectedAppMgmtControllerSyncRoutesData, ThrowOnError>) => (options.client ?? client).post<PlatformApiConnectedAppMgmtControllerSyncRoutesResponses, PlatformApiConnectedAppMgmtControllerSyncRoutesErrors, ThrowOnError>({
+export const platformApiInvitationControllerIndex = <ThrowOnError extends boolean = false>(options?: Options<PlatformApiInvitationControllerIndexData, ThrowOnError>) => (options?.client ?? client).get<PlatformApiInvitationControllerIndexResponses, PlatformApiInvitationControllerIndexErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
         body: v.optional(v.never()),
-        path: vPlatformApiConnectedAppMgmtControllerSyncRoutesPath,
+        path: v.optional(v.never()),
         query: v.optional(v.never())
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiConnectedAppMgmtControllerSyncRoutesResponse, data),
-    security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/connected-apps/{id}/sync-routes',
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiInvitationControllerIndexResponse, data),
+    security: [{ scheme: 'bearer', type: 'http' }],
+    url: '/api/v1/invitations',
     ...options
 });
 
 /**
- * Health check
- *
- * Public health check endpoint that returns:
- * - Application version
- * - Database connectivity status (SELECT 1 query)
- * - Current timestamp
- *
- * **No authentication required.**
+ * List interoperability contracts
  *
+ * Returns a paginated list of contracts scoped to the datalake.
  */
-export const platformApiPingControllerPing = <ThrowOnError extends boolean = false>(options?: Options<PlatformApiPingControllerPingData, ThrowOnError>) => (options?.client ?? client).get<PlatformApiPingControllerPingResponses, PlatformApiPingControllerPingErrors, ThrowOnError>({
+export const platformApiInteroperabilityContractControllerIndex = <ThrowOnError extends boolean = false>(options: Options<PlatformApiInteroperabilityContractControllerIndexData, ThrowOnError>) => (options.client ?? client).get<PlatformApiInteroperabilityContractControllerIndexResponses, PlatformApiInteroperabilityContractControllerIndexErrors, ThrowOnError>({
+    querySerializer: { parameters: { filters: { array: { style: 'deepObject' } } } },
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
         body: v.optional(v.never()),
-        path: v.optional(v.never()),
-        query: v.optional(v.never())
+        path: vPlatformApiInteroperabilityContractControllerIndexPath,
+        query: v.optional(vPlatformApiInteroperabilityContractControllerIndexQuery)
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiPingControllerPingResponse, data),
-    url: '/api/ping',
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiInteroperabilityContractControllerIndexResponse, data),
+    security: [{ name: 'X-API-Key', type: 'apiKey' }],
+    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/interoperability-contracts',
     ...options
 });
 
 /**
- * Get workflow metadata
+ * Create an interoperability contract
  *
- * Returns a markdown document describing the workflow's variable pipeline — available variables at each node (event dataset, MDM, context datasets, enrichment, filter, decision, actions).
+ * Creates a new contract. `slug` is auto-generated from `name` on insert.
  */
-export const platformApiAgenticWorkflowControllerMetadata = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAgenticWorkflowControllerMetadataData, ThrowOnError>) => (options.client ?? client).get<PlatformApiAgenticWorkflowControllerMetadataResponses, PlatformApiAgenticWorkflowControllerMetadataErrors, ThrowOnError>({
+export const platformApiInteroperabilityContractControllerCreate = <ThrowOnError extends boolean = false>(options: Options<PlatformApiInteroperabilityContractControllerCreateData, ThrowOnError>) => (options.client ?? client).post<PlatformApiInteroperabilityContractControllerCreateResponses, PlatformApiInteroperabilityContractControllerCreateErrors, ThrowOnError>({
+    querySerializer: { parameters: { filters: { array: { style: 'deepObject' } } } },
+    requestValidator: async (data: unknown) => await v.parseAsync(v.object({
+        body: v.optional(vPlatformApiInteroperabilityContractControllerCreateBody),
+        path: vPlatformApiInteroperabilityContractControllerCreatePath,
+        query: v.optional(vPlatformApiInteroperabilityContractControllerCreateQuery)
+    }), data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiInteroperabilityContractControllerCreateResponse, data),
+    security: [{ name: 'X-API-Key', type: 'apiKey' }],
+    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/interoperability-contracts',
+    ...options,
+    headers: {
+        'Content-Type': 'application/json',
+        ...options.headers
+    }
+});
+
+/**
+ * Get contract field metadata
+ *
+ * Returns a markdown document describing the fields of the contract's target resource type. Combines `@moduledoc` (resource description) and `@typedoc` (field definitions) from the schema.
+ */
+export const platformApiInteroperabilityContractControllerMetadata = <ThrowOnError extends boolean = false>(options: Options<PlatformApiInteroperabilityContractControllerMetadataData, ThrowOnError>) => (options.client ?? client).get<PlatformApiInteroperabilityContractControllerMetadataResponses, PlatformApiInteroperabilityContractControllerMetadataErrors, ThrowOnError>({
+    querySerializer: { parameters: { filters: { array: { style: 'deepObject' } } } },
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
         body: v.optional(v.never()),
-        path: vPlatformApiAgenticWorkflowControllerMetadataPath,
-        query: v.optional(v.never())
+        path: vPlatformApiInteroperabilityContractControllerMetadataPath,
+        query: v.optional(vPlatformApiInteroperabilityContractControllerMetadataQuery)
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAgenticWorkflowControllerMetadataResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiInteroperabilityContractControllerMetadataResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/agentic-workflows/{id}/metadata',
+    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/interoperability-contracts/{slug}/metadata',
     ...options
 });
 
 /**
- * Delete a tool
+ * Get a batch run log
  *
- * Deletes a tool. Returns 409 if the tool is referenced by another resource.
+ * Returns a single batch-level workflow run log with merged artifacts.
  */
-export const platformApiToolControllerDelete = <ThrowOnError extends boolean = false>(options: Options<PlatformApiToolControllerDeleteData, ThrowOnError>) => (options.client ?? client).delete<PlatformApiToolControllerDeleteResponses, PlatformApiToolControllerDeleteErrors, ThrowOnError>({
+export const platformApiAgenticWorkflowOperationsControllerBatchLogShow = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAgenticWorkflowOperationsControllerBatchLogShowData, ThrowOnError>) => (options.client ?? client).get<PlatformApiAgenticWorkflowOperationsControllerBatchLogShowResponses, PlatformApiAgenticWorkflowOperationsControllerBatchLogShowErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
         body: v.optional(v.never()),
-        path: vPlatformApiToolControllerDeletePath,
+        path: vPlatformApiAgenticWorkflowOperationsControllerBatchLogShowPath,
         query: v.optional(v.never())
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiToolControllerDeleteResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAgenticWorkflowOperationsControllerBatchLogShowResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/tools/{id}',
+    url: '/api/v1/tenants/{tenant_slug}/agentic-workflows/{workflow_slug}/batch-logs/{id}',
     ...options
 });
 
 /**
- * Get a tool
+ * Accept a tenant invitation
+ *
+ * Accepts a pending invitation addressed to the authenticated user, creating
+ * a `Membership` and deleting the invitation. Mirrors the LiveView flow at
+ * `/app/users/tenant-invitations` → "Accept" button. Wraps
+ * `Tenants.accept_invitation!/2` verbatim.
+ *
+ * The function-level guard `get_invitation_by_user!/2` ensures the invitation
+ * is addressed to the caller — cross-user acceptance returns 404.
+ *
+ * Requires any Bearer (the recipient often has only a tenant-less Bearer at
+ * this point — they just signed up and haven't joined a tenant yet).
  *
- * Returns a single tool by ID.
  */
-export const platformApiToolControllerShow = <ThrowOnError extends boolean = false>(options: Options<PlatformApiToolControllerShowData, ThrowOnError>) => (options.client ?? client).get<PlatformApiToolControllerShowResponses, PlatformApiToolControllerShowErrors, ThrowOnError>({
+export const platformApiInvitationControllerAccept = <ThrowOnError extends boolean = false>(options: Options<PlatformApiInvitationControllerAcceptData, ThrowOnError>) => (options.client ?? client).post<PlatformApiInvitationControllerAcceptResponses, PlatformApiInvitationControllerAcceptErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
         body: v.optional(v.never()),
-        path: vPlatformApiToolControllerShowPath,
+        path: vPlatformApiInvitationControllerAcceptPath,
         query: v.optional(v.never())
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiToolControllerShowResponse, data),
-    security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/tools/{id}',
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiInvitationControllerAcceptResponse, data),
+    security: [{ scheme: 'bearer', type: 'http' }],
+    url: '/api/v1/invitations/{id}/accept',
     ...options
 });
 
 /**
- * Replace a tool
+ * Execute an individual action for a dataset record
  *
- * Replaces a tool with the full resource body. PUT semantics — all required fields must be present.
+ * Executes a single workflow action identified by decision_key for the given dataset record, bypassing filter and decision evaluation
  */
-export const platformApiToolControllerUpdate = <ThrowOnError extends boolean = false>(options: Options<PlatformApiToolControllerUpdateData, ThrowOnError>) => (options.client ?? client).put<PlatformApiToolControllerUpdateResponses, PlatformApiToolControllerUpdateErrors, ThrowOnError>({
+export const platformApiAgenticWorkflowOperationsControllerExecute = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAgenticWorkflowOperationsControllerExecuteData, ThrowOnError>) => (options.client ?? client).post<PlatformApiAgenticWorkflowOperationsControllerExecuteResponses, PlatformApiAgenticWorkflowOperationsControllerExecuteErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: v.optional(vPlatformApiToolControllerUpdateBody),
-        path: vPlatformApiToolControllerUpdatePath,
+        body: vPlatformApiAgenticWorkflowOperationsControllerExecuteBody,
+        path: vPlatformApiAgenticWorkflowOperationsControllerExecutePath,
         query: v.optional(v.never())
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiToolControllerUpdateResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAgenticWorkflowOperationsControllerExecuteResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/tools/{id}',
+    url: '/api/v1/tenants/{tenant_slug}/agentic-workflows/{workflow_slug}/execute',
     ...options,
     headers: {
         'Content-Type': 'application/json',
@@ -485,89 +515,99 @@ export const platformApiToolControllerUpdate = <ThrowOnError extends boolean = f
 });
 
 /**
- * List processing logs for a Data Activation Client
+ * Create datalake upload link
  *
- * Returns a Flop-paginated list of `DataActivationLog` rows for this DAC. One log per `(batch_id, dataset_table)` — a single run produces multiple log rows, one per dataset table the DAC writes into. Filter or group client-side on `batch_id` to reconstruct a batch-level view.
+ * Returns a presigned PUT URL for uploading a file (NDJSON or CSV) directly to the datalake's regulated cloud storage. The returned key lives under `uploads/<datalake_id>/` and can be passed to downstream endpoints (e.g. data activation client ingest-file) that accept a pre-uploaded storage key.
  */
-export const platformApiDataActivationClientControllerLogsIndex = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDataActivationClientControllerLogsIndexData, ThrowOnError>) => (options.client ?? client).get<PlatformApiDataActivationClientControllerLogsIndexResponses, PlatformApiDataActivationClientControllerLogsIndexErrors, ThrowOnError>({
+export const platformApiDatalakeControllerCreateUploadLink = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDatalakeControllerCreateUploadLinkData, ThrowOnError>) => (options.client ?? client).post<PlatformApiDatalakeControllerCreateUploadLinkResponses, PlatformApiDatalakeControllerCreateUploadLinkErrors, ThrowOnError>({
     querySerializer: { parameters: { filters: { array: { style: 'deepObject' } } } },
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: v.optional(v.never()),
-        path: vPlatformApiDataActivationClientControllerLogsIndexPath,
-        query: v.optional(vPlatformApiDataActivationClientControllerLogsIndexQuery)
+        body: vPlatformApiDatalakeControllerCreateUploadLinkBody,
+        path: vPlatformApiDatalakeControllerCreateUploadLinkPath,
+        query: v.optional(vPlatformApiDatalakeControllerCreateUploadLinkQuery)
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDataActivationClientControllerLogsIndexResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDatalakeControllerCreateUploadLinkResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/data-activation-clients/{slug}/logs',
-    ...options
-});
-
-/**
- * Stop refresh polling for a batch run log
+    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/upload-link',
+    ...options,
+    headers: {
+        'Content-Type': 'application/json',
+        ...options.headers
+    }
+});
+
+/**
+ * List datalakes
  *
- * Deletes the DynamicCron job that polls this batch. The batch log is NOT deleted.
+ * Returns a paginated list of datalakes for the authenticated tenant.
  */
-export const platformApiAgenticWorkflowOperationsControllerBatchLogStop = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAgenticWorkflowOperationsControllerBatchLogStopData, ThrowOnError>) => (options.client ?? client).post<PlatformApiAgenticWorkflowOperationsControllerBatchLogStopResponses, PlatformApiAgenticWorkflowOperationsControllerBatchLogStopErrors, ThrowOnError>({
+export const platformApiDatalakeControllerIndex = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDatalakeControllerIndexData, ThrowOnError>) => (options.client ?? client).get<PlatformApiDatalakeControllerIndexResponses, PlatformApiDatalakeControllerIndexErrors, ThrowOnError>({
+    querySerializer: { parameters: { filters: { array: { style: 'deepObject' } } } },
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
         body: v.optional(v.never()),
-        path: vPlatformApiAgenticWorkflowOperationsControllerBatchLogStopPath,
-        query: v.optional(v.never())
+        path: vPlatformApiDatalakeControllerIndexPath,
+        query: v.optional(vPlatformApiDatalakeControllerIndexQuery)
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAgenticWorkflowOperationsControllerBatchLogStopResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDatalakeControllerIndexResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/agentic-workflows/{workflow_slug}/batch-logs/{id}/stop',
+    url: '/api/v1/tenants/{tenant_slug}/datalakes',
     ...options
 });
 
 /**
- * Get DAC dataset metadata
+ * Create a datalake
  *
- * Returns a markdown document describing the fields of each dataset connected to this data activation client via its interoperability contracts.
+ * Creates a new datalake for the authenticated tenant.
  */
-export const platformApiDataActivationClientControllerMetadata = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDataActivationClientControllerMetadataData, ThrowOnError>) => (options.client ?? client).get<PlatformApiDataActivationClientControllerMetadataResponses, PlatformApiDataActivationClientControllerMetadataErrors, ThrowOnError>({
+export const platformApiDatalakeControllerCreate = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDatalakeControllerCreateData, ThrowOnError>) => (options.client ?? client).post<PlatformApiDatalakeControllerCreateResponses, PlatformApiDatalakeControllerCreateErrors, ThrowOnError>({
+    querySerializer: { parameters: { filters: { array: { style: 'deepObject' } } } },
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: v.optional(v.never()),
-        path: vPlatformApiDataActivationClientControllerMetadataPath,
-        query: v.optional(v.never())
+        body: v.optional(vPlatformApiDatalakeControllerCreateBody),
+        path: vPlatformApiDatalakeControllerCreatePath,
+        query: v.optional(vPlatformApiDatalakeControllerCreateQuery)
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDataActivationClientControllerMetadataResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDatalakeControllerCreateResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/data-activation-clients/{slug}/metadata',
-    ...options
+    url: '/api/v1/tenants/{tenant_slug}/datalakes',
+    ...options,
+    headers: {
+        'Content-Type': 'application/json',
+        ...options.headers
+    }
 });
 
 /**
- * List agentic workflows
+ * Show a single DAC processing log
  *
- * Returns a paginated list of workflows for a datalake.
+ * Returns a single `DataActivationLog` row scoped to this DAC. Returns 404 if the id belongs to a different client.
  */
-export const platformApiAgenticWorkflowControllerIndex = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAgenticWorkflowControllerIndexData, ThrowOnError>) => (options.client ?? client).get<PlatformApiAgenticWorkflowControllerIndexResponses, PlatformApiAgenticWorkflowControllerIndexErrors, ThrowOnError>({
-    querySerializer: { parameters: { filters: { array: { style: 'deepObject' } } } },
+export const platformApiDataActivationClientControllerLogShow = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDataActivationClientControllerLogShowData, ThrowOnError>) => (options.client ?? client).get<PlatformApiDataActivationClientControllerLogShowResponses, PlatformApiDataActivationClientControllerLogShowErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
         body: v.optional(v.never()),
-        path: vPlatformApiAgenticWorkflowControllerIndexPath,
-        query: v.optional(vPlatformApiAgenticWorkflowControllerIndexQuery)
+        path: vPlatformApiDataActivationClientControllerLogShowPath,
+        query: v.optional(v.never())
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAgenticWorkflowControllerIndexResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDataActivationClientControllerLogShowResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/agentic-workflows',
+    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/data-activation-clients/{slug}/logs/{id}',
     ...options
 });
 
 /**
- * Create an agentic workflow
+ * Replace a data source
  *
- * Creates a new workflow. Attach AI agents via the `ai_agents` array.
+ * Replaces a data source with the full resource body. PUT semantics — all required fields must be present.
  */
-export const platformApiAgenticWorkflowControllerCreate = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAgenticWorkflowControllerCreateData, ThrowOnError>) => (options.client ?? client).post<PlatformApiAgenticWorkflowControllerCreateResponses, PlatformApiAgenticWorkflowControllerCreateErrors, ThrowOnError>({
+export const platformApiDataSourceControllerUpdate = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDataSourceControllerUpdateData, ThrowOnError>) => (options.client ?? client).put<PlatformApiDataSourceControllerUpdateResponses, PlatformApiDataSourceControllerUpdateErrors, ThrowOnError>({
+    querySerializer: { parameters: { filters: { array: { style: 'deepObject' } } } },
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: v.optional(vPlatformApiAgenticWorkflowControllerCreateBody),
-        path: vPlatformApiAgenticWorkflowControllerCreatePath,
-        query: v.optional(v.never())
+        body: v.optional(vPlatformApiDataSourceControllerUpdateBody),
+        path: vPlatformApiDataSourceControllerUpdatePath,
+        query: v.optional(vPlatformApiDataSourceControllerUpdateQuery)
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAgenticWorkflowControllerCreateResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDataSourceControllerUpdateResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/agentic-workflows',
+    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/data-sources/{id}',
     ...options,
     headers: {
         'Content-Type': 'application/json',
@@ -576,105 +616,114 @@ export const platformApiAgenticWorkflowControllerCreate = <ThrowOnError extends
 });
 
 /**
- * Update message tracking fields for a page
- *
- * Updates tracking timestamps (opened_at, form_submitted_at) on the message
- * linked to a page token. Called by the connected app when a user opens a page
- * or submits a form.
- *
- * **Requires X-API-Key authentication.**
+ * Delete an agentic workflow
  *
+ * Deletes a workflow and all associated actions, context datasets, and AI agent attachments.
  */
-export const platformApiConnectedAppControllerUpdateMessageTracking = <ThrowOnError extends boolean = false>(options: Options<PlatformApiConnectedAppControllerUpdateMessageTrackingData, ThrowOnError>) => (options.client ?? client).patch<PlatformApiConnectedAppControllerUpdateMessageTrackingResponses, PlatformApiConnectedAppControllerUpdateMessageTrackingErrors, ThrowOnError>({
+export const platformApiAgenticWorkflowControllerDelete = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAgenticWorkflowControllerDeleteData, ThrowOnError>) => (options.client ?? client).delete<PlatformApiAgenticWorkflowControllerDeleteResponses, PlatformApiAgenticWorkflowControllerDeleteErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: vPlatformApiConnectedAppControllerUpdateMessageTrackingBody,
-        path: vPlatformApiConnectedAppControllerUpdateMessageTrackingPath,
+        body: v.optional(v.never()),
+        path: vPlatformApiAgenticWorkflowControllerDeletePath,
         query: v.optional(v.never())
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiConnectedAppControllerUpdateMessageTrackingResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAgenticWorkflowControllerDeleteResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/connected-apps/{slug}/update-message-tracking',
-    ...options,
-    headers: {
-        'Content-Type': 'application/json',
-        ...options.headers
-    }
+    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/agentic-workflows/{id}',
+    ...options
 });
 
 /**
- * Start or restart refresh polling for a batch run log
+ * Get an agentic workflow
  *
- * Creates a DynamicCron job to poll this batch. Idempotent — if cron already exists, it's a no-op.
+ * Returns a single workflow by ID with nested AI agents.
  */
-export const platformApiAgenticWorkflowOperationsControllerBatchLogStart = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAgenticWorkflowOperationsControllerBatchLogStartData, ThrowOnError>) => (options.client ?? client).post<PlatformApiAgenticWorkflowOperationsControllerBatchLogStartResponses, PlatformApiAgenticWorkflowOperationsControllerBatchLogStartErrors, ThrowOnError>({
+export const platformApiAgenticWorkflowControllerShow = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAgenticWorkflowControllerShowData, ThrowOnError>) => (options.client ?? client).get<PlatformApiAgenticWorkflowControllerShowResponses, PlatformApiAgenticWorkflowControllerShowErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
         body: v.optional(v.never()),
-        path: vPlatformApiAgenticWorkflowOperationsControllerBatchLogStartPath,
+        path: vPlatformApiAgenticWorkflowControllerShowPath,
         query: v.optional(v.never())
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAgenticWorkflowOperationsControllerBatchLogStartResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAgenticWorkflowControllerShowResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/agentic-workflows/{workflow_slug}/batch-logs/{id}/start',
+    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/agentic-workflows/{id}',
     ...options
 });
 
 /**
- * Revoke current session
- *
- * Revokes the current Bearer session — deactivates the session and deletes
- * the linked UserToken. The Bearer token becomes immediately invalid.
- *
- * Only works with `Authorization: Bearer <session_token>` (not X-API-Key).
- *
- * **Requires Bearer authentication.**
+ * Replace an agentic workflow
  *
+ * Replaces a workflow with the full resource body. PUT semantics — all required fields must be present. The `ai_agents` array replaces the current set of attached agents transactionally.
  */
-export const platformApiSessionControllerDelete = <ThrowOnError extends boolean = false>(options?: Options<PlatformApiSessionControllerDeleteData, ThrowOnError>) => (options?.client ?? client).delete<PlatformApiSessionControllerDeleteResponses, PlatformApiSessionControllerDeleteErrors, ThrowOnError>({
+export const platformApiAgenticWorkflowControllerUpdate = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAgenticWorkflowControllerUpdateData, ThrowOnError>) => (options.client ?? client).put<PlatformApiAgenticWorkflowControllerUpdateResponses, PlatformApiAgenticWorkflowControllerUpdateErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: v.optional(v.never()),
-        path: v.optional(v.never()),
+        body: v.optional(vPlatformApiAgenticWorkflowControllerUpdateBody),
+        path: vPlatformApiAgenticWorkflowControllerUpdatePath,
         query: v.optional(v.never())
     }), data),
-    security: [{ scheme: 'bearer', type: 'http' }],
-    url: '/api/v1/sessions',
-    ...options
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAgenticWorkflowControllerUpdateResponse, data),
+    security: [{ name: 'X-API-Key', type: 'apiKey' }],
+    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/agentic-workflows/{id}',
+    ...options,
+    headers: {
+        'Content-Type': 'application/json',
+        ...options.headers
+    }
 });
 
 /**
- * Create a session (human auth)
+ * Run workflow for matching records
  *
- * Exchange user credentials for a Bearer session token.
+ * Executes the workflow for all dataset records matching the SQL WHERE clause.
+ * Creates sampled events and enqueues run_workflow jobs. Returns the batch ID
+ * and enqueued count. A WorkflowRunLog is created to track batch-level
+ * progress, polled by a daily DynamicCron.
  *
- * Send `{email, password}` (with optional `tenant_slug`) to authenticate a
- * human user and receive a session token. Use the returned `session_token`
- * as `Authorization: Bearer <session_token>` on subsequent API requests.
+ * ## Per-step artifacts (audit trail)
  *
- * When `tenant_slug` is **omitted**, returns a tenant-less Bearer for
- * pre-tenant flows: admin operations under `/api/v1/admin/...` and creating
- * your first tenant via `POST /api/v1/tenants`. Tenant-scoped routes will
- * reject such tokens with 403.
+ * Each per-row WorkflowExecutionLog (WEL) writes a fixed set of JSON
+ * artifacts to the datalake's regulated cloud-storage bucket. The path is
+ * deterministic and convention-driven — there is no separate listing
+ * endpoint:
  *
- * When `tenant_slug` is **provided**, returns a tenant-scoped Bearer with
- * the caller's membership role (or 401 if the user has no membership in
- * that tenant).
+ * workflows/{workflow_id}/executions/{wel_id}/event.json
+ * workflows/{workflow_id}/executions/{wel_id}/filter.json
+ * workflows/{workflow_id}/executions/{wel_id}/enrichment.json
+ * workflows/{workflow_id}/executions/{wel_id}/error.json   # only on failure
  *
- * Optionally specify `expires_in` (seconds) to control session duration.
- * Default: 86400 (24 hours). Maximum: 2592000 (30 days).
+ * | File              | Written by stage                       | Body                                                               |
+ * | ----------------- | -------------------------------------- | ------------------------------------------------------------------ |
+ * | `event.json`      | context build                          | full WorkflowContext (event_dataset, mdm_output, additional_context)|
+ * | `filter.json`     | filter eval (both pass and reject)     | `{filter_expression, filter_result: bool}`                         |
+ * | `enrichment.json` | enrichment terminal (success / skip / fail) | `{status: "completed" \| "failed" \| "skipped", <agent_slug>: ...}` |
+ * | `error.json`      | ANY pipeline failure                   | `{stage, error_code, ai_agent_slug, error_message, detail}`        |
  *
- * For M2M (server-to-server) authentication, use `X-API-Key` header directly
- * on each request instead — no session exchange needed.
+ * `error.json`'s presence IS the failure signal — `WEL.error_message`
+ * carries only a code-grade summary; the rich URL/HTTP-status/transport
+ * detail lives ONLY in `error.json["detail"]`. Engineers debugging a
+ * failed run should download `error.json` for full context.
  *
- * **No authentication required** — this endpoint authenticates the caller.
+ * ### Fetching an artifact
+ *
+ * Use the standard datalake download-link endpoint
+ * (`POST /api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/download-link`)
+ * with `bucket = <regulated bucket>` and the convention key above. Example:
+ *
+ * POST /api/v1/tenants/acme/datalakes/clinical/download-link
+ * { "bucket": "clinical-regulated", "key": "workflows/<wf_id>/executions/<wel_id>/error.json" }
+ *
+ * The response carries a short-lived signed URL. The regulated bucket is
+ * exposed on the datalake response as `regulated_cloud_storage.bucket`.
  *
  */
-export const platformApiSessionControllerCreate = <ThrowOnError extends boolean = false>(options: Options<PlatformApiSessionControllerCreateData, ThrowOnError>) => (options.client ?? client).post<PlatformApiSessionControllerCreateResponses, PlatformApiSessionControllerCreateErrors, ThrowOnError>({
+export const platformApiAgenticWorkflowOperationsControllerRunWorkflow = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAgenticWorkflowOperationsControllerRunWorkflowData, ThrowOnError>) => (options.client ?? client).post<PlatformApiAgenticWorkflowOperationsControllerRunWorkflowResponses, PlatformApiAgenticWorkflowOperationsControllerRunWorkflowErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: vPlatformApiSessionControllerCreateBody,
-        path: v.optional(v.never()),
+        body: vPlatformApiAgenticWorkflowOperationsControllerRunWorkflowBody,
+        path: vPlatformApiAgenticWorkflowOperationsControllerRunWorkflowPath,
         query: v.optional(v.never())
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiSessionControllerCreateResponse, data),
-    url: '/api/v1/sessions',
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAgenticWorkflowOperationsControllerRunWorkflowResponse, data),
+    security: [{ name: 'X-API-Key', type: 'apiKey' }],
+    url: '/api/v1/tenants/{tenant_slug}/agentic-workflows/{workflow_slug}/run-workflow',
     ...options,
     headers: {
         'Content-Type': 'application/json',
@@ -683,122 +732,76 @@ export const platformApiSessionControllerCreate = <ThrowOnError extends boolean
 });
 
 /**
- * List connected apps
+ * Force-refresh a batch run log
  *
- * Returns a paginated list of connected apps for the authenticated tenant.
+ * Triggers an immediate refresh of the batch run log metrics and merged artifacts.
  */
-export const platformApiConnectedAppMgmtControllerIndex = <ThrowOnError extends boolean = false>(options: Options<PlatformApiConnectedAppMgmtControllerIndexData, ThrowOnError>) => (options.client ?? client).get<PlatformApiConnectedAppMgmtControllerIndexResponses, PlatformApiConnectedAppMgmtControllerIndexErrors, ThrowOnError>({
-    querySerializer: { parameters: { filters: { array: { style: 'deepObject' } } } },
+export const platformApiAgenticWorkflowOperationsControllerBatchLogRefresh = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAgenticWorkflowOperationsControllerBatchLogRefreshData, ThrowOnError>) => (options.client ?? client).post<PlatformApiAgenticWorkflowOperationsControllerBatchLogRefreshResponses, PlatformApiAgenticWorkflowOperationsControllerBatchLogRefreshErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
         body: v.optional(v.never()),
-        path: vPlatformApiConnectedAppMgmtControllerIndexPath,
-        query: v.optional(vPlatformApiConnectedAppMgmtControllerIndexQuery)
+        path: vPlatformApiAgenticWorkflowOperationsControllerBatchLogRefreshPath,
+        query: v.optional(v.never())
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiConnectedAppMgmtControllerIndexResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAgenticWorkflowOperationsControllerBatchLogRefreshResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/connected-apps',
+    url: '/api/v1/tenants/{tenant_slug}/agentic-workflows/{workflow_slug}/batch-logs/{id}/refresh',
     ...options
 });
 
 /**
- * Create a connected app
+ * Ingest JSON data
  *
- * Creates a new connected app with automatic API key provisioning.
- */
-export const platformApiConnectedAppMgmtControllerCreate = <ThrowOnError extends boolean = false>(options: Options<PlatformApiConnectedAppMgmtControllerCreateData, ThrowOnError>) => (options.client ?? client).post<PlatformApiConnectedAppMgmtControllerCreateResponses, PlatformApiConnectedAppMgmtControllerCreateErrors, ThrowOnError>({
-    requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: v.optional(vPlatformApiConnectedAppMgmtControllerCreateBody),
-        path: vPlatformApiConnectedAppMgmtControllerCreatePath,
-        query: v.optional(v.never())
-    }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiConnectedAppMgmtControllerCreateResponse, data),
-    security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/connected-apps',
-    ...options,
-    headers: {
-        'Content-Type': 'application/json',
-        ...options.headers
-    }
-});
-
-/**
- * Confirm a user (admin bypass)
+ * Ingest a single JSON record for processing through the data activation
+ * pipeline. Returns immediately with `{batch_id, key, jobs_count}`; per-row
+ * work runs asynchronously on the data-activation Oban queue.
  *
- * Marks a user account as confirmed without requiring an email-confirmation
- * token. Idempotent — confirming an already-confirmed user is a 200 no-op
- * that returns the existing `confirmed_at` timestamp.
+ * ## Per-batch artifacts (audit trail)
  *
- * Wraps `Accounts.confirm_user!/1` verbatim — exactly the primitive that
- * backs the dev/admin email-confirm path in the LiveView UI. **Zero new
- * business logic.**
+ * The DAC pipeline does NOT use the `<step>.json` convention that workflows
+ * do — its byproducts are NDJSON archives, surfaced on the
+ * `DataActivationLog` row that the batch produces:
  *
- * Powerful primitive: bypasses the regular email-confirmation flow. Every
- * successful call is structured-logged with `caller_user_id` and
- * `target_user_id` for forensic trail.
+ * | Field           | Bucket       | Body                                                                                     |
+ * | --------------- | ------------ | ---------------------------------------------------------------------------------------- |
+ * | `key` (response)| regulated    | the raw JSON payload uploaded by THIS request                                            |
+ * | `input_files`   | regulated    | source artifacts consumed by the batch (one per ingest call merged into the batch)       |
+ * | `output_files`  | mixed        | merged NDJSON archives, one `{object_key, mode}` per bucket (`regulated` + `unregulated`)|
  *
- * **Requires platform-admin authentication** (`User.role == :admin`).
+ * ### Fetching diagnostic artifacts
  *
- */
-export const platformApiAdminControllerConfirmUser = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAdminControllerConfirmUserData, ThrowOnError>) => (options.client ?? client).put<PlatformApiAdminControllerConfirmUserResponses, PlatformApiAdminControllerConfirmUserErrors, ThrowOnError>({
-    requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: v.optional(v.never()),
-        path: vPlatformApiAdminControllerConfirmUserPath,
-        query: v.optional(v.never())
-    }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAdminControllerConfirmUserResponse, data),
-    security: [{ scheme: 'bearer', type: 'http' }],
-    url: '/api/v1/admin/users/{id}/confirm',
-    ...options
-});
-
-/**
- * Delete an AI agent
+ * Use the same datalake download-link endpoint as workflow artifacts
+ * (`POST /api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/download-link`):
  *
- * Deletes an AI agent. Returns 409 if the agent is attached to a workflow.
- */
-export const platformApiAiAgentControllerDelete = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAiAgentControllerDeleteData, ThrowOnError>) => (options.client ?? client).delete<PlatformApiAiAgentControllerDeleteResponses, PlatformApiAiAgentControllerDeleteErrors, ThrowOnError>({
-    requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: v.optional(v.never()),
-        path: vPlatformApiAiAgentControllerDeletePath,
-        query: v.optional(v.never())
-    }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAiAgentControllerDeleteResponse, data),
-    security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/ai-agents/{id}',
-    ...options
-});
-
-/**
- * Get an AI agent
+ * # raw payload that this ingest call uploaded
+ * { "bucket": "<regulated>", "key": "<response.key>" }
  *
- * Returns a single AI agent by ID.
- */
-export const platformApiAiAgentControllerShow = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAiAgentControllerShowData, ThrowOnError>) => (options.client ?? client).get<PlatformApiAiAgentControllerShowResponses, PlatformApiAiAgentControllerShowErrors, ThrowOnError>({
-    requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: v.optional(v.never()),
-        path: vPlatformApiAiAgentControllerShowPath,
-        query: v.optional(v.never())
-    }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAiAgentControllerShowResponse, data),
-    security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/ai-agents/{id}',
-    ...options
-});
-
-/**
- * Replace an AI agent
+ * # per-bucket merged archive (after batch completes)
+ * { "bucket": "<regulated|unregulated>", "key": "<output_files[i].object_key>" }
+ *
+ * `output_files[i].mode` tells you which bucket each archive lives in
+ * (`regulated` for raw attrs, `unregulated` for tokenized). The regulated /
+ * unregulated bucket names are exposed on the datalake response as
+ * `regulated_cloud_storage.bucket` / `unregulated_cloud_storage.bucket`.
+ *
+ * ### Failure surfacing
+ *
+ * On a `{:error, _}` ingest response the platform returns `422` with an
+ * `error` string. For pipeline failures (per-row Oban job exceptions),
+ * the DataActivationLog row's `rows_ingested` will be lower than the
+ * submitted count; per-row diagnostics live in the Oban job table
+ * (`oban_jobs.errors`) keyed by `batch_id`. There is no `error.json`
+ * artifact on the DAC path — that convention is workflow-only.
  *
- * Replaces an AI agent with the full resource body. PUT semantics — all required fields must be present.
  */
-export const platformApiAiAgentControllerUpdate = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAiAgentControllerUpdateData, ThrowOnError>) => (options.client ?? client).put<PlatformApiAiAgentControllerUpdateResponses, PlatformApiAiAgentControllerUpdateErrors, ThrowOnError>({
+export const platformApiDataActivationClientControllerIngest = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDataActivationClientControllerIngestData, ThrowOnError>) => (options.client ?? client).post<PlatformApiDataActivationClientControllerIngestResponses, PlatformApiDataActivationClientControllerIngestErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: v.optional(vPlatformApiAiAgentControllerUpdateBody),
-        path: vPlatformApiAiAgentControllerUpdatePath,
+        body: vPlatformApiDataActivationClientControllerIngestBody,
+        path: vPlatformApiDataActivationClientControllerIngestPath,
         query: v.optional(v.never())
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAiAgentControllerUpdateResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDataActivationClientControllerIngestResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/ai-agents/{id}',
+    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/data-activation-clients/{slug}/ingest',
     ...options,
     headers: {
         'Content-Type': 'application/json',
@@ -807,19 +810,20 @@ export const platformApiAiAgentControllerUpdate = <ThrowOnError extends boolean
 });
 
 /**
- * Trigger a manual run of a Data Activation Client
+ * Replace an action status updater
  *
- * Enqueues a one-off fetch/ingest pipeline run. Empty body or omitted `tool_call` runs with the DAC's persisted `tool_call`. Supplying a `tool_call` map applies a one-shot polymorphic override for this run only — the persisted DAC record is not modified.
+ * Replaces an action status updater with the full resource body. PUT semantics — all required fields must be present.
  */
-export const platformApiDataActivationClientControllerRunManually = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDataActivationClientControllerRunManuallyData, ThrowOnError>) => (options.client ?? client).post<PlatformApiDataActivationClientControllerRunManuallyResponses, PlatformApiDataActivationClientControllerRunManuallyErrors, ThrowOnError>({
+export const platformApiActionStatusUpdaterControllerUpdate = <ThrowOnError extends boolean = false>(options: Options<PlatformApiActionStatusUpdaterControllerUpdateData, ThrowOnError>) => (options.client ?? client).put<PlatformApiActionStatusUpdaterControllerUpdateResponses, PlatformApiActionStatusUpdaterControllerUpdateErrors, ThrowOnError>({
+    querySerializer: { parameters: { filters: { array: { style: 'deepObject' } } } },
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: v.optional(vPlatformApiDataActivationClientControllerRunManuallyBody),
-        path: vPlatformApiDataActivationClientControllerRunManuallyPath,
-        query: v.optional(v.never())
+        body: v.optional(vPlatformApiActionStatusUpdaterControllerUpdateBody),
+        path: vPlatformApiActionStatusUpdaterControllerUpdatePath,
+        query: v.optional(vPlatformApiActionStatusUpdaterControllerUpdateQuery)
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDataActivationClientControllerRunManuallyResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiActionStatusUpdaterControllerUpdateResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/data-activation-clients/{slug}/run-manually',
+    url: '/api/v1/tenants/{tenant_slug}/action-status-updaters/{id}',
     ...options,
     headers: {
         'Content-Type': 'application/json',
@@ -828,59 +832,37 @@ export const platformApiDataActivationClientControllerRunManually = <ThrowOnErro
 });
 
 /**
- * List data sources
+ * List AI agents
  *
- * Returns a paginated list of data sources for the authenticated tenant.
+ * Returns a paginated list of AI agents for the authenticated tenant.
  */
-export const platformApiDataSourceControllerIndex = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDataSourceControllerIndexData, ThrowOnError>) => (options.client ?? client).get<PlatformApiDataSourceControllerIndexResponses, PlatformApiDataSourceControllerIndexErrors, ThrowOnError>({
+export const platformApiAiAgentControllerIndex = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAiAgentControllerIndexData, ThrowOnError>) => (options.client ?? client).get<PlatformApiAiAgentControllerIndexResponses, PlatformApiAiAgentControllerIndexErrors, ThrowOnError>({
     querySerializer: { parameters: { filters: { array: { style: 'deepObject' } } } },
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
         body: v.optional(v.never()),
-        path: vPlatformApiDataSourceControllerIndexPath,
-        query: v.optional(vPlatformApiDataSourceControllerIndexQuery)
+        path: vPlatformApiAiAgentControllerIndexPath,
+        query: v.optional(vPlatformApiAiAgentControllerIndexQuery)
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDataSourceControllerIndexResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAiAgentControllerIndexResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/data-sources',
+    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/ai-agents',
     ...options
 });
 
 /**
- * Create a data source
- *
- * Creates a new data source for the authenticated tenant.
- */
-export const platformApiDataSourceControllerCreate = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDataSourceControllerCreateData, ThrowOnError>) => (options.client ?? client).post<PlatformApiDataSourceControllerCreateResponses, PlatformApiDataSourceControllerCreateErrors, ThrowOnError>({
-    querySerializer: { parameters: { filters: { array: { style: 'deepObject' } } } },
-    requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: v.optional(vPlatformApiDataSourceControllerCreateBody),
-        path: vPlatformApiDataSourceControllerCreatePath,
-        query: v.optional(vPlatformApiDataSourceControllerCreateQuery)
-    }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDataSourceControllerCreateResponse, data),
-    security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/data-sources',
-    ...options,
-    headers: {
-        'Content-Type': 'application/json',
-        ...options.headers
-    }
-});
-
-/**
- * Ingest previously uploaded file
+ * Create an AI agent
  *
- * Ingests a file that was uploaded via a presigned URL obtained from the datalake upload-link endpoint. The key must belong to this client's datalake prefix (`uploads/<datalake_id>/...`).
+ * Creates a new AI agent for the authenticated tenant.
  */
-export const platformApiDataActivationClientControllerIngestFile = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDataActivationClientControllerIngestFileData, ThrowOnError>) => (options.client ?? client).post<PlatformApiDataActivationClientControllerIngestFileResponses, PlatformApiDataActivationClientControllerIngestFileErrors, ThrowOnError>({
+export const platformApiAiAgentControllerCreate = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAiAgentControllerCreateData, ThrowOnError>) => (options.client ?? client).post<PlatformApiAiAgentControllerCreateResponses, PlatformApiAiAgentControllerCreateErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: vPlatformApiDataActivationClientControllerIngestFileBody,
-        path: vPlatformApiDataActivationClientControllerIngestFilePath,
+        body: v.optional(vPlatformApiAiAgentControllerCreateBody),
+        path: vPlatformApiAiAgentControllerCreatePath,
         query: v.optional(v.never())
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDataActivationClientControllerIngestFileResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAiAgentControllerCreateResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/data-activation-clients/{slug}/ingest-file',
+    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/ai-agents',
     ...options,
     headers: {
         'Content-Type': 'application/json',
@@ -889,24 +871,20 @@ export const platformApiDataActivationClientControllerIngestFile = <ThrowOnError
 });
 
 /**
- * Get a workflow execution log
- *
- * Returns a single execution log with action execution details. Each action
- * execution log carries a `message_body` virtual field populated from the
- * datalake message linked via `message_id`. The `data_access_mode` query
- * parameter selects which datalake schema is read for the body — defaults
- * to the session's `data_access_mode` ceiling.
+ * Get datalake domain metadata
  *
+ * Returns a markdown document describing the datalake's data domain — its available standard resources and capabilities.
  */
-export const platformApiAgenticWorkflowOperationsControllerWorkflowLogShow = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAgenticWorkflowOperationsControllerWorkflowLogShowData, ThrowOnError>) => (options.client ?? client).get<PlatformApiAgenticWorkflowOperationsControllerWorkflowLogShowResponses, PlatformApiAgenticWorkflowOperationsControllerWorkflowLogShowErrors, ThrowOnError>({
+export const platformApiDatalakeControllerMetadata = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDatalakeControllerMetadataData, ThrowOnError>) => (options.client ?? client).get<PlatformApiDatalakeControllerMetadataResponses, PlatformApiDatalakeControllerMetadataErrors, ThrowOnError>({
+    querySerializer: { parameters: { filters: { array: { style: 'deepObject' } } } },
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
         body: v.optional(v.never()),
-        path: vPlatformApiAgenticWorkflowOperationsControllerWorkflowLogShowPath,
-        query: v.optional(vPlatformApiAgenticWorkflowOperationsControllerWorkflowLogShowQuery)
+        path: vPlatformApiDatalakeControllerMetadataPath,
+        query: v.optional(vPlatformApiDatalakeControllerMetadataQuery)
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAgenticWorkflowOperationsControllerWorkflowLogShowResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDatalakeControllerMetadataResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/agentic-workflows/{workflow_slug}/workflow-logs/{id}',
+    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/metadata',
     ...options
 });
 
@@ -969,77 +947,81 @@ export const platformApiInteroperabilityContractControllerUpdate = <ThrowOnError
 });
 
 /**
- * Get datalake domain metadata
+ * Get a workflow execution log
+ *
+ * Returns a single execution log with action execution details. Each action
+ * execution log carries a `message_body` virtual field populated from the
+ * datalake message linked via `message_id`. The `data_access_mode` query
+ * parameter selects which datalake schema is read for the body — defaults
+ * to the session's `data_access_mode` ceiling.
  *
- * Returns a markdown document describing the datalake's data domain — its available standard resources and capabilities.
  */
-export const platformApiDatalakeControllerMetadata = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDatalakeControllerMetadataData, ThrowOnError>) => (options.client ?? client).get<PlatformApiDatalakeControllerMetadataResponses, PlatformApiDatalakeControllerMetadataErrors, ThrowOnError>({
-    querySerializer: { parameters: { filters: { array: { style: 'deepObject' } } } },
+export const platformApiAgenticWorkflowOperationsControllerWorkflowLogShow = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAgenticWorkflowOperationsControllerWorkflowLogShowData, ThrowOnError>) => (options.client ?? client).get<PlatformApiAgenticWorkflowOperationsControllerWorkflowLogShowResponses, PlatformApiAgenticWorkflowOperationsControllerWorkflowLogShowErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
         body: v.optional(v.never()),
-        path: vPlatformApiDatalakeControllerMetadataPath,
-        query: v.optional(vPlatformApiDatalakeControllerMetadataQuery)
+        path: vPlatformApiAgenticWorkflowOperationsControllerWorkflowLogShowPath,
+        query: v.optional(vPlatformApiAgenticWorkflowOperationsControllerWorkflowLogShowQuery)
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDatalakeControllerMetadataResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAgenticWorkflowOperationsControllerWorkflowLogShowResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/metadata',
+    url: '/api/v1/tenants/{tenant_slug}/agentic-workflows/{workflow_slug}/workflow-logs/{id}',
     ...options
 });
 
 /**
- * List AI agents
+ * Ingest previously uploaded file
  *
- * Returns a paginated list of AI agents for the authenticated tenant.
+ * Ingests a file that was uploaded via a presigned URL obtained from the datalake upload-link endpoint. The key must belong to this client's datalake prefix (`uploads/<datalake_id>/...`).
  */
-export const platformApiAiAgentControllerIndex = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAiAgentControllerIndexData, ThrowOnError>) => (options.client ?? client).get<PlatformApiAiAgentControllerIndexResponses, PlatformApiAiAgentControllerIndexErrors, ThrowOnError>({
-    querySerializer: { parameters: { filters: { array: { style: 'deepObject' } } } },
+export const platformApiDataActivationClientControllerIngestFile = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDataActivationClientControllerIngestFileData, ThrowOnError>) => (options.client ?? client).post<PlatformApiDataActivationClientControllerIngestFileResponses, PlatformApiDataActivationClientControllerIngestFileErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: v.optional(v.never()),
-        path: vPlatformApiAiAgentControllerIndexPath,
-        query: v.optional(vPlatformApiAiAgentControllerIndexQuery)
+        body: vPlatformApiDataActivationClientControllerIngestFileBody,
+        path: vPlatformApiDataActivationClientControllerIngestFilePath,
+        query: v.optional(v.never())
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAiAgentControllerIndexResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDataActivationClientControllerIngestFileResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/ai-agents',
-    ...options
+    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/data-activation-clients/{slug}/ingest-file',
+    ...options,
+    headers: {
+        'Content-Type': 'application/json',
+        ...options.headers
+    }
 });
 
 /**
- * Create an AI agent
+ * List data sources
  *
- * Creates a new AI agent for the authenticated tenant.
+ * Returns a paginated list of data sources for the authenticated tenant.
  */
-export const platformApiAiAgentControllerCreate = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAiAgentControllerCreateData, ThrowOnError>) => (options.client ?? client).post<PlatformApiAiAgentControllerCreateResponses, PlatformApiAiAgentControllerCreateErrors, ThrowOnError>({
+export const platformApiDataSourceControllerIndex = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDataSourceControllerIndexData, ThrowOnError>) => (options.client ?? client).get<PlatformApiDataSourceControllerIndexResponses, PlatformApiDataSourceControllerIndexErrors, ThrowOnError>({
+    querySerializer: { parameters: { filters: { array: { style: 'deepObject' } } } },
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: v.optional(vPlatformApiAiAgentControllerCreateBody),
-        path: vPlatformApiAiAgentControllerCreatePath,
-        query: v.optional(v.never())
+        body: v.optional(v.never()),
+        path: vPlatformApiDataSourceControllerIndexPath,
+        query: v.optional(vPlatformApiDataSourceControllerIndexQuery)
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAiAgentControllerCreateResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDataSourceControllerIndexResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/ai-agents',
-    ...options,
-    headers: {
-        'Content-Type': 'application/json',
-        ...options.headers
-    }
+    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/data-sources',
+    ...options
 });
 
 /**
- * Replace an action status updater
+ * Create a data source
  *
- * Replaces an action status updater with the full resource body. PUT semantics — all required fields must be present.
+ * Creates a new data source for the authenticated tenant.
  */
-export const platformApiActionStatusUpdaterControllerUpdate = <ThrowOnError extends boolean = false>(options: Options<PlatformApiActionStatusUpdaterControllerUpdateData, ThrowOnError>) => (options.client ?? client).put<PlatformApiActionStatusUpdaterControllerUpdateResponses, PlatformApiActionStatusUpdaterControllerUpdateErrors, ThrowOnError>({
+export const platformApiDataSourceControllerCreate = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDataSourceControllerCreateData, ThrowOnError>) => (options.client ?? client).post<PlatformApiDataSourceControllerCreateResponses, PlatformApiDataSourceControllerCreateErrors, ThrowOnError>({
     querySerializer: { parameters: { filters: { array: { style: 'deepObject' } } } },
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: v.optional(vPlatformApiActionStatusUpdaterControllerUpdateBody),
-        path: vPlatformApiActionStatusUpdaterControllerUpdatePath,
-        query: v.optional(vPlatformApiActionStatusUpdaterControllerUpdateQuery)
+        body: v.optional(vPlatformApiDataSourceControllerCreateBody),
+        path: vPlatformApiDataSourceControllerCreatePath,
+        query: v.optional(vPlatformApiDataSourceControllerCreateQuery)
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiActionStatusUpdaterControllerUpdateResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDataSourceControllerCreateResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/action-status-updaters/{id}',
+    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/data-sources',
     ...options,
     headers: {
         'Content-Type': 'application/json',
@@ -1048,59 +1030,19 @@ export const platformApiActionStatusUpdaterControllerUpdate = <ThrowOnError exte
 });
 
 /**
- * Ingest JSON data
- *
- * Ingest a single JSON record for processing through the data activation
- * pipeline. Returns immediately with `{batch_id, key, jobs_count}`; per-row
- * work runs asynchronously on the data-activation Oban queue.
- *
- * ## Per-batch artifacts (audit trail)
- *
- * The DAC pipeline does NOT use the `<step>.json` convention that workflows
- * do — its byproducts are NDJSON archives, surfaced on the
- * `DataActivationLog` row that the batch produces:
- *
- * | Field           | Bucket       | Body                                                                                     |
- * | --------------- | ------------ | ---------------------------------------------------------------------------------------- |
- * | `key` (response)| regulated    | the raw JSON payload uploaded by THIS request                                            |
- * | `input_files`   | regulated    | source artifacts consumed by the batch (one per ingest call merged into the batch)       |
- * | `output_files`  | mixed        | merged NDJSON archives, one `{object_key, mode}` per bucket (`regulated` + `unregulated`)|
- *
- * ### Fetching diagnostic artifacts
- *
- * Use the same datalake download-link endpoint as workflow artifacts
- * (`POST /api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/download-link`):
- *
- * # raw payload that this ingest call uploaded
- * { "bucket": "<regulated>", "key": "<response.key>" }
- *
- * # per-bucket merged archive (after batch completes)
- * { "bucket": "<regulated|unregulated>", "key": "<output_files[i].object_key>" }
- *
- * `output_files[i].mode` tells you which bucket each archive lives in
- * (`regulated` for raw attrs, `unregulated` for tokenized). The regulated /
- * unregulated bucket names are exposed on the datalake response as
- * `regulated_cloud_storage.bucket` / `unregulated_cloud_storage.bucket`.
- *
- * ### Failure surfacing
- *
- * On a `{:error, _}` ingest response the platform returns `422` with an
- * `error` string. For pipeline failures (per-row Oban job exceptions),
- * the DataActivationLog row's `rows_ingested` will be lower than the
- * submitted count; per-row diagnostics live in the Oban job table
- * (`oban_jobs.errors`) keyed by `batch_id`. There is no `error.json`
- * artifact on the DAC path — that convention is workflow-only.
+ * Trigger a manual run of a Data Activation Client
  *
+ * Enqueues a one-off fetch/ingest pipeline run. Empty body or omitted `tool_call` runs with the DAC's persisted `tool_call`. Supplying a `tool_call` map applies a one-shot polymorphic override for this run only — the persisted DAC record is not modified.
  */
-export const platformApiDataActivationClientControllerIngest = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDataActivationClientControllerIngestData, ThrowOnError>) => (options.client ?? client).post<PlatformApiDataActivationClientControllerIngestResponses, PlatformApiDataActivationClientControllerIngestErrors, ThrowOnError>({
+export const platformApiDataActivationClientControllerRunManually = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDataActivationClientControllerRunManuallyData, ThrowOnError>) => (options.client ?? client).post<PlatformApiDataActivationClientControllerRunManuallyResponses, PlatformApiDataActivationClientControllerRunManuallyErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: vPlatformApiDataActivationClientControllerIngestBody,
-        path: vPlatformApiDataActivationClientControllerIngestPath,
+        body: v.optional(vPlatformApiDataActivationClientControllerRunManuallyBody),
+        path: vPlatformApiDataActivationClientControllerRunManuallyPath,
         query: v.optional(v.never())
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDataActivationClientControllerIngestResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDataActivationClientControllerRunManuallyResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/data-activation-clients/{slug}/ingest',
+    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/data-activation-clients/{slug}/run-manually',
     ...options,
     headers: {
         'Content-Type': 'application/json',
@@ -1109,76 +1051,53 @@ export const platformApiDataActivationClientControllerIngest = <ThrowOnError ext
 });
 
 /**
- * Force-refresh a batch run log
+ * Delete an AI agent
  *
- * Triggers an immediate refresh of the batch run log metrics and merged artifacts.
+ * Deletes an AI agent. Returns 409 if the agent is attached to a workflow.
  */
-export const platformApiAgenticWorkflowOperationsControllerBatchLogRefresh = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAgenticWorkflowOperationsControllerBatchLogRefreshData, ThrowOnError>) => (options.client ?? client).post<PlatformApiAgenticWorkflowOperationsControllerBatchLogRefreshResponses, PlatformApiAgenticWorkflowOperationsControllerBatchLogRefreshErrors, ThrowOnError>({
+export const platformApiAiAgentControllerDelete = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAiAgentControllerDeleteData, ThrowOnError>) => (options.client ?? client).delete<PlatformApiAiAgentControllerDeleteResponses, PlatformApiAiAgentControllerDeleteErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
         body: v.optional(v.never()),
-        path: vPlatformApiAgenticWorkflowOperationsControllerBatchLogRefreshPath,
+        path: vPlatformApiAiAgentControllerDeletePath,
         query: v.optional(v.never())
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAgenticWorkflowOperationsControllerBatchLogRefreshResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAiAgentControllerDeleteResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/agentic-workflows/{workflow_slug}/batch-logs/{id}/refresh',
+    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/ai-agents/{id}',
     ...options
 });
 
 /**
- * Run workflow for matching records
- *
- * Executes the workflow for all dataset records matching the SQL WHERE clause.
- * Creates sampled events and enqueues run_workflow jobs. Returns the batch ID
- * and enqueued count. A WorkflowRunLog is created to track batch-level
- * progress, polled by a daily DynamicCron.
- *
- * ## Per-step artifacts (audit trail)
- *
- * Each per-row WorkflowExecutionLog (WEL) writes a fixed set of JSON
- * artifacts to the datalake's regulated cloud-storage bucket. The path is
- * deterministic and convention-driven — there is no separate listing
- * endpoint:
- *
- * workflows/{workflow_id}/executions/{wel_id}/event.json
- * workflows/{workflow_id}/executions/{wel_id}/filter.json
- * workflows/{workflow_id}/executions/{wel_id}/enrichment.json
- * workflows/{workflow_id}/executions/{wel_id}/error.json   # only on failure
- *
- * | File              | Written by stage                       | Body                                                               |
- * | ----------------- | -------------------------------------- | ------------------------------------------------------------------ |
- * | `event.json`      | context build                          | full WorkflowContext (event_dataset, mdm_output, additional_context)|
- * | `filter.json`     | filter eval (both pass and reject)     | `{filter_expression, filter_result: bool}`                         |
- * | `enrichment.json` | enrichment terminal (success / skip / fail) | `{status: "completed" \| "failed" \| "skipped", <agent_slug>: ...}` |
- * | `error.json`      | ANY pipeline failure                   | `{stage, error_code, ai_agent_slug, error_message, detail}`        |
- *
- * `error.json`'s presence IS the failure signal — `WEL.error_message`
- * carries only a code-grade summary; the rich URL/HTTP-status/transport
- * detail lives ONLY in `error.json["detail"]`. Engineers debugging a
- * failed run should download `error.json` for full context.
- *
- * ### Fetching an artifact
- *
- * Use the standard datalake download-link endpoint
- * (`POST /api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/download-link`)
- * with `bucket = <regulated bucket>` and the convention key above. Example:
- *
- * POST /api/v1/tenants/acme/datalakes/clinical/download-link
- * { "bucket": "clinical-regulated", "key": "workflows/<wf_id>/executions/<wel_id>/error.json" }
+ * Get an AI agent
  *
- * The response carries a short-lived signed URL. The regulated bucket is
- * exposed on the datalake response as `regulated_cloud_storage.bucket`.
+ * Returns a single AI agent by ID.
+ */
+export const platformApiAiAgentControllerShow = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAiAgentControllerShowData, ThrowOnError>) => (options.client ?? client).get<PlatformApiAiAgentControllerShowResponses, PlatformApiAiAgentControllerShowErrors, ThrowOnError>({
+    requestValidator: async (data: unknown) => await v.parseAsync(v.object({
+        body: v.optional(v.never()),
+        path: vPlatformApiAiAgentControllerShowPath,
+        query: v.optional(v.never())
+    }), data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAiAgentControllerShowResponse, data),
+    security: [{ name: 'X-API-Key', type: 'apiKey' }],
+    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/ai-agents/{id}',
+    ...options
+});
+
+/**
+ * Replace an AI agent
  *
+ * Replaces an AI agent with the full resource body. PUT semantics — all required fields must be present.
  */
-export const platformApiAgenticWorkflowOperationsControllerRunWorkflow = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAgenticWorkflowOperationsControllerRunWorkflowData, ThrowOnError>) => (options.client ?? client).post<PlatformApiAgenticWorkflowOperationsControllerRunWorkflowResponses, PlatformApiAgenticWorkflowOperationsControllerRunWorkflowErrors, ThrowOnError>({
+export const platformApiAiAgentControllerUpdate = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAiAgentControllerUpdateData, ThrowOnError>) => (options.client ?? client).put<PlatformApiAiAgentControllerUpdateResponses, PlatformApiAiAgentControllerUpdateErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: vPlatformApiAgenticWorkflowOperationsControllerRunWorkflowBody,
-        path: vPlatformApiAgenticWorkflowOperationsControllerRunWorkflowPath,
+        body: v.optional(vPlatformApiAiAgentControllerUpdateBody),
+        path: vPlatformApiAiAgentControllerUpdatePath,
         query: v.optional(v.never())
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAgenticWorkflowOperationsControllerRunWorkflowResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAiAgentControllerUpdateResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/agentic-workflows/{workflow_slug}/run-workflow',
+    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/ai-agents/{id}',
     ...options,
     headers: {
         'Content-Type': 'application/json',
@@ -1187,53 +1106,67 @@ export const platformApiAgenticWorkflowOperationsControllerRunWorkflow = <ThrowO
 });
 
 /**
- * Delete an agentic workflow
+ * Confirm a user (admin bypass)
+ *
+ * Marks a user account as confirmed without requiring an email-confirmation
+ * token. Idempotent — confirming an already-confirmed user is a 200 no-op
+ * that returns the existing `confirmed_at` timestamp.
+ *
+ * Wraps `Accounts.confirm_user!/1` verbatim — exactly the primitive that
+ * backs the dev/admin email-confirm path in the LiveView UI. **Zero new
+ * business logic.**
+ *
+ * Powerful primitive: bypasses the regular email-confirmation flow. Every
+ * successful call is structured-logged with `caller_user_id` and
+ * `target_user_id` for forensic trail.
+ *
+ * **Requires platform-admin authentication** (`User.role == :admin`).
  *
- * Deletes a workflow and all associated actions, context datasets, and AI agent attachments.
  */
-export const platformApiAgenticWorkflowControllerDelete = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAgenticWorkflowControllerDeleteData, ThrowOnError>) => (options.client ?? client).delete<PlatformApiAgenticWorkflowControllerDeleteResponses, PlatformApiAgenticWorkflowControllerDeleteErrors, ThrowOnError>({
+export const platformApiAdminControllerConfirmUser = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAdminControllerConfirmUserData, ThrowOnError>) => (options.client ?? client).put<PlatformApiAdminControllerConfirmUserResponses, PlatformApiAdminControllerConfirmUserErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
         body: v.optional(v.never()),
-        path: vPlatformApiAgenticWorkflowControllerDeletePath,
+        path: vPlatformApiAdminControllerConfirmUserPath,
         query: v.optional(v.never())
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAgenticWorkflowControllerDeleteResponse, data),
-    security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/agentic-workflows/{id}',
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAdminControllerConfirmUserResponse, data),
+    security: [{ scheme: 'bearer', type: 'http' }],
+    url: '/api/v1/admin/users/{id}/confirm',
     ...options
 });
 
 /**
- * Get an agentic workflow
+ * List connected apps
  *
- * Returns a single workflow by ID with nested AI agents.
+ * Returns a paginated list of connected apps for the authenticated tenant.
  */
-export const platformApiAgenticWorkflowControllerShow = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAgenticWorkflowControllerShowData, ThrowOnError>) => (options.client ?? client).get<PlatformApiAgenticWorkflowControllerShowResponses, PlatformApiAgenticWorkflowControllerShowErrors, ThrowOnError>({
+export const platformApiConnectedAppMgmtControllerIndex = <ThrowOnError extends boolean = false>(options: Options<PlatformApiConnectedAppMgmtControllerIndexData, ThrowOnError>) => (options.client ?? client).get<PlatformApiConnectedAppMgmtControllerIndexResponses, PlatformApiConnectedAppMgmtControllerIndexErrors, ThrowOnError>({
+    querySerializer: { parameters: { filters: { array: { style: 'deepObject' } } } },
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
         body: v.optional(v.never()),
-        path: vPlatformApiAgenticWorkflowControllerShowPath,
-        query: v.optional(v.never())
+        path: vPlatformApiConnectedAppMgmtControllerIndexPath,
+        query: v.optional(vPlatformApiConnectedAppMgmtControllerIndexQuery)
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAgenticWorkflowControllerShowResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiConnectedAppMgmtControllerIndexResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/agentic-workflows/{id}',
+    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/connected-apps',
     ...options
 });
 
 /**
- * Replace an agentic workflow
+ * Create a connected app
  *
- * Replaces a workflow with the full resource body. PUT semantics — all required fields must be present. The `ai_agents` array replaces the current set of attached agents transactionally.
+ * Creates a new connected app with automatic API key provisioning.
  */
-export const platformApiAgenticWorkflowControllerUpdate = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAgenticWorkflowControllerUpdateData, ThrowOnError>) => (options.client ?? client).put<PlatformApiAgenticWorkflowControllerUpdateResponses, PlatformApiAgenticWorkflowControllerUpdateErrors, ThrowOnError>({
+export const platformApiConnectedAppMgmtControllerCreate = <ThrowOnError extends boolean = false>(options: Options<PlatformApiConnectedAppMgmtControllerCreateData, ThrowOnError>) => (options.client ?? client).post<PlatformApiConnectedAppMgmtControllerCreateResponses, PlatformApiConnectedAppMgmtControllerCreateErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: v.optional(vPlatformApiAgenticWorkflowControllerUpdateBody),
-        path: vPlatformApiAgenticWorkflowControllerUpdatePath,
+        body: v.optional(vPlatformApiConnectedAppMgmtControllerCreateBody),
+        path: vPlatformApiConnectedAppMgmtControllerCreatePath,
         query: v.optional(v.never())
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAgenticWorkflowControllerUpdateResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiConnectedAppMgmtControllerCreateResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/agentic-workflows/{id}',
+    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/connected-apps',
     ...options,
     headers: {
         'Content-Type': 'application/json',
@@ -1242,20 +1175,62 @@ export const platformApiAgenticWorkflowControllerUpdate = <ThrowOnError extends
 });
 
 /**
- * Replace a data source
+ * Revoke current session
+ *
+ * Revokes the current Bearer session — deactivates the session and deletes
+ * the linked UserToken. The Bearer token becomes immediately invalid.
+ *
+ * Only works with `Authorization: Bearer <session_token>` (not X-API-Key).
+ *
+ * **Requires Bearer authentication.**
  *
- * Replaces a data source with the full resource body. PUT semantics — all required fields must be present.
  */
-export const platformApiDataSourceControllerUpdate = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDataSourceControllerUpdateData, ThrowOnError>) => (options.client ?? client).put<PlatformApiDataSourceControllerUpdateResponses, PlatformApiDataSourceControllerUpdateErrors, ThrowOnError>({
-    querySerializer: { parameters: { filters: { array: { style: 'deepObject' } } } },
+export const platformApiSessionControllerDelete = <ThrowOnError extends boolean = false>(options?: Options<PlatformApiSessionControllerDeleteData, ThrowOnError>) => (options?.client ?? client).delete<PlatformApiSessionControllerDeleteResponses, PlatformApiSessionControllerDeleteErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: v.optional(vPlatformApiDataSourceControllerUpdateBody),
-        path: vPlatformApiDataSourceControllerUpdatePath,
-        query: v.optional(vPlatformApiDataSourceControllerUpdateQuery)
+        body: v.optional(v.never()),
+        path: v.optional(v.never()),
+        query: v.optional(v.never())
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDataSourceControllerUpdateResponse, data),
-    security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/data-sources/{id}',
+    security: [{ scheme: 'bearer', type: 'http' }],
+    url: '/api/v1/sessions',
+    ...options
+});
+
+/**
+ * Create a session (human auth)
+ *
+ * Exchange user credentials for a Bearer session token.
+ *
+ * Send `{email, password}` (with optional `tenant_slug`) to authenticate a
+ * human user and receive a session token. Use the returned `session_token`
+ * as `Authorization: Bearer <session_token>` on subsequent API requests.
+ *
+ * When `tenant_slug` is **omitted**, returns a tenant-less Bearer for
+ * pre-tenant flows: admin operations under `/api/v1/admin/...` and creating
+ * your first tenant via `POST /api/v1/tenants`. Tenant-scoped routes will
+ * reject such tokens with 403.
+ *
+ * When `tenant_slug` is **provided**, returns a tenant-scoped Bearer with
+ * the caller's membership role (or 401 if the user has no membership in
+ * that tenant).
+ *
+ * Optionally specify `expires_in` (seconds) to control session duration.
+ * Default: 86400 (24 hours). Maximum: 2592000 (30 days).
+ *
+ * For M2M (server-to-server) authentication, use `X-API-Key` header directly
+ * on each request instead — no session exchange needed.
+ *
+ * **No authentication required** — this endpoint authenticates the caller.
+ *
+ */
+export const platformApiSessionControllerCreate = <ThrowOnError extends boolean = false>(options: Options<PlatformApiSessionControllerCreateData, ThrowOnError>) => (options.client ?? client).post<PlatformApiSessionControllerCreateResponses, PlatformApiSessionControllerCreateErrors, ThrowOnError>({
+    requestValidator: async (data: unknown) => await v.parseAsync(v.object({
+        body: vPlatformApiSessionControllerCreateBody,
+        path: v.optional(v.never()),
+        query: v.optional(v.never())
+    }), data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiSessionControllerCreateResponse, data),
+    url: '/api/v1/sessions',
     ...options,
     headers: {
         'Content-Type': 'application/json',
@@ -1264,77 +1239,80 @@ export const platformApiDataSourceControllerUpdate = <ThrowOnError extends boole
 });
 
 /**
- * Show a single DAC processing log
+ * Start or restart refresh polling for a batch run log
  *
- * Returns a single `DataActivationLog` row scoped to this DAC. Returns 404 if the id belongs to a different client.
+ * Creates a DynamicCron job to poll this batch. Idempotent — if cron already exists, it's a no-op.
  */
-export const platformApiDataActivationClientControllerLogShow = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDataActivationClientControllerLogShowData, ThrowOnError>) => (options.client ?? client).get<PlatformApiDataActivationClientControllerLogShowResponses, PlatformApiDataActivationClientControllerLogShowErrors, ThrowOnError>({
+export const platformApiAgenticWorkflowOperationsControllerBatchLogStart = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAgenticWorkflowOperationsControllerBatchLogStartData, ThrowOnError>) => (options.client ?? client).post<PlatformApiAgenticWorkflowOperationsControllerBatchLogStartResponses, PlatformApiAgenticWorkflowOperationsControllerBatchLogStartErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
         body: v.optional(v.never()),
-        path: vPlatformApiDataActivationClientControllerLogShowPath,
+        path: vPlatformApiAgenticWorkflowOperationsControllerBatchLogStartPath,
         query: v.optional(v.never())
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDataActivationClientControllerLogShowResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAgenticWorkflowOperationsControllerBatchLogStartResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/data-activation-clients/{slug}/logs/{id}',
+    url: '/api/v1/tenants/{tenant_slug}/agentic-workflows/{workflow_slug}/batch-logs/{id}/start',
     ...options
 });
 
 /**
- * List datalakes
+ * Update message tracking fields for a page
+ *
+ * Updates tracking timestamps (opened_at, form_submitted_at) on the message
+ * linked to a page token. Called by the connected app when a user opens a page
+ * or submits a form.
+ *
+ * **Requires X-API-Key authentication.**
  *
- * Returns a paginated list of datalakes for the authenticated tenant.
  */
-export const platformApiDatalakeControllerIndex = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDatalakeControllerIndexData, ThrowOnError>) => (options.client ?? client).get<PlatformApiDatalakeControllerIndexResponses, PlatformApiDatalakeControllerIndexErrors, ThrowOnError>({
-    querySerializer: { parameters: { filters: { array: { style: 'deepObject' } } } },
+export const platformApiConnectedAppControllerUpdateMessageTracking = <ThrowOnError extends boolean = false>(options: Options<PlatformApiConnectedAppControllerUpdateMessageTrackingData, ThrowOnError>) => (options.client ?? client).patch<PlatformApiConnectedAppControllerUpdateMessageTrackingResponses, PlatformApiConnectedAppControllerUpdateMessageTrackingErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: v.optional(v.never()),
-        path: vPlatformApiDatalakeControllerIndexPath,
-        query: v.optional(vPlatformApiDatalakeControllerIndexQuery)
+        body: vPlatformApiConnectedAppControllerUpdateMessageTrackingBody,
+        path: vPlatformApiConnectedAppControllerUpdateMessageTrackingPath,
+        query: v.optional(v.never())
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDatalakeControllerIndexResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiConnectedAppControllerUpdateMessageTrackingResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/datalakes',
-    ...options
+    url: '/api/v1/tenants/{tenant_slug}/connected-apps/{slug}/update-message-tracking',
+    ...options,
+    headers: {
+        'Content-Type': 'application/json',
+        ...options.headers
+    }
 });
 
 /**
- * Create a datalake
+ * List agentic workflows
  *
- * Creates a new datalake for the authenticated tenant.
+ * Returns a paginated list of workflows for a datalake.
  */
-export const platformApiDatalakeControllerCreate = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDatalakeControllerCreateData, ThrowOnError>) => (options.client ?? client).post<PlatformApiDatalakeControllerCreateResponses, PlatformApiDatalakeControllerCreateErrors, ThrowOnError>({
+export const platformApiAgenticWorkflowControllerIndex = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAgenticWorkflowControllerIndexData, ThrowOnError>) => (options.client ?? client).get<PlatformApiAgenticWorkflowControllerIndexResponses, PlatformApiAgenticWorkflowControllerIndexErrors, ThrowOnError>({
     querySerializer: { parameters: { filters: { array: { style: 'deepObject' } } } },
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: v.optional(vPlatformApiDatalakeControllerCreateBody),
-        path: vPlatformApiDatalakeControllerCreatePath,
-        query: v.optional(vPlatformApiDatalakeControllerCreateQuery)
+        body: v.optional(v.never()),
+        path: vPlatformApiAgenticWorkflowControllerIndexPath,
+        query: v.optional(vPlatformApiAgenticWorkflowControllerIndexQuery)
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDatalakeControllerCreateResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAgenticWorkflowControllerIndexResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/datalakes',
-    ...options,
-    headers: {
-        'Content-Type': 'application/json',
-        ...options.headers
-    }
+    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/agentic-workflows',
+    ...options
 });
 
 /**
- * Create datalake upload link
+ * Create an agentic workflow
  *
- * Returns a presigned PUT URL for uploading a file (NDJSON or CSV) directly to the datalake's regulated cloud storage. The returned key lives under `uploads/<datalake_id>/` and can be passed to downstream endpoints (e.g. data activation client ingest-file) that accept a pre-uploaded storage key.
+ * Creates a new workflow. Attach AI agents via the `ai_agents` array.
  */
-export const platformApiDatalakeControllerCreateUploadLink = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDatalakeControllerCreateUploadLinkData, ThrowOnError>) => (options.client ?? client).post<PlatformApiDatalakeControllerCreateUploadLinkResponses, PlatformApiDatalakeControllerCreateUploadLinkErrors, ThrowOnError>({
-    querySerializer: { parameters: { filters: { array: { style: 'deepObject' } } } },
+export const platformApiAgenticWorkflowControllerCreate = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAgenticWorkflowControllerCreateData, ThrowOnError>) => (options.client ?? client).post<PlatformApiAgenticWorkflowControllerCreateResponses, PlatformApiAgenticWorkflowControllerCreateErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: vPlatformApiDatalakeControllerCreateUploadLinkBody,
-        path: vPlatformApiDatalakeControllerCreateUploadLinkPath,
-        query: v.optional(vPlatformApiDatalakeControllerCreateUploadLinkQuery)
+        body: v.optional(vPlatformApiAgenticWorkflowControllerCreateBody),
+        path: vPlatformApiAgenticWorkflowControllerCreatePath,
+        query: v.optional(v.never())
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDatalakeControllerCreateUploadLinkResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAgenticWorkflowControllerCreateResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/upload-link',
+    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/agentic-workflows',
     ...options,
     headers: {
         'Content-Type': 'application/json',
@@ -1343,121 +1321,105 @@ export const platformApiDatalakeControllerCreateUploadLink = <ThrowOnError exten
 });
 
 /**
- * Execute an individual action for a dataset record
+ * Get DAC dataset metadata
  *
- * Executes a single workflow action identified by decision_key for the given dataset record, bypassing filter and decision evaluation
+ * Returns a markdown document describing the fields of each dataset connected to this data activation client via its interoperability contracts.
  */
-export const platformApiAgenticWorkflowOperationsControllerExecute = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAgenticWorkflowOperationsControllerExecuteData, ThrowOnError>) => (options.client ?? client).post<PlatformApiAgenticWorkflowOperationsControllerExecuteResponses, PlatformApiAgenticWorkflowOperationsControllerExecuteErrors, ThrowOnError>({
+export const platformApiDataActivationClientControllerMetadata = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDataActivationClientControllerMetadataData, ThrowOnError>) => (options.client ?? client).get<PlatformApiDataActivationClientControllerMetadataResponses, PlatformApiDataActivationClientControllerMetadataErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: vPlatformApiAgenticWorkflowOperationsControllerExecuteBody,
-        path: vPlatformApiAgenticWorkflowOperationsControllerExecutePath,
+        body: v.optional(v.never()),
+        path: vPlatformApiDataActivationClientControllerMetadataPath,
         query: v.optional(v.never())
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAgenticWorkflowOperationsControllerExecuteResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDataActivationClientControllerMetadataResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/agentic-workflows/{workflow_slug}/execute',
-    ...options,
-    headers: {
-        'Content-Type': 'application/json',
-        ...options.headers
-    }
+    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/data-activation-clients/{slug}/metadata',
+    ...options
 });
 
 /**
- * Accept a tenant invitation
- *
- * Accepts a pending invitation addressed to the authenticated user, creating
- * a `Membership` and deleting the invitation. Mirrors the LiveView flow at
- * `/app/users/tenant-invitations` → "Accept" button. Wraps
- * `Tenants.accept_invitation!/2` verbatim.
- *
- * The function-level guard `get_invitation_by_user!/2` ensures the invitation
- * is addressed to the caller — cross-user acceptance returns 404.
- *
- * Requires any Bearer (the recipient often has only a tenant-less Bearer at
- * this point — they just signed up and haven't joined a tenant yet).
+ * Stop refresh polling for a batch run log
  *
+ * Deletes the DynamicCron job that polls this batch. The batch log is NOT deleted.
  */
-export const platformApiInvitationControllerAccept = <ThrowOnError extends boolean = false>(options: Options<PlatformApiInvitationControllerAcceptData, ThrowOnError>) => (options.client ?? client).post<PlatformApiInvitationControllerAcceptResponses, PlatformApiInvitationControllerAcceptErrors, ThrowOnError>({
+export const platformApiAgenticWorkflowOperationsControllerBatchLogStop = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAgenticWorkflowOperationsControllerBatchLogStopData, ThrowOnError>) => (options.client ?? client).post<PlatformApiAgenticWorkflowOperationsControllerBatchLogStopResponses, PlatformApiAgenticWorkflowOperationsControllerBatchLogStopErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
         body: v.optional(v.never()),
-        path: vPlatformApiInvitationControllerAcceptPath,
+        path: vPlatformApiAgenticWorkflowOperationsControllerBatchLogStopPath,
         query: v.optional(v.never())
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiInvitationControllerAcceptResponse, data),
-    security: [{ scheme: 'bearer', type: 'http' }],
-    url: '/api/v1/invitations/{id}/accept',
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAgenticWorkflowOperationsControllerBatchLogStopResponse, data),
+    security: [{ name: 'X-API-Key', type: 'apiKey' }],
+    url: '/api/v1/tenants/{tenant_slug}/agentic-workflows/{workflow_slug}/batch-logs/{id}/stop',
     ...options
 });
 
 /**
- * Get a batch run log
+ * List processing logs for a Data Activation Client
  *
- * Returns a single batch-level workflow run log with merged artifacts.
+ * Returns a Flop-paginated list of `DataActivationLog` rows for this DAC. One log per `(batch_id, dataset_table)` — a single run produces multiple log rows, one per dataset table the DAC writes into. Filter or group client-side on `batch_id` to reconstruct a batch-level view.
  */
-export const platformApiAgenticWorkflowOperationsControllerBatchLogShow = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAgenticWorkflowOperationsControllerBatchLogShowData, ThrowOnError>) => (options.client ?? client).get<PlatformApiAgenticWorkflowOperationsControllerBatchLogShowResponses, PlatformApiAgenticWorkflowOperationsControllerBatchLogShowErrors, ThrowOnError>({
+export const platformApiDataActivationClientControllerLogsIndex = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDataActivationClientControllerLogsIndexData, ThrowOnError>) => (options.client ?? client).get<PlatformApiDataActivationClientControllerLogsIndexResponses, PlatformApiDataActivationClientControllerLogsIndexErrors, ThrowOnError>({
+    querySerializer: { parameters: { filters: { array: { style: 'deepObject' } } } },
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
         body: v.optional(v.never()),
-        path: vPlatformApiAgenticWorkflowOperationsControllerBatchLogShowPath,
-        query: v.optional(v.never())
+        path: vPlatformApiDataActivationClientControllerLogsIndexPath,
+        query: v.optional(vPlatformApiDataActivationClientControllerLogsIndexQuery)
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAgenticWorkflowOperationsControllerBatchLogShowResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDataActivationClientControllerLogsIndexResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/agentic-workflows/{workflow_slug}/batch-logs/{id}',
+    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/data-activation-clients/{slug}/logs',
     ...options
 });
 
 /**
- * Get contract field metadata
+ * Delete a tool
  *
- * Returns a markdown document describing the fields of the contract's target resource type. Combines `@moduledoc` (resource description) and `@typedoc` (field definitions) from the schema.
+ * Deletes a tool. Returns 409 if the tool is referenced by another resource.
  */
-export const platformApiInteroperabilityContractControllerMetadata = <ThrowOnError extends boolean = false>(options: Options<PlatformApiInteroperabilityContractControllerMetadataData, ThrowOnError>) => (options.client ?? client).get<PlatformApiInteroperabilityContractControllerMetadataResponses, PlatformApiInteroperabilityContractControllerMetadataErrors, ThrowOnError>({
-    querySerializer: { parameters: { filters: { array: { style: 'deepObject' } } } },
+export const platformApiToolControllerDelete = <ThrowOnError extends boolean = false>(options: Options<PlatformApiToolControllerDeleteData, ThrowOnError>) => (options.client ?? client).delete<PlatformApiToolControllerDeleteResponses, PlatformApiToolControllerDeleteErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
         body: v.optional(v.never()),
-        path: vPlatformApiInteroperabilityContractControllerMetadataPath,
-        query: v.optional(vPlatformApiInteroperabilityContractControllerMetadataQuery)
+        path: vPlatformApiToolControllerDeletePath,
+        query: v.optional(v.never())
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiInteroperabilityContractControllerMetadataResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiToolControllerDeleteResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/interoperability-contracts/{slug}/metadata',
+    url: '/api/v1/tenants/{tenant_slug}/tools/{id}',
     ...options
 });
 
 /**
- * List interoperability contracts
+ * Get a tool
  *
- * Returns a paginated list of contracts scoped to the datalake.
+ * Returns a single tool by ID.
  */
-export const platformApiInteroperabilityContractControllerIndex = <ThrowOnError extends boolean = false>(options: Options<PlatformApiInteroperabilityContractControllerIndexData, ThrowOnError>) => (options.client ?? client).get<PlatformApiInteroperabilityContractControllerIndexResponses, PlatformApiInteroperabilityContractControllerIndexErrors, ThrowOnError>({
-    querySerializer: { parameters: { filters: { array: { style: 'deepObject' } } } },
+export const platformApiToolControllerShow = <ThrowOnError extends boolean = false>(options: Options<PlatformApiToolControllerShowData, ThrowOnError>) => (options.client ?? client).get<PlatformApiToolControllerShowResponses, PlatformApiToolControllerShowErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
         body: v.optional(v.never()),
-        path: vPlatformApiInteroperabilityContractControllerIndexPath,
-        query: v.optional(vPlatformApiInteroperabilityContractControllerIndexQuery)
+        path: vPlatformApiToolControllerShowPath,
+        query: v.optional(v.never())
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiInteroperabilityContractControllerIndexResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiToolControllerShowResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/interoperability-contracts',
+    url: '/api/v1/tenants/{tenant_slug}/tools/{id}',
     ...options
 });
 
 /**
- * Create an interoperability contract
+ * Replace a tool
  *
- * Creates a new contract. `slug` is auto-generated from `name` on insert.
+ * Replaces a tool with the full resource body. PUT semantics — all required fields must be present.
  */
-export const platformApiInteroperabilityContractControllerCreate = <ThrowOnError extends boolean = false>(options: Options<PlatformApiInteroperabilityContractControllerCreateData, ThrowOnError>) => (options.client ?? client).post<PlatformApiInteroperabilityContractControllerCreateResponses, PlatformApiInteroperabilityContractControllerCreateErrors, ThrowOnError>({
-    querySerializer: { parameters: { filters: { array: { style: 'deepObject' } } } },
+export const platformApiToolControllerUpdate = <ThrowOnError extends boolean = false>(options: Options<PlatformApiToolControllerUpdateData, ThrowOnError>) => (options.client ?? client).put<PlatformApiToolControllerUpdateResponses, PlatformApiToolControllerUpdateErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: v.optional(vPlatformApiInteroperabilityContractControllerCreateBody),
-        path: vPlatformApiInteroperabilityContractControllerCreatePath,
-        query: v.optional(vPlatformApiInteroperabilityContractControllerCreateQuery)
+        body: v.optional(vPlatformApiToolControllerUpdateBody),
+        path: vPlatformApiToolControllerUpdatePath,
+        query: v.optional(v.never())
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiInteroperabilityContractControllerCreateResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiToolControllerUpdateResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/interoperability-contracts',
+    url: '/api/v1/tenants/{tenant_slug}/tools/{id}',
     ...options,
     headers: {
         'Content-Type': 'application/json',
@@ -1466,62 +1428,93 @@ export const platformApiInteroperabilityContractControllerCreate = <ThrowOnError
 });
 
 /**
- * List the authenticated user's pending invitations
+ * Get workflow metadata
  *
- * Returns invitations addressed to the authenticated user that have not
- * yet been accepted. Mirrors the LiveView at `/app/users/tenant-invitations`
- * that recipients see after sign-in. Wraps `Tenants.list_invitations_by_user/1`
- * verbatim — always filtered to the current user, never accepts a query
- * parameter that could leak another user's invitations.
+ * Returns a markdown document describing the workflow's variable pipeline — available variables at each node (event dataset, MDM, context datasets, enrichment, filter, decision, actions).
+ */
+export const platformApiAgenticWorkflowControllerMetadata = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAgenticWorkflowControllerMetadataData, ThrowOnError>) => (options.client ?? client).get<PlatformApiAgenticWorkflowControllerMetadataResponses, PlatformApiAgenticWorkflowControllerMetadataErrors, ThrowOnError>({
+    requestValidator: async (data: unknown) => await v.parseAsync(v.object({
+        body: v.optional(v.never()),
+        path: vPlatformApiAgenticWorkflowControllerMetadataPath,
+        query: v.optional(v.never())
+    }), data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAgenticWorkflowControllerMetadataResponse, data),
+    security: [{ name: 'X-API-Key', type: 'apiKey' }],
+    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/agentic-workflows/{id}/metadata',
+    ...options
+});
+
+/**
+ * Health check
  *
- * Requires any Bearer (tenant-less is fine — recipients typically don't
- * have tenant scope yet at this point in the bootstrap flow).
+ * Public health check endpoint that returns:
+ * - Application version
+ * - Database connectivity status (SELECT 1 query)
+ * - Current timestamp
+ *
+ * **No authentication required.**
  *
  */
-export const platformApiInvitationControllerIndex = <ThrowOnError extends boolean = false>(options?: Options<PlatformApiInvitationControllerIndexData, ThrowOnError>) => (options?.client ?? client).get<PlatformApiInvitationControllerIndexResponses, PlatformApiInvitationControllerIndexErrors, ThrowOnError>({
+export const platformApiPingControllerPing = <ThrowOnError extends boolean = false>(options?: Options<PlatformApiPingControllerPingData, ThrowOnError>) => (options?.client ?? client).get<PlatformApiPingControllerPingResponses, PlatformApiPingControllerPingErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
         body: v.optional(v.never()),
         path: v.optional(v.never()),
         query: v.optional(v.never())
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiInvitationControllerIndexResponse, data),
-    security: [{ scheme: 'bearer', type: 'http' }],
-    url: '/api/v1/invitations',
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiPingControllerPingResponse, data),
+    url: '/api/ping',
     ...options
 });
 
 /**
- * List generic tables
+ * Sync routes
  *
- * Returns a paginated list of generic tables for the datalake (custom tables + system tables for the data domain).
+ * Enqueues a background job to fetch routes from the connected app's `/.well-known/routes.json` endpoint and update the stored routes.
  */
-export const platformApiGenericTableControllerIndex = <ThrowOnError extends boolean = false>(options: Options<PlatformApiGenericTableControllerIndexData, ThrowOnError>) => (options.client ?? client).get<PlatformApiGenericTableControllerIndexResponses, PlatformApiGenericTableControllerIndexErrors, ThrowOnError>({
+export const platformApiConnectedAppMgmtControllerSyncRoutes = <ThrowOnError extends boolean = false>(options: Options<PlatformApiConnectedAppMgmtControllerSyncRoutesData, ThrowOnError>) => (options.client ?? client).post<PlatformApiConnectedAppMgmtControllerSyncRoutesResponses, PlatformApiConnectedAppMgmtControllerSyncRoutesErrors, ThrowOnError>({
+    requestValidator: async (data: unknown) => await v.parseAsync(v.object({
+        body: v.optional(v.never()),
+        path: vPlatformApiConnectedAppMgmtControllerSyncRoutesPath,
+        query: v.optional(v.never())
+    }), data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiConnectedAppMgmtControllerSyncRoutesResponse, data),
+    security: [{ name: 'X-API-Key', type: 'apiKey' }],
+    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/connected-apps/{id}/sync-routes',
+    ...options
+});
+
+/**
+ * List data activation clients
+ *
+ * Returns a paginated list of DACs for the datalake in the path.
+ */
+export const platformApiDataActivationClientControllerIndex = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDataActivationClientControllerIndexData, ThrowOnError>) => (options.client ?? client).get<PlatformApiDataActivationClientControllerIndexResponses, PlatformApiDataActivationClientControllerIndexErrors, ThrowOnError>({
     querySerializer: { parameters: { filters: { array: { style: 'deepObject' } } } },
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
         body: v.optional(v.never()),
-        path: vPlatformApiGenericTableControllerIndexPath,
-        query: v.optional(vPlatformApiGenericTableControllerIndexQuery)
+        path: vPlatformApiDataActivationClientControllerIndexPath,
+        query: v.optional(vPlatformApiDataActivationClientControllerIndexQuery)
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiGenericTableControllerIndexResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDataActivationClientControllerIndexResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/generic-tables',
+    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/data-activation-clients',
     ...options
 });
 
 /**
- * Create a generic table
+ * Create a data activation client
  *
- * Creates a new custom generic table within the datalake.
+ * Creates a new DAC. `slug` is auto-generated from `name`. `tool_call` is a polymorphic object whose shape depends on the `tool_call_type` discriminator — see `tool_call_type` enum for valid variants (RESTCall, SQLQueryCall, SFTPCall, SharePointExcelCall, AWSLambdaCall, ManualUploadCall, S3Call).
  */
-export const platformApiGenericTableControllerCreate = <ThrowOnError extends boolean = false>(options: Options<PlatformApiGenericTableControllerCreateData, ThrowOnError>) => (options.client ?? client).post<PlatformApiGenericTableControllerCreateResponses, PlatformApiGenericTableControllerCreateErrors, ThrowOnError>({
+export const platformApiDataActivationClientControllerCreate = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDataActivationClientControllerCreateData, ThrowOnError>) => (options.client ?? client).post<PlatformApiDataActivationClientControllerCreateResponses, PlatformApiDataActivationClientControllerCreateErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: v.optional(vPlatformApiGenericTableControllerCreateBody),
-        path: vPlatformApiGenericTableControllerCreatePath,
+        body: v.optional(vPlatformApiDataActivationClientControllerCreateBody),
+        path: vPlatformApiDataActivationClientControllerCreatePath,
         query: v.optional(v.never())
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiGenericTableControllerCreateResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDataActivationClientControllerCreateResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/generic-tables',
+    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/data-activation-clients',
     ...options,
     headers: {
         'Content-Type': 'application/json',
@@ -1530,55 +1523,60 @@ export const platformApiGenericTableControllerCreate = <ThrowOnError extends boo
 });
 
 /**
- * List accessible tenants
+ * Sign up a new user
  *
- * Returns a paginated list of tenants accessible to the authenticated identity.
+ * Register a new user account. Mirrors the `/auth/register` LiveView form
+ * submission shape — wraps `Accounts.register_user/2` verbatim with no
+ * business-logic divergence.
  *
- * - **Bearer token**: returns all tenants the user has membership in.
- * - **X-API-Key**: returns the single tenant the API key is scoped to.
+ * The created user is **unconfirmed** and has **no tenant memberships**. To
+ * obtain a Bearer token, the user must first be confirmed (via the email
+ * confirmation flow in production, or via `PUT /api/v1/admin/users/:id/confirm`
+ * in test bootstrap), then exchange credentials at `POST /api/v1/sessions`.
+ *
+ * No authentication required — this endpoint is the entry point for new users.
  *
  */
-export const platformApiTenantControllerIndex = <ThrowOnError extends boolean = false>(options?: Options<PlatformApiTenantControllerIndexData, ThrowOnError>) => (options?.client ?? client).get<PlatformApiTenantControllerIndexResponses, PlatformApiTenantControllerIndexErrors, ThrowOnError>({
-    querySerializer: { parameters: { filters: { array: { style: 'deepObject' } } } },
+export const platformApiAuthControllerSignUp = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAuthControllerSignUpData, ThrowOnError>) => (options.client ?? client).post<PlatformApiAuthControllerSignUpResponses, PlatformApiAuthControllerSignUpErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: v.optional(v.never()),
+        body: vPlatformApiAuthControllerSignUpBody,
         path: v.optional(v.never()),
-        query: v.optional(vPlatformApiTenantControllerIndexQuery)
+        query: v.optional(v.never())
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiTenantControllerIndexResponse, data),
-    security: [{ name: 'X-API-Key', type: 'apiKey' }, { scheme: 'bearer', type: 'http' }],
-    url: '/api/v1/tenants',
-    ...options
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAuthControllerSignUpResponse, data),
+    url: '/api/v1/auth/sign-up',
+    ...options,
+    headers: {
+        'Content-Type': 'application/json',
+        ...options.headers
+    }
 });
 
 /**
- * Create a tenant
+ * Verify subject identity
  *
- * Creates a new tenant and an `:admin` membership for the authenticated user.
- * Wraps `Platform.Tenants.create_tenant/3` verbatim — same primitive that
- * backs the `/app/tenants/new` LiveView.
+ * Verify a subject's identity against their master record using fuzzy matching.
  *
- * On success returns a regular `SessionResponse` carrying a freshly-minted
- * **tenant-scoped Bearer** (`session_token`), the new tenant, and the
- * membership role. Callers swap their tenant-less Bearer for this token
- * and proceed with tenant-scoped work — no second sign-in round-trip.
+ * Supports verification by:
+ * - **family_name** — Jaro distance >= 0.85
+ * - **given_name** — Jaro distance >= 0.80
+ * - **birth_date** — Fuzzy component matching >= 0.80
+ * - **identifiers** — Exact (system, value) match
  *
- * The user must be confirmed (`confirmed_at IS NOT NULL`); unconfirmed
- * callers receive 403. Duplicate tenant names (slug collision) return 422.
+ * At least one verification field is required.
  *
- * Requires `Authorization: Bearer <token>` (X-API-Key cannot create tenants —
- * it carries no platform-user identity to bind the membership to).
+ * **Requires X-API-Key authentication.**
  *
  */
-export const platformApiTenantControllerCreate = <ThrowOnError extends boolean = false>(options: Options<PlatformApiTenantControllerCreateData, ThrowOnError>) => (options.client ?? client).post<PlatformApiTenantControllerCreateResponses, PlatformApiTenantControllerCreateErrors, ThrowOnError>({
+export const platformApiMdmControllerVerify = <ThrowOnError extends boolean = false>(options: Options<PlatformApiMdmControllerVerifyData, ThrowOnError>) => (options.client ?? client).post<PlatformApiMdmControllerVerifyResponses, PlatformApiMdmControllerVerifyErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: vPlatformApiTenantControllerCreateBody,
-        path: v.optional(v.never()),
+        body: vPlatformApiMdmControllerVerifyBody,
+        path: vPlatformApiMdmControllerVerifyPath,
         query: v.optional(v.never())
-    }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiTenantControllerCreateResponse, data),
-    security: [{ name: 'X-API-Key', type: 'apiKey' }, { scheme: 'bearer', type: 'http' }],
-    url: '/api/v1/tenants',
+    }), data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiMdmControllerVerifyResponse, data),
+    security: [{ name: 'X-API-Key', type: 'apiKey' }],
+    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/mdm/verify',
     ...options,
     headers: {
         'Content-Type': 'application/json',
@@ -1587,36 +1585,36 @@ export const platformApiTenantControllerCreate = <ThrowOnError extends boolean =
 });
 
 /**
- * Get schema metadata for a specific dataset type
+ * Get a connected app
  *
- * Returns a markdown document describing the fields available on a dataset type. For standard datasets (patient, appointment, etc.) returns the schema moduledoc. For generic tables, pass the generic_table_id query parameter.
+ * Returns a single connected app by ID.
  */
-export const platformApiDatasetControllerDatasetMetadata = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDatasetControllerDatasetMetadataData, ThrowOnError>) => (options.client ?? client).get<PlatformApiDatasetControllerDatasetMetadataResponses, PlatformApiDatasetControllerDatasetMetadataErrors, ThrowOnError>({
+export const platformApiConnectedAppMgmtControllerShow = <ThrowOnError extends boolean = false>(options: Options<PlatformApiConnectedAppMgmtControllerShowData, ThrowOnError>) => (options.client ?? client).get<PlatformApiConnectedAppMgmtControllerShowResponses, PlatformApiConnectedAppMgmtControllerShowErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
         body: v.optional(v.never()),
-        path: vPlatformApiDatasetControllerDatasetMetadataPath,
-        query: v.optional(vPlatformApiDatasetControllerDatasetMetadataQuery)
+        path: vPlatformApiConnectedAppMgmtControllerShowPath,
+        query: v.optional(v.never())
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDatasetControllerDatasetMetadataResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiConnectedAppMgmtControllerShowResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/datasets/{dataset_type}/metadata',
+    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/connected-apps/{id}',
     ...options
 });
 
 /**
- * Test invoke a tool
+ * Replace a connected app
  *
- * Manually invokes a tool with caller-supplied parameters — the API equivalent of the 'Try It' panel in the tool form. Records a `ManualToolInvocation` for audit and returns the provider response (or error). Does not access tenant datasets, so no capability ceiling check is applied.
+ * Replaces a connected app with the full resource body. PUT semantics — all required fields must be present.
  */
-export const platformApiToolControllerTestInvocation = <ThrowOnError extends boolean = false>(options: Options<PlatformApiToolControllerTestInvocationData, ThrowOnError>) => (options.client ?? client).post<PlatformApiToolControllerTestInvocationResponses, PlatformApiToolControllerTestInvocationErrors, ThrowOnError>({
+export const platformApiConnectedAppMgmtControllerUpdate = <ThrowOnError extends boolean = false>(options: Options<PlatformApiConnectedAppMgmtControllerUpdateData, ThrowOnError>) => (options.client ?? client).put<PlatformApiConnectedAppMgmtControllerUpdateResponses, PlatformApiConnectedAppMgmtControllerUpdateErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: v.optional(vPlatformApiToolControllerTestInvocationBody),
-        path: vPlatformApiToolControllerTestInvocationPath,
+        body: v.optional(vPlatformApiConnectedAppMgmtControllerUpdateBody),
+        path: vPlatformApiConnectedAppMgmtControllerUpdatePath,
         query: v.optional(v.never())
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiToolControllerTestInvocationResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiConnectedAppMgmtControllerUpdateResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/tools/{id}/test-invocation',
+    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/connected-apps/{id}',
     ...options,
     headers: {
         'Content-Type': 'application/json',
@@ -1625,37 +1623,29 @@ export const platformApiToolControllerTestInvocation = <ThrowOnError extends boo
 });
 
 /**
- * Get a datalake
+ * Invite a user to the tenant
  *
- * Returns a single datalake by ID (non-sensitive metadata only).
- */
-export const platformApiDatalakeControllerShow = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDatalakeControllerShowData, ThrowOnError>) => (options.client ?? client).get<PlatformApiDatalakeControllerShowResponses, PlatformApiDatalakeControllerShowErrors, ThrowOnError>({
-    querySerializer: { parameters: { filters: { array: { style: 'deepObject' } } } },
-    requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: v.optional(v.never()),
-        path: vPlatformApiDatalakeControllerShowPath,
-        query: v.optional(vPlatformApiDatalakeControllerShowQuery)
-    }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDatalakeControllerShowResponse, data),
-    security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/datalakes/{id}',
-    ...options
-});
-
-/**
- * Create datalake download link
+ * Creates a `tenant_admin`-issued invitation. Mirrors the LiveView flow at
+ * `/app/team` → "Invite new member". Wraps `Tenants.send_tenant_invitation/3`
+ * verbatim, including the email send.
+ *
+ * The `role` enum is **membership-level** (`member`, `researcher`, `admin`),
+ * NOT the platform-wide `User.role` enum — privilege-escalation safe by
+ * construction.
+ *
+ * Requires a tenant-scoped Bearer with membership role `:admin`
+ * (`current_role.name == "tenant_admin"`).
  *
- * Returns a presigned GET URL for an object stored in one of the datalake's cloud storage buckets (regulated or unregulated). Typical use: read a `DACRawLogFile.object_key` (`s3://bucket/key`) off a data-activation log row, split it into `bucket` and `key`, then POST here to obtain a short-lived download URL.
  */
-export const platformApiDatalakeControllerCreateDownloadLink = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDatalakeControllerCreateDownloadLinkData, ThrowOnError>) => (options.client ?? client).post<PlatformApiDatalakeControllerCreateDownloadLinkResponses, PlatformApiDatalakeControllerCreateDownloadLinkErrors, ThrowOnError>({
+export const platformApiInvitationControllerCreate = <ThrowOnError extends boolean = false>(options: Options<PlatformApiInvitationControllerCreateData, ThrowOnError>) => (options.client ?? client).post<PlatformApiInvitationControllerCreateResponses, PlatformApiInvitationControllerCreateErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: vPlatformApiDatalakeControllerCreateDownloadLinkBody,
-        path: vPlatformApiDatalakeControllerCreateDownloadLinkPath,
+        body: vPlatformApiInvitationControllerCreateBody,
+        path: vPlatformApiInvitationControllerCreatePath,
         query: v.optional(v.never())
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDatalakeControllerCreateDownloadLinkResponse, data),
-    security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/download-link',
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiInvitationControllerCreateResponse, data),
+    security: [{ scheme: 'bearer', type: 'http' }],
+    url: '/api/v1/tenants/{tenant_slug}/invitations',
     ...options,
     headers: {
         'Content-Type': 'application/json',
@@ -1664,131 +1654,127 @@ export const platformApiDatalakeControllerCreateDownloadLink = <ThrowOnError ext
 });
 
 /**
- * Download execution context
+ * List workflow execution logs
  *
- * Returns a presigned URL for downloading the execution context JSON from R2.
+ * Returns a paginated list of per-event execution logs for a workflow.
  */
-export const platformApiAgenticWorkflowOperationsControllerWorkflowLogDownload = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAgenticWorkflowOperationsControllerWorkflowLogDownloadData, ThrowOnError>) => (options.client ?? client).get<PlatformApiAgenticWorkflowOperationsControllerWorkflowLogDownloadResponses, PlatformApiAgenticWorkflowOperationsControllerWorkflowLogDownloadErrors, ThrowOnError>({
+export const platformApiAgenticWorkflowOperationsControllerWorkflowLogsIndex = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAgenticWorkflowOperationsControllerWorkflowLogsIndexData, ThrowOnError>) => (options.client ?? client).get<PlatformApiAgenticWorkflowOperationsControllerWorkflowLogsIndexResponses, PlatformApiAgenticWorkflowOperationsControllerWorkflowLogsIndexErrors, ThrowOnError>({
+    querySerializer: { parameters: { filters: { array: { style: 'deepObject' } } } },
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
         body: v.optional(v.never()),
-        path: vPlatformApiAgenticWorkflowOperationsControllerWorkflowLogDownloadPath,
-        query: v.optional(v.never())
+        path: vPlatformApiAgenticWorkflowOperationsControllerWorkflowLogsIndexPath,
+        query: v.optional(vPlatformApiAgenticWorkflowOperationsControllerWorkflowLogsIndexQuery)
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAgenticWorkflowOperationsControllerWorkflowLogDownloadResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAgenticWorkflowOperationsControllerWorkflowLogsIndexResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/agentic-workflows/{workflow_slug}/workflow-logs/{id}/download',
+    url: '/api/v1/tenants/{tenant_slug}/agentic-workflows/{workflow_slug}/workflow-logs',
     ...options
 });
 
 /**
- * Verify current session
- *
- * Returns the current session's tenant, role, and identity information.
+ * Page results from a UserSearch — outer SQL chunk + inner resource Flop
  *
- * Works with both authentication methods:
- * - `X-API-Key` header (M2M)
- * - `Authorization: Bearer <session_token>` (human sessions)
+ * Two-tier pagination at two layers:
  *
- * Use this as a "who am I" endpoint to confirm credentials are valid and
- * inspect the resolved tenant, role, and identity.
+ * * **Outer** — `outer_pagination[page]` / `outer_pagination[page_size]`
+ * (defaults `1` / `1000`, max `1000`) pages cached IDs from
+ * `search_results`. The cap is dictated by Postgres' `WHERE id IN (^ids)`
+ * plan — past ~1k parameters the planner regresses.
+ * * **Inner** — `inner_search[page]`, `inner_search[page_size]` (defaults
+ * `1` / `20`), `inner_search[order_direction]` (sort on the schema's
+ * `:global_search` compound), `inner_search[global_search]` (single
+ * ILIKE-OR text-search knob).
  *
- * **Requires authentication** (X-API-Key or Bearer token).
+ * Response carries both metas under `meta.sql` and `meta.flop`. A caller
+ * that only drives the inner page sees `meta.sql.has_next_page=true` when
+ * the SQL search isn't exhausted; advancing `outer_pagination[page]`
+ * fetches the next chunk.
  *
  */
-export const platformApiSessionControllerVerify = <ThrowOnError extends boolean = false>(options?: Options<PlatformApiSessionControllerVerifyData, ThrowOnError>) => (options?.client ?? client).get<PlatformApiSessionControllerVerifyResponses, PlatformApiSessionControllerVerifyErrors, ThrowOnError>({
+export const platformApiDatasetControllerSearch = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDatasetControllerSearchData, ThrowOnError>) => (options.client ?? client).get<PlatformApiDatasetControllerSearchResponses, PlatformApiDatasetControllerSearchErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
         body: v.optional(v.never()),
-        path: v.optional(v.never()),
-        query: v.optional(v.never())
+        path: vPlatformApiDatasetControllerSearchPath,
+        query: v.optional(vPlatformApiDatasetControllerSearchQuery)
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiSessionControllerVerifyResponse, data),
-    security: [{ name: 'X-API-Key', type: 'apiKey' }, { scheme: 'bearer', type: 'http' }],
-    url: '/api/v1/sessions/verify',
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDatasetControllerSearchResponse, data),
+    security: [{ name: 'X-API-Key', type: 'apiKey' }],
+    url: '/api/v1/datasets/{dataset}/search',
     ...options
 });
 
 /**
- * Enqueue datalake migrations
- *
- * Enqueues a `DatalakeMigrationWorker` Oban job that brings the datalake's
- * per-tenant database to the current schema version. Required after
- * `POST /datalakes`, which only persists the metadata row — it does NOT
- * run migrations against the per-tenant DB. Without this step, every
- * downstream resource that touches per-datalake tables
- * (`data_activation_logs`, MDM tables, dataset tables) will fail with
- * `relation … does not exist`.
- *
- * Asynchronous: returns 202 Accepted as soon as the job is enqueued.
- * Callers poll `GET /datalakes/:id` and watch for `status: :ready`.
- * Idempotent at the job level — re-enqueueing on a migrated datalake
- * is a no-op once the worker completes.
- *
- * The LiveView "Migrate Datalake" button calls the same migrator
- * synchronously inside the LiveView process.
- *
- * Requires a tenant-scoped Bearer with membership role `admin`.
+ * Create and execute a SQL search for a dataset
  *
+ * Creates a `UserSearch` row, runs `INSERT INTO search_results SELECT ... WHERE <search_query>` against the regulated schema, and returns the `UserSearch` resource (including `status`, `results_count`, and `error_message`). The session's `data_access_mode` controls which schema is queried.
  */
-export const platformApiDatalakeControllerMigrate = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDatalakeControllerMigrateData, ThrowOnError>) => (options.client ?? client).post<PlatformApiDatalakeControllerMigrateResponses, PlatformApiDatalakeControllerMigrateErrors, ThrowOnError>({
+export const platformApiDatasetControllerCreateUserSearch = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDatasetControllerCreateUserSearchData, ThrowOnError>) => (options.client ?? client).post<PlatformApiDatasetControllerCreateUserSearchResponses, PlatformApiDatasetControllerCreateUserSearchErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: v.optional(v.never()),
-        path: vPlatformApiDatalakeControllerMigratePath,
-        query: v.optional(v.never())
+        body: v.optional(vPlatformApiDatasetControllerCreateUserSearchBody),
+        path: vPlatformApiDatasetControllerCreateUserSearchPath,
+        query: v.optional(vPlatformApiDatasetControllerCreateUserSearchQuery)
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDatalakeControllerMigrateResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDatasetControllerCreateUserSearchResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/migrate',
-    ...options
+    url: '/api/v1/datasets/{dataset}/user-searches',
+    ...options,
+    headers: {
+        'Content-Type': 'application/json',
+        ...options.headers
+    }
 });
 
 /**
- * Delete a data activation client
+ * List batch run logs
  *
- * Deletes a DAC. Returns 422 if the DAC is a platform default (is_default=true). Returns 409 if referenced by other resources.
+ * Returns a paginated list of batch-level workflow run logs.
  */
-export const platformApiDataActivationClientControllerDelete = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDataActivationClientControllerDeleteData, ThrowOnError>) => (options.client ?? client).delete<PlatformApiDataActivationClientControllerDeleteResponses, PlatformApiDataActivationClientControllerDeleteErrors, ThrowOnError>({
+export const platformApiAgenticWorkflowOperationsControllerBatchLogsIndex = <ThrowOnError extends boolean = false>(options: Options<PlatformApiAgenticWorkflowOperationsControllerBatchLogsIndexData, ThrowOnError>) => (options.client ?? client).get<PlatformApiAgenticWorkflowOperationsControllerBatchLogsIndexResponses, PlatformApiAgenticWorkflowOperationsControllerBatchLogsIndexErrors, ThrowOnError>({
+    querySerializer: { parameters: { filters: { array: { style: 'deepObject' } } } },
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
         body: v.optional(v.never()),
-        path: vPlatformApiDataActivationClientControllerDeletePath,
-        query: v.optional(v.never())
+        path: vPlatformApiAgenticWorkflowOperationsControllerBatchLogsIndexPath,
+        query: v.optional(vPlatformApiAgenticWorkflowOperationsControllerBatchLogsIndexQuery)
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDataActivationClientControllerDeleteResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiAgenticWorkflowOperationsControllerBatchLogsIndexResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/data-activation-clients/{slug}',
+    url: '/api/v1/tenants/{tenant_slug}/agentic-workflows/{workflow_slug}/batch-logs',
     ...options
 });
 
 /**
- * Get a data activation client
+ * List action status updaters
  *
- * Returns a single DAC by datalake-scoped slug.
+ * Returns a paginated list of action status updaters for the authenticated tenant.
  */
-export const platformApiDataActivationClientControllerShow = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDataActivationClientControllerShowData, ThrowOnError>) => (options.client ?? client).get<PlatformApiDataActivationClientControllerShowResponses, PlatformApiDataActivationClientControllerShowErrors, ThrowOnError>({
+export const platformApiActionStatusUpdaterControllerIndex = <ThrowOnError extends boolean = false>(options: Options<PlatformApiActionStatusUpdaterControllerIndexData, ThrowOnError>) => (options.client ?? client).get<PlatformApiActionStatusUpdaterControllerIndexResponses, PlatformApiActionStatusUpdaterControllerIndexErrors, ThrowOnError>({
+    querySerializer: { parameters: { filters: { array: { style: 'deepObject' } } } },
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
         body: v.optional(v.never()),
-        path: vPlatformApiDataActivationClientControllerShowPath,
-        query: v.optional(v.never())
+        path: vPlatformApiActionStatusUpdaterControllerIndexPath,
+        query: v.optional(vPlatformApiActionStatusUpdaterControllerIndexQuery)
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDataActivationClientControllerShowResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiActionStatusUpdaterControllerIndexResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/data-activation-clients/{slug}',
+    url: '/api/v1/tenants/{tenant_slug}/action-status-updaters',
     ...options
 });
 
 /**
- * Replace a data activation client
+ * Create an action status updater
  *
- * Replaces a DAC with the full resource body. PUT semantics — all required fields must be present. `slug` is immutable.
+ * Creates a new action status updater for the authenticated tenant.
  */
-export const platformApiDataActivationClientControllerUpdate = <ThrowOnError extends boolean = false>(options: Options<PlatformApiDataActivationClientControllerUpdateData, ThrowOnError>) => (options.client ?? client).put<PlatformApiDataActivationClientControllerUpdateResponses, PlatformApiDataActivationClientControllerUpdateErrors, ThrowOnError>({
+export const platformApiActionStatusUpdaterControllerCreate = <ThrowOnError extends boolean = false>(options: Options<PlatformApiActionStatusUpdaterControllerCreateData, ThrowOnError>) => (options.client ?? client).post<PlatformApiActionStatusUpdaterControllerCreateResponses, PlatformApiActionStatusUpdaterControllerCreateErrors, ThrowOnError>({
+    querySerializer: { parameters: { filters: { array: { style: 'deepObject' } } } },
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: v.optional(vPlatformApiDataActivationClientControllerUpdateBody),
-        path: vPlatformApiDataActivationClientControllerUpdatePath,
-        query: v.optional(v.never())
+        body: v.optional(vPlatformApiActionStatusUpdaterControllerCreateBody),
+        path: vPlatformApiActionStatusUpdaterControllerCreatePath,
+        query: v.optional(vPlatformApiActionStatusUpdaterControllerCreateQuery)
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiDataActivationClientControllerUpdateResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiActionStatusUpdaterControllerCreateResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/data-activation-clients/{slug}',
+    url: '/api/v1/tenants/{tenant_slug}/action-status-updaters',
     ...options,
     headers: {
         'Content-Type': 'application/json',
@@ -1797,37 +1783,51 @@ export const platformApiDataActivationClientControllerUpdate = <ThrowOnError ext
 });
 
 /**
- * List tools
+ * Run a contract against a payload (sandbox)
  *
- * Returns a paginated list of tools for the authenticated tenant.
+ * Runs the contract's `filter → transform → mdm_input` pipeline against the supplied JSON row. Stateless — no DB writes. Use for template authoring/testing.
  */
-export const platformApiToolControllerIndex = <ThrowOnError extends boolean = false>(options: Options<PlatformApiToolControllerIndexData, ThrowOnError>) => (options.client ?? client).get<PlatformApiToolControllerIndexResponses, PlatformApiToolControllerIndexErrors, ThrowOnError>({
+export const platformApiInteroperabilityContractControllerRun = <ThrowOnError extends boolean = false>(options: Options<PlatformApiInteroperabilityContractControllerRunData, ThrowOnError>) => (options.client ?? client).post<PlatformApiInteroperabilityContractControllerRunResponses, PlatformApiInteroperabilityContractControllerRunErrors, ThrowOnError>({
     querySerializer: { parameters: { filters: { array: { style: 'deepObject' } } } },
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: v.optional(v.never()),
-        path: vPlatformApiToolControllerIndexPath,
-        query: v.optional(vPlatformApiToolControllerIndexQuery)
+        body: vPlatformApiInteroperabilityContractControllerRunBody,
+        path: vPlatformApiInteroperabilityContractControllerRunPath,
+        query: v.optional(vPlatformApiInteroperabilityContractControllerRunQuery)
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiToolControllerIndexResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiInteroperabilityContractControllerRunResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/tools',
-    ...options
+    url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/interoperability-contracts/{slug}/run',
+    ...options,
+    headers: {
+        'Content-Type': 'application/json',
+        ...options.headers
+    }
 });
 
 /**
- * Create a tool
+ * Resolve a short URL token to a page
+ *
+ * Given a connected app slug and a Puid short URL token, resolves the token to
+ * the pre-stored route path and MDM subject ID. The Cloudflare app calls this
+ * endpoint when a customer clicks a short URL, forwarding the original client
+ * headers (user-agent, IP, country) in the request body.
+ *
+ * When the page token is linked to a message (via workflow action execution),
+ * the regulated message details (raw body, channel, status) are included in
+ * the response.
+ *
+ * **Requires X-API-Key authentication.**
  *
- * Creates a new tool for the authenticated tenant.
  */
-export const platformApiToolControllerCreate = <ThrowOnError extends boolean = false>(options: Options<PlatformApiToolControllerCreateData, ThrowOnError>) => (options.client ?? client).post<PlatformApiToolControllerCreateResponses, PlatformApiToolControllerCreateErrors, ThrowOnError>({
+export const platformApiConnectedAppControllerResolvePage = <ThrowOnError extends boolean = false>(options: Options<PlatformApiConnectedAppControllerResolvePageData, ThrowOnError>) => (options.client ?? client).post<PlatformApiConnectedAppControllerResolvePageResponses, PlatformApiConnectedAppControllerResolvePageErrors, ThrowOnError>({
     requestValidator: async (data: unknown) => await v.parseAsync(v.object({
-        body: v.optional(vPlatformApiToolControllerCreateBody),
-        path: vPlatformApiToolControllerCreatePath,
+        body: vPlatformApiConnectedAppControllerResolvePageBody,
+        path: vPlatformApiConnectedAppControllerResolvePagePath,
         query: v.optional(v.never())
     }), data),
-    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiToolControllerCreateResponse, data),
+    responseValidator: async (data: unknown) => await v.parseAsync(vPlatformApiConnectedAppControllerResolvePageResponse, data),
     security: [{ name: 'X-API-Key', type: 'apiKey' }],
-    url: '/api/v1/tenants/{tenant_slug}/tools',
+    url: '/api/v1/tenants/{tenant_slug}/connected-apps/{slug}/resolve-page',
     ...options,
     headers: {
         'Content-Type': 'application/json',