@gooddata/code-cli 0.47.0-alpha.3 → 0.47.0-alpha.5

package/dist/index.js

@@ -37370,7 +37370,7 @@ function isPromise(value) {
 //#endregion
 //#region package.json
 var name$1 = "@gooddata/code-cli";
-var version$1 = "0.47.0-alpha.3";
+var version$1 = "0.47.0-alpha.5";
 //#endregion
 //#region ../../../common/temp/aac/node_modules/.pnpm/vscode-languageserver@8.1.0/node_modules/vscode-languageserver/lib/common/utils/is.js
 var require_is$2 = /* @__PURE__ */ __commonJSMin(((exports) => {
@@ -134404,6 +134404,9 @@ const CoreErrorMessages = {
 	["core.onlyOneAttributeItemAllowed"]: `Dashboard filters contains more filters with same attribute or label "{0}".`,
 	["core.multipleCommonDateFilters"]: `Multiple usage of common date filters in dashboard. Define exactly one date filter that has no date dataset defined.`,
 	["core.duplicateFilterLocalIdentifier"]: `Duplicate filter local identifier "{0}". Each filter must have a unique local identifier across a dashboard tab, including filters in groups.`,
+	["core.duplicateFieldName"]: `Duplicate field name "{0}". Each field a query declares must have a unique name.`,
+	["core.duplicateFilterName"]: `Duplicate filter name "{0}". Each filter in a query must have a unique name, including the filters a date filter carries.`,
+	["core.duplicateLayerIdentifier"]: `Duplicate layer id "{0}". Each layer of a visualisation must have a unique id.`,
 	["core.duplicateTabIdentifier"]: `Duplicate tab identifier "{0}". Each tab must have a unique identifier within the dashboard.`,
 	["core.tabsAndRootContentMutuallyExclusive"]: `Dashboard "{0}" defines both "tabs" and root-level "sections" or "filters". These are mutually exclusive — keep all content inside tabs or at the root, not both.`
 };
@@ -134422,6 +134425,9 @@ const CoreErrorTypes = {
 	["core.onlyOneAttributeItemAllowed"]: "OnlyOneAttributeItemAllowed",
 	["core.multipleCommonDateFilters"]: "MultipleCommonDateFilters",
 	["core.duplicateFilterLocalIdentifier"]: "DuplicateFilterLocalIdentifier",
+	["core.duplicateFieldName"]: "DuplicateFieldName",
+	["core.duplicateFilterName"]: "DuplicateFilterName",
+	["core.duplicateLayerIdentifier"]: "DuplicateLayerIdentifier",
 	["core.duplicateTabIdentifier"]: "DuplicateTabIdentifier",
 	["core.tabsAndRootContentMutuallyExclusive"]: "TabsAndRootContentMutuallyExclusive"
 };
@@ -135122,6 +135128,7 @@ function loadColorMapping(mappings) {
 	const map = new import_dist.YAMLMap();
 	mappings.forEach((mapping) => {
 		const { color, id } = mapping;
+		if (id === null) throw newError("core.itemNotSupported", ["color mapping of the empty element"]);
 		const col = loadColor(id, color);
 		if (col) map.add(col);
 	});
@@ -135136,18 +135143,29 @@ function loadColorDefinitions(mappings) {
 	});
 	return map;
 }
-function loadColor(key, color) {
+const COMPARISON_GUIDS = {
+	positive: 1,
+	negative: -1,
+	equals: 0
+};
+/**
+* Only `/^\d+$/` guids resolve against a workspace palette (see `guidEquals` in sdk-ui-vis-commons), and
+* the schema admits no colour string but `rgb(...)`, so anything else has no code form.
+*/
+function loadColor(key, color, mode = "number") {
 	if (!color) return;
-	if (color.type === "guid") {
-		switch (color.value) {
-			case "positive": return new import_dist.Pair(key, 1);
-			case "negative": return new import_dist.Pair(key, -1);
-			case "equals": return new import_dist.Pair(key, 0);
+	const { type } = color;
+	if (type === "guid") {
+		const comparison = COMPARISON_GUIDS[color.value];
+		if (mode === "enum") {
+			if (comparison === void 0) throw newError("core.itemNotSupported", [`comparison color "${color.value}"`]);
+			return new import_dist.Pair(key, comparison);
 		}
-		return new import_dist.Pair(key, parseInt(color.value, 10));
+		if (!/^\d+$/.test(color.value)) throw newError("core.itemNotSupported", [`color "${color.value}"`]);
+		return new import_dist.Pair(key, Number.parseInt(color.value, 10));
 	}
-	if (color.type === "rgb") return new import_dist.Pair(key, `rgb(${color.value.r},${color.value.g},${color.value.b})`);
-	throw new Error(`Unknown color type: ${color}`);
+	if (type === "rgb") return new import_dist.Pair(key, `rgb(${color.value.r},${color.value.g},${color.value.b})`);
+	throw newError("core.itemNotSupported", [`color of type "${type}"`]);
 }
 /** @public */
 function saveColorMapping(mapping) {
@@ -135196,7 +135214,7 @@ function getDefById(id) {
 		case "properties.color.total": return "total";
 		case "properties.color.positive": return "positive";
 		case "properties.color.negative": return "negative";
-		default: throw new Error(`Unknown color definition id: ${id}`);
+		default: throw newError("core.itemNotSupported", [`color definition "${id}"`]);
 	}
 }
 function getIdByDef(def) {
@@ -137011,9 +137029,9 @@ function headlineChartLoad(props) {
 					["position", getValueOrDefault(val.position, DEFAULTS$11.comparison.position)],
 					["indicator_arrow", getValueOrDefault(val.isArrowEnabled, DEFAULTS$11.comparison.isArrowEnabled, "bool")],
 					["indicator_colors", val.colorConfig?.disabled === void 0 ? void 0 : !val.colorConfig.disabled],
-					["indicator_color_equals", loadColor("equals", val.colorConfig?.equals)?.value],
-					["indicator_color_negative", loadColor("negative", val.colorConfig?.negative)?.value],
-					["indicator_color_positive", loadColor("positive", val.colorConfig?.positive)?.value],
+					["indicator_color_equals", loadColor("equals", val.colorConfig?.equals, "enum")?.value],
+					["indicator_color_negative", loadColor("negative", val.colorConfig?.negative, "enum")?.value],
+					["indicator_color_positive", loadColor("positive", val.colorConfig?.positive, "enum")?.value],
 					["label_default", getValueOrDefault(val.labelConfig?.unconditionalValue, DEFAULTS$11.comparison.labelConfig.unconditionalValue)],
 					["label_conditional", getValueOrDefault(val.labelConfig?.isConditional, DEFAULTS$11.comparison.labelConfig.isConditional, "bool")],
 					["label_equals", getValueOrDefault(val.labelConfig?.equals, DEFAULTS$11.comparison.labelConfig.equals)],
@@ -139278,14 +139296,14 @@ function convertYamlConditionsToSdk(yamlConditions, nullValuesAsZero) {
 	});
 	return sdkConditions;
 }
-function yamlAbsoluteDateFilterToDeclarative(entities, filter) {
+function yamlAbsoluteDateFilterToDeclarative(entities, filter, assignFilterLocalId) {
 	let result = { filters: [{ absoluteDateFilter: {
 		dataSet: createIdentifier(filter.using, { forceType: "dataset" }),
 		from: filter.from,
 		to: filter.to
 	} }] };
 	result = mergeDeclarativeResults(result, dateFilterEmptyValuesToDeclarative(filter));
-	result = mergeDeclarativeResults(result, dateFilterWithFieldToDeclarative(entities, filter));
+	result = mergeDeclarativeResults(result, dateFilterWithFieldToDeclarative(entities, filter, assignFilterLocalId));
 	return result;
 }
 function dateFilterEmptyValuesToDeclarative(filter) {
@@ -139303,11 +139321,11 @@ function dateFilterEmptyValuesToDeclarative(filter) {
 	}
 	return { filters: [] };
 }
-function dateFilterWithFieldToDeclarative(entities, filter) {
+function dateFilterWithFieldToDeclarative(entities, filter, assignFilterLocalId) {
 	if (!filter.with) return { filters: [] };
-	return mergeDeclarativeResults(...Object.entries(filter.with).map(([key, withFilter]) => yamlFilterToDeclarative(entities, key, withFilter)));
+	return mergeDeclarativeResults(...Object.entries(filter.with).map(([key, withFilter]) => yamlFilterToDeclarative(entities, key, withFilter, assignFilterLocalId)));
 }
-function yamlRelativeDateFilterToDeclarative(entities, filter) {
+function yamlRelativeDateFilterToDeclarative(entities, filter, assignFilterLocalId) {
 	const identifier = createIdentifier(filter.using, { forceType: "dataset" });
 	if (!identifier) throw new Error(`Could not find dataset ${filter.using} to use in relative date filter`);
 	let result = {
@@ -139325,7 +139343,7 @@ function yamlRelativeDateFilterToDeclarative(entities, filter) {
 		granularity: convertGranularity$1("YEAR")
 	} }] });
 	result = mergeDeclarativeResults(result, dateFilterEmptyValuesToDeclarative(filter));
-	result = mergeDeclarativeResults(result, dateFilterWithFieldToDeclarative(entities, filter));
+	result = mergeDeclarativeResults(result, dateFilterWithFieldToDeclarative(entities, filter, assignFilterLocalId));
 	return result;
 }
 function yamlPositiveAttributeFilterToDeclarative(entities, key, filter, assignFilterLocalId = false) {
@@ -139412,9 +139430,9 @@ function yamlRankingFilterToDeclarative(filter) {
 		...filter.strict_limit_of_rows === void 0 ? {} : { strictLimitOfRows: filter.strict_limit_of_rows }
 	} }] };
 }
-function yamlFilterToDeclarative(entities, key, filter, assignFilterLocalId = false) {
-	if (isAbsoluteDateFilter(filter)) return yamlAbsoluteDateFilterToDeclarative(entities, filter);
-	if (isRelativeDateFilter(filter)) return yamlRelativeDateFilterToDeclarative(entities, filter);
+function yamlFilterToDeclarative(entities, key, filter, assignFilterLocalId) {
+	if (isAbsoluteDateFilter(filter)) return yamlAbsoluteDateFilterToDeclarative(entities, filter, assignFilterLocalId);
+	if (isRelativeDateFilter(filter)) return yamlRelativeDateFilterToDeclarative(entities, filter, assignFilterLocalId);
 	if (isPositiveAttributeFilter(filter)) return yamlPositiveAttributeFilterToDeclarative(entities, key, filter, assignFilterLocalId);
 	if (isNegativeAttributeFilter(filter)) return yamlNegativeAttributeFilterToDeclarative(entities, key, filter, assignFilterLocalId);
 	if (isArbitraryTextFilter(filter)) return yamlTextFilterToDeclarative(key, filter);
@@ -139432,6 +139450,19 @@ function mergeDeclarativeResults(...results) {
 		attributeFilterConfig: Object.assign({}, ...results.map((result) => result.attributeFilterConfig ?? {}))
 	};
 }
+/**
+* A filter's key becomes its local identifier, and the whole query shares one namespace for them across
+* nested blocks — a name reused between blocks would leave two filters indistinguishable.
+*/
+function assertDistinctLocalIdentifiers(filters) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const filter of filters) {
+		const localIdentifier = filterLocalIdentifier(filter);
+		if (!localIdentifier) continue;
+		if (seen.has(localIdentifier)) throw newError("core.duplicateFilterName", [localIdentifier]);
+		seen.add(localIdentifier);
+	}
+}
 /** @internal */
 function yamlFiltersToDeclarative(entities, filters_by, attributeFilterConfigs = {}, assignFilterLocalId = false) {
 	const isArray = Array.isArray(filters_by);
@@ -139439,6 +139470,7 @@ function yamlFiltersToDeclarative(entities, filters_by, attributeFilterConfigs =
 		filters: [],
 		attributeFilterConfig: attributeFilterConfigs
 	}, ...filters_by && !isArray ? Object.entries(filters_by).map(([key, filter]) => yamlFilterToDeclarative(entities, key, filter, assignFilterLocalId)) : [], ...filters_by && isArray ? filters_by.map((filter, i) => yamlFilterToDeclarative(entities, i.toString(), filter, assignFilterLocalId)) : []);
+	assertDistinctLocalIdentifiers(filters);
 	return {
 		filters,
 		attributeFilterConfigs: Object.keys(attributeFilterConfig ?? {}).length > 0 ? attributeFilterConfig : void 0
@@ -139610,20 +139642,20 @@ function createGeoAreaBuckets({ viewBy, metrics, segmentBy }) {
 }
 function yamlLayersToDeclarative(entities, input, _positions) {
 	if (!("layers" in input) || !Array.isArray(input.layers) || input.layers.length === 0) return [];
-	return input.layers.map((layer) => {
+	const layers = input.layers;
+	const claimed = /* @__PURE__ */ new Set();
+	for (const { id } of layers) {
+		if (claimed.has(id)) throw newError("core.duplicateLayerIdentifier", [id]);
+		claimed.add(id);
+	}
+	return layers.map((layer) => {
 		if (layer.type !== "pushpin" && layer.type !== "area") throw newError("core.layerTypeNotSupported", [layer.type ?? "<missing>"]);
 		const layerVisualizationType = layer.type === "pushpin" ? "geo_chart" : "geo_area_chart";
-		const baseQuery = layer.query;
 		const resolvedQuery = {
 			...input.query,
-			...baseQuery,
-			fields: {
-				...input.query?.fields ?? {},
-				...baseQuery?.fields ?? {}
-			}
+			fields: input.query?.fields ?? {}
 		};
 		const positions = [];
-		let attrFilterConfig = {};
 		const buckets = (layer.type === "pushpin" ? createPushpinBuckets({
 			viewBy: layer.view_by,
 			metrics: layer.metrics,
@@ -139639,22 +139671,17 @@ function yamlLayersToDeclarative(entities, input, _positions) {
 			return {
 				localIdentifier,
 				items: bucket.items.map((item) => {
-					const { bucketItem, bucketTotals, longitude, latitude, filterConfig } = yamlBucketItemToDeclarative(entities, resolvedQuery, item, resolvedQuery.fields || {}, localIdentifier);
+					const { bucketItem, bucketTotals, longitude, latitude } = yamlBucketItemToDeclarative(entities, resolvedQuery, item, resolvedQuery.fields || {}, localIdentifier);
 					if (longitude && latitude) positions.push({
 						longitude,
 						latitude
 					});
-					if (filterConfig) attrFilterConfig = {
-						...attrFilterConfig,
-						...filterConfig
-					};
 					bucketTotals.forEach((total) => totals.push(total));
 					return bucketItem;
 				}).filter(Boolean),
 				totals
 			};
 		}).filter(Boolean);
-		const { filters: layerFilters, attributeFilterConfigs } = yamlFiltersToDeclarative(entities, baseQuery?.filter_by, attrFilterConfig, true);
 		const layerProperties = layer.config || layer.type === "pushpin" && positions.length > 0 ? yamlConfigToDeclarative({
 			...input,
 			type: layerVisualizationType,
@@ -139669,9 +139696,6 @@ function yamlLayersToDeclarative(entities, input, _positions) {
 			name: layer.title,
 			type: layer.type,
 			buckets,
-			filters: layerFilters,
-			...attributeFilterConfigs ? { attributeFilterConfigs } : {},
-			sorts: yamlSortsToDeclarative(baseQuery?.sort_by, baseQuery?.fields ?? resolvedQuery.fields ?? {}),
 			properties: layerProperties && Object.keys(layerProperties).length > 0 ? layerProperties : void 0
 		};
 	});
@@ -140785,6 +140809,374 @@ function declarativeMetricToYaml(metric) {
 	};
 }
 //#endregion
+//#region ../../../sdk/libs/sdk-code-convertors/src/from/filtersToYaml.ts
+function detectEmptyValuesFilterType(filter) {
+	const attributeElements = filterAttributeElements(filter);
+	const items = attributeElements ? getAttributeElementsItems(attributeElements) : [];
+	if (items.length !== 1 || items[0] !== "") return;
+	return isPositiveAttributeFilter$1(filter) ? "only" : "exclude";
+}
+function getObjRefGroupingKey(objRef) {
+	if (!objRef || typeof objRef !== "object") return;
+	if ("identifier" in objRef) {
+		const identifier = objRef.identifier;
+		if (typeof identifier === "string") return identifier;
+		if (identifier && typeof identifier === "object" && "id" in identifier) {
+			const id = identifier.id;
+			if (typeof id === "string") return id;
+		}
+	}
+	if ("uri" in objRef) {
+		const uri = objRef.uri;
+		if (typeof uri === "string") return uri;
+	}
+	if ("localIdentifier" in objRef) {
+		const localIdentifier = objRef.localIdentifier;
+		if (typeof localIdentifier === "string") return localIdentifier;
+	}
+	return serializeObjRef(objRef);
+}
+/**
+* Groups date filters with their associated attribute filters. Leaves the rest alone.
+*/
+function groupFiltersByDateFilter(filters) {
+	const dateFilters = [...filters].filter(isDateFilter$1);
+	const nonDateFilters = [...filters].filter((f) => !isDateFilter$1(f));
+	const result = {
+		grouped: {},
+		rest: []
+	};
+	const getFilterRefDetails = (filter) => {
+		const objRef = filterObjRef(filter);
+		if (!objRef) return {
+			objRef: void 0,
+			filterRef: void 0
+		};
+		return {
+			objRef,
+			filterRef: getObjRefGroupingKey(objRef)
+		};
+	};
+	dateFilters.forEach((dateFilter) => {
+		const { filterRef: datasetId } = getFilterRefDetails(dateFilter);
+		const fi = filters.indexOf(dateFilter);
+		if (datasetId === void 0) {
+			result.rest.push([dateFilter, fi]);
+			return;
+		}
+		if (result.grouped[datasetId]) result.rest.push([dateFilter, fi]);
+		else result.grouped[datasetId] = {
+			dateFilter: [dateFilter, fi],
+			attributeFilters: []
+		};
+	});
+	nonDateFilters.forEach((filter) => {
+		const { filterRef: filterId } = getFilterRefDetails(filter);
+		const fi = filters.indexOf(filter);
+		if (filterId === void 0) {
+			result.rest.push([filter, fi]);
+			return;
+		}
+		const datasetId = filterId.split(".")[0];
+		const group = result.grouped[datasetId];
+		if (group) group.attributeFilters.push([filter, fi]);
+		else result.rest.push([filter, fi]);
+	});
+	return result;
+}
+/** @internal */
+function declarativeFiltersToYaml(entities, filters, errorContext) {
+	const filtersArray = [];
+	const filtersMap = {};
+	const usedKeys = /* @__PURE__ */ new Set();
+	const claimKey = (baseKey) => {
+		let key = baseKey;
+		let suffix = 2;
+		while (usedKeys.has(key)) {
+			key = `${baseKey}_${suffix}`;
+			suffix += 1;
+		}
+		usedKeys.add(key);
+		return key;
+	};
+	const fold = ({ carried = [], ...written }) => {
+		filtersArray.push(new import_dist.Pair(written.key, written.yaml));
+		[written, ...carried].forEach(({ key, yaml, filter }) => {
+			filtersMap[key] = {
+				yaml,
+				filter
+			};
+		});
+	};
+	const filtersGroupedByDateFilter = groupFiltersByDateFilter(filters);
+	filtersGroupedByDateFilter.rest.forEach(([filter, fi]) => {
+		const result = declarativeFilterToYaml(entities, filter, claimKey, void 0, updateErrorContext(errorContext, { path: [fi.toString()] }));
+		if (!result) return;
+		fold(result);
+	});
+	Object.values(filtersGroupedByDateFilter.grouped).forEach(({ dateFilter, attributeFilters }) => {
+		const result = declarativeFilterToYaml(entities, dateFilter[0], claimKey, attributeFilters.map(([f]) => f), updateErrorContext(errorContext, { path: [dateFilter[1].toString()] }));
+		if (!result) return;
+		fold(result);
+	});
+	return {
+		filtersMap,
+		filtersArray: filtersArray.reduce((map, filter) => {
+			map.add(filter);
+			return map;
+		}, new import_dist.YAMLMap())
+	};
+}
+function declarativeFilterToYaml(entities, filter, claimKey, connectedAttributeFilters, errorContext) {
+	if (!isFilter(filter)) return null;
+	const key = claimKey(createFilterItemKeyName(filter, "date", updateErrorContext(errorContext, { path: ["date"] })));
+	if (isAbsoluteDateFilter$1(filter)) {
+		const { yaml, carried } = declarativeAbsoluteDateFilterToYaml(filter.absoluteDateFilter, {
+			entities,
+			claimKey,
+			connectedAttributeFilters,
+			errorContext: updateErrorContext(errorContext, { path: ["absoluteDateFilter"] })
+		});
+		return {
+			key,
+			yaml,
+			filter,
+			carried
+		};
+	}
+	if (isRelativeDateFilter$1(filter)) {
+		const { yaml, carried } = declarativeRelativeDateFilterToYaml(filter.relativeDateFilter, {
+			entities,
+			claimKey,
+			connectedAttributeFilters,
+			errorContext: updateErrorContext(errorContext, { path: ["relativeDateFilter"] })
+		});
+		return {
+			key,
+			yaml,
+			filter,
+			carried
+		};
+	}
+	if (isPositiveAttributeFilter$1(filter)) return {
+		key,
+		yaml: declarativePositiveAttributeFilterToYaml(entities, filter.positiveAttributeFilter, updateErrorContext(errorContext, { path: ["positiveAttributeFilter"] })),
+		filter
+	};
+	if (isNegativeAttributeFilter$1(filter)) return {
+		key,
+		yaml: declarativeNegativeAttributeFilterToYaml(entities, filter.negativeAttributeFilter, updateErrorContext(errorContext, { path: ["negativeAttributeFilter"] })),
+		filter
+	};
+	if (isArbitraryAttributeFilter(filter)) return {
+		key,
+		yaml: declarativeArbitraryAttributeFilterToYaml(filter.arbitraryAttributeFilter, updateErrorContext(errorContext, { path: ["arbitraryAttributeFilter"] })),
+		filter
+	};
+	if (isMatchAttributeFilter(filter)) return {
+		key,
+		yaml: declarativeMatchAttributeFilterToYaml(filter.matchAttributeFilter, updateErrorContext(errorContext, { path: ["matchAttributeFilter"] })),
+		filter
+	};
+	if (isMeasureValueFilter(filter)) return {
+		key,
+		yaml: declarativeMeasureValueFilterToYaml$1(filter.measureValueFilter, updateErrorContext(errorContext, { path: ["measureValueFilter"] })),
+		filter
+	};
+	if (isRankingFilter$1(filter)) return {
+		key,
+		yaml: declarativeRankingFilterToYaml(filter.rankingFilter, updateErrorContext(errorContext, { path: ["rankingFilter"] })),
+		filter
+	};
+	throw newError("core.filterItemTypeNotSupported", [JSON.stringify(filter)], errorContext);
+}
+/** Adds `empty_values` and `with` to `map`, returning the filters written under the latter. */
+function processConnectedAttributeFilters(map, connectedAttributeFilters, entities, claimKey, errorContext) {
+	const emptyValuesFilter = connectedAttributeFilters.find((filter) => detectEmptyValuesFilterType(filter));
+	if (emptyValuesFilter) map.add(new import_dist.Pair("empty_values", detectEmptyValuesFilterType(emptyValuesFilter)));
+	const additionalAttributeFilters = connectedAttributeFilters.filter((filter) => filter !== emptyValuesFilter);
+	if (additionalAttributeFilters.length === 0) return [];
+	const withMap = new import_dist.YAMLMap();
+	map.add(new import_dist.Pair("with", withMap));
+	return additionalAttributeFilters.flatMap((filter) => {
+		const written = declarativeFilterToYaml(entities, filter, claimKey, void 0, errorContext);
+		if (!written) return [];
+		withMap.add(new import_dist.Pair(written.key, written.yaml));
+		return [written, ...written.carried ?? []];
+	});
+}
+/** @internal */
+function declarativeAbsoluteDateFilterToYaml(absoluteDateFilter, { entities, claimKey, connectedAttributeFilters = [], errorContext }) {
+	const map = new import_dist.YAMLMap();
+	map.add(new import_dist.Pair("type", "date_filter"));
+	map.add(new import_dist.Pair("from", absoluteDateFilter.from));
+	map.add(new import_dist.Pair("to", absoluteDateFilter.to));
+	const id = getIdentifier(absoluteDateFilter.dataSet, true, updateErrorContext(errorContext, { path: ["dateSet"] }));
+	map.add(new import_dist.Pair("using", id));
+	return {
+		yaml: map,
+		carried: processConnectedAttributeFilters(map, connectedAttributeFilters, entities, claimKey, errorContext)
+	};
+}
+function isRelativeDateFilterAllTime(relativeDateFilter) {
+	const { granularity, from, to } = relativeDateFilter;
+	if (granularity === "ALL_TIME_GRANULARITY") return true;
+	return granularity === "GDC.time.year" && from === void 0 && to === void 0;
+}
+/** @internal */
+function declarativeRelativeDateFilterToYaml(relativeDateFilter, { entities, claimKey, connectedAttributeFilters = [], errorContext }) {
+	const map = new import_dist.YAMLMap();
+	map.add(new import_dist.Pair("type", "date_filter"));
+	if (isRelativeDateFilterAllTime(relativeDateFilter)) {} else {
+		if (relativeDateFilter.granularity) map.add(new import_dist.Pair("granularity", parseGranularity(relativeDateFilter.granularity)));
+		if (relativeDateFilter.from !== void 0 && relativeDateFilter.to !== void 0) {
+			map.add(new import_dist.Pair("from", relativeDateFilter.from));
+			map.add(new import_dist.Pair("to", relativeDateFilter.to));
+		}
+	}
+	const id = getIdentifier(relativeDateFilter.dataSet, true, updateErrorContext(errorContext, { path: ["dataSet"] }));
+	map.add(new import_dist.Pair("using", id));
+	return {
+		yaml: map,
+		carried: processConnectedAttributeFilters(map, connectedAttributeFilters, entities, claimKey, errorContext)
+	};
+}
+/**
+* A selection given by uri has no form here: written without any `state` it reads back as listing none,
+* which an attribute filter takes to mean every element.
+*/
+function attributeElementValues(elements, field, errorContext) {
+	if (!isAttributeElementsByValue(elements)) throw newError("core.itemNotSupported", ["attribute elements not given by value"], updateErrorContext(errorContext, { path: [field] }));
+	return elements.values.filter((v) => v !== null && v !== void 0);
+}
+/** @internal */
+function declarativePositiveAttributeFilterToYaml(entities, attributeFilter, errorContext) {
+	const map = new import_dist.YAMLMap();
+	map.add(new import_dist.Pair("type", "attribute_filter"));
+	const id = getIdentifier(attributeFilter.displayForm, void 0, updateErrorContext(errorContext, { path: ["displayForm"] }));
+	map.add(new import_dist.Pair("using", id));
+	const values = attributeElementValues(attributeFilter.in, "in", errorContext);
+	map.add(new import_dist.Pair("state", new import_dist.Pair("include", parseDateValues(entities, id, values))));
+	return map;
+}
+/** @internal */
+function declarativeNegativeAttributeFilterToYaml(entities, attributeFilter, errorContext) {
+	const map = new import_dist.YAMLMap();
+	map.add(new import_dist.Pair("type", "attribute_filter"));
+	const id = getIdentifier(attributeFilter.displayForm, void 0, updateErrorContext(errorContext, { path: ["displayForm"] }));
+	map.add(new import_dist.Pair("using", id));
+	const values = isAttributeElementsByRef(attributeFilter.notIn) && attributeFilter.notIn.uris.length === 0 ? [] : attributeElementValues(attributeFilter.notIn, "notIn", errorContext);
+	if (values.length > 0) map.add(new import_dist.Pair("state", new import_dist.Pair("exclude", parseDateValues(entities, id, values))));
+	return map;
+}
+function declarativeArbitraryAttributeFilterToYaml(attributeFilter, errorContext) {
+	const map = new import_dist.YAMLMap();
+	map.add(new import_dist.Pair("type", "text_filter"));
+	map.add(new import_dist.Pair("using", getIdentifier(attributeFilter.label, void 0, updateErrorContext(errorContext, { path: ["label"] }))));
+	map.add(new import_dist.Pair("condition", attributeFilter.negativeSelection ? "isNot" : "is"));
+	map.add(new import_dist.Pair("values", attributeFilter.values));
+	return map;
+}
+function declarativeMatchAttributeFilterToYaml(attributeFilter, errorContext) {
+	const map = new import_dist.YAMLMap();
+	map.add(new import_dist.Pair("type", "text_filter"));
+	map.add(new import_dist.Pair("using", getIdentifier(attributeFilter.label, void 0, updateErrorContext(errorContext, { path: ["label"] }))));
+	map.add(new import_dist.Pair("condition", matchConditionToYaml(attributeFilter.operator, attributeFilter.negativeSelection)));
+	map.add(new import_dist.Pair("value", attributeFilter.literal));
+	if (attributeFilter.caseSensitive !== void 0) map.add(new import_dist.Pair("case_sensitive", attributeFilter.caseSensitive));
+	return map;
+}
+function asCompoundCondition(condition) {
+	const { compound } = condition;
+	return Array.isArray(compound?.conditions) ? compound : null;
+}
+function addConditionsToYaml(map, conditions, options) {
+	const { nullsCountAsZero, errorContext } = options;
+	const conditionsSeq = new import_dist.YAMLSeq();
+	let treatNullValuesAsZero = nullsCountAsZero;
+	conditions.forEach((condition) => {
+		const conditionMap = new import_dist.YAMLMap();
+		if (addConditionToYamlMap(conditionMap, condition, errorContext)) treatNullValuesAsZero = true;
+		conditionsSeq.add(conditionMap);
+	});
+	map.add(new import_dist.Pair("conditions", conditionsSeq));
+	if (treatNullValuesAsZero) map.add(new import_dist.Pair("null_values_as_zero", true));
+}
+/** Nulls are recorded only as counting for zero or not, so any other stand-in has no form here. */
+function assertNullsCountAsZero(treatNullValuesAs, errorContext) {
+	if (treatNullValuesAs !== void 0 && treatNullValuesAs !== 0) throw newError("core.itemNotSupported", [`null values treated as ${treatNullValuesAs}`], updateErrorContext(errorContext, { path: ["treatNullValuesAs"] }));
+}
+function addSingleConditionToYaml(map, condition, errorContext) {
+	const nullsCountAsZero = addConditionToYamlMap(map, condition, errorContext);
+	map.add(new import_dist.Pair("null_values_as_zero", nullsCountAsZero));
+}
+function addConditionToYamlMap(conditionMap, condition, errorContext) {
+	let hasTreatNullValues = false;
+	if (isComparisonCondition(condition)) {
+		const comp = condition.comparison;
+		assertNullsCountAsZero(comp.treatNullValuesAs, errorContext);
+		conditionMap.add(new import_dist.Pair("condition", comp.operator.toUpperCase()));
+		conditionMap.add(new import_dist.Pair("value", comp.value));
+		if (comp.treatNullValuesAs !== void 0) hasTreatNullValues = true;
+	} else if (isRangeCondition(condition)) {
+		const range = condition.range;
+		assertNullsCountAsZero(range.treatNullValuesAs, errorContext);
+		conditionMap.add(new import_dist.Pair("condition", range.operator.toUpperCase()));
+		conditionMap.add(new import_dist.Pair("from", range.from));
+		conditionMap.add(new import_dist.Pair("to", range.to));
+		if (range.treatNullValuesAs !== void 0) hasTreatNullValues = true;
+	} else throw newError("core.itemNotSupported", [`condition ${JSON.stringify(condition)}`], errorContext);
+	return hasTreatNullValues;
+}
+/** @internal */
+function declarativeMeasureValueFilterToYaml$1(measureValueFilter, errorContext) {
+	const map = new import_dist.YAMLMap();
+	map.add(new import_dist.Pair("type", "metric_value_filter"));
+	if (isLocalIdRef(measureValueFilter.measure)) map.add(new import_dist.Pair("using", measureValueFilter.measure.localIdentifier));
+	else map.add(new import_dist.Pair("using", getIdentifier(measureValueFilter.measure, void 0, updateErrorContext(errorContext, { path: ["measure"] }))));
+	const conditionContext = updateErrorContext(errorContext, { path: ["condition"] });
+	const compound = measureValueFilter.condition ? asCompoundCondition(measureValueFilter.condition) : null;
+	if (compound) {
+		assertNullsCountAsZero(compound.treatNullValuesAs, conditionContext);
+		if (compound.conditions.length > 0) addConditionsToYaml(map, compound.conditions, {
+			nullsCountAsZero: compound.treatNullValuesAs !== void 0,
+			errorContext: conditionContext
+		});
+	} else if (measureValueFilter.conditions && measureValueFilter.conditions.length > 1) addConditionsToYaml(map, measureValueFilter.conditions, {
+		nullsCountAsZero: false,
+		errorContext: conditionContext
+	});
+	else if (measureValueFilter.conditions?.length === 1) addSingleConditionToYaml(map, measureValueFilter.conditions[0], conditionContext);
+	else if (measureValueFilter.condition) addSingleConditionToYaml(map, measureValueFilter.condition, conditionContext);
+	if (measureValueFilter.dimensionality && Array.isArray(measureValueFilter.dimensionality)) {
+		const dimensionalitySeq = new import_dist.YAMLSeq();
+		measureValueFilter.dimensionality.forEach((item) => {
+			if (isLocalIdRef(item)) dimensionalitySeq.add(item.localIdentifier);
+			else dimensionalitySeq.add(getIdentifier(item));
+		});
+		map.add(new import_dist.Pair("dimensionality", dimensionalitySeq));
+	}
+	return map;
+}
+/** @internal */
+function declarativeRankingFilterToYaml(rankingFilter, errorContext) {
+	const map = new import_dist.YAMLMap();
+	map.add(new import_dist.Pair("type", "ranking_filter"));
+	if (isLocalIdRef(rankingFilter.measure)) map.add(new import_dist.Pair("using", rankingFilter.measure.localIdentifier));
+	else map.add(new import_dist.Pair("using", getIdentifier(rankingFilter.measure, void 0, updateErrorContext(errorContext, { path: ["measure"] }))));
+	if (rankingFilter.operator === "TOP") map.add(new import_dist.Pair("top", rankingFilter.value));
+	if (rankingFilter.operator === "BOTTOM") map.add(new import_dist.Pair("bottom", rankingFilter.value));
+	const rankedBy = (rankingFilter.attributes ?? []).filter(Boolean);
+	if (rankedBy.length > 1) throw newError("core.itemNotSupported", [`ranking over ${rankedBy.length} attributes`], updateErrorContext(errorContext, { path: ["attributes"] }));
+	if (rankedBy[0]) {
+		const first = rankedBy[0];
+		if (isLocalIdRef(first)) map.add(new import_dist.Pair("attribute", first.localIdentifier));
+		else map.add(new import_dist.Pair("attribute", getIdentifier(first)));
+	}
+	if (rankingFilter.strictLimitOfRows !== void 0) map.add(new import_dist.Pair("strict_limit_of_rows", rankingFilter.strictLimitOfRows));
+	return map;
+}
+//#endregion
 //#region ../../../sdk/libs/sdk-code-convertors/src/from/declarativeVisualisationToYaml.ts
 /** @public */
 function declarativeVisualisationToYaml(entities, visualisation, context) {
@@ -140807,11 +141199,31 @@ function declarativeVisualisationToYaml(entities, visualisation, context) {
 	const report = declarativeReportToYaml(entities, insight.insight, updateErrorContext(errorContext, { path: ["insight"] }));
 	doc.add(entryWithSpace("query", report.report));
 	declarativeVisToYaml(doc, insight.insight, report, entities, updateErrorContext(errorContext, { path: ["insight"] }));
+	report.buckets.assertAllConsumed(errorContext);
+	if ((insight.insight.layers ?? []).length > 0 && doc.get("layers") === void 0) throw newError("core.itemNotSupported", ["layers"], updateErrorContext(errorContext, { path: ["layers"] }));
 	return {
 		content: doc.toString({ lineWidth: 0 }),
 		json: doc.toJSON()
 	};
 }
+/**
+* Every type reads the buckets it writes by looking them up, so one it never looks up is dropped whole,
+* taking its items with it.
+*/
+function bucketRegistry(groups) {
+	const consumed = /* @__PURE__ */ new Set();
+	return {
+		consume(type) {
+			const found = groups.find((group) => group.type === type);
+			if (found) consumed.add(found);
+			return found;
+		},
+		assertAllConsumed(errorContext) {
+			const dropped = groups.find((group) => group.items.length > 0 && !consumed.has(group));
+			if (dropped) throw newError("core.itemNotSupported", [`bucket "${dropped.type}"`], updateErrorContext(errorContext, { path: ["buckets", dropped.type] }));
+		}
+	};
+}
 function declarativeReportToYaml(entities, def, errorContext) {
 	const report = new import_dist.YAMLMap();
 	const { fieldsMap, postProcessors, groups: derivedBuckets } = declarativeBucketsToYaml(entities, def.buckets, updateErrorContext(errorContext, { path: ["buckets"] }));
@@ -140829,7 +141241,7 @@ function declarativeReportToYaml(entities, def, errorContext) {
 	});
 	return {
 		report,
-		derivedBuckets
+		buckets: bucketRegistry(derivedBuckets)
 	};
 }
 function appendLayerFieldsToReport(fieldsMap, postProcessors, entities, layers, errorContext) {
@@ -140969,6 +141381,7 @@ function declarativeBucketsToYaml(entities, buckets, errorContext) {
 	const groups = [];
 	const postProcessors = { filters: [] };
 	const addField = (local, def, group, { format, axis } = {}) => {
+		if (fullFieldsMap.has(local)) throw newError("core.duplicateFieldName", [local], errorContext);
 		fullFieldsMap.add(new import_dist.Pair(local, def));
 		group.items.push(createBucketGroupItem(local, format, axis));
 	};
@@ -141138,333 +141551,6 @@ function getShortenedBucket(def) {
 	}
 	return false;
 }
-function detectEmptyValuesFilterType(filter) {
-	const attributeElements = filterAttributeElements(filter);
-	const items = attributeElements ? getAttributeElementsItems(attributeElements) : [];
-	if (items.length !== 1 || items[0] !== "") return;
-	return isPositiveAttributeFilter$1(filter) ? "only" : "exclude";
-}
-function getObjRefGroupingKey(objRef) {
-	if (!objRef || typeof objRef !== "object") return;
-	if ("identifier" in objRef) {
-		const identifier = objRef.identifier;
-		if (typeof identifier === "string") return identifier;
-		if (identifier && typeof identifier === "object" && "id" in identifier) {
-			const id = identifier.id;
-			if (typeof id === "string") return id;
-		}
-	}
-	if ("uri" in objRef) {
-		const uri = objRef.uri;
-		if (typeof uri === "string") return uri;
-	}
-	if ("localIdentifier" in objRef) {
-		const localIdentifier = objRef.localIdentifier;
-		if (typeof localIdentifier === "string") return localIdentifier;
-	}
-	return serializeObjRef(objRef);
-}
-/**
-* Groups date filters with their associated attribute filters. Leaves the rest alone.
-* @param filters
-*/
-function groupFiltersByDateFilter(filters) {
-	const dateFilters = [...filters].filter(isDateFilter$1);
-	const nonDateFilters = [...filters].filter((f) => !isDateFilter$1(f));
-	const result = {
-		grouped: {},
-		rest: []
-	};
-	const getFilterRefDetails = (filter) => {
-		const objRef = filterObjRef(filter);
-		if (!objRef) return {
-			objRef: void 0,
-			filterRef: void 0
-		};
-		return {
-			objRef,
-			filterRef: getObjRefGroupingKey(objRef)
-		};
-	};
-	dateFilters.forEach((dateFilter) => {
-		const { filterRef: datasetId } = getFilterRefDetails(dateFilter);
-		const fi = filters.indexOf(dateFilter);
-		if (datasetId === void 0) {
-			result.rest.push([dateFilter, fi]);
-			return;
-		}
-		if (result.grouped[datasetId]) result.rest.push([dateFilter, fi]);
-		else result.grouped[datasetId] = {
-			dateFilter: [dateFilter, fi],
-			attributeFilters: []
-		};
-	});
-	nonDateFilters.forEach((filter) => {
-		const { filterRef: filterId } = getFilterRefDetails(filter);
-		const fi = filters.indexOf(filter);
-		if (filterId === void 0) {
-			result.rest.push([filter, fi]);
-			return;
-		}
-		const datasetId = filterId.split(".")[0];
-		const group = result.grouped[datasetId];
-		if (group) group.attributeFilters.push([filter, fi]);
-		else result.rest.push([filter, fi]);
-	});
-	return result;
-}
-/** @internal */
-function declarativeFiltersToYaml(entities, filters, errorContext) {
-	const filtersArray = [];
-	const filtersMap = {};
-	const usedKeys = /* @__PURE__ */ new Set();
-	const getUniqueKey = (baseKey) => {
-		let key = baseKey;
-		let suffix = 2;
-		while (usedKeys.has(key)) {
-			key = `${baseKey}_${suffix}`;
-			suffix += 1;
-		}
-		usedKeys.add(key);
-		return key;
-	};
-	const filtersGroupedByDateFilter = groupFiltersByDateFilter(filters);
-	filtersGroupedByDateFilter.rest.forEach(([filter, fi]) => {
-		const result = declarativeFilterToYaml(entities, filter, getUniqueKey, void 0, updateErrorContext(errorContext, { path: [fi.toString()] }));
-		if (!result) return;
-		const { key, yaml, filter: originalFilter } = result;
-		filtersArray.push(new import_dist.Pair(key, yaml));
-		filtersMap[key] = {
-			yaml,
-			filter: originalFilter
-		};
-	});
-	Object.values(filtersGroupedByDateFilter.grouped).forEach(({ dateFilter, attributeFilters }) => {
-		const result = declarativeFilterToYaml(entities, dateFilter[0], getUniqueKey, attributeFilters.map(([f]) => f), updateErrorContext(errorContext, { path: [dateFilter[1].toString()] }));
-		if (!result) return;
-		const { key, yaml, filter: originalFilter } = result;
-		filtersArray.push(new import_dist.Pair(key, yaml));
-		filtersMap[key] = {
-			yaml,
-			filter: originalFilter
-		};
-	});
-	return {
-		filtersMap,
-		filtersArray: filtersArray.reduce((map, filter) => {
-			map.add(filter);
-			return map;
-		}, new import_dist.YAMLMap())
-	};
-}
-function declarativeFilterToYaml(entities, filter, getUniqueKey, connectedAttributeFilters, errorContext) {
-	if (!isFilter(filter)) return null;
-	const key = getUniqueKey(createFilterItemKeyName(filter, "date", updateErrorContext(errorContext, { path: ["date"] })));
-	if (isAbsoluteDateFilter$1(filter)) return {
-		key,
-		yaml: declarativeAbsoluteDateFilterToYaml(filter.absoluteDateFilter, connectedAttributeFilters, entities, getUniqueKey, updateErrorContext(errorContext, { path: ["absoluteDateFilter"] })),
-		filter
-	};
-	if (isRelativeDateFilter$1(filter)) return {
-		key,
-		yaml: declarativeRelativeDateFilterToYaml(filter.relativeDateFilter, connectedAttributeFilters, entities, getUniqueKey, updateErrorContext(errorContext, { path: ["relativeDateFilter"] })),
-		filter
-	};
-	if (isPositiveAttributeFilter$1(filter)) return {
-		key,
-		yaml: declarativePositiveAttributeFilterToYaml(entities, filter.positiveAttributeFilter, updateErrorContext(errorContext, { path: ["positiveAttributeFilter"] })),
-		filter
-	};
-	if (isNegativeAttributeFilter$1(filter)) return {
-		key,
-		yaml: declarativeNegativeAttributeFilterToYaml(entities, filter.negativeAttributeFilter, updateErrorContext(errorContext, { path: ["negativeAttributeFilter"] })),
-		filter
-	};
-	if (isArbitraryAttributeFilter(filter)) return {
-		key,
-		yaml: declarativeArbitraryAttributeFilterToYaml(filter.arbitraryAttributeFilter, updateErrorContext(errorContext, { path: ["arbitraryAttributeFilter"] })),
-		filter
-	};
-	if (isMatchAttributeFilter(filter)) return {
-		key,
-		yaml: declarativeMatchAttributeFilterToYaml(filter.matchAttributeFilter, updateErrorContext(errorContext, { path: ["matchAttributeFilter"] })),
-		filter
-	};
-	if (isMeasureValueFilter(filter)) return {
-		key,
-		yaml: declarativeMeasureValueFilterToYaml$1(filter.measureValueFilter, updateErrorContext(errorContext, { path: ["measureValueFilter"] })),
-		filter
-	};
-	if (isRankingFilter$1(filter)) return {
-		key,
-		yaml: declarativeRankingFilterToYaml(filter.rankingFilter, updateErrorContext(errorContext, { path: ["rankingFilter"] })),
-		filter
-	};
-	throw newError("core.filterItemTypeNotSupported", [JSON.stringify(filter)], errorContext);
-}
-/**
-* Modifies `map`, adding `empty_filters` and `with` keys, populated from connectedAttributeFilters.
-*/
-function processConnectedAttributeFilters(map, connectedAttributeFilters, entities, getUniqueKey, errorContext) {
-	const emptyValuesFilter = connectedAttributeFilters.find((filter) => detectEmptyValuesFilterType(filter));
-	if (emptyValuesFilter) map.add(new import_dist.Pair("empty_values", detectEmptyValuesFilterType(emptyValuesFilter)));
-	const additionalAttributeFilters = connectedAttributeFilters.filter((filter) => filter !== emptyValuesFilter);
-	if (additionalAttributeFilters.length === 0) return;
-	const withMap = new import_dist.YAMLMap();
-	map.add(new import_dist.Pair("with", withMap));
-	additionalAttributeFilters?.forEach((filter) => {
-		const converted = declarativeFilterToYaml(entities, filter, getUniqueKey, void 0, errorContext);
-		if (!converted) return;
-		withMap.add(new import_dist.Pair(converted.key, converted.yaml));
-	});
-}
-/** @internal */
-function declarativeAbsoluteDateFilterToYaml(absoluteDateFilter, connectedAttributeFilters = [], entities, getUniqueKey, errorContext) {
-	const map = new import_dist.YAMLMap();
-	map.add(new import_dist.Pair("type", "date_filter"));
-	map.add(new import_dist.Pair("from", absoluteDateFilter.from));
-	map.add(new import_dist.Pair("to", absoluteDateFilter.to));
-	const id = getIdentifier(absoluteDateFilter.dataSet, true, updateErrorContext(errorContext, { path: ["dateSet"] }));
-	map.add(new import_dist.Pair("using", id));
-	processConnectedAttributeFilters(map, connectedAttributeFilters, entities, getUniqueKey, errorContext);
-	return map;
-}
-function isRelativeDateFilterAllTime(relativeDateFilter) {
-	const { granularity, from, to } = relativeDateFilter;
-	if (granularity === "ALL_TIME_GRANULARITY") return true;
-	return granularity === "GDC.time.year" && from === void 0 && to === void 0;
-}
-/** @internal */
-function declarativeRelativeDateFilterToYaml(relativeDateFilter, connectedAttributeFilters = [], entities, getUniqueKey, errorContext) {
-	const map = new import_dist.YAMLMap();
-	map.add(new import_dist.Pair("type", "date_filter"));
-	if (isRelativeDateFilterAllTime(relativeDateFilter)) {} else {
-		if (relativeDateFilter.granularity) map.add(new import_dist.Pair("granularity", parseGranularity(relativeDateFilter.granularity)));
-		if (relativeDateFilter.from !== void 0 && relativeDateFilter.to !== void 0) {
-			map.add(new import_dist.Pair("from", relativeDateFilter.from));
-			map.add(new import_dist.Pair("to", relativeDateFilter.to));
-		}
-	}
-	const id = getIdentifier(relativeDateFilter.dataSet, true, updateErrorContext(errorContext, { path: ["dataSet"] }));
-	map.add(new import_dist.Pair("using", id));
-	processConnectedAttributeFilters(map, connectedAttributeFilters, entities, getUniqueKey, errorContext);
-	return map;
-}
-/** @internal */
-function declarativePositiveAttributeFilterToYaml(entities, attributeFilter, errorContext) {
-	const map = new import_dist.YAMLMap();
-	map.add(new import_dist.Pair("type", "attribute_filter"));
-	const id = getIdentifier(attributeFilter.displayForm, void 0, updateErrorContext(errorContext, { path: ["displayForm"] }));
-	map.add(new import_dist.Pair("using", id));
-	if (isAttributeElementsByValue(attributeFilter.in)) {
-		const values = attributeFilter.in.values.filter((v) => v !== null && v !== void 0);
-		map.add(new import_dist.Pair("state", new import_dist.Pair("include", parseDateValues(entities, id, values))));
-	}
-	return map;
-}
-/** @internal */
-function declarativeNegativeAttributeFilterToYaml(entities, attributeFilter, errorContext) {
-	const map = new import_dist.YAMLMap();
-	map.add(new import_dist.Pair("type", "attribute_filter"));
-	const id = getIdentifier(attributeFilter.displayForm, void 0, updateErrorContext(errorContext, { path: ["displayForm"] }));
-	map.add(new import_dist.Pair("using", id));
-	if (isAttributeElementsByValue(attributeFilter.notIn)) {
-		const values = attributeFilter.notIn.values.filter((v) => v !== null && v !== void 0);
-		if (values.length > 0) map.add(new import_dist.Pair("state", new import_dist.Pair("exclude", parseDateValues(entities, id, values))));
-	}
-	return map;
-}
-function declarativeArbitraryAttributeFilterToYaml(attributeFilter, errorContext) {
-	const map = new import_dist.YAMLMap();
-	map.add(new import_dist.Pair("type", "text_filter"));
-	map.add(new import_dist.Pair("using", getIdentifier(attributeFilter.label, void 0, updateErrorContext(errorContext, { path: ["label"] }))));
-	map.add(new import_dist.Pair("condition", attributeFilter.negativeSelection ? "isNot" : "is"));
-	map.add(new import_dist.Pair("values", attributeFilter.values));
-	return map;
-}
-function declarativeMatchAttributeFilterToYaml(attributeFilter, errorContext) {
-	const map = new import_dist.YAMLMap();
-	map.add(new import_dist.Pair("type", "text_filter"));
-	map.add(new import_dist.Pair("using", getIdentifier(attributeFilter.label, void 0, updateErrorContext(errorContext, { path: ["label"] }))));
-	map.add(new import_dist.Pair("condition", matchConditionToYaml(attributeFilter.operator, attributeFilter.negativeSelection)));
-	map.add(new import_dist.Pair("value", attributeFilter.literal));
-	if (attributeFilter.caseSensitive !== void 0) map.add(new import_dist.Pair("case_sensitive", attributeFilter.caseSensitive));
-	return map;
-}
-function addSingleConditionToYaml(map, condition) {
-	if (isComparisonCondition(condition)) {
-		const comp = condition.comparison;
-		map.add(new import_dist.Pair("condition", comp.operator.toUpperCase()));
-		map.add(new import_dist.Pair("value", comp.value));
-		map.add(new import_dist.Pair("null_values_as_zero", comp.treatNullValuesAs !== void 0));
-	} else if (isRangeCondition(condition)) {
-		const range = condition.range;
-		map.add(new import_dist.Pair("condition", range.operator.toUpperCase()));
-		map.add(new import_dist.Pair("from", range.from));
-		map.add(new import_dist.Pair("to", range.to));
-		map.add(new import_dist.Pair("null_values_as_zero", range.treatNullValuesAs !== void 0));
-	}
-}
-function addConditionToYamlMap(conditionMap, condition) {
-	let hasTreatNullValues = false;
-	if (isComparisonCondition(condition)) {
-		const comp = condition.comparison;
-		conditionMap.add(new import_dist.Pair("condition", comp.operator.toUpperCase()));
-		conditionMap.add(new import_dist.Pair("value", comp.value));
-		if (comp.treatNullValuesAs !== void 0) hasTreatNullValues = true;
-	} else if (isRangeCondition(condition)) {
-		const range = condition.range;
-		conditionMap.add(new import_dist.Pair("condition", range.operator.toUpperCase()));
-		conditionMap.add(new import_dist.Pair("from", range.from));
-		conditionMap.add(new import_dist.Pair("to", range.to));
-		if (range.treatNullValuesAs !== void 0) hasTreatNullValues = true;
-	}
-	return hasTreatNullValues;
-}
-/** @internal */
-function declarativeMeasureValueFilterToYaml$1(measureValueFilter, errorContext) {
-	const map = new import_dist.YAMLMap();
-	map.add(new import_dist.Pair("type", "metric_value_filter"));
-	if (isLocalIdRef(measureValueFilter.measure)) map.add(new import_dist.Pair("using", measureValueFilter.measure.localIdentifier));
-	else map.add(new import_dist.Pair("using", getIdentifier(measureValueFilter.measure, void 0, updateErrorContext(errorContext, { path: ["measure"] }))));
-	if (measureValueFilter.conditions && measureValueFilter.conditions.length > 1) {
-		const conditionsSeq = new import_dist.YAMLSeq();
-		let treatNullValuesAsZero = false;
-		measureValueFilter.conditions.forEach((cond) => {
-			const conditionMap = new import_dist.YAMLMap();
-			if (addConditionToYamlMap(conditionMap, cond)) treatNullValuesAsZero = true;
-			conditionsSeq.add(conditionMap);
-		});
-		map.add(new import_dist.Pair("conditions", conditionsSeq));
-		if (treatNullValuesAsZero) map.add(new import_dist.Pair("null_values_as_zero", true));
-	} else if (measureValueFilter.conditions?.length === 1) addSingleConditionToYaml(map, measureValueFilter.conditions[0]);
-	else if (measureValueFilter.condition) addSingleConditionToYaml(map, measureValueFilter.condition);
-	if (measureValueFilter.dimensionality && Array.isArray(measureValueFilter.dimensionality)) {
-		const dimensionalitySeq = new import_dist.YAMLSeq();
-		measureValueFilter.dimensionality.forEach((item) => {
-			if (isLocalIdRef(item)) dimensionalitySeq.add(item.localIdentifier);
-			else dimensionalitySeq.add(getIdentifier(item));
-		});
-		map.add(new import_dist.Pair("dimensionality", dimensionalitySeq));
-	}
-	return map;
-}
-/** @internal */
-function declarativeRankingFilterToYaml(rankingFilter, errorContext) {
-	const map = new import_dist.YAMLMap();
-	map.add(new import_dist.Pair("type", "ranking_filter"));
-	if (isLocalIdRef(rankingFilter.measure)) map.add(new import_dist.Pair("using", rankingFilter.measure.localIdentifier));
-	else map.add(new import_dist.Pair("using", getIdentifier(rankingFilter.measure, void 0, updateErrorContext(errorContext, { path: ["measure"] }))));
-	if (rankingFilter.operator === "TOP") map.add(new import_dist.Pair("top", rankingFilter.value));
-	if (rankingFilter.operator === "BOTTOM") map.add(new import_dist.Pair("bottom", rankingFilter.value));
-	if (rankingFilter.attributes?.[0]) {
-		const first = rankingFilter.attributes[0];
-		if (isLocalIdRef(first)) map.add(new import_dist.Pair("attribute", first.localIdentifier));
-		else map.add(new import_dist.Pair("attribute", getIdentifier(first)));
-	}
-	if (rankingFilter.strictLimitOfRows !== void 0) map.add(new import_dist.Pair("strict_limit_of_rows", rankingFilter.strictLimitOfRows));
-	return map;
-}
 /** @internal */
 function declarativeSortsToYaml(sorts, _errorContext) {
 	const sortsArray = [];
@@ -141509,151 +141595,151 @@ function declarativeMeasureSortToYaml(sort) {
 	return map;
 }
 function declarativeVisTableToYaml(doc, def, report, _context) {
-	const metrics = report.derivedBuckets.find((item) => item.type === "measures");
+	const metrics = report.buckets.consume("measures");
 	if (metrics && metrics.items.length > 0) doc.add(entryWithSpace("metrics", groupToYaml(metrics)));
-	const attribute = report.derivedBuckets.find((item) => item.type === "attribute");
+	const attribute = report.buckets.consume("attribute");
 	if (attribute && attribute.items.length > 0) doc.add(entryWithSpace("view_by", groupToYaml(attribute)));
-	const columns = report.derivedBuckets.find((item) => item.type === "columns");
+	const columns = report.buckets.consume("columns");
 	if (columns && columns.items.length > 0) doc.add(entryWithSpace("segment_by", groupToYaml(columns)));
 	const config = table.load(def.properties);
 	if (config) doc.add(config);
 }
 function declarativeVisBarToYaml(doc, def, report, _errorContext) {
-	const metrics = report.derivedBuckets.find((item) => item.type === "measures");
+	const metrics = report.buckets.consume("measures");
 	if (metrics && metrics.items.length > 0) doc.add(entryWithSpace("metrics", groupToYaml(metrics)));
-	const view = report.derivedBuckets.find((item) => item.type === "view");
+	const view = report.buckets.consume("view");
 	if (view && view.items.length > 0) doc.add(entryWithSpace("view_by", groupToYaml(view)));
-	const stack = report.derivedBuckets.find((item) => item.type === "stack");
+	const stack = report.buckets.consume("stack");
 	if (stack && stack.items.length > 0) doc.add(entryWithSpace("segment_by", groupToYaml(stack)));
 	const config = barChart.load(def.properties);
 	if (config) doc.add(config);
 }
 function declarativeVisColumnToYaml(doc, def, report, _errorContext) {
-	const metrics = report.derivedBuckets.find((item) => item.type === "measures");
+	const metrics = report.buckets.consume("measures");
 	if (metrics && metrics.items.length > 0) doc.add(entryWithSpace("metrics", groupToYaml(metrics)));
-	const view = report.derivedBuckets.find((item) => item.type === "view");
+	const view = report.buckets.consume("view");
 	if (view && view.items.length > 0) doc.add(entryWithSpace("view_by", groupToYaml(view)));
-	const stack = report.derivedBuckets.find((item) => item.type === "stack");
+	const stack = report.buckets.consume("stack");
 	if (stack && stack.items.length > 0) doc.add(entryWithSpace("segment_by", groupToYaml(stack)));
 	const config = columnChart.load(def.properties);
 	if (config) doc.add(config);
 }
 function declarativeVisLineToYaml(doc, def, report, _errorContext) {
-	const metrics = report.derivedBuckets.find((item) => item.type === "measures");
+	const metrics = report.buckets.consume("measures");
 	if (metrics && metrics.items.length > 0) doc.add(entryWithSpace("metrics", groupToYaml(metrics)));
-	const trend = report.derivedBuckets.find((item) => item.type === "trend");
+	const trend = report.buckets.consume("trend");
 	if (trend && trend.items.length > 0) doc.add(entryWithSpace("view_by", groupToYaml(trend)));
-	const segment = report.derivedBuckets.find((item) => item.type === "segment");
+	const segment = report.buckets.consume("segment");
 	if (segment && segment.items.length > 0) doc.add(entryWithSpace("segment_by", groupToYaml(segment)));
 	const config = lineChart.load(def.properties);
 	if (config) doc.add(config);
 }
 function declarativeVisRadarToYaml(doc, def, report, _errorContext) {
-	const metrics = report.derivedBuckets.find((item) => item.type === "measures");
+	const metrics = report.buckets.consume("measures");
 	if (metrics && metrics.items.length > 0) doc.add(entryWithSpace("metrics", groupToYaml(metrics)));
-	const trend = report.derivedBuckets.find((item) => item.type === "trend");
+	const trend = report.buckets.consume("trend");
 	if (trend && trend.items.length > 0) doc.add(entryWithSpace("view_by", groupToYaml(trend)));
-	const segment = report.derivedBuckets.find((item) => item.type === "segment");
+	const segment = report.buckets.consume("segment");
 	if (segment && segment.items.length > 0) doc.add(entryWithSpace("segment_by", groupToYaml(segment)));
 	const config = radarChart.load(def.properties);
 	if (config) doc.add(config);
 }
 function declarativeVisAreaToYaml(doc, def, report, _errorContext) {
-	const metrics = report.derivedBuckets.find((item) => item.type === "measures");
+	const metrics = report.buckets.consume("measures");
 	if (metrics && metrics.items.length > 0) doc.add(entryWithSpace("metrics", groupToYaml(metrics)));
-	const view = report.derivedBuckets.find((item) => item.type === "view");
+	const view = report.buckets.consume("view");
 	if (view && view.items.length > 0) doc.add(entryWithSpace("view_by", groupToYaml(view)));
-	const stack = report.derivedBuckets.find((item) => item.type === "stack");
+	const stack = report.buckets.consume("stack");
 	if (stack && stack.items.length > 0) doc.add(entryWithSpace("segment_by", groupToYaml(stack)));
 	const config = areaChart.load(def.properties);
 	if (config) doc.add(config);
 }
 function declarativeVisScatterToYaml(doc, def, report, _errorContext) {
-	const metrics1 = report.derivedBuckets.find((item) => item.type === "measures");
-	const metrics2 = report.derivedBuckets.find((item) => item.type === "secondary_measures");
+	const metrics1 = report.buckets.consume("measures");
+	const metrics2 = report.buckets.consume("secondary_measures");
 	const metrics = {
 		items: cleanUpItems([...metrics1?.items.length ? metrics1.items : [null], ...metrics2?.items.length ? metrics2.items : [null]]),
 		type: "measures"
 	};
 	if (metrics.items.length > 0) doc.add(entryWithSpace("metrics", groupToYaml(metrics)));
-	const attributes = report.derivedBuckets.find((item) => item.type === "attribute");
+	const attributes = report.buckets.consume("attribute");
 	if (attributes && attributes.items.length > 0) doc.add(entryWithSpace("view_by", groupToYaml(attributes)));
-	const segments = report.derivedBuckets.find((item) => item.type === "segment");
+	const segments = report.buckets.consume("segment");
 	if (segments && segments.items.length > 0) doc.add(entryWithSpace("segment_by", groupToYaml(segments)));
 	const config = scatterChart.load(def.properties);
 	if (config) doc.add(config);
 }
 function declarativeVisBubbleToYaml(doc, def, report, _errorContext) {
-	const metrics1 = report.derivedBuckets.find((item) => item.type === "measures");
-	const metrics2 = report.derivedBuckets.find((item) => item.type === "secondary_measures");
+	const metrics1 = report.buckets.consume("measures");
+	const metrics2 = report.buckets.consume("secondary_measures");
 	const metrics = {
 		items: cleanUpItems([...metrics1?.items.length ? metrics1.items : [null], ...metrics2?.items.length ? metrics2.items : [null]]),
 		type: "measures"
 	};
 	if (metrics.items.length > 0) doc.add(entryWithSpace("metrics", groupToYaml(metrics)));
-	const view = report.derivedBuckets.find((item) => item.type === "view");
+	const view = report.buckets.consume("view");
 	if (view && view.items.length > 0) doc.add(entryWithSpace("view_by", groupToYaml(view)));
-	const tertiaryMetrics = report.derivedBuckets.find((item) => item.type === "tertiary_measures");
+	const tertiaryMetrics = report.buckets.consume("tertiary_measures");
 	if (tertiaryMetrics && tertiaryMetrics.items.length > 0) doc.add(entryWithSpace("segment_by", groupToYaml(tertiaryMetrics)));
 	const config = bubbleChart.load(def.properties);
 	if (config) doc.add(config);
 }
 function declarativeVisPieToYaml(doc, def, report, _errorContext) {
-	const metrics = report.derivedBuckets.find((item) => item.type === "measures");
+	const metrics = report.buckets.consume("measures");
 	if (metrics && metrics.items.length > 0) doc.add(entryWithSpace("metrics", groupToYaml(metrics)));
-	const view = report.derivedBuckets.find((item) => item.type === "view");
+	const view = report.buckets.consume("view");
 	if (view && view.items.length > 0) doc.add(entryWithSpace("view_by", groupToYaml(view)));
 	const config = pieChart.load(def.properties);
 	if (config) doc.add(config);
 }
 function declarativeVisDonutToYaml(doc, def, report, _errorContext) {
-	const metrics = report.derivedBuckets.find((item) => item.type === "measures");
+	const metrics = report.buckets.consume("measures");
 	if (metrics && metrics.items.length > 0) doc.add(entryWithSpace("metrics", groupToYaml(metrics)));
-	const view = report.derivedBuckets.find((item) => item.type === "view");
+	const view = report.buckets.consume("view");
 	if (view && view.items.length > 0) doc.add(entryWithSpace("view_by", groupToYaml(view)));
 	const config = donutChart.load(def.properties);
 	if (config) doc.add(config);
 }
 function declarativeVisTreemapToYaml(doc, def, report, _errorContext) {
-	const metrics = report.derivedBuckets.find((item) => item.type === "measures");
+	const metrics = report.buckets.consume("measures");
 	if (metrics && metrics.items.length > 0) doc.add(entryWithSpace("metrics", groupToYaml(metrics)));
-	const view = report.derivedBuckets.find((item) => item.type === "view");
+	const view = report.buckets.consume("view");
 	if (view && view.items.length > 0) doc.add(entryWithSpace("view_by", groupToYaml(view)));
-	const segment = report.derivedBuckets.find((item) => item.type === "segment");
+	const segment = report.buckets.consume("segment");
 	if (segment && segment.items.length > 0) doc.add(entryWithSpace("segment_by", groupToYaml(segment)));
 	const config = treemapChart.load(def.properties);
 	if (config) doc.add(config);
 }
 function declarativeVisPyramidToYaml(doc, def, report, _errorContext) {
-	const metrics = report.derivedBuckets.find((item) => item.type === "measures");
+	const metrics = report.buckets.consume("measures");
 	if (metrics && metrics.items.length > 0) doc.add(entryWithSpace("metrics", groupToYaml(metrics)));
-	const view = report.derivedBuckets.find((item) => item.type === "view");
+	const view = report.buckets.consume("view");
 	if (view && view.items.length > 0) doc.add(entryWithSpace("view_by", groupToYaml(view)));
 	const config = pyramidChart.load(def.properties);
 	if (config) doc.add(config);
 }
 function declarativeVisFunnelToYaml(doc, def, report, _errorContext) {
-	const metrics = report.derivedBuckets.find((item) => item.type === "measures");
+	const metrics = report.buckets.consume("measures");
 	if (metrics && metrics.items.length > 0) doc.add(entryWithSpace("metrics", groupToYaml(metrics)));
-	const view = report.derivedBuckets.find((item) => item.type === "view");
+	const view = report.buckets.consume("view");
 	if (view && view.items.length > 0) doc.add(entryWithSpace("view_by", groupToYaml(view)));
 	const config = funnelChart.load(def.properties);
 	if (config) doc.add(config);
 }
 function declarativeVisHeatmapToYaml(doc, def, report, _errorContext) {
-	const metrics = report.derivedBuckets.find((item) => item.type === "measures");
+	const metrics = report.buckets.consume("measures");
 	if (metrics && metrics.items.length > 0) doc.add(entryWithSpace("metrics", groupToYaml(metrics)));
-	const view = report.derivedBuckets.find((item) => item.type === "view");
+	const view = report.buckets.consume("view");
 	if (view && view.items.length > 0) doc.add(entryWithSpace("view_by", groupToYaml(view)));
-	const stack = report.derivedBuckets.find((item) => item.type === "stack");
+	const stack = report.buckets.consume("stack");
 	if (stack && stack.items.length > 0) doc.add(entryWithSpace("segment_by", groupToYaml(stack)));
 	const config = heatmapChart.load(def.properties);
 	if (config) doc.add(config);
 }
 function declarativeVisBulletToYaml(doc, def, report, _errorContext) {
-	const metrics1 = report.derivedBuckets.find((item) => item.type === "measures");
-	const metrics2 = report.derivedBuckets.find((item) => item.type === "secondary_measures");
-	const metrics3 = report.derivedBuckets.find((item) => item.type === "tertiary_measures");
+	const metrics1 = report.buckets.consume("measures");
+	const metrics2 = report.buckets.consume("secondary_measures");
+	const metrics3 = report.buckets.consume("tertiary_measures");
 	const metrics = {
 		items: cleanUpItems([
 			...metrics1?.items.length ? metrics1.items : [null],
@@ -141663,24 +141749,24 @@ function declarativeVisBulletToYaml(doc, def, report, _errorContext) {
 		type: "measures"
 	};
 	if (metrics.items.length > 0) doc.add(entryWithSpace("metrics", groupToYaml(metrics)));
-	const view = report.derivedBuckets.find((item) => item.type === "view");
+	const view = report.buckets.consume("view");
 	if (view && view.items.length > 0) doc.add(entryWithSpace("view_by", groupToYaml(view)));
 	const config = bulletChart.load(def.properties);
 	if (config) doc.add(config);
 }
 function declarativeVisWaterfallToYaml(doc, def, report, _errorContext) {
-	const metrics = report.derivedBuckets.find((item) => item.type === "measures");
+	const metrics = report.buckets.consume("measures");
 	if (metrics && metrics.items.length > 0) doc.add(entryWithSpace("metrics", groupToYaml(metrics)));
-	const view = report.derivedBuckets.find((item) => item.type === "view");
+	const view = report.buckets.consume("view");
 	if (view && view.items.length > 0) doc.add(entryWithSpace("view_by", groupToYaml(view)));
 	const config = waterfallChart.load(def.properties);
 	if (config) doc.add(config);
 }
 function declarativeVisDependencyWheelToYaml(doc, def, report, _errorContext) {
-	const metrics = report.derivedBuckets.find((item) => item.type === "measures");
+	const metrics = report.buckets.consume("measures");
 	if (metrics && metrics.items.length > 0) doc.add(entryWithSpace("metrics", groupToYaml(metrics)));
-	const from = report.derivedBuckets.find((item) => item.type === "attribute_from");
-	const to = report.derivedBuckets.find((item) => item.type === "attribute_to");
+	const from = report.buckets.consume("attribute_from");
+	const to = report.buckets.consume("attribute_to");
 	const view = {
 		items: cleanUpItems([...from?.items.length ? from.items : [null], ...to?.items.length ? to.items : [null]]),
 		type: "view"
@@ -141690,10 +141776,10 @@ function declarativeVisDependencyWheelToYaml(doc, def, report, _errorContext) {
 	if (config) doc.add(config);
 }
 function declarativeVisSankeyToYaml(doc, def, report, _errorContext) {
-	const metrics = report.derivedBuckets.find((item) => item.type === "measures");
+	const metrics = report.buckets.consume("measures");
 	if (metrics && metrics.items.length > 0) doc.add(entryWithSpace("metrics", groupToYaml(metrics)));
-	const from = report.derivedBuckets.find((item) => item.type === "attribute_from");
-	const to = report.derivedBuckets.find((item) => item.type === "attribute_to");
+	const from = report.buckets.consume("attribute_from");
+	const to = report.buckets.consume("attribute_to");
 	const view = {
 		items: cleanUpItems([...from?.items.length ? from.items : [null], ...to?.items.length ? to.items : [null]]),
 		type: "view"
@@ -141703,8 +141789,8 @@ function declarativeVisSankeyToYaml(doc, def, report, _errorContext) {
 	if (config) doc.add(config);
 }
 function declarativeVisHeadlineToYaml(doc, def, report, _errorContext) {
-	const metrics1 = report.derivedBuckets.find((item) => item.type === "measures");
-	const metrics2 = report.derivedBuckets.find((item) => item.type === "secondary_measures");
+	const metrics1 = report.buckets.consume("measures");
+	const metrics2 = report.buckets.consume("secondary_measures");
 	const metrics = {
 		items: [...metrics1?.items ?? [null], ...metrics2?.items ?? []],
 		type: "measures"
@@ -141714,51 +141800,51 @@ function declarativeVisHeadlineToYaml(doc, def, report, _errorContext) {
 	if (config) doc.add(config);
 }
 function declarativeVisComboToYaml(doc, def, report, _errorContext) {
-	const metrics1 = addAxisTypeToGroup(report.derivedBuckets.find((item) => item.type === "measures"), "primary");
-	const metrics2 = addAxisTypeToGroup(report.derivedBuckets.find((item) => item.type === "secondary_measures"), "secondary");
+	const metrics1 = addAxisTypeToGroup(report.buckets.consume("measures"), "primary");
+	const metrics2 = addAxisTypeToGroup(report.buckets.consume("secondary_measures"), "secondary");
 	const metrics = {
 		items: [...metrics1?.items ?? [], ...metrics2?.items ?? []],
 		type: "measures"
 	};
 	if (metrics && metrics.items.length > 0) doc.add(entryWithSpace("metrics", groupToYaml(metrics)));
-	const view = report.derivedBuckets.find((item) => item.type === "view");
+	const view = report.buckets.consume("view");
 	if (view && view.items.length > 0) doc.add(entryWithSpace("view_by", groupToYaml(view)));
 	const config = comboChart.load(def.properties);
 	if (config) doc.add(config);
 }
-function addPushpinBucketsToYaml(target, groups) {
-	const sizeBucket = groups.find((item) => item.type === "size");
-	const colorBucket = groups.find((item) => item.type === "color");
+function addPushpinBucketsToYaml(target, buckets) {
+	const sizeBucket = buckets.consume("size");
+	const colorBucket = buckets.consume("color");
 	const metrics = {
 		items: cleanUpItems([...sizeBucket?.items.length ? sizeBucket.items : [null], ...colorBucket?.items ? colorBucket.items : [null]]),
 		type: "measures"
 	};
 	if (metrics.items.length > 0) target.add(entryWithSpace("metrics", groupToYaml(metrics)));
-	const location = groups.find((item) => item.type === "location");
+	const location = buckets.consume("location");
 	if (location && location.items.length > 0) target.add(entryWithSpace("view_by", groupToYaml(location)));
-	const segment = groups.find((item) => item.type === "segment");
+	const segment = buckets.consume("segment");
 	if (segment && segment.items.length > 0) target.add(entryWithSpace("segment_by", groupToYaml(segment)));
 }
-function addGeoAreaBucketsToYaml(target, groups) {
-	const colorBucket = groups.find((item) => item.type === "color");
+function addGeoAreaBucketsToYaml(target, buckets) {
+	const colorBucket = buckets.consume("color");
 	const metrics = {
 		items: cleanUpItems([...colorBucket?.items.length ? colorBucket.items : [null]]),
 		type: "measures"
 	};
 	if (metrics.items.length > 0) target.add(entryWithSpace("metrics", groupToYaml(metrics)));
-	const area = groups.find((item) => item.type === "area");
+	const area = buckets.consume("area");
 	if (area && area.items.length > 0) target.add(entryWithSpace("view_by", groupToYaml(area)));
-	const segment = groups.find((item) => item.type === "segment");
+	const segment = buckets.consume("segment");
 	if (segment && segment.items.length > 0) target.add(entryWithSpace("segment_by", groupToYaml(segment)));
 }
 function declarativeVisGeoToYaml(doc, def, report, entities, errorContext) {
-	addPushpinBucketsToYaml(doc, report.derivedBuckets);
+	addPushpinBucketsToYaml(doc, report.buckets);
 	const config = geoChart.load(def.properties);
 	if (config) doc.add(config);
 	appendLayers(doc, def, entities, errorContext);
 }
 function declarativeVisGeoAreaToYaml(doc, def, report, entities, errorContext) {
-	addGeoAreaBucketsToYaml(doc, report.derivedBuckets);
+	addGeoAreaBucketsToYaml(doc, report.buckets);
 	const config = geoAreaChart.load(def.properties);
 	if (config) doc.add(config);
 	appendLayers(doc, def, entities, errorContext);
@@ -141770,11 +141856,11 @@ function appendLayers(doc, def, entities, errorContext) {
 	if (layers.items.length > 0) doc.add(entryWithSpace("layers", layers));
 }
 function declarativeVisRepeaterToYaml(doc, def, report, _errorContext) {
-	const columnsMapped = addChartTypeToGroup(report.derivedBuckets.find((item) => item.type === "columns"), def.properties);
+	const columnsMapped = addChartTypeToGroup(report.buckets.consume("columns"), def.properties);
 	if (columnsMapped && columnsMapped.items.length > 0) doc.add(entryWithSpace("metrics", groupToYaml(columnsMapped)));
-	const view = report.derivedBuckets.find((item) => item.type === "view");
+	const view = report.buckets.consume("view");
 	if (view && view.items.length > 0) doc.add(entryWithSpace("view_by", groupToYaml(view)));
-	const attribute = report.derivedBuckets.find((item) => item.type === "attribute");
+	const attribute = report.buckets.consume("attribute");
 	if (attribute && attribute.items.length > 0) doc.add(entryWithSpace("segment_by", groupToYaml(attribute)));
 	const config = repeaterChart.load(def.properties);
 	if (config) doc.add(config);
@@ -141831,16 +141917,25 @@ function addChartTypeToGroup(group, config) {
 		})
 	};
 }
+function unrepresentableLayerField(layer) {
+	if (layer.filters?.some(isFilter)) return "filters";
+	if (layer.sorts?.length) return "sorts";
+	return Object.values(layer.attributeFilterConfigs ?? {}).some((config) => config?.displayAsLabel) ? "attributeFilterConfigs" : null;
+}
 function declarativeLayersToYaml(entities, layersDefinition, errorContext) {
 	const layers = new import_dist.YAMLSeq();
 	layersDefinition.forEach((layer, li) => {
-		const { groups } = declarativeBucketsToYaml(entities, layer.buckets ?? [], updateErrorContext(errorContext, { path: [li.toString(), "buckets"] }));
+		const unrepresentable = unrepresentableLayerField(layer);
+		if (unrepresentable !== null) throw newError("core.itemNotSupported", [`layer "${layer.id}" own ${unrepresentable}`], updateErrorContext(errorContext, { path: [li.toString(), unrepresentable] }));
+		const { groups: layerGroups } = declarativeBucketsToYaml(entities, layer.buckets ?? [], updateErrorContext(errorContext, { path: [li.toString(), "buckets"] }));
+		const buckets = bucketRegistry(layerGroups);
 		const layerKind = resolveLayerExportKind(layer.type, updateErrorContext(errorContext, { path: [li.toString(), "type"] }));
 		const layerMap = new import_dist.YAMLMap();
 		layerMap.add(new import_dist.Pair("id", layer.id));
 		if (layer.name) layerMap.add(new import_dist.Pair("title", layer.name));
 		if (layer.type) layerMap.add(new import_dist.Pair("type", layer.type));
-		appendLayerBucketsForKind(layerMap, groups, layerKind, updateErrorContext(errorContext, { path: [li.toString()] }));
+		appendLayerBucketsForKind(layerMap, buckets, layerKind, updateErrorContext(errorContext, { path: [li.toString()] }));
+		buckets.assertAllConsumed(updateErrorContext(errorContext, { path: [li.toString()] }));
 		addLayerConfig(layerMap, layerKind, layer.properties);
 		layers.add(layerMap);
 	});
@@ -141851,13 +141946,13 @@ function resolveLayerExportKind(rawLayerType, errorContext) {
 	if (rawLayerType === "area") return "area";
 	throw newError("core.layerTypeNotSupported", [rawLayerType ?? "<missing>"], errorContext);
 }
-function appendLayerBucketsForKind(layerMap, groups, kind, errorContext) {
+function appendLayerBucketsForKind(layerMap, buckets, kind, errorContext) {
 	if (kind === "pushpin") {
-		addPushpinBucketsToYaml(layerMap, groups);
+		addPushpinBucketsToYaml(layerMap, buckets);
 		return;
 	}
 	if (kind === "area") {
-		addGeoAreaBucketsToYaml(layerMap, groups);
+		addGeoAreaBucketsToYaml(layerMap, buckets);
 		return;
 	}
 	throw newError("core.layerTypeNotSupported", [kind], errorContext);
@@ -159869,7 +159964,7 @@ async function open(state, emitter, file) {
 //#endregion
 //#region ../code/package.json
 var name = "@gooddata/code";
-var version = "0.47.0-alpha.3";
+var version = "0.47.0-alpha.5";
 //#endregion
 //#region ../../../sdk/libs/api-client-tiger/src/axios.ts
 /**
@@ -159891,7 +159986,7 @@ const _CONFIG = {
 		common: {
 			"X-Requested-With": "XMLHttpRequest",
 			"X-GDC-JS-PACKAGE": "@gooddata/api-client-tiger",
-			"X-GDC-JS-PACKAGE-VERSION": "11.51.0-alpha.3"
+			"X-GDC-JS-PACKAGE-VERSION": "11.51.0-alpha.5"
 		},
 		post: { "Content-Type": "application/json;charset=utf8" },
 		put: { "Content-Type": "application/json;charset=utf8" }