@metabase/cli 0.3.2-alpha.fix-transform-test-ee-path.8ac2a7a → 0.4.0

package/dist/discard-values-yzH-kIsr.mjs

@@ -0,0 +1,55 @@
+import { H as connectionFlags, J as profileFlag, p as renderSummary, q as outputFlags } from "./cli.mjs";
+import { t as defineMetabaseCommand } from "./runtime-CZ5zh32z.mjs";
+import { t as parseId } from "./parse-id-BW09NysN.mjs";
+import { l as tableValuesDiscardResultView, n as TableValuesDiscardResult } from "./table-CxvaDiIZ.mjs";
+import { r as confirmDestructive } from "./delete-runtime-BbmRg_in.mjs";
+//#region src/commands/table/discard-values.ts
+var discard_values_default = defineMetabaseCommand({
+	meta: {
+		name: "discard-values",
+		description: "Discard the cached field values of one table"
+	},
+	details: "Deletes the cached distinct values behind this table's filter dropdowns, and with them any custom display values set on those values. No scan recreates a discarded set, neither `mb table rescan-values` nor the database's scheduled scan; Metabase rebuilds a set, without its display values, the next time it is read (a filter dropdown, `mb field values <id>`). Asks for confirmation on a terminal; pass --yes to skip it, which a non-interactive run must. To discard a set of tables use `mb table bulk-discard-values`.",
+	requires: ["table.discardValues"],
+	args: {
+		...outputFlags,
+		...profileFlag,
+		...connectionFlags,
+		yes: {
+			type: "boolean",
+			description: "Skip confirmation",
+			default: false
+		},
+		id: {
+			type: "positional",
+			description: "Table id",
+			required: true
+		}
+	},
+	outputSchema: TableValuesDiscardResult,
+	examples: ["mb table discard-values 42 --yes", "mb table discard-values 42"],
+	async run({ args, ctx, getClient }) {
+		const id = parseId(args.id);
+		const client = await getClient();
+		if (!await confirmDestructive({
+			yes: args.yes,
+			action: `discard the field values of table ${id}`,
+			promptMessage: `Discard the cached field values of table ${id}, custom display values included?`
+		})) {
+			renderSummary({
+				id,
+				discarded: false,
+				aborted: true
+			}, tableValuesDiscardResultView, `Aborted; the field values of table ${id} were not discarded.`, ctx);
+			return;
+		}
+		await client.table.discardValues(id);
+		renderSummary({
+			id,
+			discarded: true,
+			aborted: false
+		}, tableValuesDiscardResultView, `Cached field values discarded for table ${id}.`, ctx);
+	}
+});
+//#endregion
+export { discard_values_default as default };

package/dist/document-BRaba87v.mjs

@@ -0,0 +1,20 @@
+import { t as defineCommandGroup } from "./group-bpD_KcjA.mjs";
+//#region src/commands/document/index.ts
+var document_default = defineCommandGroup({
+	name: "document",
+	description: "Manage Metabase documents",
+	skills: [{
+		skill: "document",
+		purpose: "author the ProseMirror document body"
+	}],
+	subCommands: {
+		list: () => import("./list-CvZyTwmV.mjs").then((mod) => mod.default),
+		get: () => import("./get-BXsLkoit.mjs").then((mod) => mod.default),
+		create: () => import("./create-XGomrTz5.mjs").then((mod) => mod.default),
+		update: () => import("./update-BT2yNB_g.mjs").then((mod) => mod.default),
+		copy: () => import("./copy-COLUuiuF.mjs").then((mod) => mod.default),
+		archive: () => import("./archive-ewitrKdx.mjs").then((mod) => mod.default)
+	}
+});
+//#endregion
+export { document_default as default };

package/dist/{document-CA0Q6lqu.mjs → document-C18b5rM6.mjs}

@@ -1,4 +1,4 @@
-import { n as DocumentCompact } from "./document-BHpLJbKU.mjs";
+import { n as DocumentCompact } from "./document-DFCj1Az_.mjs";
 //#region src/output/views/document.ts
 const documentView = {
 	compactPick: DocumentCompact,

package/dist/{document-BHpLJbKU.mjs → document-DFCj1Az_.mjs}

@@ -1,3 +1,4 @@
+import { t as NonBlankText } from "./text-DaNkPRwt.mjs";
 import { z } from "zod";
 //#region ../client/src/domain/document.ts
 const TipTapNode = z.looseObject({
@@ -85,7 +86,7 @@ const DocumentUpdateInput = z.object({
 	cards: z.record(z.string().regex(/^-?\d+$/), DocumentCardInput).nullable().optional().describe("cards keyed by card id; negative ids create new cards")
 }).loose();
 z.object({
-	name: DocumentName.nullable().optional(),
+	name: NonBlankText.nullable().optional(),
 	collection_id: z.number().int().positive().nullable().optional(),
 	collection_position: z.number().int().positive().nullable().optional()
 }).strict();

package/dist/{download-Ddap1OAo.mjs → download-DluF-vnU.mjs}

@@ -1,5 +1,5 @@
-import { U as profileFlag, z as connectionFlags } from "./cli.mjs";
-import { t as defineMetabaseCommand } from "./runtime-Dtb93zKy.mjs";
+import { H as connectionFlags, J as profileFlag } from "./cli.mjs";
+import { t as defineMetabaseCommand } from "./runtime-CZ5zh32z.mjs";
 import { t as pipeToStdout } from "./stream-McixcoUl.mjs";
 import { z } from "zod";
 //#region src/commands/content-translation/download.ts

package/dist/{eid-HnrWhPoe.mjs → eid-Dz-mP40j.mjs}

@@ -1,6 +1,7 @@
-import { H as outputFlags, Q as ConfigError, U as profileFlag, p as renderSummary, z as connectionFlags } from "./cli.mjs";
-import { n as parseCsv, t as defineMetabaseCommand } from "./runtime-Dtb93zKy.mjs";
-import { t as readBody } from "./body-CshgcV6U.mjs";
+import { H as connectionFlags, J as profileFlag, at as ConfigError, et as parseCsv, p as renderSummary, q as outputFlags } from "./cli.mjs";
+import { t as defineMetabaseCommand } from "./runtime-CZ5zh32z.mjs";
+import { r as givenValue } from "./input-D8qW-KtR.mjs";
+import { t as readBody } from "./body-Dd-TwYYL.mjs";
 import { t as bodyInputFlags } from "./body-flags-AqKpN01Y.mjs";
 import { a as EidTranslateResultCompact, i as EidTranslateResult, n as EidModel, r as EidTranslateInput, t as EID_MODELS } from "./eid-translation-zEHtr5Oc.mjs";
 //#region src/output/views/eid-translation.ts
@@ -14,14 +15,14 @@ const eidTranslateView = {
 //#endregion
 //#region src/commands/flag-pair.ts
 function requireBothOrNeither(first, second) {
-	const firstSet = first.value !== void 0 && first.value !== "";
-	const secondSet = second.value !== void 0 && second.value !== "";
-	if (!firstSet && !secondSet) return null;
-	if (!firstSet) throw new ConfigError(`${first.name} is required when using ${second.name}`);
-	if (!secondSet) throw new ConfigError(`${second.name} is required when using ${first.name}`);
+	const firstValue = givenValue(first.value);
+	const secondValue = givenValue(second.value);
+	if (firstValue === null && secondValue === null) return null;
+	if (firstValue === null) throw new ConfigError(`${first.name} is required when using ${second.name}`);
+	if (secondValue === null) throw new ConfigError(`${second.name} is required when using ${first.name}`);
 	return {
-		first: first.value,
-		second: second.value
+		first: firstValue,
+		second: secondValue
 	};
 }
 //#endregion

package/dist/entity-CA4zfRt4.mjs

@@ -0,0 +1,20 @@
+import { f as DependencyType } from "./dependency-DKSjKT8P.mjs";
+import { t as parseEnumFlag } from "./parse-enum-CLIXMsd8.mjs";
+//#region src/commands/dependency/entity.ts
+const entityArgs = {
+	type: {
+		type: "positional",
+		description: `Entity kind (${DependencyType.options.join(" | ")})`,
+		required: true
+	},
+	id: {
+		type: "positional",
+		description: "Entity id",
+		required: true
+	}
+};
+function parseDependencyType(value) {
+	return parseEnumFlag(value, DependencyType, "type");
+}
+//#endregion
+export { parseDependencyType as n, entityArgs as t };

package/dist/entry-flags-7x7bIyOQ.mjs

@@ -0,0 +1,42 @@
+import { at as ConfigError } from "./cli.mjs";
+import { r as givenValue } from "./input-D8qW-KtR.mjs";
+import { t as readBody } from "./body-Dd-TwYYL.mjs";
+import { t as bodyInputFlags } from "./body-flags-AqKpN01Y.mjs";
+import { r as GlossaryCreateInput } from "./glossary-BlNCrYbw.mjs";
+//#region src/commands/glossary/entry-flags.ts
+const entryFlags = {
+	...bodyInputFlags,
+	term: {
+		type: "string",
+		description: "The term (used with --definition)"
+	},
+	definition: {
+		type: "string",
+		description: "The definition (used with --term)"
+	}
+};
+/**
+* The flag pair and a body are alternatives, so a `--body` or `--file` beside the flags is refused
+* rather than dropped. A body piped on stdin is not read while the flags are given: telling an
+* idle inherited pipe from one still to send would cost every flag-driven call the stdin wait.
+*/
+async function readEntryInput(args) {
+	if (args.term === void 0 && args.definition === void 0) return readBody({
+		flag: args.body,
+		file: args.file
+	}, GlossaryCreateInput);
+	if (givenValue(args.body) !== null || givenValue(args.file) !== null) throw new ConfigError("--term, --definition cannot be combined with --body or --file");
+	if (args.term === void 0) throw new ConfigError("--term is required when using --definition");
+	if (args.definition === void 0) throw new ConfigError("--definition is required when using --term");
+	return {
+		term: parseFlag(GlossaryCreateInput.shape.term, args.term, "--term"),
+		definition: parseFlag(GlossaryCreateInput.shape.definition, args.definition, "--definition")
+	};
+}
+function parseFlag(schema, value, flag) {
+	const parsed = schema.safeParse(value);
+	if (!parsed.success) throw new ConfigError(`${flag} ${parsed.error.issues.map((issue) => issue.message).join("; ")}`);
+	return parsed.data;
+}
+//#endregion
+export { readEntryInput as n, entryFlags as t };

package/dist/{events-CXqetjcS.mjs → events-2sOk6H09.mjs}

@@ -1,7 +1,7 @@
-import { B as listFlags, G as listEnvelopeSchema, H as outputFlags, U as profileFlag, d as renderList, z as connectionFlags } from "./cli.mjs";
-import { t as defineMetabaseCommand } from "./runtime-Dtb93zKy.mjs";
-import { t as parseId } from "./parse-id-DtM6q9HU.mjs";
-import { n as windowList } from "./window-DSb1tqSe.mjs";
+import { G as listFlags, H as connectionFlags, J as profileFlag, X as listEnvelopeSchema, d as renderList, q as outputFlags } from "./cli.mjs";
+import { t as defineMetabaseCommand } from "./runtime-CZ5zh32z.mjs";
+import { t as parseId } from "./parse-id-BW09NysN.mjs";
+import { n as windowList } from "./window-CI_QD04s.mjs";
 import { a as TimelineEventCompact } from "./timeline-CCSU2qOS.mjs";
 import { t as timelineEventView } from "./timeline-uDCmwGFT.mjs";
 //#region src/commands/timeline/events.ts

package/dist/export-BKkAJOFb.mjs

@@ -0,0 +1,74 @@
+import { H as connectionFlags, J as profileFlag, at as ConfigError, k as warn, p as renderSummary, q as outputFlags } from "./cli.mjs";
+import { t as defineMetabaseCommand } from "./runtime-CZ5zh32z.mjs";
+import { o as SyncExportResult } from "./git-sync-COokpYgc.mjs";
+import { n as parseWaitFlags, t as gitSyncWaitFlags } from "./wait-flags-rUU4NUrv.mjs";
+import { a as syncExportView } from "./git-sync-DspFahwV.mjs";
+import { a as throwIfFailedTask, i as taskPollOptions, n as formatSyncTask } from "./sync-task-CXFoqlpF.mjs";
+import { t as branchFlag } from "./branch-flag-pFQPNYKr.mjs";
+//#region src/commands/git-sync/export.ts
+var export_default = defineMetabaseCommand({
+	meta: {
+		name: "export",
+		description: "Export Metabase changes back to the configured git remote"
+	},
+	details: "The export targets the branch git-sync tracks. On Metabase 63+ `--branch` defaults to it and must name it (the server answers 409 for any other branch); older servers export to the branch `--branch` names and switch git-sync to it, refusing with 400 when that branch's tip is not the last synced commit unless --force is given. To push to a new branch, use `git-sync stash` or `git-sync create-branch` first. When the remote has moved past the last sync, a plain export ends in a `conflict` task on 63+ and is refused with 400 on older servers. --merge (63+) folds the remote's changes in by a three-way merge (entities changed on both sides still end in `conflict`), --force overwrites them. `git-sync export-preflight` previews which applies. A task that ends in `conflict` makes the server count the remote commit it saw as synced, so a retry, --merge included, no longer sees the remote's changes: resolve a conflict with --force on the side to keep, or `git-sync create-branch` then export, never with a retry.",
+	requires: ["gitSync.export"],
+	args: {
+		...outputFlags,
+		...profileFlag,
+		...connectionFlags,
+		branch: {
+			type: "string",
+			description: "Branch to export to (defaults to the remote-sync-branch setting; on 63+ it must be that branch)",
+			alias: "b"
+		},
+		message: {
+			type: "string",
+			description: "Commit message",
+			alias: "m"
+		},
+		force: {
+			type: "boolean",
+			description: "Force-push / overwrite remote",
+			default: false
+		},
+		merge: {
+			type: "boolean",
+			description: "When the remote moved on, fold its changes in by a three-way merge instead of ending in conflict",
+			default: false
+		},
+		...gitSyncWaitFlags
+	},
+	outputSchema: SyncExportResult,
+	examples: [
+		"mb git-sync export -m \"update dashboards\"",
+		"mb git-sync export --merge -m \"update dashboards\"",
+		"mb git-sync export --branch main --json",
+		"mb git-sync export --no-wait"
+	],
+	async run({ args, ctx, getClient }) {
+		const wait = parseWaitFlags(args);
+		if (args.merge && args.force) throw new ConfigError("--merge cannot be combined with --force");
+		const branch = branchFlag(args.branch);
+		const params = {};
+		if (branch !== null) params.branch = branch;
+		if (args.message !== void 0 && args.message !== "") params.message = args.message;
+		if (args.force) params.force = true;
+		if (args.merge) params.merge = true;
+		if (wait.enabled) params.wait = taskPollOptions(wait.schedule);
+		const result = await (await getClient()).gitSync.export(params);
+		if (!wait.enabled) renderSummary(result, syncExportView, `Started export task #${result.task_id}.`, ctx);
+		else {
+			const final = result.final ?? null;
+			renderSummary(result, syncExportView, final === null ? `Export task #${result.task_id} finished.` : formatSyncTask(final), ctx);
+			throwIfFailedTask(final, "export");
+		}
+		emitRealignHint(ctx);
+	}
+});
+function emitRealignHint(ctx) {
+	if (ctx.format !== "text") return;
+	warn("\nNote: if exporting to a host-bound repo, realign the host working tree with:\n  git -C <repo-path> restore --staged --worktree .");
+}
+//#endregion
+export { export_default as default };

package/dist/export-flags-NiZ7C3Gm.mjs

@@ -0,0 +1,81 @@
+import { at as ConfigError, v as formatScalar, y as renderRows } from "./cli.mjs";
+import { d as PivotExportFormat, u as ExportFormat } from "./card-Bv4ZN0oV.mjs";
+import { t as parseEnumFlag } from "./parse-enum-CLIXMsd8.mjs";
+//#region src/output/query-result.ts
+function formatQueryResult(result) {
+	if (result.status !== "completed" || result.data === void 0) {
+		const detail = typeof result.error === "string" && result.error !== "" ? `: ${result.error}` : "";
+		return `Query ${result.status}${detail}`;
+	}
+	const head = result.data.cols.map((col) => col.display_name ?? col.name);
+	const rowCount = result.row_count ?? result.data.rows.length;
+	const summary = `${rowCount} row${rowCount === 1 ? "" : "s"}.`;
+	if (result.data.rows.length === 0) return summary;
+	return `${renderRows(head, result.data.rows.map((row) => Array.isArray(row) ? row.map((cell) => formatScalar(cell)) : [formatScalar(row)]))}\n${summary}`;
+}
+//#endregion
+//#region src/commands/export-flags.ts
+const PIVOT_FORMATS = PivotExportFormat.options.join(" or ");
+const exportOnlyFlags = {
+	"format-rows": {
+		type: "boolean",
+		description: "Streamed exports only: format values as Metabase displays them, column settings included",
+		default: false
+	},
+	"pivot-results": {
+		type: "boolean",
+		description: `With --export-format ${PIVOT_FORMATS}: lay a pivot table's rows out as the pivot, with its subtotals; refused when the server has pivoted exports turned off`,
+		default: false
+	},
+	"csv-include-bom": {
+		type: "boolean",
+		description: "With --export-format csv: open the file with a UTF-8 byte order mark, so Excel reads it as UTF-8",
+		default: false
+	}
+};
+const exportFlags = {
+	"export-format": {
+		type: "string",
+		description: `Bypass the JSON envelope and stream the raw export: ${ExportFormat.options.join(" | ")}`
+	},
+	...exportOnlyFlags
+};
+function isExportOnlyFlag(flag) {
+	return flag in exportOnlyFlags;
+}
+const EXPORT_ONLY_FLAGS = Object.keys(exportOnlyFlags).filter(isExportOnlyFlag);
+/**
+* The export the flags ask for, or `null` when `--export-format` is absent. An export-only flag
+* given without a format would be ignored silently, so it is refused.
+*/
+function readExportRequest(args) {
+	const raw = args["export-format"];
+	if (raw === void 0 || raw === "") {
+		const stray = EXPORT_ONLY_FLAGS.find((flag) => args[flag]);
+		if (stray !== void 0) throw new ConfigError(`--${stray} requires --export-format`);
+		return null;
+	}
+	const format = parseEnumFlag(raw, ExportFormat, "--export-format");
+	if (args["csv-include-bom"] && format !== "csv") throw new ConfigError("--csv-include-bom requires --export-format csv");
+	if (args["pivot-results"] && !PivotExportFormat.safeParse(format).success) throw new ConfigError(`--pivot-results requires --export-format ${PIVOT_FORMATS}`);
+	return {
+		format,
+		params: {
+			format_rows: args["format-rows"],
+			pivot_results: args["pivot-results"],
+			csv_include_bom: args["csv-include-bom"]
+		}
+	};
+}
+/**
+* A streamed export is the server's bytes, so a flag that shapes the JSON output would be ignored
+* silently and is refused. `--json` and `--format` still pick the shape of an error report.
+*/
+function assertStreamedOutput(ctx) {
+	if (ctx.full) throw new ConfigError("--full cannot be combined with --export-format");
+	if (ctx.fields !== void 0) throw new ConfigError("--fields cannot be combined with --export-format");
+	if (ctx.maxBytesGiven) throw new ConfigError("--max-bytes cannot be combined with --export-format");
+	if (ctx.range.limit !== void 0) throw new ConfigError("--limit cannot be combined with --export-format");
+}
+//#endregion
+export { formatQueryResult as i, exportFlags as n, readExportRequest as r, assertStreamedOutput as t };

package/dist/export-preflight-CwJ_3-iX.mjs

@@ -0,0 +1,35 @@
+import { H as connectionFlags, J as profileFlag, p as renderSummary, q as outputFlags } from "./cli.mjs";
+import { t as defineMetabaseCommand } from "./runtime-CZ5zh32z.mjs";
+import { i as SyncExportPreflight } from "./git-sync-COokpYgc.mjs";
+import { i as syncExportPreflightView, t as formatExportPreflight } from "./git-sync-DspFahwV.mjs";
+import { t as branchFlag } from "./branch-flag-pFQPNYKr.mjs";
+//#region src/commands/git-sync/export-preflight.ts
+var export_preflight_default = defineMetabaseCommand({
+	meta: {
+		name: "export-preflight",
+		description: "Preview what an export would do against the live remote branch, without writing"
+	},
+	details: "Compares the current Metabase content with the remote branch. `has_changes` says whether the remote has advanced past the last synced version (false when nothing has been synced yet, and after a task that ended in `conflict`, which the server counts as synced), `clean` whether a three-way merge would apply without conflicts, `conflicts` names the entities that would conflict, `summary` counts the remote changes a merge would fold in, `force_push_casualties` names the remote content a force push would discard (empty when nothing has been synced yet, although a forced export then replaces the remote's managed directories wholesale), and `reason` is `history-rewritten` when the remote was force-pushed or rebased so no merge base exists. The branch must be the one git-sync tracks; the server answers 409 otherwise.",
+	requires: ["gitSync.exportPreflight", "gitSync.trackedBranch"],
+	args: {
+		...outputFlags,
+		...profileFlag,
+		...connectionFlags,
+		branch: {
+			type: "string",
+			description: "Branch to preview against (defaults to the remote-sync-branch setting; must be that branch)",
+			alias: "b"
+		}
+	},
+	outputSchema: SyncExportPreflight,
+	examples: ["mb git-sync export-preflight", "mb git-sync export-preflight --branch main --json"],
+	async run({ args, ctx, getClient }) {
+		const given = branchFlag(args.branch);
+		const mb = await getClient();
+		const branch = given ?? await mb.gitSync.trackedBranch();
+		const result = await mb.gitSync.exportPreflight({ branch });
+		renderSummary(result, syncExportPreflightView, () => formatExportPreflight(branch, result), ctx);
+	}
+});
+//#endregion
+export { export_preflight_default as default };

package/dist/{field-CcN4oZy6.mjs → field-5nivEfd6.mjs}

@@ -187,6 +187,17 @@ const FieldCompact = Field.pick({
 	semantic_type: true,
 	fk_target_field_id: true
 }).strip();
+const FieldWithDataSensitivity = Field.extend({ data_sensitivity: FieldDataSensitivity.nullable() });
+const FieldDetail = z.union([FieldWithDataSensitivity, Field]);
+/** The shape `GET` and `PUT /api/field/{id}` answer on a server with `features`. */
+function fieldDetailSchema(features) {
+	return features.fieldDataSensitivity ? FieldWithDataSensitivity : Field;
+}
+/** Whether `field` came from a server that labels data sensitivity. */
+function hasDataSensitivity(field) {
+	return "data_sensitivity" in field && FieldWithDataSensitivity.shape.data_sensitivity.safeParse(field.data_sensitivity).success;
+}
+const FieldWithDataSensitivityCompact = FieldCompact.extend({ data_sensitivity: FieldDataSensitivity.nullable() }).strip();
 const NonBlankNullable = z.string().min(1).nullable();
 const FieldUpdateInput = z.object({
 	display_name: NonBlankNullable.optional(),
@@ -214,12 +225,31 @@ const FieldValuesCompact = FieldValues.pick({
 	field_id: true,
 	has_more_values: true
 }).strip();
-const FieldSearchMatches = z.array(z.array(z.unknown()));
-const FieldRemappedValue = z.tuple([z.unknown(), z.unknown()]);
+const FieldSearchMatches = z.array(z.union([z.tuple([z.unknown()]), z.tuple([z.unknown(), z.unknown()])]));
+const FieldRemappedPair = z.tuple([z.unknown(), z.unknown()]);
+const FieldRemappedSingle = z.tuple([z.unknown()]).transform(([value]) => [value, value]);
+const FieldRemappedValue = z.union([FieldRemappedPair, FieldRemappedSingle]);
+const FieldRemappedRowWireV59 = z.array(z.unknown()).min(1);
+function firstTwoCells(row) {
+	const [value, second] = row;
+	return row.length === 1 ? [value, value] : [value, second];
+}
+function valueTwice(row) {
+	const [value] = row;
+	return [value, value];
+}
+/**
+* The row `GET /api/field/{id}/remapping/{remapped-id}` answers on a server with `features`, read as
+* `FieldRemappedValue`. `sameField` says the two ids name one field.
+*/
+function fieldRemappedValueSchema(features, sameField) {
+	if (!features.fieldRemappingAppendsDisplayColumns) return FieldRemappedValue;
+	return FieldRemappedRowWireV59.transform(sameField ? valueTwice : firstTwoCells);
+}
 const FieldSummary = z.object({
 	field_id: z.number().int(),
 	count: z.number().int(),
 	distincts: z.number().int()
 });
 //#endregion
-export { FieldSearchMatches as a, FieldUpdateInput as c, FieldRemappedValue as i, FieldValues as l, FieldBaseType as n, FieldSemanticType as o, FieldCompact as r, FieldSummary as s, Field as t, FieldValuesCompact as u };
+export { FieldDetail as a, FieldSummary as c, FieldValuesCompact as d, FieldWithDataSensitivity as f, hasDataSensitivity as g, fieldRemappedValueSchema as h, FieldDataSensitivity as i, FieldUpdateInput as l, fieldDetailSchema as m, FieldBaseType as n, FieldSearchMatches as o, FieldWithDataSensitivityCompact as p, FieldCompact as r, FieldSemanticType as s, Field as t, FieldValues as u };

package/dist/field-BARgq5I9.mjs

@@ -0,0 +1,21 @@
+import { t as defineCommandGroup } from "./group-bpD_KcjA.mjs";
+//#region src/commands/field/index.ts
+var field_default = defineCommandGroup({
+	name: "field",
+	description: "Manage Metabase fields",
+	skills: [{
+		skill: "metadata",
+		purpose: "semantic types, FK targets, visibility, dropdown behavior"
+	}],
+	subCommands: {
+		get: () => import("./get-Bct52yPw.mjs").then((m) => m.default),
+		values: () => import("./values-PonkbYAK.mjs").then((m) => m.default),
+		summary: () => import("./summary-DKx6ptQe.mjs").then((m) => m.default),
+		update: () => import("./update-B28EJzrx.mjs").then((m) => m.default),
+		search: () => import("./search-CnTXKJgx.mjs").then((m) => m.default),
+		remapping: () => import("./remapping-CPAvDKHV.mjs").then((m) => m.default),
+		"set-sensitivity": () => import("./set-sensitivity-D39kGTob.mjs").then((m) => m.default)
+	}
+});
+//#endregion
+export { field_default as default };

package/dist/field-wmN6raOG.mjs

@@ -0,0 +1,128 @@
+import { c as FieldSummary, d as FieldValuesCompact, p as FieldWithDataSensitivityCompact, r as FieldCompact } from "./field-5nivEfd6.mjs";
+import { z } from "zod";
+//#region src/output/views/field.ts
+function formatTypeTag(value) {
+	return typeof value === "string" ? value.replace(/^type\//, "") : "";
+}
+function formatFkTarget(value) {
+	return typeof value === "number" ? `field ${value}` : "";
+}
+const FIELD_COLUMNS = [
+	{
+		key: "id",
+		label: "ID"
+	},
+	{
+		key: "name",
+		label: "Name"
+	},
+	{
+		key: "display_name",
+		label: "Display Name"
+	},
+	{
+		key: "base_type",
+		label: "Base Type",
+		format: formatTypeTag
+	},
+	{
+		key: "semantic_type",
+		label: "Semantic Type",
+		format: formatTypeTag
+	},
+	{
+		key: "fk_target_field_id",
+		label: "FK Target",
+		format: formatFkTarget
+	},
+	{
+		key: "description",
+		label: "Description"
+	}
+];
+const fieldView = {
+	compactPick: FieldCompact,
+	tableColumns: FIELD_COLUMNS
+};
+const fieldWithDataSensitivityView = {
+	compactPick: FieldWithDataSensitivityCompact,
+	tableColumns: [...FIELD_COLUMNS, {
+		key: "data_sensitivity",
+		label: "Sensitivity"
+	}]
+};
+const FieldValueLabel = z.object({
+	value: z.unknown(),
+	label: z.unknown()
+});
+function toValueLabel(row) {
+	const [value, label = null] = row;
+	return {
+		value,
+		label
+	};
+}
+const VALUE_LABEL_COLUMNS = [{
+	key: "value",
+	label: "Value"
+}, {
+	key: "label",
+	label: "Label"
+}];
+const fieldValueLabelView = {
+	compactPick: FieldValueLabel,
+	tableColumns: VALUE_LABEL_COLUMNS
+};
+const FieldRemappingMatch = z.object({
+	found: z.literal(true),
+	...FieldValueLabel.shape
+});
+const FieldRemappingMiss = z.object({ found: z.literal(false) });
+const FieldRemappingResult = z.discriminatedUnion("found", [FieldRemappingMatch, FieldRemappingMiss]);
+const fieldRemappingMatchView = {
+	compactPick: FieldRemappingMatch,
+	tableColumns: VALUE_LABEL_COLUMNS
+};
+const fieldRemappingMissView = {
+	compactPick: FieldRemappingMiss,
+	tableColumns: [{
+		key: "found",
+		label: "Found"
+	}]
+};
+const fieldValuesView = {
+	compactPick: FieldValuesCompact,
+	tableColumns: [
+		{
+			key: "field_id",
+			label: "Field"
+		},
+		{
+			key: "has_more_values",
+			label: "Has More"
+		},
+		{
+			key: "values",
+			label: "Values"
+		}
+	]
+};
+const fieldSummaryView = {
+	compactPick: FieldSummary,
+	tableColumns: [
+		{
+			key: "field_id",
+			label: "Field"
+		},
+		{
+			key: "count",
+			label: "Count"
+		},
+		{
+			key: "distincts",
+			label: "Distinct"
+		}
+	]
+};
+//#endregion
+export { fieldSummaryView as a, fieldView as c, fieldRemappingMissView as i, fieldWithDataSensitivityView as l, FieldValueLabel as n, fieldValueLabelView as o, fieldRemappingMatchView as r, fieldValuesView as s, FieldRemappingResult as t, toValueLabel as u };

package/dist/{fields-DxHxuxwO.mjs → fields-Bod0s_uV.mjs}

@@ -1,9 +1,9 @@
-import { B as listFlags, G as listEnvelopeSchema, H as outputFlags, U as profileFlag, d as renderList, z as connectionFlags } from "./cli.mjs";
-import { t as defineMetabaseCommand } from "./runtime-Dtb93zKy.mjs";
-import { t as parseId } from "./parse-id-DtM6q9HU.mjs";
-import { n as windowList } from "./window-DSb1tqSe.mjs";
-import { r as FieldCompact } from "./field-CcN4oZy6.mjs";
-import { r as fieldView } from "./field-fDtIrY6D.mjs";
+import { G as listFlags, H as connectionFlags, J as profileFlag, X as listEnvelopeSchema, d as renderList, q as outputFlags } from "./cli.mjs";
+import { t as defineMetabaseCommand } from "./runtime-CZ5zh32z.mjs";
+import { t as parseId } from "./parse-id-BW09NysN.mjs";
+import { n as windowList } from "./window-CI_QD04s.mjs";
+import { r as FieldCompact } from "./field-5nivEfd6.mjs";
+import { c as fieldView } from "./field-wmN6raOG.mjs";
 //#region src/commands/table/fields.ts
 const FieldListEnvelope = listEnvelopeSchema(FieldCompact);
 var fields_default = defineMetabaseCommand({