@gooddata/sdk-ui 11.53.0-alpha.0 → 11.53.0-alpha.2

package/esm/base/localization/bundles/en-US.localization-bundle.d.ts

@@ -2283,6 +2283,14 @@ export declare const en_US: {
         text: string;
         crowdinContext: string;
     };
+    "parameter_filter.dropdown.search_label": {
+        text: string;
+        crowdinContext: string;
+    };
+    "parameter_filter.dropdown.default_suffix": {
+        text: string;
+        crowdinContext: string;
+    };
     "parameter_filter.dropdown.preview_label": {
         text: string;
         crowdinContext: string;

package/esm/base/localization/bundles/en-US.localization-bundle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"en-US.localization-bundle.d.ts","sourceRoot":"","sources":["../../../../src/base/localization/bundles/en-US.localization-bundle.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkvJjB,CAAC"}
+{"version":3,"file":"en-US.localization-bundle.d.ts","sourceRoot":"","sources":["../../../../src/base/localization/bundles/en-US.localization-bundle.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0vJjB,CAAC"}

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

@@ -2285,6 +2285,14 @@ export const en_US = {
         "text": "Reset",
         "crowdinContext": "Reset link in the parameter control dropdown; reverts the value to the workspace default"
     },
+    "parameter_filter.dropdown.search_label": {
+        "text": "Search values",
+        "crowdinContext": "Accessible name of the search field above the list of allowed values in the parameter control dropdown"
+    },
+    "parameter_filter.dropdown.default_suffix": {
+        "text": "(Default)",
+        "crowdinContext": "Suffix shown next to an allowed value title in the parameter control dropdown. Identifies which value is the parameter default."
+    },
     "parameter_filter.dropdown.preview_label": {
         "text": "Preview:",
         "crowdinContext": "Preview label in the parameter control dropdown"

package/esm/base/react/legacy/withEntireDataView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"withEntireDataView.d.ts","sourceRoot":"","sources":["../../../../src/base/react/legacy/withEntireDataView.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAkC,KAAK,aAAa,EAAE,MAAM,OAAO,CAAC;AAG3E,OAAO,EAAE,KAAK,SAAS,EAAc,MAAM,YAAY,CAAC;AAExD,OAAO,EAEH,KAAK,SAAS,EAOjB,MAAM,2BAA2B,CAAC;AAInC,OAAO,EAIH,KAAK,gBAAgB,EAIxB,MAAM,kCAAkC,CAAC;AAG1C,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,qBAAqB,CAAC;AAE/E,OAAO,EAAE,KAAK,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAY/E;;;;;GAKG;AACH,MAAM,WAAW,qBAAqB;IAClC;;;OAGG;IACH,SAAS,EAAE,OAAO,CAAC;IAEnB;;OAEG;IACH,QAAQ,CAAC,EAAE,SAAS,CAAC;IAErB;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;OAEG;IACH,MAAM,CAAC,EAAE,gBAAgB,CAAC,QAAQ,CAAC,CAAC;IAGpC,IAAI,EAAE,SAAS,CAAC;IAEhB;;OAEG;IACH,aAAa,CAAC,cAAc,EAAE,eAAe,GAAG,IAAI,CAAC;IAErD;;OAEG;IACH,cAAc,CAAC,IAAI,EAAE,GAAG,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAEvD;;OAEG;IACH,gBAAgB,IAAI,IAAI,CAAC;CAC5B;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,uBAAuB,EAChE,cAAc,EAAE,aAAa,CAAC,CAAC,GAAG,qBAAqB,CAAC,GACzD,aAAa,CAAC,CAAC,CAAC,CAqXlB"}
+{"version":3,"file":"withEntireDataView.d.ts","sourceRoot":"","sources":["../../../../src/base/react/legacy/withEntireDataView.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAuB,KAAK,aAAa,EAA4C,MAAM,OAAO,CAAC;AAG1G,OAAO,EAAE,KAAK,SAAS,EAAc,MAAM,YAAY,CAAC;AAExD,OAAO,EAEH,KAAK,SAAS,EAOjB,MAAM,2BAA2B,CAAC;AAInC,OAAO,EAIH,KAAK,gBAAgB,EAIxB,MAAM,kCAAkC,CAAC;AAG1C,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,qBAAqB,CAAC;AAE/E,OAAO,EAAE,KAAK,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAkC/E;;;;;GAKG;AACH,MAAM,WAAW,qBAAqB;IAClC;;;OAGG;IACH,SAAS,EAAE,OAAO,CAAC;IAEnB;;OAEG;IACH,QAAQ,CAAC,EAAE,SAAS,CAAC;IAErB;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;OAEG;IACH,MAAM,CAAC,EAAE,gBAAgB,CAAC,QAAQ,CAAC,CAAC;IAGpC,IAAI,EAAE,SAAS,CAAC;IAEhB;;OAEG;IACH,aAAa,CAAC,cAAc,EAAE,eAAe,GAAG,IAAI,CAAC;IAErD;;OAEG;IACH,cAAc,CAAC,IAAI,EAAE,GAAG,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAEvD;;OAEG;IACH,gBAAgB,IAAI,IAAI,CAAC;CAC5B;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,uBAAuB,EAChE,cAAc,EAAE,aAAa,CAAC,CAAC,GAAG,qBAAqB,CAAC,GACzD,aAAa,CAAC,CAAC,CAAC,CAsblB"}

package/esm/base/react/legacy/withEntireDataView.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 // (C) 2019-2026 GoodData Corporation
-import { Component } from "react";
+import { useCallback, useEffect, useRef, useState } from "react";
 import { isEqual, omit } from "lodash-es";
 import { injectIntl } from "react-intl";
 import { isNoDataError, isUnexpectedResponseError, } from "@gooddata/sdk-backend-spi";
@@ -11,6 +11,23 @@ import { IntlWrapper } from "../../localization/IntlWrapper.js";
 import { DataViewFacade } from "../../results/facade.js";
 import { createExportErrorFunction, createExportFunction } from "../../vis/export.js";
 import { getAvailableDrillTargets } from "./availableDrillTargets.js";
+/**
+ * Applies the wrapped component's `defaultProps` the same way React did for class components: the default
+ * value is only used when the respective prop is `undefined`.
+ */
+function applyDefaultProps(props, defaultProps) {
+    const keys = Object.keys(defaultProps);
+    if (keys.every((key) => props[key] !== undefined)) {
+        return props;
+    }
+    const propsWithDefaults = { ...props };
+    keys.forEach((key) => {
+        if (propsWithDefaults[key] === undefined) {
+            propsWithDefaults[key] = defaultProps[key];
+        }
+    });
+    return propsWithDefaults;
+}
 /**
  * A HOC to wrap data visualization components with loading / error handling.
  *
@@ -22,99 +39,81 @@ import { getAvailableDrillTargets } from "./availableDrillTargets.js";
  * @internal
  */
 export function withEntireDataView(InnerComponent) {
-    class LoadingHOCWrapped extends Component {
-        static defaultProps = InnerComponent.defaultProps || {};
-        hasUnmounted = false;
-        abortController;
+    const innerDefaultProps = (InnerComponent.defaultProps || {});
+    function LoadingHOCWrapped(receivedProps) {
+        const props = applyDefaultProps(receivedProps, innerDefaultProps);
+        const [state, setState] = useState({
+            isLoading: false,
+            error: null,
+            executionResult: null,
+            dataView: null,
+        });
+        // refs holding the latest props and state, so that the (possibly async) callbacks below always work
+        // with the current values - the same way `this.props` and `this.state` did
+        const latestPropsRef = useRef(props);
+        latestPropsRef.current = props;
+        const latestStateRef = useRef(state);
+        latestStateRef.current = state;
+        const hasUnmounted = useRef(false);
+        const abortController = useRef(new AbortController());
         /**
          * Fingerprint of the last execution definition the initialize was called with.
          */
-        lastInitRequestFingerprint = null;
-        constructor(props) {
-            super(props);
-            this.state = {
-                isLoading: false,
-                error: null,
-                executionResult: null,
-                dataView: null,
-            };
-            this.onLoadingChanged = this.onLoadingChanged.bind(this);
-            this.onDataTooLarge = this.onDataTooLarge.bind(this);
-            this.onNegativeValues = this.onNegativeValues.bind(this);
-            this.onDataView = this.onDataView.bind(this);
-            this.abortController = new AbortController();
-        }
-        componentDidMount() {
-            void this.initDataLoading(this.props.execution, this.props.forecastConfig, this.props.outliersConfig, this.props.clusteringConfig);
-        }
-        render() {
-            const { isLoading, error, dataView, seType } = this.state;
-            const { intl } = this.props;
-            // lower-level components do not need workspace
-            const props = this.stripWorkspace(this.props);
-            return (_jsx(InnerComponent, { ...props, dataView: dataView, onDataTooLarge: this.onDataTooLarge, onNegativeValues: this.onNegativeValues, error: error, seType: seType, isLoading: isLoading, intl: intl }));
-        }
-        UNSAFE_componentWillReceiveProps(nextProps) {
-            //  we need strict equality here in case only the buckets changed (not measures or attributes)
-            if (!this.props.execution.equals(nextProps.execution) ||
-                !isEqual(this.props.forecastConfig, nextProps.forecastConfig) ||
-                !isEqual(this.props.clusteringConfig, nextProps.clusteringConfig) ||
-                !isEqual(this.props.outliersConfig, nextProps.outliersConfig)) {
-                this.refreshAbortController();
-                void this.initDataLoading(nextProps.execution, nextProps.forecastConfig, nextProps.outliersConfig, nextProps.clusteringConfig);
-            }
-        }
-        componentWillUnmount() {
-            this.hasUnmounted = true;
-            this.onLoadingChanged = () => { };
-            this.onDataView = () => { };
-            this.onError = () => { };
-            this.refreshAbortController();
-        }
-        refreshAbortController() {
-            if (this.props.enableExecutionCancelling) {
-                if (this.state.isLoading) {
-                    this.abortController.abort();
+        const lastInitRequestFingerprint = useRef(null);
+        const updateState = useCallback((newState) => {
+            setState((s) => ({ ...s, ...newState }));
+        }, []);
+        const refreshAbortController = useCallback(() => {
+            if (latestPropsRef.current.enableExecutionCancelling) {
+                if (latestStateRef.current.isLoading) {
+                    abortController.current.abort();
                 }
-                this.abortController = new AbortController();
+                abortController.current = new AbortController();
             }
-        }
-        onLoadingChanged(loadingState) {
-            const { onLoadingChanged } = this.props;
-            onLoadingChanged?.(loadingState);
+        }, []);
+        const onLoadingChanged = useCallback((loadingState) => {
+            if (hasUnmounted.current) {
+                return;
+            }
+            latestPropsRef.current.onLoadingChanged?.(loadingState);
             const { isLoading } = loadingState;
-            const state = { isLoading };
+            const newState = { isLoading };
             if (isLoading) {
-                state.error = null;
+                newState.error = null;
             }
-            this.setState(state);
-        }
-        onDataView(dataView) {
-            const { onDataView } = this.props;
-            onDataView?.(DataViewFacade.for(dataView));
-        }
-        onError(error) {
-            const { onExportReady } = this.props;
+            updateState(newState);
+        }, [updateState]);
+        const onDataView = useCallback((dataView) => {
+            if (hasUnmounted.current) {
+                return;
+            }
+            latestPropsRef.current.onDataView?.(DataViewFacade.for(dataView));
+        }, []);
+        const onError = useCallback((error) => {
+            if (hasUnmounted.current) {
+                return;
+            }
+            const { onExportReady } = latestPropsRef.current;
             if (!isForecastNotReceived(error) && !isClusteringNotReceived(error)) {
                 const err = error;
-                this.setState({ error: err.getMessage(), seType: err.seType, dataView: null });
+                updateState({ error: err.getMessage(), seType: err.seType, dataView: null });
             }
-            this.onLoadingChanged({ isLoading: false });
+            onLoadingChanged({ isLoading: false });
             if (onExportReady) {
                 onExportReady(createExportErrorFunction(error));
             }
-            this.props.onError?.(error);
-        }
-        onDataTooLarge(_data, errorMessage) {
-            this.onError(new DataTooLargeToDisplaySdkError(errorMessage));
-        }
-        onNegativeValues() {
-            this.onError(new NegativeValuesSdkError());
-        }
-        isRequestStale(fingerprint) {
-            return this.lastInitRequestFingerprint !== fingerprint || this.hasUnmounted;
-        }
-        async loadClusteringData(dataView, executionResult, clusteringConfig) {
+            latestPropsRef.current.onError?.(error);
+        }, [onLoadingChanged, updateState]);
+        const onDataTooLarge = useCallback((_data, errorMessage) => {
+            onError(new DataTooLargeToDisplaySdkError(errorMessage));
+        }, [onError]);
+        const onNegativeValues = useCallback(() => {
+            onError(new NegativeValuesSdkError());
+        }, [onError]);
+        const isRequestStale = useCallback((fingerprint) => {
+            return lastInitRequestFingerprint.current !== fingerprint || hasUnmounted.current;
+        }, []);
+        const loadClusteringData = useCallback(async (dataView, executionResult, clusteringConfig) => {
             let result = dataView.withClustering(clusteringConfig);
             try {
                 const clusteringResult = await executionResult.readClusteringAll(clusteringConfig);
@@ -131,13 +130,13 @@ export function withEntireDataView(InnerComponent) {
                 throw new ClusteringNotReceivedSdkError(err.responseBody?.reason || err.message || "Unknown error", err);
             }
             return result;
-        }
-        async loadForecastData(dataView, executionResult, forecastConfig) {
-            const { pushData } = this.props;
+        }, []);
+        const loadForecastData = useCallback(async (dataView, executionResult, forecastConfig) => {
+            const { pushData } = latestPropsRef.current;
             try {
                 const forecastResult = await executionResult.readForecastAll(dataView.forecastConfig);
                 const updatedDataView = dataView.withForecast(dataView.forecastConfig, forecastResult);
-                this.setState((s) => ({ ...s, dataView: updatedDataView }));
+                updateState({ dataView: updatedDataView });
                 if (pushData) {
                     pushData({
                         dataView: updatedDataView,
@@ -150,20 +149,20 @@ export function withEntireDataView(InnerComponent) {
             }
             catch (e) {
                 const updatedDataView = dataView.withForecast(undefined);
-                this.setState((s) => ({ ...s, dataView: updatedDataView }));
+                updateState({ dataView: updatedDataView });
                 if (pushData) {
                     pushData({ dataView: updatedDataView });
                 }
                 const err = e;
                 throw new ForecastNotReceivedSdkError(err.responseBody?.reason || err.message || "Unknown error", err);
             }
-        }
-        async loadOutliersData(dataView, executionResult, _outliersConfig) {
-            const { pushData } = this.props;
+        }, [updateState]);
+        const loadOutliersData = useCallback(async (dataView, executionResult, _outliersConfig) => {
+            const { pushData } = latestPropsRef.current;
             try {
                 const outliersResult = await executionResult.readOutliersAll(dataView.outliersConfig);
                 const updatedDataView = dataView.withOutliers(dataView.outliersConfig, outliersResult);
-                this.setState((s) => ({ ...s, dataView: updatedDataView }));
+                updateState({ dataView: updatedDataView });
                 if (pushData) {
                     pushData({
                         dataView: updatedDataView,
@@ -173,19 +172,19 @@ export function withEntireDataView(InnerComponent) {
             }
             catch (e) {
                 const updatedDataView = dataView.withForecast(undefined);
-                this.setState((s) => ({ ...s, dataView: updatedDataView }));
+                updateState({ dataView: updatedDataView });
                 if (pushData) {
                     pushData({ dataView: updatedDataView });
                 }
                 const err = e;
                 throw new ForecastNotReceivedSdkError(err.responseBody?.reason || err.message || "Unknown error", err);
             }
-        }
-        handleLoadingSuccess(dataView, executionResult) {
-            const { onExportReady, pushData, exportTitle } = this.props;
-            this.setState({ dataView, error: null, executionResult });
-            this.onLoadingChanged({ isLoading: false });
-            this.onDataView(dataView);
+        }, [updateState]);
+        const handleLoadingSuccess = useCallback((dataView, executionResult) => {
+            const { onExportReady, pushData, exportTitle } = latestPropsRef.current;
+            updateState({ dataView, error: null, executionResult });
+            onLoadingChanged({ isLoading: false });
+            onDataView(dataView);
             if (onExportReady) {
                 onExportReady(createExportFunction(dataView.result, exportTitle));
             }
@@ -193,12 +192,12 @@ export function withEntireDataView(InnerComponent) {
                 const availableDrillTargets = getAvailableDrillTargets(DataViewFacade.for(dataView));
                 pushData({ dataView, availableDrillTargets });
             }
-        }
-        handleLoadingError(error, fingerprint) {
-            if (this.isRequestStale(fingerprint)) {
+        }, [onDataView, onLoadingChanged, updateState]);
+        const handleLoadingError = useCallback((error, fingerprint) => {
+            if (isRequestStale(fingerprint)) {
                 return;
             }
-            const { pushData } = this.props;
+            const { pushData } = latestPropsRef.current;
             /*
              * There can be situations, where there is no data to visualize but the result / dataView contains
              * metadata essential for setup of drilling. Look for that and if available push up.
@@ -207,21 +206,21 @@ export function withEntireDataView(InnerComponent) {
                 const availableDrillTargets = getAvailableDrillTargets(DataViewFacade.for(error.dataView));
                 pushData({ availableDrillTargets });
             }
-            this.onError(convertError(error));
-        }
-        async initDataLoading(originalExecution, forecastConfig, outliersConfig, clusteringConfig) {
+            onError(convertError(error));
+        }, [isRequestStale, onError]);
+        const initDataLoading = useCallback(async (originalExecution, forecastConfig, outliersConfig, clusteringConfig) => {
             let execution = originalExecution;
-            if (this.props.enableExecutionCancelling) {
-                execution = execution.withSignal(this.abortController.signal);
+            if (latestPropsRef.current.enableExecutionCancelling) {
+                execution = execution.withSignal(abortController.current.signal);
             }
-            const { pushData } = this.props;
-            this.onLoadingChanged({ isLoading: true });
-            this.setState({ dataView: null });
+            const { pushData } = latestPropsRef.current;
+            onLoadingChanged({ isLoading: true });
+            updateState({ dataView: null });
             const fingerprint = defFingerprint(execution.definition);
-            this.lastInitRequestFingerprint = fingerprint;
+            lastInitRequestFingerprint.current = fingerprint;
             try {
                 const executionResult = await execution.execute();
-                if (this.isRequestStale(fingerprint)) {
+                if (isRequestStale(fingerprint)) {
                     return;
                 }
                 const originalDataView = await executionResult.readAll().catch((err) => {
@@ -236,7 +235,7 @@ export function withEntireDataView(InnerComponent) {
                     }
                     throw err;
                 });
-                if (this.isRequestStale(defFingerprint(originalDataView.definition))) {
+                if (isRequestStale(defFingerprint(originalDataView.definition))) {
                     /*
                      * Stop right now if the data are not relevant anymore because there was another
                      * initialize request in the meantime.
@@ -251,7 +250,7 @@ export function withEntireDataView(InnerComponent) {
                     dataView = dataView.withOutliers(outliersConfig);
                 }
                 if (clusteringConfig) {
-                    dataView = await this.loadClusteringData(originalDataView, executionResult, clusteringConfig);
+                    dataView = await loadClusteringData(originalDataView, executionResult, clusteringConfig);
                     if (forecastConfig) {
                         dataView = dataView.withForecast(forecastConfig);
                     }
@@ -259,29 +258,79 @@ export function withEntireDataView(InnerComponent) {
                         dataView = dataView.withOutliers(outliersConfig);
                     }
                 }
-                this.handleLoadingSuccess(dataView, executionResult);
-                if (this.hasUnmounted) {
+                handleLoadingSuccess(dataView, executionResult);
+                if (hasUnmounted.current) {
                     return;
                 }
                 if (dataView.forecastConfig && forecastConfig) {
-                    dataView = await this.loadForecastData(dataView, executionResult, forecastConfig);
+                    dataView = await loadForecastData(dataView, executionResult, forecastConfig);
                 }
                 if (dataView.outliersConfig && outliersConfig) {
-                    await this.loadOutliersData(dataView, executionResult, outliersConfig);
+                    await loadOutliersData(dataView, executionResult, outliersConfig);
                 }
             }
             catch (error) {
-                this.handleLoadingError(error, fingerprint);
+                handleLoadingError(error, fingerprint);
             }
-        }
-        stripWorkspace = (props) => {
-            return omit(props, ["workspace"]);
+        }, [
+            handleLoadingError,
+            handleLoadingSuccess,
+            isRequestStale,
+            loadClusteringData,
+            loadForecastData,
+            loadOutliersData,
+            onLoadingChanged,
+            updateState,
+        ]);
+        // componentDidMount & componentWillUnmount
+        useEffect(() => {
+            hasUnmounted.current = false;
+            void initDataLoading(props.execution, props.forecastConfig, props.outliersConfig, props.clusteringConfig);
+            return () => {
+                hasUnmounted.current = true;
+                refreshAbortController();
+            };
+            // eslint-disable-next-line react-hooks/exhaustive-deps
+        }, []);
+        // UNSAFE_componentWillReceiveProps; the props are compared with custom equality, hence the effect runs
+        // on every render and decides on its own whether the data must be loaded again
+        const isFirstEffectRunRef = useRef(true);
+        const prevRef = useRef({
+            execution: props.execution,
+            forecastConfig: props.forecastConfig,
+            outliersConfig: props.outliersConfig,
+            clusteringConfig: props.clusteringConfig,
+        });
+        useEffect(() => {
+            const { execution, forecastConfig, outliersConfig, clusteringConfig } = props;
+            if (isFirstEffectRunRef.current) {
+                // the mount effect above has already started the initial load
+                isFirstEffectRunRef.current = false;
+                return;
+            }
+            const prev = prevRef.current;
+            prevRef.current = { execution, forecastConfig, outliersConfig, clusteringConfig };
+            //  we need strict equality here in case only the buckets changed (not measures or attributes)
+            if (!prev.execution.equals(execution) ||
+                !isEqual(prev.forecastConfig, forecastConfig) ||
+                !isEqual(prev.clusteringConfig, clusteringConfig) ||
+                !isEqual(prev.outliersConfig, outliersConfig)) {
+                refreshAbortController();
+                void initDataLoading(execution, forecastConfig, outliersConfig, clusteringConfig);
+            }
+        });
+        const stripWorkspace = (allProps) => {
+            return omit(allProps, ["workspace"]);
         };
+        const { isLoading, error, dataView, seType } = state;
+        const { intl } = props;
+        // lower-level components do not need workspace
+        const innerProps = stripWorkspace(props);
+        return (_jsx(InnerComponent, { ...innerProps, dataView: dataView, onDataTooLarge: onDataTooLarge, onNegativeValues: onNegativeValues, error: error, seType: seType, isLoading: isLoading, intl: intl }));
     }
     const IntlLoadingHOC = injectIntl(LoadingHOCWrapped);
-    return class LoadingHOC extends Component {
-        render() {
-            return (_jsx(IntlWrapper, { locale: this.props.locale, children: _jsx(IntlLoadingHOC, { ...this.props }) }));
-        }
-    };
+    function LoadingHOC(props) {
+        return (_jsx(IntlWrapper, { locale: props.locale, children: _jsx(IntlLoadingHOC, { ...props }) }));
+    }
+    return LoadingHOC;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gooddata/sdk-ui",
-  "version": "11.53.0-alpha.0",
+  "version": "11.53.0-alpha.2",
   "description": "GoodData.UI SDK - Core",
   "license": "MIT",
   "author": "GoodData Corporation",
@@ -42,9 +42,9 @@
     "ts-invariant": "0.10.3",
     "tslib": "2.8.1",
     "uuid": "11.1.1",
-    "@gooddata/sdk-backend-spi": "11.53.0-alpha.0",
-    "@gooddata/sdk-model": "11.53.0-alpha.0",
-    "@gooddata/util": "11.53.0-alpha.0"
+    "@gooddata/sdk-backend-spi": "11.53.0-alpha.2",
+    "@gooddata/sdk-model": "11.53.0-alpha.2",
+    "@gooddata/util": "11.53.0-alpha.2"
   },
   "devDependencies": {
     "@microsoft/api-documenter": "^7.17.0",
@@ -87,13 +87,13 @@
     "typescript": "5.9.3",
     "vitest": "4.1.8",
     "vitest-dom": "0.1.1",
-    "@gooddata/i18n-toolkit": "11.53.0-alpha.0",
-    "@gooddata/oxlint-config": "11.53.0-alpha.0",
-    "@gooddata/eslint-config": "11.53.0-alpha.0",
-    "@gooddata/reference-workspace": "11.53.0-alpha.0",
-    "@gooddata/sdk-backend-base": "11.53.0-alpha.0",
-    "@gooddata/sdk-backend-mockingbird": "11.53.0-alpha.0",
-    "@gooddata/stylelint-config": "11.53.0-alpha.0"
+    "@gooddata/eslint-config": "11.53.0-alpha.2",
+    "@gooddata/i18n-toolkit": "11.53.0-alpha.2",
+    "@gooddata/oxlint-config": "11.53.0-alpha.2",
+    "@gooddata/sdk-backend-base": "11.53.0-alpha.2",
+    "@gooddata/sdk-backend-mockingbird": "11.53.0-alpha.2",
+    "@gooddata/reference-workspace": "11.53.0-alpha.2",
+    "@gooddata/stylelint-config": "11.53.0-alpha.2"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0",