@metabase/client 0.0.0-stage → 0.1.1

package/dist/domain/field.js

@@ -0,0 +1,274 @@
+import { t as gateInput } from "../input-gate-registry-Dai7SfXb.js";
+import { z } from "zod";
+//#region src/domain/field.ts
+const FieldVisibilityType = z.enum([
+	"details-only",
+	"hidden",
+	"normal",
+	"retired",
+	"sensitive"
+]);
+const FieldValuesType = z.enum([
+	"list",
+	"search",
+	"none",
+	"auto-list"
+]);
+const SEMANTIC_TYPES_WITH_BASE = [
+	"type/AvatarURL",
+	"type/Birthdate",
+	"type/CancelationDate",
+	"type/CancelationTime",
+	"type/CancelationTimestamp",
+	"type/City",
+	"type/Comment",
+	"type/Coordinate",
+	"type/Cost",
+	"type/Country",
+	"type/CreationDate",
+	"type/CreationTime",
+	"type/CreationTimestamp",
+	"type/Currency",
+	"type/DeletionDate",
+	"type/DeletionTime",
+	"type/DeletionTimestamp",
+	"type/Description",
+	"type/Discount",
+	"type/Duration",
+	"type/Email",
+	"type/GrossMargin",
+	"type/ImageURL",
+	"type/Income",
+	"type/JoinDate",
+	"type/JoinTime",
+	"type/JoinTimestamp",
+	"type/Latitude",
+	"type/Longitude",
+	"type/Name",
+	"type/Percentage",
+	"type/Price",
+	"type/Quantity",
+	"type/Score",
+	"type/SerializedJSON",
+	"type/Share",
+	"type/State",
+	"type/Title",
+	"type/URL",
+	"type/UpdatedDate",
+	"type/UpdatedTime",
+	"type/UpdatedTimestamp",
+	"type/ZipCode"
+];
+const FieldBaseType = z.enum([
+	"type/*",
+	"type/field-values-unsupported",
+	"type/fingerprint-unsupported",
+	"type/Large",
+	"type/Number",
+	"type/Integer",
+	"type/BigInteger",
+	"type/Float",
+	"type/Double",
+	"type/Decimal",
+	"type/Text",
+	"type/UUID",
+	"type/OracleCLOB",
+	"type/Temporal",
+	"type/HasDate",
+	"type/HasTime",
+	"type/Date",
+	"type/Time",
+	"type/TimeWithTZ",
+	"type/TimeWithLocalTZ",
+	"type/TimeWithZoneOffset",
+	"type/DateTime",
+	"type/DateTimeWithTZ",
+	"type/DateTimeWithLocalTZ",
+	"type/DateTimeWithZoneOffset",
+	"type/DateTimeWithZoneID",
+	"type/Instant",
+	"type/Interval",
+	"type/Boolean",
+	"type/DruidHyperUnique",
+	"type/SnowflakeVariant",
+	"type/TextLike",
+	"type/MongoBSONID",
+	"type/MongoBinData",
+	"type/MySQLEnum",
+	"type/PostgresEnum",
+	"type/PostgresBitString",
+	"type/IPAddress",
+	"type/Collection",
+	"type/Dictionary",
+	"type/Array",
+	"type/Structured",
+	"type/JSON",
+	"type/DruidJSON",
+	"type/XML",
+	...SEMANTIC_TYPES_WITH_BASE
+]);
+const FieldSemanticType = z.enum([
+	"Semantic/*",
+	"Relation/*",
+	...SEMANTIC_TYPES_WITH_BASE,
+	"type/Location",
+	"type/Address",
+	"type/IPAddress",
+	"type/Category",
+	"type/Enum",
+	"type/Product",
+	"type/Company",
+	"type/Subscription",
+	"type/Source",
+	"type/CreationTemporal",
+	"type/JoinTemporal",
+	"type/CancelationTemporal",
+	"type/DeletionTemporal",
+	"type/UpdatedTemporal",
+	"type/Structured",
+	"type/JSON",
+	"type/DruidJSON",
+	"type/XML",
+	"type/User",
+	"type/Author",
+	"type/Owner",
+	"type/FK",
+	"type/PK"
+]);
+const FieldDataSensitivity = z.enum([
+	"SEC_KEY",
+	"SYS_TELEMETRY",
+	"PHI",
+	"BIO_GEN",
+	"PCI_FIN",
+	"SENS_PERS",
+	"PII",
+	"CORP_IP",
+	"BIZ_CONF",
+	"PUBLIC"
+]);
+const FieldCoercionStrategy = z.enum([
+	"Coercion/String->Temporal",
+	"Coercion/ISO8601->Temporal",
+	"Coercion/ISO8601->DateTime",
+	"Coercion/ISO8601->Time",
+	"Coercion/ISO8601->Date",
+	"Coercion/YYYYMMDDHHMMSSString->Temporal",
+	"Coercion/Bytes->Temporal",
+	"Coercion/YYYYMMDDHHMMSSBytes->Temporal",
+	"Coercion/ISO8601Bytes->Temporal",
+	"Coercion/Number->Temporal",
+	"Coercion/UNIXTime->Temporal",
+	"Coercion/UNIXSeconds->DateTime",
+	"Coercion/UNIXMilliSeconds->DateTime",
+	"Coercion/UNIXMicroSeconds->DateTime",
+	"Coercion/UNIXNanoSeconds->DateTime",
+	"Coercion/Temporal->Temporal",
+	"Coercion/DateTime->Date",
+	"Coercion/String->Number",
+	"Coercion/String->Float",
+	"Coercion/String->Integer",
+	"Coercion/Float->Integer"
+]);
+const Field = z.object({
+	id: z.number().int(),
+	table_id: z.number().int(),
+	name: z.string(),
+	display_name: z.string(),
+	description: z.string().nullable(),
+	database_type: z.string().nullable().optional(),
+	base_type: FieldBaseType,
+	effective_type: FieldBaseType.nullable(),
+	coercion_strategy: FieldCoercionStrategy.nullable(),
+	semantic_type: FieldSemanticType.nullable(),
+	fk_target_field_id: z.number().int().nullable(),
+	database_is_pk: z.boolean().nullable(),
+	parent_id: z.number().int().nullable(),
+	nfc_path: z.array(z.string()).nullable(),
+	has_field_values: FieldValuesType.nullable().optional(),
+	visibility_type: FieldVisibilityType.nullable().optional(),
+	active: z.boolean().optional(),
+	position: z.number().int().optional()
+}).loose();
+const FieldCompact = Field.pick({
+	id: true,
+	name: true,
+	display_name: true,
+	description: true,
+	table_id: true,
+	base_type: true,
+	semantic_type: true,
+	fk_target_field_id: true
+}).strip();
+const FieldWithTarget = Field.extend({ target: Field.nullable() });
+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 DATA_SENSITIVITY_GATE = {
+	feature: "fieldDataSensitivity",
+	effect: "needs",
+	when: { kind: "present" }
+};
+const FieldUpdateInput = z.object({
+	display_name: NonBlankNullable.optional(),
+	description: NonBlankNullable.optional(),
+	caveats: NonBlankNullable.optional(),
+	points_of_interest: NonBlankNullable.optional(),
+	semantic_type: FieldSemanticType.nullable().optional(),
+	coercion_strategy: FieldCoercionStrategy.nullable().optional(),
+	data_sensitivity: gateInput(FieldDataSensitivity.nullable().optional(), DATA_SENSITIVITY_GATE),
+	fk_target_field_id: z.number().int().positive().nullable().optional(),
+	visibility_type: FieldVisibilityType.nullable().optional(),
+	has_field_values: FieldValuesType.nullable().optional(),
+	settings: z.record(z.string(), z.unknown()).nullable().optional(),
+	nfc_path: z.array(z.string().min(1)).nullable().optional(),
+	json_unfolding: z.boolean().nullable().optional()
+}).loose();
+const FieldValues = z.object({
+	values: z.array(z.array(z.unknown())),
+	field_id: z.number().int().optional(),
+	has_more_values: z.boolean().optional(),
+	has_field_values: FieldValuesType.optional()
+}).loose();
+const FieldValuesCompact = FieldValues.pick({
+	values: true,
+	field_id: true,
+	has_more_values: true
+}).strip();
+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 { DATA_SENSITIVITY_GATE, Field, FieldBaseType, FieldCoercionStrategy, FieldCompact, FieldDataSensitivity, FieldDetail, FieldRemappedValue, FieldSearchMatches, FieldSemanticType, FieldSummary, FieldUpdateInput, FieldValues, FieldValuesCompact, FieldWithDataSensitivity, FieldWithDataSensitivityCompact, FieldWithTarget, fieldDetailSchema, fieldRemappedValueSchema, hasDataSensitivity };

package/dist/domain/git-sync.d.ts

@@ -0,0 +1,2 @@
+import { _ as SyncTaskType, a as SyncExportPreflight, b as isSyncTaskTerminal, c as SyncForcePushCasualties, d as SyncRemoteChanges, f as SyncSettingsUpdateResult, g as SyncTaskStatus, h as SyncTaskCompact, i as SyncDirtyItemCompact, l as SyncImportResult, m as SyncTask, n as SyncBranchCreated, o as SyncExportPreflightCompact, p as SyncStashResult, r as SyncDirtyItem, s as SyncExportResult, t as RemoteSyncState, u as SyncMergeSummary, v as SyncType, y as isSyncTaskFailed } from "../git-sync-C99SVdJ9.js";
+export { RemoteSyncState, SyncBranchCreated, SyncDirtyItem, SyncDirtyItemCompact, SyncExportPreflight, SyncExportPreflightCompact, SyncExportResult, SyncForcePushCasualties, SyncImportResult, SyncMergeSummary, SyncRemoteChanges, SyncSettingsUpdateResult, SyncStashResult, SyncTask, SyncTaskCompact, SyncTaskStatus, SyncTaskType, SyncType, isSyncTaskFailed, isSyncTaskTerminal };

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 PUBLISH_TARGET_COLLECTION_GATE, i as LibraryCompact, l as libraryWireSchema, n as LibraryChild, o as LibraryPublishTablesInput, r as LibraryCollectionInfo, s as LibraryWire, t as Library, u as toLibrary } from "../library-B9pEq7qP.js";
+export { Library, LibraryChild, LibraryCollectionInfo, LibraryCompact, LibraryListing, LibraryPublishTablesInput, LibraryWire, PUBLISH_TARGET_COLLECTION_GATE, libraryWireSchema, toLibrary };

package/dist/domain/library.js

@@ -0,0 +1,89 @@
+import { t as gateInput } from "../input-gate-registry-Dai7SfXb.js";
+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 PUBLISH_TARGET_COLLECTION_GATE = {
+	feature: "tablePublishTargetCollection",
+	effect: "needs",
+	when: { kind: "present" }
+};
+const LibraryPublishTablesInput = TableSelectors.extend({ collection_id: gateInput(z.number().int().positive(), PUBLISH_TARGET_COLLECTION_GATE) }).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, PUBLISH_TARGET_COLLECTION_GATE, 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-CgH14YQZ.js";
+export { Measure, MeasureCompact, MeasureCreateInput, MeasureUpdateInput };

package/dist/domain/measure.js

@@ -0,0 +1,43 @@
+import { t as gateInput } from "../input-gate-registry-Dai7SfXb.js";
+import { TABLE_FROM_DEFINITION_GATE } from "./table.js";
+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: gateInput(z.number().int().positive(), TABLE_FROM_DEFINITION_GATE),
+	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-DcYloqOQ.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 };