@metabase/cli 0.3.1-alpha.versioning.9ac5f50 → 0.3.2-alpha.fix-transform-test-ee-path.041c793

package/dist/{client-Bv7Iwdvh.mjs → client-cJ7aw0Gt.mjs}

@@ -1,31 +1,32 @@
-import { $ as ValidationError, K as ConfigError, X as ResponseShapeError, Y as NetworkError, Z as TimeoutError, et as errorMessage, it as createServerProfile, n as methodRequirements, q as InternalError } from "./cli.mjs";
+import { $ as InternalError, Q as ConfigError, at as ValidationError, n as methodRequirements, nt as ResponseShapeError, ot as errorMessage, rt as TimeoutError, tt as NetworkError } from "./cli.mjs";
 import { n as Notification, r as NotificationCardPayload, t as CARD_PAYLOAD_TYPE } from "./notification-DaA4bBHW.mjs";
-import { $ as probeServer, B as JSON_CONTENT_TYPE, F as buildNetworkError, G as credentialSecrets, H as parseJsonOrPlain, I as isConnectionClosed, J as normalizeUrl, L as HttpError, Q as checkRequirements, U as assertCredentialHeaderSafe, V as parseJson, W as credentialAuthHeader, et as CapabilityError, z as isRetryableStatus } from "./runtime-BQiGgbgZ.mjs";
-import { n as throwIfAborted, r as untilAborted, t as combineAborts } from "./signal-GhGmuHfx.mjs";
-import { s as FieldValues, t as Field } from "./field-Cr2DPUG9.mjs";
-import { r as ParameterValues } from "./parameter-DUKR8NXo.mjs";
-import { o as CardQueryResult, t as Card } from "./card-DZxRmver.mjs";
-import { p as CollectionTreeNode, r as Collection, s as CollectionItem } from "./collection-WFdBeyqa.mjs";
+import { $ as createServerProfile, B as JSON_CONTENT_TYPE, F as buildNetworkError, G as credentialSecrets, H as parseJsonOrPlain, I as isConnectionClosed, J as normalizeUrl, L as HttpError, U as assertCredentialHeaderSafe, V as parseJson, W as credentialAuthHeader, Z as checkFeatures, et as probeServer, tt as CapabilityError, z as isRetryableStatus } from "./runtime-arKqJqIT.mjs";
+import { n as throwIfAborted, r as untilAborted, t as combineAborts } from "./signal-k7cm5N6h.mjs";
+import { a as FieldSearchMatches, i as FieldRemappedValue, l as FieldValues, n as FieldBaseType, o as FieldSemanticType, t as Field } from "./field-CcN4oZy6.mjs";
+import { a as TemporalUnit, r as ParameterValues } from "./parameter-Celg0wZa.mjs";
+import { a as CardQueryResult, l as DatasetQuery, s as CardType, t as Card } from "./card-voh1k4hl.mjs";
+import { c as TableVisibilityType, i as TableForeignKey, o as TableQueryMetadata, r as TableDataLayerTier, t as Table } from "./table-DfuY0N8e.mjs";
+import { t as Database } from "./database-JtHTqSpq.mjs";
+import { t as Snippet } from "./snippet-CyKAgIZl.mjs";
+import { c as CollectionItem, i as CollectionAuthorityLevel, m as CollectionTreeNode, r as Collection, s as CollectionId } from "./collection-BxdPxD38.mjs";
 import { t as ContentTranslationUploadResult } from "./content-translation-BrHOrmj9.mjs";
-import { i as DashboardDetail, s as Dashcard, t as Dashboard } from "./dashboard-CKUR8ZpQ.mjs";
-import { i as TableQueryMetadata, t as Table } from "./table-CeeTJgQb.mjs";
-import { t as Database } from "./database-C8G6ZKG0.mjs";
-import { r as pollUntil } from "./poll-By46YQ5J.mjs";
-import { t as Document } from "./document-Cd2mmqCp.mjs";
+import { a as DashboardDetail, c as Dashcard, r as DashboardCopy, t as Dashboard } from "./dashboard-D0hwTC-f.mjs";
+import { r as pollUntil } from "./poll-CZeXepUQ.mjs";
+import { t as Document } from "./document-BHpLJbKU.mjs";
 import { i as EidTranslateResult } from "./eid-translation-zEHtr5Oc.mjs";
-import { f as isSyncTaskTerminal, l as SyncTask, n as SyncDirtyItem, o as SyncRemoteChanges, s as SyncSettingsUpdateResult, t as SyncBranchCreated } from "./git-sync-BDnxPrqU.mjs";
-import { a as toLibrary, i as libraryWireSchema, n as LibraryCollectionInfo } from "./library-DXB8sm4r.mjs";
+import { c as SyncSettingsUpdateResult, i as SyncExportPreflight, n as SyncDirtyItem, p as isSyncTaskTerminal, s as SyncRemoteChanges, t as SyncBranchCreated, u as SyncTask } from "./git-sync-BwBRmEhE.mjs";
+import { a as toLibrary, i as libraryWireSchema, n as LibraryCollectionInfo } from "./library-BPIzb3K_.mjs";
 import { t as Measure } from "./measure-CtfjqJFP.mjs";
-import { t as Pulse } from "./pulse-BmsDenXm.mjs";
-import { r as SearchResult } from "./search-DFBwUc6d.mjs";
+import { t as Pulse } from "./pulse-Dz0ocv0l.mjs";
+import { a as TransformDagTransform, d as TransformTarget, g as transformRowSchema, h as transformDetailSchema, i as TransformDagRunResult, l as TransformRunSummary, m as isTransformRunTerminal, o as TransformRun, p as isTransformRunFailed, u as TransformSourceTableEntry } from "./transform-DiW7bREn.mjs";
+import { r as SearchResult } from "./search-BAXg-EJw.mjs";
 import { t as Segment } from "./segment-OsrbUDzw.mjs";
 import { t as Setting } from "./setting-DTiLCW8g.mjs";
 import { n as SetupResult } from "./setup-CO7QV-ao.mjs";
-import { t as Snippet } from "./snippet-CyKAgIZl.mjs";
 import { i as TimelineEvent, t as Timeline } from "./timeline-CCSU2qOS.mjs";
-import { d as transformDetailSchema, f as transformRowSchema, i as TransformRun, l as isTransformRunFailed, u as isTransformRunTerminal } from "./transform-DpuG-ON3.mjs";
 import { c as transformJobSchema, n as TransformJobActiveResult, s as transformJobRunResultSchema } from "./transform-job-CCguL6LP.mjs";
 import { t as TransformTag } from "./transform-tag-CcElGp3C.mjs";
+import { i as TransformTestRunResult, t as TransformTest } from "./transform-test-BjjCQ2xm.mjs";
 import { t as UploadResult } from "./upload-DAtxBBms.mjs";
 import { z } from "zod";
 import { setTimeout } from "node:timers/promises";
@@ -261,14 +262,18 @@ function createTransport(config, options) {
 		return untilAborted(serverProfile, wait.signal);
 	}
 	const enforceRequirements = options.enforceRequirements ?? true;
-	async function requireFeatures(key, wait = {}) {
-		if (!enforceRequirements || methodRequirements(key).length === 0) return;
-		const failure = checkRequirements(key, await server(wait));
+	async function requireFeatures(features, wait = {}) {
+		if (!enforceRequirements || features.length === 0) return;
+		const failure = checkFeatures(features, await server(wait));
 		if (failure !== null) throw new CapabilityError(failure);
 	}
+	async function requireMethod(key, wait = {}) {
+		return requireFeatures(methodRequirements(key), wait);
+	}
 	const transport = {
 		server,
-		require: requireFeatures,
+		require: requireMethod,
+		requireFeatures,
 		async requestRaw(path, opts) {
 			return (await executeWithAuthRefresh(path, opts ?? {})).response;
 		},
@@ -301,8 +306,7 @@ function createTransport(config, options) {
 	return transport;
 }
 function tagOf(profile) {
-	if (profile === null || profile.version === null) return null;
-	return profile.version.tag;
+	return profile === null ? null : profile.version.tag;
 }
 function buildUrl(baseUrl, path, query) {
 	const normalizedPath = path.startsWith("/") ? path : `/${path}`;
@@ -346,6 +350,44 @@ async function readBodyForError(response) {
 	}
 }
 //#endregion
+//#region ../client/src/domain/dataset.ts
+const CompiledQuery = z.object({
+	query: z.union([z.string(), z.array(z.unknown())]),
+	params: z.array(z.unknown()).nullable().optional(),
+	collection: z.string().optional()
+}).loose();
+const FieldRef = z.tuple([
+	z.literal("field"),
+	z.string(),
+	z.object({ "base-type": FieldBaseType }).loose()
+]);
+const VirtualField = z.object({
+	id: z.union([z.number().int(), FieldRef]),
+	table_id: z.string(),
+	name: z.string(),
+	display_name: z.string(),
+	base_type: FieldBaseType,
+	semantic_type: FieldSemanticType.nullable(),
+	fk_target_field_id: z.number().int().nullable().optional()
+}).loose();
+const VirtualTable = z.object({
+	id: z.string(),
+	db_id: z.number().int(),
+	display_name: z.string(),
+	schema: z.string(),
+	description: z.string().nullable(),
+	type: CardType,
+	moderated_status: z.string().nullable(),
+	entity_id: z.string().nullable(),
+	fields: z.array(VirtualField)
+}).loose();
+const QueryMetadata = z.object({
+	databases: z.array(Database),
+	tables: z.array(z.union([TableQueryMetadata, VirtualTable])),
+	fields: z.array(Field),
+	snippets: z.array(Snippet)
+}).loose();
+//#endregion
 //#region ../client/src/resources/card.ts
 const CardApiList = z.array(Card);
 function cardResource(transport) {
@@ -417,6 +459,14 @@ function cardResource(transport) {
 			body
 		});
 	}
+	/**
+	* Get all of the required query metadata for a saved card: the databases, tables, fields and
+	* snippets its query references, plus the card's own metadata for a model or a native query.
+	*/
+	async function queryMetadata(id, options = {}) {
+		await transport.require("card.queryMetadata", options);
+		return transport.requestParsed(QueryMetadata, `/api/card/${id}/query_metadata`, { ...options });
+	}
 	return {
 		list,
 		get,
@@ -424,7 +474,8 @@ function cardResource(transport) {
 		update,
 		archive,
 		query,
-		exportQuery
+		exportQuery,
+		queryMetadata
 	};
 }
 async function* paginatePages(client, path, itemSchema, opts = {}) {
@@ -664,6 +715,20 @@ function dashboardResource(transport) {
 		});
 	}
 	/**
+	* Copy a dashboard, with its tabs and dashcards, into `collection_id` (root when absent). A deep
+	* copy duplicates the cards it can; otherwise the copy references them, except dashboard
+	* questions, which are always duplicated. Cards the caller cannot read are left behind and
+	* reported as `uncopied`.
+	*/
+	async function copy(id, params = {}, options = {}) {
+		await transport.require("dashboard.copy", options);
+		return transport.requestParsed(DashboardCopy, `/api/dashboard/${id}/copy`, {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	/**
 	* Archive (soft-delete) a dashboard by id. Metabase models this as an update, not its own
 	* endpoint. The answer is read as `Dashboard` rather than the `DashboardDetail` `update` returns:
 	* an archive is a state change on the dashboard itself, and its dashcards are not part of it.
@@ -750,6 +815,7 @@ function dashboardResource(transport) {
 		create,
 		update,
 		archive,
+		copy,
 		updateDashcard,
 		checkCardReferences,
 		parameterValues,
@@ -900,7 +966,298 @@ function datasetResource(transport) {
 			body
 		});
 	}
-	return { query };
+	/**
+	* Fetch a native version of an MBQL query. `pretty` rides in the same body as the query and
+	* defaults server-side to true.
+	*/
+	async function native(datasetQuery, params = {}, options = {}) {
+		await transport.require("dataset.native", options);
+		return transport.requestParsed(CompiledQuery, "/api/dataset/native", {
+			...options,
+			method: "POST",
+			body: {
+				...datasetQuery,
+				pretty: params.pretty
+			}
+		});
+	}
+	/**
+	* Get all of the required query metadata for an ad-hoc query: the databases, tables, fields and
+	* snippets it references. `{ settings: { "include-sensitive-fields": true } }` inside the query
+	* widens the field filter.
+	*/
+	async function queryMetadata(datasetQuery, options = {}) {
+		await transport.require("dataset.queryMetadata", options);
+		return transport.requestParsed(QueryMetadata, "/api/dataset/query_metadata", {
+			...options,
+			method: "POST",
+			body: datasetQuery
+		});
+	}
+	/**
+	* Run an ad-hoc query and stream its result as a download. Unlike `query`, this endpoint answers
+	* bytes, so a caller consumes the stream rather than a value.
+	*/
+	async function exportQuery(format, params, options = {}) {
+		await transport.require("dataset.exportQuery", options);
+		return transport.requestStream(`/api/dataset/${format}`, {
+			...options,
+			method: "POST",
+			body: {
+				query: params.query,
+				format_rows: params.format_rows,
+				pivot_results: params.pivot_results
+			}
+		});
+	}
+	return {
+		query,
+		native,
+		queryMetadata,
+		exportQuery
+	};
+}
+//#endregion
+//#region ../client/src/domain/dependency.ts
+const DependencyType = z.enum([
+	"table",
+	"card",
+	"snippet",
+	"transform",
+	"dashboard",
+	"document",
+	"sandbox",
+	"segment",
+	"measure"
+]);
+const DependencyUsageType = z.enum([
+	"table",
+	"snippet",
+	"transform",
+	"dashboard",
+	"document",
+	"sandbox",
+	"segment",
+	"question",
+	"model",
+	"metric",
+	"measure"
+]);
+const DependencyFindingErrorType = z.enum([
+	"missing-column",
+	"missing-table-alias",
+	"missing-table",
+	"missing-card",
+	"duplicate-column",
+	"syntax-error",
+	"validation-exception-error"
+]);
+const DependencyErrorSourceType = z.enum([
+	"table",
+	"card",
+	"transform"
+]);
+z.enum([
+	"name",
+	"location",
+	"view-count"
+]);
+z.enum([
+	"name",
+	"location",
+	"dependents-with-errors",
+	"dependents-errors"
+]);
+const DependencyCollectionRef = z.object({
+	id: CollectionId,
+	name: z.string(),
+	authority_level: CollectionAuthorityLevel.nullable(),
+	is_personal: z.boolean().optional()
+}).loose();
+const DependencyContainerRef = z.object({
+	id: z.number().int(),
+	name: z.string()
+}).loose();
+const DependencyEntityData = z.object({
+	name: z.string().nullable().optional(),
+	display_name: z.string().nullable().optional(),
+	description: z.string().nullable().optional(),
+	type: CardType.nullable().optional(),
+	display: z.string().nullable().optional(),
+	database_id: z.number().int().nullable().optional(),
+	db_id: z.number().int().nullable().optional(),
+	schema: z.string().nullable().optional(),
+	collection_id: CollectionId.nullable().optional(),
+	collection: DependencyCollectionRef.nullable().optional(),
+	dashboard_id: z.number().int().nullable().optional(),
+	dashboard: DependencyContainerRef.nullable().optional(),
+	document_id: z.number().int().nullable().optional(),
+	document: DependencyContainerRef.nullable().optional(),
+	table_id: z.number().int().nullable().optional(),
+	view_count: z.number().int().nullable().optional()
+}).loose();
+const DependencyEntity = z.object({
+	id: z.number().int(),
+	type: DependencyType,
+	data: DependencyEntityData
+}).loose();
+const DependencyNode = DependencyEntity.extend({ dependents_count: z.partialRecord(DependencyUsageType, z.number().int()).nullable() });
+const DependencyFindingError = z.object({
+	id: z.number().int(),
+	analyzed_entity_type: DependencyType,
+	analyzed_entity_id: z.number().int(),
+	error_type: DependencyFindingErrorType,
+	error_detail: z.string().nullable().optional(),
+	source_entity_type: DependencyErrorSourceType.nullable().optional(),
+	source_entity_id: z.number().int().nullable().optional()
+}).loose();
+const BreakingSource = DependencyNode.extend({ dependents_errors: z.array(DependencyFindingError).nullable().optional() });
+const DependencyEdge = z.object({
+	from_entity_type: DependencyType,
+	from_entity_id: z.number().int(),
+	to_entity_type: DependencyType,
+	to_entity_id: z.number().int()
+}).loose();
+const DependencyGraph = z.object({
+	nodes: z.array(DependencyNode),
+	edges: z.array(DependencyEdge)
+}).loose();
+//#endregion
+//#region ../client/src/resources/dependency.ts
+const DependencyNodeApiList = z.array(DependencyNode);
+const DependencyEntityApiList = z.array(DependencyEntity);
+const RENAMED_FILTERS = [
+	"dependent-types",
+	"dependent-card-types",
+	"card-types",
+	"include-personal-collections",
+	"sort-column",
+	"sort-direction"
+];
+function filterFeatures(params) {
+	return RENAMED_FILTERS.some((key) => params[key] !== void 0) ? ["dependencyKebabCaseFilters"] : [];
+}
+function dependencyResource(transport) {
+	/**
+	* The upstream dependency graph of one entity. `nodes` holds the starting entity plus every
+	* entity it depends on, directly or transitively; each edge runs from the dependent to what it
+	* depends on.
+	*/
+	async function graph(type, id, options = {}) {
+		await transport.require("dependency.graph", options);
+		return transport.requestParsed(DependencyGraph, "/api/ee/dependencies/graph", {
+			...options,
+			query: {
+				type,
+				id
+			}
+		});
+	}
+	/**
+	* The entities that depend directly on one entity. `dependent-types` and `dependent-card-types`
+	* narrow which kinds are listed, `broken` keeps only those whose query the entity has broken,
+	* `query` matches against names and locations, `include-personal-collections` admits content in
+	* personal collections, and `sort-column` / `sort-direction` order the result.
+	*/
+	async function dependents(type, id, params = {}, options = {}) {
+		await transport.require("dependency.dependents", options);
+		await transport.requireFeatures(filterFeatures(params), options);
+		return {
+			data: await transport.requestParsed(DependencyNodeApiList, "/api/ee/dependencies/graph/dependents", {
+				...options,
+				query: {
+					type,
+					id,
+					"dependent-types": params["dependent-types"],
+					"dependent-card-types": params["dependent-card-types"],
+					broken: params.broken,
+					query: params.query,
+					"include-personal-collections": params["include-personal-collections"],
+					"sort-column": params["sort-column"],
+					"sort-direction": params["sort-direction"]
+				}
+			}),
+			total: null
+		};
+	}
+	/**
+	* The dependents of one entity whose queries it has broken, as bare entities without a
+	* dependents count. `dependent-types` and `dependent-card-types` narrow which kinds are listed,
+	* `include-personal-collections` admits content in personal collections, and `sort-column` /
+	* `sort-direction` order the result.
+	*/
+	async function broken(type, id, params = {}, options = {}) {
+		await transport.require("dependency.broken", options);
+		await transport.requireFeatures(filterFeatures(params), options);
+		return {
+			data: await transport.requestParsed(DependencyEntityApiList, "/api/ee/dependencies/graph/broken", {
+				...options,
+				query: {
+					type,
+					id,
+					"dependent-types": params["dependent-types"],
+					"dependent-card-types": params["dependent-card-types"],
+					"include-personal-collections": params["include-personal-collections"],
+					"sort-column": params["sort-column"],
+					"sort-direction": params["sort-direction"]
+				}
+			}),
+			total: null
+		};
+	}
+	/**
+	* Walk the entities nothing depends on, one page at a time. `types` and `card-types` narrow
+	* which kinds are listed, `query` matches against names and locations,
+	* `include-personal-collections` admits content in personal collections, and `sort-column` /
+	* `sort-direction` order the result. This endpoint pages on the server, so the caller consumes
+	* pages and decides how far to pull.
+	*/
+	async function* unreferencedPages(params = {}, options = {}) {
+		await transport.require("dependency.unreferencedPages", options);
+		await transport.requireFeatures(filterFeatures(params), options);
+		yield* paginatePages(transport, "/api/ee/dependencies/graph/unreferenced", DependencyNode, {
+			query: itemListQuery(params),
+			...options.offset !== void 0 && { offset: options.offset },
+			...options.max !== void 0 && { max: options.max },
+			...options.pageSize !== void 0 && { pageSize: options.pageSize },
+			...options.signal !== void 0 && { signal: options.signal }
+		});
+	}
+	/**
+	* Walk the entities whose dependents carry analysis errors, one page at a time, each with the
+	* `dependents_errors` rows found downstream of it. The server lists cards and tables unless
+	* `types` says otherwise; `card-types`, `query`, `include-personal-collections`, `sort-column`
+	* and `sort-direction` read as on `unreferencedPages`. This endpoint pages on the server, so the
+	* caller consumes pages and decides how far to pull.
+	*/
+	async function* breakingPages(params = {}, options = {}) {
+		await transport.require("dependency.breakingPages", options);
+		await transport.requireFeatures(filterFeatures(params), options);
+		yield* paginatePages(transport, "/api/ee/dependencies/graph/breaking", BreakingSource, {
+			query: itemListQuery(params),
+			...options.offset !== void 0 && { offset: options.offset },
+			...options.max !== void 0 && { max: options.max },
+			...options.pageSize !== void 0 && { pageSize: options.pageSize },
+			...options.signal !== void 0 && { signal: options.signal }
+		});
+	}
+	return {
+		graph,
+		dependents,
+		broken,
+		unreferencedPages,
+		breakingPages
+	};
+}
+function itemListQuery(params) {
+	return {
+		types: params.types,
+		"card-types": params["card-types"],
+		query: params.query,
+		"include-personal-collections": params["include-personal-collections"],
+		"sort-column": params["sort-column"],
+		"sort-direction": params["sort-direction"]
+	};
 }
 //#endregion
 //#region ../client/src/resources/document.ts
@@ -942,12 +1299,25 @@ function documentResource(transport) {
 		await transport.require("document.archive", options);
 		return update(id, { archived: true }, options);
 	}
+	/**
+	* Copy a document into `collection_id` (root when absent), duplicating the cards saved inside
+	* it. An archived source is not found.
+	*/
+	async function copy(id, params = {}, options = {}) {
+		await transport.require("document.copy", options);
+		return transport.requestParsed(Document, `/api/document/${id}/copy`, {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
 	return {
 		list,
 		get,
 		create,
 		update,
-		archive
+		archive,
+		copy
 	};
 }
 //#endregion
@@ -969,6 +1339,82 @@ function eidTranslationResource(transport) {
 	return { translate };
 }
 //#endregion
+//#region ../client/src/domain/erd.ts
+const ErdField = z.object({
+	id: z.number().int(),
+	name: z.string(),
+	display_name: z.string(),
+	database_type: z.string(),
+	base_type: FieldBaseType.nullable(),
+	effective_type: FieldBaseType.nullable(),
+	semantic_type: FieldSemanticType.nullable(),
+	fk_target_field_id: z.number().int().nullable(),
+	fk_target_table_id: z.number().int().nullable()
+}).loose();
+const ErdOwner = z.object({
+	id: z.number().int().optional(),
+	email: z.string(),
+	first_name: z.string().nullable().optional(),
+	last_name: z.string().nullable().optional()
+}).loose().nullable();
+const ErdNode = z.object({
+	table_id: z.number().int(),
+	name: z.string(),
+	display_name: z.string(),
+	description: z.string().nullable(),
+	owner: ErdOwner,
+	schema: z.string().nullable(),
+	visibility_type: TableVisibilityType.nullable(),
+	db_id: z.number().int(),
+	fields: z.array(ErdField)
+}).loose();
+const ErdEdge = z.object({
+	source_table_id: z.number().int(),
+	source_field_id: z.number().int(),
+	target_table_id: z.number().int(),
+	target_field_id: z.number().int(),
+	relationship: z.enum(["one-to-one", "many-to-one"])
+}).loose();
+const Erd = z.object({
+	nodes: z.array(ErdNode),
+	edges: z.array(ErdEdge)
+}).loose();
+//#endregion
+//#region ../client/src/resources/erd.ts
+const ERD_PATH = "/api/ee/erd";
+function erdResource(transport) {
+	/**
+	* Get the entity relationship diagram of a database: the readable tables as nodes, each with its
+	* fields, and the foreign keys between them as edges. `table-ids` makes those tables the focal
+	* points and draws their neighbours; `schema` keeps one schema, the empty string the tables with
+	* none.
+	*/
+	async function get(params, options = {}) {
+		await transport.require("erd.get", options);
+		return transport.requestParsed(Erd, ERD_PATH, {
+			...options,
+			query: {
+				"database-id": params["database-id"],
+				"table-ids": params["table-ids"],
+				schema: params.schema
+			}
+		});
+	}
+	return { get };
+}
+//#endregion
+//#region ../client/src/resources/optional-parsed.ts
+const NO_CONTENT_STATUS = 204;
+async function fetchOptionalParsed(client, path, schema, options = {}) {
+	const response = await client.requestRaw(path, {
+		...options,
+		method: "GET",
+		expectContentType: "binary"
+	});
+	if (response.status === NO_CONTENT_STATUS) return null;
+	return parseJsonOrPlain(await response.text(), response.headers.get("content-type"), schema, { source: response.url });
+}
+//#endregion
 //#region ../client/src/resources/field.ts
 const FieldApiSummary = z.tuple([z.tuple([z.literal("count"), z.number().int()]), z.tuple([z.literal("distincts"), z.number().int()])]);
 function fieldResource(transport) {
@@ -977,15 +1423,47 @@ function fieldResource(transport) {
 		await transport.require("field.get", options);
 		return transport.requestParsed(Field, `/api/field/${id}`, { ...options });
 	}
-	/** Update a field by id, patching only the fields the body carries. */
+	/**
+	* Update a field by id, patching only the fields the body carries. A `data_sensitivity` label is
+	* a person's call the server's classifier never overwrites, and `null` withdraws it so the
+	* classifier's own applies again; a server without the column would drop the key silently, so
+	* the label is refused there before the wire.
+	*/
 	async function update(id, params, options = {}) {
 		await transport.require("field.update", options);
+		await transport.requireFeatures(params.data_sensitivity === void 0 ? [] : ["fieldDataSensitivity"], options);
 		return transport.requestParsed(Field, `/api/field/${id}`, {
 			...options,
 			method: "PUT",
 			body: params
 		});
 	}
+	/**
+	* Search the values of `searchId` that contain `value`, case-insensitively, answering the
+	* matching values of `id` paired with them. An FK on either side is followed to the PK it
+	* points at. Without `value`, the first `limit` values.
+	*/
+	async function search(id, searchId, params, options = {}) {
+		await transport.require("field.search", options);
+		return transport.requestParsed(FieldSearchMatches, `/api/field/${id}/search/${searchId}`, {
+			...options,
+			query: {
+				value: params.value,
+				limit: params.limit
+			}
+		});
+	}
+	/**
+	* The value of `remappedId` on the one row where `id` equals `value`, as `[value, remapped]`,
+	* or `null` when no row matches. `value` is parsed as a number for a numeric field.
+	*/
+	async function remapping(id, remappedId, params, options = {}) {
+		await transport.require("field.remapping", options);
+		return fetchOptionalParsed(transport, `/api/field/${id}/remapping/${remappedId}`, FieldRemappedValue, {
+			...options,
+			query: { value: params.value }
+		});
+	}
 	/** Get the row count and the distinct-value count for a field. */
 	async function summary(id, options = {}) {
 		await transport.require("field.summary", options);
@@ -1004,23 +1482,13 @@ function fieldResource(transport) {
 	return {
 		get,
 		update,
+		search,
+		remapping,
 		summary,
 		values
 	};
 }
 //#endregion
-//#region ../client/src/resources/optional-parsed.ts
-const NO_CONTENT_STATUS = 204;
-async function fetchOptionalParsed(client, path, schema, options = {}) {
-	const response = await client.requestRaw(path, {
-		...options,
-		method: "GET",
-		expectContentType: "binary"
-	});
-	if (response.status === NO_CONTENT_STATUS) return null;
-	return parseJsonOrPlain(await response.text(), response.headers.get("content-type"), schema, { source: response.url });
-}
-//#endregion
 //#region ../client/src/resources/git-sync.ts
 const SyncScopeCollection = Collection.pick({
 	id: true,
@@ -1141,6 +1609,19 @@ function gitSyncResource(transport) {
 		};
 	}
 	/**
+	* Preview what exporting to `branch` would do against the live remote, without writing: whether
+	* the remote has moved on, whether a merge would apply cleanly, which entities conflict, and what
+	* a force push would discard. `branch` must be the one git-sync tracks; the server answers 409
+	* otherwise.
+	*/
+	async function exportPreflight(params, options = {}) {
+		await transport.require("gitSync.exportPreflight", options);
+		return transport.requestParsed(SyncExportPreflight, "/api/ee/remote-sync/export-preflight", {
+			...options,
+			query: { branch: params.branch }
+		});
+	}
+	/**
 	* Export Metabase's current content to a branch the remote does not have yet. The endpoint
 	* queues a task and returns at once; pass `wait` to poll that task to a terminal status.
 	*/
@@ -1214,10 +1695,18 @@ function gitSyncResource(transport) {
 			throw error;
 		}
 	}
-	/** The branch git-sync tracks, or null when none is configured or the caller may not read it. */
+	/**
+	* The branch git-sync tracks, or null when none is configured, the caller may not read it, or
+	* the server has no remote-sync module.
+	*/
 	async function branch(options = {}) {
 		await transport.require("gitSync.branch", options);
-		return fetchOptionalParsed(transport, "/api/setting/remote-sync-branch", RemoteSyncSetting, options);
+		try {
+			return await fetchOptionalParsed(transport, "/api/setting/remote-sync-branch", RemoteSyncSetting, options);
+		} catch (error) {
+			if (isRemoteUnreadable(error)) return null;
+			throw error;
+		}
 	}
 	/**
 	* Poll the current task until it reaches a terminal status. A server with no task at all
@@ -1241,6 +1730,7 @@ function gitSyncResource(transport) {
 		hasRemoteChanges,
 		import: importFromRemote,
 		export: exportToRemote,
+		exportPreflight,
 		stash,
 		branches,
 		createBranch,
@@ -1252,6 +1742,84 @@ function gitSyncResource(transport) {
 	};
 }
 //#endregion
+//#region ../client/src/domain/glossary.ts
+const GlossaryCreator = z.object({
+	id: z.number().int(),
+	email: z.string(),
+	first_name: z.string().nullable(),
+	last_name: z.string().nullable()
+}).loose();
+const Glossary = z.object({
+	id: z.number().int(),
+	term: z.string(),
+	definition: z.string(),
+	creator_id: z.number().int(),
+	creator: GlossaryCreator,
+	created_at: z.string(),
+	updated_at: z.string()
+}).loose();
+Glossary.pick({
+	id: true,
+	term: true,
+	definition: true
+}).strip();
+z.object({
+	term: z.string().min(1),
+	definition: z.string().min(1)
+}).strict();
+//#endregion
+//#region ../client/src/resources/glossary.ts
+const GlossaryApiList = z.object({ data: z.array(Glossary) }).loose();
+function glossaryResource(transport) {
+	/**
+	* List glossary entries in term order. `search` keeps the entries whose term or definition
+	* contains it, case-insensitively.
+	*/
+	async function list(params = {}, options = {}) {
+		await transport.require("glossary.list", options);
+		return {
+			data: (await transport.requestParsed(GlossaryApiList, "/api/glossary", {
+				...options,
+				query: { search: params.search }
+			})).data,
+			total: null
+		};
+	}
+	/** Create a glossary entry, a term and its definition. Terms are unique. */
+	async function create(params, options = {}) {
+		await transport.require("glossary.create", options);
+		return transport.requestParsed(Glossary, "/api/glossary", {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	/** Replace the term and definition of a glossary entry by id. */
+	async function update(id, params, options = {}) {
+		await transport.require("glossary.update", options);
+		return transport.requestParsed(Glossary, `/api/glossary/${id}`, {
+			...options,
+			method: "PUT",
+			body: params
+		});
+	}
+	/** Delete a glossary entry by id. */
+	async function remove(id, options = {}) {
+		await transport.require("glossary.delete", options);
+		await transport.requestRaw(`/api/glossary/${id}`, {
+			...options,
+			method: "DELETE",
+			expectContentType: "binary"
+		});
+	}
+	return {
+		list,
+		create,
+		update,
+		delete: remove
+	};
+}
+//#endregion
 //#region ../client/src/resources/library.ts
 const LIBRARY_ROOT_PATH = "/api/ee/library/";
 const PUBLISH_TABLES_PATH = "/api/ee/data-studio/table/publish-tables";
@@ -1390,30 +1958,260 @@ function measureResource(transport) {
 	};
 }
 //#endregion
-//#region ../client/src/resources/notification.ts
-const NotificationApiList = z.array(Notification);
-function assertCardAlert(notification) {
-	if (notification.payload_type !== "notification/card") throw new ConfigError(`notification ${notification.id} is a ${notification.payload_type}, not a question alert — this operation accepts card alerts only`);
-	return notification;
-}
-function mergeAlertUpdate(current, patch) {
-	return Notification.parse({
-		...current,
-		...patch,
-		id: current.id,
-		payload: patch.payload === void 0 ? current.payload : mergePayload(current, patch.payload)
-	});
-}
-function mergePayload(current, patch) {
-	if (current.payload === null) throw new ConfigError(`alert ${current.id} has lost its card payload — it can be archived, but not patched`);
-	return NotificationCardPayload.parse({
-		...current.payload,
-		...patch
-	});
-}
-function notificationResource(transport) {
-	/**
-	* List question alerts, optionally narrowed by the card they watch, their creator, or a
+//#region ../client/src/domain/metric.ts
+const ClauseOptions = z.object({}).loose();
+const MetricLeafType = z.enum(["metric", "measure"]);
+const MetricLeafRef = z.tuple([
+	MetricLeafType,
+	z.object({ "lib/uuid": z.string().min(1) }).strict(),
+	z.number().int().positive()
+]);
+const MetricMathOperator = z.enum([
+	"+",
+	"-",
+	"*",
+	"/"
+]);
+const MetricMathExpression = z.lazy(() => z.union([
+	MetricLeafRef,
+	z.number(),
+	z.tuple([
+		MetricMathOperator,
+		ClauseOptions,
+		MetricMathExpression,
+		MetricMathExpression
+	]).rest(MetricMathExpression)
+]));
+const MetricBinning = z.discriminatedUnion("strategy", [
+	z.object({ strategy: z.literal("default") }).strict(),
+	z.object({
+		strategy: z.literal("bin-width"),
+		"bin-width": z.number().positive()
+	}).strict(),
+	z.object({
+		strategy: z.literal("num-bins"),
+		"num-bins": z.number().int().positive()
+	}).strict()
+]);
+const MetricDimensionRefOptions = z.object({
+	"lib/uuid": z.string().min(1).optional(),
+	"display-name": z.string().min(1).nullable().optional(),
+	"effective-type": FieldBaseType.nullable().optional(),
+	"semantic-type": FieldSemanticType.nullable().optional(),
+	"temporal-unit": TemporalUnit.nullable().optional(),
+	binning: MetricBinning.nullable().optional()
+}).strict();
+const MetricDimensionRef = z.tuple([
+	z.literal("dimension"),
+	MetricDimensionRefOptions,
+	z.string().min(1)
+]);
+const MetricFilterArgument = z.lazy(() => z.union([
+	MetricDimensionRef,
+	MetricFilterClause,
+	z.string(),
+	z.number(),
+	z.boolean(),
+	z.null()
+]));
+const MetricFilterClause = z.lazy(() => z.tuple([z.string().min(1), ClauseOptions]).rest(MetricFilterArgument));
+const MetricInstanceFilter = z.object({
+	"lib/uuid": z.string().min(1),
+	filter: MetricFilterClause
+}).strict();
+const MetricProjection = z.object({
+	type: MetricLeafType,
+	id: z.number().int().positive(),
+	"lib/uuid": z.string().min(1),
+	projection: z.array(MetricDimensionRef)
+}).strict();
+z.object({
+	expression: MetricMathExpression,
+	filters: z.array(MetricInstanceFilter).nullable().optional(),
+	projections: z.array(MetricProjection).nullable().optional()
+}).strict();
+const MetricBreakoutColumn = z.object({
+	name: z.string().optional(),
+	display_name: z.string().optional(),
+	base_type: FieldBaseType.optional(),
+	effective_type: FieldBaseType.optional(),
+	semantic_type: FieldSemanticType.nullable().optional()
+}).loose();
+const MetricBreakoutValues = z.object({
+	values: z.array(z.unknown()),
+	col: MetricBreakoutColumn
+}).loose();
+const MetricDimensionStatus = z.enum(["status/active", "status/orphaned"]);
+const MetricDimensionSource = z.object({
+	type: z.literal("field"),
+	"field-id": z.number().int().nullable()
+}).loose();
+const MetricDimensionGroup = z.object({
+	id: z.string(),
+	type: z.enum(["main", "connection"]),
+	display_name: z.string()
+}).loose();
+const MetricDimension = z.object({
+	id: z.string(),
+	name: z.string().nullable(),
+	display_name: z.string().nullable(),
+	description: z.string().nullable().optional(),
+	effective_type: FieldBaseType.nullable(),
+	semantic_type: FieldSemanticType.nullable(),
+	has_field_values: z.enum([
+		"list",
+		"search",
+		"none"
+	]).optional(),
+	status: MetricDimensionStatus.optional(),
+	status_message: z.string().optional(),
+	sources: z.array(MetricDimensionSource).optional(),
+	group: MetricDimensionGroup.optional(),
+	dimension_interestingness: z.number().optional(),
+	default_temporal_unit: TemporalUnit.optional(),
+	default: z.boolean().nullable().optional()
+}).loose();
+MetricDimension.pick({
+	id: true,
+	name: true,
+	display_name: true,
+	description: true,
+	effective_type: true,
+	semantic_type: true,
+	status: true,
+	group: true,
+	default: true
+}).strip();
+const MetricMappingTarget = z.tuple([z.string(), ClauseOptions]).rest(z.unknown());
+const MetricAddableDimension = MetricDimension.extend({ mapping_target: MetricMappingTarget });
+const MetricAddableGroup = z.object({
+	group: MetricDimensionGroup.nullable(),
+	dimensions: z.array(MetricAddableDimension)
+}).loose();
+const MetricDimensionListing = z.object({
+	added: z.array(MetricDimension),
+	addable: z.array(MetricAddableGroup)
+}).loose();
+//#endregion
+//#region ../client/src/resources/metric.ts
+function metricResource(transport) {
+	/**
+	* Run a metric definition and return the query result envelope: one metric or measure, or an
+	* arithmetic expression over several, each leaf filtered and projected on its own `lib/uuid`.
+	*/
+	async function query(definition, options = {}) {
+		await transport.require("metric.query", options);
+		return transport.requestParsed(CardQueryResult, "/api/metric/dataset", {
+			...options,
+			method: "POST",
+			body: { definition }
+		});
+	}
+	/**
+	* Fetch the distinct values of a definition's breakout dimension, with that column's metadata.
+	* Takes the same definition `query` does.
+	*/
+	async function breakoutValues(definition, options = {}) {
+		await transport.require("metric.breakoutValues", options);
+		return transport.requestParsed(MetricBreakoutValues, "/api/metric/breakout-values", {
+			...options,
+			method: "POST",
+			body: { definition }
+		});
+	}
+	/**
+	* List a metric's curated dimensions and, under `with-addable`, the columns still available to
+	* add, grouped by source table. `query` filters both by a name substring.
+	*/
+	async function dimensions(id, params = {}, options = {}) {
+		await transport.require("metric.dimensions", options);
+		return transport.requestParsed(MetricDimensionListing, `/api/metric/${id}/dimension`, {
+			...options,
+			query: {
+				query: params.query,
+				"with-addable": params["with-addable"],
+				"include-orphaned": params["include-orphaned"]
+			}
+		});
+	}
+	return {
+		query,
+		breakoutValues,
+		dimensions
+	};
+}
+//#endregion
+//#region ../client/src/domain/moderation-review.ts
+const ModeratedItemType = z.enum(["card", "dashboard"]);
+const ModerationStatus = z.enum(["verified"]);
+const ModerationReview = z.object({
+	id: z.number().int(),
+	moderated_item_id: z.number().int(),
+	moderated_item_type: ModeratedItemType,
+	moderator_id: z.number().int(),
+	status: ModerationStatus.nullable(),
+	text: z.string().nullable(),
+	most_recent: z.boolean(),
+	created_at: z.string(),
+	updated_at: z.string()
+}).loose();
+ModerationReview.pick({
+	id: true,
+	moderated_item_id: true,
+	moderated_item_type: true,
+	status: true,
+	text: true,
+	most_recent: true
+}).strip();
+z.object({
+	moderated_item_id: z.number().int().positive(),
+	moderated_item_type: ModeratedItemType,
+	status: ModerationStatus.nullable().optional(),
+	text: z.string().nullable().optional()
+}).strict();
+//#endregion
+//#region ../client/src/resources/moderation-review.ts
+function moderationReviewResource(transport) {
+	/**
+	* Create a moderation review on a card or dashboard. `status: "verified"` marks the item
+	* verified, `null` or an absent status records a note that leaves it unverified. The new review
+	* becomes the item's most recent one; the server keeps the ten newest per item. Admins only.
+	*/
+	async function create(params, options = {}) {
+		await transport.require("moderationReview.create", options);
+		return transport.requestParsed(ModerationReview, "/api/moderation-review", {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	return { create };
+}
+//#endregion
+//#region ../client/src/resources/notification.ts
+const NotificationApiList = z.array(Notification);
+function assertCardAlert(notification) {
+	if (notification.payload_type !== "notification/card") throw new ConfigError(`notification ${notification.id} is a ${notification.payload_type}, not a question alert — this operation accepts card alerts only`);
+	return notification;
+}
+function mergeAlertUpdate(current, patch) {
+	return Notification.parse({
+		...current,
+		...patch,
+		id: current.id,
+		payload: patch.payload === void 0 ? current.payload : mergePayload(current, patch.payload)
+	});
+}
+function mergePayload(current, patch) {
+	if (current.payload === null) throw new ConfigError(`alert ${current.id} has lost its card payload — it can be archived, but not patched`);
+	return NotificationCardPayload.parse({
+		...current.payload,
+		...patch
+	});
+}
+function notificationResource(transport) {
+	/**
+	* List question alerts, optionally narrowed by the card they watch, their creator, or a
 	* recipient. `/api/notification` also serves Metabase's internal system-event notifications, so
 	* the request pins the card payload type.
 	*/
@@ -1485,6 +2283,72 @@ function notificationResource(transport) {
 	};
 }
 //#endregion
+//#region ../client/src/domain/permission.ts
+const ViewDataPermission = z.enum([
+	"unrestricted",
+	"legacy-no-self-service",
+	"blocked",
+	"sandboxed",
+	"impersonated"
+]);
+const CreateQueriesPermission = z.enum([
+	"query-builder-and-native",
+	"query-builder",
+	"no"
+]);
+const DownloadPermission = z.enum(["full", "limited"]);
+const DataModelPermission = z.literal("all");
+const YesNoPermission = z.enum(["yes", "no"]);
+function granular(value) {
+	const perTable = z.record(z.string(), value);
+	const perSchema = z.record(z.string(), z.union([value, perTable]));
+	return z.union([value, perSchema]);
+}
+const DatabasePermissions = z.object({
+	"view-data": granular(ViewDataPermission).optional(),
+	"create-queries": granular(CreateQueriesPermission).optional(),
+	download: z.object({ schemas: granular(DownloadPermission) }).loose().optional(),
+	"data-model": z.object({ schemas: granular(DataModelPermission) }).loose().optional(),
+	details: YesNoPermission.optional(),
+	transforms: YesNoPermission.optional()
+}).loose();
+const PermissionsGraph = z.object({
+	revision: z.number().int().nonnegative(),
+	groups: z.record(z.string(), z.record(z.string(), DatabasePermissions))
+}).loose();
+//#endregion
+//#region ../client/src/resources/permission.ts
+function permissionResource(transport) {
+	/**
+	* Get the data permissions of every group on every database, keyed by group id then database
+	* id. Admin only. One read of the whole `data_permissions` table, so prefer `databaseGraph` when
+	* one database is the question.
+	*/
+	async function graph(options = {}) {
+		await transport.require("permission.graph", options);
+		return transport.requestParsed(PermissionsGraph, "/api/permissions/graph", { ...options });
+	}
+	/**
+	* Get the data permissions of every group on one database. Admin only. The read is filtered to
+	* that database, so this is the cheapest way to learn which groups can query a table: look the
+	* group up under the database and read `view-data` and `create-queries` down to the table id.
+	*/
+	async function databaseGraph(id, options = {}) {
+		await transport.require("permission.databaseGraph", options);
+		return transport.requestParsed(PermissionsGraph, `/api/permissions/graph/db/${id}`, { ...options });
+	}
+	/** Get the data permissions of one group on every database. Admin only. */
+	async function groupGraph(id, options = {}) {
+		await transport.require("permission.groupGraph", options);
+		return transport.requestParsed(PermissionsGraph, `/api/permissions/graph/group/${id}`, { ...options });
+	}
+	return {
+		graph,
+		databaseGraph,
+		groupGraph
+	};
+}
+//#endregion
 //#region ../client/src/resources/pulse.ts
 const PulseApiList = z.array(Pulse);
 function mergePulseUpdate(current, patch) {
@@ -1550,6 +2414,284 @@ function pulseResource(transport) {
 	};
 }
 //#endregion
+//#region ../client/src/domain/replacement.ts
+const ReplacementSourceType = z.enum(["card", "table"]);
+const ReplacementEntityType = z.enum([...ReplacementSourceType.options, "transform"]);
+const ReplacementRunStatus = z.enum([
+	"pending",
+	"started",
+	"succeeded",
+	"failed",
+	"canceled",
+	"timeout"
+]);
+const ReplacementRun = z.object({
+	id: z.number().int(),
+	status: ReplacementRunStatus,
+	is_active: z.literal(true).nullable(),
+	source_entity_type: ReplacementEntityType,
+	source_entity_id: z.number().int(),
+	target_entity_type: ReplacementEntityType,
+	target_entity_id: z.number().int(),
+	progress: z.number().min(0).max(1).nullable(),
+	message: z.string().nullable(),
+	user_id: z.number().int().nullable(),
+	start_time: z.string(),
+	end_time: z.string().nullable()
+}).loose();
+ReplacementRun.pick({
+	id: true,
+	status: true,
+	source_entity_type: true,
+	source_entity_id: true,
+	target_entity_type: true,
+	target_entity_id: true,
+	progress: true,
+	message: true,
+	start_time: true,
+	end_time: true
+}).strip();
+const ReplacementColumn = z.object({
+	id: z.number().int().nullable(),
+	name: z.string(),
+	display_name: z.string(),
+	base_type: FieldBaseType.nullable(),
+	effective_type: FieldBaseType.nullable(),
+	semantic_type: FieldSemanticType.nullable()
+});
+const ReplacementColumnError = z.enum([
+	"column-type-mismatch",
+	"missing-primary-key",
+	"missing-foreign-key",
+	"foreign-key-mismatch"
+]);
+const ReplacementColumnMatched = z.object({
+	source: ReplacementColumn,
+	target: ReplacementColumn,
+	errors: z.array(ReplacementColumnError).optional()
+}).strict();
+const ReplacementColumnMissingOnTarget = z.object({ source: ReplacementColumn }).strict();
+const ReplacementColumnMissingOnSource = z.object({ target: ReplacementColumn }).strict();
+const ReplacementColumnMapping = z.union([
+	ReplacementColumnMatched,
+	ReplacementColumnMissingOnTarget,
+	ReplacementColumnMissingOnSource
+]);
+const ReplacementError = z.enum([
+	"cycle-detected",
+	"database-mismatch",
+	"incompatible-implicit-joins",
+	"affects-gtap-policies"
+]);
+const ReplacementCheck = z.object({
+	success: z.boolean(),
+	errors: z.array(ReplacementError).optional(),
+	column_mappings: z.array(ReplacementColumnMapping).optional()
+});
+z.object({
+	source_entity_id: z.number().int().positive(),
+	source_entity_type: ReplacementSourceType,
+	target_entity_id: z.number().int().positive(),
+	target_entity_type: ReplacementSourceType
+}).strict();
+z.object({
+	card_id: z.number().int().positive(),
+	transform_name: z.string(),
+	transform_target: TransformTarget,
+	target_collection_id: z.number().int().positive().nullable().optional(),
+	transform_tag_ids: z.array(z.number().int().positive()).nullable().optional()
+}).strict();
+const ReplacementRunStarted = z.object({ run_id: z.number().int().positive() });
+//#endregion
+//#region ../client/src/resources/replacement.ts
+const ReplacementApiRunList = z.array(ReplacementRun);
+const CancelRunResponse = z.object({ success: z.literal(true) });
+function replacementResource(transport) {
+	/**
+	* Check whether every usage of a source entity could be rewritten to read a target entity
+	* instead: the two must share a database, the target must not depend on the source, every source
+	* column must exist on the target with a compatible type, and a table source must not be joined
+	* implicitly or sandboxed. Admins only.
+	*/
+	async function checkReplaceSource(params, options = {}) {
+		await transport.require("replacement.checkReplaceSource", options);
+		return transport.requestParsed(ReplacementCheck, "/api/ee/replacement/check-replace-source", {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	/**
+	* Rewrite every usage of a source entity to read a target entity, in the background. Runs the
+	* same check as `checkReplaceSource` first and refuses with a 400 when it fails, and with a 409
+	* while another replacement is running. Admins only.
+	*/
+	async function replaceSource(params, options = {}) {
+		await transport.require("replacement.replaceSource", options);
+		return transport.requestParsed(ReplacementRunStarted, "/api/ee/replacement/replace-source", {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	/**
+	* Create a transform from a model's query, run it, and rewrite every usage of the model to read
+	* the transform's output table, in the background; the model becomes a saved question. A failed
+	* transform run leaves the model as it was; a failed rewrite keeps the transform and its table
+	* as well, since other queries may already read them. Refuses with a 409 while another
+	* replacement is running. Admins only.
+	*/
+	async function replaceModelWithTransform(params, options = {}) {
+		await transport.require("replacement.replaceModelWithTransform", options);
+		return transport.requestParsed(ReplacementRunStarted, "/api/ee/replacement/replace-model-with-transform", {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	/**
+	* List replacement runs, newest first. `is-active: true` keeps only the run in progress,
+	* `false` only the ended ones. Admins only.
+	*/
+	async function listRuns(params = {}, options = {}) {
+		await transport.require("replacement.listRuns", options);
+		return {
+			data: await transport.requestParsed(ReplacementApiRunList, "/api/ee/replacement/runs", {
+				...options,
+				query: { "is-active": params["is-active"] }
+			}),
+			total: null
+		};
+	}
+	/** Get one replacement run by id, with its status and progress. Admins only. */
+	async function getRun(id, options = {}) {
+		await transport.require("replacement.getRun", options);
+		return transport.requestParsed(ReplacementRun, `/api/ee/replacement/runs/${id}`, { ...options });
+	}
+	/** Cancel the replacement in progress. Refuses with a 409 once the run has ended. Admins only. */
+	async function cancelRun(id, options = {}) {
+		await transport.require("replacement.cancelRun", options);
+		await transport.requestParsed(CancelRunResponse, `/api/ee/replacement/runs/${id}/cancel`, {
+			...options,
+			method: "POST"
+		});
+	}
+	return {
+		checkReplaceSource,
+		replaceSource,
+		replaceModelWithTransform,
+		listRuns,
+		getRun,
+		cancelRun
+	};
+}
+//#endregion
+//#region ../client/src/domain/revision.ts
+const RevisionEntity = z.enum([
+	"card",
+	"dashboard",
+	"document",
+	"measure",
+	"segment",
+	"transform"
+]);
+const RevisionUser = z.object({
+	id: z.number().int(),
+	first_name: z.string().nullable(),
+	last_name: z.string().nullable(),
+	common_name: z.string()
+}).loose();
+const Revision = z.object({
+	id: z.number().int(),
+	timestamp: z.string(),
+	is_creation: z.boolean(),
+	is_reversion: z.boolean(),
+	most_recent: z.boolean(),
+	diff: z.object({}).loose().nullable(),
+	description: z.string(),
+	has_multiple_changes: z.boolean(),
+	user: RevisionUser
+}).loose();
+Revision.pick({
+	id: true,
+	timestamp: true,
+	is_creation: true,
+	is_reversion: true,
+	description: true,
+	user: true
+}).strip();
+const RevisionRow = z.object({
+	id: z.number().int(),
+	model: z.string(),
+	model_id: z.number().int(),
+	user_id: z.number().int(),
+	object: z.object({}).loose(),
+	timestamp: z.string(),
+	is_creation: z.boolean(),
+	is_reversion: z.boolean(),
+	most_recent: z.boolean()
+}).loose();
+z.object({
+	entity: RevisionEntity,
+	id: z.number().int().positive(),
+	revision_id: z.number().int().positive()
+}).strict();
+const RevisionReverted = z.object({
+	outcome: z.literal("reverted"),
+	revision: Revision
+});
+const RevisionUnchanged = z.object({
+	outcome: z.literal("unchanged"),
+	revision: RevisionRow
+});
+z.discriminatedUnion("outcome", [RevisionReverted, RevisionUnchanged]);
+//#endregion
+//#region ../client/src/resources/revision.ts
+const RevisionApiList = z.array(Revision);
+const RevisionApiRevert = z.union([Revision.transform((revision) => ({
+	outcome: "reverted",
+	revision
+})), RevisionRow.transform((revision) => ({
+	outcome: "unchanged",
+	revision
+}))]);
+const ENTITY_FEATURES = {
+	measure: "measures",
+	transform: "transforms"
+};
+function entityFeatures(entity) {
+	const feature = ENTITY_FEATURES[entity];
+	return feature === void 0 ? [] : [feature];
+}
+function revisionResource(transport) {
+	/** List the revisions of an entity the caller may read, newest first, each with its diff. */
+	async function list(entity, id, options = {}) {
+		await transport.require("revision.list", options);
+		await transport.requireFeatures(entityFeatures(entity), options);
+		return {
+			data: await transport.requestParsed(RevisionApiList, `/api/revision/${entity}/${id}`, { ...options }),
+			total: null
+		};
+	}
+	/**
+	* Revert an entity to one of its prior revisions. Needs write access to the entity, and for a
+	* card the permission to run the query being restored.
+	*/
+	async function revert(params, options = {}) {
+		await transport.require("revision.revert", options);
+		await transport.requireFeatures(entityFeatures(params.entity), options);
+		return transport.requestParsed(RevisionApiRevert, "/api/revision/revert", {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	return {
+		list,
+		revert
+	};
+}
+//#endregion
 //#region ../client/src/resources/search.ts
 const SearchApiResponse = z.object({
 	data: z.array(SearchResult),
@@ -1559,8 +2701,10 @@ function searchResource(transport) {
 	/**
 	* Search over the instance's content, ranked against `q`. `models` narrows which kinds of entity
 	* may match, `archived` swaps the active set for the archived one, `table_db_id` restricts to
-	* items on one database, `verified` to verified content, and `limit`/`offset` are the window the
-	* server applies before ranking hydration.
+	* items on one database, `verified` to verified content, `collection` to one collection and its
+	* descendants, `created_by` to items created by any of those users, `search_native_query` also
+	* matches the text of native queries, `include_metadata` attaches each card's `result_metadata`,
+	* and `limit`/`offset` are the window the server applies before ranking hydration.
 	*/
 	async function query(params = {}, options = {}) {
 		await transport.require("search.query", options);
@@ -1573,7 +2717,11 @@ function searchResource(transport) {
 				limit: params.limit,
 				offset: params.offset,
 				table_db_id: params.table_db_id,
-				verified: params.verified
+				verified: params.verified,
+				collection: params.collection,
+				created_by: params.created_by,
+				search_native_query: params.search_native_query,
+				include_metadata: params.include_metadata
 			}
 		});
 		return {
@@ -1755,16 +2903,52 @@ function snippetResource(transport) {
 //#endregion
 //#region ../client/src/resources/table.ts
 const TableApiList = z.array(Table);
+const TableApiFks = z.array(TableForeignKey);
+const SyncSchemaResponse = z.object({ status: z.literal("ok") });
+const RescanValuesResponse = z.object({ status: z.literal("success") });
+const BulkEditResponse = z.object({});
+const BULK_EDIT_PATH = "/api/data-studio/table/edit";
+const LIST_PARAM_FEATURES = [
+	["can-query", "tableListAccessFilters"],
+	["can-write", "tableListAccessFilters"],
+	["include-transform-targets", "tableListTransformTargets"],
+	["unused-only", "tableUnusedFilter"]
+];
+function listParamFeatures(params) {
+	return LIST_PARAM_FEATURES.filter(([param]) => params[param] !== void 0).map(([, feature]) => feature);
+}
 const UPLOAD_UPDATE_PATHS = {
 	append: "append-csv",
 	replace: "replace-csv"
 };
 function tableResource(transport) {
-	/** List every table the caller can see, across all databases. */
-	async function list(options = {}) {
+	/**
+	* List every table the caller can see, across all databases. `term` matches names and display
+	* names; `can-query` and `can-write` keep only the tables the caller may query or edit the
+	* metadata of; `include-transform-targets` adds tables a transform writes to; `unused-only` keeps
+	* tables nothing depends on.
+	*/
+	async function list(params = {}, options = {}) {
 		await transport.require("table.list", options);
+		await transport.requireFeatures(listParamFeatures(params), options);
+		await requireDataLayer(params["data-layer"], options);
 		return {
-			data: await transport.requestParsed(TableApiList, "/api/table", { ...options }),
+			data: await transport.requestParsed(TableApiList, "/api/table", {
+				...options,
+				query: {
+					term: params.term,
+					"visibility-type": params["visibility-type"],
+					"data-layer": params["data-layer"],
+					"data-source": params["data-source"],
+					"owner-user-id": params["owner-user-id"],
+					"owner-email": params["owner-email"],
+					"orphan-only": params["orphan-only"],
+					"unused-only": params["unused-only"],
+					"can-query": params["can-query"],
+					"can-write": params["can-write"],
+					"include-transform-targets": params["include-transform-targets"]
+				}
+			}),
 			total: null
 		};
 	}
@@ -1776,17 +2960,72 @@ function tableResource(transport) {
 	/** Update a table by id, patching only the fields the body carries. */
 	async function update(id, params, options = {}) {
 		await transport.require("table.update", options);
+		await requireDataLayer(params.data_layer, options);
 		return transport.requestParsed(Table, `/api/table/${id}`, {
 			...options,
 			method: "PUT",
 			body: params
 		});
 	}
+	async function requireDataLayer(value, options) {
+		if (value === null || value === void 0) return;
+		if (TableDataLayerTier.safeParse(value).success) {
+			await transport.requireFeatures(["tableDataLayerTiers"], options);
+			return;
+		}
+		const { features } = await transport.server(options);
+		if (features.tableDataLayerTiers) throw new ConfigError(`data_layer "${value}" is a medallion name; this server names a table's layer ${TableDataLayerTier.options.join(", ")}`);
+	}
 	/** Get a table by id with its fields hydrated — the metadata the query builder runs on. */
 	async function queryMetadata(id, options = {}) {
 		await transport.require("table.queryMetadata", options);
 		return transport.requestParsed(TableQueryMetadata, `/api/table/${id}/query_metadata`, { ...options });
 	}
+	/**
+	* Get every foreign key whose destination is a field of this table. A table with no active
+	* fields answers no content, which is the same empty list.
+	*/
+	async function fks(id, options = {}) {
+		await transport.require("table.fks", options);
+		return {
+			data: await fetchOptionalParsed(transport, `/api/table/${id}/fks`, TableApiFks, { ...options }) ?? [],
+			total: null
+		};
+	}
+	/**
+	* Trigger a manual update of this table's schema metadata. The sync runs after the call returns;
+	* a warehouse the server cannot connect to is a 422.
+	*/
+	async function syncSchema(id, options = {}) {
+		await transport.require("table.syncSchema", options);
+		await transport.requestParsed(SyncSchemaResponse, `/api/table/${id}/sync_schema`, {
+			...options,
+			method: "POST"
+		});
+	}
+	/**
+	* Trigger an update of the field values of every eligible field of this table. The scan runs
+	* after the call returns.
+	*/
+	async function rescanValues(id, options = {}) {
+		await transport.require("table.rescanValues", options);
+		await transport.requestParsed(RescanValuesResponse, `/api/table/${id}/rescan_values`, {
+			...options,
+			method: "POST"
+		});
+	}
+	/**
+	* Set the same metadata on every table the selectors pick out. A table leaving the `hidden` data
+	* layer is re-synced after the call returns.
+	*/
+	async function bulkEdit(params, options = {}) {
+		await transport.require("table.bulkEdit", options);
+		await transport.requestParsed(BulkEditResponse, BULK_EDIT_PATH, {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
 	async function updateFromCsv(id, action, file, options) {
 		await transport.requestRaw(`/api/table/${id}/${UPLOAD_UPDATE_PATHS[action]}`, {
 			...options,
@@ -1824,6 +3063,10 @@ function tableResource(transport) {
 		get,
 		update,
 		queryMetadata,
+		fks,
+		syncSchema,
+		rescanValues,
+		bulkEdit,
 		appendCsv,
 		replaceCsv
 	};
@@ -1969,6 +3212,235 @@ function timelineResource(transport) {
 	};
 }
 //#endregion
+//#region ../client/src/domain/transform-dag-run.ts
+const TransformMemberRun = TransformRun.extend({
+	job_run_id: z.number().int().nullable(),
+	dag_run_id: z.number().int().nullable()
+});
+TransformMemberRun.pick({
+	id: true,
+	transform_id: true,
+	dag_run_id: true,
+	status: true,
+	run_method: true,
+	start_time: true,
+	end_time: true,
+	message: true
+}).strip();
+//#endregion
+//#region ../client/src/resources/transform-dag-run.ts
+const TransformMemberRunList = z.array(TransformMemberRun);
+function transformDagRunResource(transport) {
+	/**
+	* List the transform runs a DAG run coordinated so far. A member run is inserted when its
+	* transform starts, so the list grows while the DAG run is in progress.
+	*/
+	async function transformRuns(runId, options = {}) {
+		await transport.require("transformDagRun.transformRuns", options);
+		return {
+			data: await transport.requestParsed(TransformMemberRunList, `/api/transform-dag-run/${runId}/transform-runs`, { ...options }),
+			total: null
+		};
+	}
+	/** Cancel an in-progress DAG run and request cancellation of its still-running transforms. */
+	async function cancel(runId, options = {}) {
+		await transport.require("transformDagRun.cancel", options);
+		await transport.requestRaw(`/api/transform-dag-run/${runId}/cancel`, {
+			...options,
+			method: "POST",
+			expectContentType: "binary"
+		});
+	}
+	return {
+		transformRuns,
+		cancel
+	};
+}
+//#endregion
+//#region ../client/src/domain/transform-inspector.ts
+const InspectorFieldStats = z.object({
+	distinct_count: z.number().int().optional(),
+	nil_percent: z.number().optional(),
+	min: z.number().optional(),
+	max: z.number().optional(),
+	avg: z.number().optional(),
+	q1: z.number().optional(),
+	q3: z.number().optional(),
+	earliest: z.string().optional(),
+	latest: z.string().optional()
+}).loose();
+const InspectorField = z.object({
+	id: z.number().int(),
+	name: z.string(),
+	display_name: z.string().nullable().optional(),
+	base_type: z.string(),
+	semantic_type: z.string().nullable().optional(),
+	stats: InspectorFieldStats.nullable().optional()
+}).loose();
+const InspectorTable = z.object({
+	table_id: z.number().int(),
+	table_name: z.string(),
+	schema: z.string().nullable().optional(),
+	db_id: z.number().int(),
+	column_count: z.number().int(),
+	fields: z.array(InspectorField)
+}).loose();
+const LensComplexityLevel = z.enum([
+	"fast",
+	"slow",
+	"very-slow"
+]);
+const LensComplexity = z.object({
+	level: LensComplexityLevel,
+	score: z.number().int().optional()
+}).loose();
+const LensMetadata = z.object({
+	id: z.string(),
+	display_name: z.string(),
+	description: z.string().nullable().optional(),
+	complexity: LensComplexity.optional()
+}).loose();
+const TransformInspectionStatus = z.enum(["not-run", "ready"]);
+const TransformInspection = z.object({
+	name: z.string(),
+	description: z.string().nullable().optional(),
+	status: TransformInspectionStatus,
+	sources: z.array(InspectorTable),
+	target: InspectorTable.nullable().optional(),
+	visited_fields: z.object({ all: z.array(z.number().int()).optional() }).loose().nullable().optional(),
+	available_lenses: z.array(LensMetadata)
+}).loose();
+const LensCardDisplay = z.enum([
+	"bar",
+	"row",
+	"line",
+	"area",
+	"pie",
+	"scalar",
+	"gauge",
+	"progress",
+	"table",
+	"hidden"
+]);
+const LensJoinMetadata = z.object({
+	join_step: z.number().int().optional(),
+	join_alias: z.string().optional(),
+	join_strategy: z.string().optional()
+}).loose();
+const LensCardMetadata = LensJoinMetadata.extend({
+	dedup_key: z.array(z.unknown()).optional(),
+	depends_on_cards: z.array(z.string()).optional(),
+	group_id: z.string().optional(),
+	group_role: z.enum(["input", "output"]).optional(),
+	group_order: z.number().int().optional(),
+	card_type: z.string().optional()
+});
+const LensCard = z.object({
+	id: z.string(),
+	section_id: z.string().nullable().optional(),
+	title: z.string(),
+	display: LensCardDisplay,
+	dataset_query: DatasetQuery,
+	metadata: LensCardMetadata.optional()
+}).loose();
+const LensSection = z.object({
+	id: z.string(),
+	title: z.string(),
+	description: z.string().nullable().optional(),
+	layout: z.enum(["flat", "comparison"]).optional()
+}).loose();
+const LensHighlight = z.object({
+	label: z.string(),
+	value: z.unknown().optional(),
+	card_id: z.string().optional()
+}).loose();
+const LensSummary = z.object({
+	text: z.string().nullable().optional(),
+	highlights: z.array(LensHighlight).optional(),
+	alerts: z.array(z.object({}).loose()).optional()
+}).loose();
+const LensTriggerCondition = z.object({ name: z.string() }).loose();
+const LensAlertTrigger = z.object({
+	id: z.string(),
+	condition: LensTriggerCondition,
+	severity: z.enum([
+		"info",
+		"warning",
+		"error"
+	]),
+	message: z.string(),
+	metadata: LensJoinMetadata.optional()
+}).loose();
+/** The parameters a drill lens takes; `join_step` scopes a join lens to one join. */
+const LensParams = z.object({ join_step: z.number().int().optional() });
+const LensDrillTrigger = z.object({
+	lens_id: z.string(),
+	condition: LensTriggerCondition,
+	params: LensParams.loose().optional(),
+	reason: z.string().optional(),
+	metadata: LensJoinMetadata.optional()
+}).loose();
+const TransformLens = z.object({
+	id: z.string(),
+	display_name: z.string(),
+	complexity: LensComplexity.optional(),
+	summary: LensSummary.optional(),
+	sections: z.array(LensSection),
+	cards: z.array(LensCard),
+	drill_lenses: z.array(LensMetadata).optional(),
+	alert_triggers: z.array(LensAlertTrigger).optional(),
+	drill_lens_triggers: z.array(LensDrillTrigger).optional()
+}).loose();
+z.object({
+	query: DatasetQuery,
+	lens_params: LensParams.nullable().optional()
+}).strict();
+//#endregion
+//#region ../client/src/resources/transform-inspector.ts
+function lensPath(id, lensId) {
+	return `/api/ee/transforms/${id}/inspect/${encodeURIComponent(lensId)}`;
+}
+function transformInspectorResource(transport) {
+	/**
+	* Discover what the inspector can show for a transform: its source and target tables with field
+	* statistics, the fields its query touches, and the lenses available on it.
+	*/
+	async function discover(id, options = {}) {
+		await transport.require("transformInspector.discover", options);
+		return transport.requestParsed(TransformInspection, `/api/ee/transforms/${id}/inspect`, { ...options });
+	}
+	/**
+	* Open one lens on a transform: its sections, the cards with the queries that fill them, and
+	* the alert and drill-lens triggers to evaluate against the card results. A drill lens takes
+	* the `params` its trigger emitted.
+	*/
+	async function lens(id, lensId, params = {}, options = {}) {
+		await transport.require("transformInspector.lens", options);
+		return transport.requestParsed(TransformLens, lensPath(id, lensId), {
+			...options,
+			query: { join_step: params.join_step }
+		});
+	}
+	/**
+	* Run a lens card's query in the context of the lens, so the execution is attributed to the
+	* inspector. The body is the card's `dataset_query`, and the same `lens_params` the lens was
+	* opened with.
+	*/
+	async function query(id, lensId, params, options = {}) {
+		await transport.require("transformInspector.query", options);
+		return transport.requestParsed(CardQueryResult, `${lensPath(id, lensId)}/query`, {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	return {
+		discover,
+		lens,
+		query
+	};
+}
+//#endregion
 //#region ../client/src/resources/transform-job.ts
 function transformJobResource(transport) {
 	/** List every transform job the caller can see. */
@@ -2061,6 +3533,96 @@ function transformJobResource(transport) {
 	};
 }
 //#endregion
+//#region ../client/src/domain/transform-python.ts
+const PythonLibrary = z.object({
+	path: z.string(),
+	source: z.string().nullable(),
+	created_at: z.string(),
+	updated_at: z.string()
+}).loose();
+z.object({ source: z.string() }).strict();
+const TEST_RUN_ROW_LIMIT = {
+	min: 2,
+	max: 100
+};
+const TestRunRowLimit = z.number().int().min(TEST_RUN_ROW_LIMIT.min).max(TEST_RUN_ROW_LIMIT.max);
+z.object({
+	code: z.string(),
+	source_tables: z.array(TransformSourceTableEntry).min(1),
+	output_row_limit: TestRunRowLimit.optional(),
+	per_input_row_limit: TestRunRowLimit.optional()
+}).strict();
+const PythonTestRunOutput = z.object({
+	cols: z.array(z.object({ name: z.string() }).loose()),
+	rows: z.array(z.unknown())
+});
+const PythonTestRunError = z.object({ message: z.string() }).loose();
+const PythonTestRunSucceeded = z.object({
+	outcome: z.literal("succeeded"),
+	logs: z.string(),
+	output: PythonTestRunOutput
+});
+const PythonTestRunFailed = z.object({
+	outcome: z.literal("failed"),
+	logs: z.string(),
+	error: PythonTestRunError
+});
+z.discriminatedUnion("outcome", [PythonTestRunSucceeded, PythonTestRunFailed]);
+//#endregion
+//#region ../client/src/resources/transform-python.ts
+const PythonApiTestRun = z.union([z.object({
+	logs: z.string(),
+	output: PythonTestRunOutput
+}).transform(({ logs, output }) => ({
+	outcome: "succeeded",
+	logs,
+	output
+})), z.object({
+	logs: z.string(),
+	error: PythonTestRunError
+}).transform(({ logs, error }) => ({
+	outcome: "failed",
+	logs,
+	error
+}))]);
+function libraryPath(path) {
+	return `/api/ee/transforms-python/library/${encodeURIComponent(path)}`;
+}
+function transformPythonResource(transport) {
+	/** Get the Python library at a path, the user module every Python transform can import. */
+	async function getLibrary(path, options = {}) {
+		await transport.require("transformPython.getLibrary", options);
+		return transport.requestParsed(PythonLibrary, libraryPath(path), { ...options });
+	}
+	/** Replace the source of the Python library at a path, creating the library when none exists. */
+	async function updateLibrary(path, params, options = {}) {
+		await transport.require("transformPython.updateLibrary", options);
+		return transport.requestParsed(PythonLibrary, libraryPath(path), {
+			...options,
+			method: "PUT",
+			body: params
+		});
+	}
+	/**
+	* Evaluate an ad-hoc Python transform on a sample of its source tables, without a target table.
+	* Meant for early feedback on short runs: input, output and time limits apply, and the sample
+	* sizes are capped at 100 rows.
+	*/
+	async function testRun(params, options = {}) {
+		await transport.require("transformPython.testRun", options);
+		return transport.requestParsed(PythonApiTestRun, "/api/ee/transforms-python/test-run", {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	return {
+		getLibrary,
+		updateLibrary,
+		testRun
+	};
+}
+//#endregion
 //#region ../client/src/resources/transform.ts
 function transformListSchema(features) {
 	return z.array(transformRowSchema(features));
@@ -2069,6 +3631,7 @@ const TransformRunKickoff = z.object({
 	message: z.string(),
 	run_id: z.number().int().positive().nullable()
 });
+const TransformDagTransformList = z.array(TransformDagTransform);
 function transformResource(transport) {
 	async function requestTransformList(path, opts) {
 		const { features } = await transport.server(opts);
@@ -2159,6 +3722,67 @@ function transformResource(transport) {
 		});
 	}
 	/**
+	* Walk the unified run history, newest first by default: every row is a root run — a job run, a
+	* DAG reprocess run, or a standalone transform run — and never a member run of a job or DAG.
+	*/
+	async function* runSummaryPages(params = {}, options = {}) {
+		await transport.require("transform.runSummaryPages", options);
+		yield* paginatePages(transport, "/api/transform/runs", TransformRunSummary, {
+			query: {
+				types: params.types,
+				statuses: params.statuses,
+				"run-methods": params["run-methods"],
+				"start-time": params["start-time"],
+				"end-time": params["end-time"],
+				"transform-ids": params["transform-ids"],
+				"sort-column": params["sort-column"],
+				"sort-direction": params["sort-direction"]
+			},
+			...options.offset !== void 0 && { offset: options.offset },
+			...options.max !== void 0 && { max: options.max },
+			...options.pageSize !== void 0 && { pageSize: options.pageSize },
+			...options.signal !== void 0 && { signal: options.signal }
+		});
+	}
+	/**
+	* Reset the stored checkpoint of an incremental transform, so its next run reprocesses the whole
+	* source rather than the rows past the last checkpoint.
+	*/
+	async function resetCheckpoint(id, options = {}) {
+		await transport.require("transform.resetCheckpoint", options);
+		await transport.requestRaw(`/api/transform/${id}/reset-checkpoint`, {
+			...options,
+			method: "POST",
+			expectContentType: "binary"
+		});
+	}
+	/**
+	* Start a DAG reprocess run seeded at a transform: the transform plus, by `direction`, every
+	* transform it transitively depends on or every transform that transitively depends on it. The
+	* server answers at once with the run's id, or null when it ran nothing because a DAG run for
+	* this transform is already in progress or the closure is empty. Progress is read off
+	* `runSummaryPages` with `types: ["dag"]`, and the member runs off `transformDagRun.transformRuns`.
+	*/
+	async function runDag(id, params, options = {}) {
+		await transport.require("transform.runDag", options);
+		return transport.requestParsed(TransformDagRunResult, `/api/transform/${id}/run-dag`, {
+			...options,
+			method: "POST",
+			body: { direction: params.direction }
+		});
+	}
+	/** Preview the transforms a DAG reprocess seeded at a transform would run, in execution order. */
+	async function dagTransforms(id, params, options = {}) {
+		await transport.require("transform.dagTransforms", options);
+		return {
+			data: await transport.requestParsed(TransformDagTransformList, `/api/transform/${id}/dag-transforms`, {
+				...options,
+				query: { direction: params.direction }
+			}),
+			total: null
+		};
+	}
+	/**
 	* Start a run of a transform by id. The server queues the run and answers at once; `wait` polls
 	* it to a terminal status, and `syncTarget` follows that with the output table's registration.
 	* A server that answers no run id started nothing, and there is then nothing to poll.
@@ -2215,6 +3839,10 @@ function transformResource(transport) {
 		cancel,
 		getRun,
 		runPages,
+		runSummaryPages,
+		resetCheckpoint,
+		runDag,
+		dagTransforms,
 		run
 	};
 }
@@ -2265,6 +3893,82 @@ function transformTagResource(transport) {
 	};
 }
 //#endregion
+//#region ../client/src/resources/transform-test.ts
+const TransformTestApiList = z.array(TransformTest);
+function transformTestResource(transport) {
+	/** List the transform tests, optionally only those of one transform. */
+	async function list(params = {}, options = {}) {
+		await transport.require("transformTest.list", options);
+		return {
+			data: await transport.requestParsed(TransformTestApiList, "/api/ee/transform-test", {
+				...options,
+				query: { "transform-id": params["transform-id"] }
+			}),
+			total: null
+		};
+	}
+	/** Get a transform test by id. */
+	async function get(id, options = {}) {
+		await transport.require("transformTest.get", options);
+		return transport.requestParsed(TransformTest, `/api/ee/transform-test/${id}`, { ...options });
+	}
+	/**
+	* Create a transform test. The server validates the inputs and expectations against the
+	* transform before saving, and refuses with an `HttpError` whose `errorCode` is a
+	* `TransformTestRefusalCode` when they cannot run.
+	*/
+	async function create(params, options = {}) {
+		await transport.require("transformTest.create", options);
+		return transport.requestParsed(TransformTest, "/api/ee/transform-test", {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	/**
+	* Update a transform test by id, leaving omitted fields unchanged. A body that touches the
+	* transform, inputs or expectations is validated as on create, with the same refusal.
+	*/
+	async function update(id, params, options = {}) {
+		await transport.require("transformTest.update", options);
+		return transport.requestParsed(TransformTest, `/api/ee/transform-test/${id}`, {
+			...options,
+			method: "PUT",
+			body: params
+		});
+	}
+	/** Delete a transform test by id. */
+	async function remove(id, options = {}) {
+		await transport.require("transformTest.delete", options);
+		await transport.requestRaw(`/api/ee/transform-test/${id}`, {
+			...options,
+			method: "DELETE",
+			expectContentType: "binary"
+		});
+	}
+	/**
+	* Run a transform test by id. A result means the run happened: `status` is `passed` or `failed`
+	* and every expectation reports what it found, one that could not be evaluated as its own
+	* `error`. An `HttpError` whose `errorCode` is a `TransformTestRefusalCode` means the run was
+	* refused and nothing meaningful ran.
+	*/
+	async function run(id, options = {}) {
+		await transport.require("transformTest.run", options);
+		return transport.requestParsed(TransformTestRunResult, `/api/ee/transform-test/${id}/run`, {
+			...options,
+			method: "POST"
+		});
+	}
+	return {
+		list,
+		get,
+		create,
+		update,
+		delete: remove,
+		run
+	};
+}
+//#endregion
 //#region ../client/src/resources/upload.ts
 const UPLOAD_TABLE_ID_HEADER = "metabase-table-id";
 function uploadResource(transport) {
@@ -2345,14 +4049,22 @@ function createClient(config, options) {
 		dashboard: dashboardResource(transport),
 		database: databaseResource(transport),
 		dataset: datasetResource(transport),
+		dependency: dependencyResource(transport),
 		document: documentResource(transport),
 		eidTranslation: eidTranslationResource(transport),
+		erd: erdResource(transport),
 		field: fieldResource(transport),
 		gitSync: gitSyncResource(transport),
+		glossary: glossaryResource(transport),
 		library: libraryResource(transport),
 		measure: measureResource(transport),
+		metric: metricResource(transport),
+		moderationReview: moderationReviewResource(transport),
 		notification: notificationResource(transport),
+		permission: permissionResource(transport),
 		pulse: pulseResource(transport),
+		replacement: replacementResource(transport),
+		revision: revisionResource(transport),
 		search: searchResource(transport),
 		segment: segmentResource(transport),
 		setting: settingResource(transport),
@@ -2362,8 +4074,12 @@ function createClient(config, options) {
 		timeline: timelineResource(transport),
 		timelineEvent: timelineEventResource(transport),
 		transform: transformResource(transport),
+		transformDagRun: transformDagRunResource(transport),
+		transformInspector: transformInspectorResource(transport),
 		transformJob: transformJobResource(transport),
+		transformPython: transformPythonResource(transport),
 		transformTag: transformTagResource(transport),
+		transformTest: transformTestResource(transport),
 		upload: uploadResource(transport),
 		user: userResource(transport),
 		server: transport.server,