@gooddata/sdk-ui-catalog 11.46.0-alpha.4 → 11.46.0-alpha.6

package/esm/catalogDetail/share/CatalogItemShareProvider.js

@@ -30,12 +30,13 @@ export function CatalogItemShareProvider({ shareableItem, target, labels, childr
     // One controller drives both the dialog and the inline access row; the row reads
     // `state.summary`, so a save inside the dialog refreshes it too. labelsLoading/
     // labelsError keep the controller label-unresolved while labels are pending.
+    const [isOpen, setIsOpen] = useState(false);
     const controller = useObjectShare(target, {
         labels: labels.labels,
         labelsError: labels.error,
         labelsLoading: labels.loading,
+        isOpen,
     });
-    const [isOpen, setIsOpen] = useState(false);
     // The detail view is reused as the user navigates between objects, so close an
     // open dialog when the shareable target changes (or becomes non-shareable) —
     // otherwise it would linger open on the next object. Reset during render (React's

package/esm/localization/bundles/en-US.localization-bundle.js

@@ -670,7 +670,7 @@ export const en_US = {
         "crowdinContext": "Section header label above the YAML editor in the parameter dialog."
     },
     "analyticsCatalog.parameter.dialog.sectionHeader.tooltip": {
-        "text": "Create a YAML statement that defines a numeric parameter.",
+        "text": "Create a YAML statement that defines a parameter.",
         "crowdinContext": "Tooltip shown for the help icon next to the parameter definition section header."
     },
     "analyticsCatalog.parameter.dialog.create.submit": {
@@ -710,20 +710,20 @@ export const en_US = {
         "crowdinContext": "Error shown when the parameter YAML does not follow the expected object structure."
     },
     "analyticsCatalog.parameter.validation.unsupportedType": {
-        "text": "Only NUMBER parameters are supported.",
-        "crowdinContext": "Error shown when the parameter YAML declares an unsupported parameter type."
+        "text": "Only {enabledTypes} parameters are supported.",
+        "crowdinContext": "Error shown when the parameter YAML declares an unsupported parameter type. {enabledTypes} is a comma-separated list of the supported type names (e.g. 'NUMBER' or 'NUMBER and STRING')."
     },
     "analyticsCatalog.parameter.validation.invalidDefaultValue": {
-        "text": "Default value must be a number.",
-        "crowdinContext": "Error shown when the parameter YAML contains a non-numeric defaultValue."
+        "text": "Default value must be {type, select, STRING {a string} other {a number}}.",
+        "crowdinContext": "Error shown when the parameter YAML contains a defaultValue whose kind does not match the declared parameter type. {type} is the declared type: STRING expects a string, otherwise a number."
     },
     "analyticsCatalog.parameter.validation.invalidConstraints": {
-        "text": "Parameter constraints must use numeric min and max values.",
-        "crowdinContext": "Error shown when the parameter YAML contains invalid constraint values."
+        "text": "Invalid constraints: {type, select, STRING {STRING parameters allow non-negative integer minLength and maxLength} other {NUMBER parameters allow numeric min and max}}.",
+        "crowdinContext": "Error shown when the parameter YAML contains invalid constraint values. {type} is the declared type, selecting the constraint keys valid for that type."
     },
     "analyticsCatalog.parameter.validation.invalidConstraintRange": {
-        "text": "Constraint min cannot be greater than max.",
-        "crowdinContext": "Error shown when the parameter YAML declares an invalid numeric range."
+        "text": "Constraint {type, select, STRING {minLength cannot be greater than maxLength} other {min cannot be greater than max}}.",
+        "crowdinContext": "Error shown when the parameter YAML declares an invalid constraint range. {type} is the declared type, selecting the constraint key names for that type."
     },
     "analyticsCatalog.parameter.validation.invalidTags": {
         "text": "Tags must be a list of strings.",

package/esm/parameter/ParameterDialog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParameterDialog.d.ts","sourceRoot":"","sources":["../../src/parameter/ParameterDialog.tsx"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,qBAAqB,CAAC;AAM9E,OAAO,EAAE,KAAK,cAAc,EAA4B,MAAM,6BAA6B,CAAC;AAyB5F,MAAM,MAAM,mBAAmB,GAAG,QAAQ,GAAG,MAAM,CAAC;AAEpD,KAAK,KAAK,GAAG;IACT,IAAI,EAAE,mBAAmB,CAAC;IAC1B,gBAAgB,CAAC,EAAE,cAAc,CAAC;IAClC,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,QAAQ,EAAE,CAAC,SAAS,EAAE,kCAAkC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3E,WAAW,CAAC,EAAE,CAAC,SAAS,EAAE,kCAAkC,KAAK,IAAI,CAAC;CACzE,CAAC;AAEF,wBAAgB,eAAe,CAAC,KAAK,EAAE,KAAK,2CAyJ3C"}
+{"version":3,"file":"ParameterDialog.d.ts","sourceRoot":"","sources":["../../src/parameter/ParameterDialog.tsx"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,qBAAqB,CAAC;AAO9E,OAAO,EAAE,KAAK,cAAc,EAA4B,MAAM,6BAA6B,CAAC;AAyB5F,MAAM,MAAM,mBAAmB,GAAG,QAAQ,GAAG,MAAM,CAAC;AAEpD,KAAK,KAAK,GAAG;IACT,IAAI,EAAE,mBAAmB,CAAC;IAC1B,gBAAgB,CAAC,EAAE,cAAc,CAAC;IAClC,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,QAAQ,EAAE,CAAC,SAAS,EAAE,kCAAkC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3E,WAAW,CAAC,EAAE,CAAC,SAAS,EAAE,kCAAkC,KAAK,IAAI,CAAC;CACzE,CAAC;AAEF,wBAAgB,eAAe,CAAC,KAAK,EAAE,KAAK,2CAqK3C"}

package/esm/parameter/ParameterDialog.js

@@ -5,6 +5,7 @@ import { FormattedMessage, defineMessages, useIntl } from "react-intl";
 import { ConfirmDialog, UiButton, UiIcon, UiLink, UiTooltip } from "@gooddata/sdk-ui-kit";
 import { useIsWhiteLabeled } from "../permission/PermissionsContext.js";
 import { extractBackendErrorDetail } from "../utils/backendError.js";
+import { useEnabledParameterTypes } from "./gate.js";
 import { serializeParameterToYaml } from "./parameterSerialization.js";
 import { validateParameterYaml } from "./parameterValidation.js";
 import { ParameterYamlEditor } from "./ParameterYamlEditor.js";
@@ -42,11 +43,17 @@ export function ParameterDialog(props) {
     const submitMessage = intl.formatMessage(isEdit ? messages.dialogEditSubmit : messages.dialogCreateSubmit);
     const cancelMessage = intl.formatMessage(messages.dialogCancel);
     const fixedIdentifier = isEdit ? initialParameter?.id : undefined;
+    const enabledTypes = useEnabledParameterTypes();
     const validate = useCallback((value, allowIdChange = false) => {
         return validateParameterYaml(value, {
+            enabledTypes,
             fixedIdentifier: isEdit && !allowIdChange ? fixedIdentifier : undefined,
         });
-    }, [fixedIdentifier, isEdit]);
+    }, [enabledTypes, fixedIdentifier, isEdit]);
+    const formatValidationError = useCallback((result) => intl.formatMessage(messages[result.errorCode], {
+        type: result.type,
+        enabledTypes: intl.formatList(enabledTypes, { type: "conjunction" }),
+    }), [enabledTypes, intl]);
     const handleClose = useCallback(() => {
         if (!isSubmitting) {
             onClose();
@@ -61,7 +68,7 @@ export function ParameterDialog(props) {
     const handleSubmit = useCallback(async () => {
         const result = validate(yamlValue.current);
         if (!result.isValid) {
-            setValidationError(intl.formatMessage(messages[result.errorCode]));
+            setValidationError(formatValidationError(result));
             return;
         }
         setIsSubmitting(true);
@@ -75,7 +82,7 @@ export function ParameterDialog(props) {
         finally {
             setIsSubmitting(false);
         }
-    }, [intl, onSubmit, validate]);
+    }, [formatValidationError, intl, onSubmit, validate]);
     const handleDuplicate = useCallback(() => {
         if (!onDuplicate) {
             return;
@@ -83,17 +90,17 @@ export function ParameterDialog(props) {
         setSubmitError(null);
         const result = validate(yamlValue.current, true);
         if (!result.isValid) {
-            setValidationError(intl.formatMessage(messages[result.errorCode]));
+            setValidationError(formatValidationError(result));
             return;
         }
         onDuplicate(result.parameter);
-    }, [intl, onDuplicate, validate]);
+    }, [formatValidationError, onDuplicate, validate]);
     const footerLeftRenderer = useCallback(() => (_jsxs("div", { className: "gd-ascode-dialog-footer-left", children: [isWhiteLabeled ? null : (_jsxs(UiLink, { variant: "secondary", href: PARAMETER_DOCS_URL, target: "_blank", rel: "noopener noreferrer", children: [
                     _jsx(UiIcon, { type: "question", size: 14, color: "complementary-6" }), _jsx(FormattedMessage, { id: "analyticsCatalog.parameter.dialog.help" })
                 ] })), isEdit && onDuplicate ? (_jsx(UiButton, { label: intl.formatMessage(messages.dialogDuplicate), variant: "tertiary", isDisabled: isSubmitting, onClick: handleDuplicate })) : null] })), [handleDuplicate, intl, isEdit, isSubmitting, isWhiteLabeled, onDuplicate]);
     return (_jsx(ConfirmDialog, { className: "gd-ascode-dialog", containerClassName: "gd-ascode-dialog-overlay", headline: headlineMessage, cancelButtonText: cancelMessage, submitButtonText: submitMessage, isPositive: true, isSubmitDisabled: isSubmitting || (isEdit && !isDirty), isCancelDisabled: isSubmitting, shouldCloseOnEscape: !isSubmitting, onCancel: handleClose, onClose: handleClose, onSubmit: handleSubmit, displayCloseButton: !isSubmitting, footerLeftRenderer: footerLeftRenderer, children: _jsxs("div", { className: "gd-ascode-dialog-content", children: [
                 _jsxs("div", { className: "gd-ascode-dialog-section-header", children: [
                         _jsx(FormattedMessage, { id: "analyticsCatalog.parameter.dialog.sectionHeader" }), _jsx(UiTooltip, { arrowPlacement: "top", optimalPlacement: true, triggerBy: ["hover", "click", "focus"], anchor: _jsx(UiIcon, { type: "question", size: 14, color: "complementary-6" }), content: _jsx(FormattedMessage, { id: "analyticsCatalog.parameter.dialog.sectionHeader.tooltip" }) })
-                    ] }), _jsx("div", { className: "gd-ascode-dialog-editor", children: _jsx(ParameterYamlEditor, { initialValue: initialYaml, onChange: handleChange, disabled: isSubmitting }) }), validationError || submitError ? (_jsxs("div", { className: "gd-ascode-dialog-error", children: [
+                    ] }), _jsx("div", { className: "gd-ascode-dialog-editor", children: _jsx(ParameterYamlEditor, { initialValue: initialYaml, enabledTypes: enabledTypes, onChange: handleChange, disabled: isSubmitting }) }), validationError || submitError ? (_jsxs("div", { className: "gd-ascode-dialog-error", children: [
                         _jsx("span", { className: "gd-ascode-dialog-error-label", children: _jsx(FormattedMessage, { id: "analyticsCatalog.dialog.error.label" }) }), " ", validationError ?? submitError] })) : null] }) }));
 }

package/esm/parameter/ParameterYamlEditor.d.ts

@@ -1,8 +1,10 @@
+import type { ParameterType } from "@gooddata/sdk-model";
 type Props = {
     initialValue: string;
+    enabledTypes: ParameterType[];
     onChange?: (value: string) => void;
     disabled?: boolean;
 };
-export declare function ParameterYamlEditor({ initialValue, onChange, disabled }: Props): import("react/jsx-runtime").JSX.Element;
+export declare function ParameterYamlEditor({ initialValue, enabledTypes, onChange, disabled }: Props): import("react/jsx-runtime").JSX.Element;
 export {};
 //# sourceMappingURL=ParameterYamlEditor.d.ts.map

package/esm/parameter/ParameterYamlEditor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParameterYamlEditor.d.ts","sourceRoot":"","sources":["../../src/parameter/ParameterYamlEditor.tsx"],"names":[],"mappings":"AAcA,KAAK,KAAK,GAAG;IACT,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,QAAQ,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,EAAE,YAAY,EAAE,QAAQ,EAAE,QAAgB,EAAE,EAAE,KAAK,2CAwBtF"}
+{"version":3,"file":"ParameterYamlEditor.d.ts","sourceRoot":"","sources":["../../src/parameter/ParameterYamlEditor.tsx"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAMzD,KAAK,KAAK,GAAG;IACT,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,aAAa,EAAE,CAAC;IAC9B,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,QAAQ,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,EAAE,YAAY,EAAE,YAAY,EAAE,QAAQ,EAAE,QAAgB,EAAE,EAAE,KAAK,2CAyBpG"}

package/esm/parameter/ParameterYamlEditor.js

@@ -6,15 +6,16 @@ import { lintGutter } from "@codemirror/lint";
 import { lineNumbers } from "@codemirror/view";
 import { useIntl } from "react-intl";
 import { SyntaxHighlightingInput } from "@gooddata/sdk-ui-kit";
-import { parameterSchemaCompletions } from "./parameterCompletions.js";
+import { createParameterCompletions } from "./parameterCompletions.js";
 import { createYamlLinter } from "./yamlLinter.js";
-export function ParameterYamlEditor({ initialValue, onChange, disabled = false }) {
+export function ParameterYamlEditor({ initialValue, enabledTypes, onChange, disabled = false }) {
     const intl = useIntl();
     const [value, setValue] = useState(initialValue);
     const extensions = useMemo(() => [yaml(), lineNumbers(), createYamlLinter(intl), lintGutter()], [intl]);
+    const completions = useMemo(() => createParameterCompletions(enabledTypes), [enabledTypes]);
     const handleChange = useCallback((nextValue) => {
         setValue(nextValue);
         onChange?.(nextValue);
     }, [onChange]);
-    return (_jsx(SyntaxHighlightingInput, { className: "gd-ascode-dialog-editor-input", value: value, onChange: handleChange, extensions: extensions, onCompletion: parameterSchemaCompletions, disabled: disabled }));
+    return (_jsx(SyntaxHighlightingInput, { className: "gd-ascode-dialog-editor-input", value: value, onChange: handleChange, extensions: extensions, onCompletion: completions, disabled: disabled }));
 }

package/esm/parameter/gate.d.ts

@@ -1,3 +1,4 @@
+import type { ParameterType } from "@gooddata/sdk-model";
 /**
  * Catalog parameter feature gate.
  */
@@ -6,4 +7,8 @@ export declare function useIsParametersEnabled(): boolean;
  * Whether the current user can manage parameters in the catalog.
  */
 export declare function useCanManageParameter(): boolean;
+/**
+ * Parameter types authorable in the catalog, gated by `enableStringParameters`.
+ */
+export declare function useEnabledParameterTypes(): ParameterType[];
 //# sourceMappingURL=gate.d.ts.map

package/esm/parameter/gate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gate.d.ts","sourceRoot":"","sources":["../../src/parameter/gate.ts"],"names":[],"mappings":"AAIA;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,OAAO,CAEhD;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,OAAO,CAI/C"}
+{"version":3,"file":"gate.d.ts","sourceRoot":"","sources":["../../src/parameter/gate.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAIzD;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,OAAO,CAEhD;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,OAAO,CAI/C;AAED;;GAEG;AACH,wBAAgB,wBAAwB,IAAI,aAAa,EAAE,CAM1D"}

package/esm/parameter/gate.js

@@ -1,4 +1,5 @@
 // (C) 2026 GoodData Corporation
+import { useMemo } from "react";
 import { useFeatureFlag, useWorkspacePermission } from "../permission/PermissionsContext.js";
 /**
  * Catalog parameter feature gate.
@@ -14,3 +15,10 @@ export function useCanManageParameter() {
     const canManageProject = useWorkspacePermission("canManageProject");
     return isParametersEnabled && canManageProject;
 }
+/**
+ * Parameter types authorable in the catalog, gated by `enableStringParameters`.
+ */
+export function useEnabledParameterTypes() {
+    const enableStringParameters = useFeatureFlag("enableStringParameters");
+    return useMemo(() => (enableStringParameters ? ["NUMBER", "STRING"] : ["NUMBER"]), [enableStringParameters]);
+}

package/esm/parameter/parameterCompletions.d.ts

@@ -1,7 +1,13 @@
 import type { CompletionContext, CompletionResult } from "@codemirror/autocomplete";
+import type { ParameterType } from "@gooddata/sdk-model";
 /**
- * CodeMirror completion source that suggests allowed YAML property names
- * based on the parameter zod schema and cursor position in the Lezer tree.
+ * Creates a CodeMirror completion source that suggests allowed YAML property
+ * names and `type:` values.
+ *
+ * The parent mapping is derived from the cursor's indentation column. Key
+ * suggestions are narrowed to the declared `definition.type` when present
+ * (falling back to the union of the enabled types); `type:` value suggestions
+ * always offer every enabled type.
  */
-export declare function parameterSchemaCompletions(context: CompletionContext): CompletionResult | null;
+export declare function createParameterCompletions(enabledTypes: ParameterType[]): (context: CompletionContext) => CompletionResult | null;
 //# sourceMappingURL=parameterCompletions.d.ts.map

package/esm/parameter/parameterCompletions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parameterCompletions.d.ts","sourceRoot":"","sources":["../../src/parameter/parameterCompletions.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAcpF;;;GAGG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,iBAAiB,GAAG,gBAAgB,GAAG,IAAI,CAoB9F"}
+{"version":3,"file":"parameterCompletions.d.ts","sourceRoot":"","sources":["../../src/parameter/parameterCompletions.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAc,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAGhG,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAIzD;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CAAC,YAAY,EAAE,aAAa,EAAE,2DAuCvE"}

package/esm/parameter/parameterCompletions.js

@@ -1,53 +1,78 @@
 // (C) 2026 GoodData Corporation
-import { syntaxTree } from "@codemirror/language";
-import { PARAMETER_SCHEMA_KEYS } from "./parameterSchema.js";
-/** Pre-built completion options from the schema key map. */
-const completionOptions = Object.fromEntries(Object.entries(PARAMETER_SCHEMA_KEYS).map(([parent, keys]) => [
-    parent,
-    keys.map((label) => ({ label, type: "property" })),
-]));
+import { parameterSchemaKeys } from "./parameterSchema.js";
 /**
- * CodeMirror completion source that suggests allowed YAML property names
- * based on the parameter zod schema and cursor position in the Lezer tree.
+ * Creates a CodeMirror completion source that suggests allowed YAML property
+ * names and `type:` values.
+ *
+ * The parent mapping is derived from the cursor's indentation column. Key
+ * suggestions are narrowed to the declared `definition.type` when present
+ * (falling back to the union of the enabled types); `type:` value suggestions
+ * always offer every enabled type.
  */
-export function parameterSchemaCompletions(context) {
-    const line = context.state.doc.lineAt(context.pos);
-    const before = line.text.slice(0, context.pos - line.from);
-    // Only trigger when typing a key name at the start of a line
-    const match = before.match(/^(\s*)(\w*)$/);
-    if (!match) {
-        return null;
-    }
-    const word = match[2];
-    const from = context.pos - word.length;
-    const parentKey = getParentKey(context.state, context.pos);
-    const options = completionOptions[parentKey];
-    if (!options) {
-        return null;
-    }
-    return { from, options };
+export function createParameterCompletions(enabledTypes) {
+    const keyOptionsByType = new Map(enabledTypes.map((type) => [type, toOptions(parameterSchemaKeys([type]))]));
+    const fallbackKeyOptions = toOptions(parameterSchemaKeys(enabledTypes));
+    const typeValueOptions = {
+        "": [{ label: "parameter", type: "constant" }],
+        definition: enabledTypes.map((label) => ({ label, type: "constant" })),
+    };
+    return function completeParameter(context) {
+        const line = context.state.doc.lineAt(context.pos);
+        const before = line.text.slice(0, context.pos - line.from);
+        // Trigger on a key name at the start of a line, or on the value of a `type:` key
+        const keyMatch = before.match(/^(\s*)(\w*)$/);
+        const typeMatch = keyMatch ? null : before.match(/^(\s*)type:\s+(\w*)$/);
+        const match = keyMatch ?? typeMatch;
+        if (!match) {
+            return null;
+        }
+        const indent = match[1].length;
+        const word = match[2];
+        const parentKey = getParentKey(context.state.doc, line.number, indent);
+        if (parentKey === null) {
+            return null;
+        }
+        const declaredType = getDeclaredType(context.state.doc);
+        const keyOptions = (declaredType ? keyOptionsByType.get(declaredType) : undefined) ?? fallbackKeyOptions;
+        const options = (keyMatch ? keyOptions : typeValueOptions)[parentKey];
+        if (!options) {
+            return null;
+        }
+        return { from: context.pos - word.length, options };
+    };
+}
+function toOptions(keyMap) {
+    return Object.fromEntries(Object.entries(keyMap).map(([parent, keys]) => [
+        parent,
+        keys.map((label) => ({ label, type: "property" })),
+    ]));
 }
 /**
- * Walk up the Lezer YAML tree from cursor to find which key's BlockMapping
- * we're inside. Returns "" for the top-level mapping.
+ * The key whose block mapping a new entry at column `indent` would join: the
+ * nearest less-indented `key:` line above. Returns "" for the top-level
+ * mapping and null when the enclosing line is not a mapping key.
  */
-function getParentKey(state, pos) {
-    const tree = syntaxTree(state);
-    let node = tree.resolveInner(pos, -1).parent;
-    // Find the BlockMapping we're inside
-    while (node) {
-        if (node.name === "BlockMapping") {
-            // If this BlockMapping is the value of a Pair, return the Pair's key
-            const pair = node.parent;
-            if (pair?.name === "Pair") {
-                const keyNode = pair.getChild("Key");
-                if (keyNode) {
-                    return state.sliceDoc(keyNode.from, keyNode.to).trim();
-                }
-            }
-            return "";
+function getParentKey(doc, lineNumber, indent) {
+    if (indent === 0) {
+        return "";
+    }
+    for (let number = lineNumber - 1; number >= 1; number--) {
+        const text = doc.line(number).text;
+        const content = text.trimStart();
+        if (content === "" || content.startsWith("#") || text.length - content.length >= indent) {
+            continue;
         }
-        node = node.parent;
+        return content.match(/^([\w-]+):/)?.[1] ?? null;
     }
     return "";
 }
+/** Value of the first indented `type:` key, i.e. `definition.type` (the top-level `type` is unindented). */
+function getDeclaredType(doc) {
+    for (let number = 1; number <= doc.lines; number++) {
+        const match = doc.line(number).text.match(/^\s+type:\s*(\w+)/);
+        if (match) {
+            return match[1];
+        }
+    }
+    return undefined;
+}

package/esm/parameter/parameterSchema.d.ts

@@ -1,20 +1,40 @@
 import * as z from "zod/mini";
-export declare const parameterSchema: z.ZodMiniObject<{
+import type { ParameterType } from "@gooddata/sdk-model";
+/** Full-union schema: single source for the editor vocabulary and the exported types, independent of the flag. */
+declare const parameterSchema: z.ZodMiniObject<{
     type: z.ZodMiniDefault<z.ZodMiniLiteral<"parameter">>;
     id: z.ZodMiniOptional<z.ZodMiniString<string>>;
     title: z.ZodMiniOptional<z.ZodMiniString<string>>;
     description: z.ZodMiniOptional<z.ZodMiniString<string>>;
     tags: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
-    definition: z.ZodMiniDiscriminatedUnion<readonly [z.ZodMiniObject<{
+    definition: z.ZodMiniDiscriminatedUnion<[z.ZodMiniObject<{
         type: z.ZodMiniLiteral<"NUMBER">;
         defaultValue: z.ZodMiniNumber<number>;
         constraints: z.ZodMiniOptional<z.ZodMiniObject<{
             min: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
             max: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
         }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodMiniObject<{
+        type: z.ZodMiniLiteral<"STRING">;
+        defaultValue: z.ZodMiniString<string>;
+        constraints: z.ZodMiniOptional<z.ZodMiniObject<{
+            minLength: z.ZodMiniOptional<z.ZodMiniNumberFormat>;
+            maxLength: z.ZodMiniOptional<z.ZodMiniNumberFormat>;
+        }, z.core.$strict>>;
     }, z.core.$strict>], "type">;
 }, z.core.$strict>;
 export type ParameterSchemaInput = z.input<typeof parameterSchema>;
 export type ParameterSchema = z.infer<typeof parameterSchema>;
-export declare const PARAMETER_SCHEMA_KEYS: Record<string, string[]>;
+/** Parent key → allowed child keys for the schema restricted to `enabledTypes`; powers YAML editor autocompletion. */
+export declare function parameterSchemaKeys(enabledTypes: ParameterType[]): Record<string, string[]>;
+/** Runtime validation schema restricted to the enabled types; the static types stay the full union. */
+export declare function buildParameterSchema(enabledTypes: ParameterType[]): z.ZodMiniObject<{
+    type: z.ZodMiniDefault<z.ZodMiniLiteral<"parameter">>;
+    id: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    title: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    description: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    tags: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
+    definition: z.ZodMiniDiscriminatedUnion<readonly [z.core.$ZodTypeDiscriminable, ...z.core.$ZodTypeDiscriminable[]], "type">;
+}, z.core.$strict>;
+export {};
 //# sourceMappingURL=parameterSchema.d.ts.map

package/esm/parameter/parameterSchema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parameterSchema.d.ts","sourceRoot":"","sources":["../../src/parameter/parameterSchema.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AA6C9B,eAAO,MAAM,eAAe;;;;;;;;;;;;;;kBAO1B,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AACnE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D,eAAO,MAAM,qBAAqB,0BAAoC,CAAC"}
+{"version":3,"file":"parameterSchema.d.ts","sourceRoot":"","sources":["../../src/parameter/parameterSchema.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAE9B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAoDzD,kHAAkH;AAClH,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;kBAOnB,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AACnE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D,wHAAsH;AACtH,wBAAgB,mBAAmB,CAAC,YAAY,EAAE,aAAa,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAE3F;AAED,uGAAuG;AACvG,wBAAgB,oBAAoB,CAAC,YAAY,EAAE,aAAa,EAAE;;;;;;;mBAMjE"}

package/esm/parameter/parameterSchema.js

@@ -17,9 +17,22 @@ const numberConstraintsSchema = z
         });
     }
 });
-const stringConstraintsSchema = z.strictObject({
-    minLength: z.optional(z.number()),
-    maxLength: z.optional(z.number()),
+const lengthSchema = z.int().check(z.nonnegative());
+const stringConstraintsSchema = z
+    .strictObject({
+    minLength: z.optional(lengthSchema),
+    maxLength: z.optional(lengthSchema),
+})
+    .check((ctx) => {
+    const { minLength, maxLength } = ctx.value;
+    if (minLength !== undefined && maxLength !== undefined && minLength > maxLength) {
+        ctx.issues.push({
+            code: "custom",
+            message: "invalidConstraintRange",
+            input: ctx.value,
+            path: [],
+        });
+    }
 });
 /** One arm per model type; `satisfies` breaks the build if the model gains a type without an arm. */
 const definitionSchemas = {
@@ -34,19 +47,28 @@ const definitionSchemas = {
         constraints: z.optional(stringConstraintsSchema),
     }),
 };
-/** Policy knob: the types the UI validates. Others still display via the seed but are rejected at submit. */
-const supportedDefinitionSchemas = [definitionSchemas.NUMBER];
-const definitionSchema = z.discriminatedUnion("type", supportedDefinitionSchemas);
-export const parameterSchema = z.strictObject({
+/** Full-union schema: single source for the editor vocabulary and the exported types, independent of the flag. */
+const parameterSchema = z.strictObject({
     type: z._default(z.literal("parameter"), "parameter"),
     id: z.optional(z.string()),
     title: z.optional(z.string()),
     description: z.optional(z.string()),
     tags: z.optional(z.array(z.string())),
-    definition: definitionSchema,
+    definition: z.discriminatedUnion("type", [definitionSchemas.NUMBER, definitionSchemas.STRING]),
 });
-export const PARAMETER_SCHEMA_KEYS = deriveSchemaKeys(parameterSchema);
-/** Map of parent key → allowed child keys, powering YAML editor autocompletion. */
+/** Parent key → allowed child keys for the schema restricted to `enabledTypes`; powers YAML editor autocompletion. */
+export function parameterSchemaKeys(enabledTypes) {
+    return deriveSchemaKeys(buildParameterSchema(enabledTypes));
+}
+/** Runtime validation schema restricted to the enabled types; the static types stay the full union. */
+export function buildParameterSchema(enabledTypes) {
+    // Re-spread to a non-empty tuple: `discriminatedUnion` requires it and it preserves the inferred union.
+    const [first, ...rest] = enabledTypes.map((type) => definitionSchemas[type]);
+    return z.extend(parameterSchema, {
+        definition: z.discriminatedUnion("type", [first, ...rest]),
+    });
+}
+/** Map of parent key → allowed child keys. */
 function deriveSchemaKeys(schema, parentKey = "", result = {}) {
     for (const object of objectSchemasOf(schema)) {
         const { shape } = object._zod.def;

package/esm/parameter/parameterValidation.d.ts

@@ -1,3 +1,4 @@
+import type { ParameterType } from "@gooddata/sdk-model";
 import { type ParameterSchema } from "./parameterSchema.js";
 export type ParameterValidationResult = {
     isValid: true;
@@ -5,11 +6,13 @@ export type ParameterValidationResult = {
 } | {
     isValid: false;
     errorCode: ParameterValidationErrorCode;
+    type?: ParameterType;
 };
 export type ParameterValidationErrorCode = "empty" | "syntax" | "invalidStructure" | "idImmutable" | "unsupportedType" | "invalidDefaultValue" | "invalidConstraints" | "invalidConstraintRange" | "invalidTags";
 type ValidateParameterYamlOptions = {
+    enabledTypes: ParameterType[];
     fixedIdentifier?: string;
 };
-export declare function validateParameterYaml(value: string, options?: ValidateParameterYamlOptions): ParameterValidationResult;
+export declare function validateParameterYaml(value: string, options: ValidateParameterYamlOptions): ParameterValidationResult;
 export {};
 //# sourceMappingURL=parameterValidation.d.ts.map

package/esm/parameter/parameterValidation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parameterValidation.d.ts","sourceRoot":"","sources":["../../src/parameter/parameterValidation.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,eAAe,EAAmB,MAAM,sBAAsB,CAAC;AAE7E,MAAM,MAAM,yBAAyB,GAC/B;IACI,OAAO,EAAE,IAAI,CAAC;IACd,SAAS,EAAE,eAAe,CAAC;CAC9B,GACD;IACI,OAAO,EAAE,KAAK,CAAC;IACf,SAAS,EAAE,4BAA4B,CAAC;CAC3C,CAAC;AAER,MAAM,MAAM,4BAA4B,GAClC,OAAO,GACP,QAAQ,GACR,kBAAkB,GAClB,aAAa,GACb,iBAAiB,GACjB,qBAAqB,GACrB,oBAAoB,GACpB,wBAAwB,GACxB,aAAa,CAAC;AAEpB,KAAK,4BAA4B,GAAG;IAChC,eAAe,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,wBAAgB,qBAAqB,CACjC,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,4BAAiC,GAC3C,yBAAyB,CAyB3B"}
+{"version":3,"file":"parameterValidation.d.ts","sourceRoot":"","sources":["../../src/parameter/parameterValidation.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD,OAAO,EAAE,KAAK,eAAe,EAAwB,MAAM,sBAAsB,CAAC;AAElF,MAAM,MAAM,yBAAyB,GAC/B;IACI,OAAO,EAAE,IAAI,CAAC;IACd,SAAS,EAAE,eAAe,CAAC;CAC9B,GACD;IACI,OAAO,EAAE,KAAK,CAAC;IACf,SAAS,EAAE,4BAA4B,CAAC;IACxC,IAAI,CAAC,EAAE,aAAa,CAAC;CACxB,CAAC;AAER,MAAM,MAAM,4BAA4B,GAClC,OAAO,GACP,QAAQ,GACR,kBAAkB,GAClB,aAAa,GACb,iBAAiB,GACjB,qBAAqB,GACrB,oBAAoB,GACpB,wBAAwB,GACxB,aAAa,CAAC;AAEpB,KAAK,4BAA4B,GAAG;IAChC,YAAY,EAAE,aAAa,EAAE,CAAC;IAC9B,eAAe,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,wBAAgB,qBAAqB,CACjC,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,4BAA4B,GACtC,yBAAyB,CAyB3B"}

package/esm/parameter/parameterValidation.js

@@ -1,7 +1,7 @@
 // (C) 2026 GoodData Corporation
 import { parse as parseYaml } from "yaml";
-import { parameterSchema } from "./parameterSchema.js";
-export function validateParameterYaml(value, options = {}) {
+import { buildParameterSchema } from "./parameterSchema.js";
+export function validateParameterYaml(value, options) {
     if (value.trim() === "") {
         return invalid("empty");
     }
@@ -12,9 +12,9 @@ export function validateParameterYaml(value, options = {}) {
     catch {
         return invalid("syntax");
     }
-    const result = parameterSchema.safeParse(parsed);
+    const result = buildParameterSchema(options.enabledTypes).safeParse(parsed);
     if (!result.success) {
-        return classifySchemaError(result.error);
+        return classifySchemaError(result.error, readDeclaredType(parsed));
     }
     if (options.fixedIdentifier !== undefined && result.data.id !== options.fixedIdentifier) {
         return invalid("idImmutable");
@@ -24,22 +24,22 @@ export function validateParameterYaml(value, options = {}) {
         parameter: result.data,
     };
 }
-function classifySchemaError(error) {
+function classifySchemaError(error, declaredType) {
     for (const issue of error.issues) {
         const path = issue.path.map(String).join(".");
         if (issue.code === "custom") {
             if (issue.message === "invalidConstraintRange") {
-                return invalid("invalidConstraintRange");
+                return invalid("invalidConstraintRange", declaredType);
             }
         }
         if (path === "definition.type") {
             return invalid("unsupportedType");
         }
         if (path === "definition.defaultValue") {
-            return invalid("invalidDefaultValue");
+            return invalid("invalidDefaultValue", declaredType);
         }
         if (path.startsWith("definition.constraints")) {
-            return invalid("invalidConstraints");
+            return invalid("invalidConstraints", declaredType);
         }
         if (path === "tags" || path.startsWith("tags.")) {
             return invalid("invalidTags");
@@ -47,9 +47,22 @@ function classifySchemaError(error) {
     }
     return invalid("invalidStructure");
 }
-function invalid(code) {
+/** The declared `definition.type`, when it names a known model type; drives the type-specific error copy. */
+function readDeclaredType(parsed) {
+    if (!parsed || typeof parsed !== "object") {
+        return undefined;
+    }
+    const { definition } = parsed;
+    if (!definition || typeof definition !== "object") {
+        return undefined;
+    }
+    const { type } = definition;
+    return type === "NUMBER" || type === "STRING" ? type : undefined;
+}
+function invalid(code, type) {
     return {
         isValid: false,
         errorCode: code,
+        type,
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gooddata/sdk-ui-catalog",
-  "version": "11.46.0-alpha.4",
+  "version": "11.46.0-alpha.6",
   "description": "GoodData SDK - Analytics Catalog",
   "license": "MIT",
   "author": "GoodData Corporation",
@@ -45,15 +45,15 @@
     "tslib": "2.8.1",
     "yaml": "2.8.3",
     "zod": "4.3.6",
-    "@gooddata/sdk-backend-spi": "11.46.0-alpha.4",
-    "@gooddata/sdk-code-schemas": "11.46.0-alpha.4",
-    "@gooddata/sdk-ui": "11.46.0-alpha.4",
-    "@gooddata/sdk-model": "11.46.0-alpha.4",
-    "@gooddata/sdk-ui-ext": "11.46.0-alpha.4",
-    "@gooddata/sdk-ui-kit": "11.46.0-alpha.4",
-    "@gooddata/sdk-ui-semantic-search": "11.46.0-alpha.4",
-    "@gooddata/sdk-ui-theme-provider": "11.46.0-alpha.4",
-    "@gooddata/util": "11.46.0-alpha.4"
+    "@gooddata/sdk-backend-spi": "11.46.0-alpha.6",
+    "@gooddata/sdk-code-schemas": "11.46.0-alpha.6",
+    "@gooddata/sdk-model": "11.46.0-alpha.6",
+    "@gooddata/sdk-ui": "11.46.0-alpha.6",
+    "@gooddata/sdk-ui-ext": "11.46.0-alpha.6",
+    "@gooddata/sdk-ui-kit": "11.46.0-alpha.6",
+    "@gooddata/sdk-ui-semantic-search": "11.46.0-alpha.6",
+    "@gooddata/util": "11.46.0-alpha.6",
+    "@gooddata/sdk-ui-theme-provider": "11.46.0-alpha.6"
   },
   "devDependencies": {
     "@microsoft/api-documenter": "^7.17.0",
@@ -93,11 +93,11 @@
     "typescript": "5.9.3",
     "vitest": "4.1.8",
     "vitest-dom": "0.1.1",
-    "@gooddata/oxlint-config": "11.46.0-alpha.4",
-    "@gooddata/i18n-toolkit": "11.46.0-alpha.4",
-    "@gooddata/eslint-config": "11.46.0-alpha.4",
-    "@gooddata/sdk-backend-mockingbird": "11.46.0-alpha.4",
-    "@gooddata/stylelint-config": "11.46.0-alpha.4"
+    "@gooddata/eslint-config": "11.46.0-alpha.6",
+    "@gooddata/i18n-toolkit": "11.46.0-alpha.6",
+    "@gooddata/oxlint-config": "11.46.0-alpha.6",
+    "@gooddata/sdk-backend-mockingbird": "11.46.0-alpha.6",
+    "@gooddata/stylelint-config": "11.46.0-alpha.6"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0",