@metabase/cli 0.5.0 → 0.5.1

package/dist/{client-BmURNkkW.mjs → client-BBwYPXDW.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 { At as formatZodIssue, Et as TimeoutError, Mt as isNonInterruptFailure, P as CapabilityError, Q as parseJsonOrPlain, Tt as ResponseShapeError, W as HttpError, Y as isPlainObject, kt as errorMessage, n as isMethodKey, r as methodRequirements, wt as PartialWriteError, xt as InternalError, yt as ConfigError } 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 { L as profileFromProperties, Z as SessionProperties } from "./runtime-Ckns6TKK.mjs";
+import { n as featureFailures, r as supersedingFeature, t as checkFeatures } from "./requirement-check-BE3PuGsC.mjs";
+import { n as createTransport } from "./transport-0qFZhEuP.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 { r as PivotExportFormat, t as DatasetQuery } from "./query-BKtMP5eH.mjs";
+import { a as CardQueryResult, t as Card } from "./card-P5mBknsl.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 { t as Database } from "./database-2HYCdHqK.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-D-x2Ho2i.mjs";
+import { c as CollectionItem, m as CollectionTreeNode, r as Collection } from "./collection-B2wRXyTF.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 { a as DataActionExecuteResult, s as dataActionSchema } from "./data-action-DZxVB_hD.mjs";
+import { r as pollUntil } from "./poll-CX3jPtXb.mjs";
+import { i as DependencyEntity, s as DependencyGraph, t as BreakingSource, u as DependencyNode } from "./dependency-qP1hx2YN.mjs";
+import { t as Document } from "./document-UMG6me2P.mjs";
+import { i as EidTranslateResult } from "./eid-translation-Ba92VOHe.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 { t as Glossary } from "./glossary-QN-hHfOT.mjs";
+import { a as libraryWireSchema, i as LibraryPublishTablesInput, n as LibraryCollectionInfo, o as toLibrary } from "./library-BKSFtIV9.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 { 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-CXRavT7G.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() });
 /**
@@ -1037,6 +629,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),
@@ -2708,7 +2375,8 @@ const RevisionEntity = z.enum([
 	"document",
 	"measure",
 	"segment",
-	"transform"
+	"transform",
+	"transform-test"
 ]);
 const RevisionUser = z.object({
 	id: z.number().int(),
@@ -2772,7 +2440,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 +3729,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 +3876,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),