@metabase/client 0.0.0-stage → 0.1.1

package/dist/domain/metric.js

@@ -0,0 +1,139 @@
+import { FieldBaseType, FieldSemanticType } from "./field.js";
+import { TemporalUnit } from "./parameter.js";
+import { z } from "zod";
+//#region src/domain/metric.ts
+const ClauseOptions = z.object({}).loose();
+const MetricLeafType = z.enum(["metric", "measure"]);
+const MetricLeafRef = z.tuple([
+	MetricLeafType,
+	z.object({ "lib/uuid": z.string().min(1) }).strict(),
+	z.number().int().positive()
+]);
+const MetricMathOperator = z.enum([
+	"+",
+	"-",
+	"*",
+	"/"
+]);
+const MetricMathExpression = z.lazy(() => z.union([
+	MetricLeafRef,
+	z.number(),
+	z.tuple([
+		MetricMathOperator,
+		ClauseOptions,
+		MetricMathExpression,
+		MetricMathExpression
+	]).rest(MetricMathExpression)
+]));
+const MetricBinning = z.discriminatedUnion("strategy", [
+	z.object({ strategy: z.literal("default") }).strict(),
+	z.object({
+		strategy: z.literal("bin-width"),
+		"bin-width": z.number().positive()
+	}).strict(),
+	z.object({
+		strategy: z.literal("num-bins"),
+		"num-bins": z.number().int().positive()
+	}).strict()
+]);
+const MetricDimensionRefOptions = z.object({
+	"lib/uuid": z.string().min(1).optional(),
+	"display-name": z.string().min(1).nullable().optional(),
+	"effective-type": FieldBaseType.nullable().optional(),
+	"semantic-type": FieldSemanticType.nullable().optional(),
+	"temporal-unit": TemporalUnit.nullable().optional(),
+	binning: MetricBinning.nullable().optional()
+}).strict();
+const MetricDimensionRef = z.tuple([
+	z.literal("dimension"),
+	MetricDimensionRefOptions,
+	z.string().min(1)
+]);
+const MetricFilterArgument = z.lazy(() => z.union([
+	MetricDimensionRef,
+	MetricFilterClause,
+	z.string(),
+	z.number(),
+	z.boolean(),
+	z.null()
+]));
+const MetricFilterClause = z.lazy(() => z.tuple([z.string().min(1), ClauseOptions]).rest(MetricFilterArgument));
+const MetricInstanceFilter = z.object({
+	"lib/uuid": z.string().min(1),
+	filter: MetricFilterClause
+}).strict();
+const MetricProjection = z.object({
+	type: MetricLeafType,
+	id: z.number().int().positive(),
+	"lib/uuid": z.string().min(1),
+	projection: z.array(MetricDimensionRef)
+}).strict();
+const MetricDefinition = z.object({
+	expression: MetricMathExpression,
+	filters: z.array(MetricInstanceFilter).nullable().optional(),
+	projections: z.array(MetricProjection).nullable().optional()
+}).strict();
+const MetricBreakoutColumn = z.object({
+	name: z.string().optional(),
+	display_name: z.string().optional(),
+	base_type: FieldBaseType.optional(),
+	effective_type: FieldBaseType.optional(),
+	semantic_type: FieldSemanticType.nullable().optional()
+}).loose();
+const MetricBreakoutValues = z.object({
+	values: z.array(z.unknown()),
+	col: MetricBreakoutColumn
+}).loose();
+const MetricDimensionStatus = z.enum(["status/active", "status/orphaned"]);
+const MetricDimensionSource = z.object({
+	type: z.literal("field"),
+	"field-id": z.number().int().nullable()
+}).loose();
+const MetricDimensionGroup = z.object({
+	id: z.string(),
+	type: z.enum(["main", "connection"]),
+	display_name: z.string()
+}).loose();
+const MetricDimension = z.object({
+	id: z.string(),
+	name: z.string().nullable(),
+	display_name: z.string().nullable(),
+	description: z.string().nullable().optional(),
+	effective_type: FieldBaseType.nullable(),
+	semantic_type: FieldSemanticType.nullable(),
+	has_field_values: z.enum([
+		"list",
+		"search",
+		"none"
+	]).optional(),
+	status: MetricDimensionStatus.optional(),
+	status_message: z.string().optional(),
+	sources: z.array(MetricDimensionSource).optional(),
+	group: MetricDimensionGroup.optional(),
+	dimension_interestingness: z.number().optional(),
+	default_temporal_unit: TemporalUnit.optional(),
+	default: z.boolean().nullable().optional()
+}).loose();
+const MetricDimensionCompact = MetricDimension.pick({
+	id: true,
+	name: true,
+	display_name: true,
+	description: true,
+	effective_type: true,
+	semantic_type: true,
+	status: true,
+	group: true,
+	default: true
+}).strip();
+const MetricMappingTarget = z.tuple([z.string(), ClauseOptions]).rest(z.unknown());
+const MetricAddableDimension = MetricDimension.extend({ mapping_target: MetricMappingTarget });
+const MetricAddableGroup = z.object({
+	group: MetricDimensionGroup.nullable(),
+	dimensions: z.array(MetricAddableDimension)
+}).loose();
+const MetricDimensionListing = z.object({
+	added: z.array(MetricDimension),
+	addable: z.array(MetricAddableGroup)
+}).loose();
+//#endregion
+export { MetricAddableDimension, MetricAddableGroup, MetricBinning, MetricBreakoutColumn, MetricBreakoutValues, MetricDefinition, MetricDimension, MetricDimensionCompact, MetricDimensionGroup, MetricDimensionListing, MetricDimensionRef, MetricDimensionRefOptions, MetricDimensionSource, MetricDimensionStatus, MetricFilterClause, MetricInstanceFilter, MetricLeafRef, MetricLeafType, MetricMappingTarget, MetricMathExpression, MetricMathOperator, MetricProjection };

package/dist/domain/moderation-review.d.ts

@@ -0,0 +1,2 @@
+import { a as ModerationStatus, i as ModerationReviewCreateInput, n as ModerationReview, r as ModerationReviewCompact, t as ModeratedItemType } from "../moderation-review-B4RUTZ6_.js";
+export { ModeratedItemType, ModerationReview, ModerationReviewCompact, ModerationReviewCreateInput, ModerationStatus };

package/dist/domain/moderation-review.js

@@ -0,0 +1,31 @@
+import { z } from "zod";
+//#region src/domain/moderation-review.ts
+const ModeratedItemType = z.enum(["card", "dashboard"]);
+const ModerationStatus = z.enum(["verified"]);
+const ModerationReview = z.object({
+	id: z.number().int(),
+	moderated_item_id: z.number().int(),
+	moderated_item_type: ModeratedItemType,
+	moderator_id: z.number().int(),
+	status: ModerationStatus.nullable(),
+	text: z.string().nullable(),
+	most_recent: z.boolean(),
+	created_at: z.string(),
+	updated_at: z.string()
+}).loose();
+const ModerationReviewCompact = ModerationReview.pick({
+	id: true,
+	moderated_item_id: true,
+	moderated_item_type: true,
+	status: true,
+	text: true,
+	most_recent: true
+}).strip();
+const ModerationReviewCreateInput = z.object({
+	moderated_item_id: z.number().int().positive(),
+	moderated_item_type: ModeratedItemType,
+	status: ModerationStatus.nullable().optional(),
+	text: z.string().nullable().optional()
+}).strict();
+//#endregion
+export { ModeratedItemType, ModerationReview, ModerationReviewCompact, ModerationReviewCreateInput, ModerationStatus };

package/dist/domain/notification.d.ts

@@ -0,0 +1,2 @@
+import { _ as NotificationSendCondition, a as NotificationCardPayloadCompact, b as NotificationSubscriptionType, c as NotificationCompact, d as NotificationHandlerCompact, f as NotificationPayloadType, g as NotificationRecipientType, h as NotificationRecipientDetails, i as NotificationCardPayload, l as NotificationCreateInput, m as NotificationRecipientCompact, n as CARD_PAYLOAD_TYPE, o as NotificationCardPayloadPatch, p as NotificationRecipient, r as Notification, s as NotificationChannelType, t as AnyNotification, u as NotificationHandler, v as NotificationSubscription, x as NotificationUpdateInput, y as NotificationSubscriptionCompact } from "../notification-D1MThyKE.js";
+export { AnyNotification, CARD_PAYLOAD_TYPE, Notification, NotificationCardPayload, NotificationCardPayloadCompact, NotificationCardPayloadPatch, NotificationChannelType, NotificationCompact, NotificationCreateInput, NotificationHandler, NotificationHandlerCompact, NotificationPayloadType, NotificationRecipient, NotificationRecipientCompact, NotificationRecipientDetails, NotificationRecipientType, NotificationSendCondition, NotificationSubscription, NotificationSubscriptionCompact, NotificationSubscriptionType, NotificationUpdateInput };

package/dist/domain/notification.js

@@ -0,0 +1,143 @@
+import { CronUiDisplayType } from "./cron.js";
+import { z } from "zod";
+//#region src/domain/notification.ts
+const NotificationPayloadType = z.enum([
+	"notification/card",
+	"notification/dashboard",
+	"notification/system-event",
+	"notification/testing"
+]);
+const CARD_PAYLOAD_TYPE = "notification/card";
+const NotificationSendCondition = z.enum([
+	"has_result",
+	"goal_above",
+	"goal_below"
+]);
+const NotificationChannelType = z.enum([
+	"channel/email",
+	"channel/slack",
+	"channel/http"
+]);
+const NotificationRecipientType = z.enum([
+	"notification-recipient/user",
+	"notification-recipient/group",
+	"notification-recipient/raw-value",
+	"notification-recipient/template"
+]);
+const NotificationSubscriptionType = z.enum(["notification-subscription/cron", "notification-subscription/system-event"]);
+const NotificationRecipientDetails = z.object({
+	value: z.string().optional(),
+	channel_id: z.string().nullable().optional()
+}).loose();
+const NotificationRecipientDetailsCompact = NotificationRecipientDetails.pick({
+	value: true,
+	channel_id: true
+}).strip();
+const NotificationRecipient = z.object({
+	id: z.number().int().optional(),
+	type: NotificationRecipientType,
+	user_id: z.number().int().nullable().optional(),
+	permissions_group_id: z.number().int().nullable().optional(),
+	details: NotificationRecipientDetails.nullable().optional()
+}).loose();
+const NotificationRecipientCompact = NotificationRecipient.pick({
+	type: true,
+	user_id: true,
+	permissions_group_id: true
+}).strip().extend({ details: NotificationRecipientDetailsCompact.nullable().optional() });
+const NotificationHandler = z.object({
+	id: z.number().int().optional(),
+	channel_type: NotificationChannelType,
+	channel_id: z.number().int().nullable().optional(),
+	template_id: z.number().int().nullable().optional(),
+	active: z.boolean().optional(),
+	recipients: z.array(NotificationRecipient).optional()
+}).loose();
+const NotificationHandlerCompact = NotificationHandler.pick({
+	channel_type: true,
+	channel_id: true
+}).strip().extend({ recipients: z.array(NotificationRecipientCompact).optional() });
+const NotificationSubscription = z.object({
+	id: z.number().int().optional(),
+	type: NotificationSubscriptionType,
+	cron_schedule: z.string().nullable().optional(),
+	event_name: z.string().nullable().optional(),
+	ui_display_type: CronUiDisplayType.nullable().optional()
+}).loose();
+const NotificationSubscriptionCompact = NotificationSubscription.pick({
+	type: true,
+	cron_schedule: true
+}).strip();
+const NotificationCardPayload = z.object({
+	id: z.number().int().optional(),
+	card_id: z.number().int(),
+	send_condition: NotificationSendCondition,
+	send_once: z.boolean()
+}).loose();
+const NotificationCardPayloadCompact = NotificationCardPayload.pick({
+	card_id: true,
+	send_condition: true,
+	send_once: true
+}).strip();
+const Notification = z.object({
+	id: z.number().int(),
+	payload_type: NotificationPayloadType,
+	payload_id: z.number().int().nullable(),
+	payload: NotificationCardPayload.nullable(),
+	active: z.boolean(),
+	creator_id: z.number().int().nullable(),
+	subscriptions: z.array(NotificationSubscription),
+	handlers: z.array(NotificationHandler)
+}).loose();
+const NotificationOfOtherType = z.object({
+	id: z.number().int(),
+	payload_type: NotificationPayloadType.exclude([CARD_PAYLOAD_TYPE])
+}).loose();
+const AnyNotification = z.discriminatedUnion("payload_type", [Notification.extend({ payload_type: z.literal(CARD_PAYLOAD_TYPE) }), NotificationOfOtherType]);
+const NotificationCompact = Notification.pick({
+	id: true,
+	payload_type: true,
+	active: true,
+	creator_id: true
+}).strip().extend({
+	payload: NotificationCardPayloadCompact.nullable(),
+	subscriptions: z.array(NotificationSubscriptionCompact),
+	handlers: z.array(NotificationHandlerCompact)
+});
+const NotificationRecipientInput = z.object({
+	type: NotificationRecipientType,
+	user_id: z.number().int().positive().optional(),
+	permissions_group_id: z.number().int().positive().optional(),
+	details: NotificationRecipientDetails.optional()
+}).loose();
+const NotificationHandlerInput = z.object({
+	channel_type: NotificationChannelType,
+	channel_id: z.number().int().positive().nullable().optional(),
+	active: z.boolean().optional(),
+	recipients: z.array(NotificationRecipientInput).optional()
+}).loose();
+const NotificationSubscriptionInput = z.object({
+	type: NotificationSubscriptionType.default("notification-subscription/cron"),
+	cron_schedule: z.string().min(1)
+}).loose();
+const NotificationCardPayloadInput = z.object({
+	card_id: z.number().int().positive(),
+	send_condition: NotificationSendCondition.optional(),
+	send_once: z.boolean().optional()
+}).loose();
+const NotificationCreateInput = z.object({
+	payload_type: NotificationPayloadType.default(CARD_PAYLOAD_TYPE),
+	payload: NotificationCardPayloadInput,
+	subscriptions: z.array(NotificationSubscriptionInput).min(1),
+	handlers: z.array(NotificationHandlerInput).min(1),
+	active: z.boolean().optional()
+}).loose();
+const NotificationCardPayloadPatch = NotificationCardPayloadInput.partial();
+const NotificationUpdateInput = z.object({
+	payload: NotificationCardPayloadPatch.optional(),
+	subscriptions: z.array(NotificationSubscriptionInput).min(1).optional(),
+	handlers: z.array(NotificationHandlerInput).min(1).optional(),
+	active: z.boolean().optional()
+}).loose();
+//#endregion
+export { AnyNotification, CARD_PAYLOAD_TYPE, Notification, NotificationCardPayload, NotificationCardPayloadCompact, NotificationCardPayloadPatch, NotificationChannelType, NotificationCompact, NotificationCreateInput, NotificationHandler, NotificationHandlerCompact, NotificationPayloadType, NotificationRecipient, NotificationRecipientCompact, NotificationRecipientDetails, NotificationRecipientType, NotificationSendCondition, NotificationSubscription, NotificationSubscriptionCompact, NotificationSubscriptionType, NotificationUpdateInput };

package/dist/domain/parameter.d.ts

@@ -0,0 +1,2 @@
+import { a as ParameterTextTagTarget, c as ParameterValuesCompact, d as ValuesSourceConfig, f as ValuesSourceType, i as ParameterTemplateTagRef, l as TemporalUnit, n as ParameterMapping, o as ParameterType, r as ParameterTarget, s as ParameterValues, t as Parameter, u as ValuesQueryType } from "../parameter-ak-J-IOj.js";
+export { Parameter, ParameterMapping, ParameterTarget, ParameterTemplateTagRef, ParameterTextTagTarget, ParameterType, ParameterValues, ParameterValuesCompact, TemporalUnit, ValuesQueryType, ValuesSourceConfig, ValuesSourceType };

package/dist/domain/parameter.js

@@ -0,0 +1,109 @@
+import { z } from "zod";
+//#region src/domain/parameter.ts
+const ParameterType = z.enum([
+	"number",
+	"text",
+	"date",
+	"boolean",
+	"date/single",
+	"id",
+	"category",
+	"location/city",
+	"location/state",
+	"location/zip_code",
+	"location/country",
+	"date/range",
+	"date/month-year",
+	"date/quarter-year",
+	"date/relative",
+	"date/all-options",
+	"temporal-unit",
+	"number/!=",
+	"number/<=",
+	"number/=",
+	"number/>=",
+	"number/between",
+	"string/!=",
+	"string/=",
+	"string/contains",
+	"string/does-not-contain",
+	"string/ends-with",
+	"string/starts-with",
+	"boolean/="
+]);
+const TemporalUnit = z.enum([
+	"millisecond",
+	"second",
+	"minute",
+	"hour",
+	"day",
+	"week",
+	"month",
+	"quarter",
+	"year",
+	"second-of-minute",
+	"minute-of-hour",
+	"hour-of-day",
+	"day-of-week",
+	"day-of-month",
+	"day-of-year",
+	"week-of-year",
+	"month-of-year",
+	"quarter-of-year",
+	"year-of-era",
+	"default"
+]);
+const ValuesSourceType = z.enum(["static-list", "card"]);
+const ValuesQueryType = z.enum([
+	"list",
+	"search",
+	"none"
+]);
+const ParameterTemplateTagRef = z.tuple([z.literal("template-tag"), z.union([z.string(), z.object({ id: z.string() }).loose()])]);
+const FieldRefLike = z.tuple([z.string()]).rest(z.unknown());
+const DimensionTarget = z.tuple([z.literal("dimension"), z.union([ParameterTemplateTagRef, FieldRefLike])]).rest(z.unknown());
+const VariableTarget = z.tuple([z.literal("variable"), z.union([ParameterTemplateTagRef, FieldRefLike])]);
+const ParameterTextTagTarget = z.tuple([z.literal("text-tag"), z.string()]);
+const ParameterTarget = z.union([
+	DimensionTarget,
+	VariableTarget,
+	ParameterTextTagTarget,
+	z.number().int(),
+	FieldRefLike
+]);
+const ValuesSourceConfig = z.object({
+	values: z.array(z.unknown()).optional(),
+	card_id: z.number().int().optional(),
+	value_field: FieldRefLike.optional(),
+	label_field: FieldRefLike.optional()
+}).loose();
+const Parameter = z.object({
+	id: z.string(),
+	type: ParameterType,
+	name: z.string().optional(),
+	slug: z.string().optional(),
+	sectionId: z.string().optional(),
+	default: z.unknown().optional(),
+	required: z.boolean().nullable().optional(),
+	filteringParameters: z.array(z.string()).nullable().optional(),
+	target: ParameterTarget.optional(),
+	temporal_units: z.array(TemporalUnit).nullable().optional(),
+	values_query_type: ValuesQueryType.nullable().optional(),
+	values_source_type: ValuesSourceType.nullable().optional(),
+	values_source_config: ValuesSourceConfig.nullable().optional()
+}).loose();
+const ParameterMapping = z.object({
+	parameter_id: z.string(),
+	target: ParameterTarget,
+	card_id: z.number().int().nullable().optional()
+}).loose();
+const ParameterValues = z.object({
+	values: z.array(z.array(z.unknown())),
+	has_more_values: z.boolean()
+}).loose();
+const ParameterValuesCompact = ParameterValues.pick({
+	values: true,
+	has_more_values: true
+}).strip();
+//#endregion
+export { Parameter, ParameterMapping, ParameterTarget, ParameterTemplateTagRef, ParameterTextTagTarget, ParameterType, ParameterValues, ParameterValuesCompact, TemporalUnit, ValuesQueryType, ValuesSourceConfig, ValuesSourceType };

package/dist/domain/permission.d.ts

@@ -0,0 +1,2 @@
+import { a as PermissionsGraph, i as DownloadPermission, n as DataModelPermission, o as ViewDataPermission, r as DatabasePermissions, s as YesNoPermission, t as CreateQueriesPermission } from "../permission-BnCQw5Kp.js";
+export { CreateQueriesPermission, DataModelPermission, DatabasePermissions, DownloadPermission, PermissionsGraph, ViewDataPermission, YesNoPermission };

package/dist/domain/permission.js

@@ -0,0 +1,36 @@
+import { z } from "zod";
+//#region src/domain/permission.ts
+const ViewDataPermission = z.enum([
+	"unrestricted",
+	"legacy-no-self-service",
+	"blocked",
+	"sandboxed",
+	"impersonated"
+]);
+const CreateQueriesPermission = z.enum([
+	"query-builder-and-native",
+	"query-builder",
+	"no"
+]);
+const DownloadPermission = z.enum(["full", "limited"]);
+const DataModelPermission = z.literal("all");
+const YesNoPermission = z.enum(["yes", "no"]);
+function granular(value) {
+	const perTable = z.record(z.string(), value);
+	const perSchema = z.record(z.string(), z.union([value, perTable]));
+	return z.union([value, perSchema]);
+}
+const DatabasePermissions = z.object({
+	"view-data": granular(ViewDataPermission).optional(),
+	"create-queries": granular(CreateQueriesPermission).optional(),
+	download: z.object({ schemas: granular(DownloadPermission) }).loose().optional(),
+	"data-model": z.object({ schemas: granular(DataModelPermission) }).loose().optional(),
+	details: YesNoPermission.optional(),
+	transforms: YesNoPermission.optional()
+}).loose();
+const PermissionsGraph = z.object({
+	revision: z.number().int().nonnegative(),
+	groups: z.record(z.string(), z.record(z.string(), DatabasePermissions))
+}).loose();
+//#endregion
+export { CreateQueriesPermission, DataModelPermission, DatabasePermissions, DownloadPermission, PermissionsGraph, ViewDataPermission, YesNoPermission };

package/dist/domain/pulse.d.ts

@@ -0,0 +1,2 @@
+import { a as PulseChannelCompact, c as PulseCompact, d as PulseRecipientCompact, f as PulseScheduleDay, g as SUBSCRIPTION_FILTERS_GATE, h as PulseUpdateInput, i as PulseChannel, l as PulseCreateInput, m as PulseScheduleType, n as PulseCard, o as PulseChannelDetails, p as PulseScheduleFrame, r as PulseCardCompact, s as PulseChannelType, t as Pulse, u as PulseRecipient } from "../pulse-0LG3K6qO.js";
+export { Pulse, PulseCard, PulseCardCompact, PulseChannel, PulseChannelCompact, PulseChannelDetails, PulseChannelType, PulseCompact, PulseCreateInput, PulseRecipient, PulseRecipientCompact, PulseScheduleDay, PulseScheduleFrame, PulseScheduleType, PulseUpdateInput, SUBSCRIPTION_FILTERS_GATE };

package/dist/domain/pulse.js

@@ -0,0 +1,140 @@
+import { t as gateInput } from "../input-gate-registry-Dai7SfXb.js";
+import { Parameter } from "./parameter.js";
+import { z } from "zod";
+//#region 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 SUBSCRIPTION_FILTERS_GATE = {
+	feature: "dashboardSubscriptionFilters",
+	effect: "needs",
+	when: { kind: "nonEmpty" }
+};
+const PulseParametersInput = gateInput(z.array(Parameter).optional(), SUBSCRIPTION_FILTERS_GATE);
+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: PulseParametersInput
+}).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: PulseParametersInput
+}).loose();
+//#endregion
+export { Pulse, PulseCard, PulseCardCompact, PulseChannel, PulseChannelCompact, PulseChannelDetails, PulseChannelType, PulseCompact, PulseCreateInput, PulseRecipient, PulseRecipientCompact, PulseScheduleDay, PulseScheduleFrame, PulseScheduleType, PulseUpdateInput, SUBSCRIPTION_FILTERS_GATE };

package/dist/domain/query.d.ts

@@ -0,0 +1,2 @@
+import { a as VisualizationSettings, i as SortDirection, n as ExportFormat, r as PivotExportFormat, t as DatasetQuery } from "../query-Xsin530u.js";
+export { DatasetQuery, ExportFormat, PivotExportFormat, SortDirection, VisualizationSettings };

package/dist/domain/query.js

@@ -0,0 +1,13 @@
+import { z } from "zod";
+//#region src/domain/query.ts
+const DatasetQuery = z.object({}).loose().refine((value) => "lib/type" in value || "type" in value, { message: "dataset_query must include \"lib/type\" (MBQL 5) or \"type\" (legacy MBQL/native); empty `{}` is rejected" }).describe("MBQL 5, legacy MBQL, or native query");
+const ExportFormat = z.enum([
+	"csv",
+	"json",
+	"xlsx"
+]);
+const PivotExportFormat = ExportFormat.exclude(["json"]);
+const VisualizationSettings = z.record(z.string(), z.unknown());
+const SortDirection = z.enum(["asc", "desc"]);
+//#endregion
+export { DatasetQuery, ExportFormat, PivotExportFormat, SortDirection, VisualizationSettings };

package/dist/domain/replacement.d.ts

@@ -0,0 +1,2 @@
+import { a as ReplacementEntityType, c as ReplacementRun, d as ReplacementRunStatus, f as ReplacementSourceInput, i as ReplacementColumnMapping, l as ReplacementRunCompact, n as ReplacementColumn, o as ReplacementError, p as ReplacementSourceType, r as ReplacementColumnError, s as ReplacementModelWithTransformInput, t as ReplacementCheck, u as ReplacementRunStarted } from "../replacement-BGyggp-G.js";
+export { ReplacementCheck, ReplacementColumn, ReplacementColumnError, ReplacementColumnMapping, ReplacementEntityType, ReplacementError, ReplacementModelWithTransformInput, ReplacementRun, ReplacementRunCompact, ReplacementRunStarted, ReplacementRunStatus, ReplacementSourceInput, ReplacementSourceType };