@gooddata/sdk-ui-catalog 11.46.0-alpha.3 → 11.46.0-alpha.5

package/esm/metric/metricValidation.d.ts

@@ -0,0 +1,15 @@
+import type { IMeasureMetadataObjectDefinition } from "@gooddata/sdk-model";
+export type MetricValidationResult = {
+    isValid: true;
+    measure: IMeasureMetadataObjectDefinition;
+} | {
+    isValid: false;
+    errorCode: MetricValidationErrorCode;
+};
+export type MetricValidationErrorCode = "empty" | "syntax" | "invalidStructure" | "idImmutable" | "missingMaql" | "invalidTags";
+type ValidateMetricYamlOptions = {
+    fixedIdentifier?: string;
+};
+export declare function validateMetricYaml(value: string, options?: ValidateMetricYamlOptions): MetricValidationResult;
+export {};
+//# sourceMappingURL=metricValidation.d.ts.map

package/esm/metric/metricValidation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metricValidation.d.ts","sourceRoot":"","sources":["../../src/metric/metricValidation.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,qBAAqB,CAAC;AAK5E,MAAM,MAAM,sBAAsB,GAC5B;IACI,OAAO,EAAE,IAAI,CAAC;IACd,OAAO,EAAE,gCAAgC,CAAC;CAC7C,GACD;IACI,OAAO,EAAE,KAAK,CAAC;IACf,SAAS,EAAE,yBAAyB,CAAC;CACxC,CAAC;AAER,MAAM,MAAM,yBAAyB,GAC/B,OAAO,GACP,QAAQ,GACR,kBAAkB,GAClB,aAAa,GACb,aAAa,GACb,aAAa,CAAC;AAEpB,KAAK,yBAAyB,GAAG;IAC7B,eAAe,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,wBAAgB,kBAAkB,CAC9B,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,yBAA8B,GACxC,sBAAsB,CAyBxB"}

package/esm/metric/metricValidation.js

@@ -0,0 +1,47 @@
+// (C) 2026 GoodData Corporation
+import { parse as parseYaml } from "yaml";
+import { metricYamlToDefinition } from "./metricConverter.js";
+import { metricSchema } from "./metricSchema.js";
+export function validateMetricYaml(value, options = {}) {
+    if (value.trim() === "") {
+        return invalid("empty");
+    }
+    let parsed;
+    try {
+        parsed = parseYaml(value, { strict: true });
+    }
+    catch {
+        return invalid("syntax");
+    }
+    const result = metricSchema.safeParse(parsed);
+    if (!result.success) {
+        return classifySchemaError(result.error, parsed);
+    }
+    if (options.fixedIdentifier !== undefined && result.data.id !== options.fixedIdentifier) {
+        return invalid("idImmutable");
+    }
+    return {
+        isValid: true,
+        measure: metricYamlToDefinition(result.data),
+    };
+}
+function classifySchemaError(error, parsed) {
+    const maqlProvided = typeof parsed === "object" && parsed !== null && parsed.maql !== undefined;
+    for (const issue of error.issues) {
+        const path = issue.path.map(String).join(".");
+        if (path === "maql") {
+            // A present-but-wrong-typed maql is a structural error, not a missing field.
+            return invalid(maqlProvided ? "invalidStructure" : "missingMaql");
+        }
+        if (path === "tags" || path.startsWith("tags.")) {
+            return invalid("invalidTags");
+        }
+    }
+    return invalid("invalidStructure");
+}
+function invalid(code) {
+    return {
+        isValid: false,
+        errorCode: code,
+    };
+}

package/esm/metric/metricYamlLinter.d.ts

@@ -0,0 +1,7 @@
+import { type IntlShape } from "react-intl";
+/**
+ * Creates a CodeMirror linter extension that reports YAML syntax errors
+ * using the metric-specific syntax error message.
+ */
+export declare function createMetricYamlLinter(intl: IntlShape): import("@codemirror/state").Extension;
+//# sourceMappingURL=metricYamlLinter.d.ts.map

package/esm/metric/metricYamlLinter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metricYamlLinter.d.ts","sourceRoot":"","sources":["../../src/metric/metricYamlLinter.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,SAAS,EAAkB,MAAM,YAAY,CAAC;AAQ5D;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,SAAS,yCAErD"}

package/esm/metric/metricYamlLinter.js

@@ -0,0 +1,13 @@
+// (C) 2026 GoodData Corporation
+import { defineMessages } from "react-intl";
+import { createYamlSyntaxLinter } from "../utils/yamlSyntaxLinter.js";
+const messages = defineMessages({
+    syntaxError: { id: "analyticsCatalog.metric.validation.syntax" },
+});
+/**
+ * Creates a CodeMirror linter extension that reports YAML syntax errors
+ * using the metric-specific syntax error message.
+ */
+export function createMetricYamlLinter(intl) {
+    return createYamlSyntaxLinter(intl.formatMessage(messages.syntaxError));
+}

package/esm/metric/tests/metricMutationPort.test.utils.d.ts

@@ -0,0 +1,7 @@
+import type { IMetricMutationPort } from "../metricMutationPort.js";
+/**
+ * Test utility. Returns a metric mutation port with vi.fn() stubs.
+ * @internal
+ */
+export declare function createTestMetricMutationPort(overrides?: Partial<IMetricMutationPort>): IMetricMutationPort;
+//# sourceMappingURL=metricMutationPort.test.utils.d.ts.map

package/esm/metric/tests/metricMutationPort.test.utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metricMutationPort.test.utils.d.ts","sourceRoot":"","sources":["../../../src/metric/tests/metricMutationPort.test.utils.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAiBpE;;;GAGG;AACH,wBAAgB,4BAA4B,CACxC,SAAS,GAAE,OAAO,CAAC,mBAAmB,CAAM,GAC7C,mBAAmB,CAsBrB"}

package/esm/metric/tests/metricMutationPort.test.utils.js

@@ -0,0 +1,43 @@
+// (C) 2026 GoodData Corporation
+import { vi } from "vitest";
+const defaultSavedItem = {
+    identifier: "test-metric",
+    type: "measure",
+    title: "Test Metric",
+    description: "",
+    tags: [],
+    createdBy: "test",
+    updatedBy: "test",
+    createdAt: null,
+    updatedAt: null,
+    isLocked: false,
+    isEditable: true,
+    format: "#,##0.00",
+};
+/**
+ * Test utility. Returns a metric mutation port with vi.fn() stubs.
+ * @internal
+ */
+export function createTestMetricMutationPort(overrides = {}) {
+    return {
+        create: vi.fn().mockResolvedValue(defaultSavedItem),
+        update: vi.fn().mockResolvedValue(defaultSavedItem),
+        delete: vi.fn().mockResolvedValue(undefined),
+        load: vi.fn().mockResolvedValue({
+            id: "test-metric",
+            uri: "test-metric",
+            ref: { identifier: "test-metric", type: "measure" },
+            type: "measure",
+            title: "Test Metric",
+            description: "",
+            tags: [],
+            production: true,
+            deprecated: false,
+            unlisted: false,
+            expression: "SELECT 1",
+            format: "#,##0.00",
+        }),
+        getReferencingObjects: vi.fn().mockResolvedValue({ insights: [], measures: [] }),
+        ...overrides,
+    };
+}

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;AAK9E,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,2CAsJ3C"}
+{"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

@@ -4,6 +4,8 @@ import { useCallback, useRef, useState } from "react";
 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";
@@ -41,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();
@@ -60,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);
@@ -69,13 +77,12 @@ export function ParameterDialog(props) {
             await onSubmit(result.parameter);
         }
         catch (error) {
-            const message = error instanceof Error && error.message ? error.message : undefined;
-            setSubmitError(message ?? intl.formatMessage(messages.dialogSubmitError));
+            setSubmitError(extractBackendErrorDetail(error) ?? intl.formatMessage(messages.dialogSubmitError));
         }
         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]);
-    const footerLeftRenderer = useCallback(() => (_jsxs("div", { className: "gd-parameter-dialog-footer-left", children: [isWhiteLabeled ? null : (_jsxs(UiLink, { variant: "secondary", href: PARAMETER_DOCS_URL, target: "_blank", rel: "noopener noreferrer", children: [
+    }, [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-parameter-dialog", containerClassName: "gd-parameter-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-parameter-dialog-content", children: [
-                _jsxs("div", { className: "gd-parameter-dialog-section-header", children: [
+    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-parameter-dialog-editor", children: _jsx(ParameterYamlEditor, { initialValue: initialYaml, onChange: handleChange, disabled: isSubmitting }) }), validationError || submitError ? (_jsxs("div", { className: "gd-parameter-dialog-error", children: [
-                        _jsx("span", { className: "gd-parameter-dialog-error-label", children: "Error:" }), " ", validationError ?? submitError] })) : null] }) }));
+                    ] }), _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-parameter-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"}