@alvera-ai/platform-sdk 0.17.0 → 0.18.0

package/dist/index.mjs

@@ -817,6 +817,23 @@ const platformApiDatalakeControllerTextToSql = (options) => (options.client ?? c
 	}
 });
 /**
+* Get the advanced migrations catalog as markdown
+*
+* Returns one page of this datalake's advanced migrations, rendered as markdown for AI context. Accepts the same pagination, filtering and ordering parameters as `index`; each migration appears with its version, checksum and both SQL statements.
+*/
+const platformApiAdvancedMigrationControllerMetadata = (options) => (options.client ?? client).get({
+	querySerializer: { parameters: { filters: { array: { style: "deepObject" } } } },
+	security: [{
+		name: "X-API-Key",
+		type: "apiKey"
+	}, {
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/advanced-migrations/metadata",
+	...options
+});
+/**
 * Verify an X-API-Key credential
 *
 * Returns the API-key session's tenant, role, and key information — the
@@ -841,21 +858,31 @@ const platformApiSessionControllerVerifyApiKey = (options) => (options?.client ?
 /**
 * 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`.
+* Enqueues a `Platform.Datalakes.Workers.Migrator` Oban job that brings the
+* datalake's per-tenant database to the current schema version, **and one
+* more for every lake derived from it**. Asking a *derived* lake to migrate
+* enqueues only that lake. 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.
+* Asynchronous: returns 202 Accepted as soon as the jobs are 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.
+* **The response describes one job — this datalake's own.** It is the first
+* of the batch; the derived lakes' jobs queue behind it and are not reported
+* here.
+*
+* Deduplicated rather than idempotent: uniqueness is keyed on
+* `(datalake_id, mode)` across incomplete states, so a second call while the
+* first job is still queued or executing comes back with **that** job instead
+* of inserting a new one — `job_id` and `enqueued_at` are then the earlier
+* job's, and `status` still reads `enqueued`. Once the job has completed a
+* fresh one is inserted, runs, and finds nothing left to migrate.
+*
+* The LiveView "Migrate Datalake" button enqueues the same jobs through the
+* same helper. Neither path migrates inside the calling process.
 *
 * Requires a tenant-scoped Bearer with membership role `admin`.
 *
@@ -985,7 +1012,7 @@ const platformApiDataActivationClientControllerUpdate = (options) => (options.cl
 /**
 * 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.
+* Returns a presigned GET URL for an object stored in one of the datalake's cloud storage buckets (raw or tokenized). 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.
 */
 const platformApiDatalakeControllerCreateDownloadLink = (options) => (options.client ?? client).post({
 	security: [{
@@ -1050,7 +1077,7 @@ const platformApiDatalakeControllerShow = (options) => (options.client ?? client
 * can resend a full manifest unchanged.
 *
 * The platform performs the same gates as create before persisting: DB
-* connection probes against every regulated/unregulated reader/writer
+* connection probes against every raw/tokenized reader/writer
 * declared in the body, plus a cloud-storage reachability probe. Any
 * probe failure surfaces as `422 Unprocessable Entity` with the failing
 * field annotated in the changeset.
@@ -1343,7 +1370,7 @@ const platformApiWorkflowRunControllerCancel = (options) => (options.client ?? c
 /**
 * Create datalake upload link
 *
-* 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.
+* Returns a presigned PUT URL for uploading a file (NDJSON or CSV) directly to the datalake's raw 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.
 */
 const platformApiDatalakeControllerCreateUploadLink = (options) => (options.client ?? client).post({
 	querySerializer: { parameters: { filters: { array: { style: "deepObject" } } } },
@@ -1566,12 +1593,12 @@ const platformApiActionStatusUpdaterControllerRefresh = (options) => (options.cl
 * 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
+* the pre-stored route path and legal entity 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 raw message details (raw body, channel, status) are included in
 * the response.
 *
 * **Requires X-API-Key authentication.**
@@ -1625,9 +1652,9 @@ const platformApiDatalakeControllerChecksum = (options) => (options.client ?? cl
 *
 * | 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`)|
+* | `key` (response)| raw    | the raw JSON payload uploaded by THIS request                                            |
+* | `input_files`   | raw    | source artifacts consumed by the batch (one per ingest call merged into the batch)       |
+* | `output_files`  | raw    | the merged NDJSON archive as `{object_key, mode}`                                        |
 *
 * ### Fetching diagnostic artifacts
 *
@@ -1635,24 +1662,35 @@ const platformApiDatalakeControllerChecksum = (options) => (options.client ?? cl
 * (`POST /api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/download-link`):
 *
 * # raw payload that this ingest call uploaded
-* { "bucket": "<regulated>", "key": "<response.key>" }
+* { "bucket": "<raw>", "key": "<response.key>" }
 *
-* # per-bucket merged archive (after batch completes)
-* { "bucket": "<regulated|unregulated>", "key": "<output_files[i].object_key>" }
+* # merged archive (after batch completes)
+* { "bucket": "<raw>", "key": "<output_files[0].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`.
+* The lake has one bucket, so there is one archive and
+* `output_files[0].mode` is always `raw`. The bucket name is exposed on the
+* datalake response as `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.
+* `error` string.
+*
+* For pipeline failures (a row the contract refused), read the
+* `DataActivationLog` row's **`status` and `error`**: a refused row moves
+* `status` to `partial` and writes the reason into `error`. Those two are the
+* failure signal.
+*
+* **`rows_ingested` is not.** It is seeded to the submitted total when the
+* batch is enqueued and is never lowered — a batch that took ten rows and
+* persisted nine still reads ten. `dataset_updated`, maintained by a database
+* trigger, counts only the rows whose checksum actually changed, so it sits
+* below `rows_ingested` on clean batches too and cannot be used to infer a
+* failure either.
+*
+* 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.
 *
 */
 const platformApiDataActivationClientControllerIngest = (options) => (options.client ?? client).post({
@@ -1721,6 +1759,43 @@ const platformApiActionStatusUpdaterControllerUpdate = (options) => (options.cli
 	}
 });
 /**
+* List advanced migrations
+*
+* Returns a paginated list of the datalake's advanced migrations, oldest version first. A migration belongs to exactly one datalake, so this is the whole list for it.
+*/
+const platformApiAdvancedMigrationControllerIndex = (options) => (options.client ?? client).get({
+	querySerializer: { parameters: { filters: { array: { style: "deepObject" } } } },
+	security: [{
+		name: "X-API-Key",
+		type: "apiKey"
+	}, {
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/advanced-migrations",
+	...options
+});
+/**
+* Create an advanced migration
+*
+* Writes a new advanced migration for the datalake. It is stored, not executed — the migrator applies it on the datalake's next migration run, in version order. The version is assigned by the platform; `datalake_id` comes from the URL, not the body.
+*/
+const platformApiAdvancedMigrationControllerCreate = (options) => (options.client ?? client).post({
+	security: [{
+		name: "X-API-Key",
+		type: "apiKey"
+	}, {
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/advanced-migrations",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
 * Tools catalog as markdown
 *
 * Returns one page of the tools catalog for the current datalake, rendered as markdown. Accepts the same pagination, filtering, and ordering parameters as `index`; each tool appears with its wrapper fields, body-side schema, and the test-invocation block. The page's pagination state is written into a narrative line at the top of the body. Trailing `Shared Types` section documents `TemplateConfig` + Solid filters.
@@ -1802,27 +1877,31 @@ const platformApiWorkflowRunControllerShow = (options) => (options.client ?? cli
 	...options
 });
 /**
-* List industry-registered datasets for the datalake
+* List the datasets the platform registers
 *
-* Returns the **industry-registered** dataset name strings for this
-* datalake's `data_domain` — e.g. `patient`, `appointment` for
-* healthcare; `legal_entity`, `beneficial_owner` for foundation. Each
-* name is a valid argument to
+* Returns the dataset name strings the platform registers:
+* `action_log`, `beneficial_owner`, `document`, `legal_entity`, `message`.
+* Each name is a valid argument to
 * `GET /api/v1/datasets/:dataset_type/metadata` for the rendered
 * schema docs, and to `GET /api/v1/datasets/:dataset_type/search` for
 * row data.
 *
+* **The list does not vary by datalake or by tenant.** It is the key set of a
+* literal map in `Platform.Datasets`, read through
+* `Platform.Datasets.registered_datasets/0` — every datalake answers the same
+* five names, and the datalake in the path scopes the request for
+* authorisation only. There is no per-industry registry behind it.
+*
 * **This endpoint does not list user-defined generic tables.** Concern
 * separation: generic tables are CRUD-able resources with their own
 * lifecycle and live under
 * `GET /api/v1/tenants/:tenant_slug/datalakes/:datalake_slug/generic-tables`.
 * To enumerate the full set of queryable datasets a caller must hit
-* both endpoints (`system-datasets` for industry built-ins and
+* both endpoints (`system-datasets` for the platform-registered five and
 * `generic-tables` for operator-defined ones). Each surface owns one
 * concern: enumeration here, lifecycle there.
 *
-* Pure read — no DB access on the platform side. Derived from
-* `Platform.Dataset.get_registered_datasets/1`.
+* Pure read — no DB access on the platform side.
 *
 */
 const platformApiDatalakeControllerSystemDatasets = (options) => (options.client ?? client).get({
@@ -2028,7 +2107,7 @@ const platformApiDatasetControllerSearch = (options) => (options.client ?? clien
 /**
 * 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.
+* Creates a `UserSearch` row, runs `INSERT INTO search_results SELECT ... WHERE <search_query>` against the lake, and returns the `UserSearch` resource (including `status`, `results_count`, and `error_message`). The session's `data_access_mode` controls which schema is queried.
 */
 const platformApiDatasetControllerCreateUserSearch = (options) => (options.client ?? client).post({
 	security: [{
@@ -2046,6 +2125,45 @@ const platformApiDatasetControllerCreateUserSearch = (options) => (options.clien
 	}
 });
 /**
+* How far each table in a derived lake's copy has got
+*
+* Every table the tokenized or redacted copy carries, and how far each one has
+* got. The same list, in the same words, that the platform's own Tokenization
+* screen shows — a table reading `copying` there never reads something else here.
+*
+* **Every table, not only the ones behind.** A caller cannot ask to re-copy a
+* table it cannot see, and a table someone merely suspects has to be listed even
+* when the copy says it is fine.
+*
+* Only `caught_up` has arrived. `finished_copy` sounds like it has and has not:
+* the first pass is done and the changes since have not been applied yet, so a
+* table sitting there is still behind.
+*
+* For tables that are behind, `resync_empties` says what `POST .../resync` would
+* actually empty — the table plus anything that points at it. Postgres will not
+* empty a table anything references, so re-copying a parent means re-copying its
+* children too, and a caller offering that action should be able to say how many
+* before it happens.
+*
+* `:mode` is `tokenized` or `redacted` and names the COPY. The path names the
+* primary lake, because a derived lake is reached by naming its primary and a
+* data-access mode — it has a slug, but a slug is not an address.
+*
+* Requires a tenant-scoped Bearer with membership role `admin`.
+*
+*/
+const platformApiDatalakeControllerDerivedLakeTables = (options) => (options.client ?? client).get({
+	security: [{
+		name: "X-API-Key",
+		type: "apiKey"
+	}, {
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/tokenization/{mode}/tables",
+	...options
+});
+/**
 * Compute the drift checksum for a generic table config
 *
 * Returns the server-computed drift fingerprint a create/update would stamp for the submitted config, without persisting anything. `alvera plan` posts the operator's desired config here and compares the result against the deployed table's `checksum` (from GET) to decide absent / unchanged / edited.
@@ -2627,9 +2745,29 @@ const platformApiAgenticWorkflowOperationsControllerBatchLogsIndex = (options) =
 	...options
 });
 /**
+* Compute the drift checksum for an advanced migration config
+*
+* Returns the server-computed drift fingerprint a create/replace would stamp for the submitted config, without persisting anything. `alvera plan` posts the desired config here and compares the result against the stored `checksum` (from GET) to decide absent / unchanged / edited. The version is server-assigned and is deliberately not part of the fingerprint.
+*/
+const platformApiAdvancedMigrationControllerChecksum = (options) => (options.client ?? client).post({
+	security: [{
+		name: "X-API-Key",
+		type: "apiKey"
+	}, {
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/advanced-migrations/checksum",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
 * Get datalakes catalog as markdown
 *
-* Returns one page of the datalake catalog for the tenant, rendered as markdown — each entry carries slug, name, data_domain, status, repo_version and points at the per-datalake metadata endpoint for the full domain inventory. Accepts the same pagination, filtering, and ordering parameters as the datalake `index`; the page's pagination state is written into a narrative line at the top.
+* Returns one page of the datalake catalog for the tenant, rendered as markdown — each entry carries slug, name, status, repo_version and points at the per-datalake metadata endpoint for the full domain inventory. Accepts the same pagination, filtering, and ordering parameters as the datalake `index`; the page's pagination state is written into a narrative line at the top.
 */
 const platformApiDatalakeControllerMetadata = (options) => (options.client ?? client).get({
 	querySerializer: { parameters: { filters: { array: { style: "deepObject" } } } },
@@ -2644,6 +2782,54 @@ const platformApiDatalakeControllerMetadata = (options) => (options.client ?? cl
 	...options
 });
 /**
+* Empty one table in a derived lake's copy and copy it again
+*
+* The repair for a table that stopped arriving because the copy already held
+* rows it was being sent. Restarting the copy cannot fix that one — it restarts a
+* worker and discards nothing, so a copy that broke on a row it cannot insert
+* breaks on the same row again.
+*
+* **It empties the table, then copies it from the start.** Every row in a derived
+* lake can be produced again from the original, which is what makes emptying one
+* a repair rather than a loss. Nothing is written to the original lake — the only
+* thing that changes there is which tables its publication names, and only for
+* the tables being repaired.
+*
+* **It may empty more than one table.** Postgres will not empty a table anything
+* points at, however few rows the referencing tables hold, so repairing a parent
+* empties its children too — all of them re-copied by the same run. The response
+* says exactly which tables were emptied, and `GET .../tables` says beforehand.
+*
+* **It refuses a name it did not give you.** The table must be one this copy
+* carries or one the original can send. That gate is what stands between a typo
+* and an emptied table.
+*
+* **It does not roll back.** A failure part-way leaves the table empty and says
+* so, because the rows to put back are the ones that broke the copy in the first
+* place.
+*
+* Returns **202**: a fresh first pass has started and finishes later. Poll
+* `GET .../tables` and wait for the table to read `caught_up`.
+*
+* Requires a tenant-scoped Bearer with membership role `admin`.
+*
+*/
+const platformApiDatalakeControllerResyncTable = (options) => (options.client ?? client).post({
+	security: [{
+		name: "X-API-Key",
+		type: "apiKey"
+	}, {
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/tokenization/{mode}/resync",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
 * Single action status updater metadata as markdown
 *
 * Returns markdown for one action status updater — wrapper + cron + updater body + template configs + bound tools. Drill into a bound tool's full metadata via `GET /datalakes/:datalake_slug/tools/:id/metadata`.
@@ -2771,12 +2957,12 @@ const platformApiDataActivationClientControllerCreate = (options) => (options.cl
 	}
 });
 /**
-* Verify subject identity
+* Verify legal entity identity
 *
-* Verify a subject's identity against their master record using the
+* Verify a legal entity's identity against its master record using the
 * datalake's data-domain matching rules.
 *
-* The body carries `subject_id` plus the subject's identity fields in the
+* The body carries `legal_entity_id` plus the legal entity's identity fields in the
 * **datalake's native vocabulary** — see the `MDMVerifyRequest` schema for
 * the field set per data domain (person identity, company identity, and
 * universal fields such as `identifiers`/`phone`/`email`). String fields are
@@ -2879,6 +3065,61 @@ const platformApiDatasetControllerDatasetMetadata = (options) => (options.client
 	...options
 });
 /**
+* Turn tokenization on for a datalake
+*
+* Provisions the two lakes derived from a raw one — the tokenized lake and
+* the redacted lake — and enqueues a migration for each. Returns the raw
+* lake with `derived_datalakes` preloaded.
+*
+* **Tokenization does not run in production, and needs a manual flag to
+* enable.** The setting naming where the derived databases run exists in
+* development and test configuration and nowhere else, so in an environment
+* where nobody has stood those databases up and pointed the platform at them,
+* this call cannot succeed — the two databases have to exist first. The
+* console's button is gated on the same check and does not render there.
+*
+* **Intended as both or neither** — they are created, destroyed and paid for
+* together. **Not atomic today.** The two are provisioned in sequence and each
+* commits on its own, so a run that provisions the tokenized lake and then
+* cannot provision the redacted one reports the failure and leaves the first in
+* place. Making the pair transactional is filed tech debt.
+*
+* A caller that gets an error here should re-read the lake and check
+* `derived_datalakes` rather than assume nothing was created. Note that the
+* console's "Turn on tokenization" button only appears when there are none, so a
+* half-provisioned lake is repaired through this endpoint or not at all.
+*
+* **Idempotent.** Already-provisioned lakes are returned exactly as they are,
+* so this is safe to call twice.
+*
+* The migration is not optional and not a second call: a derived lake is
+* provisioned EMPTY, and it needs the same tables the primary has before a
+* single row can land in it. Migrating is what labels its columns and starts
+* the copy. Those migrations are asynchronous — poll `GET /datalakes` and
+* watch the derived lakes for `status: :ready`.
+*
+* A derived lake is otherwise fully managed: nothing writes to one but the
+* replication apply, and there is no endpoint that creates, configures or
+* deletes one directly.
+*
+* The LiveView "Turn on tokenization" button does the same two things in the
+* same order.
+*
+* Requires a tenant-scoped Bearer with membership role `admin`.
+*
+*/
+const platformApiDatalakeControllerProvisionTokenization = (options) => (options.client ?? client).post({
+	security: [{
+		name: "X-API-Key",
+		type: "apiKey"
+	}, {
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/tokenization",
+	...options
+});
+/**
 * Delete a connected app
 *
 * Deletes a connected app (addressed by id) within the authenticated datalake. For managed apps, infrastructure cleanup is queued before the record is removed.
@@ -3020,7 +3261,7 @@ const platformApiToolControllerChecksum = (options) => (options.client ?? client
 /**
 * Get single system template details as markdown
 *
-* Returns markdown for one system template, identified by its basename (`filename`) + `intent` query parameter. The datalake's `data_domain` (derived from `:datalake_slug`) is combined with `intent` to compute the search prefix; the server then resolves `filename` uniquely under that prefix. Out-of-domain templates are unreachable by URL construction. Returns 404 if no match, 409 if the basename is ambiguous within the resolved scope.
+* Returns markdown for one system template, identified by its basename (`filename`) + `intent` query parameter. The datalake (derived from `:datalake_slug`) is combined with `intent` to compute the search prefix; the server then resolves `filename` uniquely under that prefix. Out-of-domain templates are unreachable by URL construction. Returns 404 if no match, 409 if the basename is ambiguous within the resolved scope.
 */
 const platformApiTemplatesControllerMetadataDetails = (options) => (options.client ?? client).get({
 	security: [{
@@ -3100,7 +3341,7 @@ const platformApiDatalakeControllerExecuteSql = (options) => (options.client ??
 * ## 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
+* artifacts to the datalake's cloud-storage bucket. The path is
 * deterministic and convention-driven — there is no separate listing
 * endpoint:
 *
@@ -3125,13 +3366,13 @@ const platformApiDatalakeControllerExecuteSql = (options) => (options.client ??
 *
 * 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:
+* with `bucket = <the datalake's 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" }
+* { "bucket": "clinical-lake", "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`.
+* The response carries a short-lived signed URL. The raw bucket is
+* exposed on the datalake response as `cloud_storage.bucket`.
 *
 */
 const platformApiAgenticWorkflowOperationsControllerRunWorkflow = (options) => (options.client ?? client).post({
@@ -3218,9 +3459,14 @@ const platformApiAgenticWorkflowOperationsControllerBatchLogStart = (options) =>
 *
 * 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.
+* datalake message linked via `message_id`.
+*
+* **This surface is raw-only.** There is one message body, nothing masks it,
+* and the message is read from the raw lake. The endpoint used to take a
+* `data_access_mode` query parameter and publish it as selecting which
+* database was read; it was checked in a function guard and never used, and
+* because the guard consumed the variable no unused-variable warning was ever
+* emitted. It is gone rather than made to work.
 *
 */
 const platformApiAgenticWorkflowOperationsControllerWorkflowLogShow = (options) => (options.client ?? client).get({
@@ -3235,6 +3481,22 @@ const platformApiAgenticWorkflowOperationsControllerWorkflowLogShow = (options)
 	...options
 });
 /**
+* Get one advanced migration as markdown
+*
+* Returns a single advanced migration rendered as markdown for AI context.
+*/
+const platformApiAdvancedMigrationControllerMetadataDetails = (options) => (options.client ?? client).get({
+	security: [{
+		name: "X-API-Key",
+		type: "apiKey"
+	}, {
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/advanced-migrations/{id}/metadata",
+	...options
+});
+/**
 * Delete an interoperability contract
 *
 * Deletes a contract (addressed by id). System-created contracts are rejected with 422. DAC mappings to this contract are removed via DB cascade.
@@ -3290,9 +3552,61 @@ const platformApiInteroperabilityContractControllerUpdate = (options) => (option
 	}
 });
 /**
+* Delete an advanced migration
+*
+* Deletes an advanced migration that has not yet run. Returns 409 Conflict once it has been applied — the log of it running is tied to it, so deleting it would erase the record that it ever happened.
+*/
+const platformApiAdvancedMigrationControllerDelete = (options) => (options.client ?? client).delete({
+	security: [{
+		name: "X-API-Key",
+		type: "apiKey"
+	}, {
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/advanced-migrations/{id}",
+	...options
+});
+/**
+* Get an advanced migration
+*
+* Returns one advanced migration by id within the datalake. A migration belonging to another datalake answers 404 rather than revealing that it exists.
+*/
+const platformApiAdvancedMigrationControllerShow = (options) => (options.client ?? client).get({
+	security: [{
+		name: "X-API-Key",
+		type: "apiKey"
+	}, {
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/advanced-migrations/{id}",
+	...options
+});
+/**
+* Replace an advanced migration
+*
+* Replaces an advanced migration that has not yet run. Returns 409 Conflict once it has been applied — a statement that has already executed against a lake cannot be rewritten after the fact, because the rewritten text would no longer describe what happened.
+*/
+const platformApiAdvancedMigrationControllerUpdate = (options) => (options.client ?? client).put({
+	security: [{
+		name: "X-API-Key",
+		type: "apiKey"
+	}, {
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/advanced-migrations/{id}",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
 * Delete a generic table
 *
-* Deletes a custom generic table addressed by id. Guarded: returns 409 Conflict when the backing table still holds rows — delete the rows first. When empty, drops both physical tables (regulated + unregulated) and removes the metadata.
+* Deletes a custom generic table addressed by id. Guarded: returns 409 Conflict when the backing table still holds rows — delete the rows first. When empty, drops both physical tables and removes the metadata.
 */
 const platformApiGenericTableControllerDelete = (options) => (options.client ?? client).delete({
 	security: [{
@@ -3324,7 +3638,7 @@ const platformApiGenericTableControllerShow = (options) => (options.client ?? cl
 /**
 * Update a generic table
 *
-* Full-replace update of a custom generic table, addressed by id within the datalake. Every field in the request is required (PUT semantics) — the same body shape as create, so `alvera apply` can resend a full manifest to reconcile drift. Re-runs the regulated mirror + migration for the new column set.
+* Full-replace update of a custom generic table, addressed by id within the datalake. Every field in the request is required (PUT semantics) — the same body shape as create, so `alvera apply` can resend a full manifest to reconcile drift. Re-runs the mirror + migration for the new column set.
 */
 const platformApiGenericTableControllerUpdate = (options) => (options.client ?? client).put({
 	security: [{
@@ -3344,7 +3658,21 @@ const platformApiGenericTableControllerUpdate = (options) => (options.client ??
 /**
 * Run a contract against a payload (sandbox)
 *
-* Runs the contract's `filter → transform → mdm_input` pipeline against the supplied JSON row. Stateless — no DB writes. Use for template authoring/testing.
+* Runs three of the contract's pipeline stages — `filter → transform →
+* mdm_input` — against the supplied JSON row. Stateless: no DB writes, no MDM
+* resolution, no upsert. Use for template authoring/testing.
+*
+* **It does not run AI agent enrichment, and ingestion does.** The real
+* pipeline is `filter → ai_agent_enrichment → transform → mdm_input →
+* mdm.resolve → upsert`, and enrichment is what puts each attached agent's
+* parsed output under `enrichment.<agent_slug>` before the transform sees the
+* row. This endpoint hands the raw payload straight to **both** the transform
+* and the mdm_input render — ingestion hands each of them the enriched row —
+* so on a contract with agents attached every `{{ enrichment.… }}` reference
+* renders blank here and renders filled in production. Neither a transform
+* template nor an mdm_input template that reads enrichment can be proven
+* correct on this endpoint.
+*
 */
 const platformApiInteroperabilityContractControllerRun = (options) => (options.client ?? client).post({
 	querySerializer: { parameters: { filters: { array: { style: "deepObject" } } } },
@@ -3658,6 +3986,10 @@ function _buildApi(myClient) {
 			verifyApiKey: () => platformApiSessionControllerVerifyApiKey({
 				client: myClient,
 				throwOnError: true
+			}),
+			delete: () => platformApiSessionControllerDelete({
+				client: myClient,
+				throwOnError: true
 			})
 		},
 		admin: {
@@ -3820,6 +4152,7 @@ function _buildApi(myClient) {
 			metadata: (tenantSlug, query) => platformApiDatalakeControllerMetadata({
 				path: { tenant_slug: tenantSlug },
 				query,
+				querySerializer: bracketQuerySerializer,
 				client: myClient,
 				throwOnError: true
 			}),
@@ -3847,6 +4180,33 @@ function _buildApi(myClient) {
 				client: myClient,
 				throwOnError: true
 			}),
+			provisionTokenization: (tenantSlug, datalakeSlug) => platformApiDatalakeControllerProvisionTokenization({
+				path: {
+					tenant_slug: tenantSlug,
+					datalake_slug: datalakeSlug
+				},
+				client: myClient,
+				throwOnError: true
+			}),
+			derivedLakeTables: (tenantSlug, datalakeSlug, mode) => platformApiDatalakeControllerDerivedLakeTables({
+				path: {
+					tenant_slug: tenantSlug,
+					datalake_slug: datalakeSlug,
+					mode
+				},
+				client: myClient,
+				throwOnError: true
+			}),
+			resyncTable: (tenantSlug, datalakeSlug, mode, body) => platformApiDatalakeControllerResyncTable({
+				path: {
+					tenant_slug: tenantSlug,
+					datalake_slug: datalakeSlug,
+					mode
+				},
+				body,
+				client: myClient,
+				throwOnError: true
+			}),
 			createUploadLink: (tenantSlug, datalakeSlug, body) => platformApiDatalakeControllerCreateUploadLink({
 				path: {
 					tenant_slug: tenantSlug,
@@ -3890,6 +4250,82 @@ function _buildApi(myClient) {
 				});
 			}
 		},
+		advancedMigrations: {
+			list: (tenantSlug, datalakeSlug, query) => platformApiAdvancedMigrationControllerIndex({
+				path: {
+					tenant_slug: tenantSlug,
+					datalake_slug: datalakeSlug
+				},
+				query,
+				querySerializer: bracketQuerySerializer,
+				client: myClient,
+				throwOnError: true
+			}),
+			get: (tenantSlug, datalakeSlug, id) => platformApiAdvancedMigrationControllerShow({
+				path: {
+					tenant_slug: tenantSlug,
+					datalake_slug: datalakeSlug,
+					id
+				},
+				client: myClient,
+				throwOnError: true
+			}),
+			create: (tenantSlug, datalakeSlug, body) => platformApiAdvancedMigrationControllerCreate({
+				path: {
+					tenant_slug: tenantSlug,
+					datalake_slug: datalakeSlug
+				},
+				body,
+				client: myClient,
+				throwOnError: true
+			}),
+			update: (tenantSlug, datalakeSlug, id, body) => platformApiAdvancedMigrationControllerUpdate({
+				path: {
+					tenant_slug: tenantSlug,
+					datalake_slug: datalakeSlug,
+					id
+				},
+				body,
+				client: myClient,
+				throwOnError: true
+			}),
+			delete: (tenantSlug, datalakeSlug, id) => platformApiAdvancedMigrationControllerDelete({
+				path: {
+					tenant_slug: tenantSlug,
+					datalake_slug: datalakeSlug,
+					id
+				},
+				client: myClient,
+				throwOnError: true
+			}),
+			checksum: (tenantSlug, datalakeSlug, body) => platformApiAdvancedMigrationControllerChecksum({
+				path: {
+					tenant_slug: tenantSlug,
+					datalake_slug: datalakeSlug
+				},
+				body,
+				client: myClient,
+				throwOnError: true
+			}),
+			metadata: (tenantSlug, datalakeSlug, query) => platformApiAdvancedMigrationControllerMetadata({
+				path: {
+					tenant_slug: tenantSlug,
+					datalake_slug: datalakeSlug
+				},
+				query,
+				client: myClient,
+				throwOnError: true
+			}),
+			metadataDetails: (tenantSlug, datalakeSlug, id) => platformApiAdvancedMigrationControllerMetadataDetails({
+				path: {
+					tenant_slug: tenantSlug,
+					datalake_slug: datalakeSlug,
+					id
+				},
+				client: myClient,
+				throwOnError: true
+			})
+		},
 		dataSources: {
 			list: (tenantSlug, datalakeSlug, query) => platformApiDataSourceControllerIndex({
 				path: {
@@ -4818,14 +5254,13 @@ function _buildApi(myClient) {
 					client: myClient,
 					throwOnError: true
 				}),
-				get: (tenantSlug, datalakeSlug, workflowSlug, id, opts) => platformApiAgenticWorkflowOperationsControllerWorkflowLogShow({
+				get: (tenantSlug, datalakeSlug, workflowSlug, id) => platformApiAgenticWorkflowOperationsControllerWorkflowLogShow({
 					path: {
 						tenant_slug: tenantSlug,
 						datalake_slug: datalakeSlug,
 						workflow_slug: workflowSlug,
 						id
 					},
-					...opts?.dataAccessMode ? { query: { data_access_mode: opts.dataAccessMode } } : {},
 					client: myClient,
 					throwOnError: true
 				}),