@metabase/client 0.0.0-stage → 0.1.0

package/dist/domain/git-sync.js

@@ -0,0 +1,147 @@
+import { z } from "zod";
+//#region src/domain/git-sync.ts
+const SyncTaskStatus = z.enum([
+	"running",
+	"successful",
+	"errored",
+	"cancelled",
+	"timed-out",
+	"conflict"
+]);
+const SyncTaskType = z.enum(["import", "export"]);
+/**
+* The direction an instance syncs in: `read-only` follows the remote branch and refuses local edits
+* to synced content; `read-write` also exports its own changes.
+*/
+const SyncType = z.enum(["read-only", "read-write"]);
+/**
+* Whether a remote is configured, the direction the instance syncs in, and the branch it tracks,
+* `null` when none is set. The sync type is a `SyncType` when an admin sets it; a server that reads
+* `MB_REMOTE_SYNC_TYPE` (60 and later) does not check that value, so it is the string the server
+* holds.
+*/
+const RemoteSyncState = z.object({
+	configured: z.boolean(),
+	sync_type: z.string(),
+	branch: z.string().nullable()
+});
+const TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+	"successful",
+	"errored",
+	"cancelled",
+	"timed-out",
+	"conflict"
+]);
+const FAILED_STATUSES = /* @__PURE__ */ new Set([
+	"errored",
+	"timed-out",
+	"conflict"
+]);
+/** Whether the server will report any further progress for a task in this status. */
+function isSyncTaskTerminal(status) {
+	return TERMINAL_STATUSES.has(status);
+}
+/** Whether a terminal status means the sync did not carry out what it was asked to. */
+function isSyncTaskFailed(status) {
+	return FAILED_STATUSES.has(status);
+}
+const SyncTask = z.object({
+	id: z.number().int().positive(),
+	sync_task_type: SyncTaskType,
+	status: SyncTaskStatus,
+	progress: z.number().min(0).max(1).nullable(),
+	started_at: z.string(),
+	ended_at: z.string().nullable().optional(),
+	last_progress_report_at: z.string().nullable().optional(),
+	version: z.string().nullable().optional(),
+	initiated_by: z.number().int().positive().nullable().optional(),
+	cancelled: z.boolean().nullable().optional(),
+	error_message: z.string().nullable().optional(),
+	conflicts: z.array(z.string()).nullable().optional()
+}).loose();
+const SyncTaskCompact = SyncTask.pick({
+	id: true,
+	sync_task_type: true,
+	status: true,
+	progress: true,
+	version: true,
+	error_message: true,
+	conflicts: true
+}).strip();
+const SyncDirtyItem = z.object({
+	id: z.number().int(),
+	name: z.string().nullable(),
+	model: z.string(),
+	sync_status: z.string(),
+	collection_id: z.number().int().positive().nullable().optional(),
+	description: z.string().nullable().optional(),
+	display: z.string().nullable().optional(),
+	query_type: z.string().nullable().optional(),
+	table_id: z.number().int().positive().nullable().optional(),
+	table_name: z.string().nullable().optional()
+}).loose();
+const SyncDirtyItemCompact = SyncDirtyItem.pick({
+	id: true,
+	name: true,
+	model: true,
+	sync_status: true,
+	collection_id: true
+}).strip();
+const SyncRemoteChanges = z.object({
+	has_changes: z.boolean(),
+	remote_version: z.string().nullable(),
+	local_version: z.string().nullable(),
+	cached: z.boolean()
+});
+const SyncMergeSummary = z.object({
+	added: z.number().int(),
+	updated: z.number().int(),
+	removed: z.number().int()
+});
+const SyncForcePushCasualties = z.object({
+	deleted: z.array(z.string()),
+	overwritten: z.array(z.string())
+});
+const SyncExportPreflight = z.object({
+	has_changes: z.boolean(),
+	clean: z.boolean(),
+	conflicts: z.array(z.string()),
+	summary: SyncMergeSummary,
+	force_push_casualties: SyncForcePushCasualties,
+	reason: z.literal("history-rewritten").nullable()
+}).loose();
+const SyncExportPreflightCompact = SyncExportPreflight.pick({
+	has_changes: true,
+	clean: true,
+	conflicts: true,
+	summary: true,
+	force_push_casualties: true,
+	reason: true
+}).strip();
+const SyncBranchCreated = z.object({
+	status: z.literal("success"),
+	message: z.string()
+});
+const SyncSettingsUpdateResult = z.object({
+	success: z.boolean(),
+	task_id: z.number().int().positive().optional()
+});
+const SyncImportResult = z.object({
+	message: z.string().nullable(),
+	task_id: z.number().int().positive().nullable(),
+	final: SyncTask.nullable().optional()
+});
+const SyncExportResult = z.object({
+	message: z.string(),
+	task_id: z.number().int().positive(),
+	branch: z.string().nullable(),
+	final: SyncTask.nullable().optional()
+});
+const SyncStashResult = z.object({
+	status: z.literal("success"),
+	message: z.string(),
+	task_id: z.number().int().positive(),
+	final: SyncTask.nullable().optional()
+});
+//#endregion
+export { RemoteSyncState, SyncBranchCreated, SyncDirtyItem, SyncDirtyItemCompact, SyncExportPreflight, SyncExportPreflightCompact, SyncExportResult, SyncForcePushCasualties, SyncImportResult, SyncMergeSummary, SyncRemoteChanges, SyncSettingsUpdateResult, SyncStashResult, SyncTask, SyncTaskCompact, SyncTaskStatus, SyncTaskType, SyncType, isSyncTaskFailed, isSyncTaskTerminal };

package/dist/domain/glossary.d.ts

@@ -0,0 +1,2 @@
+import { i as GlossaryUpdateInput, n as GlossaryCompact, r as GlossaryCreateInput, t as Glossary } from "../glossary-CHK3elPj.js";
+export { Glossary, GlossaryCompact, GlossaryCreateInput, GlossaryUpdateInput };

package/dist/domain/glossary.js

@@ -0,0 +1,30 @@
+import { NonBlankText } from "./text.js";
+import { z } from "zod";
+//#region src/domain/glossary.ts
+const GlossaryCreator = z.object({
+	id: z.number().int(),
+	email: z.string(),
+	first_name: z.string().nullable(),
+	last_name: z.string().nullable()
+}).loose();
+const Glossary = z.object({
+	id: z.number().int(),
+	term: z.string(),
+	definition: z.string(),
+	creator_id: z.number().int(),
+	creator: GlossaryCreator,
+	created_at: z.string(),
+	updated_at: z.string()
+}).loose();
+const GlossaryCompact = Glossary.pick({
+	id: true,
+	term: true,
+	definition: true
+}).strip();
+const GlossaryCreateInput = z.object({
+	term: NonBlankText,
+	definition: NonBlankText
+}).strict();
+const GlossaryUpdateInput = GlossaryCreateInput;
+//#endregion
+export { Glossary, GlossaryCompact, GlossaryCreateInput, GlossaryUpdateInput };

package/dist/domain/library.d.ts

@@ -0,0 +1,2 @@
+import { a as LibraryListing, c as libraryWireSchema, i as LibraryCompact, l as toLibrary, n as LibraryChild, o as LibraryPublishTablesInput, r as LibraryCollectionInfo, s as LibraryWire, t as Library } from "../library-Cx9h_RkU.js";
+export { Library, LibraryChild, LibraryCollectionInfo, LibraryCompact, LibraryListing, LibraryPublishTablesInput, LibraryWire, libraryWireSchema, toLibrary };

package/dist/domain/library.js

@@ -0,0 +1,83 @@
+import { TableSelectors } from "./table.js";
+import { Collection, CollectionId, CollectionType } from "./collection.js";
+import { z } from "zod";
+//#region src/domain/library.ts
+const LibraryChildWireV59 = z.object({
+	id: CollectionId,
+	name: z.string(),
+	description: z.string().nullable()
+});
+const LibraryChildWireV62 = LibraryChildWireV59.extend({ type: CollectionType.nullable() });
+const LibraryChild = LibraryChildWireV62.extend({ is_remote_synced: z.boolean().nullable() });
+const Library = Collection.extend({ effective_children: z.array(LibraryChild) }).loose();
+const LibraryCompact = Library.pick({
+	id: true,
+	name: true,
+	type: true,
+	effective_children: true
+}).strip();
+const LibraryCollectionInfo = Collection.pick({
+	id: true,
+	type: true,
+	is_remote_synced: true
+}).strip();
+const LibraryPublishTablesInput = TableSelectors.extend({ collection_id: z.number().int().positive() }).strict();
+const LibraryWireV59 = Collection.extend({ effective_children: z.array(LibraryChildWireV59) }).loose();
+const LibraryWireV62 = Collection.extend({ effective_children: z.array(LibraryChildWireV62) }).loose();
+const AbsentLibrary = z.object({ data: z.null() });
+/**
+* The shape `GET /api/ee/library/` answers on a server with `features`: the Library as sent,
+* awaiting `toLibrary`, or `null` on an instance that has none.
+*/
+function libraryWireSchema(features) {
+	return presentOrAbsent(features.libraryChildrenCarryType ? LibraryWireV62.transform((root) => ({
+		childrenCarryType: true,
+		root
+	})) : LibraryWireV59.transform((root) => ({
+		childrenCarryType: false,
+		root
+	})));
+}
+function presentOrAbsent(present) {
+	return z.unknown().transform((value, ctx) => {
+		if (AbsentLibrary.safeParse(value).success) return null;
+		const parsed = present.safeParse(value);
+		if (parsed.success) return parsed.data;
+		for (const issue of parsed.error.issues) ctx.addIssue({ ...issue });
+		return z.NEVER;
+	});
+}
+/** `wire` read as `Library`, with what its children's projection omitted taken from `listing`. */
+function toLibrary(wire, listing) {
+	if (wire.childrenCarryType) {
+		const effective_children = wire.root.effective_children.map((child) => ({
+			...child,
+			is_remote_synced: listedSyncFlag(child.id, listing)
+		}));
+		return {
+			...wire.root,
+			effective_children
+		};
+	}
+	const effective_children = wire.root.effective_children.map((child) => ({
+		...child,
+		type: listedType(child.id, listing),
+		is_remote_synced: listedSyncFlag(child.id, listing)
+	}));
+	return {
+		...wire.root,
+		effective_children
+	};
+}
+function listed(id, listing) {
+	if (typeof id !== "number") return null;
+	return listing.get(id) ?? null;
+}
+function listedType(id, listing) {
+	return listed(id, listing)?.type ?? null;
+}
+function listedSyncFlag(id, listing) {
+	return listed(id, listing)?.is_remote_synced ?? null;
+}
+//#endregion
+export { Library, LibraryChild, LibraryCollectionInfo, LibraryCompact, LibraryPublishTablesInput, libraryWireSchema, toLibrary };

package/dist/domain/measure.d.ts

@@ -0,0 +1,2 @@
+import { i as MeasureUpdateInput, n as MeasureCompact, r as MeasureCreateInput, t as Measure } from "../measure-KuXdjZYJ.js";
+export { Measure, MeasureCompact, MeasureCreateInput, MeasureUpdateInput };

package/dist/domain/measure.js

@@ -0,0 +1,41 @@
+import { z } from "zod";
+//#region src/domain/measure.ts
+const Measure = z.object({
+	id: z.number().int(),
+	name: z.string(),
+	description: z.string().nullable(),
+	archived: z.boolean(),
+	table_id: z.number().int(),
+	definition: z.unknown(),
+	creator_id: z.number().int(),
+	entity_id: z.string().nullable(),
+	dimensions: z.array(z.unknown()).nullish(),
+	dimension_mappings: z.array(z.unknown()).nullish(),
+	definition_description: z.string().nullable().optional(),
+	result_column_name: z.string().nullable().optional(),
+	created_at: z.string(),
+	updated_at: z.string()
+}).loose();
+const MeasureCompact = Measure.pick({
+	id: true,
+	name: true,
+	description: true,
+	archived: true,
+	table_id: true
+}).strip();
+const MeasureDefinition = z.record(z.string(), z.unknown()).describe("MBQL query holding exactly one aggregation");
+const MeasureCreateInput = z.object({
+	name: z.string().min(1),
+	table_id: z.number().int().positive(),
+	definition: MeasureDefinition,
+	description: z.string().nullable().optional()
+}).loose();
+const MeasureUpdateInput = z.object({
+	name: z.string().min(1).nullable().optional(),
+	definition: MeasureDefinition.nullable().optional(),
+	revision_message: z.string().min(1),
+	archived: z.boolean().nullable().optional(),
+	description: z.string().nullable().optional()
+}).loose();
+//#endregion
+export { Measure, MeasureCompact, MeasureCreateInput, MeasureUpdateInput };

package/dist/domain/metric.d.ts

@@ -0,0 +1,2 @@
+import { C as MetricProjection, S as MetricMathOperator, _ as MetricInstanceFilter, a as MetricBreakoutValues, b as MetricMappingTarget, c as MetricDimensionCompact, d as MetricDimensionRef, f as MetricDimensionRefOptions, g as MetricFilterClause, h as MetricFilterArgument, i as MetricBreakoutColumn, l as MetricDimensionGroup, m as MetricDimensionStatus, n as MetricAddableGroup, o as MetricDefinition, p as MetricDimensionSource, r as MetricBinning, s as MetricDimension, t as MetricAddableDimension, u as MetricDimensionListing, v as MetricLeafRef, x as MetricMathExpression, y as MetricLeafType } from "../metric-yvehaVCS.js";
+export { MetricAddableDimension, MetricAddableGroup, MetricBinning, MetricBreakoutColumn, MetricBreakoutValues, MetricDefinition, MetricDimension, MetricDimensionCompact, MetricDimensionGroup, MetricDimensionListing, MetricDimensionRef, MetricDimensionRefOptions, MetricDimensionSource, MetricDimensionStatus, MetricFilterArgument, MetricFilterClause, MetricInstanceFilter, MetricLeafRef, MetricLeafType, MetricMappingTarget, MetricMathExpression, MetricMathOperator, MetricProjection };

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 NotificationSubscription, a as NotificationCardPayloadPatch, b as NotificationUpdateInput, c as NotificationCreateInput, d as NotificationPayloadType, f as NotificationRecipient, g as NotificationSendCondition, h as NotificationRecipientType, i as NotificationCardPayloadCompact, l as NotificationHandler, m as NotificationRecipientDetails, n as Notification, o as NotificationChannelType, p as NotificationRecipientCompact, r as NotificationCardPayload, s as NotificationCompact, t as CARD_PAYLOAD_TYPE, u as NotificationHandlerCompact, v as NotificationSubscriptionCompact, y as NotificationSubscriptionType } from "../notification-BT2TDAd_.js";
+export { 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,138 @@
+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 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 { 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 };