@metabase/cli 0.3.0-alpha.extract-api-client.e9b2dd5 → 0.3.1-alpha.fix-transform-test-ee-path.a3ca6dd

package/dist/client-toDDqakD.mjs

@@ -0,0 +1,4093 @@
+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 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-CwhhhwcB.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 { 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 { 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-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 { 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 { 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";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	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;
+	}
+}
+//#endregion
+//#region ../client/src/http/transport.ts
+const UNAUTHORIZED_STATUS = 401;
+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 settledProfile = options.server ?? null;
+	const getServerTag = options.getServerTag ?? (async () => tagOf(settledProfile));
+	const serverSkew = () => settledProfile === null ? null : settledProfile.skew;
+	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 === UNAUTHORIZED_STATUS) {
+				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)
+		};
+	}
+	let serverProfile = options.server === void 0 ? null : Promise.resolve(options.server);
+	async function server(wait = {}) {
+		throwIfAborted(wait.signal);
+		if (serverProfile === null) {
+			const probe = probeServer(transport).then((info) => {
+				settledProfile = createServerProfile(info);
+				return settledProfile;
+			});
+			probe.catch(() => {
+				serverProfile = null;
+			});
+			serverProfile = probe;
+		}
+		return untilAborted(serverProfile, wait.signal);
+	}
+	const enforceRequirements = options.enforceRequirements ?? true;
+	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: requireMethod,
+		requireFeatures,
+		async requestRaw(path, opts) {
+			return (await executeWithAuthRefresh(path, opts ?? {})).response;
+		},
+		async requestParsed(schema, path, opts) {
+			const { response, prepared } = await executeWithAuthRefresh(path, {
+				...opts,
+				expectContentType: "json"
+			});
+			return parseJsonResponse(await response.text(), schema, {
+				method: prepared.method,
+				url: prepared.url,
+				status: response.status,
+				getServerTag,
+				serverSkew: serverSkew()
+			});
+		},
+		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;
+		}
+	};
+	return transport;
+}
+function tagOf(profile) {
+	if (profile === null || profile.version === null) return null;
+	return 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/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) {
+	/** List cards. `f` picks a server-side preset; `model_id` scopes the presets that need an id. */
+	async function list(params = {}, options = {}) {
+		await transport.require("card.list", options);
+		return {
+			data: await transport.requestParsed(CardApiList, "/api/card", {
+				...options,
+				query: {
+					f: params.f,
+					model_id: params.model_id
+				}
+			}),
+			total: null
+		};
+	}
+	/** Get one card by id. */
+	async function get(id, options = {}) {
+		await transport.require("card.get", options);
+		return transport.requestParsed(Card, `/api/card/${id}`, { ...options });
+	}
+	/** Create a card — a question, a model, or a metric — from a full card body. */
+	async function create(params, options = {}) {
+		await transport.require("card.create", options);
+		return transport.requestParsed(Card, "/api/card", {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	/** Update a card by id, patching only the fields the body carries. */
+	async function update(id, params, options = {}) {
+		await transport.require("card.update", options);
+		return transport.requestParsed(Card, `/api/card/${id}`, {
+			...options,
+			method: "PUT",
+			body: params
+		});
+	}
+	/** Archive (soft-delete) a card by id. Metabase models this as an update, not its own endpoint. */
+	async function archive(id, options = {}) {
+		await transport.require("card.archive", options);
+		return update(id, { archived: true }, options);
+	}
+	/** Run a saved card and return the query result envelope. */
+	async function query(id, params, options = {}) {
+		await transport.require("card.query", options);
+		return transport.requestParsed(CardQueryResult, `/api/card/${id}/query`, {
+			...options,
+			method: "POST",
+			body: { parameters: params.parameters }
+		});
+	}
+	/**
+	* Run a saved card and stream its result as a download. Unlike `query`, this endpoint takes a
+	* form-encoded body and answers bytes, so a caller consumes the stream rather than a value.
+	*/
+	async function exportQuery(id, format, params, options = {}) {
+		await transport.require("card.exportQuery", options);
+		const body = new URLSearchParams({
+			parameters: JSON.stringify(params.parameters),
+			format_rows: String(params.format_rows),
+			pivot_results: String(params.pivot_results)
+		});
+		return transport.requestStream(`/api/card/${id}/query/${format}`, {
+			...options,
+			method: "POST",
+			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,
+		create,
+		update,
+		archive,
+		query,
+		exportQuery,
+		queryMetadata
+	};
+}
+async function* paginatePages(client, path, itemSchema, opts = {}) {
+	const envelopeSchema = paginatedEnvelopeSchema(itemSchema);
+	const pageSize = opts.pageSize ?? 50;
+	if (!Number.isInteger(pageSize) || pageSize < 1) throw new InternalError(`pageSize must be an integer of at least 1, got ${pageSize}`);
+	const start = opts.offset ?? 0;
+	const max = opts.max ?? Number.POSITIVE_INFINITY;
+	let taken = 0;
+	let previousHead = null;
+	while (taken < max) {
+		const remaining = max - taken;
+		const limit = Math.min(pageSize, remaining);
+		const offset = start + taken;
+		const envelope = await client.requestParsed(envelopeSchema, path, {
+			query: {
+				...opts.query,
+				limit,
+				offset
+			},
+			...opts.signal !== void 0 && { signal: opts.signal }
+		});
+		const items = envelope.data.length > remaining ? envelope.data.slice(0, remaining) : envelope.data;
+		const total = envelope.total ?? null;
+		const head = items.length === 0 ? null : JSON.stringify(items[0]);
+		if (head !== null && head === previousHead) throw new ConfigError(`the endpoint returned the same first row at offset ${offset} as at the previous offset; it is ignoring the offset parameter, so paging cannot advance`);
+		previousHead = head;
+		yield {
+			items,
+			total
+		};
+		if (items.length === 0) return;
+		const consumed = taken + items.length;
+		if (total !== null && start + consumed === total) return;
+		taken = consumed;
+	}
+}
+function paginatedEnvelopeSchema(itemSchema) {
+	return z.object({
+		data: z.array(itemSchema),
+		total: z.number().int().nonnegative().nullable().optional(),
+		limit: z.number().int().nonnegative().optional(),
+		offset: z.number().int().nonnegative().optional()
+	}).loose();
+}
+//#endregion
+//#region ../client/src/resources/collection.ts
+const CollectionApiList = z.array(Collection);
+const CollectionTreeApiList = z.array(CollectionTreeNode);
+const COLLECTION_LIST_QUERY = {
+	all: {},
+	archived: { archived: true },
+	personal: { "personal-only": true }
+};
+const DEFAULT_LIST_FILTER = "all";
+function refPath(ref) {
+	return encodeURIComponent(ref);
+}
+/**
+* List collections including the Library and its children, parsing each through the caller's own
+* projection. `Collection` pins `type`, `namespace` and `authority_level` to closed enums, so a
+* consumer reading a few fields off every collection on the instance narrows here: one collection
+* carrying a server value outside those sets then costs nothing to a caller that never reads the
+* field.
+*/
+async function listCollectionsWithLibrary(transport, schema, options = {}) {
+	return transport.requestParsed(z.array(schema), "/api/collection", {
+		...options,
+		query: { "include-library": true }
+	});
+}
+function collectionResource(transport) {
+	/** List collections. `filter` picks a server-side preset: everything, archived, or personal. */
+	async function list(params = {}, options = {}) {
+		await transport.require("collection.list", options);
+		return {
+			data: await transport.requestParsed(CollectionApiList, "/api/collection", {
+				...options,
+				query: COLLECTION_LIST_QUERY[params.filter ?? DEFAULT_LIST_FILTER]
+			}),
+			total: null
+		};
+	}
+	/**
+	* List collections including the Library and its children, which the plain listing omits.
+	* The Library's own children carry neither `type` nor `is_remote_synced`, so this is where a
+	* caller resolves both.
+	*/
+	async function listWithLibrary(options = {}) {
+		await transport.require("collection.listWithLibrary", options);
+		return {
+			data: await listCollectionsWithLibrary(transport, Collection, options),
+			total: null
+		};
+	}
+	/** Get one collection by id, entity id, or the `root`/`trash` alias. */
+	async function get(ref, options = {}) {
+		await transport.require("collection.get", options);
+		return transport.requestParsed(Collection, `/api/collection/${refPath(ref)}`, { ...options });
+	}
+	/** Create a new collection. */
+	async function create(params, options = {}) {
+		await transport.require("collection.create", options);
+		return transport.requestParsed(Collection, "/api/collection", {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	/** Update a collection, patching only the fields the body carries. */
+	async function update(ref, params, options = {}) {
+		await transport.require("collection.update", options);
+		return transport.requestParsed(Collection, `/api/collection/${refPath(ref)}`, {
+			...options,
+			method: "PUT",
+			body: params
+		});
+	}
+	/** Archive (soft-delete) a collection. Metabase models this as an update, not its own endpoint. */
+	async function archive(ref, options = {}) {
+		await transport.require("collection.archive", options);
+		return update(ref, { archived: true }, options);
+	}
+	/**
+	* Walk the items inside a collection one page at a time. This endpoint pages on the server, so
+	* the caller consumes pages rather than a single list and decides how far to pull.
+	*/
+	async function* itemPages(ref, params = {}, options = {}) {
+		await transport.require("collection.itemPages", options);
+		yield* paginatePages(transport, `/api/collection/${refPath(ref)}/items`, CollectionItem, {
+			query: {
+				models: params.models,
+				archived: params.archived,
+				pinned_state: params.pinned_state
+			},
+			...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 }
+		});
+	}
+	/** Fetch the collection hierarchy as a forest of nested nodes. */
+	async function tree(options = {}) {
+		await transport.require("collection.tree", options);
+		return {
+			data: await transport.requestParsed(CollectionTreeApiList, "/api/collection/tree", { ...options }),
+			total: null
+		};
+	}
+	return {
+		list,
+		listWithLibrary,
+		get,
+		create,
+		update,
+		archive,
+		itemPages,
+		tree
+	};
+}
+//#endregion
+//#region ../client/src/resources/csv-upload.ts
+const CSV_CONTENT_TYPE = "text/csv";
+function buildCsvFormData(file) {
+	const form = new FormData();
+	form.append("file", new Blob([file.bytes], { type: CSV_CONTENT_TYPE }), file.filename);
+	return form;
+}
+//#endregion
+//#region ../client/src/resources/content-translation.ts
+const CONTENT_TRANSLATION_PATH = "/api/ee/content-translation";
+function contentTranslationResource(transport) {
+	/** Download the complete content translation dictionary as CSV. */
+	async function download(options = {}) {
+		await transport.require("contentTranslation.download", options);
+		return transport.requestStream(`${CONTENT_TRANSLATION_PATH}/csv`, options);
+	}
+	/** Replace the complete content translation dictionary with the attached CSV. */
+	async function upload(file, options = {}) {
+		await transport.require("contentTranslation.upload", options);
+		const form = buildCsvFormData(file);
+		return transport.requestParsed(ContentTranslationUploadResult, `${CONTENT_TRANSLATION_PATH}/upload-dictionary`, {
+			...options,
+			method: "POST",
+			body: form
+		});
+	}
+	return {
+		download,
+		upload
+	};
+}
+//#endregion
+//#region ../client/src/resources/dashboard.ts
+const DashboardApiList = z.array(Dashboard);
+const PreflightDashcard = z.looseObject({ card_id: z.number().int().nullable().optional() });
+function dashboardResource(transport) {
+	const card = cardResource(transport);
+	/** List dashboards. `f` picks a server-side preset. */
+	async function list(params = {}, options = {}) {
+		await transport.require("dashboard.list", options);
+		return {
+			data: await transport.requestParsed(DashboardApiList, "/api/dashboard", {
+				...options,
+				query: { f: params.f }
+			}),
+			total: null
+		};
+	}
+	/** Get one dashboard by id, with its dashcards, tabs and parameters. */
+	async function get(id, options = {}) {
+		await transport.require("dashboard.get", options);
+		return transport.requestParsed(DashboardDetail, `/api/dashboard/${id}`, { ...options });
+	}
+	/**
+	* Create a dashboard. The endpoint accepts no dashcards or tabs — a follow-up `update` is what
+	* puts content on a fresh dashboard.
+	*/
+	async function create(params, options = {}) {
+		await transport.require("dashboard.create", options);
+		return transport.requestParsed(Dashboard, "/api/dashboard", {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	/**
+	* 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.
+	*/
+	async function update(id, params, options = {}) {
+		await transport.require("dashboard.update", options);
+		return transport.requestParsed(DashboardDetail, `/api/dashboard/${id}`, {
+			...options,
+			method: "PUT",
+			body: params
+		});
+	}
+	/**
+	* 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.
+	*/
+	async function archive(id, options = {}) {
+		await transport.require("dashboard.archive", options);
+		return transport.requestParsed(Dashboard, `/api/dashboard/${id}`, {
+			...options,
+			method: "PUT",
+			body: { archived: true }
+		});
+	}
+	/**
+	* 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.
+	*/
+	async function updateDashcard(dashboardId, dashcardId, params, options = {}) {
+		await transport.require("dashboard.updateDashcard", options);
+		const dashboard = await get(dashboardId, options);
+		const target = dashboard.dashcards.find((dashcard) => dashcard.id === dashcardId);
+		if (target === void 0) throw new ConfigError(`dashcard ${dashcardId} not found on dashboard ${dashboardId}`);
+		const patched = Dashcard.parse({
+			...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);
+		if (refreshed === void 0) throw new Error(`PUT /api/dashboard/${dashboardId}: dashcard ${dashcardId} missing from response`);
+		return refreshed;
+	}
+	/**
+	* Check every card a `dashcards` body references before writing it, through `GET /api/card/{id}`
+	* once per distinct id. Reports one issue per reference whose card is missing, archived, or
+	* unreadable, so an empty result means the body is safe to send; an id the server answers for in
+	* any other way propagates as the failure it was.
+	*/
+	async function checkCardReferences(dashcards, options = {}) {
+		await transport.require("dashboard.checkCardReferences", options);
+		const grouped = groupByCardId(collectCardReferences(dashcards));
+		return (await Promise.all(Array.from(grouped.entries()).map(async ([cardId, references]) => ({
+			references,
+			problem: await inspectCard(cardId, options)
+		})))).flatMap((check) => {
+			const problem = check.problem;
+			if (problem === null) return [];
+			return check.references.map((reference) => ({
+				...reference,
+				problem
+			}));
+		});
+	}
+	async function inspectCard(cardId, options) {
+		try {
+			return (await card.get(cardId, options)).archived ? { reason: "archived" } : null;
+		} catch (error) {
+			if (!(error instanceof HttpError)) throw error;
+			if (error.kind === "resource-missing") return { reason: "missing" };
+			if (error.kind === "auth") return {
+				reason: "unreadable",
+				detail: error.userMessage
+			};
+			throw error;
+		}
+	}
+	/**
+	* Fetch the selectable values for a dashboard parameter, through the chain-filter value endpoint.
+	*/
+	async function parameterValues(dashboardId, parameterId, options = {}) {
+		await transport.require("dashboard.parameterValues", options);
+		return transport.requestParsed(ParameterValues, `/api/dashboard/${dashboardId}/params/${encodeURIComponent(parameterId)}/values`, { ...options });
+	}
+	/**
+	* Search a dashboard parameter's selectable values: the server returns only values containing the
+	* substring, capped at the first 1000 matches.
+	*/
+	async function searchParameterValues(dashboardId, parameterId, query, options = {}) {
+		await transport.require("dashboard.searchParameterValues", options);
+		const parameter = encodeURIComponent(parameterId);
+		return transport.requestParsed(ParameterValues, `/api/dashboard/${dashboardId}/params/${parameter}/search/${encodeURIComponent(query)}`, { ...options });
+	}
+	return {
+		list,
+		get,
+		create,
+		update,
+		archive,
+		copy,
+		updateDashcard,
+		checkCardReferences,
+		parameterValues,
+		searchParameterValues
+	};
+}
+function collectCardReferences(dashcards) {
+	if (dashcards === void 0 || dashcards === null) return [];
+	const references = [];
+	dashcards.forEach((dashcard, index) => {
+		const parsed = PreflightDashcard.safeParse(dashcard);
+		if (!parsed.success) return;
+		const cardId = parsed.data.card_id;
+		if (typeof cardId === "number" && cardId > 0) references.push({
+			cardId,
+			path: `/dashcards/${index}/card_id`
+		});
+	});
+	return references;
+}
+function groupByCardId(references) {
+	const grouped = /* @__PURE__ */ new Map();
+	for (const reference of references) {
+		const existing = grouped.get(reference.cardId);
+		if (existing === void 0) grouped.set(reference.cardId, [reference]);
+		else existing.push(reference);
+	}
+	return grouped;
+}
+function stripEntityId(dashcard) {
+	const { entity_id: _entity_id, id, size_x, size_y, row, col, ...rest } = dashcard;
+	return {
+		...rest,
+		id,
+		size_x,
+		size_y,
+		row,
+		col
+	};
+}
+//#endregion
+//#region ../client/src/resources/database.ts
+const DatabaseApiList = z.object({
+	data: z.array(Database),
+	total: z.number().int().nonnegative()
+}).loose();
+const DatabaseTaskAck = z.object({ status: z.literal("ok") });
+const DatabaseApiSchemaList = z.array(z.string());
+const DatabaseApiSchemaTableList = z.array(Table);
+const SYNC_COMPLETE = "complete";
+function databaseResource(transport) {
+	/** List databases. `include` hydrates each database's tables; `saved` adds the Saved Questions virtual database. */
+	async function list(params = {}, options = {}) {
+		await transport.require("database.list", options);
+		const response = await transport.requestParsed(DatabaseApiList, "/api/database", {
+			...options,
+			query: {
+				include: params.include,
+				saved: params.saved
+			}
+		});
+		return {
+			data: response.data,
+			total: response.total
+		};
+	}
+	/** Get one database by id. `include` hydrates its tables, and `tables.fields` their fields too. */
+	async function get(id, params = {}, options = {}) {
+		await transport.require("database.get", options);
+		return transport.requestParsed(Database, `/api/database/${id}`, {
+			...options,
+			query: { include: params.include }
+		});
+	}
+	/** List the schema names in a database. */
+	async function schemas(id, options = {}) {
+		await transport.require("database.schemas", options);
+		return {
+			data: await transport.requestParsed(DatabaseApiSchemaList, `/api/database/${id}/schemas`, { ...options }),
+			total: null
+		};
+	}
+	/** List the tables one schema of a database holds. */
+	async function schemaTables(id, schema, options = {}) {
+		await transport.require("database.schemaTables", options);
+		return {
+			data: await transport.requestParsed(DatabaseApiSchemaTableList, `/api/database/${id}/schema/${encodeURIComponent(schema)}`, { ...options }),
+			total: null
+		};
+	}
+	/**
+	* Trigger a manual schema sync for a database. The endpoint queues the sync and returns at once;
+	* pass `wait` to poll the database until it reports its initial sync complete.
+	*/
+	async function syncSchema(id, params = {}, options = {}) {
+		await transport.require("database.syncSchema", options);
+		const ack = await transport.requestParsed(DatabaseTaskAck, `/api/database/${id}/sync_schema`, {
+			...options,
+			method: "POST"
+		});
+		const wait = params.wait;
+		if (wait === void 0) return {
+			id,
+			status: ack.status
+		};
+		const database = await pollUntil(async (signal) => transport.requestParsed(Database, `/api/database/${id}`, {
+			...options,
+			signal
+		}), (candidate) => candidate.initial_sync_status === SYNC_COMPLETE, wait);
+		return {
+			id,
+			status: ack.status,
+			initial_sync_status: database.initial_sync_status ?? null
+		};
+	}
+	/** Trigger a rescan of the cached field values across a database. */
+	async function rescanValues(id, options = {}) {
+		await transport.require("database.rescanValues", options);
+		return {
+			id,
+			status: (await transport.requestParsed(DatabaseTaskAck, `/api/database/${id}/rescan_values`, {
+				...options,
+				method: "POST"
+			})).status
+		};
+	}
+	return {
+		list,
+		get,
+		schemas,
+		schemaTables,
+		syncSchema,
+		rescanValues
+	};
+}
+//#endregion
+//#region ../client/src/resources/dataset.ts
+function datasetResource(transport) {
+	/**
+	* Run an ad-hoc query and return its result envelope. The body is a whole query — MBQL 5, legacy
+	* MBQL, or native — rather than a reference to a saved one, so nothing here is a card.
+	*/
+	async function query(body, options = {}) {
+		await transport.require("dataset.query", options);
+		return transport.requestParsed(CardQueryResult, "/api/dataset", {
+			...options,
+			method: "POST",
+			body
+		});
+	}
+	/**
+	* 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
+const DocumentApiList = z.object({ items: z.array(Document) }).loose();
+function documentResource(transport) {
+	/** Get existing documents. */
+	async function list(options = {}) {
+		await transport.require("document.list", options);
+		return {
+			data: (await transport.requestParsed(DocumentApiList, "/api/document", { ...options })).items,
+			total: null
+		};
+	}
+	/** Return an existing document by id. */
+	async function get(id, options = {}) {
+		await transport.require("document.get", options);
+		return transport.requestParsed(Document, `/api/document/${id}`, { ...options });
+	}
+	/** Create a new document. */
+	async function create(params, options = {}) {
+		await transport.require("document.create", options);
+		return transport.requestParsed(Document, "/api/document", {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	/** Update an existing document by id. */
+	async function update(id, params, options = {}) {
+		await transport.require("document.update", options);
+		return transport.requestParsed(Document, `/api/document/${id}`, {
+			...options,
+			method: "PUT",
+			body: params
+		});
+	}
+	/** Archive (soft-delete) a document by id. Metabase models this as an update, not its own endpoint. */
+	async function archive(id, options = {}) {
+		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,
+		copy
+	};
+}
+//#endregion
+//#region ../client/src/resources/eid-translation.ts
+function eidTranslationResource(transport) {
+	/**
+	* Translate entity ids to the numeric ids of the rows they name. The request groups the entity
+	* ids by model; the response is keyed by entity id, each entry carrying its model and — when the
+	* lookup succeeded — the numeric id.
+	*/
+	async function translate(params, options = {}) {
+		await transport.require("eidTranslation.translate", options);
+		return transport.requestParsed(EidTranslateResult, "/api/eid-translation/translate", {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	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) {
+	/** Get one field by id. */
+	async function get(id, options = {}) {
+		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. 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);
+		const [[, count], [, distincts]] = await transport.requestParsed(FieldApiSummary, `/api/field/${id}/summary`, { ...options });
+		return {
+			field_id: id,
+			count,
+			distincts
+		};
+	}
+	/** Get the cached distinct values Metabase holds for a field. */
+	async function values(id, options = {}) {
+		await transport.require("field.values", options);
+		return transport.requestParsed(FieldValues, `/api/field/${id}/values`, { ...options });
+	}
+	return {
+		get,
+		update,
+		search,
+		remapping,
+		summary,
+		values
+	};
+}
+//#endregion
+//#region ../client/src/resources/git-sync.ts
+const SyncScopeCollection = Collection.pick({
+	id: true,
+	name: true,
+	is_remote_synced: true
+}).strip();
+const SyncDirtyFlag = z.object({ is_dirty: z.boolean() });
+const SyncDirtyList = z.object({ dirty: z.array(SyncDirtyItem) });
+const SyncBranchList = z.object({ items: z.array(z.string()) });
+const SyncImportStarted = z.object({
+	status: z.literal("success"),
+	task_id: z.number().int().positive().nullable(),
+	message: z.string().nullable().optional()
+});
+const SyncExportStarted = z.object({
+	message: z.string(),
+	task_id: z.number().int().positive()
+});
+const SyncStashStarted = z.object({
+	status: z.literal("success"),
+	message: z.string(),
+	task_id: z.number().int().positive()
+});
+const RemoteSyncSetting = z.string().nullable();
+const FORBIDDEN_STATUS = 403;
+const UNREGISTERED_STATUS = 404;
+function isRemoteUnreadable(error) {
+	if (!(error instanceof HttpError)) return false;
+	return error.status === FORBIDDEN_STATUS || error.status === UNREGISTERED_STATUS;
+}
+function gitSyncResource(transport) {
+	/** Get the running or most recently finished sync task, or null when the server has none. */
+	async function currentTask(options = {}) {
+		await transport.require("gitSync.currentTask", options);
+		return fetchOptionalParsed(transport, "/api/ee/remote-sync/current-task", SyncTask, options);
+	}
+	/** Request cancellation of the running sync task, and answer it in the state that left it. */
+	async function cancelTask(options = {}) {
+		await transport.require("gitSync.cancelTask", options);
+		return transport.requestParsed(SyncTask, "/api/ee/remote-sync/current-task/cancel", {
+			...options,
+			method: "POST"
+		});
+	}
+	/** Whether Metabase holds content changes the remote has not been told about. */
+	async function isDirty(options = {}) {
+		await transport.require("gitSync.isDirty", options);
+		return (await transport.requestParsed(SyncDirtyFlag, "/api/ee/remote-sync/is-dirty", { ...options })).is_dirty;
+	}
+	/** List the objects whose local state differs from the remote. */
+	async function dirty(options = {}) {
+		await transport.require("gitSync.dirty", options);
+		return {
+			data: (await transport.requestParsed(SyncDirtyList, "/api/ee/remote-sync/dirty", { ...options })).dirty,
+			total: null
+		};
+	}
+	/**
+	* Compare the tracked remote branch against what Metabase last imported. The server caches the
+	* comparison; `force-refresh` re-reads the remote instead.
+	*/
+	async function hasRemoteChanges(params = {}, options = {}) {
+		await transport.require("gitSync.hasRemoteChanges", options);
+		return transport.requestParsed(SyncRemoteChanges, "/api/ee/remote-sync/has-remote-changes", {
+			...options,
+			query: { "force-refresh": params["force-refresh"] }
+		});
+	}
+	/**
+	* Import content from the remote into Metabase. The endpoint queues a task and returns at once;
+	* pass `wait` to poll that task until it reaches a terminal status. A server already up to date
+	* answers no task id, and there is then nothing to poll.
+	*/
+	async function importFromRemote(params = {}, options = {}) {
+		await transport.require("gitSync.import", options);
+		const started = await transport.requestParsed(SyncImportStarted, "/api/ee/remote-sync/import", {
+			...options,
+			method: "POST",
+			body: {
+				branch: params.branch,
+				force: params.force
+			}
+		});
+		const message = started.message ?? null;
+		if (params.wait === void 0 || started.task_id === null) return {
+			message,
+			task_id: started.task_id
+		};
+		return {
+			message,
+			task_id: started.task_id,
+			final: await settle(params.wait, options)
+		};
+	}
+	/**
+	* Export Metabase's content to the remote. The endpoint queues a task and returns at once; pass
+	* `wait` to poll that task until it reaches a terminal status.
+	*/
+	async function exportToRemote(params = {}, options = {}) {
+		await transport.require("gitSync.export", options);
+		const started = await transport.requestParsed(SyncExportStarted, "/api/ee/remote-sync/export", {
+			...options,
+			method: "POST",
+			body: {
+				branch: params.branch,
+				message: params.message,
+				force: params.force
+			}
+		});
+		if (params.wait === void 0) return {
+			message: started.message,
+			task_id: started.task_id
+		};
+		return {
+			message: started.message,
+			task_id: started.task_id,
+			final: await settle(params.wait, options)
+		};
+	}
+	/**
+	* 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.
+	*/
+	async function stash(params, options = {}) {
+		await transport.require("gitSync.stash", options);
+		const started = await transport.requestParsed(SyncStashStarted, "/api/ee/remote-sync/stash", {
+			...options,
+			method: "POST",
+			body: {
+				new_branch: params.new_branch,
+				message: params.message
+			}
+		});
+		if (params.wait === void 0) return {
+			status: started.status,
+			message: started.message,
+			task_id: started.task_id
+		};
+		return {
+			status: started.status,
+			message: started.message,
+			task_id: started.task_id,
+			final: await settle(params.wait, options)
+		};
+	}
+	/** List the branches the configured remote carries. */
+	async function branches(options = {}) {
+		await transport.require("gitSync.branches", options);
+		return {
+			data: (await transport.requestParsed(SyncBranchList, "/api/ee/remote-sync/branches", { ...options })).items,
+			total: null
+		};
+	}
+	/** Create a branch on the remote and point git-sync at it. */
+	async function createBranch(params, options = {}) {
+		await transport.require("gitSync.createBranch", options);
+		return transport.requestParsed(SyncBranchCreated, "/api/ee/remote-sync/create-branch", {
+			...options,
+			method: "POST",
+			body: { name: params.name }
+		});
+	}
+	/**
+	* Mark one collection as git-synced, or unmark it. The server cascades the flag to descendants
+	* by location prefix, and may queue an export task to carry the change to the remote.
+	*/
+	async function setCollectionSynced(collectionId, synced, options = {}) {
+		await transport.require("gitSync.setCollectionSynced", options);
+		return transport.requestParsed(SyncSettingsUpdateResult, "/api/ee/remote-sync/settings", {
+			...options,
+			method: "PUT",
+			body: { collections: { [collectionId]: synced } }
+		});
+	}
+	/** The collections currently in git-sync's scope. */
+	async function syncedCollections(options = {}) {
+		await transport.require("gitSync.syncedCollections", options);
+		return {
+			data: (await listCollectionsWithLibrary(transport, SyncScopeCollection, options)).filter((entry) => entry.is_remote_synced === true),
+			total: null
+		};
+	}
+	/** The remote's URL, or null when none is configured or the caller may not read it. */
+	async function remoteUrl(options = {}) {
+		await transport.require("gitSync.remoteUrl", options);
+		try {
+			const url = await fetchOptionalParsed(transport, "/api/setting/remote-sync-url", RemoteSyncSetting, options);
+			return url === "" ? null : url;
+		} catch (error) {
+			if (isRemoteUnreadable(error)) return null;
+			throw error;
+		}
+	}
+	/**
+	* 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);
+		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
+	* answers null, which is terminal in the same sense: nothing further will happen.
+	*/
+	async function waitForTask(wait, options = {}) {
+		await transport.require("gitSync.waitForTask", options);
+		return settle(wait, options);
+	}
+	async function settle(wait, options) {
+		return pollUntil(async (signal) => currentTask({
+			...options,
+			signal
+		}), (task) => task === null || isSyncTaskTerminal(task.status), wait);
+	}
+	return {
+		currentTask,
+		cancelTask,
+		isDirty,
+		dirty,
+		hasRemoteChanges,
+		import: importFromRemote,
+		export: exportToRemote,
+		exportPreflight,
+		stash,
+		branches,
+		createBranch,
+		setCollectionSynced,
+		syncedCollections,
+		remoteUrl,
+		branch,
+		waitForTask
+	};
+}
+//#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";
+const UNPUBLISH_TABLES_PATH = "/api/ee/data-studio/table/unpublish-tables";
+const LIBRARY_DATA_TYPE = "library-data";
+const PublishTablesResponse = z.object({ target_collection: Collection.nullable() });
+function libraryResource(transport) {
+	/** Get the Library root and its child collections, or `null` on an instance that has none. */
+	async function get(options = {}) {
+		await transport.require("library.get", options);
+		const { features } = await transport.server(options);
+		const wire = await transport.requestParsed(libraryWireSchema(features), LIBRARY_ROOT_PATH, { ...options });
+		if (wire === null) return null;
+		return toLibrary(wire, await libraryListing(options));
+	}
+	async function libraryListing(options) {
+		const data = await listCollectionsWithLibrary(transport, LibraryCollectionInfo, options);
+		const byId = /* @__PURE__ */ new Map();
+		for (const collection of data) if (typeof collection.id === "number") byId.set(collection.id, collection);
+		return byId;
+	}
+	/**
+	* Create the Library subtree (its Data and Metrics collections). Metabase takes no body, rejects
+	* a second create with a 400, and answers the bare root collection without its
+	* `effective_children` — so an existing Library short-circuits the call and a fresh one comes
+	* back from a refetch, which together make this idempotent.
+	*/
+	async function create(options = {}) {
+		await transport.require("library.create", options);
+		const existing = await get(options);
+		if (existing !== null) return existing;
+		await transport.requestRaw(LIBRARY_ROOT_PATH, {
+			...options,
+			method: "POST"
+		});
+		const created = await get(options);
+		if (created === null) throw new Error(`Library was not created after POST ${LIBRARY_ROOT_PATH}`);
+		return created;
+	}
+	/** The id of the Library's Data collection, creating the Library first when it does not exist. */
+	async function ensureDataCollectionId(options = {}) {
+		await transport.require("library.ensureDataCollectionId", options);
+		const data = (await create(options)).effective_children.find((child) => child.type === LIBRARY_DATA_TYPE);
+		if (data === void 0) throw new Error("Library has no Data collection to publish into");
+		if (typeof data.id !== "number") throw new Error(`Library Data collection has a non-numeric id ${String(data.id)}`);
+		return data.id;
+	}
+	/**
+	* Publish tables — and every upstream table they depend on — into a collection, so they lead the
+	* data pickers and rank up in search. Answers the collection they landed in.
+	*/
+	async function publishTables(params, options = {}) {
+		await transport.require("library.publishTables", options);
+		return (await transport.requestParsed(PublishTablesResponse, PUBLISH_TABLES_PATH, {
+			...options,
+			method: "POST",
+			body: params
+		})).target_collection;
+	}
+	/**
+	* Clear the Library collection from tables, and recursively from every downstream table that
+	* depends on them. The endpoint answers no JSON body.
+	*/
+	async function unpublishTables(params, options = {}) {
+		await transport.require("library.unpublishTables", options);
+		await transport.requestRaw(UNPUBLISH_TABLES_PATH, {
+			...options,
+			method: "POST",
+			body: params,
+			expectContentType: "binary"
+		});
+	}
+	return {
+		get,
+		create,
+		ensureDataCollectionId,
+		publishTables,
+		unpublishTables
+	};
+}
+//#endregion
+//#region ../client/src/resources/measure.ts
+const MeasureApiList = z.array(Measure);
+function measureResource(transport) {
+	/** List measures. */
+	async function list(options = {}) {
+		await transport.require("measure.list", options);
+		return {
+			data: await transport.requestParsed(MeasureApiList, "/api/measure", { ...options }),
+			total: null
+		};
+	}
+	/** Get one measure by id. */
+	async function get(id, options = {}) {
+		await transport.require("measure.get", options);
+		return transport.requestParsed(Measure, `/api/measure/${id}`, { ...options });
+	}
+	/** Create a measure — a saved aggregation tied to a table — from a full measure body. */
+	async function create(params, options = {}) {
+		await transport.require("measure.create", options);
+		return transport.requestParsed(Measure, "/api/measure", {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	/**
+	* Update a measure by id, patching only the fields the body carries. `revision_message` is
+	* required and lands in the audit log.
+	*/
+	async function update(id, params, options = {}) {
+		await transport.require("measure.update", options);
+		return transport.requestParsed(Measure, `/api/measure/${id}`, {
+			...options,
+			method: "PUT",
+			body: params
+		});
+	}
+	/**
+	* Archive (soft-delete) a measure by id. Metabase models this as an update, not its own endpoint,
+	* so it carries the same required `revision_message`.
+	*/
+	async function archive(id, params, options = {}) {
+		await transport.require("measure.archive", options);
+		return update(id, {
+			archived: true,
+			revision_message: params.revision_message
+		}, options);
+	}
+	return {
+		list,
+		get,
+		create,
+		update,
+		archive
+	};
+}
+//#endregion
+//#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.
+	*/
+	async function list(params = {}, options = {}) {
+		await transport.require("notification.list", options);
+		return {
+			data: await transport.requestParsed(NotificationApiList, "/api/notification", {
+				...options,
+				query: {
+					payload_type: CARD_PAYLOAD_TYPE,
+					card_id: params.card_id,
+					creator_id: params.creator_id,
+					recipient_id: params.recipient_id,
+					include_inactive: params.include_inactive
+				}
+			}),
+			total: null
+		};
+	}
+	/** Get one question alert by id, refusing an id that names a system-event notification. */
+	async function get(id, options = {}) {
+		await transport.require("notification.get", options);
+		return assertCardAlert(await transport.requestParsed(Notification, `/api/notification/${id}`, { ...options }));
+	}
+	/** Create a question alert — its card payload, schedules and handlers — from a full body. */
+	async function create(params, options = {}) {
+		await transport.require("notification.create", options);
+		return transport.requestParsed(Notification, "/api/notification", {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	/** Update a question alert by id, merging the patch over the stored notification. */
+	async function update(id, params, options = {}) {
+		await transport.require("notification.update", options);
+		const current = await get(id, options);
+		return transport.requestParsed(Notification, `/api/notification/${id}`, {
+			...options,
+			method: "PUT",
+			body: mergeAlertUpdate(current, params)
+		});
+	}
+	/** Archive a question alert by id, stopping every delivery. Metabase models this as an update. */
+	async function archive(id, options = {}) {
+		await transport.require("notification.archive", options);
+		return update(id, { active: false }, options);
+	}
+	/**
+	* Send a question alert now, off-schedule, to every handler on it. The server answers with no
+	* body.
+	*/
+	async function send(id, options = {}) {
+		await transport.require("notification.send", options);
+		await get(id, options);
+		await transport.requestRaw(`/api/notification/${id}/send`, {
+			...options,
+			method: "POST",
+			expectContentType: "binary"
+		});
+	}
+	return {
+		list,
+		get,
+		create,
+		update,
+		archive,
+		send
+	};
+}
+//#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) {
+	return {
+		...patch,
+		archived: patch.archived ?? current.archived,
+		skip_if_empty: patch.skip_if_empty ?? current.skip_if_empty
+	};
+}
+function pulseResource(transport) {
+	/** List dashboard subscriptions, optionally narrowed to one dashboard or to the archived ones. */
+	async function list(params = {}, options = {}) {
+		await transport.require("pulse.list", options);
+		return {
+			data: await transport.requestParsed(PulseApiList, "/api/pulse", {
+				...options,
+				query: {
+					dashboard_id: params.dashboard_id,
+					archived: params.archived
+				}
+			}),
+			total: null
+		};
+	}
+	/** Get one dashboard subscription by id. */
+	async function get(id, options = {}) {
+		await transport.require("pulse.get", options);
+		return transport.requestParsed(Pulse, `/api/pulse/${id}`, { ...options });
+	}
+	/** Create a dashboard subscription — its cards and its delivery channels — from a full body. */
+	async function create(params, options = {}) {
+		await transport.require("pulse.create", options);
+		return transport.requestParsed(Pulse, "/api/pulse", {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	/** Update a dashboard subscription by id, carrying the server-defaulted flags forward. */
+	async function update(id, params, options = {}) {
+		await transport.require("pulse.update", options);
+		const current = await get(id, options);
+		return transport.requestParsed(Pulse, `/api/pulse/${id}`, {
+			...options,
+			method: "PUT",
+			body: mergePulseUpdate(current, params)
+		});
+	}
+	/**
+	* Archive a dashboard subscription by id, stopping every delivery. Metabase models this as an
+	* update, and disables each of the subscription's channels as a side effect.
+	*/
+	async function archive(id, options = {}) {
+		await transport.require("pulse.archive", options);
+		return update(id, { archived: true }, options);
+	}
+	return {
+		list,
+		get,
+		create,
+		update,
+		archive
+	};
+}
+//#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),
+	total: z.number().int().nonnegative()
+}).loose();
+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, `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);
+		const response = await transport.requestParsed(SearchApiResponse, "/api/search", {
+			...options,
+			query: {
+				q: params.q,
+				models: params.models,
+				archived: params.archived,
+				limit: params.limit,
+				offset: params.offset,
+				table_db_id: params.table_db_id,
+				verified: params.verified,
+				collection: params.collection,
+				created_by: params.created_by,
+				search_native_query: params.search_native_query,
+				include_metadata: params.include_metadata
+			}
+		});
+		return {
+			data: response.data,
+			total: response.total
+		};
+	}
+	return { query };
+}
+//#endregion
+//#region ../client/src/resources/segment.ts
+const SegmentApiList = z.array(Segment);
+function segmentResource(transport) {
+	/** List every segment the caller can see. */
+	async function list(options = {}) {
+		await transport.require("segment.list", options);
+		return {
+			data: await transport.requestParsed(SegmentApiList, "/api/segment", { ...options }),
+			total: null
+		};
+	}
+	/** Get one segment by id. */
+	async function get(id, options = {}) {
+		await transport.require("segment.get", options);
+		return transport.requestParsed(Segment, `/api/segment/${id}`, { ...options });
+	}
+	/** Create a segment — a reusable row filter over one table — from a full segment body. */
+	async function create(params, options = {}) {
+		await transport.require("segment.create", options);
+		return transport.requestParsed(Segment, "/api/segment", {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	/**
+	* Update a segment by id, patching only the fields the body carries. `revision_message` is
+	* required: Metabase records every segment change in its revision history.
+	*/
+	async function update(id, params, options = {}) {
+		await transport.require("segment.update", options);
+		return transport.requestParsed(Segment, `/api/segment/${id}`, {
+			...options,
+			method: "PUT",
+			body: params
+		});
+	}
+	/**
+	* Archive (soft-delete) a segment by id. Metabase models this as an update, so it carries the
+	* same required `revision_message`.
+	*/
+	async function archive(id, params, options = {}) {
+		await transport.require("segment.archive", options);
+		return update(id, {
+			archived: true,
+			revision_message: params.revision_message
+		}, options);
+	}
+	return {
+		list,
+		get,
+		create,
+		update,
+		archive
+	};
+}
+//#endregion
+//#region ../client/src/resources/setting.ts
+const SettingApiList = z.array(Setting);
+const UNKNOWN_SETTING_PREFIX = "Unknown setting:";
+function rethrowSettingError(error, key) {
+	if (errorMessage(error).startsWith(UNKNOWN_SETTING_PREFIX)) throw new ConfigError(`unknown setting: ${key}`);
+	throw error;
+}
+function settingResource(transport) {
+	/** Get all settings and their values, with descriptions and environment-variable names. */
+	async function list(options = {}) {
+		await transport.require("setting.list", options);
+		return {
+			data: await transport.requestParsed(SettingApiList, "/api/setting", { ...options }),
+			total: null
+		};
+	}
+	/**
+	* Fetch a single setting's value by key. An unset setting answers 204 rather than 404, which
+	* reaches the caller as `null`; a string-typed setting answers bare text rather than JSON.
+	*/
+	async function get(key, options = {}) {
+		await transport.require("setting.get", options);
+		return fetchOptionalParsed(transport, `/api/setting/${encodeURIComponent(key)}`, z.unknown(), options).catch((error) => rethrowSettingError(error, key));
+	}
+	/** Set a single setting's value by key. The endpoint answers 204 with no body. */
+	async function set(key, value, options = {}) {
+		await transport.require("setting.set", options);
+		await transport.requestRaw(`/api/setting/${encodeURIComponent(key)}`, {
+			...options,
+			method: "PUT",
+			body: { value },
+			expectContentType: "binary"
+		}).catch((error) => rethrowSettingError(error, key));
+	}
+	return {
+		list,
+		get,
+		set
+	};
+}
+//#endregion
+//#region ../client/src/resources/setup.ts
+function setupResource(transport) {
+	/**
+	* Complete the initial setup wizard on a fresh instance, creating its first admin user and
+	* applying the instance preferences. The setup token is single-use.
+	*/
+	async function create(params, options = {}) {
+		await transport.require("setup.create", options);
+		return transport.requestParsed(SetupResult, "/api/setup", {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	return { create };
+}
+//#endregion
+//#region ../client/src/resources/snippet.ts
+const SnippetApiList = z.array(Snippet);
+function snippetResource(transport) {
+	/** List native query snippets. `archived` swaps the listing to archived snippets. */
+	async function list(params = {}, options = {}) {
+		await transport.require("snippet.list", options);
+		return {
+			data: await transport.requestParsed(SnippetApiList, "/api/native-query-snippet", {
+				...options,
+				query: { archived: params.archived }
+			}),
+			total: null
+		};
+	}
+	/** Get one native query snippet by id. */
+	async function get(id, options = {}) {
+		await transport.require("snippet.get", options);
+		return transport.requestParsed(Snippet, `/api/native-query-snippet/${id}`, { ...options });
+	}
+	/** Create a native query snippet from a name, its SQL fragment, and an optional collection. */
+	async function create(params, options = {}) {
+		await transport.require("snippet.create", options);
+		return transport.requestParsed(Snippet, "/api/native-query-snippet", {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	/** Update a native query snippet by id, patching only the fields the body carries. */
+	async function update(id, params, options = {}) {
+		await transport.require("snippet.update", options);
+		return transport.requestParsed(Snippet, `/api/native-query-snippet/${id}`, {
+			...options,
+			method: "PUT",
+			body: params
+		});
+	}
+	/**
+	* Archive (soft-delete) a native query snippet by id. Metabase models this as an update, not its
+	* own endpoint.
+	*/
+	async function archive(id, options = {}) {
+		await transport.require("snippet.archive", options);
+		return update(id, { archived: true }, options);
+	}
+	return {
+		list,
+		get,
+		create,
+		update,
+		archive
+	};
+}
+//#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. `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,
+				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
+		};
+	}
+	/** Get one table by id, without its fields. */
+	async function get(id, options = {}) {
+		await transport.require("table.get", options);
+		return transport.requestParsed(Table, `/api/table/${id}`, { ...options });
+	}
+	/** 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,
+			method: "POST",
+			body: buildCsvFormData(file),
+			expectContentType: "binary"
+		});
+		return {
+			table_id: id,
+			action
+		};
+	}
+	/**
+	* Inserts the rows of an uploaded CSV file into the table identified by `id`. The table must have
+	* been created by uploading a CSV file.
+	*
+	* The file may be at most 50 MB; larger uploads are rejected with a 413 response.
+	*/
+	async function appendCsv(id, file, options = {}) {
+		await transport.require("table.appendCsv", options);
+		return updateFromCsv(id, "append", file, options);
+	}
+	/**
+	* Replaces the contents of the table identified by `id` with the rows of an uploaded CSV file.
+	* The table must have been created by uploading a CSV file.
+	*
+	* The file may be at most 50 MB; larger uploads are rejected with a 413 response.
+	*/
+	async function replaceCsv(id, file, options = {}) {
+		await transport.require("table.replaceCsv", options);
+		return updateFromCsv(id, "replace", file, options);
+	}
+	return {
+		list,
+		get,
+		update,
+		queryMetadata,
+		fks,
+		syncSchema,
+		rescanValues,
+		bulkEdit,
+		appendCsv,
+		replaceCsv
+	};
+}
+//#endregion
+//#region ../client/src/resources/timeline-event.ts
+function timelineEventResource(transport) {
+	/** Get one timeline event by id. */
+	async function get(id, options = {}) {
+		await transport.require("timelineEvent.get", options);
+		return transport.requestParsed(TimelineEvent, `/api/timeline-event/${id}`, { ...options });
+	}
+	/** Create a timeline event on an existing timeline. */
+	async function create(params, options = {}) {
+		await transport.require("timelineEvent.create", options);
+		return transport.requestParsed(TimelineEvent, "/api/timeline-event", {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	/**
+	* Update a timeline event by id, patching only the fields the body carries. `timeline_id` moves
+	* the event to another timeline.
+	*/
+	async function update(id, params, options = {}) {
+		await transport.require("timelineEvent.update", options);
+		return transport.requestParsed(TimelineEvent, `/api/timeline-event/${id}`, {
+			...options,
+			method: "PUT",
+			body: params
+		});
+	}
+	/**
+	* Archive (soft-delete) a timeline event by id. Metabase models this as an update, not its own
+	* endpoint.
+	*/
+	async function archive(id, options = {}) {
+		await transport.require("timelineEvent.archive", options);
+		return update(id, { archived: true }, options);
+	}
+	/** Permanently delete a timeline event by id. The server answers with no body. */
+	async function remove(id, options = {}) {
+		await transport.require("timelineEvent.delete", options);
+		await transport.requestRaw(`/api/timeline-event/${id}`, {
+			...options,
+			method: "DELETE",
+			expectContentType: "binary"
+		});
+	}
+	return {
+		get,
+		create,
+		update,
+		archive,
+		delete: remove
+	};
+}
+//#endregion
+//#region ../client/src/resources/timeline.ts
+const TimelineApiList = z.array(Timeline);
+const TimelineWithEvents = Timeline.required({ events: true });
+function timelineResource(transport) {
+	/** List timelines. `archived` swaps the active listing for the archived one. */
+	async function list(params = {}, options = {}) {
+		await transport.require("timeline.list", options);
+		return {
+			data: await transport.requestParsed(TimelineApiList, "/api/timeline", {
+				...options,
+				query: { archived: params.archived }
+			}),
+			total: null
+		};
+	}
+	/** Get one timeline by id, without its events. */
+	async function get(id, options = {}) {
+		await transport.require("timeline.get", options);
+		return transport.requestParsed(Timeline, `/api/timeline/${id}`, { ...options });
+	}
+	/**
+	* List the events on one timeline. Metabase has no endpoint of its own for these: the same
+	* timeline read hydrates them on request, and `archived` chooses which of them come back.
+	*/
+	async function events(id, params = {}, options = {}) {
+		await transport.require("timeline.events", options);
+		return {
+			data: (await transport.requestParsed(TimelineWithEvents, `/api/timeline/${id}`, {
+				...options,
+				query: {
+					include: "events",
+					archived: params.archived
+				}
+			})).events,
+			total: null
+		};
+	}
+	/** Create a timeline from a full timeline body. */
+	async function create(params, options = {}) {
+		await transport.require("timeline.create", options);
+		return transport.requestParsed(Timeline, "/api/timeline", {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	/**
+	* Update a timeline by id, patching only the fields the body carries. Changing `archived`
+	* cascades to every event on the timeline.
+	*/
+	async function update(id, params, options = {}) {
+		await transport.require("timeline.update", options);
+		return transport.requestParsed(Timeline, `/api/timeline/${id}`, {
+			...options,
+			method: "PUT",
+			body: params
+		});
+	}
+	/**
+	* Archive (soft-delete) a timeline and all its events by id. Metabase models this as an update,
+	* not its own endpoint.
+	*/
+	async function archive(id, options = {}) {
+		await transport.require("timeline.archive", options);
+		return update(id, { archived: true }, options);
+	}
+	/** Permanently delete a timeline and all its events by id. The server answers with no body. */
+	async function remove(id, options = {}) {
+		await transport.require("timeline.delete", options);
+		await transport.requestRaw(`/api/timeline/${id}`, {
+			...options,
+			method: "DELETE",
+			expectContentType: "binary"
+		});
+	}
+	return {
+		list,
+		get,
+		events,
+		create,
+		update,
+		archive,
+		delete: remove
+	};
+}
+//#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. */
+	async function list(options = {}) {
+		await transport.require("transformJob.list", options);
+		const { features } = await transport.server(options);
+		return {
+			data: await transport.requestParsed(z.array(transformJobSchema(features)), "/api/transform-job", { ...options }),
+			total: null
+		};
+	}
+	/** Get one transform job by id. */
+	async function get(id, options = {}) {
+		await transport.require("transformJob.get", options);
+		const { features } = await transport.server(options);
+		return transport.requestParsed(transformJobSchema(features), `/api/transform-job/${id}`, { ...options });
+	}
+	/** Create a transform job — a schedule plus the tags it runs — from a full body. */
+	async function create(params, options = {}) {
+		await transport.require("transformJob.create", options);
+		const { features } = await transport.server(options);
+		return transport.requestParsed(transformJobSchema(features), "/api/transform-job", {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	/** Update a transform job by id, patching only the fields the body carries. */
+	async function update(id, params, options = {}) {
+		await transport.require("transformJob.update", options);
+		const { features } = await transport.server(options);
+		return transport.requestParsed(transformJobSchema(features), `/api/transform-job/${id}`, {
+			...options,
+			method: "PUT",
+			body: params
+		});
+	}
+	/** Delete a transform job by id, leaving the transforms it ran untouched. */
+	async function remove(id, options = {}) {
+		await transport.require("transformJob.delete", options);
+		await transport.requestRaw(`/api/transform-job/${id}`, {
+			...options,
+			method: "DELETE",
+			expectContentType: "binary"
+		});
+	}
+	/**
+	* Start a run of a transform job by id. The job runs every transform carrying one of its tags,
+	* plus those transforms' dependencies; `run_all` re-runs dependencies that are already fresh.
+	*/
+	async function run(id, params = {}, options = {}) {
+		await transport.require("transformJob.run", options);
+		const { features } = await transport.server(options);
+		return transport.requestParsed(transformJobRunResultSchema(features), `/api/transform-job/${id}/run`, {
+			...options,
+			method: "POST",
+			body: { run_all: params.run_all }
+		});
+	}
+	/** List the transforms a job would execute, resolved from the job's tags. */
+	async function transforms(id, options = {}) {
+		await transport.require("transformJob.transforms", options);
+		const { features } = await transport.server(options);
+		return {
+			data: await transport.requestParsed(z.array(transformRowSchema(features)), `/api/transform-job/${id}/transforms`, { ...options }),
+			total: null
+		};
+	}
+	/**
+	* Flip the active flag on every transform job at once. Inactive jobs do not run on schedule;
+	* manual runs ignore the flag. The path carries no id and is a different endpoint from `update`.
+	*/
+	async function setActive(active, options = {}) {
+		await transport.require("transformJob.setActive", options);
+		return transport.requestParsed(TransformJobActiveResult, "/api/transform-job/active", {
+			...options,
+			method: "PUT",
+			body: { active }
+		});
+	}
+	return {
+		list,
+		get,
+		create,
+		update,
+		delete: remove,
+		run,
+		transforms,
+		setActive
+	};
+}
+//#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));
+}
+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);
+		return {
+			data: await transport.requestParsed(transformListSchema(features), path, opts),
+			total: null
+		};
+	}
+	async function requestTransform(path, opts) {
+		const { features } = await transport.server(opts);
+		return transport.requestParsed(transformRowSchema(features), path, opts);
+	}
+	/** List every transform the caller can see. */
+	async function list(options = {}) {
+		await transport.require("transform.list", options);
+		return requestTransformList("/api/transform", { ...options });
+	}
+	/** Get one transform by id. */
+	async function get(id, options = {}) {
+		await transport.require("transform.get", options);
+		const { features } = await transport.server(options);
+		return transport.requestParsed(transformDetailSchema(features), `/api/transform/${id}`, { ...options });
+	}
+	/** Create a transform — a query plus the warehouse table it writes — from a full body. */
+	async function create(params, options = {}) {
+		await transport.require("transform.create", options);
+		return requestTransform("/api/transform", {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	/** Update a transform by id, patching only the fields the body carries. */
+	async function update(id, params, options = {}) {
+		await transport.require("transform.update", options);
+		return requestTransform(`/api/transform/${id}`, {
+			...options,
+			method: "PUT",
+			body: params
+		});
+	}
+	/** Delete a transform by id, leaving any table it already materialized in place. */
+	async function remove(id, options = {}) {
+		await transport.require("transform.delete", options);
+		await transport.requestRaw(`/api/transform/${id}`, {
+			...options,
+			method: "DELETE",
+			expectContentType: "binary"
+		});
+	}
+	/** Drop a transform's materialized output table, keeping the transform definition. */
+	async function deleteTable(id, options = {}) {
+		await transport.require("transform.deleteTable", options);
+		await transport.requestRaw(`/api/transform/${id}/table`, {
+			...options,
+			method: "DELETE",
+			expectContentType: "binary"
+		});
+	}
+	/** List the upstream transforms a transform depends on. */
+	async function dependencies(id, options = {}) {
+		await transport.require("transform.dependencies", options);
+		return requestTransformList(`/api/transform/${id}/dependencies`, { ...options });
+	}
+	/** Request cancellation of a transform's current run. */
+	async function cancel(id, options = {}) {
+		await transport.require("transform.cancel", options);
+		await transport.requestRaw(`/api/transform/${id}/cancel`, {
+			...options,
+			method: "POST",
+			expectContentType: "binary"
+		});
+	}
+	/** Get one transform run by run id — not by the id of the transform that produced it. */
+	async function getRun(runId, options = {}) {
+		await transport.require("transform.getRun", options);
+		return transport.requestParsed(TransformRun, `/api/transform/run/${runId}`, { ...options });
+	}
+	/** Walk the run history, newest first, optionally narrowed to a single transform. */
+	async function* runPages(params = {}, options = {}) {
+		await transport.require("transform.runPages", options);
+		yield* paginatePages(transport, "/api/transform/run", TransformRun, {
+			query: { "transform-ids": params["transform-ids"] },
+			...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 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.
+	*/
+	async function run(id, params = {}, options = {}) {
+		await transport.require("transform.run", options);
+		const kickoff = await transport.requestParsed(TransformRunKickoff, `/api/transform/${id}/run`, {
+			...options,
+			method: "POST"
+		});
+		const schedule = params.syncTarget === true ? params.wait ?? {} : params.wait;
+		if (schedule === void 0 || kickoff.run_id === null) return {
+			message: kickoff.message,
+			run_id: kickoff.run_id,
+			final: null
+		};
+		const runId = kickoff.run_id;
+		const final = await pollUntil(async (signal) => getRun(runId, {
+			...options,
+			signal
+		}), (candidate) => isTransformRunTerminal(candidate.status), schedule);
+		if (params.syncTarget !== true) return {
+			message: kickoff.message,
+			run_id: runId,
+			final
+		};
+		const targetTableId = isTransformRunFailed(final.status) ? null : await awaitTargetTableId(id, schedule, options);
+		return {
+			message: kickoff.message,
+			run_id: runId,
+			final,
+			target_table_id: targetTableId
+		};
+	}
+	async function awaitTargetTableId(id, wait, options) {
+		try {
+			return (await pollUntil(async (signal) => get(id, {
+				...options,
+				signal
+			}), (transform) => transform.target_table_id !== null, wait)).target_table_id;
+		} catch (error) {
+			if (error instanceof TimeoutError) return null;
+			throw error;
+		}
+	}
+	return {
+		list,
+		get,
+		create,
+		update,
+		delete: remove,
+		deleteTable,
+		dependencies,
+		cancel,
+		getRun,
+		runPages,
+		runSummaryPages,
+		resetCheckpoint,
+		runDag,
+		dagTransforms,
+		run
+	};
+}
+//#endregion
+//#region ../client/src/resources/transform-tag.ts
+const TransformTagApiList = z.array(TransformTag);
+function transformTagResource(transport) {
+	/** List every transform tag the caller can see, built-in tags included. */
+	async function list(options = {}) {
+		await transport.require("transformTag.list", options);
+		return {
+			data: await transport.requestParsed(TransformTagApiList, "/api/transform-tag", { ...options }),
+			total: null
+		};
+	}
+	/** Create a transform tag, the label a transform job matches transforms on. */
+	async function create(params, options = {}) {
+		await transport.require("transformTag.create", options);
+		return transport.requestParsed(TransformTag, "/api/transform-tag", {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	/** Rename a transform tag by id. */
+	async function update(id, params, options = {}) {
+		await transport.require("transformTag.update", options);
+		return transport.requestParsed(TransformTag, `/api/transform-tag/${id}`, {
+			...options,
+			method: "PUT",
+			body: params
+		});
+	}
+	/** Delete a transform tag by id, detaching it from every transform and job carrying it. */
+	async function remove(id, options = {}) {
+		await transport.require("transformTag.delete", options);
+		await transport.requestRaw(`/api/transform-tag/${id}`, {
+			...options,
+			method: "DELETE",
+			expectContentType: "binary"
+		});
+	}
+	return {
+		list,
+		create,
+		update,
+		delete: remove
+	};
+}
+//#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) {
+	/**
+	* Create a table and model populated with the values from the attached CSV. Returns the model ID
+	* if successful.
+	*
+	* The file may be at most 50 MB; larger uploads are rejected with a 413 response.
+	*/
+	async function createFromCsv(file, params, options = {}) {
+		await transport.require("upload.createFromCsv", options);
+		const form = buildCsvFormData(file);
+		form.append("collection_id", params.collection_id);
+		const response = await transport.requestRaw("/api/upload/csv", {
+			...options,
+			method: "POST",
+			body: form,
+			expectContentType: "binary"
+		});
+		return parseCreateUploadResult(await response.text(), response.headers);
+	}
+	return { createFromCsv };
+}
+function parseCreateUploadResult(bodyText, headers) {
+	return UploadResult.parse({
+		model_id: parseResponseInteger(bodyText, "response body"),
+		table_id: parseResponseInteger(headers.get(UPLOAD_TABLE_ID_HEADER), `${UPLOAD_TABLE_ID_HEADER} header`)
+	});
+}
+function parseResponseInteger(value, source) {
+	const trimmed = value?.trim() ?? "";
+	if (trimmed === "") throw new ResponseShapeError(`upload succeeded but the ${source} was empty`, {
+		kind: "decoded",
+		source,
+		value
+	});
+	const parsed = Number(trimmed);
+	if (!Number.isInteger(parsed)) throw new ResponseShapeError(`upload succeeded but the ${source} was not an integer: ${JSON.stringify(trimmed)}`, {
+		kind: "decoded",
+		source,
+		value
+	});
+	return parsed;
+}
+//#endregion
+//#region ../client/src/domain/user.ts
+const CurrentUser = z.object({
+	id: z.number().int(),
+	email: z.email(),
+	common_name: z.string(),
+	is_superuser: z.boolean()
+}).loose();
+CurrentUser.pick({
+	id: true,
+	email: true,
+	common_name: true,
+	is_superuser: true
+}).strip();
+//#endregion
+//#region ../client/src/resources/user.ts
+function userResource(transport) {
+	/** Get the user the request's credentials authenticate as. */
+	async function current(options = {}) {
+		await transport.require("user.current", options);
+		return transport.requestParsed(CurrentUser, "/api/user/current", { ...options });
+	}
+	return { current };
+}
+//#endregion
+//#region ../client/src/client.ts
+var client_exports = /* @__PURE__ */ __exportAll({ createClient: () => createClient });
+function createClient(config, options) {
+	const transport = createTransport(config, options);
+	return {
+		card: cardResource(transport),
+		collection: collectionResource(transport),
+		contentTranslation: contentTranslationResource(transport),
+		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),
+		setup: setupResource(transport),
+		snippet: snippetResource(transport),
+		table: tableResource(transport),
+		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,
+		requestParsed: transport.requestParsed,
+		requestRaw: transport.requestRaw,
+		requestStream: transport.requestStream
+	};
+}
+//#endregion
+export { createClient as n, client_exports as t };