@metabase/cli 0.5.0 → 0.5.2

package/dist/{client-BmURNkkW.mjs → client-D-Aw6JLk.mjs}

@@ -1,39 +1,41 @@
-import { At as isNonInterruptFailure, Ct as ResponseShapeError, Dt as errorMessage, Et as ValidationError, G as isRetryableStatus, J as isPlainObject, N as CapabilityError, Ot as formatZodIssue, St as PartialWriteError, U as HttpError, X as parseJson, Y as JSON_CONTENT_TYPE, Z as parseJsonOrPlain, n as isMethodKey, r as methodRequirements, vt as ConfigError, wt as TimeoutError, xt as NetworkError, yt as InternalError } from "./cli.mjs";
+import { Dt as PartialWriteError, Ft as isNonInterruptFailure, Mt as errorMessage, Nt as formatZodIssue, Ot as ResponseShapeError, P as CapabilityError, Q as parseJsonOrPlain, St as ConfigError, W as HttpError, Y as isPlainObject, kt as TimeoutError, n as isMethodKey, r as methodRequirements, wt as InternalError } from "./cli.mjs";
 import { n as Notification, r as NotificationCardPayload, t as CARD_PAYLOAD_TYPE } from "./notification-DaA4bBHW.mjs";
-import { B as credentialAuthHeader, F as probeBudget, J as createServerProfile, L as profileFromProperties, M as buildNetworkError, N as isConnectionClosed, P as PROBE_PATH, R as serverInfoFromProperties, V as credentialSecrets, W as normalizeUrl, Z as SessionProperties, z as assertCredentialHeaderSafe } from "./runtime-C5Ha6Ou8.mjs";
-import { n as throwIfAborted, r as untilAborted, t as combineAborts } from "./signal-Dm4N0Bcc.mjs";
-import { n as featureFailures, r as supersedingFeature, t as checkFeatures } from "./requirement-check-T3bjQ0Mr.mjs";
-import { f as FieldWithDataSensitivity, h as fieldRemappedValueSchema, m as fieldDetailSchema, n as FieldBaseType, o as FieldSearchMatches, s as FieldSemanticType, u as FieldValues } from "./field-5nivEfd6.mjs";
-import { a as TemporalUnit, r as ParameterValues } from "./parameter-Celg0wZa.mjs";
-import { a as CardQueryResult, d as PivotExportFormat, l as DatasetQuery, t as Card } from "./card-Bv4ZN0oV.mjs";
-import { b as TableVisibilityType, p as TableQueryMetadata, s as TableDataLayerTier, t as Table, u as TableForeignKey, v as TableSelectors } from "./table-zAdW5_3H.mjs";
-import { t as Database } from "./database-BdKkae1m.mjs";
+import { V as profileFromProperties, tt as SessionProperties } from "./runtime-Cmes70jO.mjs";
+import { n as featureFailures, r as supersedingFeature, t as checkFeatures } from "./requirement-check-sfmyH2PH.mjs";
+import { n as createTransport } from "./transport-Ck4anhoc.mjs";
+import { i as CardDetail, o as CardQueryResult, t as Card } from "./card-QR3zEu6E.mjs";
+import { f as FieldWithDataSensitivity, g as fieldRemappedValueSchema, h as fieldDetailSchema, n as FieldBaseType, o as FieldSearchMatches, s as FieldSemanticType, u as FieldValues } from "./field-DoWQUl7V.mjs";
+import { r as ModerationReviewCreateInput, t as ModerationReview } from "./moderation-review-Bf9bPNQI.mjs";
+import { a as TemporalUnit, r as ParameterValues } from "./parameter-DvRQMKd2.mjs";
+import { r as PivotExportFormat, t as DatasetQuery } from "./query-BKtMP5eH.mjs";
+import { b as TableVisibilityType, p as TableQueryMetadata, s as TableDataLayerTier, t as Table, u as TableForeignKey, v as TableSelectors } from "./table-CF7zW9cI.mjs";
+import { c as DatabaseWithSettings, t as Database } from "./database-CxykzTAA.mjs";
 import { t as Snippet } from "./snippet-CyKAgIZl.mjs";
-import { r as QueryMetadata, t as CompiledQuery } from "./dataset-DZgJm5hP.mjs";
-import { c as CollectionItem, m as CollectionTreeNode, r as Collection } from "./collection-zrZoJfgR.mjs";
+import { r as QueryMetadata, t as CompiledQuery } from "./dataset-DIQLAp2P.mjs";
+import { c as CollectionItem, m as CollectionTreeNode, r as Collection } from "./collection-DNmFKALA.mjs";
 import { t as ContentTranslationUploadResult } from "./content-translation-BrHOrmj9.mjs";
-import { l as Dashcard, o as DashboardDetail, r as DashboardCopy, t as Dashboard } from "./dashboard-Phz3XpRM.mjs";
-import { r as pollUntil } from "./poll-BKo5dK0l.mjs";
-import { i as DependencyEntity, s as DependencyGraph, t as BreakingSource, u as DependencyNode } from "./dependency-tQBxYjFX.mjs";
-import { t as Document } from "./document-BDobDiap.mjs";
-import { i as EidTranslateResult } from "./eid-translation-zEHtr5Oc.mjs";
-import { c as SyncRemoteChanges, d as SyncTask, i as SyncExportPreflight, l as SyncSettingsUpdateResult, m as isSyncTaskTerminal, n as SyncDirtyItem, t as SyncBranchCreated } from "./git-sync-COokpYgc.mjs";
-import { t as Glossary } from "./glossary-6LLpItof.mjs";
-import { a as libraryWireSchema, i as LibraryPublishTablesInput, n as LibraryCollectionInfo, o as toLibrary } from "./library-fWEv38OB.mjs";
+import { o as DashboardDetail, r as DashboardCopy, t as Dashboard, u as Dashcard } from "./dashboard-Chjy5GKR.mjs";
+import { a as DataActionExecuteResult, s as dataActionSchema } from "./data-action-DZxVB_hD.mjs";
+import { r as pollUntil } from "./poll-CgtcJopL.mjs";
+import { i as DependencyEntity, s as DependencyGraph, t as BreakingSource, u as DependencyNode } from "./dependency-CaC6XuTY.mjs";
+import { t as Document } from "./document-UMG6me2P.mjs";
+import { i as EidTranslateResult } from "./eid-translation-Ba92VOHe.mjs";
+import { a as SyncExportPreflight, f as SyncTask, g as isSyncTaskTerminal, l as SyncRemoteChanges, n as SyncBranchCreated, r as SyncDirtyItem, t as RemoteSyncState, u as SyncSettingsUpdateResult } from "./git-sync-DP4wQFzm.mjs";
+import { t as Glossary } from "./glossary-QN-hHfOT.mjs";
+import { a as libraryWireSchema, i as LibraryPublishTablesInput, n as LibraryCollectionInfo, o as toLibrary } from "./library-DKIqzyUk.mjs";
 import { t as Measure } from "./measure-CtfjqJFP.mjs";
-import { r as ModerationReviewCreateInput, t as ModerationReview } from "./moderation-review-BdqEH6N1.mjs";
-import { t as Pulse } from "./pulse-Dz0ocv0l.mjs";
+import { t as Pulse } from "./pulse-CC81N2_0.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 { r as SearchResult } from "./search-1et9tv_s.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 { i as TimelineEvent, t as Timeline } from "./timeline-CCSU2qOS.mjs";
-import { c as transformJobSchema, n as TransformJobActiveResult, s as transformJobRunResultSchema } from "./transform-job-CCguL6LP.mjs";
+import { i as TimelineEvent, t as Timeline } from "./timeline-DcsCXNUt.mjs";
+import { c as transformJobSchema, n as TransformJobActiveResult, s as transformJobRunResultSchema } from "./transform-job-ClX8e5iO.mjs";
 import { t as TransformTag } from "./transform-tag-CcElGp3C.mjs";
+import { i as TransformTestRunResult, t as TransformTest } from "./transform-test-Bexa_K89.mjs";
 import { t as UploadResult } from "./upload-DAtxBBms.mjs";
 import { z } from "zod";
-import { setTimeout } from "node:timers/promises";
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
@@ -46,416 +48,6 @@ var __exportAll = (all, no_symbols) => {
 	return target;
 };
 //#endregion
-//#region ../client/src/http/response-shape.ts
-async function parseJsonResponse(text, schema, context) {
-	try {
-		return parseJson(text, schema, { source: context.url });
-	} catch (error) {
-		if (error instanceof ValidationError) throw ResponseShapeError.fromZodIssues({
-			kind: "zod",
-			method: context.method,
-			url: context.url,
-			status: context.status,
-			zodIssues: error.developerDetail.zodIssues,
-			serverTag: await context.getServerTag(),
-			serverSkew: context.serverSkew
-		});
-		throw error;
-	}
-}
-//#endregion
-//#region ../client/src/http/retry.ts
-const BASE_DELAY_MS = 250;
-const MAX_DELAY_MS = 8e3;
-const MS_PER_SECOND = 1e3;
-function backoffDelay({ attempt, retryAfterHeader }) {
-	const fromHeader = parseRetryAfter(retryAfterHeader);
-	if (fromHeader !== null) return fromHeader;
-	return Math.min(MAX_DELAY_MS, BASE_DELAY_MS * 2 ** attempt);
-}
-function parseRetryAfter(header) {
-	if (!header) return null;
-	const numeric = Number(header);
-	if (Number.isFinite(numeric) && numeric >= 0) return Math.round(numeric * MS_PER_SECOND);
-	const dateMs = Date.parse(header);
-	if (Number.isFinite(dateMs)) return Math.max(0, dateMs - Date.now());
-	return null;
-}
-function sleep(ms, signal) {
-	return setTimeout(ms, void 0, { signal });
-}
-async function runWithRetries(attempt, signal) {
-	let attemptIndex = 0;
-	while (true) {
-		const outcome = await attempt(attemptIndex);
-		if (outcome.kind === "success") return outcome.response;
-		await sleep(outcome.delayMs, signal);
-		attemptIndex += 1;
-	}
-}
-const DEFAULT_TIMEOUT_MS = 3e4;
-const OCTET_STREAM_CONTENT_TYPE = "application/octet-stream";
-const TEXT_CONTENT_TYPE_PREFIX = "text/";
-const ERROR_BODY_BYTE_CAP = 64 * 1024;
-const IDEMPOTENT_METHODS = /* @__PURE__ */ new Set([
-	"GET",
-	"HEAD",
-	"OPTIONS"
-]);
-function createTransport(config, options) {
-	const baseUrl = normalizeUrl(config.url);
-	assertCredentialHeaderSafe(config.credential);
-	const fetchImpl = options.fetchImpl ?? globalThis.fetch.bind(globalThis);
-	let inForce = options.server ?? null;
-	let newest = null;
-	let probesStarted = 0;
-	let applied = null;
-	const inFlight = /* @__PURE__ */ new Set();
-	const getServerTag = options.getServerTag ?? (async () => tagOf(inForce));
-	const refreshCredential = options.refreshCredential;
-	let credential = config.credential;
-	const knownSecrets = new Set(credentialSecrets(credential));
-	const redactionContext = { knownSecrets };
-	let refreshInFlight = null;
-	function tryRefreshCredential() {
-		const refresh = refreshCredential;
-		if (credential.kind !== "oauth" || refresh === void 0) return Promise.resolve(false);
-		refreshInFlight ??= refreshOnce(refresh).finally(() => {
-			refreshInFlight = null;
-		});
-		return refreshInFlight;
-	}
-	async function refreshOnce(refresh) {
-		const next = await refresh();
-		if (next === null) return false;
-		credential = next;
-		for (const secret of credentialSecrets(next)) knownSecrets.add(secret);
-		return true;
-	}
-	async function attemptOnce(prepared, attempt) {
-		const hasRetriesLeft = attempt < prepared.retries;
-		const timeoutSignal = AbortSignal.timeout(prepared.timeoutMs);
-		const combined = combineAborts(timeoutSignal, prepared.cancelSignal);
-		let response;
-		try {
-			response = await fetchImpl(prepared.url, {
-				method: prepared.method,
-				headers: prepared.headers,
-				body: prepared.body,
-				signal: combined
-			});
-		} catch (error) {
-			throwIfAborted(prepared.cancelSignal);
-			const isStaleSocketFirstTry = attempt === 0 && isConnectionClosed(error);
-			if (prepared.idempotent && (hasRetriesLeft || isStaleSocketFirstTry)) return {
-				kind: "retry",
-				delayMs: backoffDelay({ attempt })
-			};
-			if (timeoutSignal.aborted) throw new TimeoutError(`Request timed out after ${prepared.timeoutMs}ms`, {
-				kind: "http",
-				method: prepared.method,
-				url: prepared.url,
-				timeoutMs: prepared.timeoutMs
-			});
-			throw buildNetworkError(error, prepared.method, prepared.url);
-		}
-		const canRetryStatus = hasRetriesLeft && prepared.idempotent;
-		if (!response.ok && isRetryableStatus(response.status) && canRetryStatus) {
-			const retryAfter = response.headers.get("Retry-After");
-			response.body?.cancel().catch(() => void 0);
-			return {
-				kind: "retry",
-				delayMs: backoffDelay({
-					attempt,
-					retryAfterHeader: retryAfter
-				})
-			};
-		}
-		if (!response.ok) {
-			const rawBody = await readBodyForError(response);
-			const serverTag = await getServerTag();
-			throw new HttpError({
-				status: response.status,
-				statusText: response.statusText,
-				method: prepared.method,
-				url: prepared.url,
-				responseHeaders: response.headers,
-				rawBody,
-				serverTag,
-				redactionContext
-			});
-		}
-		assertContentType(response, prepared);
-		return {
-			kind: "success",
-			response
-		};
-	}
-	async function executeRaw(prepared) {
-		try {
-			return await runWithRetries((attempt) => attemptOnce(prepared, attempt), prepared.cancelSignal);
-		} catch (error) {
-			throwIfAborted(prepared.cancelSignal);
-			throw error;
-		}
-	}
-	async function executeWithAuthRefresh(path, opts) {
-		const prepared = prepare(path, opts);
-		try {
-			return {
-				response: await executeRaw(prepared),
-				prepared
-			};
-		} catch (error) {
-			if (error instanceof HttpError && error.status === 401) {
-				if (await tryRefreshCredential()) {
-					const retried = prepare(path, opts);
-					return {
-						response: await executeRaw(retried),
-						prepared: retried
-					};
-				}
-			}
-			throw error;
-		}
-	}
-	function prepare(path, opts = {}) {
-		const method = opts.method ?? "GET";
-		const expectContentType = opts.expectContentType ?? "json";
-		const url = buildUrl(baseUrl, path, opts.query);
-		const headers = new Headers();
-		const auth = credentialAuthHeader(credential);
-		headers.set(auth.name, auth.value);
-		headers.set("accept", acceptHeader(expectContentType));
-		headers.set("user-agent", options.userAgent);
-		let body = null;
-		if (opts.body !== void 0 && opts.body !== null) if (typeof opts.body === "string" || opts.body instanceof URLSearchParams) body = opts.body;
-		else if (opts.body instanceof FormData || opts.body instanceof ReadableStream) body = opts.body;
-		else if (opts.body instanceof Uint8Array) {
-			body = opts.body;
-			headers.set("content-type", OCTET_STREAM_CONTENT_TYPE);
-		} else {
-			body = JSON.stringify(opts.body);
-			headers.set("content-type", JSON_CONTENT_TYPE);
-		}
-		return {
-			url,
-			method,
-			headers,
-			body,
-			expectContentType,
-			retries: opts.retries ?? 3,
-			idempotent: opts.idempotent ?? IDEMPOTENT_METHODS.has(method),
-			timeoutMs: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS,
-			cancelSignal: combineAborts(opts.signal, options.signal)
-		};
-	}
-	async function readJson(path, opts = {}) {
-		const chosenFor = inForce;
-		const { response, prepared } = await executeWithAuthRefresh(path, {
-			...opts,
-			expectContentType: "json"
-		});
-		return {
-			text: await response.text(),
-			context: {
-				method: prepared.method,
-				url: prepared.url,
-				status: response.status,
-				...namingOf(chosenFor)
-			}
-		};
-	}
-	function namingOf(profile) {
-		if (profile === null) return {
-			getServerTag,
-			serverSkew: null
-		};
-		return {
-			getServerTag: async () => profile.version.tag,
-			serverSkew: profile.skew
-		};
-	}
-	async function runProbe(order, budget) {
-		const read = await readJson(PROBE_PATH, probeBudget(budget));
-		const properties = await parseJsonResponse(read.text, SessionProperties, read.context);
-		const info = serverInfoFromProperties(properties);
-		const profile = createServerProfile(info);
-		if (applied === null || applied.order < order) {
-			options.onServerProbed?.(info, profile);
-			applied = {
-				order,
-				profile
-			};
-			inForce = profile;
-		}
-		return {
-			properties,
-			profile,
-			read
-		};
-	}
-	function startProbe(budget) {
-		probesStarted += 1;
-		const probed = runProbe(probesStarted, budget);
-		newest = probed;
-		inFlight.add(probed);
-		probed.then(() => {
-			inFlight.delete(probed);
-		}, () => {
-			inFlight.delete(probed);
-			if (newest === probed) newest = null;
-		});
-		return probed;
-	}
-	function appliedProfile() {
-		return applied === null ? null : applied.profile;
-	}
-	function verifying() {
-		const settled = appliedProfile();
-		if (newest === null && settled !== null) return Promise.resolve(settled);
-		return (newest ?? startProbe({})).then((probed) => probed.profile, fallBackTo(appliedProfile));
-	}
-	function profileInForce() {
-		const current = inForce;
-		if (current === null) return verifying();
-		if (newest === null) return Promise.resolve(current);
-		return newest.then((probed) => probed.profile, fallBackTo(() => inForce));
-	}
-	async function server(wait = {}) {
-		throwIfAborted(wait.signal);
-		return untilAborted(profileInForce(), wait.signal);
-	}
-	async function verifiedServer(wait = {}) {
-		throwIfAborted(wait.signal);
-		return untilAborted(verifying(), wait.signal);
-	}
-	async function probe(reader, read = {}) {
-		const { signal, ...budget } = read;
-		throwIfAborted(signal);
-		const probed = await untilAborted(startProbe(budget), signal);
-		const context = {
-			...probed.read.context,
-			...namingOf(probed.profile)
-		};
-		return parseJsonResponse(probed.read.text, reader, context);
-	}
-	async function probesSettled() {
-		while (inFlight.size > 0) await Promise.allSettled(inFlight);
-	}
-	async function requireFeatures(features, wait = {}) {
-		if (features.length === 0) return;
-		const profile = await preflightServer(wait);
-		if (profile === null) return;
-		for (const failure of featureFailures(features, profile)) refuseBeforeSending(new CapabilityError(failure));
-	}
-	async function preflightServer(wait = {}) {
-		try {
-			return await verifiedServer(wait);
-		} catch (error) {
-			if (!isNonInterruptFailure(error)) throw error;
-			skipOrThrow({
-				kind: "unverified",
-				failure: error
-			});
-			return null;
-		}
-	}
-	function refuseBeforeSending(refusal) {
-		skipOrThrow({
-			kind: "refused",
-			refusal
-		});
-	}
-	function skipOrThrow(skipped) {
-		const hook = options.onPreflightSkipped;
-		if (hook === void 0) throw skippedError(skipped);
-		hook(skipped);
-	}
-	return {
-		server,
-		verifiedServer,
-		probe,
-		requireFeatures,
-		preflightServer,
-		refuseBeforeSending,
-		probesSettled,
-		async requestRaw(path, opts) {
-			return (await executeWithAuthRefresh(path, opts ?? {})).response;
-		},
-		async requestParsed(schema, path, opts) {
-			const read = await readJson(path, opts);
-			return parseJsonResponse(read.text, schema, read.context);
-		},
-		async requestStream(path, opts) {
-			const { response, prepared } = await executeWithAuthRefresh(path, {
-				...opts,
-				expectContentType: opts?.expectContentType ?? "binary"
-			});
-			if (!response.body) throw new NetworkError("Response had no body to stream", {
-				method: prepared.method,
-				url: prepared.url,
-				cause: "missing body"
-			});
-			return response.body;
-		}
-	};
-}
-function skippedError(skipped) {
-	return skipped.kind === "refused" ? skipped.refusal : skipped.failure;
-}
-function fallBackTo(fallback) {
-	return (error) => {
-		const profile = fallback();
-		if (profile !== null && isNonInterruptFailure(error)) return profile;
-		throw error;
-	};
-}
-function tagOf(profile) {
-	return profile === null ? null : profile.version.tag;
-}
-function buildUrl(baseUrl, path, query) {
-	const normalizedPath = path.startsWith("/") ? path : `/${path}`;
-	const target = new URL(baseUrl + normalizedPath);
-	if (query) for (const [key, value] of Object.entries(query)) {
-		if (value === void 0) continue;
-		if (Array.isArray(value)) for (const entry of value) target.searchParams.append(key, String(entry));
-		else target.searchParams.append(key, String(value));
-	}
-	return target.toString();
-}
-function acceptHeader(expected) {
-	if (expected === "json") return JSON_CONTENT_TYPE;
-	if (expected === "text") return "text/*";
-	return "*/*";
-}
-function assertContentType(response, prepared) {
-	if (prepared.expectContentType === "binary") return;
-	const contentType = response.headers.get("content-type");
-	if (contentType === null) throwContentTypeMismatch(response, prepared, prepared.expectContentType);
-	if (prepared.expectContentType === "json" && !contentType.includes("application/json")) throwContentTypeMismatch(response, prepared, "json");
-	if (prepared.expectContentType === "text" && !contentType.startsWith(TEXT_CONTENT_TYPE_PREFIX)) throwContentTypeMismatch(response, prepared, "text");
-}
-function throwContentTypeMismatch(response, prepared, expected) {
-	const actual = response.headers.get("content-type") ?? "no content-type";
-	throw new HttpError({
-		status: response.status,
-		statusText: response.statusText,
-		method: prepared.method,
-		url: prepared.url,
-		responseHeaders: response.headers,
-		rawBody: null,
-		overrideUserMessage: `Expected ${expected} response but got ${actual}`
-	});
-}
-async function readBodyForError(response) {
-	try {
-		return Buffer.from(await response.arrayBuffer()).subarray(0, ERROR_BODY_BYTE_CAP).toString("utf8");
-	} catch (error) {
-		return `[body read failed: ${errorMessage(error)}]`;
-	}
-}
-//#endregion
 //#region ../client/src/resources/pivot-export.ts
 const PivotedExportsProperty = SessionProperties.extend({ "enable-pivoted-exports": z.boolean() });
 /**
@@ -485,11 +77,11 @@ function cardResource(transport) {
 	}
 	/** Get one card by id. */
 	async function get(id, options = {}) {
-		return transport.requestParsed(Card, `/api/card/${id}`, { ...options });
+		return transport.requestParsed(CardDetail, `/api/card/${id}`, { ...options });
 	}
 	/** Create a card — a question, a model, or a metric — from a full card body. */
 	async function create(params, options = {}) {
-		return transport.requestParsed(Card, "/api/card", {
+		return transport.requestParsed(CardDetail, "/api/card", {
 			...options,
 			method: "POST",
 			body: params
@@ -497,7 +89,7 @@ function cardResource(transport) {
 	}
 	/** Update a card by id, patching only the fields the body carries. */
 	async function update(id, params, options = {}) {
-		return transport.requestParsed(Card, `/api/card/${id}`, {
+		return transport.requestParsed(CardDetail, `/api/card/${id}`, {
 			...options,
 			method: "PUT",
 			body: params
@@ -507,12 +99,20 @@ function cardResource(transport) {
 	async function archive(id, options = {}) {
 		return update(id, { archived: true }, options);
 	}
-	/** Run a saved card and return the query result envelope. */
+	/**
+	* Run the query associated with a Card and return the query result envelope. A result served
+	* from the cache carries the time it was computed in `cached`; `ignore_cache` runs the query
+	* against the database instead. The rows stop at the server's row limit for an API run, which
+	* `rows_truncated` carries when it cut them; `exportQuery` runs under the larger download limit.
+	*/
 	async function query(id, params, options = {}) {
 		return transport.requestParsed(CardQueryResult, `/api/card/${id}/query`, {
 			...options,
 			method: "POST",
-			body: { parameters: params.parameters }
+			body: {
+				parameters: params.parameters,
+				ignore_cache: params.ignore_cache
+			}
 		});
 	}
 	/**
@@ -625,13 +225,17 @@ async function listCollectionsAs(transport, schema, options = {}) {
 function collectionResource(transport) {
 	/**
 	* List collections. `filter` picks a server-side preset: everything, archived, or personal. Every
-	* preset includes the Library collections that match it.
+	* preset includes the Library collections that match it. `namespace` lists that namespace's
+	* collections, with its root, instead of the default namespace's.
 	*/
 	async function list(params = {}, options = {}) {
 		return {
 			data: await transport.requestParsed(CollectionApiList, "/api/collection", {
 				...options,
-				query: COLLECTION_LIST_QUERY[params.filter ?? DEFAULT_LIST_FILTER]
+				query: {
+					...COLLECTION_LIST_QUERY[params.filter ?? DEFAULT_LIST_FILTER],
+					namespace: params.namespace
+				}
 			}),
 			total: null
 		};
@@ -887,15 +491,26 @@ function dashboardResource(transport) {
 	}
 	/**
 	* Update a dashboard by id, patching only the fields the body carries. `dashcards` and `tabs` are
-	* full replacements: whatever the body omits is deleted from the dashboard.
+	* full replacements: whatever the arrays omit is deleted from the dashboard. A body with
+	* `dashcards` and no `tabs` key keeps the current tabs, read first: the server takes the missing
+	* key for an empty list and deletes every tab, or fails on a dashcard that still names one.
 	*/
 	async function update(id, params, options = {}) {
+		const body = await withCurrentTabs(id, params, options);
 		return transport.requestParsed(DashboardDetail, `/api/dashboard/${id}`, {
 			...options,
 			method: "PUT",
-			body: params
+			body
 		});
 	}
+	async function withCurrentTabs(id, params, options) {
+		if (params.dashcards === void 0 || params.tabs !== void 0) return params;
+		const current = await get(id, options);
+		return {
+			...params,
+			tabs: tabWrites(current.tabs)
+		};
+	}
 	/**
 	* Copy a dashboard, with its tabs and dashcards, into `collection_id` (root when absent). A deep
 	* copy duplicates its questions and metrics and references its models. With `is_deep_copy`
@@ -928,7 +543,7 @@ function dashboardResource(transport) {
 	/**
 	* Patch one dashcard on a dashboard. Metabase exposes no dashcard endpoint and its dashboard PUT
 	* is a full replace of `dashcards`, so the patch is read-modify-written over the dashboard as it
-	* currently stands.
+	* currently stands, its tabs sent back unchanged.
 	*/
 	async function updateDashcard(dashboardId, dashcardId, params, options = {}) {
 		const dashboard = await get(dashboardId, options);
@@ -938,7 +553,10 @@ function dashboardResource(transport) {
 			...target,
 			...params
 		});
-		const refreshed = (await update(dashboardId, { dashcards: dashboard.dashcards.map((dashcard) => stripEntityId(dashcard.id === dashcardId ? patched : dashcard)) }, options)).dashcards.find((dashcard) => dashcard.id === dashcardId);
+		const refreshed = (await update(dashboardId, {
+			dashcards: dashboard.dashcards.map((dashcard) => stripEntityId(dashcard.id === dashcardId ? patched : dashcard)),
+			tabs: tabWrites(dashboard.tabs)
+		}, options)).dashcards.find((dashcard) => dashcard.id === dashcardId);
 		if (refreshed === void 0) throw new Error(`PUT /api/dashboard/${dashboardId}: dashcard ${dashcardId} missing from response`);
 		return refreshed;
 	}
@@ -977,17 +595,26 @@ function dashboardResource(transport) {
 	}
 	/**
 	* Fetch the selectable values for a dashboard parameter, through the chain-filter value endpoint.
+	* `constraints` sets other parameters' values, which narrow the values of a parameter linked to
+	* them.
 	*/
-	async function parameterValues(dashboardId, parameterId, options = {}) {
-		return transport.requestParsed(ParameterValues, `/api/dashboard/${dashboardId}/params/${encodeURIComponent(parameterId)}/values`, { ...options });
+	async function parameterValues(dashboardId, parameterId, constraints = {}, options = {}) {
+		return transport.requestParsed(ParameterValues, `/api/dashboard/${dashboardId}/params/${encodeURIComponent(parameterId)}/values`, {
+			...options,
+			query: constraints
+		});
 	}
 	/**
 	* Search a dashboard parameter's selectable values: the server returns only values containing the
-	* substring, capped at the first 1000 matches.
+	* substring, capped at the first 1000 matches. `constraints` narrows them as `parameterValues`
+	* does.
 	*/
-	async function searchParameterValues(dashboardId, parameterId, query, options = {}) {
+	async function searchParameterValues(dashboardId, parameterId, query, constraints = {}, options = {}) {
 		const parameter = encodeURIComponent(parameterId);
-		return transport.requestParsed(ParameterValues, `/api/dashboard/${dashboardId}/params/${parameter}/search/${encodeURIComponent(query)}`, { ...options });
+		return transport.requestParsed(ParameterValues, `/api/dashboard/${dashboardId}/params/${parameter}/search/${encodeURIComponent(query)}`, {
+			...options,
+			query: constraints
+		});
 	}
 	return {
 		list,
@@ -1025,6 +652,12 @@ function groupByCardId(references) {
 	}
 	return grouped;
 }
+function tabWrites(tabs) {
+	return tabs.map(({ id, name }) => ({
+		id,
+		name
+	}));
+}
 function stripEntityId(dashcard) {
 	const { entity_id: _entity_id, id, size_x, size_y, row, col, ...rest } = dashcard;
 	return {
@@ -1037,6 +670,81 @@ function stripEntityId(dashcard) {
 	};
 }
 //#endregion
+//#region ../client/src/resources/data-action.ts
+function collectionFeatures(params) {
+	return params.collection_id === void 0 ? [] : [{
+		feature: "dataActionCollections",
+		fields: ["collection_id"]
+	}];
+}
+function dataActionResource(transport) {
+	const { explain } = explainer(transport, "dataAction");
+	async function readSchema(options) {
+		const { features } = await transport.server(options);
+		return dataActionSchema(features);
+	}
+	/** List the unarchived data actions the caller can see. `GET /api/action` answers a bare array. */
+	async function list(options = {}) {
+		const schema = await readSchema(options);
+		return {
+			data: await transport.requestParsed(z.array(schema), "/api/action", { ...options }),
+			total: null
+		};
+	}
+	/** Get one unarchived data action by id. */
+	async function get(id, options = {}) {
+		const schema = await readSchema(options);
+		return transport.requestParsed(schema, `/api/action/${id}`, { ...options });
+	}
+	/** Create a data action — a parameterized native query that writes to a database — in a collection. */
+	async function create(params, options = {}) {
+		const schema = await readSchema(options);
+		return transport.requestParsed(schema, "/api/action", {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	/** Update a data action by id, patching only the fields the body carries. */
+	async function update(id, params, options = {}) {
+		const schema = await readSchema(options);
+		return transport.requestParsed(schema, `/api/action/${id}`, {
+			...options,
+			method: "PUT",
+			body: params
+		});
+	}
+	/** Archive (soft-delete) a data action by id. Metabase models this as an update, not its own endpoint. */
+	async function archive(id, options = {}) {
+		return update(id, { archived: true }, options);
+	}
+	/** Delete a data action by id, removing it and the dashboard buttons that run it. */
+	async function remove(id, options = {}) {
+		await transport.requestRaw(`/api/action/${id}`, {
+			...options,
+			method: "DELETE",
+			expectContentType: "binary"
+		});
+	}
+	/** Execute a data action by id with parameter values keyed by parameter id. */
+	async function execute(id, params, options = {}) {
+		return transport.requestParsed(DataActionExecuteResult, `/api/action/${id}/execute`, {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	return {
+		list,
+		get,
+		create: explain("create", create),
+		update: explain("update", update, (_id, params) => collectionFeatures(params)),
+		archive,
+		delete: remove,
+		execute
+	};
+}
+//#endregion
 //#region ../client/src/resources/database.ts
 const DatabaseApiList = z.object({
 	data: z.array(Database),
@@ -1068,6 +776,14 @@ function databaseResource(transport) {
 			query: { include: params.include }
 		});
 	}
+	/** Update a database's settings by id; the server merges them into the ones it holds. */
+	async function update(id, params, options = {}) {
+		return transport.requestParsed(DatabaseWithSettings, `/api/database/${id}`, {
+			...options,
+			method: "PUT",
+			body: params
+		});
+	}
 	/** List the schema names in a database. */
 	async function schemas(id, options = {}) {
 		return {
@@ -1119,6 +835,7 @@ function databaseResource(transport) {
 	return {
 		list,
 		get,
+		update,
 		schemas,
 		schemaTables,
 		syncSchema,
@@ -1618,6 +1335,11 @@ const RemoteSyncBranchProperty = SessionProperties.extend({ "remote-sync-branch"
 const RemoteSyncUrlProperty = SessionProperties.extend({ "remote-sync-url": z.string().nullable().optional() });
 const BRANCH_UNREADABLE_MESSAGE = "the remote-sync-branch setting is not readable: only admins see it, and a server without remote sync has none";
 const BRANCH_UNSET_MESSAGE = "git-sync tracks no branch: the remote-sync-branch setting is unset";
+const RemoteSyncStateProperty = RemoteSyncBranchProperty.extend({
+	"remote-sync-enabled": z.boolean().optional(),
+	"remote-sync-type": RemoteSyncState.shape.sync_type.optional()
+});
+const REMOTE_SYNC_STATE_ABSENT_MESSAGE = "the remote-sync-enabled and remote-sync-type settings are absent: the server has no remote-sync module";
 function isRemoteUnreadable(error) {
 	if (!(error instanceof HttpError)) return false;
 	return error.status === 403 || error.status === 404;
@@ -1734,13 +1456,14 @@ function gitSyncResource(transport) {
 				merge: params.merge
 			}
 		});
-		if (params.wait === void 0) return {
+		const accepted = {
 			message: started.message,
-			task_id: started.task_id
+			task_id: started.task_id,
+			branch: branchName ?? null
 		};
+		if (params.wait === void 0) return accepted;
 		return {
-			message: started.message,
-			task_id: started.task_id,
+			...accepted,
 			final: await settle(params.wait, options)
 		};
 	}
@@ -1860,6 +1583,24 @@ function gitSyncResource(transport) {
 		return tracked;
 	}
 	/**
+	* Whether a remote is configured, through the settings or the environment, the direction the
+	* instance syncs in, which is `read-only` until an admin sets it, and the branch it tracks, all
+	* from one read. The remote's URL is visible to admins only and absent when the environment sets
+	* it, so `configured` is read from its own setting. Refused like `branch` when the caller may not
+	* read the branch, and on a server without the remote-sync module.
+	*/
+	function remote(properties) {
+		const tracked = branch(properties);
+		const configured = properties["remote-sync-enabled"];
+		const syncType = properties["remote-sync-type"];
+		if (configured === void 0 || syncType === void 0) throw new ConfigError(REMOTE_SYNC_STATE_ABSENT_MESSAGE);
+		return {
+			configured,
+			sync_type: syncType,
+			branch: tracked
+		};
+	}
+	/**
 	* The branch git-sync tracks, refused when none is configured, the server has no remote sync, or
 	* the caller may not read it.
 	*/
@@ -1897,6 +1638,7 @@ function gitSyncResource(transport) {
 		syncedCollections: refuse("syncedCollections", syncedCollections),
 		remoteUrl,
 		branch: refuseAfterReading("branch", RemoteSyncBranchProperty, branch),
+		remote: refuseAfterReading("remote", RemoteSyncStateProperty, remote),
 		trackedBranch: refuseAfterReading("trackedBranch", RemoteSyncBranchProperty, trackedBranch),
 		waitForTask: explain("waitForTask", waitForTask)
 	};
@@ -2708,7 +2450,8 @@ const RevisionEntity = z.enum([
 	"document",
 	"measure",
 	"segment",
-	"transform"
+	"transform",
+	"transform-test"
 ]);
 const RevisionUser = z.object({
 	id: z.number().int(),
@@ -2772,7 +2515,8 @@ const RevisionApiRevert = z.union([Revision.transform((revision) => ({
 }))]);
 const ENTITY_FEATURES = {
 	measure: "measures",
-	transform: "transforms"
+	transform: "transforms",
+	"transform-test": "transformTests"
 };
 function entityFeatures(entity) {
 	const feature = ENTITY_FEATURES[entity];
@@ -4060,167 +3804,6 @@ function transformTagResource(transport) {
 	};
 }
 //#endregion
-//#region ../client/src/domain/transform-test.ts
-const TransformTestTable = z.object({
-	schema: z.string().min(1).nullable().optional(),
-	name: z.string().min(1)
-}).loose();
-const TransformTestColumn = z.object({
-	name: z.string().min(1),
-	cast_type: z.string().min(1)
-}).loose();
-const TransformTestCell = z.union([
-	z.boolean(),
-	z.number(),
-	z.string(),
-	z.null()
-]);
-const TransformTestRow = z.record(z.string(), TransformTestCell);
-const TransformTestSqlInput = z.object({
-	table: TransformTestTable,
-	format: z.literal("sql"),
-	sql: z.string().min(1)
-}).loose();
-const TransformTestRowsInput = z.object({
-	table: TransformTestTable,
-	format: z.literal("rows"),
-	columns: z.array(TransformTestColumn).min(1),
-	rows: z.array(TransformTestRow)
-}).loose();
-const TransformTestInput = z.discriminatedUnion("format", [TransformTestSqlInput, TransformTestRowsInput]);
-const TransformTestEqualsSqlExpectation = z.object({
-	type: z.literal("equals"),
-	name: z.string().min(1),
-	format: z.literal("sql"),
-	sql: z.string().min(1)
-}).loose();
-const TransformTestEqualsRowsExpectation = z.object({
-	type: z.literal("equals"),
-	name: z.string().min(1),
-	format: z.literal("rows"),
-	columns: z.array(TransformTestColumn).min(1),
-	rows: z.array(TransformTestRow)
-}).loose();
-const TransformTestEqualsExpectation = z.discriminatedUnion("format", [TransformTestEqualsSqlExpectation, TransformTestEqualsRowsExpectation]);
-const TransformTestEmptyExpectation = z.object({
-	type: z.literal("empty"),
-	name: z.string().min(1),
-	sql: z.string().min(1)
-}).loose();
-const TransformTestExpectation = z.discriminatedUnion("type", [TransformTestEqualsExpectation, TransformTestEmptyExpectation]);
-const TransformTest = z.object({
-	id: z.number().int(),
-	entity_id: z.string(),
-	transform_id: z.number().int(),
-	creator_id: z.number().int(),
-	name: z.string(),
-	description: z.string().nullable(),
-	inputs: z.array(TransformTestInput),
-	expectations: z.array(TransformTestExpectation),
-	created_at: z.string(),
-	updated_at: z.string()
-}).loose();
-TransformTest.pick({
-	id: true,
-	transform_id: true,
-	name: true,
-	description: true
-}).strip();
-z.object({
-	transform_id: z.number().int().positive(),
-	name: z.string().min(1),
-	description: z.string().nullable().optional(),
-	inputs: z.array(TransformTestInput),
-	expectations: z.array(TransformTestExpectation)
-}).loose();
-z.object({
-	transform_id: z.number().int().positive().optional(),
-	name: z.string().min(1).optional(),
-	description: z.string().nullable().optional(),
-	inputs: z.array(TransformTestInput).optional(),
-	expectations: z.array(TransformTestExpectation).optional()
-}).loose();
-const TransformTestResultColumn = z.object({
-	name: z.string(),
-	database_type: z.string()
-}).loose();
-const TransformTestExpectationError = z.object({
-	type: z.string(),
-	message: z.string()
-}).loose();
-const TransformTestCellMismatch = z.object({
-	column: z.string(),
-	expected: TransformTestCell,
-	actual: TransformTestCell
-}).loose();
-const TransformTestRowCounts = z.object({
-	actual: z.number().int(),
-	expected: z.number().int()
-}).loose();
-const TransformTestEqualsFindings = z.object({
-	name: z.string(),
-	type: z.literal("equals"),
-	status: z.enum(["passed", "failed"]),
-	columns: z.array(TransformTestResultColumn),
-	"row-counts": TransformTestRowCounts,
-	"extra-rows": z.array(TransformTestRow),
-	"missing-rows": z.array(TransformTestRow),
-	"cell-mismatches": z.array(TransformTestCellMismatch),
-	truncated: z.number().int()
-}).loose();
-const TransformTestEqualsError = z.object({
-	name: z.string(),
-	type: z.literal("equals"),
-	status: z.literal("error"),
-	error: TransformTestExpectationError
-}).loose();
-const TransformTestEqualsResult = z.discriminatedUnion("status", [TransformTestEqualsFindings, TransformTestEqualsError]);
-const TransformTestEmptyPassed = z.object({
-	name: z.string(),
-	type: z.literal("empty"),
-	status: z.literal("passed")
-}).loose();
-const TransformTestEmptyFailed = z.object({
-	name: z.string(),
-	type: z.literal("empty"),
-	status: z.literal("failed"),
-	columns: z.array(TransformTestResultColumn),
-	sample: z.array(TransformTestRow),
-	truncated: z.number().int()
-}).loose();
-const TransformTestEmptyError = z.object({
-	name: z.string(),
-	type: z.literal("empty"),
-	status: z.literal("error"),
-	error: TransformTestExpectationError
-}).loose();
-const TransformTestEmptyResult = z.discriminatedUnion("status", [
-	TransformTestEmptyPassed,
-	TransformTestEmptyFailed,
-	TransformTestEmptyError
-]);
-const TransformTestExpectationResult = z.discriminatedUnion("type", [TransformTestEqualsResult, TransformTestEmptyResult]);
-const TransformTestRunResult = z.object({
-	status: z.enum(["passed", "failed"]),
-	expectations: z.array(TransformTestExpectationResult),
-	tables: z.record(z.string(), z.string())
-}).loose();
-z.enum([
-	"transform-test.unknown-column",
-	"transform-test.ambiguous-column",
-	"transform-test.missing-inputs",
-	"transform-test.unused-inputs",
-	"transform-test.duplicate-input-table",
-	"transform-test.unparseable-source",
-	"transform-test.unremapped-reference",
-	"transform-test.unsupported-transform",
-	"transform-test.unsupported-driver",
-	"transform-test.transform-failed",
-	"transform-test.setup-failed",
-	"transform-test.expectation-failed",
-	"transform-test.unsupported-format"
-]);
-//#endregion
 //#region ../client/src/resources/transform-test.ts
 const TransformTestApiList = z.array(TransformTest);
 function transformTestResource(transport) {
@@ -4368,6 +3951,7 @@ function createClient(config, options) {
 		collection: collectionResource(transport),
 		contentTranslation: contentTranslationResource(transport),
 		dashboard: dashboardResource(transport),
+		dataAction: dataActionResource(transport),
 		database: databaseResource(transport),
 		dataset: datasetResource(transport),
 		dependency: dependencyResource(transport),