@gooddata/sdk-ui-catalog 11.51.0-alpha.4 → 11.51.0

package/esm/parameter/parameterSchema.d.ts

@@ -1,5 +1,30 @@
 import * as z from "zod/mini";
 import type { ParameterType } from "@gooddata/sdk-model";
+/**
+ * Codes carried by schema issues via `issue.message`; `classifySchemaError` routes each to the
+ * equally named validation error code, so every entry needs a localized message wired up.
+ */
+export declare const schemaErrorCodes: readonly ["invalidConstraintRange", "invalidAllowedValue", "invalidAllowedValueTitle", "duplicateAllowedValues", "emptyAllowedValues", "constraintsAllowedValuesExclusive", "unsupportedCardinality", "invalidDefaultValue"];
+export type SchemaErrorCode = (typeof schemaErrorCodes)[number];
+export type ParameterSchemaInput = z.input<typeof parameterSchema>;
+export type ParameterSchema = z.infer<typeof parameterSchema>;
+export type ParameterSchemaKeys = Record<string, SchemaKeysEntry>;
+/** Child keys reachable under a parent key: directly in its mapping, or inside each item of its sequence. */
+export type SchemaKeysEntry = {
+    kind: "mapping" | "sequence";
+    keys: string[];
+};
+/** Parent key → child-key entry for the schema restricted to `enabledTypes`; powers YAML editor autocompletion. */
+export declare function parameterSchemaKeys(enabledTypes: ParameterType[]): ParameterSchemaKeys;
+/** Runtime validation schema restricted to the enabled types; the static types stay the full union. */
+export declare function buildParameterSchema(enabledTypes: ParameterType[]): z.ZodMiniObject<{
+    definition: z.ZodMiniDiscriminatedUnion<readonly [z.core.$ZodTypeDiscriminable, ...z.core.$ZodTypeDiscriminable[]], "type">;
+    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>>>;
+}, z.core.$strict>;
 /** 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">>;
@@ -14,27 +39,42 @@ declare const parameterSchema: z.ZodMiniObject<{
             min: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
             max: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
         }, z.core.$strict>>;
-    }, z.core.$strict>, z.ZodMiniObject<{
+    }, z.core.$strict>, z.ZodMiniPipe<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>;
+            allowedValues: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniObject<{
+                value: z.ZodMiniString<string>;
+                title: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            }, z.core.$strict>>>;
         }, z.core.$strict>>;
-    }, z.core.$strict>], "type">;
-}, z.core.$strict>;
-export type ParameterSchemaInput = z.input<typeof parameterSchema>;
-export type ParameterSchema = z.infer<typeof parameterSchema>;
-/** 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">;
+        cardinality: z.ZodMiniOptional<z.ZodMiniLiteral<"multi" | "single">>;
+    }, z.core.$strict>, z.ZodMiniTransform<{
+        type: "STRING";
+        defaultValue: string;
+        constraints?: {
+            minLength?: number | undefined;
+            maxLength?: number | undefined;
+            allowedValues?: {
+                value: string;
+                title?: string | undefined;
+            }[] | undefined;
+        } | undefined;
+    }, {
+        type: "STRING";
+        defaultValue: string;
+        constraints?: {
+            minLength?: number | undefined;
+            maxLength?: number | undefined;
+            allowedValues?: {
+                value: string;
+                title?: string | undefined;
+            }[] | undefined;
+        } | undefined;
+        cardinality?: "multi" | "single" | undefined;
+    }>>], "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;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"}
+{"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;AAEzD;;;GAGG;AACH,eAAO,MAAM,gBAAgB,8NASnB,CAAC;AAEX,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEhE,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,MAAM,MAAM,mBAAmB,GAAG,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;AAElE,6GAA6G;AAC7G,MAAM,MAAM,eAAe,GAAG;IAC1B,IAAI,EAAE,SAAS,GAAG,UAAU,CAAC;IAC7B,IAAI,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAEF,qHAAmH;AACnH,wBAAgB,mBAAmB,CAAC,YAAY,EAAE,aAAa,EAAE,GAAG,mBAAmB,CAEtF;AAED,uGAAuG;AACvG,wBAAgB,oBAAoB,CAAC,YAAY,EAAE,aAAa,EAAE;;;;;;;mBAMjE;AAkFD,kHAAkH;AAClH,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAOnB,CAAC"}

package/esm/parameter/parameterSchema.js

@@ -1,39 +1,53 @@
 // (C) 2026 GoodData Corporation
 import { union } from "lodash-es";
 import * as z from "zod/mini";
+/**
+ * Codes carried by schema issues via `issue.message`; `classifySchemaError` routes each to the
+ * equally named validation error code, so every entry needs a localized message wired up.
+ */
+export const schemaErrorCodes = [
+    "invalidConstraintRange",
+    "invalidAllowedValue",
+    "invalidAllowedValueTitle",
+    "duplicateAllowedValues",
+    "emptyAllowedValues",
+    "constraintsAllowedValuesExclusive",
+    "unsupportedCardinality",
+    "invalidDefaultValue",
+];
+/** Parent key → child-key entry 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]),
+    });
+}
 const numberConstraintsSchema = z
     .strictObject({
     min: z.optional(z.number()),
     max: z.optional(z.number()),
 })
-    .check((ctx) => {
-    const { min, max } = ctx.value;
-    if (min !== undefined && max !== undefined && min > max) {
-        ctx.issues.push({
-            code: "custom",
-            message: "invalidConstraintRange",
-            input: ctx.value,
-            path: [],
-        });
-    }
-});
+    .check(rule("invalidConstraintRange", ({ min, max }) => min === undefined || max === undefined || min <= max));
 const lengthSchema = z.int().check(z.nonnegative());
+const allowedValueSchema = z
+    .strictObject({
+    value: z.string("invalidAllowedValue"),
+    title: z.optional(z.string("invalidAllowedValueTitle")),
+})
+    .check(rule("invalidAllowedValue", ({ value }) => value !== ""), rule("invalidAllowedValueTitle", ({ value, title }) => (title ?? value).trim() !== ""));
+const allowedValuesSchema = z.array(allowedValueSchema).check(rule("emptyAllowedValues", (entries) => entries.length > 0), rule("duplicateAllowedValues", (entries) => allUnique(entries.map((entry) => entry.value))), rule("duplicateAllowedValues", (entries) => allUnique(entries.map((entry) => entry.title ?? entry.value))));
 const stringConstraintsSchema = z
     .strictObject({
     minLength: z.optional(lengthSchema),
     maxLength: z.optional(lengthSchema),
+    allowedValues: z.optional(allowedValuesSchema),
 })
-    .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: [],
-        });
-    }
-});
+    .check(rule("invalidConstraintRange", ({ minLength, maxLength }) => minLength === undefined || maxLength === undefined || minLength <= maxLength), rule("constraintsAllowedValuesExclusive", ({ minLength, maxLength, allowedValues }) => allowedValues === undefined || (minLength === undefined && maxLength === undefined)));
 /** One arm per model type; `satisfies` breaks the build if the model gains a type without an arm. */
 const definitionSchemas = {
     NUMBER: z.strictObject({
@@ -41,11 +55,15 @@ const definitionSchemas = {
         defaultValue: z.number(),
         constraints: z.optional(numberConstraintsSchema),
     }),
-    STRING: z.strictObject({
+    STRING: z.pipe(z
+        .strictObject({
         type: z.literal("STRING"),
         defaultValue: z.string(),
         constraints: z.optional(stringConstraintsSchema),
-    }),
+        cardinality: z.optional(z.literal(["single", "multi"], "unsupportedCardinality")),
+    })
+        .check(rule("unsupportedCardinality", ({ cardinality }) => cardinality !== "multi", ["cardinality"]), rule("invalidDefaultValue", ({ defaultValue, constraints }) => !constraints?.allowedValues?.length ||
+        constraints.allowedValues.some((allowed) => allowed.value === defaultValue), ["defaultValue"])), z.transform(({ cardinality: _cardinality, ...definition }) => definition)),
 };
 /** Full-union schema: single source for the editor vocabulary and the exported types, independent of the flag. */
 const parameterSchema = z.strictObject({
@@ -56,25 +74,26 @@ const parameterSchema = z.strictObject({
     tags: z.optional(z.array(z.string())),
     definition: z.discriminatedUnion("type", [definitionSchemas.NUMBER, definitionSchemas.STRING]),
 });
-/** Parent key → allowed child keys for the schema restricted to `enabledTypes`; powers YAML editor autocompletion. */
-export function parameterSchemaKeys(enabledTypes) {
-    return deriveSchemaKeys(buildParameterSchema(enabledTypes));
+function rule(code, predicate, path) {
+    return z.refine(predicate, { message: code, path });
 }
-/** 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]),
-    });
+function allUnique(items) {
+    return new Set(items).size === items.length;
 }
-/** Map of parent key → allowed child keys. */
-function deriveSchemaKeys(schema, parentKey = "", result = {}) {
+/** Map of parent key → child-key entry; an array-of-objects child is recorded as a `sequence` entry. */
+function deriveSchemaKeys(schema, parentKey = "", kind = "mapping", result = {}) {
     for (const object of objectSchemasOf(schema)) {
         const { shape } = object._zod.def;
-        result[parentKey] = union(result[parentKey], Object.keys(shape));
+        result[parentKey] = { kind, keys: union(result[parentKey]?.keys, Object.keys(shape)) };
         for (const [key, child] of Object.entries(shape)) {
-            deriveSchemaKeys(unwrap(child), key, result);
+            const inner = unwrap(child);
+            if (inner._zod.def.type === "array") {
+                const element = unwrap(inner._zod.def.element);
+                deriveSchemaKeys(element, key, "sequence", result);
+            }
+            else {
+                deriveSchemaKeys(inner, key, "mapping", result);
+            }
         }
     }
     return result;
@@ -95,5 +114,8 @@ function unwrap(schema) {
     if (type === "optional" || type === "default") {
         return unwrap(schema._zod.def.innerType);
     }
+    if (type === "pipe") {
+        return unwrap(schema._zod.def.in);
+    }
     return schema;
 }

package/esm/parameter/parameterValidation.d.ts

@@ -1,5 +1,5 @@
 import type { ParameterType } from "@gooddata/sdk-model";
-import { type ParameterSchema } from "./parameterSchema.js";
+import { type ParameterSchema, type SchemaErrorCode } from "./parameterSchema.js";
 export type ParameterValidationResult = {
     isValid: true;
     parameter: ParameterSchema;
@@ -8,7 +8,7 @@ export type ParameterValidationResult = {
     errorCode: ParameterValidationErrorCode;
     type?: ParameterType;
 };
-export type ParameterValidationErrorCode = "empty" | "syntax" | "invalidStructure" | "idImmutable" | "unsupportedType" | "invalidDefaultValue" | "invalidConstraints" | "invalidConstraintRange" | "invalidTags";
+export type ParameterValidationErrorCode = "empty" | "syntax" | "invalidStructure" | "idImmutable" | "unsupportedType" | "invalidDefaultValue" | "invalidConstraints" | "invalidTags" | SchemaErrorCode;
 type ValidateParameterYamlOptions = {
     enabledTypes: ParameterType[];
     fixedIdentifier?: string;

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

@@ -1 +1 @@
-{"version":3,"file":"parameterValidation.d.ts","sourceRoot":"","sources":["../../src/parameter/parameterValidation.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAIzD,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,CAY3B"}
+{"version":3,"file":"parameterValidation.d.ts","sourceRoot":"","sources":["../../src/parameter/parameterValidation.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAIzD,OAAO,EACH,KAAK,eAAe,EACpB,KAAK,eAAe,EAGvB,MAAM,sBAAsB,CAAC;AAE9B,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,aAAa,GACb,eAAe,CAAC;AAEtB,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,CAY3B"}

package/esm/parameter/parameterValidation.js

@@ -1,6 +1,6 @@
 // (C) 2026 GoodData Corporation
 import { validateYaml } from "../asCode/validateYaml.js";
-import { buildParameterSchema } from "./parameterSchema.js";
+import { buildParameterSchema, schemaErrorCodes, } from "./parameterSchema.js";
 export function validateParameterYaml(value, options) {
     const result = validateYaml(value, {
         schema: buildParameterSchema(options.enabledTypes),
@@ -16,10 +16,8 @@ export function validateParameterYaml(value, options) {
 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", declaredType);
-            }
+        if (isSchemaErrorCode(issue.message)) {
+            return invalid(issue.message, declaredType);
         }
         if (path === "definition.type") {
             return invalid("unsupportedType");
@@ -36,6 +34,10 @@ function classifySchemaError(error, declaredType) {
     }
     return invalid("invalidStructure");
 }
+const schemaErrorCodeSet = new Set(schemaErrorCodes);
+function isSchemaErrorCode(message) {
+    return schemaErrorCodeSet.has(message);
+}
 function readDeclaredType(parsed) {
     if (!parsed || typeof parsed !== "object") {
         return undefined;

package/package.json

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