@grafana/scenes 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,796 @@
+/// <reference types="react" />
+import React from 'react';
+import { Observable, Observer, Subscription, Unsubscribable } from 'rxjs';
+import { BusEventWithPayload, PanelData, BusEvent, BusEventType, BusEventHandler, TimeZone, TimeRange, ScopedVars, DataTransformerConfig, DataSourceRef, DataQuery, Registry, RegistryItem, VariableRefresh, VariableSort, FieldConfigSource, PanelPlugin, AbsoluteTimeRange } from '@grafana/data';
+import { VariableType, VariableHide, VariableModel } from '@grafana/schema';
+import { IconName } from '@grafana/ui';
+import ReactGridLayout from 'react-grid-layout';
+
+interface SceneVariableState extends SceneObjectStatePlain {
+    type: VariableType;
+    name: string;
+    label?: string;
+    hide?: VariableHide;
+    skipUrlSync?: boolean;
+    loading?: boolean;
+    error?: any | null;
+    description?: string | null;
+}
+interface SceneVariable<TState extends SceneVariableState = SceneVariableState> extends SceneObject<TState> {
+    /**
+     * This function is called on activation or when a dependency changes.
+     */
+    validateAndUpdate?(): Observable<ValidateAndUpdateResult>;
+    /**
+     * Should return the value for the given field path
+     */
+    getValue(fieldPath?: string): VariableValue | undefined | null;
+    /**
+     * Should return the value display text, used by the "text" formatter
+     * Example: ${podId:text}
+     * Useful for variables that have non user friendly values but friendly display text names.
+     */
+    getValueText?(fieldPath?: string): string;
+}
+type VariableValue = VariableValueSingle | VariableValueSingle[];
+type VariableValueSingle = string | boolean | number | VariableValueCustom;
+/**
+ * This is for edge case values like the custom "allValue" that should not be escaped/formatted like other values.
+ * The custom all value usually contain wildcards that should not be escaped.
+ */
+interface VariableValueCustom {
+    isCustomValue: true;
+    toString(): string;
+}
+interface ValidateAndUpdateResult {
+}
+interface VariableValueOption {
+    label: string;
+    value: VariableValueSingle;
+}
+interface SceneVariableSetState extends SceneObjectStatePlain {
+    variables: SceneVariable[];
+}
+interface SceneVariables extends SceneObject<SceneVariableSetState> {
+    getByName(name: string): SceneVariable | undefined;
+}
+declare class SceneVariableValueChangedEvent extends BusEventWithPayload<SceneVariable> {
+    static type: string;
+}
+interface SceneVariableDependencyConfigLike {
+    /** Return all variable names this object depend on */
+    getNames(): Set<string>;
+    /** Used to check for dependency on a specific variable */
+    hasDependencyOn(name: string): boolean;
+    /**
+     * Will be called when any variable value has changed.
+     **/
+    variableValuesChanged(variables: Set<SceneVariable>): void;
+}
+
+interface SceneObjectStatePlain {
+    key?: string;
+    $timeRange?: SceneTimeRangeLike;
+    $data?: SceneObject<SceneDataState>;
+    $editor?: SceneEditor;
+    $variables?: SceneVariables;
+}
+interface SceneLayoutChildState extends SceneObjectStatePlain {
+    placement?: SceneLayoutChildOptions;
+}
+type SceneObjectState = SceneObjectStatePlain | SceneLayoutState | SceneLayoutChildState;
+interface SceneLayoutChildOptions {
+    width?: number | string;
+    height?: number | string;
+    xSizing?: 'fill' | 'content';
+    ySizing?: 'fill' | 'content';
+    x?: number;
+    y?: number;
+    minWidth?: number | string;
+    minHeight?: number | string;
+    isDraggable?: boolean;
+    isResizable?: boolean;
+}
+interface SceneComponentProps<T> {
+    model: T;
+    isEditing?: boolean;
+}
+type SceneComponent<TModel> = React.FunctionComponent<SceneComponentProps<TModel>>;
+interface SceneDataState extends SceneObjectStatePlain {
+    data?: PanelData;
+}
+interface SceneObject<TState extends SceneObjectState = SceneObjectState> {
+    /** The current state */
+    readonly state: TState;
+    /** True when there is a React component mounted for this Object */
+    readonly isActive: boolean;
+    /** SceneObject parent */
+    readonly parent?: SceneObject;
+    /** This abtractions declares what variables the scene object depends on and how to handle when they change value. **/
+    readonly variableDependency?: SceneVariableDependencyConfigLike;
+    /** This abstraction declares URL sync dependencies of a scene object. **/
+    readonly urlSync?: SceneObjectUrlSyncHandler<TState>;
+    /** Subscribe to state changes */
+    subscribeToState(observer?: Partial<Observer<TState>>): Subscription;
+    /** Subscribe to a scene event */
+    subscribeToEvent<T extends BusEvent>(typeFilter: BusEventType<T>, handler: BusEventHandler<T>): Unsubscribable;
+    /** Publish an event and optionally bubble it up the scene */
+    publishEvent(event: BusEvent, bubble?: boolean): void;
+    /** Utility hook that wraps useObservable. Used by React components to subscribes to state changes */
+    useState(): TState;
+    /** How to modify state */
+    setState(state: Partial<TState>): void;
+    /** Called when the Component is mounted. A place to register event listeners add subscribe to state changes */
+    activate(): void;
+    /** Called when component unmounts. Unsubscribe and closes all subscriptions  */
+    deactivate(): void;
+    /** Get the scene root */
+    getRoot(): SceneObject;
+    /** Returns a deep clone this object and all its children */
+    clone(state?: Partial<TState>): this;
+    /** A React component to use for rendering the object */
+    Component(props: SceneComponentProps<SceneObject<TState>>): React.ReactElement | null;
+    /** To be replaced by declarative method */
+    Editor(props: SceneComponentProps<SceneObject<TState>>): React.ReactElement | null;
+    /** Force a re-render, should only be needed when variable values change */
+    forceRender(): void;
+}
+type SceneLayoutChild = SceneObject<SceneLayoutChildState | SceneLayoutState>;
+interface SceneLayoutState extends SceneLayoutChildState {
+    children: SceneLayoutChild[];
+}
+type SceneLayout<T extends SceneLayoutState = SceneLayoutState> = SceneObject<T>;
+interface SceneEditorState extends SceneObjectStatePlain {
+    hoverObject?: SceneObjectRef;
+    selectedObject?: SceneObjectRef;
+}
+interface SceneEditor extends SceneObject<SceneEditorState> {
+    onMouseEnterObject(model: SceneObject): void;
+    onMouseLeaveObject(model: SceneObject): void;
+    onSelectObject(model: SceneObject): void;
+    getEditComponentWrapper(): React.ComponentType<SceneComponentEditWrapperProps>;
+}
+interface SceneComponentEditWrapperProps {
+    editor: SceneEditor;
+    model: SceneObject;
+    children: React.ReactNode;
+}
+interface SceneTimeRangeState extends SceneObjectStatePlain {
+    from: string;
+    to: string;
+    timeZone: TimeZone;
+    fiscalYearStartMonth?: number;
+    value: TimeRange;
+}
+interface SceneTimeRangeLike extends SceneObject<SceneTimeRangeState> {
+    onTimeRangeChange(timeRange: TimeRange): void;
+    onIntervalChanged(interval: string): void;
+    onRefresh(): void;
+}
+interface SceneObjectRef {
+    ref: SceneObject;
+}
+declare function isSceneObject(obj: any): obj is SceneObject;
+interface SceneObjectWithUrlSync<TState> extends SceneObject {
+    getUrlState(state: TState): SceneObjectUrlValues;
+    updateFromUrl(values: SceneObjectUrlValues): void;
+}
+interface SceneObjectUrlSyncHandler<TState> {
+    getKeys(): string[];
+    getUrlState(state: TState): SceneObjectUrlValues;
+    updateFromUrl(values: SceneObjectUrlValues): void;
+}
+type SceneObjectUrlValue = string | string[] | undefined | null;
+type SceneObjectUrlValues = Record<string, SceneObjectUrlValue>;
+type DeepPartial<T> = {
+    [K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K];
+};
+
+interface SceneObjectStateChangedPayload {
+    prevState: SceneObjectState;
+    newState: SceneObjectState;
+    partialUpdate: Partial<SceneObjectState>;
+    changedObject: SceneObject;
+}
+declare class SceneObjectStateChangedEvent extends BusEventWithPayload<SceneObjectStateChangedPayload> {
+    static readonly type = "scene-object-state-change";
+}
+
+type CustomFormatterFn = (value: unknown, legacyVariableModel: Partial<VariableModel>, legacyDefaultFormatter?: CustomFormatterFn) => string;
+
+/**
+ * Get the closest node with variables
+ */
+declare function getVariables(sceneObject: SceneObject): SceneVariables;
+/**
+ * Will walk up the scene object graph to the closest $data scene object
+ */
+declare function getData(sceneObject: SceneObject): SceneObject<SceneDataState>;
+/**
+ * Will walk up the scene object graph to the closest $timeRange scene object
+ */
+declare function getTimeRange(sceneObject: SceneObject): SceneTimeRangeLike;
+/**
+ * Will walk up the scene object graph to the closest $editor scene object
+ */
+declare function getSceneEditor(sceneObject: SceneObject): SceneEditor;
+/**
+ * Will walk up the scene object graph to the closest $layout scene object
+ */
+declare function getLayout(scene: SceneObject): SceneObject<SceneLayoutState>;
+/**
+ * Interpolates the given string using the current scene object as context.   *
+ */
+declare function interpolate(sceneObject: SceneObject, value: string | undefined | null, scopedVars?: ScopedVars, format?: string | CustomFormatterFn): string;
+declare const sceneGraph: {
+    getVariables: typeof getVariables;
+    getData: typeof getData;
+    getTimeRange: typeof getTimeRange;
+    getSceneEditor: typeof getSceneEditor;
+    getLayout: typeof getLayout;
+    interpolate: typeof interpolate;
+};
+
+declare abstract class SceneObjectBase<TState extends SceneObjectState = SceneObjectState> implements SceneObject<TState> {
+    private _isActive;
+    private _subject;
+    private _state;
+    private _events;
+    /** Incremented in SceneComponentWrapper, useful for tests and rendering optimizations */
+    protected _renderCount: number;
+    protected _parent?: SceneObject;
+    protected _subs: Subscription;
+    protected _variableDependency: SceneVariableDependencyConfigLike | undefined;
+    protected _urlSync: SceneObjectUrlSyncHandler<TState> | undefined;
+    constructor(state: TState);
+    /** Current state */
+    get state(): TState;
+    /** True if currently being active (ie displayed for visual objects) */
+    get isActive(): boolean;
+    /** Returns the parent, undefined for root object */
+    get parent(): SceneObject | undefined;
+    /** Returns variable dependency config */
+    get variableDependency(): SceneVariableDependencyConfigLike | undefined;
+    /** Returns url sync config */
+    get urlSync(): SceneObjectUrlSyncHandler<TState> | undefined;
+    /**
+     * Used in render functions when rendering a SceneObject.
+     * Wraps the component in an EditWrapper that handles edit mode
+     */
+    get Component(): SceneComponent<this>;
+    /**
+     * Temporary solution, should be replaced by declarative options
+     */
+    get Editor(): SceneComponent<this>;
+    private setParent;
+    /**
+     * Subscribe to the scene state subject
+     **/
+    subscribeToState(observerOrNext?: Partial<Observer<TState>>): Subscription;
+    /**
+     * Subscribe to the scene event
+     **/
+    subscribeToEvent<T extends BusEvent>(eventType: BusEventType<T>, handler: BusEventHandler<T>): Unsubscribable;
+    setState(update: Partial<TState>): void;
+    publishEvent(event: BusEvent, bubble?: boolean): void;
+    getRoot(): SceneObject;
+    /**
+     * Called by the SceneComponentWrapper when the react component is mounted
+     */
+    activate(): void;
+    /**
+     * Called by the SceneComponentWrapper when the react component is unmounted
+     */
+    deactivate(): void;
+    /**
+     * Utility hook to get and subscribe to state
+     */
+    useState(): TState;
+    /** Force a re-render, should only be needed when variable values change */
+    forceRender(): void;
+    /**
+     * Will create new SceneObject with shallow-cloned state, but all state items of type SceneObject are deep cloned
+     */
+    clone(withState?: Partial<TState>): this;
+}
+
+interface SceneDataNodeState extends SceneObjectStatePlain {
+    data?: PanelData;
+}
+declare class SceneDataNode extends SceneObjectBase<SceneDataNodeState> {
+}
+
+interface SceneDataTransformerState extends SceneDataState {
+    transformations?: DataTransformerConfig[];
+}
+declare class SceneDataTransformer extends SceneObjectBase<SceneDataTransformerState> {
+    private _transformationsSub?;
+    activate(): void;
+    deactivate(): void;
+    private transformData;
+}
+
+interface SceneObjectUrlSyncConfigOptions {
+    keys: string[];
+}
+declare class SceneObjectUrlSyncConfig<TState extends SceneObjectState> implements SceneObjectUrlSyncHandler<TState> {
+    private _sceneObject;
+    private _keys;
+    constructor(_sceneObject: SceneObjectWithUrlSync<TState>, _options: SceneObjectUrlSyncConfigOptions);
+    getKeys(): string[];
+    getUrlState(state: TState): SceneObjectUrlValues;
+    updateFromUrl(values: SceneObjectUrlValues): void;
+}
+
+declare class SceneTimeRange extends SceneObjectBase<SceneTimeRangeState> implements SceneTimeRangeLike {
+    protected _urlSync: SceneObjectUrlSyncConfig<SceneTimeRangeState>;
+    constructor(state?: Partial<SceneTimeRangeState>);
+    onTimeRangeChange: (timeRange: TimeRange) => void;
+    onRefresh: () => void;
+    onIntervalChanged: (_: string) => void;
+    getUrlState(state: SceneTimeRangeState): {
+        from: string;
+        to: string;
+    };
+    updateFromUrl(values: SceneObjectUrlValues): void;
+}
+
+interface VariableDependencyConfigOptions<TState extends SceneObjectState> {
+    /**
+     * State paths to scan / extract variable dependencies from. Leave empty to scan all paths.
+     */
+    statePaths?: Array<keyof TState>;
+    /**
+     * Optional way to customize how to handle when a dependent variable changes
+     * If not specified the default behavior is to trigger a re-render
+     */
+    onReferencedVariableValueChanged?: () => void;
+}
+declare class VariableDependencyConfig<TState extends SceneObjectState> implements SceneVariableDependencyConfigLike {
+    private _sceneObject;
+    private _state;
+    private _dependencies;
+    private _statePaths?;
+    private _onReferencedVariableValueChanged;
+    scanCount: number;
+    constructor(_sceneObject: SceneObject<TState>, options: VariableDependencyConfigOptions<TState>);
+    /**
+     * Used to check for dependency on a specific variable
+     */
+    hasDependencyOn(name: string): boolean;
+    /**
+     * This is called whenever any set of variables have new values. It up to this implementation to check if it's relevant given the current dependencies.
+     */
+    variableValuesChanged(variables: Set<SceneVariable>): void;
+    /**
+     * Only way to force a re-render is to update state right now
+     */
+    private defaultHandlerReferencedVariableValueChanged;
+    getNames(): Set<string>;
+    private scanStateForDependencies;
+    private extractVariablesFrom;
+}
+
+interface QueryRunnerState extends SceneObjectStatePlain {
+    data?: PanelData;
+    queries: DataQueryExtended[];
+    transformations?: DataTransformerConfig[];
+    datasource?: DataSourceRef;
+    minInterval?: string;
+    maxDataPoints?: number;
+    maxDataPointsFromWidth?: boolean;
+}
+interface DataQueryExtended extends DataQuery {
+    [key: string]: any;
+}
+declare class SceneQueryRunner extends SceneObjectBase<QueryRunnerState> {
+    private _querySub?;
+    private _containerWidth?;
+    protected _variableDependency: VariableDependencyConfig<QueryRunnerState>;
+    activate(): void;
+    private shouldRunQueriesOnActivate;
+    deactivate(): void;
+    setContainerWidth(width: number): void;
+    runQueries(): void;
+    private getMaxDataPoints;
+    private runWithTimeRange;
+    private onDataReceived;
+}
+
+interface FormatRegistryItem extends RegistryItem {
+    formatter(value: VariableValue, args: string[], variable: FormatVariable): string;
+}
+/**
+ * Slimmed down version of the SceneVariable interface so that it only contains what the formatters actually use.
+ * This is useful as we have some implementations of this interface that does not need to be full scene objects.
+ * For example ScopedVarsVariable and LegacyVariableWrapper.
+ */
+interface FormatVariable {
+    state: {
+        name: string;
+        type: VariableType | string;
+    };
+    getValue(fieldPath?: string): VariableValue | undefined | null;
+    getValueText?(fieldPath?: string): string;
+}
+declare enum FormatRegistryID {
+    lucene = "lucene",
+    raw = "raw",
+    regex = "regex",
+    pipe = "pipe",
+    distributed = "distributed",
+    csv = "csv",
+    html = "html",
+    json = "json",
+    percentEncode = "percentencode",
+    singleQuote = "singlequote",
+    doubleQuote = "doublequote",
+    sqlString = "sqlstring",
+    date = "date",
+    glob = "glob",
+    text = "text",
+    queryParam = "queryparam"
+}
+declare const formatRegistry: Registry<FormatRegistryItem>;
+
+declare class VariableValueSelectors extends SceneObjectBase<SceneObjectStatePlain> {
+    static Component: typeof VariableValueSelectorsRenderer;
+}
+declare function VariableValueSelectorsRenderer({ model }: SceneComponentProps<VariableValueSelectors>): JSX.Element;
+
+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  */
+    private updating;
+    getByName(name: string): SceneVariable | undefined;
+    /**
+     * Subscribes to child variable value changes
+     * And starts the variable value validation process
+     */
+    activate(): void;
+    /**
+     * Cancel all currently running updates
+     */
+    deactivate(): void;
+    /**
+     * This loops through variablesToUpdate and update all that that can.
+     * If one has a dependency that is currently in variablesToUpdate it will be skipped for now.
+     */
+    private updateNextBatch;
+    /**
+     * A variable has completed it's update process. This could mean that variables that depend on it can now be updated in turn.
+     */
+    private validateAndUpdateCompleted;
+    /**
+     * TODO handle this properly (and show error in UI).
+     * Not sure if this should be handled here on in MultiValueVariable
+     */
+    private handleVariableError;
+    /**
+     * Checks if the variable has any dependencies that is currently in variablesToUpdate
+     */
+    private hasDependendencyInUpdateQueue;
+    /**
+     * Extract dependencies from all variables and add those that needs update to the variablesToUpdate map
+     * Then it will start the update process.
+     */
+    private validateAndUpdateAll;
+    /**
+     * This will trigger an update of all variables that depend on it.
+     * */
+    private onVariableValueChanged;
+    /**
+     * Walk scene object graph and update all objects that depend on variables that have changed
+     */
+    private notifyDependentSceneObjects;
+    /**
+     * Recursivly walk the full scene object graph and notify all objects with dependencies that include any of changed variables
+     */
+    private traverseSceneAndNotify;
+}
+
+interface ConstantVariableState extends SceneVariableState {
+    value: string;
+}
+declare class ConstantVariable extends SceneObjectBase<ConstantVariableState> implements SceneVariable<ConstantVariableState> {
+    constructor(initialState: Partial<ConstantVariableState>);
+    getValue(): VariableValue;
+}
+
+interface MultiValueVariableState extends SceneVariableState {
+    value: VariableValue;
+    text: VariableValue;
+    options: VariableValueOption[];
+    isMulti?: boolean;
+    includeAll?: boolean;
+    defaultToAll?: boolean;
+    allValue?: string;
+    placeholder?: string;
+}
+interface VariableGetOptionsArgs {
+    searchFilter?: string;
+}
+declare abstract class MultiValueVariable<TState extends MultiValueVariableState = MultiValueVariableState> extends SceneObjectBase<TState> implements SceneVariable<TState> {
+    protected _urlSync: SceneObjectUrlSyncHandler<TState>;
+    /**
+     * The source of value options.
+     */
+    abstract getValueOptions(args: VariableGetOptionsArgs): Observable<VariableValueOption[]>;
+    /**
+     * This function is called on when SceneVariableSet is activated or when a dependency changes.
+     */
+    validateAndUpdate(): Observable<ValidateAndUpdateResult>;
+    /**
+     * Check if current value is valid given new options. If not update the value.
+     */
+    private updateValueGivenNewOptions;
+    getValue(): VariableValue;
+    getValueText(): string;
+    private hasAllValue;
+    private getDefaultMultiState;
+    /**
+     * Change the value and publish SceneVariableValueChangedEvent event
+     */
+    changeValueTo(value: VariableValue, text?: VariableValue): void;
+    private findLabelTextForValue;
+    /**
+     * This helper function is to counter the contravariance of setState
+     */
+    private setStateHelper;
+    getOptionsForSelect(): VariableValueOption[];
+}
+
+interface CustomVariableState extends MultiValueVariableState {
+    query: string;
+}
+declare class CustomVariable extends MultiValueVariable<CustomVariableState> {
+    protected _variableDependency: VariableDependencyConfig<CustomVariableState>;
+    constructor(initialState: Partial<CustomVariableState>);
+    getValueOptions(args: VariableGetOptionsArgs): Observable<VariableValueOption[]>;
+    static Component: ({ model }: SceneComponentProps<MultiValueVariable>) => JSX.Element;
+}
+
+interface DataSourceVariableState extends MultiValueVariableState {
+    query: string;
+    regex: string;
+}
+declare class DataSourceVariable extends MultiValueVariable<DataSourceVariableState> {
+    protected _variableDependency: VariableDependencyConfig<DataSourceVariableState>;
+    constructor(initialState: Partial<DataSourceVariableState>);
+    getValueOptions(args: VariableGetOptionsArgs): Observable<VariableValueOption[]>;
+    private getDataSourceTypes;
+    static Component: ({ model }: SceneComponentProps<MultiValueVariable>) => JSX.Element;
+}
+
+interface QueryVariableState extends MultiValueVariableState {
+    type: 'query';
+    datasource: DataSourceRef | null;
+    query: any;
+    regex: string;
+    refresh: VariableRefresh;
+    sort: VariableSort;
+}
+declare class QueryVariable extends MultiValueVariable<QueryVariableState> {
+    private updateSubscription?;
+    private dataSourceSubject?;
+    protected _variableDependency: VariableDependencyConfig<QueryVariableState>;
+    constructor(initialState: Partial<QueryVariableState>);
+    activate(): void;
+    deactivate(): void;
+    getValueOptions(args: VariableGetOptionsArgs): Observable<VariableValueOption[]>;
+    private getDataSource;
+    private getRequest;
+    static Component: ({ model }: SceneComponentProps<MultiValueVariable>) => JSX.Element;
+}
+
+interface TestVariableState extends MultiValueVariableState {
+    query: string;
+    delayMs?: number;
+    issuedQuery?: string;
+}
+/**
+ * This variable is only designed for unit tests and potentially e2e tests.
+ */
+declare class TestVariable extends MultiValueVariable<TestVariableState> {
+    private completeUpdate;
+    isGettingValues: boolean;
+    getValueOptionsCount: number;
+    protected _variableDependency: VariableDependencyConfig<TestVariableState>;
+    constructor(initialState: Partial<TestVariableState>);
+    getValueOptions(args: VariableGetOptionsArgs): Observable<VariableValueOption[]>;
+    private issueQuery;
+    /** Useful from tests */
+    signalUpdateCompleted(): void;
+    static Component: ({ model }: SceneComponentProps<MultiValueVariable>) => JSX.Element;
+}
+
+declare class UrlSyncManager {
+    private sceneRoot;
+    private locationListenerUnsub;
+    private stateChangeSub;
+    private initialStates;
+    private urlKeyMapper;
+    constructor(sceneRoot: SceneObject);
+    /**
+     * Updates the current scene state to match URL state.
+     */
+    initSync(): void;
+    private onLocationUpdate;
+    private onStateChanged;
+    cleanUp(): void;
+    private syncSceneStateFromUrl;
+}
+
+interface SceneState extends SceneObjectStatePlain {
+    title: string;
+    body: SceneObject;
+    actions?: SceneObject[];
+    subMenu?: SceneObject;
+    isEditing?: boolean;
+}
+declare class EmbeddedScene extends SceneObjectBase<SceneState> {
+    static Component: typeof EmbeddedSceneRenderer;
+    private urlSyncManager?;
+    activate(): void;
+    deactivate(): void;
+}
+declare function EmbeddedSceneRenderer({ model }: SceneComponentProps<EmbeddedScene>): JSX.Element;
+
+declare function VizPanelRenderer({ model }: SceneComponentProps<VizPanel>): JSX.Element;
+declare namespace VizPanelRenderer {
+    var displayName: string;
+}
+
+interface VizPanelState<TOptions = {}, TFieldConfig = {}> extends SceneLayoutChildState {
+    title: string;
+    pluginId: string;
+    options: DeepPartial<TOptions>;
+    fieldConfig: FieldConfigSource<DeepPartial<TFieldConfig>>;
+    pluginVersion?: string;
+    pluginLoadError?: string;
+}
+declare class VizPanel<TOptions = {}, TFieldConfig = {}> extends SceneObjectBase<VizPanelState<TOptions, TFieldConfig>> {
+    static Component: typeof VizPanelRenderer;
+    static Editor: typeof VizPanelEditor;
+    private _plugin?;
+    constructor(state: Partial<VizPanelState<TOptions, TFieldConfig>>);
+    activate(): void;
+    private pluginLoaded;
+    private getPluginVersion;
+    getPlugin(): PanelPlugin | undefined;
+    onChangeTimeRange: (timeRange: AbsoluteTimeRange) => void;
+    onOptionsChange: (options: TOptions) => void;
+    onFieldConfigChange: (fieldConfig: FieldConfigSource<TFieldConfig>) => void;
+}
+declare function VizPanelEditor({ model }: SceneComponentProps<VizPanel>): JSX.Element;
+
+interface NestedSceneState extends SceneLayoutChildState {
+    title: string;
+    isCollapsed?: boolean;
+    canCollapse?: boolean;
+    canRemove?: boolean;
+    body: SceneLayout;
+    actions?: SceneObject[];
+}
+declare class NestedScene extends SceneObjectBase<NestedSceneState> {
+    static Component: typeof NestedSceneRenderer;
+    onToggle: () => void;
+    /** Removes itself from its parent's children array */
+    onRemove: () => void;
+}
+declare function NestedSceneRenderer({ model, isEditing }: SceneComponentProps<NestedScene>): JSX.Element;
+
+interface SceneCanvasTextState extends SceneLayoutChildState {
+    text: string;
+    fontSize?: number;
+    align?: 'left' | 'center' | 'right';
+}
+declare class SceneCanvasText extends SceneObjectBase<SceneCanvasTextState> {
+    static Editor: typeof Editor;
+    protected _variableDependency: VariableDependencyConfig<SceneCanvasTextState>;
+    static Component: ({ model }: SceneComponentProps<SceneCanvasText>) => JSX.Element;
+}
+declare function Editor({ model }: SceneComponentProps<SceneCanvasText>): JSX.Element;
+
+interface ToolbarButtonState extends SceneObjectStatePlain {
+    icon: IconName;
+    onClick: () => void;
+}
+declare class SceneToolbarButton extends SceneObjectBase<ToolbarButtonState> {
+    static Component: ({ model }: SceneComponentProps<SceneToolbarButton>) => JSX.Element;
+}
+interface SceneToolbarInputState extends SceneObjectStatePlain {
+    value?: string;
+    onChange: (value: number) => void;
+}
+declare class SceneToolbarInput extends SceneObjectBase<SceneToolbarInputState> {
+    static Component: ({ model }: SceneComponentProps<SceneToolbarInput>) => JSX.Element;
+}
+
+interface SceneTimePickerState extends SceneObjectStatePlain {
+    hidePicker?: boolean;
+}
+declare class SceneTimePicker extends SceneObjectBase<SceneTimePickerState> {
+    static Component: typeof SceneTimePickerRenderer;
+}
+declare function SceneTimePickerRenderer({ model }: SceneComponentProps<SceneTimePicker>): JSX.Element | null;
+
+interface RepeatOptions extends SceneObjectStatePlain {
+    layout: SceneObject<SceneLayoutState>;
+}
+declare class ScenePanelRepeater extends SceneObjectBase<RepeatOptions> {
+    activate(): void;
+    private performRepeat;
+    static Component: ({ model, isEditing }: SceneComponentProps<ScenePanelRepeater>) => JSX.Element;
+}
+
+interface SceneSubMenuState extends SceneLayoutState {
+}
+declare class SceneSubMenu extends SceneObjectBase<SceneSubMenuState> {
+    static Component: typeof SceneSubMenuRenderer;
+}
+declare function SceneSubMenuRenderer({ model }: SceneComponentProps<SceneSubMenu>): JSX.Element;
+
+type FlexLayoutDirection = 'column' | 'row';
+interface SceneFlexLayoutState extends SceneLayoutState {
+    direction?: FlexLayoutDirection;
+}
+declare class SceneFlexLayout extends SceneObjectBase<SceneFlexLayoutState> {
+    static Component: typeof FlexLayoutRenderer;
+    static Editor: typeof FlexLayoutEditor;
+    toggleDirection(): void;
+}
+declare function FlexLayoutRenderer({ model, isEditing }: SceneComponentProps<SceneFlexLayout>): JSX.Element;
+declare function FlexLayoutEditor({ model }: SceneComponentProps<SceneFlexLayout>): JSX.Element;
+
+interface SceneGridRowState extends SceneLayoutChildState {
+    title: string;
+    isCollapsible?: boolean;
+    isCollapsed?: boolean;
+    children: Array<SceneObject<SceneLayoutChildState>>;
+}
+declare class SceneGridRow extends SceneObjectBase<SceneGridRowState> {
+    static Component: typeof SceneGridRowRenderer;
+    protected _urlSync: SceneObjectUrlSyncConfig<SceneGridRowState>;
+    constructor(state: SceneGridRowState);
+    onCollapseToggle: () => void;
+    getUrlState(state: SceneGridRowState): {
+        rowc: string;
+    };
+    updateFromUrl(values: SceneObjectUrlValues): void;
+}
+declare function SceneGridRowRenderer({ model }: SceneComponentProps<SceneGridRow>): JSX.Element;
+
+interface SceneGridLayoutState extends SceneLayoutState {
+}
+declare class SceneGridLayout extends SceneObjectBase<SceneGridLayoutState> {
+    static Component: typeof SceneGridLayoutRenderer;
+    private _skipOnLayoutChange;
+    constructor(state: SceneGridLayoutState);
+    toggleRow(row: SceneGridRow): void;
+    onLayoutChange: (layout: ReactGridLayout.Layout[]) => void;
+    /**
+     * Will also scan row children and return child of the row
+     */
+    getSceneLayoutChild(key: string): SceneLayoutChild;
+    onResizeStop: ReactGridLayout.ItemCallback;
+    private pushChildDown;
+    /**
+     *  We assume the layout array is storted according to y pos, and walk upwards until we find a row.
+     *  If it is collapsed there is no row to add it to. The default is then to return the SceneGridLayout itself
+     */
+    private findGridItemSceneParent;
+    /**
+     * This likely needs a slighltly different approach. Where we clone or deactivate or and re-activate the moved child
+     */
+    moveChildTo(child: SceneLayoutChild, target: SceneGridLayout | SceneGridRow): SceneLayoutChild[];
+    onDragStop: ReactGridLayout.ItemCallback;
+    private toGridCell;
+    buildGridLayout(width: number): ReactGridLayout.Layout[];
+}
+declare function SceneGridLayoutRenderer({ model }: SceneComponentProps<SceneGridLayout>): JSX.Element;
+
+export { ConstantVariable, CustomFormatterFn, CustomVariable, DataSourceVariable, DeepPartial, EmbeddedScene, FormatRegistryID, FormatVariable, NestedScene, QueryRunnerState, QueryVariable, SceneCanvasText, SceneComponent, SceneComponentProps, SceneDataNode, SceneDataState, SceneDataTransformer, SceneEditor, SceneEditorState, SceneFlexLayout, SceneGridLayout, SceneGridRow, SceneLayout, SceneLayoutChild, SceneLayoutChildOptions, SceneLayoutChildState, SceneLayoutState, SceneObject, SceneObjectBase, SceneObjectRef, SceneObjectState, SceneObjectStateChangedEvent, SceneObjectStateChangedPayload, SceneObjectStatePlain, SceneObjectUrlSyncConfig, SceneObjectUrlSyncHandler, SceneObjectUrlValue, SceneObjectUrlValues, SceneObjectWithUrlSync, ScenePanelRepeater, SceneQueryRunner, SceneState, SceneSubMenu, SceneTimePicker, SceneTimeRange, SceneTimeRangeLike, SceneTimeRangeState, SceneToolbarButton, SceneToolbarInput, SceneVariable, SceneVariableDependencyConfigLike, SceneVariableSet, SceneVariableSetState, SceneVariableState, SceneVariableValueChangedEvent, SceneVariables, TestVariable, UrlSyncManager, ValidateAndUpdateResult, VariableValue, VariableValueCustom, VariableValueOption, VariableValueSelectors, VariableValueSingle, VizPanel, VizPanelState, formatRegistry, isSceneObject, sceneGraph };