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

package/esm/parameter/parameterCompletions.js

@@ -1,4 +1,5 @@
 // (C) 2026 GoodData Corporation
+import { snippetCompletion, } from "@codemirror/autocomplete";
 import { parameterSchemaKeys } from "./parameterSchema.js";
 /**
  * Creates a CodeMirror completion source that suggests allowed YAML property
@@ -10,8 +11,8 @@ import { parameterSchemaKeys } from "./parameterSchema.js";
  * always offer every enabled type.
  */
 export function createParameterCompletions(enabledTypes) {
-    const keyOptionsByType = new Map(enabledTypes.map((type) => [type, toOptions(parameterSchemaKeys([type]))]));
-    const fallbackKeyOptions = toOptions(parameterSchemaKeys(enabledTypes));
+    const vocabularyByType = new Map(enabledTypes.map((type) => [type, toVocabulary(parameterSchemaKeys([type]))]));
+    const fallbackVocabulary = toVocabulary(parameterSchemaKeys(enabledTypes));
     const typeValueOptions = {
         "": [{ label: "parameter", type: "constant" }],
         definition: enabledTypes.map((label) => ({ label, type: "constant" })),
@@ -19,45 +20,63 @@ export function createParameterCompletions(enabledTypes) {
     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
+        // Trigger on a key name at the start of a line, on a key inside a sequence item, or on the
+        // value of a `type:` key; the three patterns are mutually exclusive.
         const keyMatch = before.match(/^(\s*)(\w*)$/);
-        const typeMatch = keyMatch ? null : before.match(/^(\s*)type:\s+(\w*)$/);
-        const match = keyMatch ?? typeMatch;
+        const itemMatch = before.match(/^(\s*)-\s+(\w*)$/);
+        const typeMatch = before.match(/^(\s*)type:\s+(\w*)$/);
+        const match = keyMatch ?? itemMatch ?? 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) {
+        const from = context.pos - word.length;
+        const parent = getParentKey(context.state.doc, line.number, indent);
+        if (parent === null) {
             return null;
         }
+        if (typeMatch) {
+            const options = typeValueOptions[parent.key];
+            return options ? { from, options } : null;
+        }
         const declaredType = getDeclaredType(context.state.doc);
-        const keyOptions = (declaredType ? keyOptionsByType.get(declaredType) : undefined) ?? fallbackKeyOptions;
-        const options = (keyMatch ? keyOptions : typeValueOptions)[parentKey];
-        if (!options) {
+        const vocabulary = (declaredType ? vocabularyByType.get(declaredType) : undefined) ?? fallbackVocabulary;
+        const entry = vocabulary[parent.key];
+        // A sequence's keys are valid only inside a `- ` item; a mapping's keys only outside one.
+        const inItem = itemMatch !== null || parent.inItem;
+        if (!entry || (entry.kind === "sequence") !== inItem) {
             return null;
         }
-        return { from: context.pos - word.length, options };
+        return { from, options: entry.options };
     };
 }
-function toOptions(keyMap) {
-    return Object.fromEntries(Object.entries(keyMap).map(([parent, keys]) => [
+function toVocabulary(schemaKeys) {
+    return Object.fromEntries(Object.entries(schemaKeys).map(([parent, { kind, keys }]) => [
         parent,
-        keys.map((label) => ({ label, type: "property" })),
+        { kind, options: keys.map((key) => toKeyOption(key, schemaKeys)) },
     ]));
 }
+function toKeyOption(label, schemaKeys) {
+    const child = schemaKeys[label];
+    if (child?.kind === "sequence") {
+        return snippetCompletion(`${label}:\n\t- ${child.keys[0]}: \${}`, { label, type: "property" });
+    }
+    return { label, type: "property" };
+}
 /**
- * The key whose block mapping a new entry at column `indent` would join: the nearest less-indented
- * `key:` line above. Returns `""` only for the top-level mapping (`indent === 0`), and `null` when the
+ * The key whose block a new entry at column `indent` would join: the nearest less-indented `key:` line
+ * above. `key` is `""` only for the top-level mapping (`indent === 0`); the result is `null` when the
  * enclosing line is not a mapping key or an indented line has no less-indented ancestor above it (an
- * orphaned line, which is not top-level). Derived purely from indentation, not from a parsed syntax
- * tree, so it also resolves the parent on a blank indented line; the flip side is that it does not
- * understand block scalars (`|`, `>`), whose literal content is scanned as if it were mapping keys.
+ * orphaned line, which is not top-level). When the nearest ancestor is a sequence item, it resolves
+ * to the key owning that sequence with `inItem` set, so continuation lines inside an item
+ * report the list's key (e.g. `allowedValues`). Derived purely from indentation, not from a parsed
+ * syntax tree, so it also resolves the parent on a blank indented line; the flip side is that it does
+ * not understand block scalars (`|`, `>`), whose literal content is scanned as if it were mapping keys.
  */
 function getParentKey(doc, lineNumber, indent) {
     if (indent === 0) {
-        return "";
+        return { key: "", inItem: false };
     }
     for (let number = lineNumber - 1; number >= 1; number--) {
         const text = doc.line(number).text;
@@ -66,7 +85,12 @@ function getParentKey(doc, lineNumber, indent) {
         if (content === "" || content.startsWith("#") || text.length - content.length >= indent) {
             continue;
         }
-        return content.match(/^([\w-]+):/)?.[1] ?? null;
+        if (content === "-" || content.startsWith("- ")) {
+            const parent = getParentKey(doc, number, text.length - content.length);
+            return parent && { key: parent.key, inItem: true };
+        }
+        const key = content.match(/^([\w-]+):/)?.[1];
+        return key === undefined ? null : { key, inItem: false };
     }
     // Indented with no less-indented ancestor: an orphaned line, not top-level.
     return null;
@@ -79,8 +103,11 @@ function getParentKey(doc, lineNumber, indent) {
 function getDeclaredType(doc) {
     for (let number = 1; number <= doc.lines; number++) {
         const match = doc.line(number).text.match(/^(\s+)type:\s*(\w+)/);
-        if (match && getParentKey(doc, number, match[1].length) === "definition") {
-            return match[2];
+        if (match) {
+            const parent = getParentKey(doc, number, match[1].length);
+            if (parent?.key === "definition" && !parent.inItem) {
+                return match[2];
+            }
         }
     }
     return undefined;

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

@@ -1 +1 @@
-{"version":3,"file":"parameterDescriptor.d.ts","sourceRoot":"","sources":["../../src/parameter/parameterDescriptor.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,qBAAqB,CAAC;AAQ9E,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAwErE;;GAEG;AACH,eAAO,MAAM,mBAAmB,gHAiC9B,CAAC"}
+{"version":3,"file":"parameterDescriptor.d.ts","sourceRoot":"","sources":["../../src/parameter/parameterDescriptor.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,qBAAqB,CAAC;AAQ9E,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAoFrE;;GAEG;AACH,eAAO,MAAM,mBAAmB,gHAiC9B,CAAC"}

package/esm/parameter/parameterDescriptor.js

@@ -36,6 +36,14 @@ const errorMessages = defineMessages({
     invalidDefaultValue: { id: "analyticsCatalog.parameter.validation.invalidDefaultValue" },
     invalidConstraints: { id: "analyticsCatalog.parameter.validation.invalidConstraints" },
     invalidConstraintRange: { id: "analyticsCatalog.parameter.validation.invalidConstraintRange" },
+    invalidAllowedValue: { id: "analyticsCatalog.parameter.validation.invalidAllowedValue" },
+    invalidAllowedValueTitle: { id: "analyticsCatalog.parameter.validation.invalidAllowedValueTitle" },
+    duplicateAllowedValues: { id: "analyticsCatalog.parameter.validation.duplicateAllowedValues" },
+    emptyAllowedValues: { id: "analyticsCatalog.parameter.validation.emptyAllowedValues" },
+    constraintsAllowedValuesExclusive: {
+        id: "analyticsCatalog.parameter.validation.constraintsAllowedValuesExclusive",
+    },
+    unsupportedCardinality: { id: "analyticsCatalog.parameter.validation.unsupportedCardinality" },
     invalidTags: { id: "analyticsCatalog.parameter.validation.invalidTags" },
 });
 function useParameterEditing() {
@@ -45,8 +53,12 @@ function useParameterEditing() {
     return useMemo(() => ({
         completionSource,
         syntaxErrorMessage: intl.formatMessage(errorMessages.syntax),
-        // Parameter YAML round-trips 1:1 to its definition, so serialization is a plain stringify.
-        serialize: (definition) => serializeParameterToYaml(definition),
+        // Parameter YAML round-trips 1:1 to its definition, so serialization is a plain stringify and
+        // every definition has a code form.
+        serialize: (definition) => ({
+            yaml: serializeParameterToYaml(definition),
+            hasCodeForm: true,
+        }),
         validate: (value, context) => {
             const result = validateParameterYaml(value, {
                 enabledTypes,

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/esm/sdk-ui-catalog.d.ts

@@ -1,5 +1,4 @@
 import type { CertificationStatus } from '@gooddata/sdk-model';
-import type { CompletionSource } from '@codemirror/autocomplete';
 import type { IAnalyticalBackend } from '@gooddata/sdk-backend-spi';
 import type { IDataSetMetadataObject } from '@gooddata/sdk-model';
 import type { IdentifierRef } from '@gooddata/sdk-model';
@@ -11,6 +10,7 @@ import { MouseEvent as MouseEvent_2 } from 'react';
 import type { ObjectType as ObjectType_2 } from '@gooddata/sdk-model';
 import { PropsWithChildren } from 'react';
 import { ReactNode } from 'react';
+import type { YamlCompletionSource } from '@gooddata/sdk-ui-kit';
 
 /**
  * @public
@@ -35,6 +35,16 @@ export declare function AnalyticsCatalogDetailContent({ backend, workspace, loca
  */
 export declare function AnalyticsCatalogFilter<T>(props: IAnalyticsCatalogFilterProps<T>): JSX.Element;
 
+/** @internal */
+export declare type AsCodeSerialization = {
+    yaml: string;
+    /**
+     * False for a definition with no code form at all, so no edit of it can be saved — as opposed to a
+     * document the codec's own rules reject, which the author can act on.
+     */
+    hasCodeForm: boolean;
+};
+
 /** @internal */
 export declare type AsCodeValidation<TDef> = {
     isValid: true;
@@ -221,9 +231,10 @@ export declare interface IAnalyticsCatalogProps {
 
 /** @internal */
 export declare interface IAsCodeEditing<TDef> {
-    completionSource: CompletionSource;
+    completionSource: YamlCompletionSource;
     syntaxErrorMessage: string;
-    serialize(definition: TDef): string;
+    /** A throw is a failure to load the object, not a document error: the dialog closes. */
+    serialize(definition: TDef): AsCodeSerialization;
     validate(value: string, context: AsCodeValidationContext): AsCodeValidation<TDef>;
     /** Re-adds content the YAML can't express; applied on every persisting path. Omit if lossless. */
     reconcile?(base: TDef, edited: TDef): TDef;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gooddata/sdk-ui-catalog",
-  "version": "11.51.0-alpha.3",
+  "version": "11.51.0-alpha.5",
   "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.3",
-    "@gooddata/sdk-code-schemas": "11.51.0-alpha.3",
-    "@gooddata/sdk-model": "11.51.0-alpha.3",
-    "@gooddata/sdk-ui": "11.51.0-alpha.3",
-    "@gooddata/sdk-ui-kit": "11.51.0-alpha.3",
-    "@gooddata/sdk-ui-ext": "11.51.0-alpha.3",
-    "@gooddata/sdk-ui-semantic-search": "11.51.0-alpha.3",
-    "@gooddata/sdk-ui-theme-provider": "11.51.0-alpha.3",
-    "@gooddata/util": "11.51.0-alpha.3"
+    "@gooddata/sdk-backend-spi": "11.51.0-alpha.5",
+    "@gooddata/sdk-code-schemas": "11.51.0-alpha.5",
+    "@gooddata/sdk-model": "11.51.0-alpha.5",
+    "@gooddata/sdk-ui-ext": "11.51.0-alpha.5",
+    "@gooddata/sdk-ui": "11.51.0-alpha.5",
+    "@gooddata/sdk-ui-kit": "11.51.0-alpha.5",
+    "@gooddata/sdk-ui-semantic-search": "11.51.0-alpha.5",
+    "@gooddata/sdk-ui-theme-provider": "11.51.0-alpha.5",
+    "@gooddata/util": "11.51.0-alpha.5"
   },
   "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/i18n-toolkit": "11.51.0-alpha.3",
-    "@gooddata/eslint-config": "11.51.0-alpha.3",
-    "@gooddata/oxlint-config": "11.51.0-alpha.3",
-    "@gooddata/stylelint-config": "11.51.0-alpha.3",
-    "@gooddata/sdk-backend-mockingbird": "11.51.0-alpha.3"
+    "@gooddata/i18n-toolkit": "11.51.0-alpha.5",
+    "@gooddata/eslint-config": "11.51.0-alpha.5",
+    "@gooddata/oxlint-config": "11.51.0-alpha.5",
+    "@gooddata/sdk-backend-mockingbird": "11.51.0-alpha.5",
+    "@gooddata/stylelint-config": "11.51.0-alpha.5"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0",

package/styles/css/codeDialog.css

@@ -97,6 +97,16 @@
   font-weight: 700;
 }
 
+.gd-ascode-dialog-notice {
+  background-color: var(--gd-palette-warning-dimmed, #fce7cc);
+  color: var(--gd-palette-warning-text-dimmed, #685945);
+  font-size: 14px;
+  line-height: 20px;
+  padding: 4px 10px;
+  margin: 0 20px 10px;
+  border-radius: 3px;
+}
+
 .gd-ascode-dialog-footer-left {
   display: flex;
   align-items: center;

package/styles/css/codeDialog.css.map

@@ -1 +1 @@
-{"version":3,"sourceRoot":"","sources":["../scss/codeDialog.scss","../../node_modules/@gooddata/sdk-ui-kit/styles/scss/variables.scss"],"names":[],"mappings":"AAIA;EACI;EACA;EACA;EACA;EACA;;AAGA;EACI;EACA;;AAGJ;EACI;;AAGJ;EACI;EACA;EACA;;AAGJ;EACI;EACA;EACA;EACA;EACA;;;AAIR;EACI;EACA;EACA;EACA;EACA;;;AAGJ;EACI;EACA;EACA;EACA;EACA;;;AAGJ;EACI;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;AAGJ;EACI;EACA;EACA;;AAEA;EACI;EACA;EACA;EACA;;AAEA;EACI;EACA;EACA;EACA;EACA;;AAEA;EACI,cCpCU;;ADwClB;EACI;;AAGJ;EACI;EACA;EACA;EACA;;;AAKZ;EACI;EACA;EACA;EACA;EACA;EACA;EACA;;AAEA;EACI;;;AAIR;EACI;EACA;EACA;EACA;EACA;EACA","file":"codeDialog.css"}
+{"version":3,"sourceRoot":"","sources":["../scss/codeDialog.scss","../../node_modules/@gooddata/sdk-ui-kit/styles/scss/variables.scss"],"names":[],"mappings":"AAIA;EACI;EACA;EACA;EACA;EACA;;AAGA;EACI;EACA;;AAGJ;EACI;;AAGJ;EACI;EACA;EACA;;AAGJ;EACI;EACA;EACA;EACA;EACA;;;AAIR;EACI;EACA;EACA;EACA;EACA;;;AAGJ;EACI;EACA;EACA;EACA;EACA;;;AAGJ;EACI;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;AAGJ;EACI;EACA;EACA;;AAEA;EACI;EACA;EACA;EACA;;AAEA;EACI;EACA;EACA;EACA;EACA;;AAEA;EACI,cCpCU;;ADwClB;EACI;;AAGJ;EACI;EACA;EACA;EACA;;;AAKZ;EACI;EACA;EACA;EACA;EACA;EACA;EACA;;AAEA;EACI;;;AAIR;EAEI;EACA;EACA;EACA;EACA;EACA;EACA;;;AAGJ;EACI;EACA;EACA;EACA;EACA;EACA","file":"codeDialog.css"}

package/styles/css/detail.css

@@ -113,6 +113,16 @@
   font-weight: 700;
 }
 
+.gd-ascode-dialog-notice {
+  background-color: var(--gd-palette-warning-dimmed, #fce7cc);
+  color: var(--gd-palette-warning-text-dimmed, #685945);
+  font-size: 14px;
+  line-height: 20px;
+  padding: 4px 10px;
+  margin: 0 20px 10px;
+  border-radius: 3px;
+}
+
 .gd-ascode-dialog-footer-left {
   display: flex;
   align-items: center;

package/styles/css/detail.css.map

@@ -1 +1 @@
-{"version":3,"sourceRoot":"","sources":["../scss/objectType.scss","../scss/codeDialog.scss","../../node_modules/@gooddata/sdk-ui-kit/styles/scss/variables.scss","../scss/detail.scss"],"names":[],"mappings":"AAKI;EAEI;;AAGJ;EACI;;AAGJ;EACI;;AAGJ;EAEI;;AAGJ;EACI;;;ACpBR;EACI;EACA;EACA;EACA;EACA;;AAGA;EACI;EACA;;AAGJ;EACI;;AAGJ;EACI;EACA;EACA;;AAGJ;EACI;EACA;EACA;EACA;EACA;;;AAIR;EACI;EACA;EACA;EACA;EACA;;;AAGJ;EACI;EACA;EACA;EACA;EACA;;;AAGJ;EACI;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;AAGJ;EACI;EACA;EACA;;AAEA;EACI;EACA;EACA;EACA;;AAEA;EACI;EACA;EACA;EACA;EACA;;AAEA;EACI,cCpCU;;ADwClB;EACI;;AAGJ;EACI;EACA;EACA;EACA;;;AAKZ;EACI;EACA;EACA;EACA;EACA;EACA;EACA;;AAEA;EACI;;;AAIR;EACI;EACA;EACA;EACA;EACA;EACA;;;AE1GJ;EACI,aDwFc;ECvFd,WAJgB;EAKhB,OAVI;EAWJ;;AAEA;EANJ;IAOQ;;;AAGJ;EAEI;EACA;;AAGJ;EACI;EACA;EACA;;AAEA;EACI;;AAIR;EACI;EACA;EACA;;AAGA;EACI;EACA;EACA;;AAIJ;EACI;EACA;;AAEA;EACI;EACA;EACA;EACA;;AAIR;EACI;EACA;EACA;EACA;EACA;;AAEA;EACI;EACA;EACA;EACA;EACA,ODzCA;EC0CA,WAtEE;EAuEF,aAtES;EAuET;EACA;;AAEA;EACI;;AAOJ;EACI;EACA;EACA;EACA;EACA;;AAGJ;EAGI;EACA;EACA;EACA;;AAGJ;EACI;EACA;EACA;;AAGJ;EACI;EACA;EACA;EACA;EACA;;AAGJ;EAGI;;AAGJ;EACI,ODpGG;;ACuGP;EACI;EACA,ODtGJ;ECuGI;EACA;;AAGJ;EAEI;;AAGJ;EACI;;AAIR;EACI;;AAEA;EACI,ODzHJ;EC0HI,aA/IQ;EAgJR,WAjJC;EAkJD;EACA;EACA;;AAGJ;EACI,OD9HJ;EC+HI,WAvJA;EAwJA;EACA;EACA;EACA;EACA;;AAGJ;EACI,OD/IG;;ACkJP;EACI;EACA,ODjJJ;;ACqJJ;EACI;;AAEA;EACI;;AAKZ;EACI;EACA;;AAIR;EACI;EACA;EACA;;AAEA;EACI;;AAKR;EACI;EACA;EACA;;AAGJ;EACI;EACA;EACA;EACA;EACA;;AAEA;AAAA;EAEI;EACA;EACA;EACA;EACA;EACA;;AAGJ;EACI;;AAMR;EACI;EACA;EACA;EACA;EACA;EACA;EACA;;AAEA;EACI;;AAGJ;EACI;;AAIR;EACI;EACA;EACA;EACA;;AAEA;EACI;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;AAGJ;EACI;EACA;EACA;EACA;EACA;EACA;EACA;;AAGJ;EACI;EACA;;AAEA;EACI;;AAKZ;EACI;EACA;EACA;EACA;EACA;;AAEA;EACI;EACA;EACA;;AAIR;EACI;EACA;EACA;EACA,ODtRQ;ECuRR;EACA;EACA;EACA;;AAEA;EACI;EACA;;AAKJ;EACI;;AAGJ;EACI;EACA;;AAKJ;EACI;EACA;;AAGJ;EACI,ODvTW;;AC0Tf;EACI;EACA,ODzTI;;AC6TZ;EACI,OD1TQ;EC2TR;EACA;EACA;EACA;;AAGJ;EACI;EACA;;AAEA;EACI,OD7UW;EC8UX;EACA;EACA;EACA;;AAIR;EACI;EACA;EACA;EACA;;AAEA;EACI;EACA;EACA;EACA;EACA;EACA;;AAEJ;EACI;EACA;;AAEJ;EACI;EACA;EACA;EACA;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;AAEA;EACI;EACA;EACA;;AAIR;EACI,MDnZS;;ACqZb;AAAA;EAEI,MDtZQ;;ACwZZ;AAAA;EAEI,MDxZO;;AC0ZX;EACI;;AAEJ;EACI;;AAGJ;EACI,QDjZW;;;ACuZnB;EACI;EACA;EACA;EACA;EACA;EACA;EACA,kBDpaS;ECqaT;EACA;;AAEA;EACI;;AAGJ;EACI;EACA;;AAGJ;EACI;;AAGJ;EACI;EACA;EACA;EACA;;AAGJ;EACI;EACA;EACA;EACA;;AAGI;EACI;EACA;;AAIR;EACI;;AAGJ;EACI;;AAIR;EACI;EACA;EACA,kBDrdK;ECsdL;EACA;EACA,OD3cI;;AC6cJ;EACI;EACA;EACA;;AAGJ;EACI;;AAGJ;EACI;EACA;;AAGJ;EACI","file":"detail.css"}
+{"version":3,"sourceRoot":"","sources":["../scss/objectType.scss","../scss/codeDialog.scss","../../node_modules/@gooddata/sdk-ui-kit/styles/scss/variables.scss","../scss/detail.scss"],"names":[],"mappings":"AAKI;EAEI;;AAGJ;EACI;;AAGJ;EACI;;AAGJ;EAEI;;AAGJ;EACI;;;ACpBR;EACI;EACA;EACA;EACA;EACA;;AAGA;EACI;EACA;;AAGJ;EACI;;AAGJ;EACI;EACA;EACA;;AAGJ;EACI;EACA;EACA;EACA;EACA;;;AAIR;EACI;EACA;EACA;EACA;EACA;;;AAGJ;EACI;EACA;EACA;EACA;EACA;;;AAGJ;EACI;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;AAGJ;EACI;EACA;EACA;;AAEA;EACI;EACA;EACA;EACA;;AAEA;EACI;EACA;EACA;EACA;EACA;;AAEA;EACI,cCpCU;;ADwClB;EACI;;AAGJ;EACI;EACA;EACA;EACA;;;AAKZ;EACI;EACA;EACA;EACA;EACA;EACA;EACA;;AAEA;EACI;;;AAIR;EAEI;EACA;EACA;EACA;EACA;EACA;EACA;;;AAGJ;EACI;EACA;EACA;EACA;EACA;EACA;;;AErHJ;EACI,aDwFc;ECvFd,WAJgB;EAKhB,OAVI;EAWJ;;AAEA;EANJ;IAOQ;;;AAGJ;EAEI;EACA;;AAGJ;EACI;EACA;EACA;;AAEA;EACI;;AAIR;EACI;EACA;EACA;;AAGA;EACI;EACA;EACA;;AAIJ;EACI;EACA;;AAEA;EACI;EACA;EACA;EACA;;AAIR;EACI;EACA;EACA;EACA;EACA;;AAEA;EACI;EACA;EACA;EACA;EACA,ODzCA;EC0CA,WAtEE;EAuEF,aAtES;EAuET;EACA;;AAEA;EACI;;AAOJ;EACI;EACA;EACA;EACA;EACA;;AAGJ;EAGI;EACA;EACA;EACA;;AAGJ;EACI;EACA;EACA;;AAGJ;EACI;EACA;EACA;EACA;EACA;;AAGJ;EAGI;;AAGJ;EACI,ODpGG;;ACuGP;EACI;EACA,ODtGJ;ECuGI;EACA;;AAGJ;EAEI;;AAGJ;EACI;;AAIR;EACI;;AAEA;EACI,ODzHJ;EC0HI,aA/IQ;EAgJR,WAjJC;EAkJD;EACA;EACA;;AAGJ;EACI,OD9HJ;EC+HI,WAvJA;EAwJA;EACA;EACA;EACA;EACA;;AAGJ;EACI,OD/IG;;ACkJP;EACI;EACA,ODjJJ;;ACqJJ;EACI;;AAEA;EACI;;AAKZ;EACI;EACA;;AAIR;EACI;EACA;EACA;;AAEA;EACI;;AAKR;EACI;EACA;EACA;;AAGJ;EACI;EACA;EACA;EACA;EACA;;AAEA;AAAA;EAEI;EACA;EACA;EACA;EACA;EACA;;AAGJ;EACI;;AAMR;EACI;EACA;EACA;EACA;EACA;EACA;EACA;;AAEA;EACI;;AAGJ;EACI;;AAIR;EACI;EACA;EACA;EACA;;AAEA;EACI;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;AAGJ;EACI;EACA;EACA;EACA;EACA;EACA;EACA;;AAGJ;EACI;EACA;;AAEA;EACI;;AAKZ;EACI;EACA;EACA;EACA;EACA;;AAEA;EACI;EACA;EACA;;AAIR;EACI;EACA;EACA;EACA,ODtRQ;ECuRR;EACA;EACA;EACA;;AAEA;EACI;EACA;;AAKJ;EACI;;AAGJ;EACI;EACA;;AAKJ;EACI;EACA;;AAGJ;EACI,ODvTW;;AC0Tf;EACI;EACA,ODzTI;;AC6TZ;EACI,OD1TQ;EC2TR;EACA;EACA;EACA;;AAGJ;EACI;EACA;;AAEA;EACI,OD7UW;EC8UX;EACA;EACA;EACA;;AAIR;EACI;EACA;EACA;EACA;;AAEA;EACI;EACA;EACA;EACA;EACA;EACA;;AAEJ;EACI;EACA;;AAEJ;EACI;EACA;EACA;EACA;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;AAEA;EACI;EACA;EACA;;AAIR;EACI,MDnZS;;ACqZb;AAAA;EAEI,MDtZQ;;ACwZZ;AAAA;EAEI,MDxZO;;AC0ZX;EACI;;AAEJ;EACI;;AAGJ;EACI,QDjZW;;;ACuZnB;EACI;EACA;EACA;EACA;EACA;EACA;EACA,kBDpaS;ECqaT;EACA;;AAEA;EACI;;AAGJ;EACI;EACA;;AAGJ;EACI;;AAGJ;EACI;EACA;EACA;EACA;;AAGJ;EACI;EACA;EACA;EACA;;AAGI;EACI;EACA;;AAIR;EACI;;AAGJ;EACI;;AAIR;EACI;EACA;EACA,kBDrdK;ECsdL;EACA;EACA,OD3cI;;AC6cJ;EACI;EACA;EACA;;AAGJ;EACI;;AAGJ;EACI;EACA;;AAGJ;EACI","file":"detail.css"}

package/styles/css/main.css

@@ -429,6 +429,16 @@
   font-weight: 700;
 }
 
+.gd-ascode-dialog-notice {
+  background-color: var(--gd-palette-warning-dimmed, #fce7cc);
+  color: var(--gd-palette-warning-text-dimmed, #685945);
+  font-size: 14px;
+  line-height: 20px;
+  padding: 4px 10px;
+  margin: 0 20px 10px;
+  border-radius: 3px;
+}
+
 .gd-ascode-dialog-footer-left {
   display: flex;
   align-items: center;