@gooddata/sdk-code-schemas 11.43.0-alpha.2 → 11.43.0-alpha.4

package/esm/sdk-code-schemas.d.ts

@@ -4939,6 +4939,121 @@ export declare const metadata_v1: {
                             type: string;
                         };
                     };
+                    conditional_formatting: {
+                        type: string;
+                        description: string;
+                        additionalProperties: boolean;
+                        properties: {
+                            version: {
+                                type: string;
+                                description: string;
+                            };
+                            enabled: {
+                                type: string;
+                                description: string;
+                            };
+                            rules: {
+                                type: string;
+                                description: string;
+                                items: {
+                                    type: string;
+                                    additionalProperties: boolean;
+                                    required: string[];
+                                    properties: {
+                                        id: {
+                                            type: string;
+                                            description: string;
+                                        };
+                                        target: {
+                                            type: string;
+                                            description: string;
+                                            oneOf: ({
+                                                type: string;
+                                                additionalProperties: boolean;
+                                                required: string[];
+                                                properties: {
+                                                    measure: {
+                                                        type: string;
+                                                        description: string;
+                                                    };
+                                                    attribute?: undefined;
+                                                };
+                                            } | {
+                                                type: string;
+                                                additionalProperties: boolean;
+                                                required: string[];
+                                                properties: {
+                                                    measure?: undefined;
+                                                    attribute: {
+                                                        type: string;
+                                                        description: string;
+                                                    };
+                                                };
+                                            })[];
+                                        };
+                                        conditions: {
+                                            type: string;
+                                            description: string;
+                                            items: {
+                                                type: string;
+                                                additionalProperties: boolean;
+                                                required: string[];
+                                                properties: {
+                                                    id: {
+                                                        type: string;
+                                                    };
+                                                    operator: {
+                                                        type: string;
+                                                        enum: string[];
+                                                    };
+                                                    value: {
+                                                        description: string;
+                                                        oneOf: ({
+                                                            properties?: undefined;
+                                                            required?: undefined;
+                                                            additionalProperties?: undefined;
+                                                            type: string;
+                                                        } | {
+                                                            type: string;
+                                                            additionalProperties: boolean;
+                                                            required: string[];
+                                                            properties: {
+                                                                from: {
+                                                                    type: string;
+                                                                };
+                                                                to: {
+                                                                    type: string;
+                                                                };
+                                                            };
+                                                        })[];
+                                                    };
+                                                    format: {
+                                                        type: string;
+                                                        additionalProperties: boolean;
+                                                        required: string[];
+                                                        properties: {
+                                                            text: {
+                                                                type: string;
+                                                                description: string;
+                                                            };
+                                                            fill: {
+                                                                type: string;
+                                                                description: string;
+                                                            };
+                                                            scope: {
+                                                                type: string;
+                                                                enum: string[];
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
                 };
                 $defs: {};
             };
@@ -11581,6 +11696,67 @@ declare interface VisualisationConfig {
     enable_accessibility?: boolean;
     line_style_control_metrics?: string[];
     line_style_excluded_metrics?: string[];
+    /**
+     * Conditional formatting rules that color cells or rows based on their values.
+     */
+    conditional_formatting?: {
+        /**
+         * Conditional-formatting model version. "1" (default if omitted) — initial shape: discrete rules, one column per rule with stacked conditions. Readers must tolerate omission (treat as "1") and evolve under the same backward-compat contract as the dashboard model version, so server-side consumers (e.g. XLSX export) stay forward-compatible.
+         */
+        version?: string;
+        /**
+         * Master toggle for all conditional formatting rules.
+         */
+        enabled?: boolean;
+        /**
+         * Ordered list of rules; the first matching rule wins.
+         */
+        rules?: {
+            /**
+             * Stable, table-unique rule id.
+             */
+            id: string;
+            /**
+             * The measure or attribute the rule targets — exactly one of measure/attribute.
+             */
+            target: {
+                /**
+                 * Local identifier of the targeted measure.
+                 */
+                measure: string;
+            } | {
+                /**
+                 * Local identifier of the targeted attribute.
+                 */
+                attribute: string;
+            };
+            /**
+             * Stacked conditions; the first matching condition wins.
+             */
+            conditions: {
+                id: string;
+                operator: "all" | "equal_to" | "not_equal_to" | "less_than" | "less_than_or_equal_to" | "greater_than" | "greater_than_or_equal_to" | "between" | "not_between" | "contains" | "not_contains" | "starts_with" | "not_starts_with" | "ends_with" | "not_ends_with" | "is_empty" | "is_not_empty";
+                /**
+                 * Literal (number or string); a \{from,to\} range for between/not_between; omitted for all/is_empty/is_not_empty.
+                 */
+                value?: number | string | {
+                    from: number;
+                    to: number;
+                };
+                format: {
+                    /**
+                     * Text color as hex (e.g. #FFFFFF).
+                     */
+                    text?: string;
+                    /**
+                     * Background color as hex (e.g. #E54D40).
+                     */
+                    fill?: string;
+                    scope: "cell" | "row";
+                };
+            }[];
+        }[];
+    };
     [k: string]: unknown;
 }
 
@@ -11755,6 +11931,67 @@ declare interface VisualisationConfig1 {
     enable_accessibility?: boolean;
     line_style_control_metrics?: string[];
     line_style_excluded_metrics?: string[];
+    /**
+     * Conditional formatting rules that color cells or rows based on their values.
+     */
+    conditional_formatting?: {
+        /**
+         * Conditional-formatting model version. "1" (default if omitted) — initial shape: discrete rules, one column per rule with stacked conditions. Readers must tolerate omission (treat as "1") and evolve under the same backward-compat contract as the dashboard model version, so server-side consumers (e.g. XLSX export) stay forward-compatible.
+         */
+        version?: string;
+        /**
+         * Master toggle for all conditional formatting rules.
+         */
+        enabled?: boolean;
+        /**
+         * Ordered list of rules; the first matching rule wins.
+         */
+        rules?: {
+            /**
+             * Stable, table-unique rule id.
+             */
+            id: string;
+            /**
+             * The measure or attribute the rule targets — exactly one of measure/attribute.
+             */
+            target: {
+                /**
+                 * Local identifier of the targeted measure.
+                 */
+                measure: string;
+            } | {
+                /**
+                 * Local identifier of the targeted attribute.
+                 */
+                attribute: string;
+            };
+            /**
+             * Stacked conditions; the first matching condition wins.
+             */
+            conditions: {
+                id: string;
+                operator: "all" | "equal_to" | "not_equal_to" | "less_than" | "less_than_or_equal_to" | "greater_than" | "greater_than_or_equal_to" | "between" | "not_between" | "contains" | "not_contains" | "starts_with" | "not_starts_with" | "ends_with" | "not_ends_with" | "is_empty" | "is_not_empty";
+                /**
+                 * Literal (number or string); a \{from,to\} range for between/not_between; omitted for all/is_empty/is_not_empty.
+                 */
+                value?: number | string | {
+                    from: number;
+                    to: number;
+                };
+                format: {
+                    /**
+                     * Text color as hex (e.g. #FFFFFF).
+                     */
+                    text?: string;
+                    /**
+                     * Background color as hex (e.g. #E54D40).
+                     */
+                    fill?: string;
+                    scope: "cell" | "row";
+                };
+            }[];
+        }[];
+    };
     [k: string]: unknown;
 }
 
@@ -11929,6 +12166,67 @@ declare interface VisualisationConfig10 {
     enable_accessibility?: boolean;
     line_style_control_metrics?: string[];
     line_style_excluded_metrics?: string[];
+    /**
+     * Conditional formatting rules that color cells or rows based on their values.
+     */
+    conditional_formatting?: {
+        /**
+         * Conditional-formatting model version. "1" (default if omitted) — initial shape: discrete rules, one column per rule with stacked conditions. Readers must tolerate omission (treat as "1") and evolve under the same backward-compat contract as the dashboard model version, so server-side consumers (e.g. XLSX export) stay forward-compatible.
+         */
+        version?: string;
+        /**
+         * Master toggle for all conditional formatting rules.
+         */
+        enabled?: boolean;
+        /**
+         * Ordered list of rules; the first matching rule wins.
+         */
+        rules?: {
+            /**
+             * Stable, table-unique rule id.
+             */
+            id: string;
+            /**
+             * The measure or attribute the rule targets — exactly one of measure/attribute.
+             */
+            target: {
+                /**
+                 * Local identifier of the targeted measure.
+                 */
+                measure: string;
+            } | {
+                /**
+                 * Local identifier of the targeted attribute.
+                 */
+                attribute: string;
+            };
+            /**
+             * Stacked conditions; the first matching condition wins.
+             */
+            conditions: {
+                id: string;
+                operator: "all" | "equal_to" | "not_equal_to" | "less_than" | "less_than_or_equal_to" | "greater_than" | "greater_than_or_equal_to" | "between" | "not_between" | "contains" | "not_contains" | "starts_with" | "not_starts_with" | "ends_with" | "not_ends_with" | "is_empty" | "is_not_empty";
+                /**
+                 * Literal (number or string); a \{from,to\} range for between/not_between; omitted for all/is_empty/is_not_empty.
+                 */
+                value?: number | string | {
+                    from: number;
+                    to: number;
+                };
+                format: {
+                    /**
+                     * Text color as hex (e.g. #FFFFFF).
+                     */
+                    text?: string;
+                    /**
+                     * Background color as hex (e.g. #E54D40).
+                     */
+                    fill?: string;
+                    scope: "cell" | "row";
+                };
+            }[];
+        }[];
+    };
     [k: string]: unknown;
 }
 
@@ -12103,6 +12401,67 @@ declare interface VisualisationConfig11 {
     enable_accessibility?: boolean;
     line_style_control_metrics?: string[];
     line_style_excluded_metrics?: string[];
+    /**
+     * Conditional formatting rules that color cells or rows based on their values.
+     */
+    conditional_formatting?: {
+        /**
+         * Conditional-formatting model version. "1" (default if omitted) — initial shape: discrete rules, one column per rule with stacked conditions. Readers must tolerate omission (treat as "1") and evolve under the same backward-compat contract as the dashboard model version, so server-side consumers (e.g. XLSX export) stay forward-compatible.
+         */
+        version?: string;
+        /**
+         * Master toggle for all conditional formatting rules.
+         */
+        enabled?: boolean;
+        /**
+         * Ordered list of rules; the first matching rule wins.
+         */
+        rules?: {
+            /**
+             * Stable, table-unique rule id.
+             */
+            id: string;
+            /**
+             * The measure or attribute the rule targets — exactly one of measure/attribute.
+             */
+            target: {
+                /**
+                 * Local identifier of the targeted measure.
+                 */
+                measure: string;
+            } | {
+                /**
+                 * Local identifier of the targeted attribute.
+                 */
+                attribute: string;
+            };
+            /**
+             * Stacked conditions; the first matching condition wins.
+             */
+            conditions: {
+                id: string;
+                operator: "all" | "equal_to" | "not_equal_to" | "less_than" | "less_than_or_equal_to" | "greater_than" | "greater_than_or_equal_to" | "between" | "not_between" | "contains" | "not_contains" | "starts_with" | "not_starts_with" | "ends_with" | "not_ends_with" | "is_empty" | "is_not_empty";
+                /**
+                 * Literal (number or string); a \{from,to\} range for between/not_between; omitted for all/is_empty/is_not_empty.
+                 */
+                value?: number | string | {
+                    from: number;
+                    to: number;
+                };
+                format: {
+                    /**
+                     * Text color as hex (e.g. #FFFFFF).
+                     */
+                    text?: string;
+                    /**
+                     * Background color as hex (e.g. #E54D40).
+                     */
+                    fill?: string;
+                    scope: "cell" | "row";
+                };
+            }[];
+        }[];
+    };
     [k: string]: unknown;
 }
 
@@ -12277,6 +12636,67 @@ declare interface VisualisationConfig12 {
     enable_accessibility?: boolean;
     line_style_control_metrics?: string[];
     line_style_excluded_metrics?: string[];
+    /**
+     * Conditional formatting rules that color cells or rows based on their values.
+     */
+    conditional_formatting?: {
+        /**
+         * Conditional-formatting model version. "1" (default if omitted) — initial shape: discrete rules, one column per rule with stacked conditions. Readers must tolerate omission (treat as "1") and evolve under the same backward-compat contract as the dashboard model version, so server-side consumers (e.g. XLSX export) stay forward-compatible.
+         */
+        version?: string;
+        /**
+         * Master toggle for all conditional formatting rules.
+         */
+        enabled?: boolean;
+        /**
+         * Ordered list of rules; the first matching rule wins.
+         */
+        rules?: {
+            /**
+             * Stable, table-unique rule id.
+             */
+            id: string;
+            /**
+             * The measure or attribute the rule targets — exactly one of measure/attribute.
+             */
+            target: {
+                /**
+                 * Local identifier of the targeted measure.
+                 */
+                measure: string;
+            } | {
+                /**
+                 * Local identifier of the targeted attribute.
+                 */
+                attribute: string;
+            };
+            /**
+             * Stacked conditions; the first matching condition wins.
+             */
+            conditions: {
+                id: string;
+                operator: "all" | "equal_to" | "not_equal_to" | "less_than" | "less_than_or_equal_to" | "greater_than" | "greater_than_or_equal_to" | "between" | "not_between" | "contains" | "not_contains" | "starts_with" | "not_starts_with" | "ends_with" | "not_ends_with" | "is_empty" | "is_not_empty";
+                /**
+                 * Literal (number or string); a \{from,to\} range for between/not_between; omitted for all/is_empty/is_not_empty.
+                 */
+                value?: number | string | {
+                    from: number;
+                    to: number;
+                };
+                format: {
+                    /**
+                     * Text color as hex (e.g. #FFFFFF).
+                     */
+                    text?: string;
+                    /**
+                     * Background color as hex (e.g. #E54D40).
+                     */
+                    fill?: string;
+                    scope: "cell" | "row";
+                };
+            }[];
+        }[];
+    };
     [k: string]: unknown;
 }
 
@@ -12451,6 +12871,67 @@ declare interface VisualisationConfig13 {
     enable_accessibility?: boolean;
     line_style_control_metrics?: string[];
     line_style_excluded_metrics?: string[];
+    /**
+     * Conditional formatting rules that color cells or rows based on their values.
+     */
+    conditional_formatting?: {
+        /**
+         * Conditional-formatting model version. "1" (default if omitted) — initial shape: discrete rules, one column per rule with stacked conditions. Readers must tolerate omission (treat as "1") and evolve under the same backward-compat contract as the dashboard model version, so server-side consumers (e.g. XLSX export) stay forward-compatible.
+         */
+        version?: string;
+        /**
+         * Master toggle for all conditional formatting rules.
+         */
+        enabled?: boolean;
+        /**
+         * Ordered list of rules; the first matching rule wins.
+         */
+        rules?: {
+            /**
+             * Stable, table-unique rule id.
+             */
+            id: string;
+            /**
+             * The measure or attribute the rule targets — exactly one of measure/attribute.
+             */
+            target: {
+                /**
+                 * Local identifier of the targeted measure.
+                 */
+                measure: string;
+            } | {
+                /**
+                 * Local identifier of the targeted attribute.
+                 */
+                attribute: string;
+            };
+            /**
+             * Stacked conditions; the first matching condition wins.
+             */
+            conditions: {
+                id: string;
+                operator: "all" | "equal_to" | "not_equal_to" | "less_than" | "less_than_or_equal_to" | "greater_than" | "greater_than_or_equal_to" | "between" | "not_between" | "contains" | "not_contains" | "starts_with" | "not_starts_with" | "ends_with" | "not_ends_with" | "is_empty" | "is_not_empty";
+                /**
+                 * Literal (number or string); a \{from,to\} range for between/not_between; omitted for all/is_empty/is_not_empty.
+                 */
+                value?: number | string | {
+                    from: number;
+                    to: number;
+                };
+                format: {
+                    /**
+                     * Text color as hex (e.g. #FFFFFF).
+                     */
+                    text?: string;
+                    /**
+                     * Background color as hex (e.g. #E54D40).
+                     */
+                    fill?: string;
+                    scope: "cell" | "row";
+                };
+            }[];
+        }[];
+    };
     [k: string]: unknown;
 }
 
@@ -12625,6 +13106,67 @@ declare interface VisualisationConfig14 {
     enable_accessibility?: boolean;
     line_style_control_metrics?: string[];
     line_style_excluded_metrics?: string[];
+    /**
+     * Conditional formatting rules that color cells or rows based on their values.
+     */
+    conditional_formatting?: {
+        /**
+         * Conditional-formatting model version. "1" (default if omitted) — initial shape: discrete rules, one column per rule with stacked conditions. Readers must tolerate omission (treat as "1") and evolve under the same backward-compat contract as the dashboard model version, so server-side consumers (e.g. XLSX export) stay forward-compatible.
+         */
+        version?: string;
+        /**
+         * Master toggle for all conditional formatting rules.
+         */
+        enabled?: boolean;
+        /**
+         * Ordered list of rules; the first matching rule wins.
+         */
+        rules?: {
+            /**
+             * Stable, table-unique rule id.
+             */
+            id: string;
+            /**
+             * The measure or attribute the rule targets — exactly one of measure/attribute.
+             */
+            target: {
+                /**
+                 * Local identifier of the targeted measure.
+                 */
+                measure: string;
+            } | {
+                /**
+                 * Local identifier of the targeted attribute.
+                 */
+                attribute: string;
+            };
+            /**
+             * Stacked conditions; the first matching condition wins.
+             */
+            conditions: {
+                id: string;
+                operator: "all" | "equal_to" | "not_equal_to" | "less_than" | "less_than_or_equal_to" | "greater_than" | "greater_than_or_equal_to" | "between" | "not_between" | "contains" | "not_contains" | "starts_with" | "not_starts_with" | "ends_with" | "not_ends_with" | "is_empty" | "is_not_empty";
+                /**
+                 * Literal (number or string); a \{from,to\} range for between/not_between; omitted for all/is_empty/is_not_empty.
+                 */
+                value?: number | string | {
+                    from: number;
+                    to: number;
+                };
+                format: {
+                    /**
+                     * Text color as hex (e.g. #FFFFFF).
+                     */
+                    text?: string;
+                    /**
+                     * Background color as hex (e.g. #E54D40).
+                     */
+                    fill?: string;
+                    scope: "cell" | "row";
+                };
+            }[];
+        }[];
+    };
     [k: string]: unknown;
 }
 
@@ -12799,6 +13341,67 @@ declare interface VisualisationConfig15 {
     enable_accessibility?: boolean;
     line_style_control_metrics?: string[];
     line_style_excluded_metrics?: string[];
+    /**
+     * Conditional formatting rules that color cells or rows based on their values.
+     */
+    conditional_formatting?: {
+        /**
+         * Conditional-formatting model version. "1" (default if omitted) — initial shape: discrete rules, one column per rule with stacked conditions. Readers must tolerate omission (treat as "1") and evolve under the same backward-compat contract as the dashboard model version, so server-side consumers (e.g. XLSX export) stay forward-compatible.
+         */
+        version?: string;
+        /**
+         * Master toggle for all conditional formatting rules.
+         */
+        enabled?: boolean;
+        /**
+         * Ordered list of rules; the first matching rule wins.
+         */
+        rules?: {
+            /**
+             * Stable, table-unique rule id.
+             */
+            id: string;
+            /**
+             * The measure or attribute the rule targets — exactly one of measure/attribute.
+             */
+            target: {
+                /**
+                 * Local identifier of the targeted measure.
+                 */
+                measure: string;
+            } | {
+                /**
+                 * Local identifier of the targeted attribute.
+                 */
+                attribute: string;
+            };
+            /**
+             * Stacked conditions; the first matching condition wins.
+             */
+            conditions: {
+                id: string;
+                operator: "all" | "equal_to" | "not_equal_to" | "less_than" | "less_than_or_equal_to" | "greater_than" | "greater_than_or_equal_to" | "between" | "not_between" | "contains" | "not_contains" | "starts_with" | "not_starts_with" | "ends_with" | "not_ends_with" | "is_empty" | "is_not_empty";
+                /**
+                 * Literal (number or string); a \{from,to\} range for between/not_between; omitted for all/is_empty/is_not_empty.
+                 */
+                value?: number | string | {
+                    from: number;
+                    to: number;
+                };
+                format: {
+                    /**
+                     * Text color as hex (e.g. #FFFFFF).
+                     */
+                    text?: string;
+                    /**
+                     * Background color as hex (e.g. #E54D40).
+                     */
+                    fill?: string;
+                    scope: "cell" | "row";
+                };
+            }[];
+        }[];
+    };
     [k: string]: unknown;
 }
 
@@ -12973,6 +13576,67 @@ declare interface VisualisationConfig16 {
     enable_accessibility?: boolean;
     line_style_control_metrics?: string[];
     line_style_excluded_metrics?: string[];
+    /**
+     * Conditional formatting rules that color cells or rows based on their values.
+     */
+    conditional_formatting?: {
+        /**
+         * Conditional-formatting model version. "1" (default if omitted) — initial shape: discrete rules, one column per rule with stacked conditions. Readers must tolerate omission (treat as "1") and evolve under the same backward-compat contract as the dashboard model version, so server-side consumers (e.g. XLSX export) stay forward-compatible.
+         */
+        version?: string;
+        /**
+         * Master toggle for all conditional formatting rules.
+         */
+        enabled?: boolean;
+        /**
+         * Ordered list of rules; the first matching rule wins.
+         */
+        rules?: {
+            /**
+             * Stable, table-unique rule id.
+             */
+            id: string;
+            /**
+             * The measure or attribute the rule targets — exactly one of measure/attribute.
+             */
+            target: {
+                /**
+                 * Local identifier of the targeted measure.
+                 */
+                measure: string;
+            } | {
+                /**
+                 * Local identifier of the targeted attribute.
+                 */
+                attribute: string;
+            };
+            /**
+             * Stacked conditions; the first matching condition wins.
+             */
+            conditions: {
+                id: string;
+                operator: "all" | "equal_to" | "not_equal_to" | "less_than" | "less_than_or_equal_to" | "greater_than" | "greater_than_or_equal_to" | "between" | "not_between" | "contains" | "not_contains" | "starts_with" | "not_starts_with" | "ends_with" | "not_ends_with" | "is_empty" | "is_not_empty";
+                /**
+                 * Literal (number or string); a \{from,to\} range for between/not_between; omitted for all/is_empty/is_not_empty.
+                 */
+                value?: number | string | {
+                    from: number;
+                    to: number;
+                };
+                format: {
+                    /**
+                     * Text color as hex (e.g. #FFFFFF).
+                     */
+                    text?: string;
+                    /**
+                     * Background color as hex (e.g. #E54D40).
+                     */
+                    fill?: string;
+                    scope: "cell" | "row";
+                };
+            }[];
+        }[];
+    };
     [k: string]: unknown;
 }
 
@@ -13147,6 +13811,67 @@ declare interface VisualisationConfig17 {
     enable_accessibility?: boolean;
     line_style_control_metrics?: string[];
     line_style_excluded_metrics?: string[];
+    /**
+     * Conditional formatting rules that color cells or rows based on their values.
+     */
+    conditional_formatting?: {
+        /**
+         * Conditional-formatting model version. "1" (default if omitted) — initial shape: discrete rules, one column per rule with stacked conditions. Readers must tolerate omission (treat as "1") and evolve under the same backward-compat contract as the dashboard model version, so server-side consumers (e.g. XLSX export) stay forward-compatible.
+         */
+        version?: string;
+        /**
+         * Master toggle for all conditional formatting rules.
+         */
+        enabled?: boolean;
+        /**
+         * Ordered list of rules; the first matching rule wins.
+         */
+        rules?: {
+            /**
+             * Stable, table-unique rule id.
+             */
+            id: string;
+            /**
+             * The measure or attribute the rule targets — exactly one of measure/attribute.
+             */
+            target: {
+                /**
+                 * Local identifier of the targeted measure.
+                 */
+                measure: string;
+            } | {
+                /**
+                 * Local identifier of the targeted attribute.
+                 */
+                attribute: string;
+            };
+            /**
+             * Stacked conditions; the first matching condition wins.
+             */
+            conditions: {
+                id: string;
+                operator: "all" | "equal_to" | "not_equal_to" | "less_than" | "less_than_or_equal_to" | "greater_than" | "greater_than_or_equal_to" | "between" | "not_between" | "contains" | "not_contains" | "starts_with" | "not_starts_with" | "ends_with" | "not_ends_with" | "is_empty" | "is_not_empty";
+                /**
+                 * Literal (number or string); a \{from,to\} range for between/not_between; omitted for all/is_empty/is_not_empty.
+                 */
+                value?: number | string | {
+                    from: number;
+                    to: number;
+                };
+                format: {
+                    /**
+                     * Text color as hex (e.g. #FFFFFF).
+                     */
+                    text?: string;
+                    /**
+                     * Background color as hex (e.g. #E54D40).
+                     */
+                    fill?: string;
+                    scope: "cell" | "row";
+                };
+            }[];
+        }[];
+    };
     [k: string]: unknown;
 }
 
@@ -13321,6 +14046,67 @@ declare interface VisualisationConfig18 {
     enable_accessibility?: boolean;
     line_style_control_metrics?: string[];
     line_style_excluded_metrics?: string[];
+    /**
+     * Conditional formatting rules that color cells or rows based on their values.
+     */
+    conditional_formatting?: {
+        /**
+         * Conditional-formatting model version. "1" (default if omitted) — initial shape: discrete rules, one column per rule with stacked conditions. Readers must tolerate omission (treat as "1") and evolve under the same backward-compat contract as the dashboard model version, so server-side consumers (e.g. XLSX export) stay forward-compatible.
+         */
+        version?: string;
+        /**
+         * Master toggle for all conditional formatting rules.
+         */
+        enabled?: boolean;
+        /**
+         * Ordered list of rules; the first matching rule wins.
+         */
+        rules?: {
+            /**
+             * Stable, table-unique rule id.
+             */
+            id: string;
+            /**
+             * The measure or attribute the rule targets — exactly one of measure/attribute.
+             */
+            target: {
+                /**
+                 * Local identifier of the targeted measure.
+                 */
+                measure: string;
+            } | {
+                /**
+                 * Local identifier of the targeted attribute.
+                 */
+                attribute: string;
+            };
+            /**
+             * Stacked conditions; the first matching condition wins.
+             */
+            conditions: {
+                id: string;
+                operator: "all" | "equal_to" | "not_equal_to" | "less_than" | "less_than_or_equal_to" | "greater_than" | "greater_than_or_equal_to" | "between" | "not_between" | "contains" | "not_contains" | "starts_with" | "not_starts_with" | "ends_with" | "not_ends_with" | "is_empty" | "is_not_empty";
+                /**
+                 * Literal (number or string); a \{from,to\} range for between/not_between; omitted for all/is_empty/is_not_empty.
+                 */
+                value?: number | string | {
+                    from: number;
+                    to: number;
+                };
+                format: {
+                    /**
+                     * Text color as hex (e.g. #FFFFFF).
+                     */
+                    text?: string;
+                    /**
+                     * Background color as hex (e.g. #E54D40).
+                     */
+                    fill?: string;
+                    scope: "cell" | "row";
+                };
+            }[];
+        }[];
+    };
     [k: string]: unknown;
 }
 
@@ -13495,6 +14281,67 @@ declare interface VisualisationConfig19 {
     enable_accessibility?: boolean;
     line_style_control_metrics?: string[];
     line_style_excluded_metrics?: string[];
+    /**
+     * Conditional formatting rules that color cells or rows based on their values.
+     */
+    conditional_formatting?: {
+        /**
+         * Conditional-formatting model version. "1" (default if omitted) — initial shape: discrete rules, one column per rule with stacked conditions. Readers must tolerate omission (treat as "1") and evolve under the same backward-compat contract as the dashboard model version, so server-side consumers (e.g. XLSX export) stay forward-compatible.
+         */
+        version?: string;
+        /**
+         * Master toggle for all conditional formatting rules.
+         */
+        enabled?: boolean;
+        /**
+         * Ordered list of rules; the first matching rule wins.
+         */
+        rules?: {
+            /**
+             * Stable, table-unique rule id.
+             */
+            id: string;
+            /**
+             * The measure or attribute the rule targets — exactly one of measure/attribute.
+             */
+            target: {
+                /**
+                 * Local identifier of the targeted measure.
+                 */
+                measure: string;
+            } | {
+                /**
+                 * Local identifier of the targeted attribute.
+                 */
+                attribute: string;
+            };
+            /**
+             * Stacked conditions; the first matching condition wins.
+             */
+            conditions: {
+                id: string;
+                operator: "all" | "equal_to" | "not_equal_to" | "less_than" | "less_than_or_equal_to" | "greater_than" | "greater_than_or_equal_to" | "between" | "not_between" | "contains" | "not_contains" | "starts_with" | "not_starts_with" | "ends_with" | "not_ends_with" | "is_empty" | "is_not_empty";
+                /**
+                 * Literal (number or string); a \{from,to\} range for between/not_between; omitted for all/is_empty/is_not_empty.
+                 */
+                value?: number | string | {
+                    from: number;
+                    to: number;
+                };
+                format: {
+                    /**
+                     * Text color as hex (e.g. #FFFFFF).
+                     */
+                    text?: string;
+                    /**
+                     * Background color as hex (e.g. #E54D40).
+                     */
+                    fill?: string;
+                    scope: "cell" | "row";
+                };
+            }[];
+        }[];
+    };
     [k: string]: unknown;
 }
 
@@ -13669,6 +14516,67 @@ declare interface VisualisationConfig2 {
     enable_accessibility?: boolean;
     line_style_control_metrics?: string[];
     line_style_excluded_metrics?: string[];
+    /**
+     * Conditional formatting rules that color cells or rows based on their values.
+     */
+    conditional_formatting?: {
+        /**
+         * Conditional-formatting model version. "1" (default if omitted) — initial shape: discrete rules, one column per rule with stacked conditions. Readers must tolerate omission (treat as "1") and evolve under the same backward-compat contract as the dashboard model version, so server-side consumers (e.g. XLSX export) stay forward-compatible.
+         */
+        version?: string;
+        /**
+         * Master toggle for all conditional formatting rules.
+         */
+        enabled?: boolean;
+        /**
+         * Ordered list of rules; the first matching rule wins.
+         */
+        rules?: {
+            /**
+             * Stable, table-unique rule id.
+             */
+            id: string;
+            /**
+             * The measure or attribute the rule targets — exactly one of measure/attribute.
+             */
+            target: {
+                /**
+                 * Local identifier of the targeted measure.
+                 */
+                measure: string;
+            } | {
+                /**
+                 * Local identifier of the targeted attribute.
+                 */
+                attribute: string;
+            };
+            /**
+             * Stacked conditions; the first matching condition wins.
+             */
+            conditions: {
+                id: string;
+                operator: "all" | "equal_to" | "not_equal_to" | "less_than" | "less_than_or_equal_to" | "greater_than" | "greater_than_or_equal_to" | "between" | "not_between" | "contains" | "not_contains" | "starts_with" | "not_starts_with" | "ends_with" | "not_ends_with" | "is_empty" | "is_not_empty";
+                /**
+                 * Literal (number or string); a \{from,to\} range for between/not_between; omitted for all/is_empty/is_not_empty.
+                 */
+                value?: number | string | {
+                    from: number;
+                    to: number;
+                };
+                format: {
+                    /**
+                     * Text color as hex (e.g. #FFFFFF).
+                     */
+                    text?: string;
+                    /**
+                     * Background color as hex (e.g. #E54D40).
+                     */
+                    fill?: string;
+                    scope: "cell" | "row";
+                };
+            }[];
+        }[];
+    };
     [k: string]: unknown;
 }
 
@@ -13843,6 +14751,67 @@ declare interface VisualisationConfig20 {
     enable_accessibility?: boolean;
     line_style_control_metrics?: string[];
     line_style_excluded_metrics?: string[];
+    /**
+     * Conditional formatting rules that color cells or rows based on their values.
+     */
+    conditional_formatting?: {
+        /**
+         * Conditional-formatting model version. "1" (default if omitted) — initial shape: discrete rules, one column per rule with stacked conditions. Readers must tolerate omission (treat as "1") and evolve under the same backward-compat contract as the dashboard model version, so server-side consumers (e.g. XLSX export) stay forward-compatible.
+         */
+        version?: string;
+        /**
+         * Master toggle for all conditional formatting rules.
+         */
+        enabled?: boolean;
+        /**
+         * Ordered list of rules; the first matching rule wins.
+         */
+        rules?: {
+            /**
+             * Stable, table-unique rule id.
+             */
+            id: string;
+            /**
+             * The measure or attribute the rule targets — exactly one of measure/attribute.
+             */
+            target: {
+                /**
+                 * Local identifier of the targeted measure.
+                 */
+                measure: string;
+            } | {
+                /**
+                 * Local identifier of the targeted attribute.
+                 */
+                attribute: string;
+            };
+            /**
+             * Stacked conditions; the first matching condition wins.
+             */
+            conditions: {
+                id: string;
+                operator: "all" | "equal_to" | "not_equal_to" | "less_than" | "less_than_or_equal_to" | "greater_than" | "greater_than_or_equal_to" | "between" | "not_between" | "contains" | "not_contains" | "starts_with" | "not_starts_with" | "ends_with" | "not_ends_with" | "is_empty" | "is_not_empty";
+                /**
+                 * Literal (number or string); a \{from,to\} range for between/not_between; omitted for all/is_empty/is_not_empty.
+                 */
+                value?: number | string | {
+                    from: number;
+                    to: number;
+                };
+                format: {
+                    /**
+                     * Text color as hex (e.g. #FFFFFF).
+                     */
+                    text?: string;
+                    /**
+                     * Background color as hex (e.g. #E54D40).
+                     */
+                    fill?: string;
+                    scope: "cell" | "row";
+                };
+            }[];
+        }[];
+    };
     [k: string]: unknown;
 }
 
@@ -14017,6 +14986,67 @@ declare interface VisualisationConfig21 {
     enable_accessibility?: boolean;
     line_style_control_metrics?: string[];
     line_style_excluded_metrics?: string[];
+    /**
+     * Conditional formatting rules that color cells or rows based on their values.
+     */
+    conditional_formatting?: {
+        /**
+         * Conditional-formatting model version. "1" (default if omitted) — initial shape: discrete rules, one column per rule with stacked conditions. Readers must tolerate omission (treat as "1") and evolve under the same backward-compat contract as the dashboard model version, so server-side consumers (e.g. XLSX export) stay forward-compatible.
+         */
+        version?: string;
+        /**
+         * Master toggle for all conditional formatting rules.
+         */
+        enabled?: boolean;
+        /**
+         * Ordered list of rules; the first matching rule wins.
+         */
+        rules?: {
+            /**
+             * Stable, table-unique rule id.
+             */
+            id: string;
+            /**
+             * The measure or attribute the rule targets — exactly one of measure/attribute.
+             */
+            target: {
+                /**
+                 * Local identifier of the targeted measure.
+                 */
+                measure: string;
+            } | {
+                /**
+                 * Local identifier of the targeted attribute.
+                 */
+                attribute: string;
+            };
+            /**
+             * Stacked conditions; the first matching condition wins.
+             */
+            conditions: {
+                id: string;
+                operator: "all" | "equal_to" | "not_equal_to" | "less_than" | "less_than_or_equal_to" | "greater_than" | "greater_than_or_equal_to" | "between" | "not_between" | "contains" | "not_contains" | "starts_with" | "not_starts_with" | "ends_with" | "not_ends_with" | "is_empty" | "is_not_empty";
+                /**
+                 * Literal (number or string); a \{from,to\} range for between/not_between; omitted for all/is_empty/is_not_empty.
+                 */
+                value?: number | string | {
+                    from: number;
+                    to: number;
+                };
+                format: {
+                    /**
+                     * Text color as hex (e.g. #FFFFFF).
+                     */
+                    text?: string;
+                    /**
+                     * Background color as hex (e.g. #E54D40).
+                     */
+                    fill?: string;
+                    scope: "cell" | "row";
+                };
+            }[];
+        }[];
+    };
     [k: string]: unknown;
 }
 
@@ -14191,6 +15221,67 @@ declare interface VisualisationConfig22 {
     enable_accessibility?: boolean;
     line_style_control_metrics?: string[];
     line_style_excluded_metrics?: string[];
+    /**
+     * Conditional formatting rules that color cells or rows based on their values.
+     */
+    conditional_formatting?: {
+        /**
+         * Conditional-formatting model version. "1" (default if omitted) — initial shape: discrete rules, one column per rule with stacked conditions. Readers must tolerate omission (treat as "1") and evolve under the same backward-compat contract as the dashboard model version, so server-side consumers (e.g. XLSX export) stay forward-compatible.
+         */
+        version?: string;
+        /**
+         * Master toggle for all conditional formatting rules.
+         */
+        enabled?: boolean;
+        /**
+         * Ordered list of rules; the first matching rule wins.
+         */
+        rules?: {
+            /**
+             * Stable, table-unique rule id.
+             */
+            id: string;
+            /**
+             * The measure or attribute the rule targets — exactly one of measure/attribute.
+             */
+            target: {
+                /**
+                 * Local identifier of the targeted measure.
+                 */
+                measure: string;
+            } | {
+                /**
+                 * Local identifier of the targeted attribute.
+                 */
+                attribute: string;
+            };
+            /**
+             * Stacked conditions; the first matching condition wins.
+             */
+            conditions: {
+                id: string;
+                operator: "all" | "equal_to" | "not_equal_to" | "less_than" | "less_than_or_equal_to" | "greater_than" | "greater_than_or_equal_to" | "between" | "not_between" | "contains" | "not_contains" | "starts_with" | "not_starts_with" | "ends_with" | "not_ends_with" | "is_empty" | "is_not_empty";
+                /**
+                 * Literal (number or string); a \{from,to\} range for between/not_between; omitted for all/is_empty/is_not_empty.
+                 */
+                value?: number | string | {
+                    from: number;
+                    to: number;
+                };
+                format: {
+                    /**
+                     * Text color as hex (e.g. #FFFFFF).
+                     */
+                    text?: string;
+                    /**
+                     * Background color as hex (e.g. #E54D40).
+                     */
+                    fill?: string;
+                    scope: "cell" | "row";
+                };
+            }[];
+        }[];
+    };
     [k: string]: unknown;
 }
 
@@ -14365,6 +15456,67 @@ declare interface VisualisationConfig3 {
     enable_accessibility?: boolean;
     line_style_control_metrics?: string[];
     line_style_excluded_metrics?: string[];
+    /**
+     * Conditional formatting rules that color cells or rows based on their values.
+     */
+    conditional_formatting?: {
+        /**
+         * Conditional-formatting model version. "1" (default if omitted) — initial shape: discrete rules, one column per rule with stacked conditions. Readers must tolerate omission (treat as "1") and evolve under the same backward-compat contract as the dashboard model version, so server-side consumers (e.g. XLSX export) stay forward-compatible.
+         */
+        version?: string;
+        /**
+         * Master toggle for all conditional formatting rules.
+         */
+        enabled?: boolean;
+        /**
+         * Ordered list of rules; the first matching rule wins.
+         */
+        rules?: {
+            /**
+             * Stable, table-unique rule id.
+             */
+            id: string;
+            /**
+             * The measure or attribute the rule targets — exactly one of measure/attribute.
+             */
+            target: {
+                /**
+                 * Local identifier of the targeted measure.
+                 */
+                measure: string;
+            } | {
+                /**
+                 * Local identifier of the targeted attribute.
+                 */
+                attribute: string;
+            };
+            /**
+             * Stacked conditions; the first matching condition wins.
+             */
+            conditions: {
+                id: string;
+                operator: "all" | "equal_to" | "not_equal_to" | "less_than" | "less_than_or_equal_to" | "greater_than" | "greater_than_or_equal_to" | "between" | "not_between" | "contains" | "not_contains" | "starts_with" | "not_starts_with" | "ends_with" | "not_ends_with" | "is_empty" | "is_not_empty";
+                /**
+                 * Literal (number or string); a \{from,to\} range for between/not_between; omitted for all/is_empty/is_not_empty.
+                 */
+                value?: number | string | {
+                    from: number;
+                    to: number;
+                };
+                format: {
+                    /**
+                     * Text color as hex (e.g. #FFFFFF).
+                     */
+                    text?: string;
+                    /**
+                     * Background color as hex (e.g. #E54D40).
+                     */
+                    fill?: string;
+                    scope: "cell" | "row";
+                };
+            }[];
+        }[];
+    };
     [k: string]: unknown;
 }
 
@@ -14539,6 +15691,67 @@ declare interface VisualisationConfig4 {
     enable_accessibility?: boolean;
     line_style_control_metrics?: string[];
     line_style_excluded_metrics?: string[];
+    /**
+     * Conditional formatting rules that color cells or rows based on their values.
+     */
+    conditional_formatting?: {
+        /**
+         * Conditional-formatting model version. "1" (default if omitted) — initial shape: discrete rules, one column per rule with stacked conditions. Readers must tolerate omission (treat as "1") and evolve under the same backward-compat contract as the dashboard model version, so server-side consumers (e.g. XLSX export) stay forward-compatible.
+         */
+        version?: string;
+        /**
+         * Master toggle for all conditional formatting rules.
+         */
+        enabled?: boolean;
+        /**
+         * Ordered list of rules; the first matching rule wins.
+         */
+        rules?: {
+            /**
+             * Stable, table-unique rule id.
+             */
+            id: string;
+            /**
+             * The measure or attribute the rule targets — exactly one of measure/attribute.
+             */
+            target: {
+                /**
+                 * Local identifier of the targeted measure.
+                 */
+                measure: string;
+            } | {
+                /**
+                 * Local identifier of the targeted attribute.
+                 */
+                attribute: string;
+            };
+            /**
+             * Stacked conditions; the first matching condition wins.
+             */
+            conditions: {
+                id: string;
+                operator: "all" | "equal_to" | "not_equal_to" | "less_than" | "less_than_or_equal_to" | "greater_than" | "greater_than_or_equal_to" | "between" | "not_between" | "contains" | "not_contains" | "starts_with" | "not_starts_with" | "ends_with" | "not_ends_with" | "is_empty" | "is_not_empty";
+                /**
+                 * Literal (number or string); a \{from,to\} range for between/not_between; omitted for all/is_empty/is_not_empty.
+                 */
+                value?: number | string | {
+                    from: number;
+                    to: number;
+                };
+                format: {
+                    /**
+                     * Text color as hex (e.g. #FFFFFF).
+                     */
+                    text?: string;
+                    /**
+                     * Background color as hex (e.g. #E54D40).
+                     */
+                    fill?: string;
+                    scope: "cell" | "row";
+                };
+            }[];
+        }[];
+    };
     [k: string]: unknown;
 }
 
@@ -14713,6 +15926,67 @@ declare interface VisualisationConfig5 {
     enable_accessibility?: boolean;
     line_style_control_metrics?: string[];
     line_style_excluded_metrics?: string[];
+    /**
+     * Conditional formatting rules that color cells or rows based on their values.
+     */
+    conditional_formatting?: {
+        /**
+         * Conditional-formatting model version. "1" (default if omitted) — initial shape: discrete rules, one column per rule with stacked conditions. Readers must tolerate omission (treat as "1") and evolve under the same backward-compat contract as the dashboard model version, so server-side consumers (e.g. XLSX export) stay forward-compatible.
+         */
+        version?: string;
+        /**
+         * Master toggle for all conditional formatting rules.
+         */
+        enabled?: boolean;
+        /**
+         * Ordered list of rules; the first matching rule wins.
+         */
+        rules?: {
+            /**
+             * Stable, table-unique rule id.
+             */
+            id: string;
+            /**
+             * The measure or attribute the rule targets — exactly one of measure/attribute.
+             */
+            target: {
+                /**
+                 * Local identifier of the targeted measure.
+                 */
+                measure: string;
+            } | {
+                /**
+                 * Local identifier of the targeted attribute.
+                 */
+                attribute: string;
+            };
+            /**
+             * Stacked conditions; the first matching condition wins.
+             */
+            conditions: {
+                id: string;
+                operator: "all" | "equal_to" | "not_equal_to" | "less_than" | "less_than_or_equal_to" | "greater_than" | "greater_than_or_equal_to" | "between" | "not_between" | "contains" | "not_contains" | "starts_with" | "not_starts_with" | "ends_with" | "not_ends_with" | "is_empty" | "is_not_empty";
+                /**
+                 * Literal (number or string); a \{from,to\} range for between/not_between; omitted for all/is_empty/is_not_empty.
+                 */
+                value?: number | string | {
+                    from: number;
+                    to: number;
+                };
+                format: {
+                    /**
+                     * Text color as hex (e.g. #FFFFFF).
+                     */
+                    text?: string;
+                    /**
+                     * Background color as hex (e.g. #E54D40).
+                     */
+                    fill?: string;
+                    scope: "cell" | "row";
+                };
+            }[];
+        }[];
+    };
     [k: string]: unknown;
 }
 
@@ -14887,6 +16161,67 @@ declare interface VisualisationConfig6 {
     enable_accessibility?: boolean;
     line_style_control_metrics?: string[];
     line_style_excluded_metrics?: string[];
+    /**
+     * Conditional formatting rules that color cells or rows based on their values.
+     */
+    conditional_formatting?: {
+        /**
+         * Conditional-formatting model version. "1" (default if omitted) — initial shape: discrete rules, one column per rule with stacked conditions. Readers must tolerate omission (treat as "1") and evolve under the same backward-compat contract as the dashboard model version, so server-side consumers (e.g. XLSX export) stay forward-compatible.
+         */
+        version?: string;
+        /**
+         * Master toggle for all conditional formatting rules.
+         */
+        enabled?: boolean;
+        /**
+         * Ordered list of rules; the first matching rule wins.
+         */
+        rules?: {
+            /**
+             * Stable, table-unique rule id.
+             */
+            id: string;
+            /**
+             * The measure or attribute the rule targets — exactly one of measure/attribute.
+             */
+            target: {
+                /**
+                 * Local identifier of the targeted measure.
+                 */
+                measure: string;
+            } | {
+                /**
+                 * Local identifier of the targeted attribute.
+                 */
+                attribute: string;
+            };
+            /**
+             * Stacked conditions; the first matching condition wins.
+             */
+            conditions: {
+                id: string;
+                operator: "all" | "equal_to" | "not_equal_to" | "less_than" | "less_than_or_equal_to" | "greater_than" | "greater_than_or_equal_to" | "between" | "not_between" | "contains" | "not_contains" | "starts_with" | "not_starts_with" | "ends_with" | "not_ends_with" | "is_empty" | "is_not_empty";
+                /**
+                 * Literal (number or string); a \{from,to\} range for between/not_between; omitted for all/is_empty/is_not_empty.
+                 */
+                value?: number | string | {
+                    from: number;
+                    to: number;
+                };
+                format: {
+                    /**
+                     * Text color as hex (e.g. #FFFFFF).
+                     */
+                    text?: string;
+                    /**
+                     * Background color as hex (e.g. #E54D40).
+                     */
+                    fill?: string;
+                    scope: "cell" | "row";
+                };
+            }[];
+        }[];
+    };
     [k: string]: unknown;
 }
 
@@ -15061,6 +16396,67 @@ declare interface VisualisationConfig7 {
     enable_accessibility?: boolean;
     line_style_control_metrics?: string[];
     line_style_excluded_metrics?: string[];
+    /**
+     * Conditional formatting rules that color cells or rows based on their values.
+     */
+    conditional_formatting?: {
+        /**
+         * Conditional-formatting model version. "1" (default if omitted) — initial shape: discrete rules, one column per rule with stacked conditions. Readers must tolerate omission (treat as "1") and evolve under the same backward-compat contract as the dashboard model version, so server-side consumers (e.g. XLSX export) stay forward-compatible.
+         */
+        version?: string;
+        /**
+         * Master toggle for all conditional formatting rules.
+         */
+        enabled?: boolean;
+        /**
+         * Ordered list of rules; the first matching rule wins.
+         */
+        rules?: {
+            /**
+             * Stable, table-unique rule id.
+             */
+            id: string;
+            /**
+             * The measure or attribute the rule targets — exactly one of measure/attribute.
+             */
+            target: {
+                /**
+                 * Local identifier of the targeted measure.
+                 */
+                measure: string;
+            } | {
+                /**
+                 * Local identifier of the targeted attribute.
+                 */
+                attribute: string;
+            };
+            /**
+             * Stacked conditions; the first matching condition wins.
+             */
+            conditions: {
+                id: string;
+                operator: "all" | "equal_to" | "not_equal_to" | "less_than" | "less_than_or_equal_to" | "greater_than" | "greater_than_or_equal_to" | "between" | "not_between" | "contains" | "not_contains" | "starts_with" | "not_starts_with" | "ends_with" | "not_ends_with" | "is_empty" | "is_not_empty";
+                /**
+                 * Literal (number or string); a \{from,to\} range for between/not_between; omitted for all/is_empty/is_not_empty.
+                 */
+                value?: number | string | {
+                    from: number;
+                    to: number;
+                };
+                format: {
+                    /**
+                     * Text color as hex (e.g. #FFFFFF).
+                     */
+                    text?: string;
+                    /**
+                     * Background color as hex (e.g. #E54D40).
+                     */
+                    fill?: string;
+                    scope: "cell" | "row";
+                };
+            }[];
+        }[];
+    };
     [k: string]: unknown;
 }
 
@@ -15235,6 +16631,67 @@ declare interface VisualisationConfig8 {
     enable_accessibility?: boolean;
     line_style_control_metrics?: string[];
     line_style_excluded_metrics?: string[];
+    /**
+     * Conditional formatting rules that color cells or rows based on their values.
+     */
+    conditional_formatting?: {
+        /**
+         * Conditional-formatting model version. "1" (default if omitted) — initial shape: discrete rules, one column per rule with stacked conditions. Readers must tolerate omission (treat as "1") and evolve under the same backward-compat contract as the dashboard model version, so server-side consumers (e.g. XLSX export) stay forward-compatible.
+         */
+        version?: string;
+        /**
+         * Master toggle for all conditional formatting rules.
+         */
+        enabled?: boolean;
+        /**
+         * Ordered list of rules; the first matching rule wins.
+         */
+        rules?: {
+            /**
+             * Stable, table-unique rule id.
+             */
+            id: string;
+            /**
+             * The measure or attribute the rule targets — exactly one of measure/attribute.
+             */
+            target: {
+                /**
+                 * Local identifier of the targeted measure.
+                 */
+                measure: string;
+            } | {
+                /**
+                 * Local identifier of the targeted attribute.
+                 */
+                attribute: string;
+            };
+            /**
+             * Stacked conditions; the first matching condition wins.
+             */
+            conditions: {
+                id: string;
+                operator: "all" | "equal_to" | "not_equal_to" | "less_than" | "less_than_or_equal_to" | "greater_than" | "greater_than_or_equal_to" | "between" | "not_between" | "contains" | "not_contains" | "starts_with" | "not_starts_with" | "ends_with" | "not_ends_with" | "is_empty" | "is_not_empty";
+                /**
+                 * Literal (number or string); a \{from,to\} range for between/not_between; omitted for all/is_empty/is_not_empty.
+                 */
+                value?: number | string | {
+                    from: number;
+                    to: number;
+                };
+                format: {
+                    /**
+                     * Text color as hex (e.g. #FFFFFF).
+                     */
+                    text?: string;
+                    /**
+                     * Background color as hex (e.g. #E54D40).
+                     */
+                    fill?: string;
+                    scope: "cell" | "row";
+                };
+            }[];
+        }[];
+    };
     [k: string]: unknown;
 }
 
@@ -15409,6 +16866,67 @@ declare interface VisualisationConfig9 {
     enable_accessibility?: boolean;
     line_style_control_metrics?: string[];
     line_style_excluded_metrics?: string[];
+    /**
+     * Conditional formatting rules that color cells or rows based on their values.
+     */
+    conditional_formatting?: {
+        /**
+         * Conditional-formatting model version. "1" (default if omitted) — initial shape: discrete rules, one column per rule with stacked conditions. Readers must tolerate omission (treat as "1") and evolve under the same backward-compat contract as the dashboard model version, so server-side consumers (e.g. XLSX export) stay forward-compatible.
+         */
+        version?: string;
+        /**
+         * Master toggle for all conditional formatting rules.
+         */
+        enabled?: boolean;
+        /**
+         * Ordered list of rules; the first matching rule wins.
+         */
+        rules?: {
+            /**
+             * Stable, table-unique rule id.
+             */
+            id: string;
+            /**
+             * The measure or attribute the rule targets — exactly one of measure/attribute.
+             */
+            target: {
+                /**
+                 * Local identifier of the targeted measure.
+                 */
+                measure: string;
+            } | {
+                /**
+                 * Local identifier of the targeted attribute.
+                 */
+                attribute: string;
+            };
+            /**
+             * Stacked conditions; the first matching condition wins.
+             */
+            conditions: {
+                id: string;
+                operator: "all" | "equal_to" | "not_equal_to" | "less_than" | "less_than_or_equal_to" | "greater_than" | "greater_than_or_equal_to" | "between" | "not_between" | "contains" | "not_contains" | "starts_with" | "not_starts_with" | "ends_with" | "not_ends_with" | "is_empty" | "is_not_empty";
+                /**
+                 * Literal (number or string); a \{from,to\} range for between/not_between; omitted for all/is_empty/is_not_empty.
+                 */
+                value?: number | string | {
+                    from: number;
+                    to: number;
+                };
+                format: {
+                    /**
+                     * Text color as hex (e.g. #FFFFFF).
+                     */
+                    text?: string;
+                    /**
+                     * Background color as hex (e.g. #E54D40).
+                     */
+                    fill?: string;
+                    scope: "cell" | "row";
+                };
+            }[];
+        }[];
+    };
     [k: string]: unknown;
 }