@grafana/scenes 6.27.3--canary.1189.16466706909.0 → 6.28.0

package/dist/grafana-scenes-YMli37Xh.js

@@ -0,0 +1,153 @@
+'use strict';
+
+var grafanaScenes = {
+	"grafana-scenes": {
+	components: {
+		"adhoc-filter-pill": {
+			"edit-filter-with-key": "Editar filtro con la clave {{keyLabel}}",
+			"managed-filter": "Filtro gestionado de {{origin}}",
+			"remove-filter-with-key": "Eliminar filtro con la clave {{keyLabel}}"
+		},
+		"adhoc-filters-combobox": {
+			"remove-filter-value": "Eliminar valor del filtro: {{itemLabel}}",
+			"use-custom-value": "Usar valor personalizado: {{itemLabel}}"
+		},
+		"fallback-page": {
+			content: "Si ha llegado hasta aquí mediante un enlace, es posible que haya un error en esta aplicación.",
+			subTitle: "La URL no coincide con ninguna página",
+			title: "No se ha encontrado"
+		},
+		"nested-scene-renderer": {
+			"collapse-button-label": "Contraer escena",
+			"expand-button-label": "Expandir escena",
+			"remove-button-label": "Eliminar escena"
+		},
+		"scene-debugger": {
+			"object-details": "Detalles del objeto",
+			"scene-graph": "Gráfico de la escena",
+			"title-scene-debugger": "Depurador de escenas"
+		},
+		"scene-grid-row": {
+			"collapse-row": "Contraer fila",
+			"expand-row": "Expandir fila"
+		},
+		"scene-time-range-compare-renderer": {
+			"button-label": "Comparación",
+			"button-tooltip": "Habilitar comparación de intervalos de tiempo"
+		},
+		splitter: {
+			"aria-label-pane-resize-widget": "Widget de cambio de tamaño del panel"
+		},
+		"viz-panel": {
+			title: {
+				title: "Título"
+			}
+		},
+		"viz-panel-explore-button": {
+			explore: "Explorar"
+		},
+		"viz-panel-renderer": {
+			"loading-plugin-panel": "Cargando panel de plugins...",
+			"panel-plugin-has-no-panel-component": "El plugin del panel no tiene ningún componente de panel"
+		},
+		"viz-panel-series-limit": {
+			"content-rendering-series-single-panel-impact-performance": "Representar demasiadas series en un solo panel puede afectar al rendimiento y dificultar la lectura de los datos.",
+			"warning-message": "Mostrando solo {{seriesLimit}} serie(s)"
+		}
+	},
+	utils: {
+		"controls-label": {
+			"tooltip-remove": "Eliminar"
+		},
+		"loading-indicator": {
+			"content-cancel-query": "Cancelar consulta"
+		}
+	},
+	variables: {
+		"ad-hoc-combobox": {
+			"aria-label-edit-filter-operator": "Editar operador de filtro"
+		},
+		"ad-hoc-filter-builder": {
+			"aria-label-add-filter": "Añadir filtro",
+			"title-add-filter": "Añadir filtro"
+		},
+		"ad-hoc-filter-renderer": {
+			"aria-label-remove-filter": "Eliminar filtro",
+			"key-select": {
+				"placeholder-select-label": "Seleccionar etiqueta"
+			},
+			"label-select-label": "Seleccionar etiqueta",
+			"title-remove-filter": "Eliminar filtro",
+			"value-select": {
+				"placeholder-select-value": "Seleccionar valor"
+			}
+		},
+		"data-source-variable": {
+			label: {
+				"default": "predeterminada"
+			}
+		},
+		"default-group-by-custom-indicator-container": {
+			"aria-label-clear": "borrar",
+			tooltip: "Aplicado de forma predeterminada en este dashboard. Si se edita, se transfiere a otros dashboards.",
+			"tooltip-restore-groupby-set-by-this-dashboard": "Restaura la función groupby definida por este dashboard."
+		},
+		"format-registry": {
+			formats: {
+				description: {
+					"commaseparated-values": "Valores separados por comas",
+					"double-quoted-values": "Valores entre comillas dobles",
+					"format-date-in-different-ways": "Dar formato a la fecha de diferentes maneras",
+					"format-multivalued-variables-using-syntax-example": "Dar formato a las variables de múltiples valores con la sintaxis glob, por ejemplo, {value1,value2}",
+					"html-escaping-of-values": "Escape HTML de valores",
+					"json-stringify-value": "Valor de JSON stringify",
+					"keep-value-as-is": "Mantener el valor tal cual",
+					"multiple-values-are-formatted-like-variablevalue": "Los valores múltiples tienen el formato variable=valor",
+					"single-quoted-values": "Valores entre comillas simples",
+					"useful-escaping-values-taking-syntax-characters": "Útil para valores de escape URL, utilizando caracteres de sintaxis URI",
+					"useful-for-url-escaping-values": "Útil para valores de escape URL",
+					"values-are-separated-by-character": "Los valores están separados por el carácter |"
+				}
+			}
+		},
+		"group-by-variable-renderer": {
+			"aria-label-group-by-selector": "Agrupar por selector",
+			"placeholder-group-by-label": "Agrupar por etiqueta"
+		},
+		"interval-variable": {
+			"placeholder-select-value": "Seleccionar valor"
+		},
+		"loading-options-placeholder": {
+			"loading-options": "Cargando opciones..."
+		},
+		"multi-value-apply-button": {
+			apply: "Aplicar"
+		},
+		"no-options-placeholder": {
+			"no-options-found": "No se han encontrado opciones"
+		},
+		"options-error-placeholder": {
+			"error-occurred-fetching-labels-click-retry": "Se ha producido un error al recuperar las etiquetas. Haga clic para volver a intentarlo"
+		},
+		"test-object-with-variable-dependency": {
+			title: {
+				hello: "Hola"
+			}
+		},
+		"test-variable": {
+			text: {
+				text: "Texto"
+			}
+		},
+		"variable-value-input": {
+			"placeholder-enter-value": "Introducir valor"
+		},
+		"variable-value-select": {
+			"placeholder-select-value": "Seleccionar valor"
+		}
+	}
+}
+};
+
+exports.default = grafanaScenes;
+//# sourceMappingURL=grafana-scenes-YMli37Xh.js.map

package/dist/grafana-scenes-YMli37Xh.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"grafana-scenes-YMli37Xh.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/grafana-scenes-n10eQkNF.js

@@ -0,0 +1,153 @@
+'use strict';
+
+var grafanaScenes = {
+	"grafana-scenes": {
+	components: {
+		"adhoc-filter-pill": {
+			"edit-filter-with-key": "Filter mit Schlüssel {{keyLabel}} bearbeiten",
+			"managed-filter": "{{origin}} verwalteter Filter",
+			"remove-filter-with-key": "Filter mit Schlüssel {{keyLabel}} entfernen"
+		},
+		"adhoc-filters-combobox": {
+			"remove-filter-value": "Filterwert entfernen – {{itemLabel}}",
+			"use-custom-value": "Benutzerdefinierten Wert verwenden: {{itemLabel}}"
+		},
+		"fallback-page": {
+			content: "Wenn Sie über einen Link hierher gekommen sind, enthält diese Anwendung möglicherweise einen Fehler.",
+			subTitle: "Die URL stimmt mit keiner Seite überein",
+			title: "Nicht gefunden"
+		},
+		"nested-scene-renderer": {
+			"collapse-button-label": "Szene ausblenden",
+			"expand-button-label": "Szene einblenden",
+			"remove-button-label": "Szene entfernen"
+		},
+		"scene-debugger": {
+			"object-details": "Objektdetails",
+			"scene-graph": "Szenengraph",
+			"title-scene-debugger": "Szenen-Debugger"
+		},
+		"scene-grid-row": {
+			"collapse-row": "Zeile ausblenden",
+			"expand-row": "Zeile einblenden"
+		},
+		"scene-time-range-compare-renderer": {
+			"button-label": "Vergleich",
+			"button-tooltip": "Zeitrahmenvergleich aktivieren"
+		},
+		splitter: {
+			"aria-label-pane-resize-widget": "Widget zur Größenänderung des Bereichs"
+		},
+		"viz-panel": {
+			title: {
+				title: "Titel"
+			}
+		},
+		"viz-panel-explore-button": {
+			explore: "Entdecken"
+		},
+		"viz-panel-renderer": {
+			"loading-plugin-panel": "Plugin-Panel wird geladen …",
+			"panel-plugin-has-no-panel-component": "Das Panel-Plugin hat keine Panel-Komponente"
+		},
+		"viz-panel-series-limit": {
+			"content-rendering-series-single-panel-impact-performance": "Das Rendern von zu vielen Reihen in einem einzigen Panel kann die Leistung beeinträchtigen und das Lesen der Daten erschweren.",
+			"warning-message": "Es werden nur {{seriesLimit}} Reihen angezeigt"
+		}
+	},
+	utils: {
+		"controls-label": {
+			"tooltip-remove": "Entfernen"
+		},
+		"loading-indicator": {
+			"content-cancel-query": "Abfrage abbrechen"
+		}
+	},
+	variables: {
+		"ad-hoc-combobox": {
+			"aria-label-edit-filter-operator": "Filteroperator bearbeiten"
+		},
+		"ad-hoc-filter-builder": {
+			"aria-label-add-filter": "Filter hinzufügen",
+			"title-add-filter": "Filter hinzufügen"
+		},
+		"ad-hoc-filter-renderer": {
+			"aria-label-remove-filter": "Filter entfernen",
+			"key-select": {
+				"placeholder-select-label": "Label auswählen"
+			},
+			"label-select-label": "Label auswählen",
+			"title-remove-filter": "Filter entfernen",
+			"value-select": {
+				"placeholder-select-value": "Wert auswählen"
+			}
+		},
+		"data-source-variable": {
+			label: {
+				"default": "Standard"
+			}
+		},
+		"default-group-by-custom-indicator-container": {
+			"aria-label-clear": "löschen",
+			tooltip: "Wird in diesem Dashboard standardmäßig angewendet. Wenn es bearbeitet wird, wird es auf andere Dashboards übertragen.",
+			"tooltip-restore-groupby-set-by-this-dashboard": "Die Einstellung „Gruppieren nach“ von diesem Dashboard wiederherstellen."
+		},
+		"format-registry": {
+			formats: {
+				description: {
+					"commaseparated-values": "Kommagetrennte Werte",
+					"double-quoted-values": "Doppelt angegebene Werte",
+					"format-date-in-different-ways": "Datum auf verschiedene Arten formatieren",
+					"format-multivalued-variables-using-syntax-example": "Formatieren Sie mehrwertige Variablen mit der glob-Syntax, Beispiel {value1,value2}",
+					"html-escaping-of-values": "HTML-Escaping von Werten",
+					"json-stringify-value": "JSON-Stringify-Wert",
+					"keep-value-as-is": "Wert unverändert lassen",
+					"multiple-values-are-formatted-like-variablevalue": "Mehrere Werte werden als variable=value formatiert",
+					"single-quoted-values": "Einfach angegebene Werte",
+					"useful-escaping-values-taking-syntax-characters": "Nützlich für URL-Escaping-Werte, die URI-Syntaxzeichen nutzen",
+					"useful-for-url-escaping-values": "Nützlich für URL-Escaping-Werte",
+					"values-are-separated-by-character": "Werte werden durch das Zeichen | getrennt"
+				}
+			}
+		},
+		"group-by-variable-renderer": {
+			"aria-label-group-by-selector": "Nach Selektor gruppieren",
+			"placeholder-group-by-label": "Nach Label gruppieren"
+		},
+		"interval-variable": {
+			"placeholder-select-value": "Wert auswählen"
+		},
+		"loading-options-placeholder": {
+			"loading-options": "Optionen werden geladen …"
+		},
+		"multi-value-apply-button": {
+			apply: "Anwenden"
+		},
+		"no-options-placeholder": {
+			"no-options-found": "Keine Optionen gefunden"
+		},
+		"options-error-placeholder": {
+			"error-occurred-fetching-labels-click-retry": "Beim Abrufen der Label ist ein Fehler aufgetreten. Klicken Sie zum Wiederholen"
+		},
+		"test-object-with-variable-dependency": {
+			title: {
+				hello: "Hallo"
+			}
+		},
+		"test-variable": {
+			text: {
+				text: "Text"
+			}
+		},
+		"variable-value-input": {
+			"placeholder-enter-value": "Wert eingeben"
+		},
+		"variable-value-select": {
+			"placeholder-select-value": "Wert auswählen"
+		}
+	}
+}
+};
+
+exports.default = grafanaScenes;
+//# sourceMappingURL=grafana-scenes-n10eQkNF.js.map

package/dist/grafana-scenes-n10eQkNF.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"grafana-scenes-n10eQkNF.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/{grafana-scenes-DCHONTnD.js → grafana-scenes-uBsCv-Bu.js}

@@ -6,6 +6,7 @@ var grafanaScenes = {
 		"adhoc-filter-pill": {
 			"edit-filter-with-key": "Edit filter with key {{keyLabel}}",
 			"managed-filter": "{{origin}} managed filter",
+			"non-applicable": "Filter is not applicable",
 			"remove-filter-with-key": "Remove filter with key {{keyLabel}}"
 		},
 		"adhoc-filters-combobox": {
@@ -150,4 +151,4 @@ var grafanaScenes = {
 };
 
 exports.default = grafanaScenes;
-//# sourceMappingURL=grafana-scenes-DCHONTnD.js.map
+//# sourceMappingURL=grafana-scenes-uBsCv-Bu.js.map

package/dist/grafana-scenes-uBsCv-Bu.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"grafana-scenes-uBsCv-Bu.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/index.d.ts

@@ -858,6 +858,7 @@ interface AdHocFilterWithLabels<M extends Record<string, any> = {}> extends AdHo
     readOnly?: boolean;
     restorable?: boolean;
     nonApplicable?: boolean;
+    nonApplicableReason?: string;
 }
 type AdHocControlsLayout = ControlsLayout | 'combobox';
 type FilterOrigin = 'dashboard' | 'scope' | string;
@@ -988,7 +989,7 @@ declare class AdHocFiltersVariable extends SceneObjectBase<AdHocFiltersVariableS
     _removeFilter(filter: AdHocFilterWithLabels): void;
     _removeLastFilter(): void;
     _handleComboboxBackspace(filter: AdHocFilterWithLabels): void;
-    _verifyNonApplicableFilters(): Promise<never[] | undefined>;
+    _setStateWithFiltersApplicabilityCheck(update: Partial<AdHocFiltersVariableState>): Promise<void>;
     /**
      * Get possible keys given current filters. Do not call from plugins directly
      */

package/dist/index.js

@@ -5197,7 +5197,7 @@ const getStyles$c = (theme) => ({
     color: theme.colors.text.primary,
     boxShadow: theme.shadows.z2,
     overflowY: "auto",
-    zIndex: theme.zIndex.dropdown
+    zIndex: theme.zIndex.portal
   }),
   inputStyle: css.css({
     paddingBlock: 0,
@@ -5233,7 +5233,7 @@ const getStyles$c = (theme) => ({
 
 const LABEL_MAX_VISIBLE_LENGTH = 20;
 function AdHocFilterPill({ filter, model, readOnly, focusOnWipInputRef }) {
-  var _a, _b, _c;
+  var _a, _b, _c, _d;
   const styles = ui.useStyles2(getStyles$b);
   const [viewMode, setViewMode] = React.useState(true);
   const [shouldFocusOnPillWrapper, setShouldFocusOnPillWrapper] = React.useState(false);
@@ -5288,6 +5288,7 @@ function AdHocFilterPill({ filter, model, readOnly, focusOnWipInputRef }) {
       };
     }
   };
+  const cleanFilter = !filter.restorable && !filter.readOnly && !filter.nonApplicable;
   if (viewMode) {
     const pillTextContent = `${keyLabel} ${filter.operator} ${valueLabel}`;
     const pillText = /* @__PURE__ */ React__default.default.createElement("span", { className: css.cx(styles.pillText, filter.nonApplicable && styles.strikethrough) }, pillTextContent);
@@ -5369,7 +5370,7 @@ function AdHocFilterPill({ filter, model, readOnly, focusOnWipInputRef }) {
         },
         /* @__PURE__ */ React__default.default.createElement(ui.Icon, { name: "lock", size: "md", className: styles.readOnlyPillIcon })
       ),
-      filter.origin && !filter.restorable && !filter.readOnly && /* @__PURE__ */ React__default.default.createElement(ui.Tooltip, { content: getOriginFilterTooltips(filter.origin).info, placement: "bottom" }, /* @__PURE__ */ React__default.default.createElement(ui.Icon, { name: "info-circle", size: "md", className: styles.infoPillIcon })),
+      filter.origin && cleanFilter && /* @__PURE__ */ React__default.default.createElement(ui.Tooltip, { content: getOriginFilterTooltips(filter.origin).info, placement: "bottom" }, /* @__PURE__ */ React__default.default.createElement(ui.Icon, { name: "info-circle", size: "md", className: styles.infoPillIcon })),
       filter.origin && filter.restorable && !filter.readOnly && /* @__PURE__ */ React__default.default.createElement(
         ui.IconButton,
         {
@@ -5389,6 +5390,14 @@ function AdHocFilterPill({ filter, model, readOnly, focusOnWipInputRef }) {
           className: isMatchAllFilter(filter) ? styles.matchAllPillIcon : styles.pillIcon,
           tooltip: getOriginFilterTooltips(filter.origin).restore
         }
+      ),
+      filter.nonApplicable && /* @__PURE__ */ React__default.default.createElement(
+        ui.Tooltip,
+        {
+          content: (_d = filter.nonApplicableReason) != null ? _d : i18n.t("grafana-scenes.components.adhoc-filter-pill.non-applicable", "Filter is not applicable"),
+          placement: "bottom"
+        },
+        /* @__PURE__ */ React__default.default.createElement(ui.Icon, { name: "info-circle", size: "md", className: styles.infoPillIcon })
       )
     );
   }
@@ -5699,7 +5708,10 @@ class AdHocFiltersVariable extends SceneObjectBase {
     });
     this._urlSync = new AdHocFiltersVariableUrlSyncHandler(this);
     this._activationHandler = () => {
-      this._verifyNonApplicableFilters();
+      this._setStateWithFiltersApplicabilityCheck({
+        filters: this.state.filters,
+        originFilters: this.state.originFilters
+      });
       return () => {
         var _a;
         (_a = this.state.originFilters) == null ? void 0 : _a.forEach((filter) => {
@@ -5763,7 +5775,10 @@ class AdHocFiltersVariable extends SceneObjectBase {
       ...editedScopeFilters.filter((filter) => scopeFilterKeys.includes(filter.key)),
       ...scopeFilters.filter((filter) => !editedScopeFilterKeys.includes(filter.key))
     ];
-    this.setState({ originFilters: [...finalFilters, ...remainingFilters] });
+    this._setStateWithFiltersApplicabilityCheck({
+      filters: this.state.filters,
+      originFilters: [...finalFilters, ...remainingFilters]
+    });
     this._prevScopes = scopes;
   }
   setState(update) {
@@ -5844,7 +5859,11 @@ class AdHocFiltersVariable extends SceneObjectBase {
     }
     if (filter === _wip) {
       if ("value" in update && update["value"] !== "") {
-        this.setState({ filters: [...filters, { ..._wip, ...update }], _wip: void 0 });
+        this._setStateWithFiltersApplicabilityCheck({
+          filters: [...filters, { ..._wip, ...update }],
+          originFilters: this.state.originFilters,
+          _wip: void 0
+        });
       } else {
         this.setState({ _wip: { ...filter, ...update } });
       }
@@ -5871,7 +5890,10 @@ class AdHocFiltersVariable extends SceneObjectBase {
       this.setState({ _wip: void 0 });
       return;
     }
-    this.setState({ filters: this.state.filters.filter((f) => f !== filter) });
+    this._setStateWithFiltersApplicabilityCheck({
+      filters: this.state.filters.filter((f) => f !== filter),
+      originFilters: this.state.originFilters
+    });
   }
   _removeLastFilter() {
     const filterToRemove = this.state.filters.at(-1);
@@ -5927,46 +5949,51 @@ class AdHocFiltersVariable extends SceneObjectBase {
       });
     }
   }
-  async _verifyNonApplicableFilters() {
-    var _a, _b, _c;
-    const filters = [...this.state.filters, ...(_a = this.state.originFilters) != null ? _a : []];
+  async _setStateWithFiltersApplicabilityCheck(update) {
+    var _a, _b;
     const ds = await this._dataSourceSrv.get(this.state.datasource, this._scopedVars);
-    if (!ds || !ds.getApplicableFilters) {
-      return [];
+    if (!ds || !ds.getFiltersApplicability) {
+      this.setState(update);
+      return;
+    }
+    if (!update.filters) {
+      return;
     }
     const timeRange = sceneGraph.getTimeRange(this).state.value;
     const queries = this.state.useQueriesAsFilterForOptions ? getQueriesForVariables(this) : void 0;
-    const response = await ds.getApplicableFilters({
-      filters,
+    const response = await ds.getFiltersApplicability({
+      filters: [...update.filters, ...(_a = update.originFilters) != null ? _a : []],
       queries,
       timeRange,
       scopes: sceneGraph.getScopes(this),
       ...getEnrichedFiltersRequest(this)
     });
-    const update = {
-      filters: [...this.state.filters],
-      originFilters: [...(_b = this.state.originFilters) != null ? _b : []]
-    };
+    const responseMap = /* @__PURE__ */ new Map();
+    response.forEach((filter) => {
+      responseMap.set(`${filter.key}${filter.origin ? `-${filter.origin}` : ""}`, filter);
+    });
     update.filters.forEach((f) => {
-      const isApplicable = response.includes(f.key);
-      if (!isApplicable) {
-        f.nonApplicable = true;
+      const filter = responseMap.get(f.key);
+      if (filter) {
+        f.nonApplicable = !filter.applicable;
+        f.nonApplicableReason = filter.reason;
       }
     });
-    (_c = update.originFilters) == null ? void 0 : _c.forEach((f) => {
-      const isApplicable = response.includes(f.key);
-      if (!isApplicable) {
+    (_b = update.originFilters) == null ? void 0 : _b.forEach((f) => {
+      const filter = responseMap.get(`${f.key}-${f.origin}`);
+      if (filter) {
         if (!f.matchAllFilter) {
-          f.nonApplicable = true;
+          f.nonApplicable = !filter.applicable;
+          f.nonApplicableReason = filter.reason;
         }
         const originalValue = this._originalValues.get(`${f.key}-${f.origin}`);
         if (originalValue) {
-          originalValue.nonApplicable = true;
+          originalValue.nonApplicable = !filter.applicable;
+          originalValue.nonApplicableReason = filter == null ? void 0 : filter.reason;
         }
       }
     });
     this.setState(update);
-    return;
   }
   /**
    * Get possible keys given current filters. Do not call from plugins directly
@@ -10928,7 +10955,6 @@ function VizPanelMenuRenderer({ model }) {
             ui.Menu.Item,
             {
               key: item.text,
-              role: "menuitem",
               label: item.text,
               icon: item.iconClassName,
               childItems: item.subMenu ? renderItems(item.subMenu) : void 0,
@@ -14420,7 +14446,25 @@ const VizConfigBuilders = {
 
 function __variableDynamicImportRuntime0__(path) {
   switch (path) {
-    case '../locales/en-US/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-DCHONTnD.js'); });
+    case '../locales/cs-CZ/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-CY85TD5F.js'); });
+    case '../locales/de-DE/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-n10eQkNF.js'); });
+    case '../locales/en-US/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-uBsCv-Bu.js'); });
+    case '../locales/es-ES/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-YMli37Xh.js'); });
+    case '../locales/fr-FR/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-DXM1LI4B.js'); });
+    case '../locales/hu-HU/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-DlUSL8jI.js'); });
+    case '../locales/id-ID/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-D5qs_fc9.js'); });
+    case '../locales/it-IT/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-Dy2CLUY9.js'); });
+    case '../locales/ja-JP/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-CBRfJ-2H.js'); });
+    case '../locales/ko-KR/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-CgIzGE5F.js'); });
+    case '../locales/nl-NL/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-Br6NPcwR.js'); });
+    case '../locales/pl-PL/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-B3ypGD5T.js'); });
+    case '../locales/pt-BR/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-COr0P0oM.js'); });
+    case '../locales/pt-PT/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-Cub9Gl0n.js'); });
+    case '../locales/ru-RU/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-BGCbMCFm.js'); });
+    case '../locales/sv-SE/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-CqRf9pRc.js'); });
+    case '../locales/tr-TR/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-CeVkPanY.js'); });
+    case '../locales/zh-Hans/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-DObtL2WT.js'); });
+    case '../locales/zh-Hant/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-B0JDDOYY.js'); });
     default: return new Promise(function(resolve, reject) {
       (typeof queueMicrotask === 'function' ? queueMicrotask : setTimeout)(
         reject.bind(null, new Error("Unknown variable dynamic import: " + path))