@metabase/cli 0.2.1-alpha.trust-system-ca.541e4e0 → 0.2.2-alpha.extract-api-client.27e2241

package/dist/{parameter-BZ6y-Gfs.mjs → parameter-DUKR8NXo.mjs}

@@ -1,6 +1,5 @@
 import { z } from "zod";
-
-//#region src/domain/parameter.ts
+//#region ../client/src/domain/parameter.ts
 const ParameterType = z.enum([
 	"number",
 	"text",
@@ -106,13 +105,5 @@ const ParameterValuesCompact = ParameterValues.pick({
 	values: true,
 	has_more_values: true
 }).strip();
-const parameterValuesView = {
-	compactPick: ParameterValuesCompact,
-	tableColumns: [{
-		key: "has_more_values",
-		label: "More available"
-	}]
-};
-
 //#endregion
-export { Parameter, ParameterMapping, ParameterValues, parameterValuesView };
+export { ParameterValuesCompact as i, ParameterMapping as n, ParameterValues as r, Parameter as t };

package/dist/{parameter-values-ZXKECrJk.mjs → parameter-values-CJTdqd8c.mjs}

@@ -1,9 +1,17 @@
-import { ConfigError, connectionFlags, outputFlags, profileFlag, renderSummary } from "./capabilities-CSjeWyLV.mjs";
-import "./command-augment-D9pI9Vbh.mjs";
-import { defineMetabaseCommand } from "./runtime-MGH96fhp.mjs";
-import { ParameterValues, parameterValuesView } from "./parameter-BZ6y-Gfs.mjs";
-import { parseId } from "./parse-id-ySsF4nA3.mjs";
-
+import { i as ConfigError } from "./predicates-Bkm2IoeX.mjs";
+import { F as outputFlags, I as profileFlag, M as connectionFlags, c as renderSummary } from "./cli.mjs";
+import { t as defineMetabaseCommand } from "./runtime-DiKyBxOw.mjs";
+import { t as parseId } from "./parse-id-C_jmKFaa.mjs";
+import { i as ParameterValuesCompact, r as ParameterValues } from "./parameter-DUKR8NXo.mjs";
+//#region src/output/views/parameter.ts
+const parameterValuesView = {
+	compactPick: ParameterValuesCompact,
+	tableColumns: [{
+		key: "has_more_values",
+		label: "More available"
+	}]
+};
+//#endregion
 //#region src/commands/dashboard/parameter-values.ts
 var parameter_values_default = defineMetabaseCommand({
 	meta: {
@@ -42,13 +50,11 @@ var parameter_values_default = defineMetabaseCommand({
 		const parameterId = args["parameter-id"];
 		if (parameterId === "") throw new ConfigError("parameter-id must not be empty");
 		const client = await getClient();
-		const base = `/api/dashboard/${dashboardId}/params/${encodeURIComponent(parameterId)}`;
-		const path = args.query === void 0 || args.query === "" ? `${base}/values` : `${base}/search/${encodeURIComponent(args.query)}`;
-		const result = await client.requestParsed(ParameterValues, path);
+		const search = args.query === void 0 || args.query === "" ? null : args.query;
+		const result = search === null ? await client.dashboard.parameterValues(dashboardId, parameterId) : await client.dashboard.searchParameterValues(dashboardId, parameterId, search);
 		const more = result.has_more_values ? " (more available — narrow with --query)" : "";
 		renderSummary(result, parameterValuesView, `${result.values.length} value(s)${more}.`, ctx);
 	}
 });
-
 //#endregion
-export { parameter_values_default as default };
+export { parameter_values_default as default };

package/dist/{parse-enum-D5h-JePs.mjs → parse-enum-D0Jfm_Bz.mjs}

@@ -1,11 +1,9 @@
-import { ConfigError } from "./capabilities-CSjeWyLV.mjs";
-
+import { i as ConfigError } from "./predicates-Bkm2IoeX.mjs";
 //#region src/commands/parse-enum.ts
 function parseEnumFlag(value, schema, name) {
 	const result = schema.safeParse(value);
 	if (result.success) return result.data;
 	throw new ConfigError(`invalid ${name}: "${value}" (expected one of: ${schema.options.join(", ")})`);
 }
-
 //#endregion
-export { parseEnumFlag };
+export { parseEnumFlag as t };

package/dist/{parse-id-ySsF4nA3.mjs → parse-id-C_jmKFaa.mjs}

@@ -1,5 +1,4 @@
-import { parseInteger } from "./runtime-MGH96fhp.mjs";
-
+import { R as parseInteger } from "./runtime-DiKyBxOw.mjs";
 //#region src/commands/parse-id.ts
 function parseId(value, name = "id") {
 	return parseInteger(value, {
@@ -7,6 +6,5 @@ function parseId(value, name = "id") {
 		min: 1
 	});
 }
-
 //#endregion
-export { parseId };
+export { parseId as t };

package/dist/{parse-ref-Ds8VxdKb.mjs → parse-ref-ibKVB0J4.mjs}

@@ -1,7 +1,6 @@
-import { ConfigError } from "./capabilities-CSjeWyLV.mjs";
-
+import { i as ConfigError } from "./predicates-Bkm2IoeX.mjs";
 //#region src/commands/collection/parse-ref.ts
-const SPECIAL_TOKENS = new Set(["root", "trash"]);
+const SPECIAL_TOKENS = /* @__PURE__ */ new Set(["root", "trash"]);
 const POSITIVE_INTEGER_PATTERN = /^[1-9]\d*$/;
 const NANO_ID_PATTERN = /^[A-Za-z0-9_-]{21}$/;
 const FORMAT_HINT = "expected integer, \"root\", \"trash\", or 21-char entity id";
@@ -12,6 +11,5 @@ function parseCollectionRef(raw) {
 	if (POSITIVE_INTEGER_PATTERN.test(trimmed) || NANO_ID_PATTERN.test(trimmed)) return trimmed;
 	throw new ConfigError(`invalid id: ${JSON.stringify(raw)} (${FORMAT_HINT})`);
 }
-
 //#endregion
-export { parseCollectionRef };
+export { parseCollectionRef as t };

package/dist/{path-C6ucgeYs.mjs → path-B5gHvrYL.mjs}

@@ -1,9 +1,8 @@
-import { listEnvelopeSchema, outputFlags, renderList, wrapList } from "./capabilities-CSjeWyLV.mjs";
-import "./command-augment-D9pI9Vbh.mjs";
-import { defineMetabaseCommand } from "./runtime-MGH96fhp.mjs";
-import { findSkillByName, loadAllSkills, loadVisibleSkills } from "./skills-aRQfUvCq.mjs";
+import { F as outputFlags, N as listFlags, R as listEnvelopeSchema, s as renderList } from "./cli.mjs";
+import { t as defineMetabaseCommand } from "./runtime-DiKyBxOw.mjs";
+import { n as windowList } from "./window-BkvrP0gB.mjs";
+import { i as loadVisibleSkills, n as findSkillByName, r as loadAllSkills } from "./skills-DTCrMcix.mjs";
 import { z } from "zod";
-
 //#region src/commands/skills/path.ts
 const SkillPath = z.object({
 	name: z.string(),
@@ -25,8 +24,10 @@ var path_default = defineMetabaseCommand({
 		name: "path",
 		description: "Print the absolute path to a skill (or all skills). Useful when an agent needs to read the SKILL.md or its references with the Read tool directly."
 	},
+	capabilities: null,
 	args: {
 		...outputFlags,
+		...listFlags,
 		name: {
 			type: "positional",
 			description: "Skill name (omit to list every non-hidden skill)",
@@ -40,8 +41,7 @@ var path_default = defineMetabaseCommand({
 		"mb skills path core --json"
 	],
 	run({ args, ctx }) {
-		const items = args.name === void 0 ? loadVisibleSkills().map(toSkillPath) : [toSkillPath(findSkillByName(loadAllSkills(), args.name))];
-		renderList(wrapList(items), skillPathView, ctx);
+		renderList(windowList(args.name === void 0 ? loadVisibleSkills().map(toSkillPath) : [toSkillPath(findSkillByName(loadAllSkills(), args.name))], ctx.range), skillPathView, ctx);
 	}
 });
 function toSkillPath(info) {
@@ -50,6 +50,5 @@ function toSkillPath(info) {
 		dir: info.dir
 	};
 }
-
 //#endregion
-export { path_default as default };
+export { path_default as default };

package/dist/{poll-CgzD9_RH.mjs → poll-75SvT7Zv.mjs}

@@ -1,28 +1,25 @@
-import { TimeoutError } from "./capabilities-CSjeWyLV.mjs";
-import { combineAborts, throwIfAborted } from "./runtime-MGH96fhp.mjs";
+import { l as TimeoutError } from "./predicates-Bkm2IoeX.mjs";
+import { n as throwIfAborted, t as combineAborts } from "./signal-CMd0EFUa.mjs";
 import { setTimeout } from "node:timers/promises";
-
-//#region src/runtime/poll.ts
+//#region ../client/src/poll.ts
 const DEFAULT_INTERVAL_MS = 2e3;
-const DEFAULT_MAX_INTERVAL_MS = 3e4;
 const DEFAULT_TIMEOUT_MS = 6e5;
 async function pollUntil(fn, done, opts = {}) {
-	const intervalMs = opts.intervalMs ?? DEFAULT_INTERVAL_MS;
-	const maxIntervalMs = opts.maxIntervalMs ?? DEFAULT_MAX_INTERVAL_MS;
-	const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+	const intervalMs = opts.intervalMs ?? 2e3;
+	const maxIntervalMs = opts.maxIntervalMs ?? 3e4;
+	const timeoutMs = opts.timeoutMs ?? 6e5;
 	const backoff = opts.backoff ?? "fixed";
-	const timeoutSignal = AbortSignal.timeout(timeoutMs);
-	const { combined, processSignal } = combineAborts(timeoutSignal, opts.signal);
+	const combined = combineAborts(AbortSignal.timeout(timeoutMs), opts.signal);
 	let interval = intervalMs;
 	let attempts = 0;
 	while (true) {
-		throwIfAborted(processSignal);
+		throwIfAborted(opts.signal);
 		if (combined.aborted) throw pollTimeout(timeoutMs, attempts);
 		let value;
 		try {
 			value = await fn(combined);
 		} catch (error) {
-			throwIfAborted(processSignal);
+			throwIfAborted(opts.signal);
 			if (combined.aborted) throw pollTimeout(timeoutMs, attempts);
 			throw error;
 		}
@@ -31,7 +28,7 @@ async function pollUntil(fn, done, opts = {}) {
 		try {
 			await setTimeout(interval, void 0, { signal: combined });
 		} catch (error) {
-			throwIfAborted(processSignal);
+			throwIfAborted(opts.signal);
 			if (combined.aborted) throw pollTimeout(timeoutMs, attempts);
 			throw error;
 		}
@@ -45,6 +42,5 @@ function pollTimeout(timeoutMs, attempts) {
 		attempts
 	});
 }
-
 //#endregion
-export { DEFAULT_INTERVAL_MS, DEFAULT_TIMEOUT_MS, pollUntil };
+export { DEFAULT_TIMEOUT_MS as n, pollUntil as r, DEFAULT_INTERVAL_MS as t };

package/dist/predicates-Bkm2IoeX.mjs

@@ -0,0 +1,170 @@
+import { ZodError, core } from "zod";
+//#region ../client/src/json-pointer.ts
+function escapeJsonPointerSegment(key) {
+	if (typeof key === "number") return String(key);
+	return (typeof key === "symbol" ? key.toString() : key).replaceAll("~", "~0").replaceAll("/", "~1");
+}
+//#endregion
+//#region ../client/src/errors.ts
+var MetabaseError = class extends Error {
+	get userMessage() {
+		return this.message;
+	}
+};
+var NetworkError = class extends MetabaseError {
+	category = "network";
+	isRetryable = true;
+	developerDetail;
+	constructor(message, developerDetail) {
+		super(message);
+		this.name = "NetworkError";
+		this.developerDetail = developerDetail;
+	}
+};
+var TimeoutError = class extends MetabaseError {
+	category = "timeout";
+	isRetryable = true;
+	developerDetail;
+	constructor(message, developerDetail) {
+		super(message);
+		this.name = "TimeoutError";
+		this.developerDetail = developerDetail;
+	}
+};
+var ValidationError = class extends MetabaseError {
+	category = "validation";
+	isRetryable = false;
+	developerDetail;
+	constructor(message, developerDetail) {
+		super(message);
+		this.name = "ValidationError";
+		this.developerDetail = developerDetail;
+	}
+	get userMessage() {
+		const issues = this.developerDetail.zodIssues;
+		if (issues.length === 0) return this.message;
+		return `${this.message}\n${formatIssueLines(issues, VALIDATION_ISSUE_FORMAT)}`;
+	}
+};
+const VALIDATION_MAX_ISSUES = 10;
+const RESPONSE_SHAPE_MAX_ISSUES = 5;
+const VALIDATION_ISSUE_FORMAT = {
+	max: VALIDATION_MAX_ISSUES,
+	formatIssue: (issue) => `${formatZodIssuePointer(issue.path)}: ${issue.message}`
+};
+const RESPONSE_SHAPE_ISSUE_FORMAT = {
+	max: RESPONSE_SHAPE_MAX_ISSUES,
+	formatIssue: formatZodIssue
+};
+function formatIssueLines(issues, format) {
+	const head = issues.slice(0, format.max).map(format.formatIssue);
+	const overflow = issues.length - format.max;
+	if (overflow > 0) head.push(`... and ${overflow} more`);
+	return head.map((line) => `  ${line}`).join("\n");
+}
+function formatZodIssuePointer(path) {
+	if (path.length === 0) return "/";
+	return path.map((key) => `/${escapeJsonPointerSegment(key)}`).join("");
+}
+const RESPONSE_SHAPE_LEAD_UNKNOWN_VERSION = "Metabase returned unexpected response shape";
+var ResponseShapeError = class ResponseShapeError extends MetabaseError {
+	category = "response-shape";
+	isRetryable = false;
+	developerDetail;
+	constructor(message, developerDetail) {
+		super(message);
+		this.name = "ResponseShapeError";
+		this.developerDetail = developerDetail;
+	}
+	static fromZodIssues(developerDetail) {
+		return new ResponseShapeError(formatResponseShapeMessage(developerDetail.zodIssues, developerDetail.serverTag), developerDetail);
+	}
+};
+function formatResponseShapeMessage(issues, serverTag) {
+	const lead = serverTag === null ? RESPONSE_SHAPE_LEAD_UNKNOWN_VERSION : `On Metabase ${serverTag} the response shape was unexpected`;
+	if (issues.length === 0) return lead;
+	return `${lead}:\n${formatIssueLines(issues, RESPONSE_SHAPE_ISSUE_FORMAT)}`;
+}
+var ConfigError = class extends MetabaseError {
+	category = "config";
+	isRetryable = false;
+	developerDetail = null;
+	constructor(message) {
+		super(message);
+		this.name = "ConfigError";
+	}
+};
+var InternalError = class extends MetabaseError {
+	category = "internal";
+	isRetryable = false;
+	developerDetail = null;
+	constructor(message) {
+		super(message);
+		this.name = "InternalError";
+	}
+};
+var AbortError = class extends MetabaseError {
+	category = "abort";
+	isRetryable = false;
+	developerDetail = null;
+	constructor(message = "aborted") {
+		super(message);
+		this.name = "AbortError";
+	}
+};
+var ChainedRequestError = class extends MetabaseError {
+	cause;
+	constructor(message, cause) {
+		super(message);
+		this.name = "ChainedRequestError";
+		this.cause = cause;
+	}
+	get category() {
+		return this.cause.category;
+	}
+	get isRetryable() {
+		return this.cause.isRetryable;
+	}
+	get developerDetail() {
+		return this.cause.developerDetail;
+	}
+};
+var UnknownError = class extends MetabaseError {
+	category = "unknown";
+	isRetryable = false;
+	developerDetail;
+	constructor(input) {
+		super(input.originalMessage);
+		this.name = "UnknownError";
+		this.developerDetail = input;
+	}
+};
+function toMetabaseError(error) {
+	if (error instanceof MetabaseError) return error;
+	if (error instanceof ZodError) return new ConfigError(error.issues.map(formatZodIssue).join("; "));
+	if (error instanceof Error) return new UnknownError({
+		originalMessage: error.message,
+		stack: error.stack ?? null
+	});
+	return new UnknownError({
+		originalMessage: String(error),
+		stack: null
+	});
+}
+function formatZodIssue(issue) {
+	const path = core.toDotPath(issue.path);
+	return path === "" ? issue.message : `${path}: ${issue.message}`;
+}
+function isFileNotFoundError(value) {
+	return value instanceof Error && "code" in value && value.code === "ENOENT";
+}
+function errorMessage(value) {
+	return value instanceof Error ? value.message : String(value);
+}
+//#endregion
+//#region ../client/src/predicates.ts
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+export { InternalError as a, ResponseShapeError as c, ValidationError as d, errorMessage as f, escapeJsonPointerSegment as h, ConfigError as i, TimeoutError as l, toMetabaseError as m, AbortError as n, MetabaseError as o, isFileNotFoundError as p, ChainedRequestError as r, NetworkError as s, isPlainObject as t, UnknownError as u };

package/dist/preflight-YpPQo-sa.mjs

@@ -0,0 +1,29 @@
+import { i as ConfigError, o as MetabaseError } from "./predicates-Bkm2IoeX.mjs";
+import { l as writeJson } from "./cli.mjs";
+import { i as chainRequestFailure } from "./network-error-CEb9ymDW.mjs";
+import "./validate-BWchyW0V.mjs";
+//#region src/commands/dashboard/preflight.ts
+async function preflightDashcardCardReferences(client, dashcards) {
+	const issues = await client.dashboard.checkCardReferences(dashcards);
+	if (issues.length === 0) return;
+	const errors = issues.map((issue) => ({
+		path: issue.path,
+		message: describeIssue(issue)
+	}));
+	writeJson({
+		ok: false,
+		errors
+	});
+	throw new ConfigError(`dashboard card-reference pre-flight failed: ${errors.length} error(s) — fix the dashcard card_id values listed above`);
+}
+function wrapChainedDashboardWriteError(error, dashboardId) {
+	if (!(error instanceof MetabaseError)) return error;
+	return chainRequestFailure(error, `${`dashboard ${dashboardId} created but the follow-up update to dashboard ${dashboardId} failed`}: ${error.userMessage}; dashcards not applied`);
+}
+function describeIssue(issue) {
+	if (issue.problem.reason === "missing") return `card ${issue.cardId} not found`;
+	if (issue.problem.reason === "archived") return `card ${issue.cardId} is archived`;
+	return `card ${issue.cardId} is not readable: ${issue.problem.detail}`;
+}
+//#endregion
+export { wrapChainedDashboardWriteError as n, preflightDashcardCardReferences as t };

package/dist/{process-jjR_DX5G.mjs → process-DBOOrmET.mjs}

@@ -1,6 +1,5 @@
-import { isNotFoundError } from "./capabilities-CSjeWyLV.mjs";
+import { p as isFileNotFoundError } from "./predicates-Bkm2IoeX.mjs";
 import { spawn } from "node:child_process";
-
 //#region src/runtime/process.ts
 var ProcessNotFoundError = class extends Error {
 	command;
@@ -10,7 +9,7 @@ var ProcessNotFoundError = class extends Error {
 		this.command = command;
 	}
 };
-const stdoutDecoder = new TextDecoder("utf-8");
+new TextDecoder("utf-8");
 function streamProcess(command, args, options = {}) {
 	return new Promise((resolve, reject) => {
 		const child = spawn(command, args, {
@@ -18,7 +17,7 @@ function streamProcess(command, args, options = {}) {
 			...options.shell === true ? { shell: true } : {}
 		});
 		child.on("error", (error) => {
-			if (isNotFoundError(error)) {
+			if (isFileNotFoundError(error)) {
 				reject(new ProcessNotFoundError(command));
 				return;
 			}
@@ -68,6 +67,5 @@ function openBrowser(url) {
 		});
 	});
 }
-
 //#endregion
-export { openBrowser, streamProcess };
+export { streamProcess as n, openBrowser as t };

package/dist/{publish-F-QbufXr.mjs → publish-DijrxaCW.mjs}

@@ -1,22 +1,31 @@
-import { connectionFlags, outputFlags, profileFlag, renderSummary } from "./capabilities-CSjeWyLV.mjs";
-import "./command-augment-D9pI9Vbh.mjs";
-import { defineMetabaseCommand } from "./runtime-MGH96fhp.mjs";
-import "./parse-id-ySsF4nA3.mjs";
-import { Collection, CollectionCompact } from "./collection-C52Ndi_O.mjs";
-import "./listing-wFZuS5li.mjs";
-import "./poll-CgzD9_RH.mjs";
-import "./poll-task-DF9xJl13.mjs";
-import { warnIfOutsideSyncScope } from "./sync-scope-CKx6xeF6.mjs";
-import { ensureLibraryDataCollectionId } from "./resolve-8iT-dXgX.mjs";
-import { parseTableSelectors, tableSelectorFlags } from "./selectors-D34gXjQa.mjs";
+import { f as errorMessage } from "./predicates-Bkm2IoeX.mjs";
+import { F as outputFlags, I as profileFlag, M as connectionFlags, b as warn, c as renderSummary } from "./cli.mjs";
+import { t as defineMetabaseCommand } from "./runtime-DiKyBxOw.mjs";
+import { i as CollectionCompact, r as Collection } from "./collection-CfulNRBG.mjs";
+import { n as tableSelectorFlags, t as parseTableSelectors } from "./selectors-DGDn0Hto.mjs";
 import { z } from "zod";
-
+//#region src/commands/git-sync/sync-scope.ts
+function isOutsideSyncScope(collection) {
+	return collection !== null && collection.is_remote_synced === false;
+}
+function syncScopeHint(collection, remoteSyncUrl) {
+	if (!isOutsideSyncScope(collection) || remoteSyncUrl === null) return null;
+	return `Note: collection ${collection.id} "${collection.name}" is not marked for git-sync, so \`mb git-sync export\` will not carry it (or its published tables' metadata) to ${remoteSyncUrl}. Add it with: mb git-sync add-collection ${collection.id}`;
+}
+async function warnIfOutsideSyncScope(mb, collection) {
+	if (!isOutsideSyncScope(collection)) return;
+	try {
+		const hint = syncScopeHint(collection, await mb.gitSync.remoteUrl());
+		if (hint !== null) warn(hint);
+	} catch (error) {
+		warn(`Could not check git-sync scope for collection ${collection.id}: ${errorMessage(error)}`);
+	}
+}
+//#endregion
 //#region src/commands/library/publish.ts
-const PUBLISH_TABLES_PATH = "/api/ee/data-studio/table/publish-tables";
 const LibraryPublishResult = z.object({ target_collection: Collection.nullable() });
-const LibraryPublishResultCompact = z.object({ target_collection: CollectionCompact.nullable() });
 const libraryPublishResultView = {
-	compactPick: LibraryPublishResultCompact,
+	compactPick: z.object({ target_collection: CollectionCompact.nullable() }),
 	tableColumns: [{
 		key: "target_collection",
 		label: "Target collection"
@@ -47,17 +56,14 @@ var publish_default = defineMetabaseCommand({
 	async run({ args, ctx, getClient }) {
 		const selectors = parseTableSelectors(args);
 		const client = await getClient();
-		const collectionId = await ensureLibraryDataCollectionId(client);
-		const body = {
+		const collectionId = await client.library.ensureDataCollectionId();
+		const target = await client.library.publishTables({
 			collection_id: collectionId,
 			...selectors
-		};
-		const result = await client.requestParsed(LibraryPublishResult, PUBLISH_TABLES_PATH, {
-			method: "POST",
-			body
 		});
+		const result = { target_collection: target };
 		renderSummary(result, libraryPublishResultView, summaryLine(result), ctx);
-		await warnIfOutsideSyncScope(client, result.target_collection);
+		await warnIfOutsideSyncScope(client, target);
 	}
 });
 function summaryLine(result) {
@@ -65,6 +71,5 @@ function summaryLine(result) {
 	if (collection === null) return "Published tables to the Library.";
 	return `Published tables to the Library (collection ${collection.id} "${collection.name}").`;
 }
-
 //#endregion
-export { publish_default as default };
+export { publish_default as default };

package/dist/pulse-BmsDenXm.mjs

@@ -0,0 +1,133 @@
+import { t as Parameter } from "./parameter-DUKR8NXo.mjs";
+import { z } from "zod";
+//#region ../client/src/domain/pulse.ts
+const PulseChannelType = z.enum([
+	"email",
+	"slack",
+	"http"
+]);
+const PulseScheduleType = z.enum([
+	"hourly",
+	"daily",
+	"weekly",
+	"monthly"
+]);
+const PulseScheduleDay = z.enum([
+	"mon",
+	"tue",
+	"wed",
+	"thu",
+	"fri",
+	"sat",
+	"sun"
+]);
+const PulseScheduleFrame = z.enum([
+	"first",
+	"mid",
+	"last"
+]);
+const PulseChannelDetails = z.object({ channel: z.string().optional() }).loose();
+const PulseRecipient = z.object({
+	id: z.number().int().nullable().optional(),
+	email: z.string()
+}).loose();
+const PulseRecipientCompact = PulseRecipient.pick({
+	id: true,
+	email: true
+}).strip();
+const PulseChannel = z.object({
+	id: z.number().int().optional(),
+	channel_type: PulseChannelType,
+	channel_id: z.number().int().nullable().optional(),
+	enabled: z.boolean(),
+	schedule_type: PulseScheduleType,
+	schedule_hour: z.number().int().nullable(),
+	schedule_day: PulseScheduleDay.nullable(),
+	schedule_frame: PulseScheduleFrame.nullable(),
+	details: PulseChannelDetails.optional(),
+	recipients: z.array(PulseRecipient)
+}).loose();
+const PulseChannelCompact = PulseChannel.pick({
+	channel_type: true,
+	enabled: true,
+	schedule_type: true,
+	schedule_hour: true,
+	schedule_day: true,
+	schedule_frame: true,
+	details: true
+}).strip().extend({ recipients: z.array(PulseRecipientCompact) });
+const PulseCard = z.object({
+	id: z.number().int(),
+	name: z.string(),
+	dashboard_card_id: z.number().int().nullable(),
+	include_csv: z.boolean(),
+	include_xls: z.boolean()
+}).loose();
+const PulseCardCompact = PulseCard.pick({
+	id: true,
+	name: true,
+	dashboard_card_id: true,
+	include_csv: true,
+	include_xls: true
+}).strip();
+const Pulse = z.object({
+	id: z.number().int(),
+	name: z.string().nullable(),
+	creator_id: z.number().int(),
+	dashboard_id: z.number().int().nullable(),
+	collection_id: z.number().int().nullable(),
+	archived: z.boolean(),
+	skip_if_empty: z.boolean(),
+	parameters: z.array(Parameter),
+	cards: z.array(PulseCard),
+	channels: z.array(PulseChannel)
+}).loose();
+const PulseCompact = Pulse.pick({
+	id: true,
+	name: true,
+	dashboard_id: true,
+	collection_id: true,
+	archived: true,
+	skip_if_empty: true
+}).strip().extend({
+	cards: z.array(PulseCardCompact),
+	channels: z.array(PulseChannelCompact)
+});
+const PulseRecipientInput = z.union([z.object({ id: z.number().int().positive() }).loose(), z.object({ email: z.string().min(1) }).loose()]);
+const PulseCardInput = z.object({
+	id: z.number().int().positive(),
+	include_csv: z.boolean(),
+	include_xls: z.boolean(),
+	dashboard_card_id: z.number().int().positive().nullable().optional(),
+	format_rows: z.boolean().optional(),
+	pivot_results: z.boolean().optional()
+}).loose();
+const PulseChannelInput = z.object({
+	channel_type: PulseChannelType,
+	enabled: z.boolean().default(true),
+	schedule_type: PulseScheduleType,
+	schedule_hour: z.number().int().min(0).max(23).nullable().optional(),
+	schedule_day: PulseScheduleDay.nullable().optional(),
+	schedule_frame: PulseScheduleFrame.nullable().optional(),
+	channel_id: z.number().int().positive().nullable().optional(),
+	details: PulseChannelDetails.optional(),
+	recipients: z.array(PulseRecipientInput).optional()
+}).loose();
+const PulseCreateInput = z.object({
+	name: z.string().min(1),
+	dashboard_id: z.number().int().positive(),
+	cards: z.array(PulseCardInput).min(1),
+	channels: z.array(PulseChannelInput).min(1),
+	skip_if_empty: z.boolean().optional(),
+	parameters: z.array(Parameter).optional()
+}).loose();
+const PulseUpdateInput = z.object({
+	name: z.string().min(1).optional(),
+	cards: z.array(PulseCardInput).min(1).optional(),
+	channels: z.array(PulseChannelInput).min(1).optional(),
+	skip_if_empty: z.boolean().optional(),
+	archived: z.boolean().optional(),
+	parameters: z.array(Parameter).optional()
+}).loose();
+//#endregion
+export { PulseUpdateInput as a, PulseCreateInput as i, PulseChannel as n, PulseCompact as r, Pulse as t };