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

package/dist/client-BqhzKdLM.mjs

@@ -1,2194 +0,0 @@
-import { a as InternalError, c as ResponseShapeError, d as ValidationError, f as errorMessage, i as ConfigError, l as TimeoutError, s as NetworkError } from "./predicates-Bkm2IoeX.mjs";
-import { n as Notification, r as NotificationCardPayload, t as CARD_PAYLOAD_TYPE } from "./notification-DaA4bBHW.mjs";
-import { a as isRetryableStatus, c as normalizeUrl, d as credentialSecrets, g as parseJsonOrPlain, h as parseJson, l as assertCredentialHeaderSafe, m as JSON_CONTENT_TYPE, n as isConnectionClosed, r as HttpError, t as buildNetworkError, u as credentialAuthHeader } from "./network-error-CEb9ymDW.mjs";
-import { n as throwIfAborted, t as combineAborts } from "./signal-CMd0EFUa.mjs";
-import { s as FieldValues, t as Field } from "./field-Cr2DPUG9.mjs";
-import { r as ParameterValues } from "./parameter-DUKR8NXo.mjs";
-import { o as CardQueryResult, t as Card } from "./card-DZxRmver.mjs";
-import { f as CollectionTreeNode, o as CollectionItem, r as Collection } from "./collection-CfulNRBG.mjs";
-import { i as DashboardDetail, s as Dashcard, t as Dashboard } from "./dashboard-BCpSq_G-.mjs";
-import { i as TableQueryMetadata, t as Table } from "./table-CeeTJgQb.mjs";
-import { t as Database } from "./database-C8G6ZKG0.mjs";
-import { r as pollUntil } from "./poll-75SvT7Zv.mjs";
-import { t as Document } from "./document-Cd2mmqCp.mjs";
-import { i as EidTranslateResult } from "./eid-translation-zEHtr5Oc.mjs";
-import { f as isSyncTaskTerminal, l as SyncTask, n as SyncDirtyItem, o as SyncRemoteChanges, s as SyncSettingsUpdateResult, t as SyncBranchCreated } from "./git-sync-BDnxPrqU.mjs";
-import { t as Library } from "./library-ClLgrAXy.mjs";
-import { t as Measure } from "./measure-CtfjqJFP.mjs";
-import { t as Pulse } from "./pulse-BmsDenXm.mjs";
-import { r as SearchResult } from "./search-DFBwUc6d.mjs";
-import { t as Segment } from "./segment-OsrbUDzw.mjs";
-import { t as Setting } from "./setting-DTiLCW8g.mjs";
-import { n as SetupResult } from "./setup-CO7QV-ao.mjs";
-import { t as Snippet } from "./snippet-CyKAgIZl.mjs";
-import { i as TimelineEvent, t as Timeline } from "./timeline-CCSU2qOS.mjs";
-import { i as TransformRun, l as isTransformRunFailed, t as Transform, u as isTransformRunTerminal } from "./transform-D3QX0jxA.mjs";
-import { a as TransformJobRunResult, n as TransformJobActiveResult, t as TransformJob } from "./transform-job-DRrK28IH.mjs";
-import { t as TransformTag } from "./transform-tag-CcElGp3C.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
-const NO_SERVER_TAG = async () => null;
-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()
-		});
-		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);
-	const getServerTag = options.getServerTag ?? NO_SERVER_TAG;
-	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)
-		};
-	}
-	return {
-		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
-			});
-		},
-		async requestStream(path, opts) {
-			const { response, prepared } = await executeWithAuthRefresh(path, {
-				...opts,
-				expectContentType: opts?.expectContentType ?? "binary"
-			});
-			if (!response.body) throw new NetworkError("Response had no body to stream", {
-				method: prepared.method,
-				url: prepared.url,
-				cause: "missing body"
-			});
-			return response.body;
-		}
-	};
-}
-function buildUrl(baseUrl, path, query) {
-	const normalizedPath = path.startsWith("/") ? path : `/${path}`;
-	const target = new URL(baseUrl + normalizedPath);
-	if (query) for (const [key, value] of Object.entries(query)) {
-		if (value === void 0) continue;
-		if (Array.isArray(value)) for (const entry of value) target.searchParams.append(key, String(entry));
-		else target.searchParams.append(key, String(value));
-	}
-	return target.toString();
-}
-function acceptHeader(expected) {
-	if (expected === "json") return JSON_CONTENT_TYPE;
-	if (expected === "text") return "text/*";
-	return "*/*";
-}
-function assertContentType(response, prepared) {
-	if (prepared.expectContentType === "binary") return;
-	const contentType = response.headers.get("content-type");
-	if (contentType === null) throwContentTypeMismatch(response, prepared, prepared.expectContentType);
-	if (prepared.expectContentType === "json" && !contentType.includes("application/json")) throwContentTypeMismatch(response, prepared, "json");
-	if (prepared.expectContentType === "text" && !contentType.startsWith(TEXT_CONTENT_TYPE_PREFIX)) throwContentTypeMismatch(response, prepared, "text");
-}
-function throwContentTypeMismatch(response, prepared, expected) {
-	const actual = response.headers.get("content-type") ?? "no content-type";
-	throw new HttpError({
-		status: response.status,
-		statusText: response.statusText,
-		method: prepared.method,
-		url: prepared.url,
-		responseHeaders: response.headers,
-		rawBody: null,
-		overrideUserMessage: `Expected ${expected} response but got ${actual}`
-	});
-}
-async function readBodyForError(response) {
-	try {
-		return Buffer.from(await response.arrayBuffer()).subarray(0, ERROR_BODY_BYTE_CAP).toString("utf8");
-	} catch (error) {
-		return `[body read failed: ${errorMessage(error)}]`;
-	}
-}
-//#endregion
-//#region ../client/src/resources/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 = {}) {
-		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 = {}) {
-		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 = {}) {
-		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 = {}) {
-		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 = {}) {
-		return update(id, { archived: true }, options);
-	}
-	/** Run a saved card and return the query result envelope. */
-	async function query(id, params, 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 = {}) {
-		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
-		});
-	}
-	return {
-		list,
-		get,
-		create,
-		update,
-		archive,
-		query,
-		exportQuery
-	};
-}
-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 = {}) {
-		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 = {}) {
-		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 = {}) {
-		return transport.requestParsed(Collection, `/api/collection/${refPath(ref)}`, { ...options });
-	}
-	/** Create a new collection. */
-	async function create(params, 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 = {}) {
-		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 = {}) {
-		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.
-	*/
-	function itemPages(ref, params = {}, options = {}) {
-		return 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 = {}) {
-		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/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 = {}) {
-		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 = {}) {
-		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 = {}) {
-		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 = {}) {
-		return transport.requestParsed(DashboardDetail, `/api/dashboard/${id}`, {
-			...options,
-			method: "PUT",
-			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 = {}) {
-		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 = {}) {
-		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 = {}) {
-		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 = {}) {
-		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 = {}) {
-		const parameter = encodeURIComponent(parameterId);
-		return transport.requestParsed(ParameterValues, `/api/dashboard/${dashboardId}/params/${parameter}/search/${encodeURIComponent(query)}`, { ...options });
-	}
-	return {
-		list,
-		get,
-		create,
-		update,
-		archive,
-		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 = {}) {
-		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 = {}) {
-		return transport.requestParsed(Database, `/api/database/${id}`, {
-			...options,
-			query: { include: params.include }
-		});
-	}
-	/** List the schema names in a database. */
-	async function schemas(id, 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 = {}) {
-		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 = {}) {
-		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 = {}) {
-		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 = {}) {
-		return transport.requestParsed(CardQueryResult, "/api/dataset", {
-			...options,
-			method: "POST",
-			body
-		});
-	}
-	return { query };
-}
-//#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 = {}) {
-		return {
-			data: (await transport.requestParsed(DocumentApiList, "/api/document", { ...options })).items,
-			total: null
-		};
-	}
-	/** Return an existing document by id. */
-	async function get(id, options = {}) {
-		return transport.requestParsed(Document, `/api/document/${id}`, { ...options });
-	}
-	/** Create a new document. */
-	async function create(params, options = {}) {
-		return transport.requestParsed(Document, "/api/document", {
-			...options,
-			method: "POST",
-			body: params
-		});
-	}
-	/** Update an existing document by id. */
-	async function update(id, params, 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 = {}) {
-		return update(id, { archived: true }, options);
-	}
-	return {
-		list,
-		get,
-		create,
-		update,
-		archive
-	};
-}
-//#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 = {}) {
-		return transport.requestParsed(EidTranslateResult, "/api/eid-translation/translate", {
-			...options,
-			method: "POST",
-			body: params
-		});
-	}
-	return { translate };
-}
-//#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 = {}) {
-		return transport.requestParsed(Field, `/api/field/${id}`, { ...options });
-	}
-	/** Update a field by id, patching only the fields the body carries. */
-	async function update(id, params, options = {}) {
-		return transport.requestParsed(Field, `/api/field/${id}`, {
-			...options,
-			method: "PUT",
-			body: params
-		});
-	}
-	/** Get the row count and the distinct-value count for a field. */
-	async function summary(id, 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 = {}) {
-		return transport.requestParsed(FieldValues, `/api/field/${id}/values`, { ...options });
-	}
-	return {
-		get,
-		update,
-		summary,
-		values
-	};
-}
-//#endregion
-//#region ../client/src/resources/optional-parsed.ts
-const NO_CONTENT_STATUS = 204;
-async function fetchOptionalParsed(client, path, schema, options = {}) {
-	const response = await client.requestRaw(path, {
-		...options,
-		method: "GET",
-		expectContentType: "binary"
-	});
-	if (response.status === NO_CONTENT_STATUS) return null;
-	return parseJsonOrPlain(await response.text(), response.headers.get("content-type"), schema, { source: response.url });
-}
-//#endregion
-//#region ../client/src/resources/git-sync.ts
-const SyncScopeCollection = Collection.pick({
-	id: true,
-	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 = {}) {
-		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 = {}) {
-		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 = {}) {
-		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 = {}) {
-		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 = {}) {
-		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 = {}) {
-		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 = {}) {
-		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)
-		};
-	}
-	/**
-	* 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 = {}) {
-		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 = {}) {
-		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 = {}) {
-		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 = {}) {
-		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 = {}) {
-		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 = {}) {
-		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 or the caller may not read it. */
-	async function branch(options = {}) {
-		return fetchOptionalParsed(transport, "/api/setting/remote-sync-branch", RemoteSyncSetting, options);
-	}
-	/**
-	* 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 = {}) {
-		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,
-		stash,
-		branches,
-		createBranch,
-		setCollectionSynced,
-		syncedCollections,
-		remoteUrl,
-		branch,
-		waitForTask
-	};
-}
-//#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 AbsentLibrary = z.object({ data: z.null() });
-const LibraryOrAbsent = z.union([Library, AbsentLibrary]);
-const PublishTablesResponse = z.object({ target_collection: Collection.nullable() });
-const LibraryCollectionInfo = Collection.pick({
-	id: true,
-	type: true,
-	is_remote_synced: true
-}).strip();
-function libraryResource(transport) {
-	/** Get the Library root and its child collections, or `null` on an instance that has none. */
-	async function get(options = {}) {
-		const result = await transport.requestParsed(LibraryOrAbsent, LIBRARY_ROOT_PATH, { ...options });
-		if (!("effective_children" in result)) return null;
-		const infoById = await libraryCollectionsById(options);
-		const effective_children = result.effective_children.map((child) => {
-			if (typeof child.id !== "number") return child;
-			const info = infoById.get(child.id);
-			if (info === void 0) return child;
-			return {
-				...child,
-				type: info.type ?? child.type,
-				is_remote_synced: info.is_remote_synced ?? child.is_remote_synced
-			};
-		});
-		return {
-			...result,
-			effective_children
-		};
-	}
-	async function libraryCollectionsById(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 = {}) {
-		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 = {}) {
-		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 = {}) {
-		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.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 = {}) {
-		return {
-			data: await transport.requestParsed(MeasureApiList, "/api/measure", { ...options }),
-			total: null
-		};
-	}
-	/** Get one measure by id. */
-	async function get(id, 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 = {}) {
-		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 = {}) {
-		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 = {}) {
-		return update(id, {
-			archived: true,
-			revision_message: params.revision_message
-		}, options);
-	}
-	return {
-		list,
-		get,
-		create,
-		update,
-		archive
-	};
-}
-//#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 = {}) {
-		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 = {}) {
-		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 = {}) {
-		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 = {}) {
-		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 = {}) {
-		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 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/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 = {}) {
-		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 = {}) {
-		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 = {}) {
-		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 = {}) {
-		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 = {}) {
-		return update(id, { archived: true }, options);
-	}
-	return {
-		list,
-		get,
-		create,
-		update,
-		archive
-	};
-}
-//#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, and `limit`/`offset` are the window the
-	* server applies before ranking hydration.
-	*/
-	async function query(params = {}, 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
-			}
-		});
-		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 = {}) {
-		return {
-			data: await transport.requestParsed(SegmentApiList, "/api/segment", { ...options }),
-			total: null
-		};
-	}
-	/** Get one segment by id. */
-	async function get(id, 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 = {}) {
-		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 = {}) {
-		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 = {}) {
-		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 = {}) {
-		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`; older servers answer the value as bare text rather than JSON.
-	*/
-	async function get(key, 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.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 = {}) {
-		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 = {}) {
-		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 = {}) {
-		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 = {}) {
-		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 = {}) {
-		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 = {}) {
-		return update(id, { archived: true }, options);
-	}
-	return {
-		list,
-		get,
-		create,
-		update,
-		archive
-	};
-}
-//#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/table.ts
-const TableApiList = z.array(Table);
-const UPLOAD_UPDATE_PATHS = {
-	append: "append-csv",
-	replace: "replace-csv"
-};
-function tableResource(transport) {
-	/** List every table the caller can see, across all databases. */
-	async function list(options = {}) {
-		return {
-			data: await transport.requestParsed(TableApiList, "/api/table", { ...options }),
-			total: null
-		};
-	}
-	/** Get one table by id, without its fields. */
-	async function get(id, 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 = {}) {
-		return transport.requestParsed(Table, `/api/table/${id}`, {
-			...options,
-			method: "PUT",
-			body: params
-		});
-	}
-	/** Get a table by id with its fields hydrated — the metadata the query builder runs on. */
-	async function queryMetadata(id, options = {}) {
-		return transport.requestParsed(TableQueryMetadata, `/api/table/${id}/query_metadata`, { ...options });
-	}
-	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 = {}) {
-		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 = {}) {
-		return updateFromCsv(id, "replace", file, options);
-	}
-	return {
-		list,
-		get,
-		update,
-		queryMetadata,
-		appendCsv,
-		replaceCsv
-	};
-}
-//#endregion
-//#region ../client/src/resources/timeline-event.ts
-function timelineEventResource(transport) {
-	/** Get one timeline event by id. */
-	async function get(id, options = {}) {
-		return transport.requestParsed(TimelineEvent, `/api/timeline-event/${id}`, { ...options });
-	}
-	/** Create a timeline event on an existing timeline. */
-	async function create(params, 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 = {}) {
-		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 = {}) {
-		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.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 = {}) {
-		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 = {}) {
-		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 = {}) {
-		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 = {}) {
-		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 = {}) {
-		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 = {}) {
-		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.requestRaw(`/api/timeline/${id}`, {
-			...options,
-			method: "DELETE",
-			expectContentType: "binary"
-		});
-	}
-	return {
-		list,
-		get,
-		events,
-		create,
-		update,
-		archive,
-		delete: remove
-	};
-}
-//#endregion
-//#region ../client/src/resources/transform-job.ts
-const TransformJobApiList = z.array(TransformJob);
-const TransformApiList$1 = z.array(Transform);
-function transformJobResource(transport) {
-	/** List every transform job the caller can see. */
-	async function list(options = {}) {
-		return {
-			data: await transport.requestParsed(TransformJobApiList, "/api/transform-job", { ...options }),
-			total: null
-		};
-	}
-	/** Get one transform job by id. */
-	async function get(id, options = {}) {
-		return transport.requestParsed(TransformJob, `/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 = {}) {
-		return transport.requestParsed(TransformJob, "/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 = {}) {
-		return transport.requestParsed(TransformJob, `/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.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 = {}) {
-		return transport.requestParsed(TransformJobRunResult, `/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 = {}) {
-		return {
-			data: await transport.requestParsed(TransformApiList$1, `/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 = {}) {
-		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/resources/transform.ts
-const TransformApiList = z.array(Transform);
-const TransformRunKickoff = z.object({
-	message: z.string(),
-	run_id: z.number().int().positive().nullable()
-});
-function transformResource(transport) {
-	/** List every transform the caller can see. */
-	async function list(options = {}) {
-		return {
-			data: await transport.requestParsed(TransformApiList, "/api/transform", { ...options }),
-			total: null
-		};
-	}
-	/** Get one transform by id. */
-	async function get(id, options = {}) {
-		return transport.requestParsed(Transform, `/api/transform/${id}`, { ...options });
-	}
-	/** Create a transform — a query plus the warehouse table it writes — from a full body. */
-	async function create(params, options = {}) {
-		return transport.requestParsed(Transform, "/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 = {}) {
-		return transport.requestParsed(Transform, `/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.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.requestRaw(`/api/transform/${id}/table`, {
-			...options,
-			method: "DELETE",
-			expectContentType: "binary"
-		});
-	}
-	/** List the upstream transforms a transform depends on. */
-	async function dependencies(id, options = {}) {
-		return {
-			data: await transport.requestParsed(TransformApiList, `/api/transform/${id}/dependencies`, { ...options }),
-			total: null
-		};
-	}
-	/** Request cancellation of a transform's current run. */
-	async function cancel(id, 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 = {}) {
-		return transport.requestParsed(TransformRun, `/api/transform/run/${runId}`, { ...options });
-	}
-	/** Walk the run history, newest first, optionally narrowed to a single transform. */
-	function runPages(params = {}, options = {}) {
-		return 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 }
-		});
-	}
-	/**
-	* 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 = {}) {
-		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 linkedTableId(await pollUntil(async (signal) => get(id, {
-				...options,
-				signal
-			}), (transform) => linkedTableId(transform) !== null, wait));
-		} catch (error) {
-			if (error instanceof TimeoutError) return null;
-			throw error;
-		}
-	}
-	return {
-		list,
-		get,
-		create,
-		update,
-		delete: remove,
-		deleteTable,
-		dependencies,
-		cancel,
-		getRun,
-		runPages,
-		run
-	};
-}
-function linkedTableId(transform) {
-	return transform.target_table_id ?? transform.table?.id ?? null;
-}
-//#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 = {}) {
-		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 = {}) {
-		return transport.requestParsed(TransformTag, "/api/transform-tag", {
-			...options,
-			method: "POST",
-			body: params
-		});
-	}
-	/** Rename a transform tag by id. */
-	async function update(id, params, 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.requestRaw(`/api/transform-tag/${id}`, {
-			...options,
-			method: "DELETE",
-			expectContentType: "binary"
-		});
-	}
-	return {
-		list,
-		create,
-		update,
-		delete: remove
-	};
-}
-//#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 = {}) {
-		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 = {}) {
-		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),
-		dashboard: dashboardResource(transport),
-		database: databaseResource(transport),
-		dataset: datasetResource(transport),
-		document: documentResource(transport),
-		eidTranslation: eidTranslationResource(transport),
-		field: fieldResource(transport),
-		gitSync: gitSyncResource(transport),
-		library: libraryResource(transport),
-		measure: measureResource(transport),
-		notification: notificationResource(transport),
-		pulse: pulseResource(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),
-		transformJob: transformJobResource(transport),
-		transformTag: transformTagResource(transport),
-		upload: uploadResource(transport),
-		user: userResource(transport),
-		requestParsed: transport.requestParsed,
-		requestRaw: transport.requestRaw,
-		requestStream: transport.requestStream
-	};
-}
-//#endregion
-export { createClient as n, client_exports as t };