@grafana/scenes 6.11.1 → 6.12.0--canary.1121.15045230319.0

package/dist/esm/variables/variants/ScopesVariable.js

@@ -0,0 +1,80 @@
+import { SceneObjectBase } from '../../core/SceneObjectBase.js';
+import { SceneVariableValueChangedEvent } from '../types.js';
+import { ScopesContext } from '@grafana/runtime';
+import React, { useContext, useEffect } from 'react';
+import { VariableHide } from '@grafana/schema';
+import { SCOPES_VARIABLE_NAME } from '../constants.js';
+
+class ScopesVariable extends SceneObjectBase {
+  constructor(state) {
+    super({
+      skipUrlSync: true,
+      loading: true,
+      scopes: [],
+      ...state,
+      type: "system",
+      name: SCOPES_VARIABLE_NAME,
+      hide: VariableHide.hideVariable
+    });
+    this._renderBeforeActivation = true;
+  }
+  /**
+   * Temporary simple implementation to stringify the scopes.
+   */
+  getValue(fieldPath) {
+    var _a;
+    const scopes = (_a = this.state.scopes) != null ? _a : [];
+    const scopeNames = scopes.map((scope) => scope.metadata.name);
+    return scopeNames.join(", ");
+  }
+  getScopes() {
+    return this.state.scopes;
+  }
+  /**
+   * This method is used to keep the context up to date with the scopes context received from React
+   * 1) Subscribes to ScopesContext state changes and synchronizes it with the variable state
+   * 2) Handles enable / disabling of scopes based on variable enable option.
+   */
+  setContext(context) {
+    if (!context) {
+      return;
+    }
+    this._context = context;
+    const oldState = context.state;
+    if (this.state.enable != null) {
+      context.setEnabled(this.state.enable);
+    }
+    const sub = context.stateObservable.subscribe((state) => {
+      this.updateStateFromContext(state);
+    });
+    return () => {
+      sub.unsubscribe();
+      if (this.state.enable != null) {
+        context.setEnabled(oldState.enabled);
+      }
+    };
+  }
+  updateStateFromContext(state) {
+    const loading = state.value.length === 0 ? false : state.loading;
+    this.setState({ scopes: state.value, loading });
+    if (!loading) {
+      this.publishEvent(new SceneVariableValueChangedEvent(this), true);
+    }
+  }
+  /**
+   * Special function that enables variables to be hidden but still render to access react contexts
+   */
+  hiddenRender() {
+    return /* @__PURE__ */ React.createElement(ScopesVariableRenderer, { model: this });
+  }
+}
+function ScopesVariableRenderer({ model }) {
+  const context = useContext(ScopesContext);
+  useEffect(() => {
+    return model.setContext(context);
+  }, [context, model]);
+  return null;
+}
+
+export { ScopesVariable };
+//# sourceMappingURL=ScopesVariable.js.map

package/dist/esm/variables/variants/ScopesVariable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScopesVariable.js","sources":["../../../../src/variables/variants/ScopesVariable.tsx"],"sourcesContent":["import { SceneObjectBase } from '../../core/SceneObjectBase';\nimport { SceneVariable, SceneVariableState, SceneVariableValueChangedEvent, VariableValue } from '../types';\nimport { Scope } from '@grafana/data';\nimport { SceneComponentProps } from '../../core/types';\nimport { ScopesContext, ScopesContextValue } from '@grafana/runtime';\nimport React, { ReactNode, useContext, useEffect } from 'react';\nimport { VariableHide } from '@grafana/schema';\nimport { SCOPES_VARIABLE_NAME } from '../constants';\n\nexport interface ScopesVariableState extends SceneVariableState {\n  /**\n   * Last captured state from ScopesContext\n   */\n  scopes: Scope[];\n  /**\n   * Set to true if you want to the variable to enable / disable scopes when activated / deactivated\n   */\n  enable?: boolean;\n}\n\nexport class ScopesVariable extends SceneObjectBase<ScopesVariableState> implements SceneVariable<ScopesVariableState> {\n  protected _renderBeforeActivation = true;\n  protected _context: ScopesContextValue | undefined;\n\n  public constructor(state: Partial<ScopesVariableState>) {\n    super({\n      skipUrlSync: true,\n      loading: true,\n      scopes: [],\n      ...state,\n      type: 'system',\n      name: SCOPES_VARIABLE_NAME,\n      hide: VariableHide.hideVariable,\n    });\n  }\n\n  /**\n   * Temporary simple implementation to stringify the scopes.\n   */\n  public getValue(fieldPath: string): VariableValue {\n    const scopes = this.state.scopes ?? [];\n    const scopeNames = scopes.map((scope) => scope.metadata.name);\n    return scopeNames.join(', ');\n  }\n\n  public getScopes(): Scope[] | undefined {\n    return this.state.scopes;\n  }\n\n  /**\n   * This method is used to keep the context up to date with the scopes context received from React\n   * 1) Subscribes to ScopesContext state changes and synchronizes it with the variable state\n   * 2) Handles enable / disabling of scopes based on variable enable option.\n   */\n  public setContext(context: ScopesContextValue | undefined) {\n    if (!context) {\n      return;\n    }\n\n    this._context = context;\n\n    const oldState = context.state;\n\n    // Update scopes enable state if state.enable is defined\n    if (this.state.enable != null) {\n      context.setEnabled(this.state.enable);\n    }\n\n    // Subscribe to context state changes\n    const sub = context.stateObservable.subscribe((state) => {\n      this.updateStateFromContext(state);\n    });\n\n    return () => {\n      sub.unsubscribe();\n\n      if (this.state.enable != null) {\n        context.setEnabled(oldState.enabled);\n      }\n    };\n  }\n\n  public updateStateFromContext(state: { loading: boolean; value: Scope[] }) {\n    // There was logic in SceneQueryRunner that said if there are no scopes then loading state should not block query execution\n    const loading = state.value.length === 0 ? false : state.loading;\n    this.setState({ scopes: state.value, loading });\n\n    if (!loading) {\n      this.publishEvent(new SceneVariableValueChangedEvent(this), true);\n    }\n  }\n\n  /**\n   * Special function that enables variables to be hidden but still render to access react contexts\n   */\n  public hiddenRender(): ReactNode {\n    return <ScopesVariableRenderer model={this} />;\n  }\n}\n\nfunction ScopesVariableRenderer({ model }: SceneComponentProps<ScopesVariable>) {\n  const context = useContext(ScopesContext);\n\n  useEffect(() => {\n    return model.setContext(context);\n  }, [context, model]);\n\n  return null;\n}\n"],"names":[],"mappings":";;;;;;;AAoBO,MAAM,uBAAuB,eAAmF,CAAA;AAAA,EAI9G,YAAY,KAAqC,EAAA;AACtD,IAAM,KAAA,CAAA;AAAA,MACJ,WAAa,EAAA,IAAA;AAAA,MACb,OAAS,EAAA,IAAA;AAAA,MACT,QAAQ,EAAC;AAAA,MACT,GAAG,KAAA;AAAA,MACH,IAAM,EAAA,QAAA;AAAA,MACN,IAAM,EAAA,oBAAA;AAAA,MACN,MAAM,YAAa,CAAA;AAAA,KACpB,CAAA;AAZH,IAAA,IAAA,CAAU,uBAA0B,GAAA,IAAA;AAAA;AAapC;AAAA;AAAA;AAAA,EAKO,SAAS,SAAkC,EAAA;AAvCpD,IAAA,IAAA,EAAA;AAwCI,IAAA,MAAM,MAAS,GAAA,CAAA,EAAA,GAAA,IAAA,CAAK,KAAM,CAAA,MAAA,KAAX,YAAqB,EAAC;AACrC,IAAA,MAAM,aAAa,MAAO,CAAA,GAAA,CAAI,CAAC,KAAU,KAAA,KAAA,CAAM,SAAS,IAAI,CAAA;AAC5D,IAAO,OAAA,UAAA,CAAW,KAAK,IAAI,CAAA;AAAA;AAC7B,EAEO,SAAiC,GAAA;AACtC,IAAA,OAAO,KAAK,KAAM,CAAA,MAAA;AAAA;AACpB;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,WAAW,OAAyC,EAAA;AACzD,IAAA,IAAI,CAAC,OAAS,EAAA;AACZ,MAAA;AAAA;AAGF,IAAA,IAAA,CAAK,QAAW,GAAA,OAAA;AAEhB,IAAA,MAAM,WAAW,OAAQ,CAAA,KAAA;AAGzB,IAAI,IAAA,IAAA,CAAK,KAAM,CAAA,MAAA,IAAU,IAAM,EAAA;AAC7B,MAAQ,OAAA,CAAA,UAAA,CAAW,IAAK,CAAA,KAAA,CAAM,MAAM,CAAA;AAAA;AAItC,IAAA,MAAM,GAAM,GAAA,OAAA,CAAQ,eAAgB,CAAA,SAAA,CAAU,CAAC,KAAU,KAAA;AACvD,MAAA,IAAA,CAAK,uBAAuB,KAAK,CAAA;AAAA,KAClC,CAAA;AAED,IAAA,OAAO,MAAM;AACX,MAAA,GAAA,CAAI,WAAY,EAAA;AAEhB,MAAI,IAAA,IAAA,CAAK,KAAM,CAAA,MAAA,IAAU,IAAM,EAAA;AAC7B,QAAQ,OAAA,CAAA,UAAA,CAAW,SAAS,OAAO,CAAA;AAAA;AACrC,KACF;AAAA;AACF,EAEO,uBAAuB,KAA6C,EAAA;AAEzE,IAAA,MAAM,UAAU,KAAM,CAAA,KAAA,CAAM,MAAW,KAAA,CAAA,GAAI,QAAQ,KAAM,CAAA,OAAA;AACzD,IAAA,IAAA,CAAK,SAAS,EAAE,MAAA,EAAQ,KAAM,CAAA,KAAA,EAAO,SAAS,CAAA;AAE9C,IAAA,IAAI,CAAC,OAAS,EAAA;AACZ,MAAA,IAAA,CAAK,YAAa,CAAA,IAAI,8BAA+B,CAAA,IAAI,GAAG,IAAI,CAAA;AAAA;AAClE;AACF;AAAA;AAAA;AAAA,EAKO,YAA0B,GAAA;AAC/B,IAAO,uBAAA,KAAA,CAAA,aAAA,CAAC,sBAAuB,EAAA,EAAA,KAAA,EAAO,IAAM,EAAA,CAAA;AAAA;AAEhD;AAEA,SAAS,sBAAA,CAAuB,EAAE,KAAA,EAA8C,EAAA;AAC9E,EAAM,MAAA,OAAA,GAAU,WAAW,aAAa,CAAA;AAExC,EAAA,SAAA,CAAU,MAAM;AACd,IAAO,OAAA,KAAA,CAAM,WAAW,OAAO,CAAA;AAAA,GAC9B,EAAA,CAAC,OAAS,EAAA,KAAK,CAAC,CAAA;AAEnB,EAAO,OAAA,IAAA;AACT;;;;"}

package/dist/index.d.ts

@@ -1,13 +1,13 @@
 import * as _grafana_data from '@grafana/data';
-import { BusEventWithPayload, EventBus, BusEvent, BusEventType, BusEventHandler, PanelMenuItem, FieldConfigSource, PanelPlugin, AbsoluteTimeRange, PanelData, InterpolateFunction, PanelModel, TimeRange, DataTransformContext, DataFrame, DataQueryRequest, DataSourceGetTagKeysOptions, DataSourceGetTagValuesOptions, Scope, IconName, PageLayoutType, UrlQueryMap, DataQuery as DataQuery$1, DataSourceApi, Registry, RegistryItem, ScopedVars, AdHocVariableFilter, GetTagResponse, MetricFindValue, SelectableValue, VariableRefresh as VariableRefresh$1, VariableSort, EventFilterOptions, AnnotationEvent, AnnotationQuery, DataTransformerConfig, TimeOption, FieldConfig, FieldType, FieldValueMatcherConfig, ScopedVar, RawTimeRange } from '@grafana/data';
+import { BusEventWithPayload, EventBus, BusEvent, BusEventType, BusEventHandler, PanelMenuItem, FieldConfigSource, PanelPlugin, AbsoluteTimeRange, PanelData, InterpolateFunction, PanelModel, TimeRange, DataTransformContext, DataFrame, DataQueryRequest, DataSourceGetTagKeysOptions, DataSourceGetTagValuesOptions, IconName, PageLayoutType, UrlQueryMap, DataQuery as DataQuery$1, DataSourceApi, Registry, RegistryItem, ScopedVars, AdHocVariableFilter, GetTagResponse, MetricFindValue, SelectableValue, VariableRefresh as VariableRefresh$1, VariableSort, Scope, EventFilterOptions, AnnotationEvent, AnnotationQuery, DataTransformerConfig, TimeOption, FieldConfig, FieldType, FieldValueMatcherConfig, ScopedVar, RawTimeRange } from '@grafana/data';
 import * as React$1 from 'react';
-import React__default, { ComponentType, CSSProperties, PointerEvent, ForwardRefExoticComponent } from 'react';
+import React__default, { ComponentType, ReactNode, CSSProperties, PointerEvent, ForwardRefExoticComponent } from 'react';
 import * as rxjs from 'rxjs';
 import { Observable, Subscription, Unsubscribable, MonoTypeOperatorFunction, ReplaySubject } from 'rxjs';
 import * as _grafana_schema from '@grafana/schema';
 import { VariableType, VariableHide, TimeZone, DataQuery, DataTopic, DataSourceRef, VariableRefresh, LoadingState, DashboardCursorSync, MatcherConfig, TableFieldOptions } from '@grafana/schema';
 import { PanelContext, WeekStart, IconName as IconName$1 } from '@grafana/ui';
-import { ScopesContextValue, LocationService, VariableInterpolation } from '@grafana/runtime';
+import { LocationService, VariableInterpolation, ScopesContextValue } from '@grafana/runtime';
 import { Location } from 'history';
 import ReactGridLayout from 'react-grid-layout';
 import { Options, FieldConfig as FieldConfig$1 } from '@grafana/schema/dist/esm/raw/composable/barchart/panelcfg/x/BarChartPanelCfg_types.gen';
@@ -63,6 +63,10 @@ interface SceneVariable<TState extends SceneVariableState = SceneVariableState>
      * Allows cancelling variable execution.
      */
     onCancel?(): void;
+    /**
+     * Edge case for variables that is hidden but wants to be render to access react contexts (ScopesVariable)
+     */
+    hiddenRender?(): React.ReactNode;
     /**
      * @experimental
      * Indicates that a variable loads values lazily when user interacts with the variable dropdown.
@@ -275,6 +279,10 @@ interface VariableDependencyConfigOptions<TState extends SceneObjectState> {
      * Handle time macros.
      */
     handleTimeMacros?: boolean;
+    /**
+     * Depends on scopes
+     */
+    dependsOnScopes?: boolean;
 }
 declare class VariableDependencyConfig<TState extends SceneObjectState> implements SceneVariableDependencyConfigLike {
     private _sceneObject;
@@ -366,7 +374,7 @@ interface VizPanelState<TOptions = {}, TFieldConfig = {}> extends SceneObjectSta
 }
 declare class VizPanel<TOptions = {}, TFieldConfig extends {} = {}> extends SceneObjectBase<VizPanelState<TOptions, TFieldConfig>> {
     static Component: typeof VizPanelRenderer;
-    protected _variableDependency: VariableDependencyConfig<VizPanelState<{}, {}>>;
+    protected _variableDependency: VariableDependencyConfig<VizPanelState<TOptions, TFieldConfig>>;
     protected _panelContext?: PanelContext;
     private _plugin?;
     private _prevData?;
@@ -406,7 +414,7 @@ declare class VizPanel<TOptions = {}, TFieldConfig extends {} = {}> extends Scen
     private _onSeriesVisibilityChange;
     private _onInstanceStateChange;
     private _onToggleLegendSort;
-    clone(withState?: Partial<VizPanelState>): this;
+    clone(): this;
     private buildPanelContext;
 }
 
@@ -651,36 +659,6 @@ declare class EmbeddedScene extends SceneObjectBase<EmbeddedSceneState> {
 }
 declare function EmbeddedSceneRenderer({ model }: SceneComponentProps<EmbeddedScene>): React__default.JSX.Element;
 
-declare class SceneScopesBridge extends SceneObjectBase {
-    static Component: typeof SceneScopesBridgeRenderer;
-    protected _renderBeforeActivation: boolean;
-    private _contextSubject;
-    getValue(): Scope[];
-    /**
-     * Emits values of the selected scopes array. It emits the current value and the previous value if there is a change.
-     * @param cb
-     */
-    subscribeToValue(cb: (newScopes: Scope[], prevScopes: Scope[]) => void): Unsubscribable;
-    isLoading(): boolean;
-    subscribeToLoading(cb: (loading: boolean) => void): Unsubscribable;
-    setEnabled(enabled: boolean): void;
-    setReadOnly(readOnly: boolean): void;
-    /**
-     * This method is used to keep the context up to date with the scopes context received from React
-     *
-     * Its rationale is:
-     *   - When a new context is available, check if we have pending scopes passed from the URL
-     *      - If we have pending scopes, ask the new context to load them
-     *      - The loading should happen in a setTimeout to allow the existing context to pass its values to the URL sync handler
-     *   - If a new context is received, propagate it as a new value in the behavior subject
-     *   - If a new value is received, force a re-render to trigger the URL sync handler
-     */
-    updateContext(newContext: ScopesContextValue | undefined): void;
-    private get context();
-    private get contextObservable();
-}
-declare function SceneScopesBridgeRenderer({ model }: SceneComponentProps<SceneScopesBridge>): null;
-
 interface SceneRouteMatch<Params extends {
     [K in keyof Params]?: string;
 } = {}> {
@@ -693,7 +671,6 @@ interface SceneAppState extends SceneObjectState {
     pages: SceneAppPageLike[];
     name?: string;
     urlSyncOptions?: SceneUrlSyncOptions;
-    scopesBridge?: SceneScopesBridge;
 }
 interface SceneAppRoute {
     path: string;
@@ -738,7 +715,6 @@ interface SceneAppPageState extends SceneObjectState {
      */
     getFallbackPage?: () => SceneAppPageLike;
     layout?: PageLayoutType;
-    useScopes?: boolean;
 }
 interface SceneAppPageLike extends SceneObject<SceneAppPageState>, DataRequestEnricher {
     initializeScene(scene: SceneObject): void;
@@ -966,8 +942,9 @@ declare class AdHocFiltersVariable extends SceneObjectBase<AdHocFiltersVariableS
     static Component: typeof AdHocFiltersVariableRenderer;
     private _scopedVars;
     private _dataSourceSrv;
-    private _scopesBridge;
     private _originalValues;
+    /** Needed for scopes dependency */
+    protected _variableDependency: VariableDependencyConfig<AdHocFiltersVariableState>;
     protected _urlSync: AdHocFiltersVariableUrlSyncHandler;
     constructor(state: Partial<AdHocFiltersVariableState>);
     private _activationHandler;
@@ -1220,7 +1197,6 @@ declare class GroupByVariable extends MultiValueVariable<GroupByVariableState> {
     static Component: typeof GroupByVariableRenderer;
     isLazy: boolean;
     protected _urlSync: SceneObjectUrlSyncHandler;
-    private _scopesBridge;
     validateAndUpdate(): Observable<ValidateAndUpdateResult>;
     private _updateValueGivenNewOptions;
     getValueOptions(args: VariableGetOptionsArgs): Observable<VariableValueOption[]>;
@@ -1417,9 +1393,9 @@ declare function getAncestor<ParentType>(sceneObject: SceneObject, ancestorType:
  */
 declare function findDescendents<T extends SceneObject>(scene: SceneObject, descendentType: SceneType<T>): T[];
 /**
- * Will walk up the scene object graph to the closest $scopesBridge scene object
+ * Will return the scopes from the scopes variable if available.
  */
-declare function getScopesBridge(sceneObject: SceneObject): SceneScopesBridge | undefined;
+declare function getScopes(sceneObject: SceneObject): Scope[] | undefined;
 
 declare const sceneGraph: {
     getVariables: typeof getVariables;
@@ -1437,7 +1413,7 @@ declare const sceneGraph: {
     getAncestor: typeof getAncestor;
     getQueryController: typeof getQueryController;
     findDescendents: typeof findDescendents;
-    getScopesBridge: typeof getScopesBridge;
+    getScopes: typeof getScopes;
 };
 
 interface ActWhenVariableChangedState extends SceneObjectState {
@@ -1704,8 +1680,6 @@ declare class SceneQueryRunner extends SceneObjectBase<QueryRunnerState> impleme
     private _dataLayersMerger;
     private _timeSub?;
     private _timeSubRange?;
-    private _scopesSub?;
-    private _scopesSubBridge?;
     private _containerWidth?;
     private _variableValueRecorder;
     private _results;
@@ -1744,12 +1718,11 @@ declare class SceneQueryRunner extends SceneObjectBase<QueryRunnerState> impleme
     private _onDeactivate;
     setContainerWidth(width: number): void;
     isDataReadyToDisplay(): boolean;
-    private subscribeToScopesChanges;
     private subscribeToTimeRangeChanges;
     runQueries(): void;
     private getMaxDataPoints;
     cancelQuery(): void;
-    private runWithTimeRangeAndScopes;
+    private runWithTimeRange;
     clone(withState?: Partial<QueryRunnerState>): this;
     private prepareRequests;
     private onDataReceived;
@@ -1884,7 +1857,7 @@ interface VariableSelectProps {
     /** To provide an option to hide the label in the variable value selector */
     hideLabel?: boolean;
 }
-declare function VariableValueSelectWrapper({ variable, layout, showAlways, hideLabel }: VariableSelectProps): React__default.JSX.Element | null;
+declare function VariableValueSelectWrapper({ variable, layout, showAlways, hideLabel }: VariableSelectProps): string | number | boolean | React__default.JSX.Element | Iterable<React__default.ReactNode> | null | undefined;
 
 interface VariableValueControlState extends SceneObjectState {
     layout?: ControlsLayout;
@@ -1899,8 +1872,6 @@ declare class VariableValueControl extends SceneObjectBase<VariableValueControlS
 declare function VariableValueControlRenderer({ model }: SceneComponentProps<VariableValueControl>): React__default.JSX.Element | null;
 
 declare class SceneVariableSet extends SceneObjectBase<SceneVariableSetState> implements SceneVariables {
-    /** Variables that have changed in since the activation or since the first manual value change */
-    private _variablesThatHaveChanged;
     /** Variables that are scheduled to be validated and updated */
     private _variablesToUpdate;
     /** Variables currently updating  */
@@ -2003,6 +1974,41 @@ declare class TestVariable extends MultiValueVariable<TestVariableState> {
     static Component: ({ model }: SceneComponentProps<MultiValueVariable>) => React__default.JSX.Element;
 }
 
+interface ScopesVariableState extends SceneVariableState {
+    /**
+     * Last captured state from ScopesContext
+     */
+    scopes: Scope[];
+    /**
+     * Set to true if you want to the variable to enable / disable scopes when activated / deactivated
+     */
+    enable?: boolean;
+}
+declare class ScopesVariable extends SceneObjectBase<ScopesVariableState> implements SceneVariable<ScopesVariableState> {
+    protected _renderBeforeActivation: boolean;
+    protected _context: ScopesContextValue | undefined;
+    constructor(state: Partial<ScopesVariableState>);
+    /**
+     * Temporary simple implementation to stringify the scopes.
+     */
+    getValue(fieldPath: string): VariableValue;
+    getScopes(): Scope[] | undefined;
+    /**
+     * This method is used to keep the context up to date with the scopes context received from React
+     * 1) Subscribes to ScopesContext state changes and synchronizes it with the variable state
+     * 2) Handles enable / disabling of scopes based on variable enable option.
+     */
+    setContext(context: ScopesContextValue | undefined): (() => void) | undefined;
+    updateStateFromContext(state: {
+        loading: boolean;
+        value: Scope[];
+    }): void;
+    /**
+     * Special function that enables variables to be hidden but still render to access react contexts
+     */
+    hiddenRender(): ReactNode;
+}
+
 interface LocalValueVariableState extends SceneVariableState {
     value: VariableValue;
     text: VariableValue;
@@ -2492,9 +2498,6 @@ declare class SceneAppPage extends SceneObjectBase<SceneAppPageState> implements
     static Component: typeof SceneAppPageRenderer;
     private _sceneCache;
     private _drilldownCache;
-    private _scopesBridge;
-    constructor(state: SceneAppPageState);
-    private _activationHandler;
     initializeScene(scene: EmbeddedScene): void;
     getScene(routeMatch: SceneRouteMatch): EmbeddedScene;
     getDrilldownPage(drilldown: SceneAppDrilldownView, routeMatch: SceneRouteMatch<{}>): SceneAppPageLike;
@@ -3029,5 +3032,5 @@ declare const sceneUtils: {
     isGroupByVariable: typeof isGroupByVariable;
 };
 
-export { AdHocFiltersVariable, ConstantVariable, ControlsLabel, CustomVariable, DataProviderProxy, DataSourceVariable, EmbeddedScene, FieldConfigBuilder, FieldConfigBuilders, FieldConfigOverridesBuilder, GroupByVariable, IntervalVariable, LazyLoader, LocalValueVariable, MultiOrSingleValueSelect, MultiValueVariable, NestedScene, NewSceneObjectAddedEvent, PanelBuilders, PanelOptionsBuilders, QueryVariable, RuntimeDataSource, SafeSerializableSceneObject, SceneApp, SceneAppPage, SceneByFrameRepeater, SceneByVariableRepeater, SceneCSSGridItem, SceneCSSGridLayout, SceneCanvasText, SceneControlsSpacer, SceneDataLayerBase, SceneDataLayerControls, SceneDataLayerSet, SceneDataLayerSetBase, SceneDataNode, SceneDataTransformer, SceneDebugger, SceneFlexItem, SceneFlexLayout, SceneGridItem, SceneGridLayout, SceneGridLayoutDragStartEvent, SceneGridRow, SceneObjectBase, SceneObjectRef, SceneObjectStateChangedEvent, SceneObjectUrlSyncConfig, SceneQueryRunner, SceneReactObject, SceneRefreshPicker, SceneScopesBridge, SceneTimePicker, SceneTimeRange, SceneTimeRangeCompare, SceneTimeRangeTransformerBase, SceneTimeZoneOverride, SceneToolbarButton, SceneToolbarInput, SceneVariableSet, SceneVariableValueChangedEvent, SplitLayout, TestVariable, TextBoxVariable, UrlSyncContextProvider, UrlSyncManager, UserActionEvent, VariableDependencyConfig, VariableValueControl, VariableValueSelectWrapper, VariableValueSelectors, VizConfigBuilder, VizConfigBuilders, VizPanel, VizPanelBuilder, VizPanelExploreButton, VizPanelMenu, index$1 as behaviors, index as dataLayers, formatRegistry, getExploreURL, isCustomVariableValue, isDataLayer, isDataRequestEnricher, isFiltersRequestEnricher, isSceneObject, registerQueryWithController, registerRuntimeDataSource, sceneGraph, sceneUtils, useSceneApp, useSceneObjectState, useUrlSync };
+export { AdHocFiltersVariable, ConstantVariable, ControlsLabel, CustomVariable, DataProviderProxy, DataSourceVariable, EmbeddedScene, FieldConfigBuilder, FieldConfigBuilders, FieldConfigOverridesBuilder, GroupByVariable, IntervalVariable, LazyLoader, LocalValueVariable, MultiOrSingleValueSelect, MultiValueVariable, NestedScene, NewSceneObjectAddedEvent, PanelBuilders, PanelOptionsBuilders, QueryVariable, RuntimeDataSource, SafeSerializableSceneObject, SceneApp, SceneAppPage, SceneByFrameRepeater, SceneByVariableRepeater, SceneCSSGridItem, SceneCSSGridLayout, SceneCanvasText, SceneControlsSpacer, SceneDataLayerBase, SceneDataLayerControls, SceneDataLayerSet, SceneDataLayerSetBase, SceneDataNode, SceneDataTransformer, SceneDebugger, SceneFlexItem, SceneFlexLayout, SceneGridItem, SceneGridLayout, SceneGridLayoutDragStartEvent, SceneGridRow, SceneObjectBase, SceneObjectRef, SceneObjectStateChangedEvent, SceneObjectUrlSyncConfig, SceneQueryRunner, SceneReactObject, SceneRefreshPicker, SceneTimePicker, SceneTimeRange, SceneTimeRangeCompare, SceneTimeRangeTransformerBase, SceneTimeZoneOverride, SceneToolbarButton, SceneToolbarInput, SceneVariableSet, SceneVariableValueChangedEvent, ScopesVariable, SplitLayout, TestVariable, TextBoxVariable, UrlSyncContextProvider, UrlSyncManager, UserActionEvent, VariableDependencyConfig, VariableValueControl, VariableValueSelectWrapper, VariableValueSelectors, VizConfigBuilder, VizConfigBuilders, VizPanel, VizPanelBuilder, VizPanelExploreButton, VizPanelMenu, index$1 as behaviors, index as dataLayers, formatRegistry, getExploreURL, isCustomVariableValue, isDataLayer, isDataRequestEnricher, isFiltersRequestEnricher, isSceneObject, registerQueryWithController, registerRuntimeDataSource, sceneGraph, sceneUtils, useSceneApp, useSceneObjectState, useUrlSync };
 export type { AdHocFilterWithLabels, CancelActivationHandler, ControlsLayout, CustomFormatterVariable, CustomTransformOperator, CustomTransformerDefinition, CustomVariableValue, DataLayerFilter, DataRequestEnricher, DeepPartial, EmbeddedSceneState, ExtraQueryDataProcessor, ExtraQueryDescriptor, ExtraQueryProvider, FiltersRequestEnricher, FormatVariable, InterpolationFormatParameter, MacroVariableConstructor, MultiValueVariableState, QueryRunnerState, SceneActivationHandler, SceneAppDrilldownView, SceneAppPageLike, SceneAppPageState, SceneAppRoute, SceneComponent, SceneComponentProps, SceneDataLayerProvider, SceneDataLayerProviderState, SceneDataProvider, SceneDataProviderResult, SceneDataQuery, SceneDataState, SceneDataTransformerState, SceneDeactivationHandler, SceneFlexItemLike, SceneFlexItemState, SceneGridItemLike, SceneGridItemStateLike, SceneInteractionProfileEvent, SceneLayout, SceneLayoutChildOptions, SceneLayoutState, SceneObject, SceneObjectState, SceneObjectStateChangedPayload, SceneObjectUrlSyncHandler, SceneObjectUrlValue, SceneObjectUrlValues, SceneObjectWithUrlSync, SceneQueryControllerEntry, SceneQueryControllerEntryType, SceneQueryControllerLike, SceneRefreshPickerState, SceneRouteMatch, SceneStateChangedHandler, SceneStatelessBehavior, SceneTimeRangeLike, SceneTimeRangeState, SceneUrlSyncOptions, SceneVariable, SceneVariableDependencyConfigLike, SceneVariableSetState, SceneVariableState, SceneVariables, UrlSyncManagerLike, UseStateHookOptions, ValidateAndUpdateResult, VariableCustomFormatterFn, VariableGetOptionsArgs, VariableValue, VariableValueOption, VariableValueSingle, VizConfig, VizPanelState };