@gooddata/code-cli 0.52.0-alpha.5 → 0.52.0-alpha.7

package/NOTICE

@@ -9,7 +9,7 @@ The following 3rd-party software packages may be used by or distributed with gdc
 
 Date generated: 2026-9-8
 
-Revision ID: b372da4ff3ae3c4227dff9b1a0b3343f7fa8a9f5
+Revision ID: c3978e6d95b691f58341d7a2af5e76ea67f3bf55
 
 ================================================================================
 ================================================================================

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.52.0-alpha.5";
+var version$1 = "0.52.0-alpha.7";
 //#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) => {
@@ -103070,6 +103070,8 @@ var CoreErrorCode;
 	CoreErrorCode["ParameterDuplicateAllowedTitle"] = "core.parameter.duplicateAllowedTitle";
 	CoreErrorCode["ParameterLengthRange"] = "core.parameter.lengthRange";
 	CoreErrorCode["ParameterDefaultOutOfBounds"] = "core.parameter.defaultOutOfBounds";
+	CoreErrorCode["ParameterNumberRange"] = "core.parameter.numberRange";
+	CoreErrorCode["ParameterDefaultOutOfRange"] = "core.parameter.defaultOutOfRange";
 	CoreErrorCode["MissingDataSourceId"] = "core.missingDataSourceId";
 	CoreErrorCode["NonExistingRemoteReference"] = "core.nonExistingRemoteReference";
 	CoreErrorCode["NonExistingRemoteReferences"] = "core.nonExistingRemoteReferences";
@@ -103169,6 +103171,8 @@ const CoreErrorMessages$1 = {
 	[CoreErrorCode.ParameterDuplicateAllowedTitle]: `allowed_values contains duplicate title "{0}". Each title must be unique.`,
 	[CoreErrorCode.ParameterLengthRange]: `minLength {0} is greater than maxLength {1}. The bounds must describe a non-empty range.`,
 	[CoreErrorCode.ParameterDefaultOutOfBounds]: `Default "{0}" has length {1}, which is outside the declared bounds {2}.`,
+	[CoreErrorCode.ParameterNumberRange]: `min {0} is greater than max {1}. The bounds must describe a non-empty range.`,
+	[CoreErrorCode.ParameterDefaultOutOfRange]: `Default {0} is outside the declared bounds {1}.`,
 	[CoreErrorCode.MissingDataSourceId]: `Missing data source. Data source must be specified in profile or directly on dataset. Use "data_source" property in profile or "data_source" property in current dataset definition.`,
 	[CoreErrorCode.SqlIsNotRefreshedFromServer]: `SQL statement not loaded from server and need to be refreshed. Use "Run" button over the SQL statement to force retrieve new definition.`,
 	[SpecificCoreErrorCode.UniquenessDatasetsId]: `There are more datasets with id "{0}". Use unique names for datasets.`,
@@ -103254,6 +103258,8 @@ const CoreErrorTypes$1 = {
 	[CoreErrorCode.ParameterDuplicateAllowedTitle]: "ParameterDuplicateAllowedTitle",
 	[CoreErrorCode.ParameterLengthRange]: "ParameterLengthRange",
 	[CoreErrorCode.ParameterDefaultOutOfBounds]: "ParameterDefaultOutOfBounds",
+	[CoreErrorCode.ParameterNumberRange]: "ParameterNumberRange",
+	[CoreErrorCode.ParameterDefaultOutOfRange]: "ParameterDefaultOutOfRange",
 	[CoreErrorCode.MissingDataSourceId]: "MissingDataSourceId",
 	[SpecificCoreErrorCode.UniquenessDatasetsId]: "UniquenessDatasetsId",
 	[SpecificCoreErrorCode.UniquenessMetricsId]: "UniquenessMetricsId",
@@ -106661,7 +106667,12 @@ function normalizeUrl(urlString, options) {
 }
 //#endregion
 //#region ../code/esm/features/references/utils/index.js
+/**
+* The computed attribute token precedes "attribute" in the alternation the patterns build from
+* this list, so the longer token wins.
+*/
 const SupportedReferenceTypes$1 = [
+	"computed_attribute",
 	"fact",
 	"label",
 	"metric",
@@ -106669,14 +106680,21 @@ const SupportedReferenceTypes$1 = [
 	"attribute"
 ];
 /**
-* MAQL can additionally name a parameter and a computed attribute; custom URLs and shorthand fields
-* cannot. The computed attribute token precedes "attribute" in the alternation the patterns build
-* from this list, so the longer token wins.
+* MAQL can additionally name a parameter.
 */
-const SupportedMaqlReferenceTypes = [
-	"computed_attribute",
-	...SupportedReferenceTypes$1,
-	"parameter"
+const SupportedMaqlReferenceTypes = [...SupportedReferenceTypes$1, "parameter"];
+/**
+* A custom URL substitutes attribute values only; it cannot name a computed attribute or a parameter.
+*/
+const SupportedCustomUrlReferenceTypes = SupportedReferenceTypes$1.filter((type) => type !== "computed_attribute");
+/**
+* Reference prefixes that stand for an attribute-like object a query field, an attribute filter
+* or a drill can use. A computed attribute behaves as a label with computed values.
+*/
+const AttributeLikeReferenceTypes$1 = [
+	"attribute",
+	"label",
+	"computed_attribute"
 ];
 /** The id fragment of a `type/id` reference, shared by every pattern that matches one. */
 const REFERENCE_ID_PATTERN = "(?!\\.)[.A-Za-z0-9_-]{1,255}";
@@ -106883,11 +106901,7 @@ function isShothandField(obj) {
 function isAttributeField$1(obj) {
 	if (typeof obj === "object" && obj && "using" in obj && typeof obj.using === "string" && !("aggregation" in obj)) {
 		const id = parseReferenceObject$1(obj.using);
-		return Boolean(id && [
-			"attribute",
-			"label",
-			"fact"
-		].includes(id.type));
+		return Boolean(id && [...AttributeLikeReferenceTypes$1, "fact"].includes(id.type));
 	}
 	return false;
 }
@@ -106938,14 +106952,14 @@ function isAllTimeDateFilter$1(obj) {
 function isAttributeFilter$2(obj) {
 	if (typeof obj === "object" && obj && "using" in obj && "type" in obj && obj.type === "attribute_filter") {
 		const id = parseReferenceObject$1(obj.using);
-		return Boolean(id && ["attribute", "label"].includes(id.type));
+		return Boolean(id && AttributeLikeReferenceTypes$1.includes(id.type));
 	}
 	return false;
 }
 function isTextFilter$1(obj) {
 	if (typeof obj === "object" && obj && "using" in obj && typeof obj.using === "string" && "type" in obj && obj.type === "text_filter") {
 		const id = parseReferenceObject$1(obj.using);
-		return Boolean(id && ["attribute", "label"].includes(id.type));
+		return Boolean(id && AttributeLikeReferenceTypes$1.includes(id.type));
 	}
 	return false;
 }
@@ -106999,7 +107013,7 @@ function isDashboardAttributeFilter$2(obj) {
 function isDashboardTextFilter$1(obj) {
 	if (typeof obj === "object" && obj && "type" in obj && obj.type === "text_filter" && "using" in obj && typeof obj.using === "string") {
 		const id = parseReferenceObject$1(obj.using);
-		return Boolean(id && ["attribute", "label"].includes(id.type));
+		return Boolean(id && AttributeLikeReferenceTypes$1.includes(id.type));
 	}
 	return false;
 }
@@ -135226,15 +135240,32 @@ function getIdentifier(obj, untype, errorContext) {
 		identifier: obj.identifier.id
 	} : obj;
 	if (isLocalIdRef(idRef)) return idRef.localIdentifier;
-	if (isIdentifierRef(idRef) && !untype) return `${idRef.type === "measure" ? "metric" : idRef.type}/${idRef.identifier}`;
+	if (isIdentifierRef(idRef) && !untype) return `${declarativeTypeToReferencePrefix(idRef.type)}/${idRef.identifier}`;
 	if (isIdentifierRef(idRef) && untype) return idRef.identifier;
 	throw newError("core.referenceTypeNotSupported", [JSON.stringify(obj)], errorContext);
 }
+/**
+* Maps the yaml reference prefix (`metric/`, `computed_attribute/`, ...) to the object type the
+* declarative API uses for the same object.
+*/
+function referencePrefixToDeclarativeType(prefix, forceMetric) {
+	if (prefix === "metric" && !forceMetric) return "measure";
+	if (prefix === "computed_attribute") return "computedAttribute";
+	return prefix;
+}
+/**
+* Inverse of {@link referencePrefixToDeclarativeType}.
+*/
+function declarativeTypeToReferencePrefix(type) {
+	if (type === "measure") return "metric";
+	if (type === "computedAttribute") return "computed_attribute";
+	return type;
+}
 /** @public */
 function createIdentifier(data, { forceMetric, forceType } = {}) {
 	const [type, objId] = data.split("/");
 	if (type && objId) return { identifier: {
-		type: forceType || (type === "metric" && !forceMetric ? "measure" : type),
+		type: forceType || referencePrefixToDeclarativeType(type, forceMetric),
 		id: objId
 	} };
 	if (forceType) return { identifier: {
@@ -135540,6 +135571,14 @@ function yamlMetricToDeclarative(input) {
 function isDeclarativeStringParameter(parameter) {
 	return parameter.content.type === "STRING";
 }
+/** @public */
+function isDeclarativeNumberParameter(parameter) {
+	return parameter.content.type === "NUMBER";
+}
+/** @public */
+function isDeclarativeCodeParameter(parameter) {
+	return isDeclarativeStringParameter(parameter) || isDeclarativeNumberParameter(parameter);
+}
 /**
 * Spreadable `constraints` entry for a parameter definition: present only when at least one
 * restriction is set, and never carrying a key whose value is undefined.
@@ -135568,6 +135607,9 @@ function yamlParameterToDeclarative(input) {
 	};
 }
 function yamlParameterDefinitionToDeclarative(definition) {
+	return definition.type === "NUMBER" ? yamlNumberDefinitionToDeclarative(definition) : yamlStringDefinitionToDeclarative(definition);
+}
+function yamlStringDefinitionToDeclarative(definition) {
 	const { minLength, maxLength, allowedValues } = definition.constraints ?? {};
 	return {
 		type: "STRING",
@@ -135579,15 +135621,19 @@ function yamlParameterDefinitionToDeclarative(definition) {
 		})
 	};
 }
+function yamlNumberDefinitionToDeclarative(definition) {
+	const { min, max } = definition.constraints ?? {};
+	return {
+		type: "NUMBER",
+		defaultValue: definition.defaultValue,
+		...optionalConstraints({
+			min,
+			max
+		})
+	};
+}
 //#endregion
 //#region ../../../sdk/libs/sdk-code-convertors/src/to/yamlComputedAttributeToDeclarative.ts
-/**
-* A computed attribute is textual for now: the backend does not transfer the value type from
-* metadata yet, so every computed attribute is interpreted as a STRING/TEXT one. The YAML shape
-* therefore does not expose dataType/valueType and the defaults are filled in here.
-*/
-const DEFAULT_DATA_TYPE = "STRING";
-const DEFAULT_VALUE_TYPE = "TEXT";
 /** @public */
 function yamlComputedAttributeToDeclarative(input) {
 	const output = {
@@ -135595,10 +135641,15 @@ function yamlComputedAttributeToDeclarative(input) {
 		title: input.title ?? convertIdToTitle$1(input.id),
 		description: input.description ?? "",
 		tags: input.tags ?? [],
-		content: { maql: input.maql },
-		dataType: DEFAULT_DATA_TYPE,
-		valueType: DEFAULT_VALUE_TYPE
-	};
+		content: { maql: input.maql }
+	};
+	if (input.format !== void 0) output.content.format = input.format;
+	if (input.metric_type !== void 0) output.content.metricType = input.metric_type;
+	if (input.data_type !== void 0) output.dataType = input.data_type;
+	if (input.value_type !== void 0) output.valueType = input.value_type;
+	if (input.is_nullable !== void 0) output.isNullable = input.is_nullable;
+	if (input.null_value_join_replacement !== void 0) output.nullValue = input.null_value_join_replacement;
+	if (input.show_in_ai_results !== void 0) output.isHidden = input.show_in_ai_results === false;
 	if (input.locale !== void 0) output.locale = input.locale;
 	return output;
 }
@@ -135655,10 +135706,20 @@ function addInPath(base, path, newValue) {
 const SupportedReferenceTypes = [
 	"fact",
 	"label",
+	"computed_attribute",
 	"metric",
 	"dataset",
 	"attribute"
 ];
+/**
+* Reference prefixes that stand for an attribute-like object a query field, an attribute filter
+* or a drill can use. A computed attribute behaves as a label with computed values.
+*/
+const AttributeLikeReferenceTypes = [
+	"attribute",
+	"label",
+	"computed_attribute"
+];
 function parseReferenceObject(obj) {
 	const [t, identifier] = obj?.split("/") ?? [];
 	const type = t;
@@ -135676,14 +135737,16 @@ function isAttribute(obj) {
 function isAttributeField(obj) {
 	if (typeof obj === "object" && obj && "using" in obj && typeof obj.using === "string" && !("aggregation" in obj)) {
 		const id = parseReferenceObject(obj.using);
-		return Boolean(id && [
-			"attribute",
-			"label",
-			"fact"
-		].includes(id.type));
+		return Boolean(id && [...AttributeLikeReferenceTypes, "fact"].includes(id.type));
 	}
 	return false;
 }
+/**
+* Whether the reference names a computed attribute (`computed_attribute/{id}`).
+*/
+function isComputedAttributeReference(reference) {
+	return parseReferenceObject(reference)?.type === "computed_attribute";
+}
 function isInlineMetricField(obj) {
 	return typeof obj === "object" && obj !== null && "maql" in obj && typeof obj.maql === "string";
 }
@@ -135731,7 +135794,7 @@ function isAllTimeDateFilter(obj) {
 function isAttributeFilter(obj) {
 	if (typeof obj === "object" && obj && "using" in obj && "type" in obj && obj.type === "attribute_filter") {
 		const id = parseReferenceObject(obj.using);
-		return Boolean(id && ["attribute", "label"].includes(id.type));
+		return Boolean(id && AttributeLikeReferenceTypes.includes(id.type));
 	}
 	return false;
 }
@@ -139638,6 +139701,10 @@ function findObjectProps(entities, item) {
 	switch (item.identifier.type) {
 		case "attribute": return { title: items.attributes.find((attribute) => attribute.attribute.id === item.identifier.id)?.attribute.title ?? firstLetterUpperCase(convertIdToTitle$1(item.identifier.id).toLowerCase()) };
 		case "fact": return { title: items.facts.find((fact) => fact.fact.id === item.identifier.id)?.fact.title ?? firstLetterUpperCase(convertIdToTitle$1(item.identifier.id).toLowerCase()) };
+		case "computedAttribute": {
+			const found = entities.find((entity) => entity.type === "computed_attribute" && entity.id === item.identifier.id);
+			return { title: (found ? found.data.title : void 0) ?? firstLetterUpperCase(convertIdToTitle$1(item.identifier.id).toLowerCase()) };
+		}
 		case "label":
 		case "metric": return { title: items.labels.find((label) => label.id === item.identifier.id)?.title ?? firstLetterUpperCase(convertIdToTitle$1(item.identifier.id).toLowerCase()) };
 	}
@@ -141057,7 +141124,7 @@ function sourceInsightFilterIdToDeclarative(filterId, sourceVisualizationFilters
 }
 function yamlIgnoredFilterToDeclarative(input) {
 	const ref = parseReferenceObject(input);
-	if (ref?.type === "label") return {
+	if (ref?.type === "label" || ref?.type === "computed_attribute") return {
 		type: "attributeFilterReference",
 		displayForm: createIdentifier(input)
 	};
@@ -141620,6 +141687,9 @@ function declarativeParameterToYaml(parameter) {
 	};
 }
 function declarativeParameterDefinitionToYaml(definition) {
+	return definition.type === "NUMBER" ? declarativeNumberDefinitionToYaml(definition) : declarativeStringDefinitionToYaml(definition);
+}
+function declarativeStringDefinitionToYaml(definition) {
 	const { minLength, maxLength, allowedValues } = definition.constraints ?? {};
 	const [first, ...rest] = allowedValues ?? [];
 	return {
@@ -141632,6 +141702,17 @@ function declarativeParameterDefinitionToYaml(definition) {
 		})
 	};
 }
+function declarativeNumberDefinitionToYaml(definition) {
+	const { min, max } = definition.constraints ?? {};
+	return {
+		type: "NUMBER",
+		defaultValue: definition.defaultValue,
+		...optionalConstraints({
+			min,
+			max
+		})
+	};
+}
 //#endregion
 //#region ../../../sdk/libs/sdk-code-convertors/src/from/declarativeComputedAttributeToYaml.ts
 /** @public */
@@ -141643,6 +141724,13 @@ function declarativeComputedAttributeToYaml(computedAttribute) {
 	doc.commentBefore = COMPUTED_ATTRIBUTE_COMMENT;
 	fillOptionalMetaFields(doc, computedAttribute);
 	doc.add(entryWithSpace("maql", computedAttribute.content.maql ?? ""));
+	if (computedAttribute.content.format) doc.add(doc.createPair("format", computedAttribute.content.format));
+	if (computedAttribute.content.metricType) doc.add(doc.createPair("metric_type", computedAttribute.content.metricType));
+	if (computedAttribute.dataType) doc.add(doc.createPair("data_type", computedAttribute.dataType));
+	if (computedAttribute.valueType) doc.add(doc.createPair("value_type", computedAttribute.valueType));
+	if (computedAttribute.isNullable !== void 0) doc.add(doc.createPair("is_nullable", computedAttribute.isNullable));
+	if (computedAttribute.nullValue !== void 0) doc.add(doc.createPair("null_value_join_replacement", computedAttribute.nullValue));
+	if (computedAttribute.isHidden === true) doc.add(doc.createPair("show_in_ai_results", false));
 	if (computedAttribute.locale) doc.add(doc.createPair("locale", computedAttribute.locale));
 	return {
 		content: doc.toString({ lineWidth: 0 }),
@@ -143510,7 +143598,7 @@ function buildExecution(entities, query) {
 			const fieldDef = getFullField$1(fields[field]);
 			if (isAttributeField(fieldDef)) return {
 				localIdentifier: field,
-				label: createIdentifier(fieldDef.using, { forceType: "label" }),
+				label: isComputedAttributeReference(fieldDef.using) ? createIdentifier(fieldDef.using) : createIdentifier(fieldDef.using, { forceType: "label" }),
 				showAllValues: fieldDef.show_all_values
 			};
 			return null;
@@ -143794,8 +143882,8 @@ const SupportedUrlTargetPlaceholders = [
 	"workspace_id"
 ];
 const SupportFilterPlaceholders = ["dash_attribute_filter_selection", "attribute_filter_selection"];
-new RegExp(`\\{((?:${SupportedReferenceTypes$1.join("|")})\\/(?!\\.)[.A-Za-z0-9_-]{1,255})\\}`);
-const referenceAndPlaceholdersRegex = new RegExp(`\\{((?:${SupportedReferenceTypes$1.join("|")})\\/(?!\\.)[.A-Za-z0-9_-]{1,255}|(?:${SupportedUrlTargetPlaceholders.join("|")})|(?:${SupportFilterPlaceholders.join("|")})\\((?!\\.)[.A-Za-z0-9_-]{1,255}\\))\\}`);
+new RegExp(`\\{((?:${SupportedCustomUrlReferenceTypes.join("|")})\\/(?!\\.)[.A-Za-z0-9_-]{1,255})\\}`);
+const referenceAndPlaceholdersRegex = new RegExp(`\\{((?:${SupportedCustomUrlReferenceTypes.join("|")})\\/(?!\\.)[.A-Za-z0-9_-]{1,255}|(?:${SupportedUrlTargetPlaceholders.join("|")})|(?:${SupportFilterPlaceholders.join("|")})\\((?!\\.)[.A-Za-z0-9_-]{1,255}\\))\\}`);
 function loadUrlTarget(data) {
 	const parsed = data.split(referenceAndPlaceholdersRegex);
 	const result = [];
@@ -145212,7 +145300,7 @@ function resolveCurrentInsightWidgetQueryFieldAttribute(references, widget, type
 					visualisation: visualisation.id
 				};
 				if (!isDateAttribute && types.includes("attribute")) return {
-					id: attributesMap[field.using],
+					id: attributesMap[field.using] ?? field.using,
 					..."title" in field ? { title: field.title } : {},
 					..."alias" in field ? { title: field.alias } : {},
 					visualisation: visualisation.id
@@ -147501,9 +147589,59 @@ const metadata_v1 = {
 					"description": "Define MAQL syntax for the computed attribute. Values are assigned with break points written as CASE WHEN branches over a metric, and the first matching branch wins.",
 					"$semantic": { "type": "maql" }
 				},
-				"locale": {
+				"format": {
+					"type": "string",
+					"description": "An optional Excel-like format string applied to the computed values."
+				},
+				"metric_type": {
 					"type": "string",
-					"description": "An optional locale whose collation order the computed values are sorted by."
+					"enum": ["UNSPECIFIED", "CURRENCY"],
+					"description": "An optional categorization of the computed values semantics, for example currency."
+				},
+				"data_type": {
+					"type": "string",
+					"enum": [
+						"INT",
+						"STRING",
+						"DATE",
+						"NUMERIC",
+						"TIMESTAMP",
+						"TIMESTAMP_TZ",
+						"BOOLEAN",
+						"HLL"
+					],
+					"description": "An optional data type of the computed values. Defaults to STRING on the backend."
+				},
+				"value_type": {
+					"type": "string",
+					"enum": [
+						"TEXT",
+						"HYPERLINK",
+						"GEO",
+						"GEO_LONGITUDE",
+						"GEO_LATITUDE",
+						"GEO_AREA",
+						"GEO_ICON",
+						"IMAGE",
+						"HYPERLOGLOG"
+					],
+					"description": "An optional specific type of the computed values. Defaults to TEXT on the backend."
+				},
+				"is_nullable": {
+					"type": "boolean",
+					"description": "Optional flag to indicate if the computed attribute can contain null values."
+				},
+				"null_value_join_replacement": {
+					"type": "string",
+					"description": "Optional value which can be used as replacement for NULL in join conditions."
+				},
+				"show_in_ai_results": {
+					"type": "boolean",
+					"description": "Optional flag to indicate if the computed attribute should be shown in AI results. When omitted, the computed attribute is visible."
+				},
+				"locale": {
+					"$ref": "#/$global/gaac/locale",
+					"description": "An optional locale in BCP 47 format (for example en-US) whose collation order the computed values are sorted by."
 				}
 			},
 			"$semantic": {
@@ -149781,6 +149919,12 @@ const metadata_v1 = {
 				"typePrefix": true
 			}
 		},
+		"locale": {
+			"title": "Locale",
+			"type": "string",
+			"pattern": "^[a-zA-Z]{2,3}(-[a-zA-Z0-9]{1,8})*$",
+			"description": "Locale string in BCP 47 format (for example en-US or cs-CZ-u-kn-true)."
+		},
 		"dashboardFilters": {
 			"title": "Dashboard Filters",
 			"type": "object",
@@ -149861,6 +150005,17 @@ const metadata_v1 = {
 				"typePrefix": true
 			}
 		},
+		"computedAttributeIdentifier": {
+			"title": "Computed Attribute Identifier",
+			"description": "A computed attribute identifier in the form of computed_attribute/{id}.",
+			"type": "string",
+			"pattern": "^computed_attribute/(?!\\.)[.A-Za-z0-9_-]{1,255}$",
+			"$semantic": {
+				"type": "reference",
+				"source": "computedAttribute.id",
+				"typePrefix": true
+			}
+		},
 		"queryFilters": {
 			"title": "Query Filters",
 			"type": "object",
@@ -150606,6 +150761,17 @@ const metadata_v1 = {
 				"typePrefix": true
 			}
 		},
+		"computedAttributeIdentifier": {
+			"title": "Computed Attribute Identifier",
+			"description": "A computed attribute identifier in the form of computed_attribute/{id}.",
+			"type": "string",
+			"pattern": "^computed_attribute/(?!\\.)[.A-Za-z0-9_-]{1,255}$",
+			"$semantic": {
+				"type": "reference",
+				"source": "computedAttribute.id",
+				"typePrefix": true
+			}
+		},
 		"displayAsLabelIdentifier": {
 			"title": "Display As Label Identifier",
 			"description": "Configures the label used for representing attribute filter elements in UI.",
@@ -150831,7 +150997,11 @@ const metadata_v1 = {
 				},
 				"using": {
 					"description": "Attribute or label to use in this filter.",
-					"oneOf": [{ "$ref": "#/$defs/attributeIdentifier" }, { "$ref": "#/$defs/labelIdentifier" }],
+					"oneOf": [
+						{ "$ref": "#/$defs/attributeIdentifier" },
+						{ "$ref": "#/$defs/labelIdentifier" },
+						{ "$ref": "#/$defs/computedAttributeIdentifier" }
+					],
 					"$semantic": { "type": "one_attribute_item_only" }
 				},
 				"multiselect": {
@@ -150919,7 +151089,11 @@ const metadata_v1 = {
 					},
 					"using": {
 						"description": "Attribute or label to use in this filter.",
-						"oneOf": [{ "$ref": "#/$defs/attributeIdentifier" }, { "$ref": "#/$defs/labelIdentifier" }]
+						"oneOf": [
+							{ "$ref": "#/$defs/attributeIdentifier" },
+							{ "$ref": "#/$defs/labelIdentifier" },
+							{ "$ref": "#/$defs/computedAttributeIdentifier" }
+						]
 					},
 					"multiselect": {
 						"type": "boolean",
@@ -151019,7 +151193,11 @@ const metadata_v1 = {
 					},
 					"using": {
 						"description": "Attribute or label to use in this filter.",
-						"oneOf": [{ "$ref": "#/$defs/attributeIdentifier" }, { "$ref": "#/$defs/labelIdentifier" }]
+						"oneOf": [
+							{ "$ref": "#/$defs/attributeIdentifier" },
+							{ "$ref": "#/$defs/labelIdentifier" },
+							{ "$ref": "#/$defs/computedAttributeIdentifier" }
+						]
 					},
 					"multiselect": {
 						"type": "boolean",
@@ -151127,7 +151305,11 @@ const metadata_v1 = {
 				},
 				"using": {
 					"description": "Attribute or label to use in this filter.",
-					"oneOf": [{ "$ref": "#/$defs/attributeIdentifier" }, { "$ref": "#/$defs/labelIdentifier" }],
+					"oneOf": [
+						{ "$ref": "#/$defs/attributeIdentifier" },
+						{ "$ref": "#/$defs/labelIdentifier" },
+						{ "$ref": "#/$defs/computedAttributeIdentifier" }
+					],
 					"$semantic": { "type": "one_attribute_item_only" }
 				},
 				"case_sensitive": { "type": "boolean" },
@@ -151229,7 +151411,11 @@ const metadata_v1 = {
 					},
 					"using": {
 						"description": "Attribute or label to use in this filter.",
-						"oneOf": [{ "$ref": "#/$defs/attributeIdentifier" }, { "$ref": "#/$defs/labelIdentifier" }],
+						"oneOf": [
+							{ "$ref": "#/$defs/attributeIdentifier" },
+							{ "$ref": "#/$defs/labelIdentifier" },
+							{ "$ref": "#/$defs/computedAttributeIdentifier" }
+						],
 						"$semantic": { "type": "one_attribute_item_only" }
 					},
 					"condition": { "enum": ["is", "isNot"] },
@@ -151342,7 +151528,11 @@ const metadata_v1 = {
 					},
 					"using": {
 						"description": "Attribute or label to use in this filter.",
-						"oneOf": [{ "$ref": "#/$defs/attributeIdentifier" }, { "$ref": "#/$defs/labelIdentifier" }],
+						"oneOf": [
+							{ "$ref": "#/$defs/attributeIdentifier" },
+							{ "$ref": "#/$defs/labelIdentifier" },
+							{ "$ref": "#/$defs/computedAttributeIdentifier" }
+						],
 						"$semantic": { "type": "one_attribute_item_only" }
 					},
 					"condition": { "enum": [
@@ -151421,8 +151611,8 @@ const metadata_v1 = {
 				},
 				"dimensionality": {
 					"type": "array",
-					"description": "Optional array of label references to apply dimensionality to the filter.",
-					"items": { "$ref": "#/$defs/labelIdentifier" }
+					"description": "Optional array of label or computed attribute references to apply dimensionality to the filter.",
+					"items": { "oneOf": [{ "$ref": "#/$defs/labelIdentifier" }, { "$ref": "#/$defs/computedAttributeIdentifier" }] }
 				},
 				"null_values_as_zero": {
 					"type": "boolean",
@@ -151909,7 +152099,11 @@ const metadata_v1 = {
 				},
 				"using": {
 					"description": "Attribute or label to use in this filter.",
-					"oneOf": [{ "$ref": "#/$defs/attributeIdentifier" }, { "$ref": "#/$defs/labelIdentifier" }]
+					"oneOf": [
+						{ "$ref": "#/$defs/attributeIdentifier" },
+						{ "$ref": "#/$defs/labelIdentifier" },
+						{ "$ref": "#/$defs/computedAttributeIdentifier" }
+					]
 				},
 				"display_as": {
 					"type": "string",
@@ -151973,7 +152167,11 @@ const metadata_v1 = {
 				},
 				"using": {
 					"description": "Attribute or label to use in this filter.",
-					"oneOf": [{ "$ref": "#/$defs/attributeIdentifier" }, { "$ref": "#/$defs/labelIdentifier" }]
+					"oneOf": [
+						{ "$ref": "#/$defs/attributeIdentifier" },
+						{ "$ref": "#/$defs/labelIdentifier" },
+						{ "$ref": "#/$defs/computedAttributeIdentifier" }
+					]
 				},
 				"case_sensitive": { "type": "boolean" },
 				"display_as": {
@@ -151990,7 +152188,11 @@ const metadata_v1 = {
 					},
 					"using": {
 						"description": "Attribute or label to use in this filter.",
-						"oneOf": [{ "$ref": "#/$defs/attributeIdentifier" }, { "$ref": "#/$defs/labelIdentifier" }]
+						"oneOf": [
+							{ "$ref": "#/$defs/attributeIdentifier" },
+							{ "$ref": "#/$defs/labelIdentifier" },
+							{ "$ref": "#/$defs/computedAttributeIdentifier" }
+						]
 					},
 					"condition": { "enum": ["is", "isNot"] },
 					"values": {
@@ -152018,7 +152220,11 @@ const metadata_v1 = {
 					},
 					"using": {
 						"description": "Attribute or label to use in this filter.",
-						"oneOf": [{ "$ref": "#/$defs/attributeIdentifier" }, { "$ref": "#/$defs/labelIdentifier" }]
+						"oneOf": [
+							{ "$ref": "#/$defs/attributeIdentifier" },
+							{ "$ref": "#/$defs/labelIdentifier" },
+							{ "$ref": "#/$defs/computedAttributeIdentifier" }
+						]
 					},
 					"condition": { "enum": [
 						"contains",
@@ -152122,13 +152328,17 @@ const metadata_v1 = {
 							"dimensionality": {
 								"type": "array",
 								"description": "Optional array of attribute or label references or local identifiers to apply dimensionality to the filter.",
-								"items": { "oneOf": [{ "$ref": "#/$defs/labelIdentifier" }, {
-									"type": "string",
-									"$semantic": {
-										"type": "reference",
-										"sources": ["current.query.attribute.localId"]
+								"items": { "oneOf": [
+									{ "$ref": "#/$defs/labelIdentifier" },
+									{ "$ref": "#/$defs/computedAttributeIdentifier" },
+									{
+										"type": "string",
+										"$semantic": {
+											"type": "reference",
+											"sources": ["current.query.attribute.localId"]
+										}
 									}
-								}] }
+								] }
 							}
 						},
 						"required": [
@@ -152191,13 +152401,17 @@ const metadata_v1 = {
 							"dimensionality": {
 								"type": "array",
 								"description": "Optional array of attribute or label references or local identifiers to apply dimensionality to the filter.",
-								"items": { "oneOf": [{ "$ref": "#/$defs/labelIdentifier" }, {
-									"type": "string",
-									"$semantic": {
-										"type": "reference",
-										"sources": ["current.query.attribute.localId"]
+								"items": { "oneOf": [
+									{ "$ref": "#/$defs/labelIdentifier" },
+									{ "$ref": "#/$defs/computedAttributeIdentifier" },
+									{
+										"type": "string",
+										"$semantic": {
+											"type": "reference",
+											"sources": ["current.query.attribute.localId"]
+										}
 									}
-								}] }
+								] }
 							}
 						},
 						"required": [
@@ -152251,13 +152465,17 @@ const metadata_v1 = {
 							"dimensionality": {
 								"type": "array",
 								"description": "Optional array of attribute or label references or local identifiers to apply dimensionality to the filter.",
-								"items": { "oneOf": [{ "$ref": "#/$defs/labelIdentifier" }, {
-									"type": "string",
-									"$semantic": {
-										"type": "reference",
-										"sources": ["current.query.attribute.localId"]
+								"items": { "oneOf": [
+									{ "$ref": "#/$defs/labelIdentifier" },
+									{ "$ref": "#/$defs/computedAttributeIdentifier" },
+									{
+										"type": "string",
+										"$semantic": {
+											"type": "reference",
+											"sources": ["current.query.attribute.localId"]
+										}
 									}
-								}] }
+								] }
 							}
 						},
 						"required": [
@@ -152298,13 +152516,17 @@ const metadata_v1 = {
 							"dimensionality": {
 								"type": "array",
 								"description": "Optional array of attribute or label references or local identifiers to apply dimensionality to the filter.",
-								"items": { "oneOf": [{ "$ref": "#/$defs/labelIdentifier" }, {
-									"type": "string",
-									"$semantic": {
-										"type": "reference",
-										"sources": ["current.query.attribute.localId"]
+								"items": { "oneOf": [
+									{ "$ref": "#/$defs/labelIdentifier" },
+									{ "$ref": "#/$defs/computedAttributeIdentifier" },
+									{
+										"type": "string",
+										"$semantic": {
+											"type": "reference",
+											"sources": ["current.query.attribute.localId"]
+										}
 									}
-								}] }
+								] }
 							}
 						},
 						"required": ["type", "using"]
@@ -152339,13 +152561,17 @@ const metadata_v1 = {
 				},
 				"attribute": {
 					"description": "Label reference or local identifier to use for this filter.",
-					"oneOf": [{ "$ref": "#/$defs/labelIdentifier" }, {
-						"type": "string",
-						"$semantic": {
-							"type": "reference",
-							"source": "current.query.attribute.localId"
+					"oneOf": [
+						{ "$ref": "#/$defs/labelIdentifier" },
+						{ "$ref": "#/$defs/computedAttributeIdentifier" },
+						{
+							"type": "string",
+							"$semantic": {
+								"type": "reference",
+								"source": "current.query.attribute.localId"
+							}
 						}
-					}]
+					]
 				},
 				"bottom": {
 					"type": "number",
@@ -152420,9 +152646,59 @@ const metadata_v1 = {
 					"description": "Define MAQL syntax for the computed attribute. Values are assigned with break points written as CASE WHEN branches over a metric, and the first matching branch wins.",
 					"$semantic": { "type": "maql" }
 				},
-				"locale": {
+				"format": {
+					"type": "string",
+					"description": "An optional Excel-like format string applied to the computed values."
+				},
+				"metric_type": {
+					"type": "string",
+					"enum": ["UNSPECIFIED", "CURRENCY"],
+					"description": "An optional categorization of the computed values semantics, for example currency."
+				},
+				"data_type": {
+					"type": "string",
+					"enum": [
+						"INT",
+						"STRING",
+						"DATE",
+						"NUMERIC",
+						"TIMESTAMP",
+						"TIMESTAMP_TZ",
+						"BOOLEAN",
+						"HLL"
+					],
+					"description": "An optional data type of the computed values. Defaults to STRING on the backend."
+				},
+				"value_type": {
+					"type": "string",
+					"enum": [
+						"TEXT",
+						"HYPERLINK",
+						"GEO",
+						"GEO_LONGITUDE",
+						"GEO_LATITUDE",
+						"GEO_AREA",
+						"GEO_ICON",
+						"IMAGE",
+						"HYPERLOGLOG"
+					],
+					"description": "An optional specific type of the computed values. Defaults to TEXT on the backend."
+				},
+				"is_nullable": {
+					"type": "boolean",
+					"description": "Optional flag to indicate if the computed attribute can contain null values."
+				},
+				"null_value_join_replacement": {
 					"type": "string",
-					"description": "An optional locale whose collation order the computed values are sorted by."
+					"description": "Optional value which can be used as replacement for NULL in join conditions."
+				},
+				"show_in_ai_results": {
+					"type": "boolean",
+					"description": "Optional flag to indicate if the computed attribute should be shown in AI results. When omitted, the computed attribute is visible."
+				},
+				"locale": {
+					"$ref": "#/$global/gaac/locale",
+					"description": "An optional locale in BCP 47 format (for example en-US) whose collation order the computed values are sorted by."
 				}
 			},
 			"$semantic": {
@@ -153222,13 +153498,14 @@ const metadata_v1 = {
 					"description": "A list of dashboard filters to be ignored for this widget",
 					"items": {
 						"type": "string",
-						"description": "An id of the dashboard label, attribute, metric or date to be ignored",
+						"description": "An id of the dashboard label, attribute, computed attribute, metric or date to be ignored",
 						"$semantic": {
 							"type": "reference",
 							"sources": [
 								"dateDataset.id",
 								"attribute.id",
 								"label.id",
+								"computedAttribute.id",
 								"metric.id"
 							],
 							"typePrefix": true
@@ -153282,11 +153559,19 @@ const metadata_v1 = {
 					"properties": {
 						"href": {
 							"description": "An ID of the attribute that holds the url to be opened on interaction",
-							"oneOf": [{ "$ref": "#/$global/gaac/attributeIdentifier" }, { "$ref": "#/$global/gaac/labelIdentifier" }]
+							"oneOf": [
+								{ "$ref": "#/$global/gaac/attributeIdentifier" },
+								{ "$ref": "#/$global/gaac/labelIdentifier" },
+								{ "$ref": "#/$global/gaac/computedAttributeIdentifier" }
+							]
 						},
 						"label": {
 							"description": "An id of the attribute that holds the label for the url to be opened on interaction",
-							"oneOf": [{ "$ref": "#/$global/gaac/attributeIdentifier" }, { "$ref": "#/$global/gaac/labelIdentifier" }]
+							"oneOf": [
+								{ "$ref": "#/$global/gaac/attributeIdentifier" },
+								{ "$ref": "#/$global/gaac/labelIdentifier" },
+								{ "$ref": "#/$global/gaac/computedAttributeIdentifier" }
+							]
 						}
 					}
 				},
@@ -153824,7 +154109,7 @@ const metadata_v1 = {
 					"deprecated": true
 				},
 				"locale": {
-					"$ref": "#/$defs/locale",
+					"$ref": "#/$global/gaac/locale",
 					"description": "Locale string in BCP 47 format used for default label sorting."
 				},
 				"is_nullable": {
@@ -154009,11 +154294,6 @@ const metadata_v1 = {
 				"code": "core.reference.table.column.dataType"
 			}
 		},
-		"locale": {
-			"type": "string",
-			"pattern": "^[a-zA-Z]{2,3}(-[a-zA-Z0-9]{1,8})*$",
-			"description": "Locale string in BCP 47 format (for example en-US or cs-CZ-u-kn-true)."
-		},
 		"label": {
 			"title": "Label",
 			"type": "object",
@@ -154067,7 +154347,7 @@ const metadata_v1 = {
 					"deprecated": true
 				},
 				"locale": {
-					"$ref": "#/$defs/locale",
+					"$ref": "#/$global/gaac/locale",
 					"description": "Locale string in BCP 47 format used for default label sorting."
 				},
 				"translations": {
@@ -154114,7 +154394,7 @@ const metadata_v1 = {
 					"description": "Column that stores the localized label values."
 				},
 				"locale": {
-					"$ref": "#/$defs/locale",
+					"$ref": "#/$global/gaac/locale",
 					"description": "Locale string in BCP 47 format that identifies the translation."
 				}
 			},
@@ -154269,17 +154549,23 @@ const metadata_v1 = {
 		},
 		"parameterDefinition": {
 			"title": "Parameter Definition",
-			"description": "A typed parameter definition. Only textual parameters are supported as code.",
+			"description": "A typed parameter definition: textual or numeric.",
 			"allOf": [{
 				"if": {
 					"properties": { "type": { "const": "STRING" } },
 					"required": ["type"]
 				},
 				"then": { "$ref": "#/$defs/stringParameterDefinition" }
+			}, {
+				"if": {
+					"properties": { "type": { "const": "NUMBER" } },
+					"required": ["type"]
+				},
+				"then": { "$ref": "#/$defs/numberParameterDefinition" }
 			}],
 			"properties": { "type": {
 				"type": "string",
-				"enum": ["STRING"]
+				"enum": ["STRING", "NUMBER"]
 			} },
 			"required": ["type"]
 		},
@@ -154326,6 +154612,40 @@ const metadata_v1 = {
 			"required": ["type", "defaultValue"],
 			"$semantic": { "type": "parameter_constraints" }
 		},
+		"numberParameterDefinition": {
+			"title": "Number Parameter Definition",
+			"description": "A numeric parameter definition. Without 'constraints' the parameter accepts any number.",
+			"type": "object",
+			"additionalProperties": false,
+			"properties": {
+				"type": {
+					"type": "string",
+					"enum": ["NUMBER"]
+				},
+				"defaultValue": {
+					"type": "number",
+					"description": "The value used whenever the parameter is not overridden."
+				},
+				"constraints": {
+					"title": "Number Parameter Constraints",
+					"type": "object",
+					"additionalProperties": false,
+					"description": "Optional bounds the parameter value must satisfy.",
+					"properties": {
+						"min": {
+							"type": "number",
+							"description": "The smallest accepted value, inclusive."
+						},
+						"max": {
+							"type": "number",
+							"description": "The largest accepted value, inclusive."
+						}
+					}
+				}
+			},
+			"required": ["type", "defaultValue"],
+			"$semantic": { "type": "parameter_constraints" }
+		},
 		"parameterAllowedValue": {
 			"title": "Parameter Allowed Value",
 			"type": "object",
@@ -154404,6 +154724,7 @@ const metadata_v1 = {
 			"oneOf": [
 				{ "$ref": "#/$global/gaac/attributeIdentifier" },
 				{ "$ref": "#/$global/gaac/labelIdentifier" },
+				{ "$ref": "#/$global/gaac/computedAttributeIdentifier" },
 				{ "$ref": "#/$global/gaac/metricIdentifier" },
 				{ "$ref": "#/$global/gaac/factIdentifier" },
 				{
@@ -154501,6 +154822,7 @@ const metadata_v1 = {
 										"oneOf": [
 											{ "$ref": "#/$global/gaac/attributeIdentifier" },
 											{ "$ref": "#/$global/gaac/labelIdentifier" },
+											{ "$ref": "#/$global/gaac/computedAttributeIdentifier" },
 											{ "$ref": "#/$global/gaac/factIdentifier" }
 										]
 									}
@@ -154866,7 +155188,8 @@ const metadata_v1 = {
 							}
 						},
 						{ "$ref": "#/$global/gaac/attributeIdentifier" },
-						{ "$ref": "#/$global/gaac/labelIdentifier" }
+						{ "$ref": "#/$global/gaac/labelIdentifier" },
+						{ "$ref": "#/$global/gaac/computedAttributeIdentifier" }
 					]
 				},
 				"direction": {
@@ -154925,7 +155248,8 @@ const metadata_v1 = {
 											}
 										},
 										{ "$ref": "#/$global/gaac/attributeIdentifier" },
-										{ "$ref": "#/$global/gaac/labelIdentifier" }
+										{ "$ref": "#/$global/gaac/labelIdentifier" },
+										{ "$ref": "#/$global/gaac/computedAttributeIdentifier" }
 									]
 								},
 								"element": {
@@ -157473,26 +157797,43 @@ function validateYamlSemanticForParameterConstraints(schemas, schema, node) {
 		const report = (code, params) => {
 			currentDiagnostics.diagnostics.push(createDiagnostic$1(SchemaDiagnosticSeverity.Error, node.position, getSchemaArray(schemas, schema), code, CoreErrorMessages$1[code], params));
 		};
-		const { defaultValue, constraints } = definition;
-		const { minLength, maxLength, allowedValues } = constraints ?? {};
-		if (minLength !== void 0 && maxLength !== void 0 && minLength > maxLength) report(CoreErrorCode.ParameterLengthRange, [String(minLength), String(maxLength)]);
-		const declared = Array.isArray(allowedValues) ? allowedValues.filter((allowed) => typeof allowed?.value === "string") : [];
-		for (const value of findDuplicates(declared.map((allowed) => allowed.value))) report(CoreErrorCode.ParameterDuplicateAllowedValue, [value]);
-		const distinct = uniqueBy(declared, (allowed) => allowed.value);
-		for (const title of findDuplicates(distinct.map((allowed) => allowed.title ?? allowed.value))) report(CoreErrorCode.ParameterDuplicateAllowedTitle, [title]);
-		if (typeof defaultValue !== "string") return currentDiagnostics;
-		const values = distinct.map((allowed) => allowed.value);
-		if (values.length > 0 && !values.includes(defaultValue)) report(CoreErrorCode.ParameterDefaultNotAllowed, [defaultValue, values.join(", ")]);
-		const tooShort = minLength !== void 0 && defaultValue.length < minLength;
-		const tooLong = maxLength !== void 0 && defaultValue.length > maxLength;
-		if (tooShort || tooLong) report(CoreErrorCode.ParameterDefaultOutOfBounds, [
-			defaultValue,
-			String(defaultValue.length),
-			describeBounds(minLength, maxLength)
-		]);
+		if (definition.type === "NUMBER") validateNumberDefinition(definition, report);
+		else validateStringDefinition(definition, report);
 		return currentDiagnostics;
 	}));
 }
+function validateStringDefinition(definition, report) {
+	const { defaultValue, constraints } = definition;
+	const { minLength, maxLength, allowedValues } = constraints ?? {};
+	if (minLength !== void 0 && maxLength !== void 0 && minLength > maxLength) {
+		report(CoreErrorCode.ParameterLengthRange, [String(minLength), String(maxLength)]);
+		return;
+	}
+	const declared = Array.isArray(allowedValues) ? allowedValues.filter((allowed) => typeof allowed?.value === "string") : [];
+	for (const value of findDuplicates(declared.map((allowed) => allowed.value))) report(CoreErrorCode.ParameterDuplicateAllowedValue, [value]);
+	const distinct = uniqueBy(declared, (allowed) => allowed.value);
+	for (const title of findDuplicates(distinct.map((allowed) => allowed.title ?? allowed.value))) report(CoreErrorCode.ParameterDuplicateAllowedTitle, [title]);
+	if (typeof defaultValue !== "string") return;
+	const values = distinct.map((allowed) => allowed.value);
+	if (values.length > 0 && !values.includes(defaultValue)) report(CoreErrorCode.ParameterDefaultNotAllowed, [defaultValue, values.join(", ")]);
+	const tooShort = minLength !== void 0 && defaultValue.length < minLength;
+	const tooLong = maxLength !== void 0 && defaultValue.length > maxLength;
+	if (tooShort || tooLong) report(CoreErrorCode.ParameterDefaultOutOfBounds, [
+		defaultValue,
+		String(defaultValue.length),
+		describeBounds(minLength, maxLength)
+	]);
+}
+function validateNumberDefinition(definition, report) {
+	const { defaultValue, constraints } = definition;
+	const { min, max } = constraints ?? {};
+	if (typeof min === "number" && typeof max === "number" && min > max) {
+		report(CoreErrorCode.ParameterNumberRange, [String(min), String(max)]);
+		return;
+	}
+	if (typeof defaultValue !== "number") return;
+	if (typeof min === "number" && defaultValue < min || typeof max === "number" && defaultValue > max) report(CoreErrorCode.ParameterDefaultOutOfRange, [String(defaultValue), describeBounds(min, max)]);
+}
 function describeBounds(minLength, maxLength) {
 	if (minLength === void 0) return `at most ${maxLength}`;
 	if (maxLength === void 0) return `at least ${minLength}`;
@@ -161410,7 +161751,7 @@ async function open(state, emitter, file) {
 //#endregion
 //#region ../code/package.json
 var name = "@gooddata/code";
-var version = "0.52.0-alpha.5";
+var version = "0.52.0-alpha.7";
 //#endregion
 //#region ../../../sdk/libs/api-client-tiger/src/axios.ts
 /**
@@ -161432,7 +161773,7 @@ const _CONFIG = {
 		common: {
 			"X-Requested-With": "XMLHttpRequest",
 			"X-GDC-JS-PACKAGE": "@gooddata/api-client-tiger",
-			"X-GDC-JS-PACKAGE-VERSION": "11.56.0-alpha.5"
+			"X-GDC-JS-PACKAGE-VERSION": "11.56.0-alpha.7"
 		},
 		post: { "Content-Type": "application/json;charset=utf8" },
 		put: { "Content-Type": "application/json;charset=utf8" }
@@ -201533,7 +201874,7 @@ async function makeRequest(func) {
 }
 function mergeParameters(current, fromFiles) {
 	const authored = new Set(fromFiles.map((parameter) => parameter.id));
-	return [...(current ?? []).filter((parameter) => !isDeclarativeStringParameter(parameter) && !authored.has(parameter.id)), ...fromFiles];
+	return [...(current ?? []).filter((parameter) => !isDeclarativeCodeParameter(parameter) && !authored.has(parameter.id)), ...fromFiles];
 }
 function updateDeclarativeLayout(currentWs, newWs) {
 	return {
@@ -202089,7 +202430,7 @@ async function fromDeclarative(workspace, basePath, profile, { tables = {}, stor
 		});
 		return createNewFile(store, filePath, createFileContent({ content: Buffer.from(content, "utf8") }), { mode: "remote" });
 	}) ?? []);
-	if (workspace?.analytics?.parameters) mergeResults(update, workspace.analytics.parameters.filter(isDeclarativeStringParameter).map((parameter) => {
+	if (workspace?.analytics?.parameters) mergeResults(update, workspace.analytics.parameters.filter(isDeclarativeCodeParameter).map((parameter) => {
 		const { content, json } = declarativeParameterToYaml(parameter);
 		const filePath = generateFileName(files, parametersPath, parameter.id, parameter.title);
 		if (json && content) entitiesLoaded.push({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gooddata/code-cli",
-  "version": "0.52.0-alpha.5",
+  "version": "0.52.0-alpha.7",
   "description": "GoodData CLI",
   "keywords": [
     "analytics",