@grafana/data on Grafana Labs

AbsoluteTimeRange

Sat, 04 Apr 2026 12:26:57 +0000

AbsoluteTimeRange interface

Signature

export interface AbsoluteTimeRange

Import

import { AbsoluteTimeRange } from '@grafana/data';

Properties

Property	Type	Description
from	`number`
to	`number`

from property

Signature

from: number;

to property

Signature

to: number;

addDurationToDate

Sat, 04 Apr 2026 12:26:57 +0000

addDurationToDate() function

addDurationToDate adds given duration to given date and returns a new Date object

Signature

export declare function addDurationToDate(date: Date | number, duration: Duration): Date;

Import

import { addDurationToDate } from '@grafana/data';

Parameters

Parameter	Type	Description
date	`Date \| number`	date to add to. Can be either Date object or a number (milliseconds since epoch)
duration	`Duration`	duration to add. For example ‘2m’, ‘5h 20s’

Returns:

Date

addLogLevelToSeries

Sat, 04 Apr 2026 12:26:57 +0000

addLogLevelToSeries() function

Signature

export declare function addLogLevelToSeries(series: DataFrame, lineIndex: number): DataFrame;

Import

import { addLogLevelToSeries } from '@grafana/data';

Parameters

Parameter	Type	Description
series	`DataFrame`
lineIndex	`number`

Returns:

DataFrame

AlertErrorPayload

Sat, 04 Apr 2026 12:26:57 +0000

AlertErrorPayload type

Signature

export declare type AlertErrorPayload = [string, (string | Error)?];

Import

import { AlertErrorPayload } from '@grafana/data';

AlertPayload

Sat, 04 Apr 2026 12:26:57 +0000

AlertPayload type

Signature

export declare type AlertPayload = [string, string?];

Import

import { AlertPayload } from '@grafana/data';

alpha

Sat, 04 Apr 2026 12:26:57 +0000

colorManipulator.alpha() function

colorManipulator.alpha() function

Set the absolute transparency of a color. Any existing alpha values are overwritten.

Signature

export declare function alpha(color: string, value: number): string;

Import

import { colorManipulator } from '@grafana/data';
const { alpha } = colorManipulator;

Parameters

Parameter	Type	Description
color	`string`	CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla(), color()
value	`number`	value to set the alpha channel to in the range 0 - 1

Returns:

string

A CSS color string. Hex input values are returned as rgb

AnnotationEvent

Sat, 04 Apr 2026 12:26:57 +0000

AnnotationEvent interface

Signature

export interface AnnotationEvent

Import

import { AnnotationEvent } from '@grafana/data';

Properties

Property	Type	Description
alertId	`number`
annotation	`any`
avatarUrl	`string`
color	`string`
dashboardId	`number`
email	`string`
id	`string`
isRegion	`boolean`
login	`string`
newState	`string`
panelId	`number`
source	`any`
tags	`string[]`
text	`string`
time	`number`
timeEnd	`number`
title	`string`
type	`string`
userId	`number`

alertId property

Signature

alertId?: number;

annotation property

Signature

annotation?: any;

avatarUrl property

Signature

avatarUrl?: string;

color property

Signature

color?: string;

dashboardId property

Signature

dashboardId?: number;

email property

Signature

email?: string;

id property

Signature

id?: string;

isRegion property

Signature

isRegion?: boolean;

Signature

login?: string;

newState property

Signature

newState?: string;

panelId property

Signature

panelId?: number;

source property

Signature

source?: any;

tags property

Signature

tags?: string[];

text property

Signature

text?: string;

time property

Signature

time?: number;

timeEnd property

Signature

timeEnd?: number;

title property

Signature

title?: string;

type property

Signature

type?: string;

userId property

Signature

userId?: number;

AnnotationEventFieldMapping

Sat, 04 Apr 2026 12:26:57 +0000

AnnotationEventFieldMapping interface

Signature

export interface AnnotationEventFieldMapping

Import

import { AnnotationEventFieldMapping } from '@grafana/data';

Properties

Property	Type	Description
regex	`string`
source	`AnnotationEventFieldSource`
value	`string`

regex property

Signature

regex?: string;

source property

Signature

source?: AnnotationEventFieldSource;

value property

Signature

value?: string;

AnnotationEventMappings

Sat, 04 Apr 2026 12:26:57 +0000

AnnotationEventMappings type

Signature

export declare type AnnotationEventMappings = Partial<Record<keyof AnnotationEvent, AnnotationEventFieldMapping>>;

Import

import { AnnotationEventMappings } from '@grafana/data';

AnnotationEventUIModel

Sat, 04 Apr 2026 12:26:57 +0000

AnnotationEventUIModel interface

Signature

export interface AnnotationEventUIModel

Import

import { AnnotationEventUIModel } from '@grafana/data';

Properties

Property	Type	Description
description	`string`
from	`number`
id	`string`
tags	`string[]`
to	`number`

description property

Signature

description: string;

from property

Signature

from: number;

id property

Signature

id?: string;

tags property

Signature

tags: string[];

to property

Signature

to: number;

AnnotationQuery

Sat, 04 Apr 2026 12:26:57 +0000

AnnotationQuery interface

This JSON object is stored in the dashboard json model.

Signature

export interface AnnotationQuery<TQuery extends DataQuery = DataQuery>

Import

import { AnnotationQuery } from '@grafana/data';

Properties

Property	Type	Description
builtIn	`number`
datasource	`DataSourceRef \| string \| null`
enable	`boolean`
hide	`boolean`
iconColor	`string`
mappings	`AnnotationEventMappings`
name	`string`
snapshotData	`any`
target	`TQuery`
type	`string`

builtIn property

Signature

builtIn?: number;

datasource property

Signature

datasource?: DataSourceRef | string | null;

enable property

Signature

enable: boolean;

hide property

Signature

hide?: boolean;

iconColor property

Signature

iconColor: string;

mappings property

Signature

mappings?: AnnotationEventMappings;

name property

Signature

name: string;

snapshotData property

Signature

snapshotData?: any;

target property

Signature

target?: TQuery;

type property

Signature

type?: string;

AnnotationQueryRequest

Sat, 04 Apr 2026 12:26:57 +0000

AnnotationQueryRequest interface

Options passed to the datasource.annotationQuery method. See docs/plugins/developing/datasource.md

Signature

export interface AnnotationQueryRequest<MoreOptions = {}>

Import

import { AnnotationQueryRequest } from '@grafana/data';

Properties

Property	Type	Description
annotation	`AnnotationQuery`
dashboard	`any`
range	`TimeRange`
rangeRaw	`RawTimeRange`

annotation property

Signature

annotation: AnnotationQuery;

dashboard property

Signature

dashboard: any;

range property

Signature

range: TimeRange;

rangeRaw property

Signature

rangeRaw: RawTimeRange;

AnnotationSupport

Sat, 04 Apr 2026 12:26:57 +0000

AnnotationSupport interface

Since Grafana 7.2

This offers a generic approach to annotation processing

Signature

export interface AnnotationSupport<TQuery extends DataQuery = DataQuery, TAnno = AnnotationQuery<TQuery>>

Import

import { AnnotationSupport } from '@grafana/data';

Properties

Property	Type	Description
QueryEditor	`ComponentType<QueryEditorProps<any, TQuery>>`	Specify a custom QueryEditor for the annotation page. If not specified, the standard one will be used

Methods

Method	Description
prepareAnnotation(json)	This hook lets you manipulate any existing stored values before running them though the processor. This is particularly helpful when dealing with migrating old formats. ie query as a string vs object
prepareQuery(anno)	Convert the stored JSON model to a standard datasource query object. This query will be executed in the datasource and the results converted into events. Returning an undefined result will quietly skip query execution
processEvents(anno, data)	When the standard frame > event processing is insufficient, this allows explicit control of the mappings

QueryEditor property

Specify a custom QueryEditor for the annotation page. If not specified, the standard one will be used

Signature

QueryEditor?: ComponentType<QueryEditorProps<any, TQuery>>;

prepareAnnotation method

This hook lets you manipulate any existing stored values before running them though the processor. This is particularly helpful when dealing with migrating old formats. ie query as a string vs object

Signature

prepareAnnotation?(json: any): TAnno;

Parameters

Parameter	Type	Description
json	`any`

Returns:

TAnno

prepareQuery method

Convert the stored JSON model to a standard datasource query object. This query will be executed in the datasource and the results converted into events. Returning an undefined result will quietly skip query execution

Signature

prepareQuery?(anno: TAnno): TQuery | undefined;

Parameters

Parameter	Type	Description
anno	`TAnno`

Returns:

TQuery | undefined

processEvents method

When the standard frame > event processing is insufficient, this allows explicit control of the mappings

Signature

processEvents?(anno: TAnno, data: DataFrame[]): Observable<AnnotationEvent[] | undefined>;

Parameters

Parameter	Type	Description
anno	`TAnno`
data	`DataFrame[]`

Returns:

Observable<AnnotationEvent[] | undefined>

anySeriesWithTimeField

Sat, 04 Apr 2026 12:26:57 +0000

anySeriesWithTimeField() function

Indicates if there is any time field in the array of data frames

Signature

export declare function anySeriesWithTimeField(data: DataFrame[]): boolean;

Import

import { anySeriesWithTimeField } from '@grafana/data';

Parameters

Parameter	Type	Description
data	`DataFrame[]`

Returns:

boolean

AppendedVectors

Sat, 04 Apr 2026 12:26:57 +0000

AppendedVectors class

This may be more trouble than it is worth. This trades some computation time for RAM – rather than allocate a new array the size of all previous arrays, this just points the correct index to their original array values

Signature

export declare class AppendedVectors<T = any> implements Vector<T>

Import

import { AppendedVectors } from '@grafana/data';

Constructors

Constructor	Modifiers	Description
constructor(startAt)		Constructs a new instance of the `AppendedVectors` class

Properties

Property	Modifiers	Type	Description
length		`number`
source		`Array<AppendedVectorInfo<T>>`

Methods

Method	Modifiers	Description
append(v)
get(index)
setLength(length)		Make the vector look like it is this long
toArray()
toJSON()

constructor(startAt)

Constructs a new instance of the AppendedVectors class

Signature

constructor(startAt?: number);

Parameters

Parameter	Type	Description
startAt	`number`

length property

Signature

length: number;

source property

Signature

source: Array<AppendedVectorInfo<T>>;

append method

Signature

append(v: Vector<T>): AppendedVectorInfo<T>;

Parameters

Parameter	Type	Description
v	`Vector<T>`

Returns:

AppendedVectorInfo<T>

get method

Signature

get(index: number): T;

Parameters

Parameter	Type	Description
index	`number`

Returns:

T

setLength method

Make the vector look like it is this long

Signature

setLength(length: number): void;

Parameters

Parameter	Type	Description
length	`number`

Returns:

void

toArray method

Signature

toArray(): T[];

Returns:

T[]

toJSON method

Signature

toJSON(): T[];

Returns:

T[]

AppEvent

Sat, 04 Apr 2026 12:26:57 +0000

AppEvent interface

Signature

export interface AppEvent<T>

Import

import { AppEvent } from '@grafana/data';

Properties

Property	Type	Description
name	`string`
payload	`T`

name property

Signature

readonly name: string;

payload property

Signature

payload?: T;

AppEvents

Sat, 04 Apr 2026 12:26:57 +0000

AppEvents variable

Signature

AppEvents: {
    alertSuccess: import("../events").AppEvent<AlertPayload>;
    alertWarning: import("../events").AppEvent<AlertPayload>;
    alertError: import("../events").AppEvent<AlertErrorPayload>;
}

Import

import { AppEvents } from '@grafana/data';

ApplyFieldOverrideOptions

Sat, 04 Apr 2026 12:26:57 +0000

ApplyFieldOverrideOptions interface

Signature

export interface ApplyFieldOverrideOptions

Import

import { ApplyFieldOverrideOptions } from '@grafana/data';

Properties

Property	Type	Description
data	`DataFrame[]`
fieldConfig	`FieldConfigSource`
fieldConfigRegistry	`FieldConfigOptionsRegistry`
replaceVariables	`InterpolateFunction`
theme	`GrafanaTheme2`
timeZone	`TimeZone`

data property

Signature

data?: DataFrame[];

fieldConfig property

Signature

fieldConfig: FieldConfigSource;

fieldConfigRegistry property

Signature

fieldConfigRegistry?: FieldConfigOptionsRegistry;

replaceVariables property

Signature

replaceVariables: InterpolateFunction;

theme property

Signature

theme: GrafanaTheme2;

timeZone property

Signature

timeZone?: TimeZone;

applyFieldOverrides

Sat, 04 Apr 2026 12:26:57 +0000

applyFieldOverrides() function

Return a copy of the DataFrame with all rules applied

Signature

export declare function applyFieldOverrides(options: ApplyFieldOverrideOptions): DataFrame[];

Import

import { applyFieldOverrides } from '@grafana/data';

Parameters

Parameter	Type	Description
options	`ApplyFieldOverrideOptions`

Returns:

DataFrame[]

applyRawFieldOverrides

Sat, 04 Apr 2026 12:26:57 +0000

applyRawFieldOverrides() function

Return a copy of the DataFrame with raw data

Signature

export declare function applyRawFieldOverrides(data: DataFrame[]): DataFrame[];

Import

import { applyRawFieldOverrides } from '@grafana/data';

Parameters

Parameter	Type	Description
data	`DataFrame[]`

Returns:

DataFrame[]

AppPlugin

Sat, 04 Apr 2026 12:26:57 +0000

AppPlugin class

Signature

export declare class AppPlugin<T = KeyValue> extends GrafanaPlugin<AppPluginMeta<T>>

Import

import { AppPlugin } from '@grafana/data';

Properties

Property	Modifiers	Type	Description
root		`ComponentType<AppRootProps<T>>`
rootNav		`NavModel`

Methods

Method	Modifiers	Description
init(meta)		Called after the module has loaded, and before the app is used. This function may be called multiple times on the same instance. The first time, `this.meta` will be undefined
setComponentsFromLegacyExports(pluginExports)
setRootPage(root, rootNav)		Set the component displayed under: /a/${plugin-id}/*If the NavModel is configured, the page will have a managed frame, otheriwse it has full control.NOTE: this structure will change in 7.2+ so that it is managed with a normal react router

root property

Signature

root?: ComponentType<AppRootProps<T>>;

rootNav property

Signature

rootNav?: NavModel;

init method

Called after the module has loaded, and before the app is used. This function may be called multiple times on the same instance. The first time, this.meta will be undefined

Signature

init(meta: AppPluginMeta): void;

Parameters

Parameter	Type	Description
meta	`AppPluginMeta`

Returns:

void

setComponentsFromLegacyExports method

Signature

setComponentsFromLegacyExports(pluginExports: any): void;

Parameters

Parameter	Type	Description
pluginExports	`any`

Returns:

void

setRootPage method

Set the component displayed under: /a/${plugin-id}/*

If the NavModel is configured, the page will have a managed frame, otheriwse it has full control.

NOTE: this structure will change in 7.2+ so that it is managed with a normal react router

Signature

setRootPage(root: ComponentType<AppRootProps<T>>, rootNav?: NavModel): this;

Parameters

Parameter	Type	Description
root	`ComponentType<AppRootProps<T>>`
rootNav	`NavModel`

Returns:

this

AppPluginMeta

Sat, 04 Apr 2026 12:26:57 +0000

AppPluginMeta interface

Signature

export interface AppPluginMeta<T = KeyValue> extends PluginMeta<T>

Import

import { AppPluginMeta } from '@grafana/data';

AppRootProps

Sat, 04 Apr 2026 12:26:57 +0000

AppRootProps interface

Signature

export interface AppRootProps<T = KeyValue>

Import

import { AppRootProps } from '@grafana/data';

Properties

Property	Type	Description
basename	`string`	base URL segment for an app, /app/pluginId
meta	`AppPluginMeta<T>`
onNavChanged	`(nav: NavModel) => void`	Pass the nav model to the container… is there a better way?
path	`string`	The URL path to this page
query	`KeyValue`	The URL query parameters

basename property

base URL segment for an app, /app/pluginId

Signature

basename: string;

meta property

Signature

meta: AppPluginMeta<T>;

onNavChanged property

Pass the nav model to the container… is there a better way?

Signature

onNavChanged: (nav: NavModel) => void;

path property

The URL path to this page

Signature

path: string;

query property

The URL query parameters

Signature

query: KeyValue;

arrayUtils

Sat, 04 Apr 2026 12:26:57 +0000

arrayUtils namespace

arrayUtils namespace

Import

import { arrayUtils } from '@grafana/data';

Functions

Function	Description
sortValues(sort)

ArrayVector

Sat, 04 Apr 2026 12:26:57 +0000

ArrayVector class

Signature

export declare class ArrayVector<T = any> extends FunctionalVector<T> implements MutableVector<T>

Import

import { ArrayVector } from '@grafana/data';

Constructors

Constructor	Modifiers	Description
constructor(buffer)		Constructs a new instance of the `ArrayVector` class

Properties

Property	Modifiers	Type	Description
buffer		`T[]`
length		`number`

Methods

Method	Modifiers	Description
add(value)
get(index)
reverse()
set(index, value)
toArray()
toJSON()

constructor(buffer)

Constructs a new instance of the ArrayVector class

Signature

constructor(buffer?: T[]);

Parameters

Parameter	Type	Description
buffer	`T[]`

buffer property

Signature

buffer: T[];

length property

Signature

get length(): number;

add method

Signature

add(value: T): void;

Parameters

Parameter	Type	Description
value	`T`

Returns:

void

get method

Signature

get(index: number): T;

Parameters

Parameter	Type	Description
index	`number`

Returns:

T

reverse method

Signature

reverse(): void;

Returns:

void

set method

Signature

set(index: number, value: T): void;

Parameters

Parameter	Type	Description
index	`number`
value	`T`

Returns:

void

toArray method

Signature

toArray(): T[];

Returns:

T[]

toJSON method

Signature

toJSON(): T[];

Returns:

T[]

asHexString

Sat, 04 Apr 2026 12:26:57 +0000

colorManipulator.asHexString() function

Converts a color to hex6 format if there is no alpha, hex8 if there is.

Signature

export declare function asHexString(color: string): string;

Import

import { colorManipulator } from '@grafana/data';
const { asHexString } = colorManipulator;

Parameters

Parameter	Type	Description
color	`string`	Hex, RGB, HSL color

Returns:

string

A hex color string, i.e. #ff0000 or #ff0000ff

AsNumberVector

Sat, 04 Apr 2026 12:26:57 +0000

AsNumberVector class

This will force all values to be numbers

Signature

export declare class AsNumberVector extends FunctionalVector<number>

Import

import { AsNumberVector } from '@grafana/data';

Constructors

Constructor	Modifiers	Description
constructor(field)		Constructs a new instance of the `AsNumberVector` class

Properties

Property	Modifiers	Type	Description
length		`number`

Methods

Method	Modifiers	Description
get(index)

constructor(field)

Constructs a new instance of the AsNumberVector class

Signature

constructor(field: Vector);

Parameters

Parameter	Type	Description
field	`Vector`

length property

Signature

get length(): number;

get method

Signature

get(index: number): number;

Parameters

Parameter	Type	Description
index	`number`

Returns:

number

BasicValueMatcherOptions

Sat, 04 Apr 2026 12:26:57 +0000

BasicValueMatcherOptions interface

Describes a basic value matcher option that has a single value.

Signature

export interface BasicValueMatcherOptions<T = any> extends ValueMatcherOptions

Import

import { BasicValueMatcherOptions } from '@grafana/data';

Properties

Property	Type	Description
value	`T`

value property

Signature

value: T;

BinaryOperation

Sat, 04 Apr 2026 12:26:57 +0000

BinaryOperation type

Signature

export declare type BinaryOperation = (left: number, right: number) => number;

Import

import { BinaryOperation } from '@grafana/data';

BinaryOperationID

Sat, 04 Apr 2026 12:26:57 +0000

BinaryOperationID enum

Signature

export declare enum BinaryOperationID

Import

import { BinaryOperationID } from '@grafana/data';

Enumeration Members

Member	Value	Description
Add	`"+"`
Divide	`"/"`
Multiply	`"*"`
Subtract	`"-"`

BinaryOperationVector

Sat, 04 Apr 2026 12:26:57 +0000

BinaryOperationVector class

Signature

export declare class BinaryOperationVector implements Vector<number>

Import

import { BinaryOperationVector } from '@grafana/data';

Constructors

Constructor	Modifiers	Description
constructor(left, right, operation)		Constructs a new instance of the `BinaryOperationVector` class

Properties

Property	Modifiers	Type	Description
length		`number`

Methods

Method	Modifiers	Description
get(index)
toArray()
toJSON()

constructor(left, right, operation)

Constructs a new instance of the BinaryOperationVector class

Signature

constructor(left: Vector<number>, right: Vector<number>, operation: BinaryOperation);

Parameters

Parameter	Type	Description
left	`Vector<number>`
right	`Vector<number>`
operation	`BinaryOperation`

length property

Signature

get length(): number;

get method

Signature

get(index: number): number;

Parameters

Parameter	Type	Description
index	`number`

Returns:

number

toArray method

Signature

toArray(): number[];

Returns:

number[]

toJSON method

Signature

toJSON(): number[];

Returns:

number[]

binaryOperators

Sat, 04 Apr 2026 12:26:57 +0000

binaryOperators variable

Signature

binaryOperators: Registry<BinaryOperatorInfo>

Import

import { binaryOperators } from '@grafana/data';

booleanOverrideProcessor

Sat, 04 Apr 2026 12:26:57 +0000

booleanOverrideProcessor variable

Signature

booleanOverrideProcessor: (value: boolean, _context: FieldOverrideContext, _settings?: ThresholdsFieldConfigSettings | undefined) => boolean

Import

import { booleanOverrideProcessor } from '@grafana/data';

booleanValueFormatter

Sat, 04 Apr 2026 12:26:57 +0000

booleanValueFormatter() function

Signature

export declare function booleanValueFormatter(t: string, f: string): ValueFormatter;

Import

import { booleanValueFormatter } from '@grafana/data';

Parameters

Parameter	Type	Description
t	`string`
f	`string`

Returns:

ValueFormatter

BuildInfo

Sat, 04 Apr 2026 12:26:57 +0000

BuildInfo interface

Describes the build information that will be available via the Grafana configuration.

Signature

export interface BuildInfo

Import

import { BuildInfo } from '@grafana/data';

Properties

Property	Type	Description
commit	`string`
edition	`GrafanaEdition`
env	`string`
hasUpdate	`boolean`
hideVersion	`boolean`
latestVersion	`string`
version	`string`

commit property

Signature

commit: string;

edition property

Signature

edition: GrafanaEdition;

env property

Signature

env: string;

hasUpdate property

Signature

hasUpdate: boolean;

hideVersion property

Signature

hideVersion: boolean;

latestVersion property

Signature

latestVersion: string;

version property

Signature

version: string;

BusEventType

Sat, 04 Apr 2026 12:26:57 +0000

BusEventType interface

Signature

export interface BusEventType<T extends BusEvent>

Import

import { BusEventType } from '@grafana/data';

Properties

Property	Type	Description
type	`string`

Methods

Method	Description
new(args)

type property

Signature

type: string;

new(args)

Signature

new (...args: any[]): T;

Parameters

Parameter	Type	Description
args	`any[]`

Returns:

T

ByNamesMatcherMode

Sat, 04 Apr 2026 12:26:57 +0000

ByNamesMatcherMode enum

Mode to be able to toggle if the names matcher should match fields in provided list or all except provided names.

Signature

export declare enum ByNamesMatcherMode

Import

import { ByNamesMatcherMode } from '@grafana/data';

Enumeration Members

Member	Value	Description
exclude	`"exclude"`
include	`"include"`

ByNamesMatcherOptions

Sat, 04 Apr 2026 12:26:57 +0000

ByNamesMatcherOptions interface

Options to instruct the by names matcher to either match all fields in given list or all except the fields in the list.

Signature

export interface ByNamesMatcherOptions

Import

import { ByNamesMatcherOptions } from '@grafana/data';

Properties

Property	Type	Description
mode	`ByNamesMatcherMode`
names	`string[]`
prefix	`string`
readOnly	`boolean`

mode property

Signature

mode?: ByNamesMatcherMode;

names property

Signature

names?: string[];

prefix property

Signature

prefix?: string;

readOnly property

Signature

readOnly?: boolean;

calculateFieldStats

Sat, 04 Apr 2026 12:26:57 +0000

calculateFieldStats() function

Signature

export declare function calculateFieldStats(rows: LogRowModel[], extractor: RegExp): LogLabelStatsModel[];

Import

import { calculateFieldStats } from '@grafana/data';

Parameters

Parameter	Type	Description
rows	`LogRowModel[]`
extractor	`RegExp`

Returns:

LogLabelStatsModel[]

calculateInterval

Sat, 04 Apr 2026 12:26:57 +0000

rangeUtil.calculateInterval() function

Signature

export declare function calculateInterval(range: TimeRange, resolution: number, lowLimitInterval?: string): IntervalValues;

Import

import { rangeUtil } from '@grafana/data';
const { calculateInterval } = rangeUtil;

Parameters

Parameter	Type	Description
range	`TimeRange`
resolution	`number`
lowLimitInterval	`string`

Returns:

IntervalValues

calculateLogsLabelStats

Sat, 04 Apr 2026 12:26:57 +0000

calculateLogsLabelStats() function

Signature

export declare function calculateLogsLabelStats(rows: LogRowModel[], label: string): LogLabelStatsModel[];

Import

import { calculateLogsLabelStats } from '@grafana/data';

Parameters

Parameter	Type	Description
rows	`LogRowModel[]`
label	`string`

Returns:

LogLabelStatsModel[]

calculateStats

Sat, 04 Apr 2026 12:26:57 +0000

calculateStats() function

Signature

export declare function calculateStats(values: any[]): LogLabelStatsModel[];

Import

import { calculateStats } from '@grafana/data';

Parameters

Parameter	Type	Description
values	`any[]`

Returns:

LogLabelStatsModel[]

CartesianCoords2D

Sat, 04 Apr 2026 12:26:57 +0000

CartesianCoords2D interface

A coordinate on a two dimensional plane.

Signature

export interface CartesianCoords2D

Import

import { CartesianCoords2D } from '@grafana/data';

Properties

Property	Type	Description
x	`number`
y	`number`

x property

Signature

x: number;

y property

Signature

y: number;

checkLogsError

Sat, 04 Apr 2026 12:26:57 +0000

checkLogsError variable

Signature

checkLogsError: (logRow: LogRowModel) => {
    hasError: boolean;
    errorMessage?: string;
}

Import

import { checkLogsError } from '@grafana/data';

CircularDataFrame

Sat, 04 Apr 2026 12:26:57 +0000

CircularDataFrame class

This dataframe can have values constantly added, and will never exceed the given capacity

Signature

export declare class CircularDataFrame<T = any> extends MutableDataFrame<T>

Import

import { CircularDataFrame } from '@grafana/data';

Constructors

Constructor	Modifiers	Description
constructor(options)		Constructs a new instance of the `CircularDataFrame` class

constructor(options)

Constructs a new instance of the CircularDataFrame class

Signature

constructor(options: CircularOptions);

Parameters

Parameter	Type	Description
options	`CircularOptions`

CircularVector

Sat, 04 Apr 2026 12:26:57 +0000

CircularVector class

Circular vector uses a single buffer to capture a stream of values overwriting the oldest value on add.

This supports adding to the ‘head’ or ’tail’ and will grow the buffer to match a configured capacity.

Signature

export declare class CircularVector<T = any> extends FunctionalVector<T> implements MutableVector<T>

Import

import { CircularVector } from '@grafana/data';

Constructors

Constructor	Modifiers	Description
constructor(options)		Constructs a new instance of the `CircularVector` class

Properties

Property	Modifiers	Type	Description
add		`(value: T) => void`	Add the value to the buffer
length		`number`

Methods

Method	Modifiers	Description
get(index)
reverse()
set(index, value)
setAppendMode(mode)
setCapacity(v)
toArray()
toJSON()

constructor(options)

Constructs a new instance of the CircularVector class

Signature

constructor(options: CircularOptions<T>);

Parameters

Parameter	Type	Description
options	`CircularOptions<T>`

add property

Add the value to the buffer

Signature

add: (value: T) => void;

length property

Signature

get length(): number;

get method

Signature

get(index: number): T;

Parameters

Parameter	Type	Description
index	`number`

Returns:

T

reverse method

Signature

reverse(): void;

Returns:

void

set method

Signature

set(index: number, value: T): void;

Parameters

Parameter	Type	Description
index	`number`
value	`T`

Returns:

void

setAppendMode method

Signature

setAppendMode(mode: 'head' | 'tail'): void;

Parameters

Parameter	Type	Description
mode	`‘head’ \| ’tail’`

Returns:

void

setCapacity method

Signature

setCapacity(v: number): void;

Parameters

Parameter	Type	Description
v	`number`

Returns:

void

toArray method

Signature

toArray(): T[];

Returns:

T[]

toJSON method

Signature

toJSON(): T[];

Returns:

T[]

classicColors

Sat, 04 Apr 2026 12:26:57 +0000

classicColors variable

Signature

classicColors: string[]

Import

import { classicColors } from '@grafana/data';

colorManipulator

Sat, 04 Apr 2026 12:26:57 +0000

colorManipulator namespace

colorManipulator namespace

Import

import { colorManipulator } from '@grafana/data';

Functions

Function	Description
alpha(color, value)	*(BETA)* Set the absolute transparency of a color. Any existing alpha values are overwritten.
asHexString(color)	Converts a color to hex6 format if there is no alpha, hex8 if there is.
darken(color, coefficient)	*(BETA)* Darkens a color.
decomposeColor(color)	*(BETA)* Returns an object with the type and values of a color.Note: Does not support rgb % values.
emphasize(color, coefficient)	*(BETA)* Darken or lighten a color, depending on its luminance. Light colors are darkened, dark colors are lightened.
getContrastRatio(foreground, background, canvas)	*(BETA)* Calculates the contrast ratio between two colors.Formula: https://www.w3.org/TR/WCAG20-TECHS/G17.html#G17-tests
getLuminance(color, background)	*(BETA)* The relative brightness of any point in a color space, normalized to 0 for darkest black and 1 for lightest white.Formula: https://www.w3.org/TR/WCAG20-TECHS/G17.html#G17-tests
hexToRgb(color)	*(BETA)* Converts a color from CSS hex format to CSS rgb format.
hslToRgb(color)	*(BETA)* Converts a color from hsl format to rgb format.
lighten(color, coefficient)	*(BETA)* Lightens a color.
recomposeColor(color)	*(BETA)* Converts a color object with type and values to a string.
rgbToHex(color)	*(BETA)* Converts a color from CSS rgb format to CSS hex format.

Column

Sat, 04 Apr 2026 12:26:57 +0000

Column interface

Signature

export interface Column

Import

import { Column } from '@grafana/data';

Properties

Property	Type	Description
custom	`Record<string, any>`
filterable	`boolean`
text	`string`
unit	`string`

custom property

Signature

custom?: Record<string, any>;

filterable property

Signature

filterable?: boolean;

text property

Signature

text: string;

unit property

Signature

unit?: string;

compareArrayValues

Sat, 04 Apr 2026 12:26:57 +0000

compareArrayValues() function

compareArrayValues() function

Check if all values in two arrays match the compare funciton

Signature

export declare function compareArrayValues<T>(a: T[], b: T[], cmp: (a: T, b: T) => boolean): boolean;

Import

import { compareArrayValues } from '@grafana/data';

Parameters

Parameter	Type	Description
a	`T[]`
b	`T[]`
cmp	`(a: T, b: T) => boolean`

Returns:

boolean

compareDataFrameStructures

Sat, 04 Apr 2026 12:26:57 +0000

compareDataFrameStructures() function

compareDataFrameStructures() function

Returns true if both frames have the same name, fields, labels and configs.

Signature

export declare function compareDataFrameStructures(a: DataFrame, b: DataFrame, skipConfig?: boolean): boolean;

Import

import { compareDataFrameStructures } from '@grafana/data';

Parameters

Parameter	Type	Description
a	`DataFrame`
b	`DataFrame`
skipConfig	`boolean`

Returns:

boolean

Example

To compare multiple frames use:

compareArrayValues(a, b, framesHaveSameStructure);

NOTE: this does a shallow check on the FieldConfig properties, when using the query editor, this should be sufficient, however if applications are mutating properties deep in the FieldConfig this will not recognize a change

ConfigOverrideRule

Sat, 04 Apr 2026 12:26:57 +0000

ConfigOverrideRule interface

Signature

export interface ConfigOverrideRule

Import

import { ConfigOverrideRule } from '@grafana/data';

Properties

Property	Type	Description
matcher	`MatcherConfig`
properties	`DynamicConfigValue[]`

matcher property

Signature

matcher: MatcherConfig;

properties property

Signature

properties: DynamicConfigValue[];

ConstantVector

Sat, 04 Apr 2026 12:26:57 +0000

ConstantVector class

Signature

export declare class ConstantVector<T = any> implements Vector<T>

Import

import { ConstantVector } from '@grafana/data';

Constructors

Constructor	Modifiers	Description
constructor(value, len)		Constructs a new instance of the `ConstantVector` class

Properties

Property	Modifiers	Type	Description
length		`number`

Methods

Method	Modifiers	Description
get(index)
toArray()
toJSON()

constructor(value, len)

Constructs a new instance of the ConstantVector class

Signature

constructor(value: T, len: number);

Parameters

Parameter	Type	Description
value	`T`
len	`number`

length property

Signature

get length(): number;

get method

Signature

get(index: number): T;

Parameters

Parameter	Type	Description
index	`number`

Returns:

T

toArray method

Signature

toArray(): T[];

Returns:

T[]

toJSON method

Signature

toJSON(): T[];

Returns:

T[]

convertRawToRange

Sat, 04 Apr 2026 12:26:57 +0000

rangeUtil.convertRawToRange variable

Signature

convertRawToRange: (raw: RawTimeRange, timeZone?: string | undefined, fiscalYearStartMonth?: number | undefined) => TimeRange

Import

import { rangeUtil } from '@grafana/data';
const { convertRawToRange } = rangeUtil;

CoreApp

Sat, 04 Apr 2026 12:26:57 +0000

CoreApp enum

The app container that is loading another plugin (panel or query editor)

Signature

export declare enum CoreApp

Import

import { CoreApp } from '@grafana/data';

Enumeration Members

Member	Value	Description
CloudAlerting	`"cloud-alerting"`
Dashboard	`"dashboard"`
Explore	`"explore"`
PanelEditor	`"panel-editor"`
PanelViewer	`"panel-viewer"`
UnifiedAlerting	`"unified-alerting"`
Unknown	`"unknown"`

createDimension

Sat, 04 Apr 2026 12:26:57 +0000

createDimension variable

Signature

createDimension: (name: string, columns: Field[]) => Dimension

Import

import { createDimension } from '@grafana/data';

CreatePlotOverlay

Sat, 04 Apr 2026 12:26:57 +0000

CreatePlotOverlay interface

Signature

export interface CreatePlotOverlay

Import

import { CreatePlotOverlay } from '@grafana/data';

CSVConfig

Sat, 04 Apr 2026 12:26:57 +0000

CSVConfig interface

Signature

export interface CSVConfig

Import

import { CSVConfig } from '@grafana/data';

Properties

Property	Type	Description
delimiter	`string`
encoding	`string`
headerStyle	`CSVHeaderStyle`
newline	`string`
quoteChar	`string`
useExcelHeader	`boolean`

delimiter property

Signature

delimiter?: string;

encoding property

Signature

encoding?: string;

headerStyle property

Signature

headerStyle?: CSVHeaderStyle;

newline property

Signature

newline?: string;

quoteChar property

Signature

quoteChar?: string;

useExcelHeader property

Signature

useExcelHeader?: boolean;

CSVHeaderStyle

Sat, 04 Apr 2026 12:26:57 +0000

CSVHeaderStyle enum

Signature

export declare enum CSVHeaderStyle

Import

import { CSVHeaderStyle } from '@grafana/data';

Enumeration Members

Member	Value	Description
full	`0`
name	`1`
none	`2`

CSVOptions

Sat, 04 Apr 2026 12:26:57 +0000

CSVOptions interface

Signature

export interface CSVOptions

Import

import { CSVOptions } from '@grafana/data';

Properties

Property	Type	Description
callback	`CSVParseCallbacks`
config	`CSVConfig`

callback property

Signature

callback?: CSVParseCallbacks;

config property

Signature

config?: CSVConfig;

CSVParseCallbacks

Sat, 04 Apr 2026 12:26:57 +0000

CSVParseCallbacks interface

Signature

export interface CSVParseCallbacks

Import

import { CSVParseCallbacks } from '@grafana/data';

Properties

Property	Type	Description
onHeader	`(fields: Field[]) => void`	Get a callback before any rows are processed This can return a modified table to force any Column configurations
onRow	`(row: any[]) => void`

onHeader property

Get a callback before any rows are processed This can return a modified table to force any Column configurations

Signature

onHeader: (fields: Field[]) => void;

onRow property

Signature

onRow: (row: any[]) => void;

CSVReader

Sat, 04 Apr 2026 12:26:57 +0000

CSVReader class

Signature

export declare class CSVReader

Import

import { CSVReader } from '@grafana/data';

Constructors

Constructor	Modifiers	Description
constructor(options)		Constructs a new instance of the `CSVReader` class

Properties

Property	Modifiers	Type	Description
callback		`CSVParseCallbacks`
config		`CSVConfig`
current		`MutableDataFrame`
data		`MutableDataFrame[]`
state		`ParseState`

Methods

Method	Modifiers	Description
readCSV(text)

constructor(options)

Constructs a new instance of the CSVReader class

Signature

constructor(options?: CSVOptions);

Parameters

Parameter	Type	Description
options	`CSVOptions`

callback property

Signature

callback?: CSVParseCallbacks;

config property

Signature

config: CSVConfig;

current property

Signature

current: MutableDataFrame;

data property

Signature

data: MutableDataFrame[];

state property

Signature

state: ParseState;

readCSV method

Signature

readCSV(text: string): MutableDataFrame[];

Parameters

Parameter	Type	Description
text	`string`

Returns:

MutableDataFrame[]

darken

Sat, 04 Apr 2026 12:26:57 +0000

colorManipulator.darken() function

colorManipulator.darken() function

Darkens a color.

Signature

export declare function darken(color: string, coefficient: number): string;

Import

import { colorManipulator } from '@grafana/data';
const { darken } = colorManipulator;

Parameters

Parameter	Type	Description
color	`string`	CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla(), color()
coefficient	`number`	multiplier in the range 0 - 1

Returns:

string

A CSS color string. Hex input values are returned as rgb

DashboardCursorSync

Sat, 04 Apr 2026 12:26:57 +0000

DashboardCursorSync enum

Signature

export declare enum DashboardCursorSync

Import

import { DashboardCursorSync } from '@grafana/data';

Enumeration Members

Member	Value	Description
Crosshair	`1`
Off	`0`
Tooltip	`2`

DataConfigSource

Sat, 04 Apr 2026 12:26:57 +0000

DataConfigSource interface

Describes and API for exposing panel specific data configurations.

Signature

export interface DataConfigSource

Import

import { DataConfigSource } from '@grafana/data';

Properties

Property	Type	Description
configRev	`number`
getDataSupport	`() => PanelPluginDataSupport`
getFieldOverrideOptions	`() => ApplyFieldOverrideOptions \| undefined`
getTransformations	`() => DataTransformerConfig[] \| undefined`
snapshotData	`DataFrameDTO[]`

configRev property

Signature

configRev?: number;

getDataSupport property

Signature

getDataSupport: () => PanelPluginDataSupport;

getFieldOverrideOptions property

Signature

getFieldOverrideOptions: () => ApplyFieldOverrideOptions | undefined;

getTransformations property

Signature

getTransformations: () => DataTransformerConfig[] | undefined;

snapshotData property

Signature

snapshotData?: DataFrameDTO[];

DataFrame

Sat, 04 Apr 2026 12:26:57 +0000

DataFrame interface

Signature

export interface DataFrame extends QueryResultBase

Import

import { DataFrame } from '@grafana/data';

Properties

Property	Type	Description
fields	`Field[]`
length	`number`
name	`string`

fields property

Signature

fields: Field[];

length property

Signature

length: number;

name property

Signature

name?: string;

DataFrameDTO

Sat, 04 Apr 2026 12:26:57 +0000

DataFrameDTO interface

Like a DataFrame, but fields may be a FieldDTO

Signature

export interface DataFrameDTO extends QueryResultBase

Import

import { DataFrameDTO } from '@grafana/data';

Properties

Property	Type	Description
fields	`Array<FieldDTO \| Field>`
name	`string`

fields property

Signature

fields: Array<FieldDTO | Field>;

name property

Signature

name?: string;

DataFrameType

Sat, 04 Apr 2026 12:26:57 +0000

DataFrameType enum

Signature

export declare enum DataFrameType

Import

import { DataFrameType } from '@grafana/data';

Enumeration Members

Member	Value	Description
TimeSeriesLong	`"timeseries-long"`
TimeSeriesMany	`"timeseries-many"`
TimeSeriesWide	`"timeseries-wide"`

DataFrameView

Sat, 04 Apr 2026 12:26:57 +0000

DataFrameView class

This abstraction will present the contents of a DataFrame as if it were a well typed javascript object Vector.

Signature

export declare class DataFrameView<T = any> extends FunctionalVector<T>

Import

import { DataFrameView } from '@grafana/data';

Remarks

The DataFrameView.get() is optimized for use in a loop and will return same object. See function for more details.

Constructors

Constructor	Modifiers	Description
constructor(data)		*(BETA)* Constructs a new instance of the `DataFrameView` class

Properties

Property	Modifiers	Type	Description
dataFrame		`DataFrame`	*(BETA)*
length		`number`	*(BETA)*

Methods

Method	Modifiers	Description
get(idx)		*(BETA)* The contents of the object returned from this function are optimized for use in a loop. All calls return the same object but the index has changed.
getFieldDisplayProcessor(colIndex)		*(BETA)* Helper function to return the DisplayProcessor for a given field column.
toArray()		*(BETA)*

constructor(data)

Constructs a new instance of the DataFrameView class

Signature

constructor(data: DataFrame);

Parameters

Parameter	Type	Description
data	`DataFrame`

dataFrame property

Signature

get dataFrame(): DataFrame;

length property

Signature

get length(): number;

get method

The contents of the object returned from this function are optimized for use in a loop. All calls return the same object but the index has changed.

Signature

get(idx: number): T;

Parameters

Parameter	Type	Description
idx	`number`	The index of the object you currently are inspecting

Returns:

T

Example

  // `first`, `second` and `third` will all point to the same contents at index 2:
  const first = view.get(0);
  const second = view.get(1);
  const third = view.get(2);

  // If you need three different objects, consider something like:
  const first = { ...view.get(0) };
  const second = { ...view.get(1) };
  const third = { ...view.get(2) };

getFieldDisplayProcessor method

Helper function to return the DisplayProcessor for a given field column.

Signature

getFieldDisplayProcessor(colIndex: number): DisplayProcessor | undefined;

Parameters

Parameter	Type	Description
colIndex	`number`	the field column index for the data frame.

Returns:

DisplayProcessor | undefined

toArray method

Signature

toArray(): T[];

Returns:

T[]

DataLink

Sat, 04 Apr 2026 12:26:57 +0000

DataLink interface

Link configuration. The values may contain variables that need to be processed before showing the link to user.

TODO: <T extends DataQuery> is not strictly true for internal links as we do not need refId for example but all data source defined queries extend this so this is more for documentation.

Signature

export interface DataLink<T extends DataQuery = any>

Import

import { DataLink } from '@grafana/data';

Properties

Property	Type	Description
internal	`InternalDataLink<T>`
onBuildUrl	`(event: DataLinkClickEvent) => string`
onClick	`(event: DataLinkClickEvent) => void`
targetBlank	`boolean`
title	`string`
url	`string`

internal property

Signature

internal?: InternalDataLink<T>;

onBuildUrl property

Signature

onBuildUrl?: (event: DataLinkClickEvent) => string;

onClick property

Signature

onClick?: (event: DataLinkClickEvent) => void;

targetBlank property

Signature

targetBlank?: boolean;

title property

Signature

title: string;

url property

Signature

url: string;

DataLinkBuiltInVars

Sat, 04 Apr 2026 12:26:57 +0000

DataLinkBuiltInVars variable

Signature

DataLinkBuiltInVars: {
    keepTime: string;
    timeRangeFrom: string;
    timeRangeTo: string;
    includeVars: string;
    seriesName: string;
    fieldName: string;
    valueTime: string;
    valueNumeric: string;
    valueText: string;
    valueRaw: string;
    valueCalc: string;
}

Import

import { DataLinkBuiltInVars } from '@grafana/data';

DataLinkClickEvent

Sat, 04 Apr 2026 12:26:57 +0000

DataLinkClickEvent interface

Callback info for DataLink click events

Signature

export interface DataLinkClickEvent<T = any>

Import

import { DataLinkClickEvent } from '@grafana/data';

Properties

Property	Type	Description
e	`any`
origin	`T`
replaceVariables	`InterpolateFunction \| undefined`

e property

Signature

e?: any;

origin property

Signature

origin: T;

replaceVariables property

Signature

replaceVariables: InterpolateFunction | undefined;

DataLinksFieldConfigSettings

Sat, 04 Apr 2026 12:26:57 +0000

DataLinksFieldConfigSettings interface

Signature

export interface DataLinksFieldConfigSettings

Import

import { DataLinksFieldConfigSettings } from '@grafana/data';

dataLinksOverrideProcessor

Sat, 04 Apr 2026 12:26:57 +0000

dataLinksOverrideProcessor variable

Signature

dataLinksOverrideProcessor: (value: any, _context: FieldOverrideContext, _settings?: DataLinksFieldConfigSettings | undefined) => DataLink<any>[]

Import

import { dataLinksOverrideProcessor } from '@grafana/data';

DataQuery

Sat, 04 Apr 2026 12:26:57 +0000

DataQuery interface

These are the common properties available to all queries in all datasources Specific implementations will *extend* this interface adding the required properties for the given context

Signature

export interface DataQuery

Import

import { DataQuery } from '@grafana/data';

Properties

Property	Type	Description
datasource	`DataSourceRef \| null`	For mixed data sources the selected datasource is on the query level. For non mixed scenarios this is undefined.
hide	`boolean`	true if query is disabled (ie should not be returned to the dashboard)
key	`string`	Unique, guid like, string used in explore mode
queryType	`string`	Specify the query flavor
refId	`string`	A - Z

datasource property

For mixed data sources the selected datasource is on the query level. For non mixed scenarios this is undefined.

Signature

datasource?: DataSourceRef | null;

hide property

true if query is disabled (ie should not be returned to the dashboard)

Signature

hide?: boolean;

key property

Unique, guid like, string used in explore mode

Signature

key?: string;

queryType property

Specify the query flavor

Signature

queryType?: string;

refId property

A - Z

Signature

refId: string;

DataQueryError

Sat, 04 Apr 2026 12:26:57 +0000

DataQueryError interface

Signature

export interface DataQueryError

Import

import { DataQueryError } from '@grafana/data';

Properties

Property	Type	Description
data	`{` `message?: string;` `error?: string;` `}`
message	`string`
refId	`string`
status	`string`
statusText	`string`
type	`DataQueryErrorType`

data property

Signature

data?: {
        message?: string;
        error?: string;
    };

message property

Signature

message?: string;

refId property

Signature

refId?: string;

status property

Signature

status?: string;

statusText property

Signature

statusText?: string;

type property

Signature

type?: DataQueryErrorType;

DataQueryErrorType

Sat, 04 Apr 2026 12:26:57 +0000

DataQueryErrorType enum

Signature

export declare enum DataQueryErrorType

Import

import { DataQueryErrorType } from '@grafana/data';

Enumeration Members

Member	Value	Description
Cancelled	`"cancelled"`
Timeout	`"timeout"`
Unknown	`"unknown"`

DataQueryRequest

Sat, 04 Apr 2026 12:26:57 +0000

DataQueryRequest interface

Signature

export interface DataQueryRequest<TQuery extends DataQuery = DataQuery>

Import

import { DataQueryRequest } from '@grafana/data';

Properties

Property	Type	Description
app	`CoreApp \| string`
cacheTimeout	`string \| null`
dashboardId	`number`
endTime	`number`
interval	`string`
intervalMs	`number`
liveStreaming	`boolean`
maxDataPoints	`number`
panelId	`number`
range	`TimeRange`
rangeRaw	`RawTimeRange`
requestId	`string`
reverse	`boolean`
scopedVars	`ScopedVars`
startTime	`number`
targets	`TQuery[]`
timeInfo	`string`
timezone	`string`

app property

Signature

app: CoreApp | string;

cacheTimeout property

Signature

cacheTimeout?: string | null;

dashboardId property

Signature

dashboardId?: number;

endTime property

Signature

endTime?: number;

interval property

Signature

interval: string;

intervalMs property

Signature

intervalMs: number;

liveStreaming property

Signature

liveStreaming?: boolean;

maxDataPoints property

Signature

maxDataPoints?: number;

panelId property

Signature

panelId?: number;

range property

Signature

range: TimeRange;

rangeRaw property

Signature

rangeRaw?: RawTimeRange;

requestId property

Signature

requestId: string;

reverse property

Signature

reverse?: boolean;

scopedVars property

Signature

scopedVars: ScopedVars;

startTime property

Signature

startTime: number;

targets property

Signature

targets: TQuery[];

timeInfo property

Signature

timeInfo?: string;

timezone property

Signature

timezone: string;

DataQueryResponse

Sat, 04 Apr 2026 12:26:57 +0000

DataQueryResponse interface

Signature

export interface DataQueryResponse

Import

import { DataQueryResponse } from '@grafana/data';

Properties

Property	Type	Description
data	`DataQueryResponseData[]`	The response data. When streaming, this may be empty or a partial result set
error	`DataQueryError`	Optionally include error info along with the response data
key	`string`	When returning multiple partial responses or streams Use this key to inform Grafana how to combine the partial responses Multiple responses with same key are replaced (latest used)
state	`LoadingState`	Use this to control which state the response should have Defaults to LoadingState.Done if state is not defined

data property

The response data. When streaming, this may be empty or a partial result set

Signature

data: DataQueryResponseData[];

error property

Optionally include error info along with the response data

Signature

error?: DataQueryError;

key property

When returning multiple partial responses or streams Use this key to inform Grafana how to combine the partial responses Multiple responses with same key are replaced (latest used)

Signature

key?: string;

state property

Use this to control which state the response should have Defaults to LoadingState.Done if state is not defined

Signature

state?: LoadingState;

DataQueryResponseData

Sat, 04 Apr 2026 12:26:57 +0000

DataQueryResponseData type

Signature

export declare type DataQueryResponseData = DataFrame | DataFrameDTO | LegacyResponseData;

Import

import { DataQueryResponseData } from '@grafana/data';

DataQueryTimings

Sat, 04 Apr 2026 12:26:57 +0000

DataQueryTimings interface

Signature

export interface DataQueryTimings

Import

import { DataQueryTimings } from '@grafana/data';

Properties

Property	Type	Description
dataProcessingTime	`number`

dataProcessingTime property

Signature

dataProcessingTime: number;

DataSourceApi

Sat, 04 Apr 2026 12:26:57 +0000

DataSourceApi class

The main data source abstraction interface, represents an instance of a data source

Although this is a class, datasource implementations do not *yet* need to extend it. As such, we can not yet add functions with default implementations.

Signature

declare abstract class DataSourceApi<TQuery extends DataQuery = DataQuery, TOptions extends DataSourceJsonData = DataSourceJsonData, TQueryImportConfiguration extends Record<string, object> = {}>

Import

import { DataSourceApi } from '@grafana/data';

Constructors

Constructor	Modifiers	Description
constructor(instanceSettings)		Constructs a new instance of the `DataSourceApi` class

Properties

Property	Type	Description
annotations	`AnnotationSupport<TQuery>`	An annotation processor allows explicit control for how annotations are managed.It is only necessary to configure an annotation processor if the default behavior is not desirable
components	`DataSourcePluginComponents<DataSourceApi<TQuery, TOptions>, TQuery, TOptions>`	Set after constructor call, as the data source instance is the most common thing to pass around we attach the components to this instance for easy access
getLogRowContext	`<TContextQueryOptions extends {}>(row: LogRowModel, options?: TContextQueryOptions) => Promise<DataQueryResponse>`
id	`number`	Set in constructor
init	`() => void`	Initializes a datasource after instantiation
interval	`string`	min interval range
languageProvider	`any`	Used in explore
meta	`DataSourcePluginMeta`	static information about the datasource
name	`string`	Set in constructor
type	`string`	Set in constructor
uid	`string`	Set in constructor

Methods

Method	Modifiers	Description
annotationQuery(options)		Can be optionally implemented to allow datasource to be a source of annotations for dashboard. This function will only be called if an angular is configured and the is undefined
filterQuery(query)		Override to skip executing a query
getHighlighterExpression(query)
getImportQueryConfiguration()		Returns configuration for importing queries from other data sources
getQueryDisplayText(query)		Convert a query to a simple text string
getQueryHints(query, results, rest)		Get hints for query improvements
getRef()		Get an identifier object for this datasource instance
getTagKeys(options)		Get tag keys for adhoc filters
getTagValues(options)		Get tag values for adhoc filters
getVersion(optionalOptions)
importQueries(queries, originDataSource)
interpolateVariablesInQueries(queries, scopedVars)
metricFindQuery(query, options)		Variable query action.
modifyQuery(query, action)		Used in explore
query(request)		Query for data, and optionally stream results
showContextToggle(row)
targetContainsTemplate(query)		Used by alerting to check if query contains template variables
testDatasource()		Test & verify datasource settings & connection details (returning TestingStatus)When verification fails - errors specific to the data source should be handled here and converted to a TestingStatus object. Unknown errors and HTTP errors can be re-thrown and will be handled here: public/app/features/datasources/state/actions.ts

constructor(instanceSettings)

Constructs a new instance of the DataSourceApi class

Signature

constructor(instanceSettings: DataSourceInstanceSettings<TOptions>);

Parameters

Parameter	Type	Description
instanceSettings	`DataSourceInstanceSettings<TOptions>`

annotations property

An annotation processor allows explicit control for how annotations are managed.

It is only necessary to configure an annotation processor if the default behavior is not desirable

Signature

annotations?: AnnotationSupport<TQuery>;

components property

Set after constructor call, as the data source instance is the most common thing to pass around we attach the components to this instance for easy access

Signature

components?: DataSourcePluginComponents<DataSourceApi<TQuery, TOptions>, TQuery, TOptions>;

getLogRowContext property

Signature

getLogRowContext?: <TContextQueryOptions extends {}>(row: LogRowModel, options?: TContextQueryOptions) => Promise<DataQueryResponse>;

id property

Set in constructor

Signature

readonly id: number;

init property

Initializes a datasource after instantiation

Signature

init?: () => void;

interval property

min interval range

Signature

interval?: string;

languageProvider property

Used in explore

Signature

languageProvider?: any;

meta property

static information about the datasource

Signature

meta: DataSourcePluginMeta;

name property

Set in constructor

Signature

readonly name: string;

type property

Set in constructor

Signature

readonly type: string;

uid property

Set in constructor

Signature

readonly uid: string;

annotationQuery method

Can be optionally implemented to allow datasource to be a source of annotations for dashboard. This function will only be called if an angular is configured and the is undefined

Signature

annotationQuery?(options: AnnotationQueryRequest<TQuery>): Promise<AnnotationEvent[]>;

Parameters

Parameter	Type	Description
options	`AnnotationQueryRequest<TQuery>`

Returns:

Promise<AnnotationEvent[]>

filterQuery method

Override to skip executing a query

Signature

/** @virtual */
filterQuery?(query: TQuery): boolean;

Parameters

Parameter	Type	Description
query	`TQuery`

Returns:

boolean

false if the query should be skipped

getHighlighterExpression method

Signature

getHighlighterExpression?(query: TQuery): string[];

Parameters

Parameter	Type	Description
query	`TQuery`

Returns:

string[]

getImportQueryConfiguration method

Returns configuration for importing queries from other data sources

Signature

getImportQueryConfiguration?(): TQueryImportConfiguration;

Returns:

TQueryImportConfiguration

getQueryDisplayText method

Convert a query to a simple text string

Signature

getQueryDisplayText?(query: TQuery): string;

Parameters

Parameter	Type	Description
query	`TQuery`

Returns:

string

getQueryHints method

Get hints for query improvements

Signature

getQueryHints?(query: TQuery, results: any[], ...rest: any): QueryHint[];

Parameters

Parameter	Type	Description
query	`TQuery`
results	`any[]`
rest	`any`

Returns:

QueryHint[]

getRef method

Get an identifier object for this datasource instance

Signature

getRef(): DataSourceRef;

Returns:

DataSourceRef

getTagKeys method

Get tag keys for adhoc filters

Signature

getTagKeys?(options?: any): Promise<MetricFindValue[]>;

Parameters

Parameter	Type	Description
options	`any`

Returns:

Promise<MetricFindValue[]>

getTagValues method

Get tag values for adhoc filters

Signature

getTagValues?(options: any): Promise<MetricFindValue[]>;

Parameters

Parameter	Type	Description
options	`any`

Returns:

Promise<MetricFindValue[]>

getVersion method

Signature

getVersion?(optionalOptions?: any): Promise<string>;

Parameters

Parameter	Type	Description
optionalOptions	`any`

Returns:

Promise<string>

importQueries method

Signature

importQueries?(queries: DataQuery[], originDataSource: DataSourceApi<DataQuery>): Promise<TQuery[]>;

Parameters

Parameter	Type	Description
queries	`DataQuery[]`
originDataSource	`DataSourceApi<DataQuery>`

Returns:

Promise<TQuery[]>

interpolateVariablesInQueries method

Signature

interpolateVariablesInQueries?(queries: TQuery[], scopedVars: ScopedVars | {}): TQuery[];

Parameters

Parameter	Type	Description
queries	`TQuery[]`
scopedVars	`ScopedVars \| {}`

Returns:

TQuery[]

metricFindQuery method

Variable query action.

Signature

metricFindQuery?(query: any, options?: any): Promise<MetricFindValue[]>;

Parameters

Parameter	Type	Description
query	`any`
options	`any`

Returns:

Promise<MetricFindValue[]>

modifyQuery method

Used in explore

Signature

modifyQuery?(query: TQuery, action: QueryFixAction): TQuery;

Parameters

Parameter	Type	Description
query	`TQuery`
action	`QueryFixAction`

Returns:

TQuery

query method

Query for data, and optionally stream results

Signature

abstract query(request: DataQueryRequest<TQuery>): Promise<DataQueryResponse> | Observable<DataQueryResponse>;

Parameters

Parameter	Type	Description
request	`DataQueryRequest<TQuery>`

Returns:

Promise<DataQueryResponse> | Observable<DataQueryResponse>

showContextToggle method

Signature

showContextToggle?(row?: LogRowModel): boolean;

Parameters

Parameter	Type	Description
row	`LogRowModel`

Returns:

boolean

targetContainsTemplate method

Used by alerting to check if query contains template variables

Signature

targetContainsTemplate?(query: TQuery): boolean;

Parameters

Parameter	Type	Description
query	`TQuery`

Returns:

boolean

testDatasource method

Test & verify datasource settings & connection details (returning TestingStatus)

When verification fails - errors specific to the data source should be handled here and converted to a TestingStatus object. Unknown errors and HTTP errors can be re-thrown and will be handled here: public/app/features/datasources/state/actions.ts

Signature

abstract testDatasource(): Promise<any>;

Returns:

Promise<any>

DataSourceConstructor

Sat, 04 Apr 2026 12:26:57 +0000

DataSourceConstructor interface

Signature

export interface DataSourceConstructor<DSType extends DataSourceApi<TQuery, TOptions>, TQuery extends DataQuery = DataQuery, TOptions extends DataSourceJsonData = DataSourceJsonData>

Import

import { DataSourceConstructor } from '@grafana/data';

Methods

Method	Description
new(instanceSettings, args)

new(instanceSettings, args)

Signature

new (instanceSettings: DataSourceInstanceSettings<TOptions>, ...args: any[]): DSType;

Parameters

Parameter	Type	Description
instanceSettings	`DataSourceInstanceSettings<TOptions>`
args	`any[]`

Returns:

DSType

DataSourceInstanceSettings

Sat, 04 Apr 2026 12:26:57 +0000

DataSourceInstanceSettings interface

Frontend settings model that is passed to Datasource constructor. This differs a bit from the model above as this data model is available to every user who has access to a data source (Viewers+). This is loaded in bootData (on page load), or from: /api/frontend/settings

Signature

export interface DataSourceInstanceSettings<T extends DataSourceJsonData = DataSourceJsonData>

Import

import { DataSourceInstanceSettings } from '@grafana/data';

Properties

Property	Type	Description
access	`‘direct’ \| ‘proxy’`
basicAuth	`string`	This is the full Authorization header if basic auth is enabled. Only available here when access is Browser (direct), when access is Server (proxy) The basic auth header, username & password is never exposed to browser/Frontend so this will be empty then.
database	`string`
id	`number`
isDefault	`boolean`
jsonData	`T`
meta	`DataSourcePluginMeta`
name	`string`
password	`string`
rawRef	`DataSourceRef`	When the name+uid are based on template variables, maintain access to the real values
type	`string`
uid	`string`
url	`string`
username	`string`
withCredentials	`boolean`

access property

Signature

access: 'direct' | 'proxy';

basicAuth property

This is the full Authorization header if basic auth is enabled. Only available here when access is Browser (direct), when access is Server (proxy) The basic auth header, username & password is never exposed to browser/Frontend so this will be empty then.

Signature

basicAuth?: string;

database property

Signature

database?: string;

id property

Signature

id: number;

isDefault property

Signature

isDefault?: boolean;

jsonData property

Signature

jsonData: T;

meta property

Signature

meta: DataSourcePluginMeta;

name property

Signature

name: string;

password property

Signature

password?: string;

rawRef property

When the name+uid are based on template variables, maintain access to the real values

Signature

rawRef?: DataSourceRef;

type property

Signature

type: string;

uid property

Signature

uid: string;

url property

Signature

url?: string;

username property

Signature

username?: string;

withCredentials property

Signature

withCredentials?: boolean;

DataSourceJsonData

Sat, 04 Apr 2026 12:26:57 +0000

DataSourceJsonData interface

Signature

export interface DataSourceJsonData

Import

import { DataSourceJsonData } from '@grafana/data';

Properties

Property	Type	Description
alertmanagerUid	`string`
authType	`string`
defaultRegion	`string`
manageAlerts	`boolean`
profile	`string`

alertmanagerUid property

Signature

alertmanagerUid?: string;

authType property

Signature

authType?: string;

defaultRegion property

Signature

defaultRegion?: string;

manageAlerts property

Signature

manageAlerts?: boolean;

profile property

Signature

profile?: string;

DataSourceOptionsType

Sat, 04 Apr 2026 12:26:57 +0000

DataSourceOptionsType type

Signature

export declare type DataSourceOptionsType<DSType> = DSType extends DataSourceApi<any, infer TOptions> ? TOptions : never;

Import

import { DataSourceOptionsType } from '@grafana/data';

DataSourcePlugin

Sat, 04 Apr 2026 12:26:57 +0000

DataSourcePlugin class

Signature

export declare class DataSourcePlugin<DSType extends DataSourceApi<TQuery, TOptions>, TQuery extends DataQuery = DataSourceQueryType<DSType>, TOptions extends DataSourceJsonData = DataSourceOptionsType<DSType>, TSecureOptions = {}> extends GrafanaPlugin<DataSourcePluginMeta<TOptions>>

Import

import { DataSourcePlugin } from '@grafana/data';

Constructors

Constructor	Modifiers	Description
constructor(DataSourceClass)		Constructs a new instance of the `DataSourcePlugin` class

Properties

Property	Modifiers	Type	Description
components		`DataSourcePluginComponents<DSType, TQuery, TOptions, TSecureOptions>`
DataSourceClass		`DataSourceConstructor<DSType, TQuery, TOptions>`

Methods

Method	Modifiers	Description
setAnnotationQueryCtrl(AnnotationsQueryCtrl)
setComponentsFromLegacyExports(pluginExports)
setConfigCtrl(ConfigCtrl)
setConfigEditor(editor)
setExploreLogsQueryField(ExploreQueryField)
setExploreMetricsQueryField(ExploreQueryField)
setExploreQueryField(ExploreQueryField)
setExploreStartPage(ExploreStartPage)
setMetadataInspector(MetadataInspector)
setQueryCtrl(QueryCtrl)
setQueryEditor(QueryEditor)
setQueryEditorHelp(QueryEditorHelp)
setVariableQueryEditor(VariableQueryEditor)

constructor(DataSourceClass)

Constructs a new instance of the DataSourcePlugin class

Signature

constructor(DataSourceClass: DataSourceConstructor<DSType, TQuery, TOptions>);

Parameters

Parameter	Type	Description
DataSourceClass	`DataSourceConstructor<DSType, TQuery, TOptions>`

components property

Signature

components: DataSourcePluginComponents<DSType, TQuery, TOptions, TSecureOptions>;

DataSourceClass property

Signature

DataSourceClass: DataSourceConstructor<DSType, TQuery, TOptions>;

setAnnotationQueryCtrl method

Signature

setAnnotationQueryCtrl(AnnotationsQueryCtrl: any): this;

Parameters

Parameter	Type	Description
AnnotationsQueryCtrl	`any`

Returns:

this

setComponentsFromLegacyExports method

Signature

setComponentsFromLegacyExports(pluginExports: any): void;

Parameters

Parameter	Type	Description
pluginExports	`any`

Returns:

void

setConfigCtrl method

Signature

setConfigCtrl(ConfigCtrl: any): this;

Parameters

Parameter	Type	Description
ConfigCtrl	`any`

Returns:

this

setConfigEditor method

Signature

setConfigEditor(editor: ComponentType<DataSourcePluginOptionsEditorProps<TOptions, TSecureOptions>>): this;

Parameters

Parameter	Type	Description
editor	`ComponentType<DataSourcePluginOptionsEditorProps<TOptions, TSecureOptions>>`

Returns:

this

setExploreLogsQueryField method

Signature

setExploreLogsQueryField(ExploreQueryField: ComponentType<QueryEditorProps<DSType, TQuery, TOptions>>): this;

Parameters

Parameter	Type	Description
ExploreQueryField	`ComponentType<QueryEditorProps<DSType, TQuery, TOptions>>`

Returns:

this

setExploreMetricsQueryField method

Signature

setExploreMetricsQueryField(ExploreQueryField: ComponentType<QueryEditorProps<DSType, TQuery, TOptions>>): this;

Parameters

Parameter	Type	Description
ExploreQueryField	`ComponentType<QueryEditorProps<DSType, TQuery, TOptions>>`

Returns:

this

setExploreQueryField method

Signature

setExploreQueryField(ExploreQueryField: ComponentType<QueryEditorProps<DSType, TQuery, TOptions>>): this;

Parameters

Parameter	Type	Description
ExploreQueryField	`ComponentType<QueryEditorProps<DSType, TQuery, TOptions>>`

Returns:

this

setExploreStartPage method

Signature

setExploreStartPage(ExploreStartPage: ComponentType<QueryEditorHelpProps<TQuery>>): this;

Parameters

Parameter	Type	Description
ExploreStartPage	`ComponentType<QueryEditorHelpProps<TQuery>>`

Returns:

this

setMetadataInspector method

Signature

setMetadataInspector(MetadataInspector: ComponentType<MetadataInspectorProps<DSType, TQuery, TOptions>>): this;

Parameters

Parameter	Type	Description
MetadataInspector	`ComponentType<MetadataInspectorProps<DSType, TQuery, TOptions>>`

Returns:

this

setQueryCtrl method

Signature

setQueryCtrl(QueryCtrl: any): this;

Parameters

Parameter	Type	Description
QueryCtrl	`any`

Returns:

this

setQueryEditor method

Signature

setQueryEditor(QueryEditor: ComponentType<QueryEditorProps<DSType, TQuery, TOptions>>): this;

Parameters

Parameter	Type	Description
QueryEditor	`ComponentType<QueryEditorProps<DSType, TQuery, TOptions>>`

Returns:

this

setQueryEditorHelp method

Signature

setQueryEditorHelp(QueryEditorHelp: ComponentType<QueryEditorHelpProps<TQuery>>): this;

Parameters

Parameter	Type	Description
QueryEditorHelp	`ComponentType<QueryEditorHelpProps<TQuery>>`

Returns:

this

setVariableQueryEditor method

Signature

setVariableQueryEditor(VariableQueryEditor: any): this;

Parameters

Parameter	Type	Description
VariableQueryEditor	`any`

Returns:

this

DataSourcePluginComponents

Sat, 04 Apr 2026 12:26:57 +0000

DataSourcePluginComponents interface

Signature

export interface DataSourcePluginComponents<DSType extends DataSourceApi<TQuery, TOptions>, TQuery extends DataQuery = DataQuery, TOptions extends DataSourceJsonData = DataSourceJsonData, TSecureOptions = {}>

Import

import { DataSourcePluginComponents } from '@grafana/data';

Properties

Property	Type	Description
AnnotationsQueryCtrl	`any`
ConfigEditor	`ComponentType<DataSourcePluginOptionsEditorProps<TOptions, TSecureOptions>>`
ExploreLogsQueryField	`ComponentType<QueryEditorProps<DSType, TQuery, TOptions>>`
ExploreMetricsQueryField	`ComponentType<QueryEditorProps<DSType, TQuery, TOptions>>`
ExploreQueryField	`ComponentType<QueryEditorProps<DSType, TQuery, TOptions>>`
MetadataInspector	`ComponentType<MetadataInspectorProps<DSType, TQuery, TOptions>>`
QueryCtrl	`any`
QueryEditor	`ComponentType<QueryEditorProps<DSType, TQuery, TOptions>>`
QueryEditorHelp	`ComponentType<QueryEditorHelpProps<TQuery>>`
VariableQueryEditor	`any`

AnnotationsQueryCtrl property

Signature

AnnotationsQueryCtrl?: any;

ConfigEditor property

Signature

ConfigEditor?: ComponentType<DataSourcePluginOptionsEditorProps<TOptions, TSecureOptions>>;

ExploreLogsQueryField property

Signature

ExploreLogsQueryField?: ComponentType<QueryEditorProps<DSType, TQuery, TOptions>>;

ExploreMetricsQueryField property

Signature

ExploreMetricsQueryField?: ComponentType<QueryEditorProps<DSType, TQuery, TOptions>>;

ExploreQueryField property

Signature

ExploreQueryField?: ComponentType<QueryEditorProps<DSType, TQuery, TOptions>>;

MetadataInspector property

Signature

MetadataInspector?: ComponentType<MetadataInspectorProps<DSType, TQuery, TOptions>>;

QueryCtrl property

Signature

QueryCtrl?: any;

QueryEditor property

Signature

QueryEditor?: ComponentType<QueryEditorProps<DSType, TQuery, TOptions>>;

QueryEditorHelp property

Signature

QueryEditorHelp?: ComponentType<QueryEditorHelpProps<TQuery>>;

VariableQueryEditor property

Signature

VariableQueryEditor?: any;

DataSourcePluginMeta

Sat, 04 Apr 2026 12:26:57 +0000

DataSourcePluginMeta interface

Signature

export interface DataSourcePluginMeta<T extends KeyValue = {}> extends PluginMeta<T>

Import

import { DataSourcePluginMeta } from '@grafana/data';

Properties

Property	Type	Description
alerting	`boolean`
annotations	`boolean`
backend	`boolean`
builtIn	`boolean`
category	`string`
hasQueryHelp	`boolean`
isBackend	`boolean`
logs	`boolean`
metrics	`boolean`
mixed	`boolean`
queryOptions	`PluginMetaQueryOptions`
sort	`number`
streaming	`boolean`
tracing	`boolean`
unlicensed	`boolean`

alerting property

Signature

alerting?: boolean;

annotations property

Signature

annotations?: boolean;

backend property

Signature

backend?: boolean;

builtIn property

Signature

builtIn?: boolean;

category property

Signature

category?: string;

hasQueryHelp property

Signature

hasQueryHelp?: boolean;

isBackend property

Signature

isBackend?: boolean;

logs property

Signature

logs?: boolean;

metrics property

Signature

metrics?: boolean;

mixed property

Signature

mixed?: boolean;

queryOptions property

Signature

queryOptions?: PluginMetaQueryOptions;

sort property

Signature

sort?: number;

streaming property

Signature

streaming?: boolean;

tracing property

Signature

tracing?: boolean;

unlicensed property

Signature

unlicensed?: boolean;

DataSourcePluginOptionsEditorProps

Sat, 04 Apr 2026 12:26:57 +0000

DataSourcePluginOptionsEditorProps interface

Signature

export interface DataSourcePluginOptionsEditorProps<JSONData = DataSourceJsonData, SecureJSONData = {}>

Import

import { DataSourcePluginOptionsEditorProps } from '@grafana/data';

Properties

Property	Type	Description
onOptionsChange	`(options: DataSourceSettings<JSONData, SecureJSONData>) => void`
options	`DataSourceSettings<JSONData, SecureJSONData>`

onOptionsChange property

Signature

onOptionsChange: (options: DataSourceSettings<JSONData, SecureJSONData>) => void;

options property

Signature

options: DataSourceSettings<JSONData, SecureJSONData>;

DataSourceQueryType

Sat, 04 Apr 2026 12:26:57 +0000

DataSourceQueryType type

Signature

export declare type DataSourceQueryType<DSType> = DSType extends DataSourceApi<infer TQuery, any> ? TQuery : never;

Import

import { DataSourceQueryType } from '@grafana/data';

DataSourceRef

Sat, 04 Apr 2026 12:26:57 +0000

DataSourceRef interface

Signature

export interface DataSourceRef

Import

import { DataSourceRef } from '@grafana/data';

Properties

Property	Type	Description
type	`string`	The plugin type-id
uid	`string`	Specific datasource instance

type property

The plugin type-id

Signature

type?: string;

uid property

Specific datasource instance

Signature

uid?: string;

DataSourceSelectItem

Sat, 04 Apr 2026 12:26:57 +0000

DataSourceSelectItem interface

Signature

export interface DataSourceSelectItem

Import

import { DataSourceSelectItem } from '@grafana/data';

Properties

Property	Type	Description
meta	`DataSourcePluginMeta`
name	`string`
value	`string \| null`

meta property

Signature

meta: DataSourcePluginMeta;

name property

Signature

name: string;

value property

Signature

value: string | null;

DataSourceSettings

Sat, 04 Apr 2026 12:26:57 +0000

DataSourceSettings interface

Data Source instance edit model. This is returned from: /api/datasources

Signature

export interface DataSourceSettings<T extends DataSourceJsonData = DataSourceJsonData, S = {}> extends WithAccessControlMetadata

Import

import { DataSourceSettings } from '@grafana/data';

Properties

Property	Type	Description
access	`string`
basicAuth	`boolean`
basicAuthPassword	`string`
basicAuthUser	`string`
database	`string`
id	`number`
isDefault	`boolean`
jsonData	`T`
name	`string`
orgId	`number`
password	`string`
readOnly	`boolean`
secureJsonData	`S`
secureJsonFields	`KeyValue<boolean>`
type	`string`
typeLogoUrl	`string`
typeName	`string`
uid	`string`
url	`string`
user	`string`
version	`number`
withCredentials	`boolean`

access property

Signature

access: string;

basicAuth property

Signature

basicAuth: boolean;

basicAuthPassword property

Signature

basicAuthPassword: string;

basicAuthUser property

Signature

basicAuthUser: string;

database property

Signature

database: string;

id property

Signature

id: number;

isDefault property

Signature

isDefault: boolean;

jsonData property

Signature

jsonData: T;

name property

Signature

name: string;

orgId property

Signature

orgId: number;

password property

Signature

password: string;

readOnly property

Signature

readOnly: boolean;

secureJsonData property

Signature

secureJsonData?: S;

secureJsonFields property

Signature

secureJsonFields: KeyValue<boolean>;

type property

Signature

type: string;

typeLogoUrl property

Signature

typeLogoUrl: string;

typeName property

Signature

typeName: string;

uid property

Signature

uid: string;

url property

Signature

url: string;

user property

Signature

user: string;

version property

Signature

version?: number;

withCredentials property

Signature

withCredentials: boolean;

DataTopic

Sat, 04 Apr 2026 12:26:57 +0000

DataTopic enum

Attached to query results (not persisted)

Signature

export declare enum DataTopic

Import

import { DataTopic } from '@grafana/data';

Enumeration Members

Member	Value	Description
Annotations	`"annotations"`

DataTransformerConfig

Sat, 04 Apr 2026 12:26:57 +0000

DataTransformerConfig interface

Signature

export interface DataTransformerConfig<TOptions = any>

Import

import { DataTransformerConfig } from '@grafana/data';

Properties

Property	Type	Description
disabled	`boolean`	Disabled transformations are skipped
id	`string`	Unique identifier of transformer
options	`TOptions`	Options to be passed to the transformer

disabled property

Disabled transformations are skipped

Signature

disabled?: boolean;

id property

Unique identifier of transformer

Signature

id: string;

options property

Options to be passed to the transformer

Signature

options: TOptions;

DataTransformerID

Sat, 04 Apr 2026 12:26:57 +0000

DataTransformerID enum

Signature

export declare enum DataTransformerID

Import

import { DataTransformerID } from '@grafana/data';

Enumeration Members

Member	Value	Description
append	`"append"`
calculateField	`"calculateField"`
concatenate	`"concatenate"`
configFromData	`"configFromData"`
convertFieldType	`"convertFieldType"`
ensureColumns	`"ensureColumns"`
extractFields	`"extractFields"`
fieldLookup	`"fieldLookup"`
filterByRefId	`"filterByRefId"`
filterByValue	`"filterByValue"`
filterFields	`"filterFields"`
filterFieldsByName	`"filterFieldsByName"`
filterFrames	`"filterFrames"`
groupBy	`"groupBy"`
histogram	`"histogram"`
labelsToFields	`"labelsToFields"`
merge	`"merge"`
noop	`"noop"`
order	`"order"`
organize	`"organize"`
prepareTimeSeries	`"prepareTimeSeries"`
reduce	`"reduce"`
rename	`"rename"`
renameByRegex	`"renameByRegex"`
rowsToFields	`"rowsToFields"`
seriesToColumns	`"seriesToColumns"`
seriesToRows	`"seriesToRows"`
sortBy	`"sortBy"`
spatial	`"spatial"`

DataTransformerInfo

Sat, 04 Apr 2026 12:26:57 +0000

DataTransformerInfo interface

Function that transform data frames (AKA transformer)

Signature

export interface DataTransformerInfo<TOptions = any> extends RegistryItemWithOptions

Import

import { DataTransformerInfo } from '@grafana/data';

Properties

Property	Type	Description
operator	`(options: TOptions) => MonoTypeOperatorFunction<DataFrame[]>`	Function that configures transformation and returns a transformer

operator property

Function that configures transformation and returns a transformer

Signature

operator: (options: TOptions) => MonoTypeOperatorFunction<DataFrame[]>;

dateMath

Sat, 04 Apr 2026 12:26:57 +0000

dateMath namespace

dateMath namespace

Import

import { dateMath } from '@grafana/data';

Functions

Function	Description
isMathString(text)	Determine if a string contains a relative date time.
isValid(text)	Checks if text is a valid date which in this context means that it is either a Moment instance or it can be parsed by parse function. See parse function to see what is considered acceptable.
parse(text, roundUp, timezone, fiscalYearStartMonth)	Parses different types input to a moment instance. There is a specific formatting language that can be used if text arg is string. See unit tests for examples.
parseDateMath(mathString, time, roundUp, fiscalYearStartMonth)	Parses math part of the time string and shifts supplied time according to that math. See unit tests for examples.
roundToFiscal(fyStartMonth, dateTime, unit, roundUp)

dateTime

Sat, 04 Apr 2026 12:26:57 +0000

dateTime variable

Signature

dateTime: (input?: DateTimeInput | undefined, formatInput?: FormatInput) => DateTime

Import

import { dateTime } from '@grafana/data';

dateTimeAsMoment

Sat, 04 Apr 2026 12:26:57 +0000

dateTimeAsMoment variable

Signature

dateTimeAsMoment: (input?: DateTimeInput | undefined) => moment.Moment

Import

import { dateTimeAsMoment } from '@grafana/data';

DateTimeBuiltinFormat

Sat, 04 Apr 2026 12:26:57 +0000

DateTimeBuiltinFormat interface

Signature

export interface DateTimeBuiltinFormat

Import

import { DateTimeBuiltinFormat } from '@grafana/data';

Properties

Property	Type	Description
__momentBuiltinFormatBrand	`any`

__momentBuiltinFormatBrand property

Signature

__momentBuiltinFormatBrand: any;

DateTimeDuration

Sat, 04 Apr 2026 12:26:57 +0000

DateTimeDuration interface

Signature

export interface DateTimeDuration

Import

import { DateTimeDuration } from '@grafana/data';

Properties

Property	Type	Description
asHours	`() => number`
asSeconds	`() => number`
hours	`() => number`
minutes	`() => number`
seconds	`() => number`

asHours property

Signature

asHours: () => number;

asSeconds property

Signature

asSeconds: () => number;

hours property

Signature

hours: () => number;

minutes property

Signature

minutes: () => number;

seconds property

Signature

seconds: () => number;

dateTimeFormat

Sat, 04 Apr 2026 12:26:57 +0000

dateTimeFormat variable

Helper function to format date and time according to the specified options. If no options are supplied, then default values are used. For more details, see DateTimeOptionsWithFormat.

Signature

dateTimeFormat: DateTimeFormatter<DateTimeOptionsWithFormat>

Import

import { dateTimeFormat } from '@grafana/data';

dateTimeFormatISO

Sat, 04 Apr 2026 12:26:57 +0000

dateTimeFormatISO variable

Helper function to format date and time according to the standard ISO format e.g. 2013-02-04T22:44:30.652Z. If no options are supplied, then default values are used. For more details, see DateTimeOptionsWithFormat.

Signature

dateTimeFormatISO: DateTimeFormatter

Import

import { dateTimeFormatISO } from '@grafana/data';

dateTimeFormatTimeAgo

Sat, 04 Apr 2026 12:26:57 +0000

dateTimeFormatTimeAgo variable

Helper function to return elapsed time since passed date. The returned value will be formatted in a human readable format e.g. 4 years ago. If no options are supplied, then default values are used. For more details, see DateTimeOptions.

Signature

dateTimeFormatTimeAgo: DateTimeFormatter

Import

import { dateTimeFormatTimeAgo } from '@grafana/data';

dateTimeFormatWithAbbrevation

Sat, 04 Apr 2026 12:26:57 +0000

dateTimeFormatWithAbbrevation variable

Helper function to format date and time according to the Grafana default formatting, but it also appends the time zone abbreviation at the end e.g. 2020-05-20 13:37:00 CET. If no options are supplied, then default values are used. For more details please see DateTimeOptions.

Signature

dateTimeFormatWithAbbrevation: DateTimeFormatter

Import

import { dateTimeFormatWithAbbrevation } from '@grafana/data';

dateTimeForTimeZone

Sat, 04 Apr 2026 12:26:57 +0000

dateTimeForTimeZone variable

Signature

dateTimeForTimeZone: (timezone?: string | undefined, input?: DateTimeInput | undefined, formatInput?: FormatInput) => DateTime

Import

import { dateTimeForTimeZone } from '@grafana/data';

DateTimeInput

Sat, 04 Apr 2026 12:26:57 +0000

DateTimeInput type

Signature

export declare type DateTimeInput = Date | string | number | Array<string | number> | DateTime | null;

Import

import { DateTimeInput } from '@grafana/data';

DateTimeLocale

Sat, 04 Apr 2026 12:26:57 +0000

DateTimeLocale interface

Signature

export interface DateTimeLocale

Import

import { DateTimeLocale } from '@grafana/data';

Properties

Property	Type	Description
firstDayOfWeek	`() => number`

firstDayOfWeek property

Signature

firstDayOfWeek: () => number;

DateTimeOptions

Sat, 04 Apr 2026 12:26:57 +0000

DateTimeOptions interface

The type describing date and time options. Used for all the helper functions available to parse or format date and time values.

Signature

export interface DateTimeOptions extends TimeZoneOptions

Import

import { DateTimeOptions } from '@grafana/data';

Properties

Property	Type	Description
format	`string`	Specify a momentjs format to use a custom formatting pattern or parsing pattern. If no format is set, then system configured default format is used.

format property

Specify a momentjs format to use a custom formatting pattern or parsing pattern. If no format is set, then system configured default format is used.

Signature

format?: string;

DateTimeOptionsWhenParsing

Sat, 04 Apr 2026 12:26:57 +0000

DateTimeOptionsWhenParsing interface

The type that describes options that can be passed when parsing a date and time value.

Signature

export interface DateTimeOptionsWhenParsing extends DateTimeOptions

Import

import { DateTimeOptionsWhenParsing } from '@grafana/data';

Properties

Property	Type	Description
fiscalYearStartMonth	`number`
roundUp	`boolean`	If the input is a Grafana quick date, e.g. now-6h, then you can specify this to control whether the last part of the date and time value is included or excluded.Example: now-6h and the current time is 12:20:00 if roundUp is set to true the returned DateTime value will be 06:00:00.

fiscalYearStartMonth property

Signature

fiscalYearStartMonth?: number;

roundUp property

If the input is a Grafana quick date, e.g. now-6h, then you can specify this to control whether the last part of the date and time value is included or excluded.

Example: now-6h and the current time is 12:20:00 if roundUp is set to true the returned DateTime value will be 06:00:00.

Signature

roundUp?: boolean;

DateTimeOptionsWithFormat

Sat, 04 Apr 2026 12:26:57 +0000

DateTimeOptionsWithFormat interface

The type describing the options that can be passed to the dateTimeFormat helper function to control how the date and time value passed to the function is formatted.

Signature

export interface DateTimeOptionsWithFormat extends DateTimeOptions

Import

import { DateTimeOptionsWithFormat } from '@grafana/data';

Properties

Property	Type	Description
defaultWithMS	`boolean`	Set this value to `true` if you want to include milliseconds when formatting date and time

defaultWithMS property

Set this value to true if you want to include milliseconds when formatting date and time

Signature

defaultWithMS?: boolean;

dateTimeParse

Sat, 04 Apr 2026 12:26:57 +0000

dateTimeParse variable

Helper function to parse a number, text or Date to a DateTime value. If a timeZone is supplied the incoming value is parsed with that timeZone as a base. The only exception to this is if the passed value is in a UTC-based format. Then it will use UTC as the base. If no format is specified the current system format will be assumed.

It can also parse the Grafana quick date and time format, e.g. now-6h will be parsed as Date.now() - 6 hours and returned as a valid DateTime value.

If no options are supplied, then default values are used. For more details please see DateTimeOptions.

Signature

dateTimeParse: DateTimeParser<DateTimeOptionsWhenParsing>

Import

import { dateTimeParse } from '@grafana/data';

DecimalCount

Sat, 04 Apr 2026 12:26:57 +0000

DecimalCount type

Signature

export declare type DecimalCount = number | null | undefined;

Import

import { DecimalCount } from '@grafana/data';

DecimalInfo

Sat, 04 Apr 2026 12:26:57 +0000

DecimalInfo interface

Signature

export interface DecimalInfo

Import

import { DecimalInfo } from '@grafana/data';

Properties

Property	Type	Description
decimals	`DecimalCount`
scaledDecimals	`DecimalCount`

decimals property

Signature

decimals: DecimalCount;

scaledDecimals property

Signature

scaledDecimals: DecimalCount;

decomposeColor

Sat, 04 Apr 2026 12:26:57 +0000

colorManipulator.decomposeColor() function

colorManipulator.decomposeColor() function

Returns an object with the type and values of a color.

Note: Does not support rgb % values.

Signature

export declare function decomposeColor(color: string | DecomposeColor): DecomposeColor;

Import

import { colorManipulator } from '@grafana/data';
const { decomposeColor } = colorManipulator;

Parameters

Parameter	Type	Description
color	`string \| DecomposeColor`	CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla()

Returns:

DecomposeColor

{object} - A MUI color object: {type: string, values: number[]}

DEFAULT_FIELD_DISPLAY_VALUES_LIMIT

Sat, 04 Apr 2026 12:26:57 +0000

DEFAULT_FIELD_DISPLAY_VALUES_LIMIT variable

Signature

DEFAULT_FIELD_DISPLAY_VALUES_LIMIT = 25

Import

import { DEFAULT_FIELD_DISPLAY_VALUES_LIMIT } from '@grafana/data';

DEFAULT_SAML_NAME

Sat, 04 Apr 2026 12:26:57 +0000

DEFAULT_SAML_NAME variable

Signature

DEFAULT_SAML_NAME = "SAML"

Import

import { DEFAULT_SAML_NAME } from '@grafana/data';

DefaultTimeZone

Sat, 04 Apr 2026 12:26:57 +0000

DefaultTimeZone variable

Signature

DefaultTimeZone: TimeZone

Import

import { DefaultTimeZone } from '@grafana/data';

deprecationWarning

Sat, 04 Apr 2026 12:26:57 +0000

deprecationWarning variable

Signature

deprecationWarning: (file: string, oldName: string, newName?: string | undefined) => void

Import

import { deprecationWarning } from '@grafana/data';

describeInterval

Sat, 04 Apr 2026 12:26:57 +0000

rangeUtil.describeInterval() function

Signature

export declare function describeInterval(str: string): {
    sec: number;
    type: string;
    count: number;
};

Import

import { rangeUtil } from '@grafana/data';
const { describeInterval } = rangeUtil;

Parameters

Parameter	Type	Description
str	`string`

Returns:

{ sec: number; type: string; count: number; }

describeTextRange

Sat, 04 Apr 2026 12:26:57 +0000

rangeUtil.describeTextRange() function

Signature

export declare function describeTextRange(expr: any): any;

Import

import { rangeUtil } from '@grafana/data';
const { describeTextRange } = rangeUtil;

Parameters

Parameter	Type	Description
expr	`any`

Returns:

any

describeTimeRangeAbbreviation

Sat, 04 Apr 2026 12:26:57 +0000

rangeUtil.describeTimeRangeAbbreviation variable

Signature

describeTimeRangeAbbreviation: (range: TimeRange, timeZone?: string | undefined) => string

Import

import { rangeUtil } from '@grafana/data';
const { describeTimeRangeAbbreviation } = rangeUtil;

Dimension

Sat, 04 Apr 2026 12:26:57 +0000

Dimension interface

Signature

export interface Dimension<T = any>

Import

import { Dimension } from '@grafana/data';

Properties

Property	Type	Description
columns	`Array<Field<T>>`
name	`string`

columns property

Signature

columns: Array<Field<T>>;

name property

Signature

name: string;

Dimensions

Sat, 04 Apr 2026 12:26:57 +0000

Dimensions type

Signature

export declare type Dimensions = KeyValue<Dimension>;

Import

import { Dimensions } from '@grafana/data';

Dimensions2D

Sat, 04 Apr 2026 12:26:57 +0000

Dimensions2D interface

2d object dimensions.

Signature

export interface Dimensions2D

Import

import { Dimensions2D } from '@grafana/data';

Properties

Property	Type	Description
height	`number`
width	`number`

height property

Signature

height: number;

width property

Signature

width: number;

displayNameOverrideProcessor

Sat, 04 Apr 2026 12:26:57 +0000

displayNameOverrideProcessor variable

Signature

displayNameOverrideProcessor: (value: any, context: FieldOverrideContext, settings?: StringFieldConfigSettings | undefined) => any

Import

import { displayNameOverrideProcessor } from '@grafana/data';

DisplayProcessor

Sat, 04 Apr 2026 12:26:57 +0000

DisplayProcessor type

Signature

export declare type DisplayProcessor = (value: any) => DisplayValue;

Import

import { DisplayProcessor } from '@grafana/data';

DisplayValue

Sat, 04 Apr 2026 12:26:57 +0000

DisplayValue interface

Signature

export interface DisplayValue extends FormattedValue

Import

import { DisplayValue } from '@grafana/data';

Properties

Property	Type	Description
color	`string`	Color based on mappings or threshold
description	`string`	Used in limited scenarios like legend reducer calculations
icon	`string`	Icon based on mappings or threshold
numeric	`number`	Use isNaN to check if it is a real number
percent	`number`	0-1 between min & max
title	`string`

color property

Color based on mappings or threshold

Signature

color?: string;

description property

Used in limited scenarios like legend reducer calculations

Signature

description?: string;

icon property

Icon based on mappings or threshold

Signature

icon?: string;

numeric property

Use isNaN to check if it is a real number

Signature

numeric: number;

percent property

0-1 between min & max

Signature

percent?: number;

title property

Signature

title?: string;

DisplayValueAlignmentFactors

Sat, 04 Apr 2026 12:26:57 +0000

DisplayValueAlignmentFactors interface

These represents the display value with the longest title and text. Used to align widths and heights when displaying multiple DisplayValues

Signature

export interface DisplayValueAlignmentFactors extends FormattedValue

Import

import { DisplayValueAlignmentFactors } from '@grafana/data';

Properties

Property	Type	Description
title	`string`

title property

Signature

title: string;

doStandardCalcs

Sat, 04 Apr 2026 12:26:57 +0000

doStandardCalcs() function

Signature

export declare function doStandardCalcs(field: Field, ignoreNulls: boolean, nullAsZero: boolean): FieldCalcs;

Import

import { doStandardCalcs } from '@grafana/data';

Parameters

Parameter	Type	Description
field	`Field`
ignoreNulls	`boolean`
nullAsZero	`boolean`

Returns:

FieldCalcs

DurationInput

Sat, 04 Apr 2026 12:26:57 +0000

DurationInput type

Signature

export declare type DurationInput = string | number | DateTimeDuration;

Import

import { DurationInput } from '@grafana/data';

durationToMilliseconds

Sat, 04 Apr 2026 12:26:57 +0000

durationToMilliseconds() function

durationToMilliseconds convert a duration object to milliseconds

Signature

export declare function durationToMilliseconds(duration: Duration): number;

Import

import { durationToMilliseconds } from '@grafana/data';

Parameters

Parameter	Type	Description
duration	`Duration`	datefns Duration object

Returns:

number

DurationUnit

Sat, 04 Apr 2026 12:26:57 +0000

DurationUnit type

Signature

export declare type DurationUnit = 'year' | 'years' | 'y' | 'month' | 'months' | 'M' | 'week' | 'weeks' | 'isoWeek' | 'w' | 'day' | 'days' | 'd' | 'hour' | 'hours' | 'h' | 'minute' | 'minutes' | 'm' | 'second' | 'seconds' | 's' | 'millisecond' | 'milliseconds' | 'ms' | 'quarter' | 'quarters' | 'Q';

Import

import { DurationUnit } from '@grafana/data';

DynamicConfigValue

Sat, 04 Apr 2026 12:26:57 +0000

DynamicConfigValue interface

Signature

export interface DynamicConfigValue

Import

import { DynamicConfigValue } from '@grafana/data';

Properties

Property	Type	Description
id	`string`
value	`any`

id property

Signature

id: string;

value property

Signature

value?: any;

emphasize

Sat, 04 Apr 2026 12:26:57 +0000

colorManipulator.emphasize() function

colorManipulator.emphasize() function

Darken or lighten a color, depending on its luminance. Light colors are darkened, dark colors are lightened.

Signature

export declare function emphasize(color: string, coefficient?: number): string;

Import

import { colorManipulator } from '@grafana/data';
const { emphasize } = colorManipulator;

Parameters

Parameter	Type	Description
color	`string`	CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla(), color()
coefficient	`number`	=0.15 - multiplier in the range 0 - 1

Returns:

string

A CSS color string. Hex input values are returned as rgb

ensureTimeField

Sat, 04 Apr 2026 12:26:57 +0000

ensureTimeField() function

Checks the first value. Assumes any number should be time fieldtype. Otherwise attempts to make the fieldtype time.

Signature

export declare function ensureTimeField(field: Field, dateFormat?: string): Field;

Import

import { ensureTimeField } from '@grafana/data';

Parameters

Parameter	Type	Description
field	`Field`	field to ensure is a time fieldtype
dateFormat	`string`	date format used to parse a string datetime

Returns:

Field

field as time

escapeStringForRegex

Sat, 04 Apr 2026 12:26:57 +0000

escapeStringForRegex variable

Signature

escapeStringForRegex: (value: string) => string

Import

import { escapeStringForRegex } from '@grafana/data';

escapeUnescapedString

Sat, 04 Apr 2026 12:26:57 +0000

escapeUnescapedString variable

Signature

escapeUnescapedString: (string: string) => string

Import

import { escapeUnescapedString } from '@grafana/data';

eventFactory

Sat, 04 Apr 2026 12:26:57 +0000

eventFactory() function

Signature

export declare function eventFactory<T = undefined>(name: string): AppEvent<T>;

Import

import { eventFactory } from '@grafana/data';

Parameters

Parameter	Type	Description
name	`string`

Returns:

AppEvent<T>

ExploreMode

Sat, 04 Apr 2026 12:26:57 +0000

ExploreMode enum

Signature

export declare enum ExploreMode

Import

import { ExploreMode } from '@grafana/data';

Enumeration Members

Member	Value	Description
Logs	`"Logs"`
Metrics	`"Metrics"`
Tracing	`"Tracing"`

ExplorePanelsState

Sat, 04 Apr 2026 12:26:57 +0000

ExplorePanelsState interface

Signature

export interface ExplorePanelsState extends Partial<Record<PreferredVisualisationType, {}>>

Import

import { ExplorePanelsState } from '@grafana/data';

Properties

Property	Type	Description
trace	`ExploreTracePanelState`

trace property

Signature

trace?: ExploreTracePanelState;

ExploreQueryFieldProps

Sat, 04 Apr 2026 12:26:57 +0000

ExploreQueryFieldProps type

Signature

export declare type ExploreQueryFieldProps<DSType extends DataSourceApi<TQuery, TOptions>, TQuery extends DataQuery = DataQuery, TOptions extends DataSourceJsonData = DataSourceJsonData> = QueryEditorProps<DSType, TQuery, TOptions>;

Import

import { ExploreQueryFieldProps } from '@grafana/data';

ExploreTracePanelState

Sat, 04 Apr 2026 12:26:57 +0000

ExploreTracePanelState interface

Signature

export interface ExploreTracePanelState

Import

import { ExploreTracePanelState } from '@grafana/data';

Properties

Property	Type	Description
spanId	`string`

spanId property

Signature

spanId?: string;

FALLBACK_COLOR

Sat, 04 Apr 2026 12:26:57 +0000

FALLBACK_COLOR variable

Signature

FALLBACK_COLOR = "gray"

Import

import { FALLBACK_COLOR } from '@grafana/data';

FeatureToggles

Sat, 04 Apr 2026 12:26:57 +0000

FeatureToggles interface

Describes available feature toggles in Grafana. These can be configured via conf/custom.ini to enable features under development or not yet available in stable version.

Only enabled values will be returned in this interface

Signature

export interface FeatureToggles

Import

import { FeatureToggles } from '@grafana/data';

Properties

Property	Type	Description
“live-config”	`boolean`
“live-pipeline”	`boolean`
“live-service-web-worker”	`boolean`
“service-accounts”	`boolean`
accesscontrol	`boolean`
dashboardPreviews	`boolean`
database_metrics	`boolean`
disable_http_request_histogram	`boolean`
envelopeEncryption	`boolean`
featureHighlights	`boolean`
fullRangeLogsVolume	`boolean`
httpclientprovider_azure_auth	`boolean`
migrationLocking	`boolean`
newNavigation	`boolean`
prometheus_azure_auth	`boolean`
queryOverLive	`boolean`
showFeatureFlagsInUI	`boolean`
swaggerUi	`boolean`
tempoBackendSearch	`boolean`
tempoSearch	`boolean`
tempoServiceGraph	`boolean`
trimDefaults	`boolean`
validatedQueries	`boolean`

“live-config” property

Signature

['live-config']?: boolean;

“live-pipeline” property

Signature

['live-pipeline']?: boolean;

“live-service-web-worker” property

Signature

['live-service-web-worker']?: boolean;

“service-accounts” property

Signature

['service-accounts']?: boolean;

accesscontrol property

Signature

accesscontrol?: boolean;

dashboardPreviews property

Signature

dashboardPreviews?: boolean;

database_metrics property

Signature

database_metrics?: boolean;

disable_http_request_histogram property

Signature

disable_http_request_histogram?: boolean;

envelopeEncryption property

Signature

envelopeEncryption?: boolean;

featureHighlights property

Signature

featureHighlights?: boolean;

fullRangeLogsVolume property

Signature

fullRangeLogsVolume?: boolean;

httpclientprovider_azure_auth property

Signature

httpclientprovider_azure_auth?: boolean;

migrationLocking property

Signature

migrationLocking?: boolean;

newNavigation property

Signature

newNavigation?: boolean;

prometheus_azure_auth property

Signature

prometheus_azure_auth?: boolean;

queryOverLive property

Signature

queryOverLive?: boolean;

showFeatureFlagsInUI property

Signature

showFeatureFlagsInUI?: boolean;

swaggerUi property

Signature

swaggerUi?: boolean;

tempoBackendSearch property

Signature

tempoBackendSearch?: boolean;

tempoSearch property

Signature

tempoSearch?: boolean;

tempoServiceGraph property

Signature

tempoServiceGraph?: boolean;

trimDefaults property

Signature

trimDefaults?: boolean;

validatedQueries property

Signature

validatedQueries?: boolean;

Field

Sat, 04 Apr 2026 12:26:57 +0000

Field interface

Signature

export interface Field<T = any, V = Vector<T>>

Import

import { Field } from '@grafana/data';

Properties

Property	Type	Description
config	`FieldConfig`	Meta info about how field and how to display it
display	`DisplayProcessor`	Convert a value for display
getLinks	`(config: ValueLinkConfig) => Array<LinkModel<Field>>`	Get value data links with variables interpolated
labels	`Labels`
name	`string`	Name of the field (column)
state	`FieldState \| null`	Cached values with appropriate display and id values
type	`FieldType`	Field value type (string, number, etc)
values	`V`

config property

Meta info about how field and how to display it

Signature

config: FieldConfig;

display property

Convert a value for display

Signature

display?: DisplayProcessor;

getLinks property

Get value data links with variables interpolated

Signature

getLinks?: (config: ValueLinkConfig) => Array<LinkModel<Field>>;

labels property

Signature

labels?: Labels;

name property

Name of the field (column)

Signature

name: string;

state property

Cached values with appropriate display and id values

Signature

state?: FieldState | null;

type property

Field value type (string, number, etc)

Signature

type: FieldType;

values property

Signature

values: V;

FieldCache

Sat, 04 Apr 2026 12:26:57 +0000

FieldCache class

Signature

export declare class FieldCache

Import

import { FieldCache } from '@grafana/data';

Constructors

Constructor	Modifiers	Description
constructor(data)		Constructs a new instance of the `FieldCache` class

Properties

Property	Modifiers	Type	Description
fields		`FieldWithIndex[]`

Methods

Method	Modifiers	Description
getFieldByName(name)		Returns the first field with the given name.
getFields(type)
getFieldsByLabel(label, value)		Returns the fields with the given label.
getFirstFieldOfType(type, includeHidden)
hasFieldNamed(name)
hasFieldOfType(type)
hasFieldWithNameAndType(name, type)

constructor(data)

Constructs a new instance of the FieldCache class

Signature

constructor(data: DataFrame);

Parameters

Parameter	Type	Description
data	`DataFrame`

fields property

Signature

fields: FieldWithIndex[];

getFieldByName method

Returns the first field with the given name.

Signature

getFieldByName(name: string): FieldWithIndex | undefined;

Parameters

Parameter	Type	Description
name	`string`

Returns:

FieldWithIndex | undefined

getFields method

Signature

getFields(type?: FieldType): FieldWithIndex[];

Parameters

Parameter	Type	Description
type	`FieldType`

Returns:

FieldWithIndex[]

getFieldsByLabel method

Returns the fields with the given label.

Signature

getFieldsByLabel(label: string, value: string): FieldWithIndex[];

Parameters

Parameter	Type	Description
label	`string`
value	`string`

Returns:

FieldWithIndex[]

getFirstFieldOfType method

Signature

getFirstFieldOfType(type: FieldType, includeHidden?: boolean): FieldWithIndex | undefined;

Parameters

Parameter	Type	Description
type	`FieldType`
includeHidden	`boolean`

Returns:

FieldWithIndex | undefined

hasFieldNamed method

Signature

hasFieldNamed(name: string): boolean;

Parameters

Parameter	Type	Description
name	`string`

Returns:

boolean

hasFieldOfType method

Signature

hasFieldOfType(type: FieldType): boolean;

Parameters

Parameter	Type	Description
type	`FieldType`

Returns:

boolean

hasFieldWithNameAndType method

Signature

hasFieldWithNameAndType(name: string, type: FieldType): boolean;

Parameters

Parameter	Type	Description
name	`string`
type	`FieldType`

Returns:

boolean

FieldCalcs

Sat, 04 Apr 2026 12:26:57 +0000

FieldCalcs interface

Signature

export interface FieldCalcs extends Record<string, any>

Import

import { FieldCalcs } from '@grafana/data';

FieldColor

Sat, 04 Apr 2026 12:26:57 +0000

FieldColor interface

Signature

export interface FieldColor

Import

import { FieldColor } from '@grafana/data';

Properties

Property	Type	Description
fixedColor	`string`	Stores the fixed color value if mode is fixed
mode	`FieldColorModeId \| string`	The main color scheme mode
seriesBy	`FieldColorSeriesByMode`	Some visualizations need to know how to assign a series color from by value color schemes

fixedColor property

Stores the fixed color value if mode is fixed

Signature

fixedColor?: string;

mode property

The main color scheme mode

Signature

mode: FieldColorModeId | string;

seriesBy property

Some visualizations need to know how to assign a series color from by value color schemes

Signature

seriesBy?: FieldColorSeriesByMode;

FieldColorConfigSettings

Sat, 04 Apr 2026 12:26:57 +0000

FieldColorConfigSettings interface

Signature

export interface FieldColorConfigSettings

Import

import { FieldColorConfigSettings } from '@grafana/data';

Properties

Property	Type	Description
bySeriesSupport	`boolean`	Set to true if the visualization supports both by value and by series This will enable the Color by series UI option that sets the `color.seriesBy` option.
byValueSupport	`boolean`	When switching to a visualization that does not support by value coloring then Grafana will switch to a by series palette based color mode
preferThresholdsMode	`boolean`	When switching to a visualization that has this set to true then Grafana will change color mode to from thresholds if it was set to a by series palette

bySeriesSupport property

Set to true if the visualization supports both by value and by series This will enable the Color by series UI option that sets the color.seriesBy option.

Signature

bySeriesSupport?: boolean;

byValueSupport property

When switching to a visualization that does not support by value coloring then Grafana will switch to a by series palette based color mode

Signature

byValueSupport?: boolean;

preferThresholdsMode property

When switching to a visualization that has this set to true then Grafana will change color mode to from thresholds if it was set to a by series palette

Signature

preferThresholdsMode?: boolean;

FieldColorMode

Sat, 04 Apr 2026 12:26:57 +0000

FieldColorMode interface

Signature

export interface FieldColorMode extends RegistryItem

Import

import { FieldColorMode } from '@grafana/data';

Properties

Property	Type	Description
getCalculator	`(field: Field, theme: GrafanaTheme2) => FieldValueColorCalculator`	*(BETA)*
getColors	`(theme: GrafanaTheme2) => string[]`	*(BETA)*
isByValue	`boolean`	*(BETA)*
isContinuous	`boolean`	*(BETA)*

getCalculator property

Signature

getCalculator: (field: Field, theme: GrafanaTheme2) => FieldValueColorCalculator;

getColors property

Signature

getColors?: (theme: GrafanaTheme2) => string[];

isByValue property

Signature

isByValue?: boolean;

isContinuous property

Signature

isContinuous?: boolean;

FieldColorModeId

Sat, 04 Apr 2026 12:26:57 +0000

FieldColorModeId enum

Signature

export declare enum FieldColorModeId

Import

import { FieldColorModeId } from '@grafana/data';

Enumeration Members

Member	Value	Description
ContinuousGrYlRd	`"continuous-GrYlRd"`
Fixed	`"fixed"`
PaletteClassic	`"palette-classic"`
PaletteSaturated	`"palette-saturated"`
Thresholds	`"thresholds"`

FieldColorSeriesByMode

Sat, 04 Apr 2026 12:26:57 +0000

FieldColorSeriesByMode type

FieldColorSeriesByMode type

Signature

export declare type FieldColorSeriesByMode = 'min' | 'max' | 'last';

Import

import { FieldColorSeriesByMode } from '@grafana/data';

FieldConfig

Sat, 04 Apr 2026 12:26:57 +0000

FieldConfig interface

Every property is optional

Plugins may extend this with additional properties. Something like series overrides

Signature

export interface FieldConfig<TOptions = any>

Import

import { FieldConfig } from '@grafana/data';

Properties

Property	Type	Description
color	`FieldColor`
custom	`TOptions`
decimals	`number \| null`
description	`string`	Human readable field metadata
displayName	`string`	The display value for this field. This supports template variables blank is auto
displayNameFromDS	`string`	This can be used by data sources that return and explicit naming structure for values and labels When this property is configured, this value is used rather than the default naming strategy.
filterable	`boolean`	True if data source field supports ad-hoc filters
interval	`number \| null`
links	`DataLink[]`
mappings	`ValueMapping[]`
max	`number \| null`
min	`number \| null`
noValue	`string`
nullValueMode	`NullValueMode`
path	`string`	An explict path to the field in the datasource. When the frame meta includes a path, This will default to `${frame.meta.path}/${field.name}When defined, this value can be used as an identifier within the datasource scope, and may be used to update the results
thresholds	`ThresholdsConfig`
unit	`string`
writeable	`boolean`	True if data source can write a value to the path. Auth/authz are supported separately

color property

Signature

color?: FieldColor;

custom property

Signature

custom?: TOptions;

decimals property

Signature

decimals?: number | null;

description property

Human readable field metadata

Signature

description?: string;

displayName property

The display value for this field. This supports template variables blank is auto

Signature

displayName?: string;

displayNameFromDS property

This can be used by data sources that return and explicit naming structure for values and labels When this property is configured, this value is used rather than the default naming strategy.

Signature

displayNameFromDS?: string;

filterable property

True if data source field supports ad-hoc filters

Signature

filterable?: boolean;

interval property

Signature

interval?: number | null;

links property

Signature

links?: DataLink[];

mappings property

Signature

mappings?: ValueMapping[];

max property

Signature

max?: number | null;

min property

Signature

min?: number | null;

noValue property

Signature

noValue?: string;

nullValueMode property

Signature

nullValueMode?: NullValueMode;

path property

An explict path to the field in the datasource. When the frame meta includes a path, This will default to `${frame.meta.path}/${field.name}

When defined, this value can be used as an identifier within the datasource scope, and may be used to update the results

Signature

path?: string;

thresholds property

Signature

thresholds?: ThresholdsConfig;

unit property

Signature

unit?: string;

writeable property

True if data source can write a value to the path. Auth/authz are supported separately

Signature

writeable?: boolean;

FieldConfigEditorBuilder

Sat, 04 Apr 2026 12:26:57 +0000

FieldConfigEditorBuilder class

Fluent API for declarative creation of field config option editors

Signature

export declare class FieldConfigEditorBuilder<TOptions> extends OptionsUIRegistryBuilder<TOptions, FieldConfigEditorProps<any, any>, FieldConfigPropertyItem<TOptions>>

Import

import { FieldConfigEditorBuilder } from '@grafana/data';

Methods

Method	Modifiers	Description
addBooleanSwitch(config)
addColorPicker(config)
addNumberInput(config)
addRadio(config)
addSelect(config)
addSliderInput(config)
addTextInput(config)
addUnitPicker(config)

addBooleanSwitch method

Signature

addBooleanSwitch<TSettings = any>(config: FieldConfigEditorConfig<TOptions, TSettings, boolean>): this;

Parameters

Parameter	Type	Description
config	`FieldConfigEditorConfig<TOptions, TSettings, boolean>`

Returns:

this

addColorPicker method

Signature

addColorPicker<TSettings = any>(config: FieldConfigEditorConfig<TOptions, TSettings, string>): this;

Parameters

Parameter	Type	Description
config	`FieldConfigEditorConfig<TOptions, TSettings, string>`

Returns:

this

addNumberInput method

Signature

addNumberInput<TSettings>(config: FieldConfigEditorConfig<TOptions, TSettings & NumberFieldConfigSettings, number>): this;

Parameters

Parameter	Type	Description
config	`FieldConfigEditorConfig<TOptions, TSettings & NumberFieldConfigSettings, number>`

Returns:

this

addRadio method

Signature

addRadio<TOption, TSettings = any>(config: FieldConfigEditorConfig<TOptions, TSettings, TOption>): this;

Parameters

Parameter	Type	Description
config	`FieldConfigEditorConfig<TOptions, TSettings, TOption>`

Returns:

this

addSelect method

Signature

addSelect<TOption, TSettings extends SelectFieldConfigSettings<TOption>>(config: FieldConfigEditorConfig<TOptions, TSettings, TOption>): this;

Parameters

Parameter	Type	Description
config	`FieldConfigEditorConfig<TOptions, TSettings, TOption>`

Returns:

this

addSliderInput method

Signature

addSliderInput<TSettings>(config: FieldConfigEditorConfig<TOptions, TSettings & SliderFieldConfigSettings, number>): this;

Parameters

Parameter	Type	Description
config	`FieldConfigEditorConfig<TOptions, TSettings & SliderFieldConfigSettings, number>`

Returns:

this

addTextInput method

Signature

addTextInput<TSettings>(config: FieldConfigEditorConfig<TOptions, TSettings & StringFieldConfigSettings, string>): this;

Parameters

Parameter	Type	Description
config	`FieldConfigEditorConfig<TOptions, TSettings & StringFieldConfigSettings, string>`

Returns:

this

addUnitPicker method

Signature

addUnitPicker<TSettings = any>(config: FieldConfigEditorConfig<TOptions, TSettings & UnitFieldConfigSettings, string>): this;

Parameters

Parameter	Type	Description
config	`FieldConfigEditorConfig<TOptions, TSettings & UnitFieldConfigSettings, string>`

Returns:

this

FieldConfigEditorConfig

Sat, 04 Apr 2026 12:26:57 +0000

FieldConfigEditorConfig interface

Signature

export interface FieldConfigEditorConfig<TOptions, TSettings = any, TValue = any> extends OptionEditorConfig<TOptions, TSettings, TValue>

Import

import { FieldConfigEditorConfig } from '@grafana/data';

Properties

Property	Type	Description
hideFromDefaults	`boolean`	Indicates that option shoukd not be available in the Field config tab
hideFromOverrides	`boolean`	Indicates that option should not be available for the overrides
shouldApply	`(field: Field) => boolean`	Function that allows specifying whether or not this field config should apply to a given field.

hideFromDefaults property

Indicates that option shoukd not be available in the Field config tab

Signature

hideFromDefaults?: boolean;

hideFromOverrides property

Indicates that option should not be available for the overrides

Signature

hideFromOverrides?: boolean;

shouldApply property

Function that allows specifying whether or not this field config should apply to a given field.

Signature

shouldApply?: (field: Field) => boolean;

FieldConfigEditorProps

Sat, 04 Apr 2026 12:26:57 +0000

FieldConfigEditorProps interface

Signature

export interface FieldConfigEditorProps<TValue, TSettings> extends Omit<StandardEditorProps<TValue, TSettings>, 'item'>

Import

import { FieldConfigEditorProps } from '@grafana/data';

Properties

Property	Type	Description
context	`FieldOverrideContext`
item	`FieldConfigPropertyItem<any, TValue, TSettings>`
onChange	`(value?: TValue) => void`
value	`TValue`

context property

Signature

context: FieldOverrideContext;

item property

Signature

item: FieldConfigPropertyItem<any, TValue, TSettings>;

onChange property

Signature

onChange: (value?: TValue) => void;

value property

Signature

value: TValue;

FieldConfigOptionsRegistry

Sat, 04 Apr 2026 12:26:57 +0000

FieldConfigOptionsRegistry class

Signature

export declare class FieldConfigOptionsRegistry extends Registry<FieldConfigPropertyItem>

Import

import { FieldConfigOptionsRegistry } from '@grafana/data';

FieldConfigProperty

Sat, 04 Apr 2026 12:26:57 +0000

FieldConfigProperty enum

Signature

export declare enum FieldConfigProperty

Import

import { FieldConfigProperty } from '@grafana/data';

Enumeration Members

Member	Value	Description
Color	`"color"`
Decimals	`"decimals"`
DisplayName	`"displayName"`
Links	`"links"`
Mappings	`"mappings"`
Max	`"max"`
Min	`"min"`
NoValue	`"noValue"`
Thresholds	`"thresholds"`
Unit	`"unit"`

FieldConfigPropertyItem

Sat, 04 Apr 2026 12:26:57 +0000

FieldConfigPropertyItem interface

Signature

export interface FieldConfigPropertyItem<TOptions = any, TValue = any, TSettings extends {} = any> extends OptionsEditorItem<TOptions, TSettings, FieldConfigEditorProps<TValue, TSettings>, TValue>

Import

import { FieldConfigPropertyItem } from '@grafana/data';

Properties

Property	Type	Description
hideFromDefaults	`boolean`	Hides option from the Field config tab
hideFromOverrides	`boolean`	Indicates that option should not be available for the overrides
isCustom	`boolean`	true for plugin field config properties
override	`ComponentType<FieldOverrideEditorProps<TValue, TSettings>>`
process	`(value: any, context: FieldOverrideContext, settings?: TSettings) => TValue \| undefined \| null`	Convert the override value to a well typed value
shouldApply	`(field: Field) => boolean`	Checks if field should be processed

hideFromDefaults property

Hides option from the Field config tab

Signature

hideFromDefaults?: boolean;

hideFromOverrides property

Indicates that option should not be available for the overrides

Signature

hideFromOverrides?: boolean;

isCustom property

true for plugin field config properties

Signature

isCustom?: boolean;

override property

Signature

override: ComponentType<FieldOverrideEditorProps<TValue, TSettings>>;

process property

Convert the override value to a well typed value

Signature

process: (value: any, context: FieldOverrideContext, settings?: TSettings) => TValue | undefined | null;

shouldApply property

Checks if field should be processed

Signature

shouldApply: (field: Field) => boolean;

FieldConfigSource

Sat, 04 Apr 2026 12:26:57 +0000

FieldConfigSource interface

Signature

export interface FieldConfigSource<TOptions = any>

Import

import { FieldConfigSource } from '@grafana/data';

Properties

Property	Type	Description
defaults	`FieldConfig<TOptions>`
overrides	`ConfigOverrideRule[]`

defaults property

Signature

defaults: FieldConfig<TOptions>;

overrides property

Signature

overrides: ConfigOverrideRule[];

FieldDisplay

Sat, 04 Apr 2026 12:26:57 +0000

FieldDisplay interface

Signature

export interface FieldDisplay

Import

import { FieldDisplay } from '@grafana/data';

Properties

Property	Type	Description
colIndex	`number`
display	`DisplayValue`
field	`FieldConfig`
getLinks	`() => LinkModel[]`
hasLinks	`boolean`
name	`string`
rowIndex	`number`
sparkline	`FieldSparkline`
view	`DataFrameView`

colIndex property

Signature

colIndex?: number;

display property

Signature

display: DisplayValue;

field property

Signature

field: FieldConfig;

getLinks property

Signature

getLinks?: () => LinkModel[];

hasLinks property

Signature

hasLinks: boolean;

name property

Signature

name: string;

rowIndex property

Signature

rowIndex?: number;

sparkline property

Signature

sparkline?: FieldSparkline;

view property

Signature

view?: DataFrameView;

FieldDTO

Sat, 04 Apr 2026 12:26:57 +0000

FieldDTO interface

Like a field, but properties are optional and values may be a simple array

Signature

export interface FieldDTO<T = any>

Import

import { FieldDTO } from '@grafana/data';

Properties

Property	Type	Description
config	`FieldConfig`
labels	`Labels`
name	`string`
type	`FieldType`
values	`Vector<T> \| T[]`

config property

Signature

config?: FieldConfig;

labels property

Signature

labels?: Labels;

name property

Signature

name: string;

type property

Signature

type?: FieldType;

values property

Signature

values?: Vector<T> | T[];

FieldMatcher

Sat, 04 Apr 2026 12:26:57 +0000

FieldMatcher type

Signature

export declare type FieldMatcher = (field: Field, frame: DataFrame, allFrames: DataFrame[]) => boolean;

Import

import { FieldMatcher } from '@grafana/data';

FieldMatcherID

Sat, 04 Apr 2026 12:26:57 +0000

FieldMatcherID enum

Signature

export declare enum FieldMatcherID

Import

import { FieldMatcherID } from '@grafana/data';

Enumeration Members

Member	Value	Description
byFrameRefID	`"byFrameRefID"`
byName	`"byName"`
byNames	`"byNames"`
byRegexp	`"byRegexp"`
byRegexpOrNames	`"byRegexpOrNames"`
byType	`"byType"`
first	`"first"`
firstTimeField	`"firstTimeField"`
numeric	`"numeric"`
time	`"time"`

FieldMatcherInfo

Sat, 04 Apr 2026 12:26:57 +0000

FieldMatcherInfo interface

Signature

export interface FieldMatcherInfo<TOptions = any> extends RegistryItemWithOptions<TOptions>

Import

import { FieldMatcherInfo } from '@grafana/data';

Properties

Property	Type	Description
get	`(options: TOptions) => FieldMatcher`

get property

Signature

get: (options: TOptions) => FieldMatcher;

fieldMatchers

Sat, 04 Apr 2026 12:26:57 +0000

fieldMatchers variable

Registry that contains all of the built in field matchers.

Signature

fieldMatchers: Registry<FieldMatcherInfo<any>>

Import

import { fieldMatchers } from '@grafana/data';

FieldNamePickerConfigSettings

Sat, 04 Apr 2026 12:26:57 +0000

FieldNamePickerConfigSettings interface

Signature

export interface FieldNamePickerConfigSettings

Import

import { FieldNamePickerConfigSettings } from '@grafana/data';

Properties

Property	Type	Description
filter	`(field: Field) => boolean`	Function is a predicate, to test each element of the array. Return a value that coerces to true to keep the field, or to false otherwise.
noFieldsMessage	`string`	Show this text when no values are found
placeholderText	`string`	Placeholder text to display when nothing is selected.
width	`number`	addFieldNamePicker Sets the width to a pixel value.

filter property

Function is a predicate, to test each element of the array. Return a value that coerces to true to keep the field, or to false otherwise.

Signature

filter?: (field: Field) => boolean;

noFieldsMessage property

Show this text when no values are found

Signature

noFieldsMessage?: string;

placeholderText property

Placeholder text to display when nothing is selected.

Signature

placeholderText?: string;

width property

addFieldNamePicker Sets the width to a pixel value.

Signature

width?: number;

FieldOverrideContext

Sat, 04 Apr 2026 12:26:57 +0000

FieldOverrideContext interface

Signature

export interface FieldOverrideContext extends StandardEditorContext<any, any>

Import

import { FieldOverrideContext } from '@grafana/data';

Properties

Property	Type	Description
dataFrameIndex	`number`
field	`Field`

dataFrameIndex property

Signature

dataFrameIndex?: number;

field property

Signature

field?: Field;

FieldOverrideEditorProps

Sat, 04 Apr 2026 12:26:57 +0000

FieldOverrideEditorProps interface

Signature

export interface FieldOverrideEditorProps<TValue, TSettings> extends Omit<StandardEditorProps<TValue>, 'item'>

Import

import { FieldOverrideEditorProps } from '@grafana/data';

Properties

Property	Type	Description
context	`FieldOverrideContext`
item	`FieldConfigPropertyItem<TValue, TSettings>`

context property

Signature

context: FieldOverrideContext;

item property

Signature

item: FieldConfigPropertyItem<TValue, TSettings>;

FieldReducerInfo

Sat, 04 Apr 2026 12:26:57 +0000

FieldReducerInfo interface

Signature

export interface FieldReducerInfo extends RegistryItem

Import

import { FieldReducerInfo } from '@grafana/data';

Properties

Property	Type	Description
emptyInputResult	`any`
reduce	`FieldReducer`
standard	`boolean`

emptyInputResult property

Signature

emptyInputResult?: any;

reduce property

Signature

reduce?: FieldReducer;

standard property

Signature

standard: boolean;

fieldReducers

Sat, 04 Apr 2026 12:26:57 +0000

fieldReducers variable

Signature

fieldReducers: Registry<FieldReducerInfo>

Import

import { fieldReducers } from '@grafana/data';

FieldSparkline

Sat, 04 Apr 2026 12:26:57 +0000

FieldSparkline interface

Signature

export interface FieldSparkline

Import

import { FieldSparkline } from '@grafana/data';

Properties

Property	Type	Description
highlightIndex	`number`
timeRange	`TimeRange`
x	`Field`
y	`Field`

highlightIndex property

Signature

highlightIndex?: number;

timeRange property

Signature

timeRange?: TimeRange;

x property

Signature

x?: Field;

y property

Signature

y: Field;

FieldType

Sat, 04 Apr 2026 12:26:57 +0000

FieldType enum

Signature

export declare enum FieldType

Import

import { FieldType } from '@grafana/data';

Enumeration Members

Member	Value	Description
boolean	`"boolean"`
geo	`"geo"`
number	`"number"`
other	`"other"`
string	`"string"`
time	`"time"`
trace	`"trace"`

FieldWithIndex

Sat, 04 Apr 2026 12:26:57 +0000

FieldWithIndex interface

Signature

export interface FieldWithIndex extends Field

Import

import { FieldWithIndex } from '@grafana/data';

Properties

Property	Type	Description
index	`number`

index property

Signature

index: number;

findCommonLabels

Sat, 04 Apr 2026 12:26:57 +0000

findCommonLabels() function

Returns a map labels that are common to the given label sets.

Signature

export declare function findCommonLabels(labelsSets: Labels[]): Labels;

Import

import { findCommonLabels } from '@grafana/data';

Parameters

Parameter	Type	Description
labelsSets	`Labels[]`

Returns:

Labels

findHighlightChunksInText

Sat, 04 Apr 2026 12:26:57 +0000

findHighlightChunksInText() function

Adapt findMatchesInText for react-highlight-words findChunks handler. See https://github.com/bvaughn/react-highlight-words#props

Signature

export declare function findHighlightChunksInText({ searchWords, textToHighlight, }: {
    searchWords: Array<string | RegExp>;
    textToHighlight: string;
}): TextMatch[];

Import

import { findHighlightChunksInText } from '@grafana/data';

Parameters

Parameter	Type	Description
{ searchWords, textToHighlight, }	`{` `searchWords: Array<string \| RegExp>;` `textToHighlight: string;` `}`

Returns:

TextMatch[]

findMatchesInText

Sat, 04 Apr 2026 12:26:57 +0000

findMatchesInText() function

Returns a list of substring regexp matches.

Signature

export declare function findMatchesInText(haystack: string, needle: string): TextMatch[];

Import

import { findMatchesInText } from '@grafana/data';

Parameters

Parameter	Type	Description
haystack	`string`
needle	`string`

Returns:

TextMatch[]

findUniqueLabels

Sat, 04 Apr 2026 12:26:57 +0000

findUniqueLabels() function

Returns a map of labels that are in labels, but not in commonLabels.

Signature

export declare function findUniqueLabels(labels: Labels | undefined, commonLabels: Labels): Labels;

Import

import { findUniqueLabels } from '@grafana/data';

Parameters

Parameter	Type	Description
labels	`Labels \| undefined`
commonLabels	`Labels`

Returns:

Labels

FlotDataPoint

Sat, 04 Apr 2026 12:26:57 +0000

FlotDataPoint interface

Signature

export interface FlotDataPoint

Import

import { FlotDataPoint } from '@grafana/data';

Properties

Property	Type	Description
dataIndex	`number`
datapoint	`number[]`
pageX	`number`
pageY	`number`
series	`any`
seriesIndex	`number`

dataIndex property

Signature

dataIndex: number;

datapoint property

Signature

datapoint: number[];

pageX property

Signature

pageX: number;

pageY property

Signature

pageY: number;

series property

Signature

series: any;

seriesIndex property

Signature

seriesIndex: number;

FormatInput

Sat, 04 Apr 2026 12:26:57 +0000

FormatInput type

Signature

export declare type FormatInput = string | DateTimeBuiltinFormat | undefined;

Import

import { FormatInput } from '@grafana/data';

formatLabels

Sat, 04 Apr 2026 12:26:57 +0000

formatLabels() function

Serializes the given labels to a string.

Signature

export declare function formatLabels(labels: Labels, defaultValue?: string, withoutBraces?: boolean): string;

Import

import { formatLabels } from '@grafana/data';

Parameters

Parameter	Type	Description
labels	`Labels`
defaultValue	`string`
withoutBraces	`boolean`

Returns:

string

FormattedValue

Sat, 04 Apr 2026 12:26:57 +0000

FormattedValue interface

Signature

export interface FormattedValue

Import

import { FormattedValue } from '@grafana/data';

Properties

Property	Type	Description
prefix	`string`
suffix	`string`
text	`string`

prefix property

Signature

prefix?: string;

suffix property

Signature

suffix?: string;

text property

Signature

text: string;

formattedValueToString

Sat, 04 Apr 2026 12:26:57 +0000

formattedValueToString() function

Signature

export declare function formattedValueToString(val: FormattedValue): string;

Import

import { formattedValueToString } from '@grafana/data';

Parameters

Parameter	Type	Description
val	`FormattedValue`

Returns:

string

FormattedVector

Sat, 04 Apr 2026 12:26:57 +0000

FormattedVector class

Signature

export declare class FormattedVector<T = any> extends FunctionalVector<string>

Import

import { FormattedVector } from '@grafana/data';

Constructors

Constructor	Modifiers	Description
constructor(source, formatter)		Constructs a new instance of the `FormattedVector` class

Properties

Property	Modifiers	Type	Description
length		`number`

Methods

Method	Modifiers	Description
get(index)

constructor(source, formatter)

Constructs a new instance of the FormattedVector class

Signature

constructor(source: Vector<T>, formatter: DisplayProcessor);

Parameters

Parameter	Type	Description
source	`Vector<T>`
formatter	`DisplayProcessor`

length property

Signature

get length(): number;

get method

Signature

get(index: number): string;

Parameters

Parameter	Type	Description
index	`number`

Returns:

string

FrameMatcher

Sat, 04 Apr 2026 12:26:57 +0000

FrameMatcher type

Signature

export declare type FrameMatcher = (frame: DataFrame) => boolean;

Import

import { FrameMatcher } from '@grafana/data';

FrameMatcherID

Sat, 04 Apr 2026 12:26:57 +0000

FrameMatcherID enum

Field name matchers

Signature

export declare enum FrameMatcherID

Import

import { FrameMatcherID } from '@grafana/data';

Enumeration Members

Member	Value	Description
byIndex	`"byIndex"`
byLabel	`"byLabel"`
byName	`"byName"`
byRefId	`"byRefId"`

FrameMatcherInfo

Sat, 04 Apr 2026 12:26:57 +0000

FrameMatcherInfo interface

Signature

export interface FrameMatcherInfo<TOptions = any> extends RegistryItemWithOptions<TOptions>

Import

import { FrameMatcherInfo } from '@grafana/data';

Properties

Property	Type	Description
get	`(options: TOptions) => FrameMatcher`

get property

Signature

get: (options: TOptions) => FrameMatcher;

frameMatchers

Sat, 04 Apr 2026 12:26:57 +0000

frameMatchers variable

Registry that contains all of the built in frame matchers.

Signature

frameMatchers: Registry<FrameMatcherInfo<any>>

Import

import { frameMatchers } from '@grafana/data';

GAUGE_DEFAULT_MAXIMUM

Sat, 04 Apr 2026 12:26:57 +0000

GAUGE_DEFAULT_MAXIMUM variable

Signature

GAUGE_DEFAULT_MAXIMUM = 100

Import

import { GAUGE_DEFAULT_MAXIMUM } from '@grafana/data';

GAUGE_DEFAULT_MINIMUM

Sat, 04 Apr 2026 12:26:57 +0000

GAUGE_DEFAULT_MINIMUM variable

Signature

GAUGE_DEFAULT_MINIMUM = 0

Import

import { GAUGE_DEFAULT_MINIMUM } from '@grafana/data';

getActiveThreshold

Sat, 04 Apr 2026 12:26:57 +0000

getActiveThreshold() function

Signature

export declare function getActiveThreshold(value: number, thresholds: Threshold[] | undefined): Threshold;

Import

import { getActiveThreshold } from '@grafana/data';

Parameters

Parameter	Type	Description
value	`number`
thresholds	`Threshold[] \| undefined`

Returns:

Threshold

getAllValuesFromDimension

Sat, 04 Apr 2026 12:26:57 +0000

getAllValuesFromDimension variable

Signature

getAllValuesFromDimension: (dimension: Dimension, column: number, row: number) => any[]

Import

import { getAllValuesFromDimension } from '@grafana/data';

getColorForTheme

Sat, 04 Apr 2026 12:26:57 +0000

getColorForTheme() function

Signature

export declare function getColorForTheme(color: string, theme: GrafanaTheme): string;

Import

import { getColorForTheme } from '@grafana/data';

Parameters

Parameter	Type	Description
color	`string`
theme	`GrafanaTheme`

Returns:

string

getColorFromHexRgbOrName

Sat, 04 Apr 2026 12:26:57 +0000

getColorFromHexRgbOrName() function

Signature

export declare function getColorFromHexRgbOrName(color: string, type?: GrafanaThemeType): string;

Import

import { getColorFromHexRgbOrName } from '@grafana/data';

Parameters

Parameter	Type	Description
color	`string`
type	`GrafanaThemeType`

Returns:

string

getColumnFromDimension

Sat, 04 Apr 2026 12:26:57 +0000

getColumnFromDimension variable

Signature

getColumnFromDimension: (dimension: Dimension, column: number) => Field<any, import("..").Vector<any>>

Import

import { getColumnFromDimension } from '@grafana/data';

getColumnsFromDimension

Sat, 04 Apr 2026 12:26:57 +0000

getColumnsFromDimension variable

Signature

getColumnsFromDimension: (dimension: Dimension) => Field<any, import("..").Vector<any>>[]

Import

import { getColumnsFromDimension } from '@grafana/data';

getContrastRatio

Sat, 04 Apr 2026 12:26:57 +0000

colorManipulator.getContrastRatio() function

colorManipulator.getContrastRatio() function

Calculates the contrast ratio between two colors.

Formula: https://www.w3.org/TR/WCAG20-TECHS/G17.html#G17-tests

Signature

export declare function getContrastRatio(foreground: string, background: string, canvas?: string): number;

Import

import { colorManipulator } from '@grafana/data';
const { getContrastRatio } = colorManipulator;

Parameters

Parameter	Type	Description
foreground	`string`	CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla()
background	`string`	CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla()
canvas	`string`	A CSS color that alpha based backgrounds blends into

Returns:

number

A contrast ratio value in the range 0 - 21.

getDataFrameRow

Sat, 04 Apr 2026 12:26:57 +0000

getDataFrameRow() function

Wrapper to get an array from each field value

Signature

export declare function getDataFrameRow(data: DataFrame, row: number): any[];

Import

import { getDataFrameRow } from '@grafana/data';

Parameters

Parameter	Type	Description
data	`DataFrame`
row	`number`

Returns:

any[]

getDataSourceRef

Sat, 04 Apr 2026 12:26:57 +0000

getDataSourceRef() function

Convert instance settings to a reference

Signature

export declare function getDataSourceRef(ds: DataSourceInstanceSettings): DataSourceRef;

Import

import { getDataSourceRef } from '@grafana/data';

Parameters

Parameter	Type	Description
ds	`DataSourceInstanceSettings`

Returns:

DataSourceRef

getDataSourceUID

Sat, 04 Apr 2026 12:26:57 +0000

getDataSourceUID() function

Get the UID from a string of reference

Signature

export declare function getDataSourceUID(ref: DataSourceRef | string | null): string | undefined;

Import

import { getDataSourceUID } from '@grafana/data';

Parameters

Parameter	Type	Description
ref	`DataSourceRef \| string \| null`

Returns:

string | undefined

getDefaultRelativeTimeRange

Sat, 04 Apr 2026 12:26:57 +0000

getDefaultRelativeTimeRange() function

Returns the default realtive time range.

Signature

export declare function getDefaultRelativeTimeRange(): RelativeTimeRange;

Import

import { getDefaultRelativeTimeRange } from '@grafana/data';

Returns:

RelativeTimeRange

getDefaultTimeRange

Sat, 04 Apr 2026 12:26:57 +0000

getDefaultTimeRange() function

Signature

export declare function getDefaultTimeRange(): TimeRange;

Import

import { getDefaultTimeRange } from '@grafana/data';

Returns:

TimeRange

getDimensionByName

Sat, 04 Apr 2026 12:26:57 +0000

getDimensionByName variable

Signature

getDimensionByName: (dimensions: Dimensions, name: string) => Dimension<any>

Import

import { getDimensionByName } from '@grafana/data';

getDisplayProcessor

Sat, 04 Apr 2026 12:26:57 +0000

getDisplayProcessor() function

Signature

export declare function getDisplayProcessor(options?: DisplayProcessorOptions): DisplayProcessor;

Import

import { getDisplayProcessor } from '@grafana/data';

Parameters

Parameter	Type	Description
options	`DisplayProcessorOptions`

Returns:

DisplayProcessor

getDisplayValueAlignmentFactors

Sat, 04 Apr 2026 12:26:57 +0000

getDisplayValueAlignmentFactors() function

Signature

export declare function getDisplayValueAlignmentFactors(values: FieldDisplay[]): DisplayValueAlignmentFactors;

Import

import { getDisplayValueAlignmentFactors } from '@grafana/data';

Parameters

Parameter	Type	Description
values	`FieldDisplay[]`

Returns:

DisplayValueAlignmentFactors

getFieldColorMode

Sat, 04 Apr 2026 12:26:57 +0000

getFieldColorMode() function

getFieldColorMode() function

Signature

export declare function getFieldColorMode(mode?: FieldColorModeId | string): FieldColorMode;

Import

import { getFieldColorMode } from '@grafana/data';

Parameters

Parameter	Type	Description
mode	`FieldColorModeId \| string`

Returns:

FieldColorMode

getFieldColorModeForField

Sat, 04 Apr 2026 12:26:57 +0000

getFieldColorModeForField() function

getFieldColorModeForField() function

Signature

export declare function getFieldColorModeForField(field: Field): FieldColorMode;

Import

import { getFieldColorModeForField } from '@grafana/data';

Parameters

Parameter	Type	Description
field	`Field`

Returns:

FieldColorMode

getFieldDisplayName

Sat, 04 Apr 2026 12:26:57 +0000

getFieldDisplayName() function

Signature

export declare function getFieldDisplayName(field: Field, frame?: DataFrame, allFrames?: DataFrame[]): string;

Import

import { getFieldDisplayName } from '@grafana/data';

Parameters

Parameter	Type	Description
field	`Field`
frame	`DataFrame`
allFrames	`DataFrame[]`

Returns:

string

getFieldDisplayValues

Sat, 04 Apr 2026 12:26:57 +0000

getFieldDisplayValues variable

Signature

getFieldDisplayValues: (options: GetFieldDisplayValuesOptions) => FieldDisplay[]

Import

import { getFieldDisplayValues } from '@grafana/data';

GetFieldDisplayValuesOptions

Sat, 04 Apr 2026 12:26:57 +0000

GetFieldDisplayValuesOptions interface

Signature

export interface GetFieldDisplayValuesOptions

Import

import { GetFieldDisplayValuesOptions } from '@grafana/data';

Properties

Property	Type	Description
data	`DataFrame[]`
fieldConfig	`FieldConfigSource`
reduceOptions	`ReduceDataOptions`
replaceVariables	`InterpolateFunction`
sparkline	`boolean`
theme	`GrafanaTheme2`
timeZone	`TimeZone`

data property

Signature

data?: DataFrame[];

fieldConfig property

Signature

fieldConfig: FieldConfigSource;

reduceOptions property

Signature

reduceOptions: ReduceDataOptions;

replaceVariables property

Signature

replaceVariables: InterpolateFunction;

sparkline property

Signature

sparkline?: boolean;

theme property

Signature

theme: GrafanaTheme2;

timeZone property

Signature

timeZone?: TimeZone;

getFieldMatcher

Sat, 04 Apr 2026 12:26:57 +0000

getFieldMatcher() function

Resolves a field matcher from the registry for given config. Will throw an error if matcher can not be resolved.

Signature

export declare function getFieldMatcher(config: MatcherConfig): FieldMatcher;

Import

import { getFieldMatcher } from '@grafana/data';

Parameters

Parameter	Type	Description
config	`MatcherConfig`

Returns:

FieldMatcher

getFieldTypeFromValue

Sat, 04 Apr 2026 12:26:57 +0000

getFieldTypeFromValue() function

Check the field type to see what the contents are

Signature

export declare function getFieldTypeFromValue(v: any): FieldType;

Import

import { getFieldTypeFromValue } from '@grafana/data';

Parameters

Parameter	Type	Description
v	`any`

Returns:

FieldType

getFlotPairs

Sat, 04 Apr 2026 12:26:57 +0000

getFlotPairs() function

Signature

export declare function getFlotPairs({ xField, yField, nullValueMode }: FlotPairsOptions): GraphSeriesValue[][];

Import

import { getFlotPairs } from '@grafana/data';

Parameters

Parameter	Type	Description
{ xField, yField, nullValueMode }	`FlotPairsOptions`

Returns:

GraphSeriesValue[][]

getFlotPairsConstant

Sat, 04 Apr 2026 12:26:57 +0000

getFlotPairsConstant() function

Returns a constant series based on the first value from the provide series.

Signature

export declare function getFlotPairsConstant(seriesData: GraphSeriesValue[][], range: TimeRange): GraphSeriesValue[][];

Import

import { getFlotPairsConstant } from '@grafana/data';

Parameters

Parameter	Type	Description
seriesData	`GraphSeriesValue[][]`	Series
range	`TimeRange`	Start and end time for the constant series

Returns:

GraphSeriesValue[][]

getFrameDisplayName

Sat, 04 Apr 2026 12:26:57 +0000

getFrameDisplayName() function

Get an appropriate display title

Signature

export declare function getFrameDisplayName(frame: DataFrame, index?: number): string;

Import

import { getFrameDisplayName } from '@grafana/data';

Parameters

Parameter	Type	Description
frame	`DataFrame`
index	`number`

Returns:

string

getFrameMatchers

Sat, 04 Apr 2026 12:26:57 +0000

getFrameMatchers() function

Resolves a frame matcher from the registry for given config. Will throw an error if matcher can not be resolved.

Signature

export declare function getFrameMatchers(config: MatcherConfig): FrameMatcher;

Import

import { getFrameMatchers } from '@grafana/data';

Parameters

Parameter	Type	Description
config	`MatcherConfig`

Returns:

FrameMatcher

getLocale

Sat, 04 Apr 2026 12:26:57 +0000

getLocale variable

Signature

getLocale: () => string

Import

import { getLocale } from '@grafana/data';

getLocaleData

Sat, 04 Apr 2026 12:26:57 +0000

getLocaleData variable

Signature

getLocaleData: () => DateTimeLocale

Import

import { getLocaleData } from '@grafana/data';

getLogLevel

Sat, 04 Apr 2026 12:26:57 +0000

getLogLevel() function

Returns the log level of a log line. Parse the line for level words. If no level is found, it returns LogLevel.unknown.

Example: getLogLevel('WARN 1999-12-31 this is great') // LogLevel.warn

Signature

export declare function getLogLevel(line: string): LogLevel;

Import

import { getLogLevel } from '@grafana/data';

Parameters

Parameter	Type	Description
line	`string`

Returns:

LogLevel

getLogLevelFromKey

Sat, 04 Apr 2026 12:26:57 +0000

getLogLevelFromKey() function

Signature

export declare function getLogLevelFromKey(key: string | number): LogLevel;

Import

import { getLogLevelFromKey } from '@grafana/data';

Parameters

Parameter	Type	Description
key	`string \| number`

Returns:

LogLevel

getLuminance

Sat, 04 Apr 2026 12:26:57 +0000

colorManipulator.getLuminance() function

colorManipulator.getLuminance() function

The relative brightness of any point in a color space, normalized to 0 for darkest black and 1 for lightest white.

Formula: https://www.w3.org/TR/WCAG20-TECHS/G17.html#G17-tests

Signature

export declare function getLuminance(color: string, background?: string): number;

Import

import { colorManipulator } from '@grafana/data';
const { getLuminance } = colorManipulator;

Parameters

Parameter	Type	Description
color	`string`	CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla(), color()
background	`string`	CSS color that needs to be take in to account to calculate luminance for colors with opacity

Returns:

number

The relative brightness of the color in the range 0 - 1

getParser

Sat, 04 Apr 2026 12:26:57 +0000

getParser() function

Signature

export declare function getParser(line: string): LogsParser | undefined;

Import

import { getParser } from '@grafana/data';

Parameters

Parameter	Type	Description
line	`string`

Returns:

LogsParser | undefined

getRawDisplayProcessor

Sat, 04 Apr 2026 12:26:57 +0000

getRawDisplayProcessor() function

Signature

export declare function getRawDisplayProcessor(): DisplayProcessor;

Import

import { getRawDisplayProcessor } from '@grafana/data';

Returns:

DisplayProcessor

getScaleCalculator

Sat, 04 Apr 2026 12:26:57 +0000

getScaleCalculator() function

Signature

export declare function getScaleCalculator(field: Field, theme: GrafanaTheme2): ScaleCalculator;

Import

import { getScaleCalculator } from '@grafana/data';

Parameters

Parameter	Type	Description
field	`Field`
theme	`GrafanaTheme2`

Returns:

ScaleCalculator

getSeriesTimeStep

Sat, 04 Apr 2026 12:26:57 +0000

getSeriesTimeStep variable

Returns minimal time step from series time field

Signature

getSeriesTimeStep: (timeField: Field) => number

Import

import { getSeriesTimeStep } from '@grafana/data';

getTimeField

Sat, 04 Apr 2026 12:26:57 +0000

getTimeField variable

Signature

getTimeField: (series: DataFrame) => {
    timeField?: Field;
    timeIndex?: number;
}

Import

import { getTimeField } from '@grafana/data';

getTimeZone

Sat, 04 Apr 2026 12:26:57 +0000

getTimeZone variable

Used to get the current selected time zone. If a valid time zone is passed in the options it will be returned. If no valid time zone is passed either the time zone configured for the user account will be returned or the default for Grafana.

Signature

getTimeZone: <T extends TimeZoneOptions>(options?: T | undefined) => TimeZone

Import

import { getTimeZone } from '@grafana/data';

getTimeZoneGroups

Sat, 04 Apr 2026 12:26:57 +0000

getTimeZoneGroups variable

Signature

getTimeZoneGroups: ((includeInternal?: boolean | InternalTimeZones[]) => GroupedTimeZones[]) & import("lodash").MemoizedFunction

Import

import { getTimeZoneGroups } from '@grafana/data';

getTimeZoneInfo

Sat, 04 Apr 2026 12:26:57 +0000

getTimeZoneInfo variable

Signature

getTimeZoneInfo: (zone: string, timestamp: number) => TimeZoneInfo | undefined

Import

import { getTimeZoneInfo } from '@grafana/data';

getTimeZones

Sat, 04 Apr 2026 12:26:57 +0000

getTimeZones variable

Signature

getTimeZones: ((includeInternal?: boolean | InternalTimeZones[]) => TimeZone[]) & import("lodash").MemoizedFunction

Import

import { getTimeZones } from '@grafana/data';

getValueFormat

Sat, 04 Apr 2026 12:26:57 +0000

getValueFormat() function

Signature

export declare function getValueFormat(id?: string | null): ValueFormatter;

Import

import { getValueFormat } from '@grafana/data';

Parameters

Parameter	Type	Description
id	`string \| null`

Returns:

ValueFormatter

getValueFormats

Sat, 04 Apr 2026 12:26:57 +0000

getValueFormats() function

Signature

export declare function getValueFormats(): {
    text: string;
    submenu: {
        text: string;
        value: string;
    }[];
}[];

Import

import { getValueFormats } from '@grafana/data';

Returns:

{ text: string; submenu: { text: string; value: string; }[]; }[]

getValueFormatterIndex

Sat, 04 Apr 2026 12:26:57 +0000

getValueFormatterIndex() function

Signature

export declare function getValueFormatterIndex(): ValueFormatterIndex;

Import

import { getValueFormatterIndex } from '@grafana/data';

Returns:

ValueFormatterIndex

getValueFromDimension

Sat, 04 Apr 2026 12:26:57 +0000

getValueFromDimension variable

Signature

getValueFromDimension: (dimension: Dimension, column: number, row: number) => any

Import

import { getValueFromDimension } from '@grafana/data';

getValueMatcher

Sat, 04 Apr 2026 12:26:57 +0000

getValueMatcher() function

Resolves a value matcher from the registry for given config. Will throw an error if matcher can not be resolved.

Signature

export declare function getValueMatcher(config: MatcherConfig): ValueMatcher;

Import

import { getValueMatcher } from '@grafana/data';

Parameters

Parameter	Type	Description
config	`MatcherConfig`

Returns:

ValueMatcher

getWeekdayIndex

Sat, 04 Apr 2026 12:26:57 +0000

getWeekdayIndex variable

Signature

getWeekdayIndex: (day: string) => number

Import

import { getWeekdayIndex } from '@grafana/data';

GrafanaConfig

Sat, 04 Apr 2026 12:26:57 +0000

GrafanaConfig interface

Describes all the different Grafana configuration values available for an instance.

Signature

export interface GrafanaConfig

Import

import { GrafanaConfig } from '@grafana/data';

Properties

Property	Type	Description
alertingEnabled	`boolean`
alertingErrorOrTimeout	`string`
alertingMinInterval	`number`
alertingNoDataOrNullValues	`string`
allowOrgCreate	`boolean`
appSubUrl	`string`
authProxyEnabled	`boolean`
autoAssignOrg	`boolean`
bootData	`any`
buildInfo	`BuildInfo`
customTheme	`any`
datasources	`{` `[str: string]: DataSourceInstanceSettings;` `}`
dateFormats	`SystemDateFormatSettings`
defaultDatasource	`string`
disableLoginForm	`boolean`
disableSanitizeHtml	`boolean`
disableUserSignUp	`boolean`
editorsCanAdmin	`boolean`
exploreEnabled	`boolean`
externalUserMngInfo	`string`
externalUserMngLinkName	`string`
externalUserMngLinkUrl	`string`
featureToggles	`FeatureToggles`
geomapDefaultBaseLayer	`MapLayerOptions`
geomapDisableCustomBaseLayer	`boolean`
http2Enabled	`boolean`
ldapEnabled	`boolean`
licenseInfo	`LicenseInfo`
liveEnabled	`boolean`
loginError	`any`
loginHint	`any`
minRefreshInterval	`string`
navTree	`any`
newPanelTitle	`string`
oauth	`any`
panels	`{` `[key: string]: PanelPluginMeta;` `}`
passwordHint	`any`
pluginsToPreload	`PreloadPlugin[]`
samlEnabled	`boolean`
sentry	`SentryConfig`
sigV4AuthEnabled	`boolean`
theme	`GrafanaTheme`
theme2	`GrafanaTheme2`
unifiedAlertingEnabled	`boolean`
verifyEmailEnabled	`boolean`
viewersCanEdit	`boolean`
windowTitlePrefix	`string`

alertingEnabled property

Signature

alertingEnabled: boolean;

alertingErrorOrTimeout property

Signature

alertingErrorOrTimeout: string;

alertingMinInterval property

Signature

alertingMinInterval: number;

alertingNoDataOrNullValues property

Signature

alertingNoDataOrNullValues: string;

allowOrgCreate property

Signature

allowOrgCreate: boolean;

appSubUrl property

Signature

appSubUrl: string;

authProxyEnabled property

Signature

authProxyEnabled: boolean;

autoAssignOrg property

Signature

autoAssignOrg: boolean;

bootData property

Signature

bootData: any;

buildInfo property

Signature

buildInfo: BuildInfo;

customTheme property

Signature

customTheme?: any;

datasources property

Signature

datasources: {
        [str: string]: DataSourceInstanceSettings;
    };

dateFormats property

Signature

dateFormats?: SystemDateFormatSettings;

defaultDatasource property

Signature

defaultDatasource: string;

disableLoginForm property

Signature

disableLoginForm: boolean;

disableSanitizeHtml property

Signature

disableSanitizeHtml: boolean;

disableUserSignUp property

Signature

disableUserSignUp: boolean;

editorsCanAdmin property

Signature

editorsCanAdmin: boolean;

exploreEnabled property

Signature

exploreEnabled: boolean;

externalUserMngInfo property

Signature

externalUserMngInfo: string;

externalUserMngLinkName property

Signature

externalUserMngLinkName: string;

externalUserMngLinkUrl property

Signature

externalUserMngLinkUrl: string;

featureToggles property

Signature

featureToggles: FeatureToggles;

geomapDefaultBaseLayer property

Signature

geomapDefaultBaseLayer?: MapLayerOptions;

geomapDisableCustomBaseLayer property

Signature

geomapDisableCustomBaseLayer?: boolean;

http2Enabled property

Signature

http2Enabled: boolean;

ldapEnabled property

Signature

ldapEnabled: boolean;

licenseInfo property

Signature

licenseInfo: LicenseInfo;

liveEnabled property

Signature

liveEnabled: boolean;

loginError property

Signature

loginError: any;

loginHint property

Signature

loginHint: any;

minRefreshInterval property

Signature

minRefreshInterval: string;

navTree property

Signature

navTree: any;

newPanelTitle property

Signature

newPanelTitle: string;

oauth property

Signature

oauth: any;

panels property

Signature

panels: {
        [key: string]: PanelPluginMeta;
    };

passwordHint property

Signature

passwordHint: any;

pluginsToPreload property

Signature

pluginsToPreload: PreloadPlugin[];

samlEnabled property

Signature

samlEnabled: boolean;

sentry property

Signature

sentry: SentryConfig;

sigV4AuthEnabled property

Signature

sigV4AuthEnabled: boolean;

theme property

Signature

theme: GrafanaTheme;

theme2 property

Signature

theme2: GrafanaTheme2;

unifiedAlertingEnabled property

Signature

unifiedAlertingEnabled: boolean;

verifyEmailEnabled property

Signature

verifyEmailEnabled: boolean;

viewersCanEdit property

Signature

viewersCanEdit: boolean;

windowTitlePrefix property

Signature

windowTitlePrefix: string;

GrafanaPlugin

Sat, 04 Apr 2026 12:26:57 +0000

GrafanaPlugin class

Signature

export declare class GrafanaPlugin<T extends PluginMeta = PluginMeta>

Import

import { GrafanaPlugin } from '@grafana/data';

Constructors

Constructor	Modifiers	Description
constructor()		Constructs a new instance of the `GrafanaPlugin` class

Properties

Property	Modifiers	Type	Description
angularConfigCtrl		`any`
configPages		`Array<PluginConfigPage<T>>`
loadError		`boolean`
meta		`T`

Methods

Method	Modifiers	Description
addConfigPage(tab)
setChannelSupport(support)

constructor()

Constructs a new instance of the GrafanaPlugin class

Signature

constructor();

angularConfigCtrl property

Signature

angularConfigCtrl?: any;

configPages property

Signature

configPages?: Array<PluginConfigPage<T>>;

loadError property

Signature

loadError?: boolean;

meta property

Signature

meta: T;

addConfigPage method

Signature

addConfigPage(tab: PluginConfigPage<T>): this;

Parameters

Parameter	Type	Description
tab	`PluginConfigPage<T>`

Returns:

this

setChannelSupport method

Signature

setChannelSupport(support: any): this;

Parameters

Parameter	Type	Description
support	`any`

Returns:

this

GrafanaTheme

Sat, 04 Apr 2026 12:26:57 +0000

GrafanaTheme interface

Signature

export interface GrafanaTheme extends GrafanaThemeCommons

Import

import { GrafanaTheme } from '@grafana/data';

Properties

Property	Type	Description
colors	`{` `bg1: string;` `bg2: string;` `bg3: string;` `border1: string;` `border2: string;` `border3: string;` `bgBlue1: string;` `bgBlue2: string;` `dashboardBg: string;` `bodyBg: string;` `panelBg: string;` `panelBorder: string;` `pageHeaderBg: string;` `pageHeaderBorder: string;` `dropdownBg: string;` `dropdownShadow: string;` `dropdownOptionHoverBg: string;` `link: string;` `linkDisabled: string;` `linkHover: string;` `linkExternal: string;` `textStrong: string;` `textHeading: string;` `text: string;` `textSemiWeak: string;` `textWeak: string;` `textFaint: string;` `textBlue: string;` `formLabel: string;` `formDescription: string;` `formInputBg: string;` `formInputBgDisabled: string;` `formInputBorder: string;` `formInputBorderHover: string;` `formInputBorderActive: string;` `formInputBorderInvalid: string;` `formFocusOutline: string;` `formInputText: string;` `formInputDisabledText: string;` `formInputPlaceholderText: string;` `formValidationMessageText: string;` `formValidationMessageBg: string;` `}`
isDark	`boolean`
isLight	`boolean`
palette	`{` `black: string;` `white: string;` `dark1: string;` `dark2: string;` `dark3: string;` `dark4: string;` `dark5: string;` `dark6: string;` `dark7: string;` `dark8: string;` `dark9: string;` `dark10: string;` `gray1: string;` `gray2: string;` `gray3: string;` `gray4: string;` `gray5: string;` `gray6: string;` `gray7: string;` `gray98: string;` `gray97: string;` `gray95: string;` `gray90: string;` `gray85: string;` `gray70: string;` `gray60: string;` `gray33: string;` `gray25: string;` `gray15: string;` `gray10: string;` `gray05: string;` `blue95: string;` `blue85: string;` `blue80: string;` `blue77: string;` `red88: string;` `redBase: string;` `redShade: string;` `greenBase: string;` `greenShade: string;` `red: string;` `yellow: string;` `purple: string;` `orange: string;` `orangeDark: string;` `queryRed: string;` `queryGreen: string;` `queryPurple: string;` `queryOrange: string;` `brandPrimary: string;` `brandSuccess: string;` `brandWarning: string;` `brandDanger: string;` `online: string;` `warn: string;` `critical: string;` `}`
shadows	`{` `listItem: string;` `}`
type	`GrafanaThemeType`
visualization	`ThemeVisualizationColors`

colors property

Signature

colors: {
        bg1: string;
        bg2: string;
        bg3: string;
        border1: string;
        border2: string;
        border3: string;
        bgBlue1: string;
        bgBlue2: string;
        dashboardBg: string;
        bodyBg: string;
        panelBg: string;
        panelBorder: string;
        pageHeaderBg: string;
        pageHeaderBorder: string;
        dropdownBg: string;
        dropdownShadow: string;
        dropdownOptionHoverBg: string;
        link: string;
        linkDisabled: string;
        linkHover: string;
        linkExternal: string;
        textStrong: string;
        textHeading: string;
        text: string;
        textSemiWeak: string;
        textWeak: string;
        textFaint: string;
        textBlue: string;
        formLabel: string;
        formDescription: string;
        formInputBg: string;
        formInputBgDisabled: string;
        formInputBorder: string;
        formInputBorderHover: string;
        formInputBorderActive: string;
        formInputBorderInvalid: string;
        formFocusOutline: string;
        formInputText: string;
        formInputDisabledText: string;
        formInputPlaceholderText: string;
        formValidationMessageText: string;
        formValidationMessageBg: string;
    };

isDark property

Signature

isDark: boolean;

isLight property

Signature

isLight: boolean;

palette property

Signature

palette: {
        black: string;
        white: string;
        dark1: string;
        dark2: string;
        dark3: string;
        dark4: string;
        dark5: string;
        dark6: string;
        dark7: string;
        dark8: string;
        dark9: string;
        dark10: string;
        gray1: string;
        gray2: string;
        gray3: string;
        gray4: string;
        gray5: string;
        gray6: string;
        gray7: string;
        gray98: string;
        gray97: string;
        gray95: string;
        gray90: string;
        gray85: string;
        gray70: string;
        gray60: string;
        gray33: string;
        gray25: string;
        gray15: string;
        gray10: string;
        gray05: string;
        blue95: string;
        blue85: string;
        blue80: string;
        blue77: string;
        red88: string;
        redBase: string;
        redShade: string;
        greenBase: string;
        greenShade: string;
        red: string;
        yellow: string;
        purple: string;
        orange: string;
        orangeDark: string;
        queryRed: string;
        queryGreen: string;
        queryPurple: string;
        queryOrange: string;
        brandPrimary: string;
        brandSuccess: string;
        brandWarning: string;
        brandDanger: string;
        online: string;
        warn: string;
        critical: string;
    };

shadows property

Signature

shadows: {
        listItem: string;
    };

type property

Signature

type: GrafanaThemeType;

visualization property

Signature

visualization: ThemeVisualizationColors;

GrafanaTheme2

Sat, 04 Apr 2026 12:26:57 +0000

GrafanaTheme2 interface

Next gen theme model introduced in Grafana v8.

Signature

export interface GrafanaTheme2

Import

import { GrafanaTheme2 } from '@grafana/data';

Properties

Property	Type	Description
breakpoints	`ThemeBreakpoints`	*(BETA)*
colors	`ThemeColors`	*(BETA)*
components	`ThemeComponents`	*(BETA)*
isDark	`boolean`	*(BETA)*
isLight	`boolean`	*(BETA)*
name	`string`	*(BETA)*
shadows	`ThemeShadows`	*(BETA)*
shape	`ThemeShape`	*(BETA)*
spacing	`ThemeSpacing`	*(BETA)*
transitions	`ThemeTransitions`	*(BETA)*
typography	`ThemeTypography`	*(BETA)*
v1	`GrafanaTheme`	*(BETA)*
visualization	`ThemeVisualizationColors`	*(BETA)*
zIndex	`ThemeZIndices`	*(BETA)*

breakpoints property

Signature

breakpoints: ThemeBreakpoints;

colors property

Signature

colors: ThemeColors;

components property

Signature

components: ThemeComponents;

isDark property

Signature

isDark: boolean;

isLight property

Signature

isLight: boolean;

name property

Signature

name: string;

shadows property

Signature

shadows: ThemeShadows;

shape property

Signature

shape: ThemeShape;

spacing property

Signature

spacing: ThemeSpacing;

transitions property

Signature

transitions: ThemeTransitions;

typography property

Signature

typography: ThemeTypography;

v1 property

Signature

v1: GrafanaTheme;

visualization property

Signature

visualization: ThemeVisualizationColors;

zIndex property

Signature

zIndex: ThemeZIndices;

GrafanaThemeCommons

Sat, 04 Apr 2026 12:26:57 +0000

GrafanaThemeCommons interface

Signature

export interface GrafanaThemeCommons

Import

import { GrafanaThemeCommons } from '@grafana/data';

Properties

Property	Type	Description
border	`{` `radius: {` `sm: string;` `md: string;` `lg: string;` `};` `width: {` `sm: string;` `};` `}`
breakpoints	`{` `xs: string;` `sm: string;` `md: string;` `lg: string;` `xl: string;` `xxl: string;` `}`
height	`{` `sm: number;` `md: number;` `lg: number;` `}`
name	`string`
panelHeaderHeight	`number`
panelPadding	`number`
spacing	`{` `base: number;` `insetSquishMd: string;` `d: string;` `xxs: string;` `xs: string;` `sm: string;` `md: string;` `lg: string;` `xl: string;` `gutter: string;` `formSpacingBase: number;` `formMargin: string;` `formFieldsetMargin: string;` `formInputHeight: number;` `formButtonHeight: number;` `formInputPaddingHorizontal: string;` `formInputAffixPaddingHorizontal: string;` `formInputMargin: string;` `formLabelPadding: string;` `formLabelMargin: string;` `formValidationMessagePadding: string;` `formValidationMessageMargin: string;` `inlineFormMargin: string;` `}`
typography	`{` `fontFamily: {` `sansSerif: string;` `monospace: string;` `};` `size: {` `base: string;` `xs: string;` `sm: string;` `md: string;` `lg: string;` `};` `weight: {` `light: number;` `regular: number;` `semibold: number;` `bold: number;` `};` `lineHeight: {` `xs: number;` `sm: number;` `md: number;` `lg: number;` `};` `heading: {` `h1: string;` `h2: string;` `h3: string;` `h4: string;` `h5: string;` `h6: string;` `};` `link: {` `decoration: string;` `hoverDecoration: string;` `};` `}`
zIndex	`{` `dropdown: number;` `navbarFixed: number;` `sidemenu: number;` `tooltip: number;` `modalBackdrop: number;` `modal: number;` `portal: number;` `typeahead: number;` `}`

border property

Signature

border: {
        radius: {
            sm: string;
            md: string;
            lg: string;
        };
        width: {
            sm: string;
        };
    };

breakpoints property

Signature

breakpoints: {
        xs: string;
        sm: string;
        md: string;
        lg: string;
        xl: string;
        xxl: string;
    };

height property

Signature

height: {
        sm: number;
        md: number;
        lg: number;
    };

name property

Signature

name: string;

panelHeaderHeight property

Signature

panelHeaderHeight: number;

panelPadding property

Signature

panelPadding: number;

spacing property

Signature

spacing: {
        base: number;
        insetSquishMd: string;
        d: string;
        xxs: string;
        xs: string;
        sm: string;
        md: string;
        lg: string;
        xl: string;
        gutter: string;
        formSpacingBase: number;
        formMargin: string;
        formFieldsetMargin: string;
        formInputHeight: number;
        formButtonHeight: number;
        formInputPaddingHorizontal: string;
        formInputAffixPaddingHorizontal: string;
        formInputMargin: string;
        formLabelPadding: string;
        formLabelMargin: string;
        formValidationMessagePadding: string;
        formValidationMessageMargin: string;
        inlineFormMargin: string;
    };

typography property

Signature

typography: {
        fontFamily: {
            sansSerif: string;
            monospace: string;
        };
        size: {
            base: string;
            xs: string;
            sm: string;
            md: string;
            lg: string;
        };
        weight: {
            light: number;
            regular: number;
            semibold: number;
            bold: number;
        };
        lineHeight: {
            xs: number;
            sm: number;
            md: number;
            lg: number;
        };
        heading: {
            h1: string;
            h2: string;
            h3: string;
            h4: string;
            h5: string;
            h6: string;
        };
        link: {
            decoration: string;
            hoverDecoration: string;
        };
    };

zIndex property

Signature

zIndex: {
        dropdown: number;
        navbarFixed: number;
        sidemenu: number;
        tooltip: number;
        modalBackdrop: number;
        modal: number;
        portal: number;
        typeahead: number;
    };

GrafanaThemeType

Sat, 04 Apr 2026 12:26:57 +0000

GrafanaThemeType enum

Signature

export declare enum GrafanaThemeType

Import

import { GrafanaThemeType } from '@grafana/data';

Enumeration Members

Member	Value	Description
Dark	`"dark"`
Light	`"light"`

GraphSeriesValue

Sat, 04 Apr 2026 12:26:57 +0000

GraphSeriesValue type

Signature

export declare type GraphSeriesValue = number | null;

Import

import { GraphSeriesValue } from '@grafana/data';

GraphSeriesXY

Sat, 04 Apr 2026 12:26:57 +0000

GraphSeriesXY interface

View model projection of a series

Signature

export interface GraphSeriesXY

Import

import { GraphSeriesXY } from '@grafana/data';

Properties

Property	Type	Description
color	`string`
data	`GraphSeriesValue[][]`
info	`DisplayValue[]`
isVisible	`boolean`
label	`string`
seriesIndex	`number`
timeField	`Field`
timeStep	`number`
valueField	`Field`
yAxis	`YAxis`

color property

Signature

color?: string;

data property

Signature

data: GraphSeriesValue[][];

info property

Signature

info?: DisplayValue[];

isVisible property

Signature

isVisible: boolean;

label property

Signature

label: string;

seriesIndex property

Signature

seriesIndex: number;

timeField property

Signature

timeField: Field;

timeStep property

Signature

timeStep: number;

valueField property

Signature

valueField: Field;

yAxis property

Signature

yAxis: YAxis;

GroupedTimeZones

Sat, 04 Apr 2026 12:26:57 +0000

GroupedTimeZones interface

Signature

export interface GroupedTimeZones

Import

import { GroupedTimeZones } from '@grafana/data';

Properties

Property	Type	Description
name	`string`
zones	`TimeZone[]`

name property

Signature

name: string;

zones property

Signature

zones: TimeZone[];

guessFieldTypeForField

Sat, 04 Apr 2026 12:26:57 +0000

guessFieldTypeForField() function

Looks at the data to guess the column type. This ignores any existing setting

Signature

export declare function guessFieldTypeForField(field: Field): FieldType | undefined;

Import

import { guessFieldTypeForField } from '@grafana/data';

Parameters

Parameter	Type	Description
field	`Field`

Returns:

FieldType | undefined

guessFieldTypeFromNameAndValue

Sat, 04 Apr 2026 12:26:57 +0000

guessFieldTypeFromNameAndValue() function

Given a name and value, this will pick a reasonable field type

Signature

export declare function guessFieldTypeFromNameAndValue(name: string, v: any): FieldType;

Import

import { guessFieldTypeFromNameAndValue } from '@grafana/data';

Parameters

Parameter	Type	Description
name	`string`
v	`any`

Returns:

FieldType

guessFieldTypeFromValue

Sat, 04 Apr 2026 12:26:57 +0000

guessFieldTypeFromValue() function

Given a value this will guess the best column type

NOTE: this is will try to see if string values can be mapped to other types (like number)

Signature

export declare function guessFieldTypeFromValue(v: any): FieldType;

Import

import { guessFieldTypeFromValue } from '@grafana/data';

Parameters

Parameter	Type	Description
v	`any`

Returns:

FieldType

guessFieldTypes

Sat, 04 Apr 2026 12:26:57 +0000

guessFieldTypes variable

Signature

guessFieldTypes: (series: DataFrame, guessDefined?: boolean) => DataFrame

Import

import { guessFieldTypes } from '@grafana/data';

hasLinks

Sat, 04 Apr 2026 12:26:57 +0000

hasLinks() function

Signature

export declare function hasLinks(field: Field): boolean;

Import

import { hasLinks } from '@grafana/data';

Parameters

Parameter	Type	Description
field	`Field`

Returns:

boolean

hasMsResolution

Sat, 04 Apr 2026 12:26:57 +0000

hasMsResolution variable

Checks if series time field has ms resolution

Signature

hasMsResolution: (timeField: Field) => boolean

Import

import { hasMsResolution } from '@grafana/data';

hexToRgb

Sat, 04 Apr 2026 12:26:57 +0000

colorManipulator.hexToRgb() function

colorManipulator.hexToRgb() function

Converts a color from CSS hex format to CSS rgb format.

Signature

export declare function hexToRgb(color: string): string;

Import

import { colorManipulator } from '@grafana/data';
const { hexToRgb } = colorManipulator;

Parameters

Parameter	Type	Description
color	`string`	Hex color, i.e. #nnn or #nnnnnn

Returns:

string

A CSS rgb color string

HistoryItem

Sat, 04 Apr 2026 12:26:57 +0000

HistoryItem interface

Signature

export interface HistoryItem<TQuery extends DataQuery = DataQuery>

Import

import { HistoryItem } from '@grafana/data';

Properties

Property	Type	Description
query	`TQuery`
ts	`number`

query property

Signature

query: TQuery;

ts property

Signature

ts: number;

hslToRgb

Sat, 04 Apr 2026 12:26:57 +0000

colorManipulator.hslToRgb() function

colorManipulator.hslToRgb() function

Converts a color from hsl format to rgb format.

Signature

export declare function hslToRgb(color: string | DecomposeColor): string;

Import

import { colorManipulator } from '@grafana/data';
const { hslToRgb } = colorManipulator;

Parameters

Parameter	Type	Description
color	`string \| DecomposeColor`	HSL color values

Returns:

string

rgb color values

identityOverrideProcessor

Sat, 04 Apr 2026 12:26:57 +0000

identityOverrideProcessor variable

Signature

identityOverrideProcessor: <T>(value: T, _context: FieldOverrideContext, _settings: any) => T

Import

import { identityOverrideProcessor } from '@grafana/data';

IndexVector

Sat, 04 Apr 2026 12:26:57 +0000

IndexVector class

IndexVector is a simple vector implementation that returns the index value for each element in the vector. It is functionally equivolant a vector backed by an array with values: [0,1,2,...,length-1]

Signature

export declare class IndexVector extends FunctionalVector<number>

Import

import { IndexVector } from '@grafana/data';

Constructors

Constructor	Modifiers	Description
constructor(len)		Constructs a new instance of the `IndexVector` class

Properties

Property	Modifiers	Type	Description
length		`number`

Methods

Method	Modifiers	Description
get(index)
newField(len)	`static`	Returns a field representing the range [0 … length-1]

constructor(len)

Constructs a new instance of the IndexVector class

Signature

constructor(len: number);

Parameters

Parameter	Type	Description
len	`number`

length property

Signature

get length(): number;

get method

Signature

get(index: number): number;

Parameters

Parameter	Type	Description
index	`number`

Returns:

number

newField method

Returns a field representing the range [0 … length-1]

Signature

static newField(len: number): Field<number>;

Parameters

Parameter	Type	Description
len	`number`

Returns:

Field<number>

InternalTimeZones

Sat, 04 Apr 2026 12:26:57 +0000

InternalTimeZones enum

Signature

export declare enum InternalTimeZones

Import

import { InternalTimeZones } from '@grafana/data';

Enumeration Members

Member	Value	Description
default	`""`
localBrowserTime	`"browser"`
utc	`"utc"`

InterpolateFunction

Sat, 04 Apr 2026 12:26:57 +0000

InterpolateFunction type

Signature

export declare type InterpolateFunction = (value: string, scopedVars?: ScopedVars, format?: string | Function) => string;

Import

import { InterpolateFunction } from '@grafana/data';

intervalToAbbreviatedDurationString

Sat, 04 Apr 2026 12:26:57 +0000

intervalToAbbreviatedDurationString() function

intervalToAbbreviatedDurationString converts interval to readable duration string

Signature

export declare function intervalToAbbreviatedDurationString(interval: Interval, includeSeconds?: boolean): string;

Import

import { intervalToAbbreviatedDurationString } from '@grafana/data';

Parameters

Parameter	Type	Description
interval	`Interval`	interval to convert
includeSeconds	`boolean`	optional, default true. If false, will not include seconds unless interval is less than 1 minute

Returns:

string

intervalToMs

Sat, 04 Apr 2026 12:26:57 +0000

rangeUtil.intervalToMs() function

Signature

export declare function intervalToMs(str: string): number;

Import

import { rangeUtil } from '@grafana/data';
const { intervalToMs } = rangeUtil;

Parameters

Parameter	Type	Description
str	`string`

Returns:

number

intervalToSeconds

Sat, 04 Apr 2026 12:26:57 +0000

rangeUtil.intervalToSeconds() function

Signature

export declare function intervalToSeconds(str: string): number;

Import

import { rangeUtil } from '@grafana/data';
const { intervalToSeconds } = rangeUtil;

Parameters

Parameter	Type	Description
str	`string`

Returns:

number

IntervalValues

Sat, 04 Apr 2026 12:26:57 +0000

IntervalValues interface

Signature

export interface IntervalValues

Import

import { IntervalValues } from '@grafana/data';

Properties

Property	Type	Description
interval	`string`
intervalMs	`number`

interval property

Signature

interval: string;

intervalMs property

Signature

intervalMs: number;

isBooleanUnit

Sat, 04 Apr 2026 12:26:57 +0000

isBooleanUnit() function

Signature

export declare function isBooleanUnit(unit?: string): boolean | "" | undefined;

Import

import { isBooleanUnit } from '@grafana/data';

Parameters

Parameter	Type	Description
unit	`string`

Returns:

boolean | "" | undefined

isDataFrame

Sat, 04 Apr 2026 12:26:57 +0000

isDataFrame variable

Signature

isDataFrame: (data: any) => data is DataFrame

Import

import { isDataFrame } from '@grafana/data';

isDataSourceRef

Sat, 04 Apr 2026 12:26:57 +0000

isDataSourceRef() function

Returns true if the argument is a DataSourceRef

Signature

export declare function isDataSourceRef(ref: DataSourceRef | string | null): ref is DataSourceRef;

Import

import { isDataSourceRef } from '@grafana/data';

Parameters

Parameter	Type	Description
ref	`DataSourceRef \| string \| null`

Returns:

ref is DataSourceRef

isDateTime

Sat, 04 Apr 2026 12:26:57 +0000

isDateTime variable

Signature

isDateTime: (value: any) => value is DateTime

Import

import { isDateTime } from '@grafana/data';

isFiscal

Sat, 04 Apr 2026 12:26:57 +0000

rangeUtil.isFiscal() function

Signature

export declare function isFiscal(timeRange: TimeRange): boolean;

Import

import { rangeUtil } from '@grafana/data';
const { isFiscal } = rangeUtil;

Parameters

Parameter	Type	Description
timeRange	`TimeRange`

Returns:

boolean

isLiveChannelJoinEvent

Sat, 04 Apr 2026 12:26:57 +0000

isLiveChannelJoinEvent() function

Signature

export declare function isLiveChannelJoinEvent<T>(evt: LiveChannelEvent<T>): evt is LiveChannelJoinEvent;

Import

import { isLiveChannelJoinEvent } from '@grafana/data';

Parameters

Parameter	Type	Description
evt	`LiveChannelEvent<T>`

Returns:

evt is LiveChannelJoinEvent

isLiveChannelLeaveEvent

Sat, 04 Apr 2026 12:26:57 +0000

isLiveChannelLeaveEvent() function

Signature

export declare function isLiveChannelLeaveEvent<T>(evt: LiveChannelEvent<T>): evt is LiveChannelLeaveEvent;

Import

import { isLiveChannelLeaveEvent } from '@grafana/data';

Parameters

Parameter	Type	Description
evt	`LiveChannelEvent<T>`

Returns:

evt is LiveChannelLeaveEvent

isLiveChannelMessageEvent

Sat, 04 Apr 2026 12:26:57 +0000

isLiveChannelMessageEvent() function

Signature

export declare function isLiveChannelMessageEvent<T>(evt: LiveChannelEvent<T>): evt is LiveChannelMessageEvent<T>;

Import

import { isLiveChannelMessageEvent } from '@grafana/data';

Parameters

Parameter	Type	Description
evt	`LiveChannelEvent<T>`

Returns:

evt is LiveChannelMessageEvent<T>

isLiveChannelStatusEvent

Sat, 04 Apr 2026 12:26:57 +0000

isLiveChannelStatusEvent() function

Signature

export declare function isLiveChannelStatusEvent<T>(evt: LiveChannelEvent<T>): evt is LiveChannelStatusEvent;

Import

import { isLiveChannelStatusEvent } from '@grafana/data';

Parameters

Parameter	Type	Description
evt	`LiveChannelEvent<T>`

Returns:

evt is LiveChannelStatusEvent

isMathString

Sat, 04 Apr 2026 12:26:57 +0000

dateMath.isMathString() function

Determine if a string contains a relative date time.

Signature

export declare function isMathString(text: string | DateTime | Date): boolean;

Import

import { dateMath } from '@grafana/data';
const { isMathString } = dateMath;

Parameters

Parameter	Type	Description
text	`string \| DateTime \| Date`

Returns:

boolean

ISO_8601

Sat, 04 Apr 2026 12:26:57 +0000

ISO_8601 variable

Signature

ISO_8601: DateTimeBuiltinFormat

Import

import { ISO_8601 } from '@grafana/data';

isRelativeTimeRange

Sat, 04 Apr 2026 12:26:57 +0000

rangeUtil.isRelativeTimeRange() function

Signature

export declare function isRelativeTimeRange(raw: RawTimeRange): boolean;

Import

import { rangeUtil } from '@grafana/data';
const { isRelativeTimeRange } = rangeUtil;

Parameters

Parameter	Type	Description
raw	`RawTimeRange`

Returns:

boolean

isTableData

Sat, 04 Apr 2026 12:26:57 +0000

isTableData variable

Signature

isTableData: (data: any) => data is DataFrame

Import

import { isTableData } from '@grafana/data';

isValid

Sat, 04 Apr 2026 12:26:57 +0000

dateMath.isValid() function

Checks if text is a valid date which in this context means that it is either a Moment instance or it can be parsed by parse function. See parse function to see what is considered acceptable.

Signature

export declare function isValid(text: string | DateTime): boolean;

Import

import { dateMath } from '@grafana/data';
const { isValid } = dateMath;

Parameters

Parameter	Type	Description
text	`string \| DateTime`

Returns:

boolean

isValidDate

Sat, 04 Apr 2026 12:26:57 +0000

isValidDate() function

isValidDate returns true if given string can be parsed into valid Date object, false otherwise

Signature

export declare function isValidDate(dateString: string): boolean;

Import

import { isValidDate } from '@grafana/data';

Parameters

Parameter	Type	Description
dateString	`string`	string representation of a date

Returns:

boolean

isValidDuration

Sat, 04 Apr 2026 12:26:57 +0000

isValidDuration() function

isValidDuration returns true if the given string can be parsed into a valid Duration object, false otherwise

Signature

export declare function isValidDuration(durationString: string): boolean;

Import

import { isValidDuration } from '@grafana/data';

Parameters

Parameter	Type	Description
durationString	`string`	string representation of a duration

Returns:

boolean

isValidTimeSpan

Sat, 04 Apr 2026 12:26:57 +0000

rangeUtil.isValidTimeSpan variable

Signature

isValidTimeSpan: (value: string) => boolean

Import

import { rangeUtil } from '@grafana/data';
const { isValidTimeSpan } = rangeUtil;

KeyValue

Sat, 04 Apr 2026 12:26:57 +0000

KeyValue type

Signature

export declare type KeyValue<T = any> = Record<string, T>;

Import

import { KeyValue } from '@grafana/data';

Labels

Sat, 04 Apr 2026 12:26:57 +0000

Labels interface

Signature

export interface Labels

Import

import { Labels } from '@grafana/data';

LanguageProvider

Sat, 04 Apr 2026 12:26:57 +0000

LanguageProvider class

Signature

declare abstract class LanguageProvider

Import

import { LanguageProvider } from '@grafana/data';

Properties

Property	Type	Description
datasource	`DataSourceApi<any, any>`
request	`(url: string, params?: any) => Promise<any>`
start	`() => Promise<Array<Promise<any>>>`	Returns startTask that resolves with a task list when main syntax is loaded. Task list consists of secondary promises that load more detailed language features.
startTask	`Promise<any[]>`

datasource property

Signature

abstract datasource: DataSourceApi<any, any>;

request property

Signature

abstract request: (url: string, params?: any) => Promise<any>;

start property

Returns startTask that resolves with a task list when main syntax is loaded. Task list consists of secondary promises that load more detailed language features.

Signature

abstract start: () => Promise<Array<Promise<any>>>;

startTask property

Signature

startTask?: Promise<any[]>;

LayoutMode

Sat, 04 Apr 2026 12:26:57 +0000

LayoutMode type

Signature

export declare type LayoutMode = LayoutModes.Grid | LayoutModes.List;

Import

import { LayoutMode } from '@grafana/data';

LayoutModes

Sat, 04 Apr 2026 12:26:57 +0000

LayoutModes enum

Signature

export declare enum LayoutModes

Import

import { LayoutModes } from '@grafana/data';

Enumeration Members

Member	Value	Description
Grid	`"grid"`
List	`"list"`

LegacyEmitter

Sat, 04 Apr 2026 12:26:57 +0000

LegacyEmitter interface

Signature

export interface LegacyEmitter

Import

import { LegacyEmitter } from '@grafana/data';

Methods

Method	Description
emit(event, payload)
off(event, handler)
on(event, handler, scope)

emit method

Signature

emit<T>(event: AppEvent<T> | string, payload?: T): void;

Parameters

Parameter	Type	Description
event	`AppEvent<T> \| string`
payload	`T`

Returns:

void

off method

Signature

off<T>(event: AppEvent<T> | string, handler: (payload?: T | any) => void): void;

Parameters

Parameter	Type	Description
event	`AppEvent<T> \| string`
handler	`(payload?: T \| any) => void`

Returns:

void

on method

Signature

on<T>(event: AppEvent<T> | string, handler: LegacyEventHandler<T>, scope?: any): void;

Parameters

Parameter	Type	Description
event	`AppEvent<T> \| string`
handler	`LegacyEventHandler<T>`
scope	`any`

Returns:

void

LegacyEventHandler

Sat, 04 Apr 2026 12:26:57 +0000

LegacyEventHandler interface

Signature

export interface LegacyEventHandler<T>

Import

import { LegacyEventHandler } from '@grafana/data';

Properties

Property	Type	Description
wrapper	`(event: BusEvent) => void`

wrapper property

Signature

wrapper?: (event: BusEvent) => void;

LegacyGraphHoverEventPayload

Sat, 04 Apr 2026 12:26:57 +0000

LegacyGraphHoverEventPayload interface

Signature

export interface LegacyGraphHoverEventPayload extends DataHoverPayload

Import

import { LegacyGraphHoverEventPayload } from '@grafana/data';

Properties

Property	Type	Description
panel	`{` `id: number;` `}`
pos	`any`

panel property

Signature

panel: {
        id: number;
    };

pos property

Signature

pos: any;

LegacyResponseData

Sat, 04 Apr 2026 12:26:57 +0000

LegacyResponseData type

Starting in v6.2 DataFrame can represent both TimeSeries and TableData

Signature

export declare type LegacyResponseData = TimeSeries | TableData | any;

Import

import { LegacyResponseData } from '@grafana/data';

LicenseInfo

Sat, 04 Apr 2026 12:26:57 +0000

LicenseInfo interface

Describes the license information about the current running instance of Grafana.

Signature

export interface LicenseInfo

Import

import { LicenseInfo } from '@grafana/data';

Properties

Property	Type	Description
edition	`GrafanaEdition`
enabledFeatures	`{` `[key: string]: boolean;` `}`
expiry	`number`
licenseUrl	`string`
stateInfo	`string`

edition property

Signature

edition: GrafanaEdition;

enabledFeatures property

Signature

enabledFeatures: {
        [key: string]: boolean;
    };

expiry property

Signature

expiry: number;

licenseUrl property

Signature

licenseUrl: string;

stateInfo property

Signature

stateInfo: string;

lighten

Sat, 04 Apr 2026 12:26:57 +0000

colorManipulator.lighten() function

colorManipulator.lighten() function

Lightens a color.

Signature

export declare function lighten(color: string, coefficient: number): string;

Import

import { colorManipulator } from '@grafana/data';
const { lighten } = colorManipulator;

Parameters

Parameter	Type	Description
color	`string`	CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla(), color()
coefficient	`number`	multiplier in the range 0 - 1

Returns:

string

A CSS color string. Hex input values are returned as rgb

LinkModel

Sat, 04 Apr 2026 12:26:57 +0000

LinkModel interface

Processed Link Model. The values are ready to use

Signature

export interface LinkModel<T = any>

Import

import { LinkModel } from '@grafana/data';

Properties

Property	Type	Description
href	`string`
onClick	`(e: any, origin?: any) => void`
origin	`T`
target	`LinkTarget`
title	`string`

href property

Signature

href: string;

onClick property

Signature

onClick?: (e: any, origin?: any) => void;

origin property

Signature

origin: T;

target property

Signature

target: LinkTarget;

title property

Signature

title: string;

LinkModelSupplier

Sat, 04 Apr 2026 12:26:57 +0000

LinkModelSupplier interface

Provides a way to produce links on demand

TODO: ScopedVars in in GrafanaUI package!

Signature

export interface LinkModelSupplier<T extends object>

Import

import { LinkModelSupplier } from '@grafana/data';

Methods

Method	Description
getLinks(replaceVariables)

getLinks method

Signature

getLinks(replaceVariables?: InterpolateFunction): Array<LinkModel<T>>;

Parameters

Parameter	Type	Description
replaceVariables	`InterpolateFunction`

Returns:

Array<LinkModel<T>>

LinkTarget

Sat, 04 Apr 2026 12:26:57 +0000

LinkTarget type

Signature

export declare type LinkTarget = '_blank' | '_self' | undefined;

Import

import { LinkTarget } from '@grafana/data';

LiveChannelConnectionState

Sat, 04 Apr 2026 12:26:57 +0000

LiveChannelConnectionState enum

Signature

export declare enum LiveChannelConnectionState

Import

import { LiveChannelConnectionState } from '@grafana/data';

Enumeration Members

Member	Value	Description
Connected	`"connected"`	Connected to the channel
Disconnected	`"disconnected"`	Disconnected from the channel. The channel will reconnect when possible
Invalid	`"invalid"`	Channel configuraiton was invalid and will not connect
Pending	`"pending"`	The connection is not yet established
Shutdown	`"shutdown"`	Was at some point connected, and will not try to reconnect

LiveChannelEvent

Sat, 04 Apr 2026 12:26:57 +0000

LiveChannelEvent type

Signature

export declare type LiveChannelEvent<T = any> = LiveChannelStatusEvent | LiveChannelJoinEvent | LiveChannelLeaveEvent | LiveChannelMessageEvent<T>;

Import

import { LiveChannelEvent } from '@grafana/data';

LiveChannelEventType

Sat, 04 Apr 2026 12:26:57 +0000

LiveChannelEventType enum

Signature

export declare enum LiveChannelEventType

Import

import { LiveChannelEventType } from '@grafana/data';

Enumeration Members

Member	Value	Description
Join	`"join"`
Leave	`"leave"`
Message	`"message"`
Status	`"status"`

LiveChannelJoinEvent

Sat, 04 Apr 2026 12:26:57 +0000

LiveChannelJoinEvent interface

Signature

export interface LiveChannelJoinEvent

Import

import { LiveChannelJoinEvent } from '@grafana/data';

Properties

Property	Type	Description
type	`LiveChannelEventType.Join`
user	`any`

type property

Signature

type: LiveChannelEventType.Join;

user property

Signature

user: any;

LiveChannelLeaveEvent

Sat, 04 Apr 2026 12:26:57 +0000

LiveChannelLeaveEvent interface

Signature

export interface LiveChannelLeaveEvent

Import

import { LiveChannelLeaveEvent } from '@grafana/data';

Properties

Property	Type	Description
type	`LiveChannelEventType.Leave`
user	`any`

type property

Signature

type: LiveChannelEventType.Leave;

user property

Signature

user: any;

LiveChannelMessageEvent

Sat, 04 Apr 2026 12:26:57 +0000

LiveChannelMessageEvent interface

Signature

export interface LiveChannelMessageEvent<T>

Import

import { LiveChannelMessageEvent } from '@grafana/data';

Properties

Property	Type	Description
message	`T`
type	`LiveChannelEventType.Message`

message property

Signature

message: T;

type property

Signature

type: LiveChannelEventType.Message;

LoadingState

Sat, 04 Apr 2026 12:26:57 +0000

LoadingState enum

Represent panel data loading state.

Signature

export declare enum LoadingState

Import

import { LoadingState } from '@grafana/data';

Enumeration Members

Member	Value	Description
Done	`"Done"`
Error	`"Error"`
Loading	`"Loading"`
NotStarted	`"NotStarted"`
Streaming	`"Streaming"`

locale

Sat, 04 Apr 2026 12:26:57 +0000

locale() function

Signature

export declare function locale(value: number, decimals: DecimalCount): FormattedValue;

Import

import { locale } from '@grafana/data';

Parameters

Parameter	Type	Description
value	`number`
decimals	`DecimalCount`

Returns:

FormattedValue

localTimeFormat

Sat, 04 Apr 2026 12:26:57 +0000

localTimeFormat() function

localTimeFormat helps to generate date formats for momentjs based on browser’s locale

Signature

export declare function localTimeFormat(options: Intl.DateTimeFormatOptions, locale?: string | string[] | null, fallback?: string): string;

Import

import { localTimeFormat } from '@grafana/data';

Parameters

Parameter	Type	Description
options	`Intl.DateTimeFormatOptions`	DateTimeFormatOptions to format date
locale	`string \| string[] \| null`	browser locale, or default
fallback	`string`	default format if Intl API is not present

Returns:

string

locationUtil

Sat, 04 Apr 2026 12:26:57 +0000

locationUtil variable

Signature

locationUtil: {
    initialize: (dependencies: LocationUtilDependencies) => void;
    stripBaseFromUrl: (url: string) => string;
    assureBaseUrl: (url: string) => string;
    updateSearchParams: (init: string, partial: string) => string;
    getTimeRangeUrlParams: () => string | null;
    getVariablesUrlParams: (scopedVars?: ScopedVars | undefined) => string | null;
    processUrl: (url: string) => string;
}

Import

import { locationUtil } from '@grafana/data';

LogLabelStatsModel

Sat, 04 Apr 2026 12:26:57 +0000

LogLabelStatsModel interface

Signature

export interface LogLabelStatsModel

Import

import { LogLabelStatsModel } from '@grafana/data';

Properties

Property	Type	Description
active	`boolean`
count	`number`
proportion	`number`
value	`string`

active property

Signature

active?: boolean;

count property

Signature

count: number;

proportion property

Signature

proportion: number;

value property

Signature

value: string;

LogLevel

Sat, 04 Apr 2026 12:26:57 +0000

LogLevel enum

Mapping of log level abbreviation to canonical log level. Supported levels are reduce to limit color variation.

Signature

export declare enum LogLevel

Import

import { LogLevel } from '@grafana/data';

Enumeration Members

Member	Value	Description
alert	`"critical"`
crit	`"critical"`
critical	`"critical"`
dbug	`"debug"`
debug	`"debug"`
emerg	`"critical"`
eror	`"error"`
err	`"error"`
error	`"error"`
fatal	`"critical"`
info	`"info"`
information	`"info"`
informational	`"info"`
notice	`"info"`
trace	`"trace"`
unknown	`"unknown"`
warn	`"warning"`
warning	`"warning"`

LogRowModel

Sat, 04 Apr 2026 12:26:57 +0000

LogRowModel interface

Signature

export interface LogRowModel

Import

import { LogRowModel } from '@grafana/data';

Properties

Property	Type	Description
dataFrame	`DataFrame`
duplicates	`number`
entry	`string`
entryFieldIndex	`number`
hasAnsi	`boolean`
hasUnescapedContent	`boolean`
labels	`Labels`
logLevel	`LogLevel`
raw	`string`
rowIndex	`number`
searchWords	`string[]`
timeEpochMs	`number`
timeEpochNs	`string`
timeFromNow	`string`
timeLocal	`string`
timeUtc	`string`
uid	`string`
uniqueLabels	`Labels`

dataFrame property

Signature

dataFrame: DataFrame;

duplicates property

Signature

duplicates?: number;

entry property

Signature

entry: string;

entryFieldIndex property

Signature

entryFieldIndex: number;

hasAnsi property

Signature

hasAnsi: boolean;

hasUnescapedContent property

Signature

hasUnescapedContent: boolean;

labels property

Signature

labels: Labels;

logLevel property

Signature

logLevel: LogLevel;

raw property

Signature

raw: string;

rowIndex property

Signature

rowIndex: number;

searchWords property

Signature

searchWords?: string[];

timeEpochMs property

Signature

timeEpochMs: number;

timeEpochNs property

Signature

timeEpochNs: string;

timeFromNow property

Signature

timeFromNow: string;

timeLocal property

Signature

timeLocal: string;

timeUtc property

Signature

timeUtc: string;

uid property

Signature

uid: string;

uniqueLabels property

Signature

uniqueLabels?: Labels;

LogsDedupDescription

Sat, 04 Apr 2026 12:26:57 +0000

LogsDedupDescription enum

Signature

export declare enum LogsDedupDescription

Import

import { LogsDedupDescription } from '@grafana/data';

Enumeration Members

Member	Value	Description
exact	`"De-duplication of successive lines that are identical, ignoring ISO datetimes."`
none	`"No de-duplication"`
numbers	`"De-duplication of successive lines that are identical when ignoring numbers, e.g., IP addresses, latencies."`
signature	`"De-duplication of successive lines that have identical punctuation and whitespace."`

LogsDedupStrategy

Sat, 04 Apr 2026 12:26:57 +0000

LogsDedupStrategy enum

Signature

export declare enum LogsDedupStrategy

Import

import { LogsDedupStrategy } from '@grafana/data';

Enumeration Members

Member	Value	Description
exact	`"exact"`
none	`"none"`
numbers	`"numbers"`
signature	`"signature"`

LogSearchMatch

Sat, 04 Apr 2026 12:26:57 +0000

LogSearchMatch interface

Signature

export interface LogSearchMatch

Import

import { LogSearchMatch } from '@grafana/data';

Properties

Property	Type	Description
length	`number`
start	`number`
text	`string`

length property

Signature

length: number;

start property

Signature

start: number;

text property

Signature

text: string;

LogsMetaItem

Sat, 04 Apr 2026 12:26:57 +0000

LogsMetaItem interface

Signature

export interface LogsMetaItem

Import

import { LogsMetaItem } from '@grafana/data';

Properties

Property	Type	Description
kind	`LogsMetaKind`
label	`string`
value	`string \| number \| Labels`

kind property

Signature

kind: LogsMetaKind;

label property

Signature

label: string;

value property

Signature

value: string | number | Labels;

LogsMetaKind

Sat, 04 Apr 2026 12:26:57 +0000

LogsMetaKind enum

Signature

export declare enum LogsMetaKind

Import

import { LogsMetaKind } from '@grafana/data';

Enumeration Members

Member	Value	Description
Error	`3`
LabelsMap	`2`
Number	`0`
String	`1`

LogsModel

Sat, 04 Apr 2026 12:26:57 +0000

LogsModel interface

Signature

export interface LogsModel

Import

import { LogsModel } from '@grafana/data';

Properties

Property	Type	Description
hasUniqueLabels	`boolean`
meta	`LogsMetaItem[]`
queries	`DataQuery[]`
rows	`LogRowModel[]`
series	`DataFrame[]`
visibleRange	`AbsoluteTimeRange`

hasUniqueLabels property

Signature

hasUniqueLabels: boolean;

meta property

Signature

meta?: LogsMetaItem[];

queries property

Signature

queries?: DataQuery[];

rows property

Signature

rows: LogRowModel[];

series property

Signature

series?: DataFrame[];

visibleRange property

Signature

visibleRange?: AbsoluteTimeRange;

LogsParser

Sat, 04 Apr 2026 12:26:57 +0000

LogsParser interface

Signature

export interface LogsParser

Import

import { LogsParser } from '@grafana/data';

Properties

Property	Type	Description
buildMatcher	`(label: string) => RegExp`	Value-agnostic matcher for a field label. Used to filter rows, and first capture group contains the value.
getFields	`(line: string) => string[]`	Returns all parsable substrings from a line, used for highlighting
getLabelFromField	`(field: string) => string`	Gets the label name from a parsable substring of a line
getValueFromField	`(field: string) => string`	Gets the label value from a parsable substring of a line
test	`(line: string) => boolean`	Function to verify if this is a valid parser for the given line. The parser accepts the line if it returns true.

buildMatcher property

Value-agnostic matcher for a field label. Used to filter rows, and first capture group contains the value.

Signature

buildMatcher: (label: string) => RegExp;

getFields property

Returns all parsable substrings from a line, used for highlighting

Signature

getFields: (line: string) => string[];

getLabelFromField property

Gets the label name from a parsable substring of a line

Signature

getLabelFromField: (field: string) => string;

getValueFromField property

Gets the label value from a parsable substring of a line

Signature

getValueFromField: (field: string) => string;

test property

Function to verify if this is a valid parser for the given line. The parser accepts the line if it returns true.

Signature

test: (line: string) => boolean;

LogsParsers

Sat, 04 Apr 2026 12:26:57 +0000

LogsParsers variable

Signature

LogsParsers: {
    [name: string]: LogsParser;
}

Import

import { LogsParsers } from '@grafana/data';

LogsSortOrder

Sat, 04 Apr 2026 12:26:57 +0000

LogsSortOrder enum

Signature

export declare enum LogsSortOrder

Import

import { LogsSortOrder } from '@grafana/data';

Enumeration Members

Member	Value	Description
Ascending	`"Ascending"`
Descending	`"Descending"`

makeClassES5Compatible

Sat, 04 Apr 2026 12:26:57 +0000

makeClassES5Compatible() function

makeClassES5Compatible() function

Proxies a ES6 class so that it can be used as a base class for an ES5 class

Signature

export declare function makeClassES5Compatible<T>(ES6Class: T): T;

Import

import { makeClassES5Compatible } from '@grafana/data';

Parameters

Parameter	Type	Description
ES6Class	`T`

Returns:

T

mapInternalLinkToExplore

Sat, 04 Apr 2026 12:26:57 +0000

mapInternalLinkToExplore() function

Signature

export declare function mapInternalLinkToExplore(options: LinkToExploreOptions): LinkModel<Field>;

Import

import { mapInternalLinkToExplore } from '@grafana/data';

Parameters

Parameter	Type	Description
options	`LinkToExploreOptions`

Returns:

LinkModel<Field>

matchAllLabels

Sat, 04 Apr 2026 12:26:57 +0000

matchAllLabels() function

Check that all labels exist in another set of labels

Signature

export declare function matchAllLabels(expect: Labels, against?: Labels): boolean;

Import

import { matchAllLabels } from '@grafana/data';

Parameters

Parameter	Type	Description
expect	`Labels`
against	`Labels`

Returns:

boolean

MatcherConfig

Sat, 04 Apr 2026 12:26:57 +0000

MatcherConfig interface

Signature

export interface MatcherConfig<TOptions = any>

Import

import { MatcherConfig } from '@grafana/data';

Properties

Property	Type	Description
id	`string`
options	`TOptions`

id property

Signature

id: string;

options property

Signature

options?: TOptions;

MatcherID

Sat, 04 Apr 2026 12:26:57 +0000

MatcherID enum

Signature

export declare enum MatcherID

Import

import { MatcherID } from '@grafana/data';

Enumeration Members

Member	Value	Description
allMatch	`"allMatch"`
alwaysMatch	`"alwaysMatch"`
anyMatch	`"anyMatch"`
invertMatch	`"invertMatch"`
neverMatch	`"neverMatch"`

MetadataInspectorProps

Sat, 04 Apr 2026 12:26:57 +0000

MetadataInspectorProps interface

Signature

export interface MetadataInspectorProps<DSType extends DataSourceApi<TQuery, TOptions>, TQuery extends DataQuery = DataQuery, TOptions extends DataSourceJsonData = DataSourceJsonData>

Import

import { MetadataInspectorProps } from '@grafana/data';

Properties

Property	Type	Description
data	`DataFrame[]`
datasource	`DSType`

data property

Signature

data: DataFrame[];

datasource property

Signature

datasource: DSType;

MetricFindValue

Sat, 04 Apr 2026 12:26:57 +0000

MetricFindValue interface

Signature

export interface MetricFindValue

Import

import { MetricFindValue } from '@grafana/data';

Properties

Property	Type	Description
expandable	`boolean`
text	`string`
value	`string \| number`

expandable property

Signature

expandable?: boolean;

text property

Signature

text: string;

value property

Signature

value?: string | number;

MISSING_VALUE

Sat, 04 Apr 2026 12:26:57 +0000

MISSING_VALUE variable

Signature

MISSING_VALUE: any

Import

import { MISSING_VALUE } from '@grafana/data';

msRangeToTimeString

Sat, 04 Apr 2026 12:26:57 +0000

rangeUtil.msRangeToTimeString() function

Signature

export declare function msRangeToTimeString(rangeMs: number): string;

Import

import { rangeUtil } from '@grafana/data';
const { msRangeToTimeString } = rangeUtil;

Parameters

Parameter	Type	Description
rangeMs	`number`

Returns:

string

MutableDataFrame

Sat, 04 Apr 2026 12:26:57 +0000

MutableDataFrame class

Signature

export declare class MutableDataFrame<T = any> extends FunctionalVector<T> implements DataFrame, MutableVector<T>

Import

import { MutableDataFrame } from '@grafana/data';

Constructors

Constructor	Modifiers	Description
constructor(source, creator)		Constructs a new instance of the `MutableDataFrame` class

Properties

Property	Modifiers	Type	Description
fields		`MutableField[]`
length		`number`
meta		`QueryResultMeta`
name		`string`
refId		`string`

Methods

Method	Modifiers	Description
add(value)		Add values from an object to corresponding fields. Similar to appendRow but does not create new fields.
addField(f, startLength)
addFieldFor(value, name)
appendRow(row)		This will add each value to the corresponding column
get(idx)		Get an object with a property for each field in the DataFrame
reverse()		Reverse all values
set(index, value)
setParser(field, parser)
toJSON()		The simplified JSON values used in JSON.stringify()
validate()

constructor(source, creator)

Constructs a new instance of the MutableDataFrame class

Signature

constructor(source?: DataFrame | DataFrameDTO, creator?: MutableVectorCreator);

Parameters

Parameter	Type	Description
source	`DataFrame \| DataFrameDTO`
creator	`MutableVectorCreator`

fields property

Signature

fields: MutableField[];

length property

Signature

get length(): number;

meta property

Signature

meta?: QueryResultMeta;

name property

Signature

name?: string;

refId property

Signature

refId?: string;

add method

Add values from an object to corresponding fields. Similar to appendRow but does not create new fields.

Signature

add(value: T): void;

Parameters

Parameter	Type	Description
value	`T`

Returns:

void

addField method

Signature

addField(f: Field | FieldDTO, startLength?: number): MutableField;

Parameters

Parameter	Type	Description
f	`Field \| FieldDTO`
startLength	`number`

Returns:

MutableField

addFieldFor method

Signature

addFieldFor(value: any, name?: string): MutableField;

Parameters

Parameter	Type	Description
value	`any`
name	`string`

Returns:

MutableField

appendRow method

This will add each value to the corresponding column

Signature

appendRow(row: any[]): void;

Parameters

Parameter	Type	Description
row	`any[]`

Returns:

void

get method

Get an object with a property for each field in the DataFrame

Signature

get(idx: number): T;

Parameters

Parameter	Type	Description
idx	`number`

Returns:

T

reverse method

Reverse all values

Signature

reverse(): void;

Returns:

void

set method

Signature

set(index: number, value: T): void;

Parameters

Parameter	Type	Description
index	`number`
value	`T`

Returns:

void

setParser method

Signature

setParser(field: Field, parser: (v: string) => any): (v: string) => any;

Parameters

Parameter	Type	Description
field	`Field`
parser	`(v: string) => any`

Returns:

(v: string) => any

toJSON method

The simplified JSON values used in JSON.stringify()

Signature

toJSON(): DataFrameDTO;

Returns:

DataFrameDTO

validate method

Signature

validate(): void;

Returns:

void

MutableField

Sat, 04 Apr 2026 12:26:57 +0000

MutableField type

Signature

export declare type MutableField<T = any> = Field<T, MutableVector<T>>;

Import

import { MutableField } from '@grafana/data';

MutableVector

Sat, 04 Apr 2026 12:26:57 +0000

MutableVector interface

Vector with standard manipulation functions

Signature

export interface MutableVector<T = any> extends ReadWriteVector<T>

Import

import { MutableVector } from '@grafana/data';

Properties

Property	Type	Description
add	`(value: T) => void`	Adds the value to the vector
reverse	`() => void`	modifies the vector so it is now the opposite order

add property

Adds the value to the vector

Signature

add: (value: T) => void;

reverse property

modifies the vector so it is now the opposite order

Signature

reverse: () => void;

NavIndex

Sat, 04 Apr 2026 12:26:57 +0000

NavIndex type

Signature

export declare type NavIndex = {
    [s: string]: NavModelItem;
};

Import

import { NavIndex } from '@grafana/data';

NavMenuItemType

Sat, 04 Apr 2026 12:26:57 +0000

NavMenuItemType enum

Signature

export declare enum NavMenuItemType

Import

import { NavMenuItemType } from '@grafana/data';

Enumeration Members

Member	Value	Description
Item	`"item"`
Section	`"section"`

NavModel

Sat, 04 Apr 2026 12:26:57 +0000

NavModel interface

Interface used to describe different kinds of page titles and page navigation. Navmodels are usually generated in the backend and stored in Redux.

Signature

export interface NavModel

Import

import { NavModel } from '@grafana/data';

Properties

Property	Type	Description
breadcrumbs	`NavModelItem[]`	Describes breadcrumbs that are used in places such as data source settings., folder page and plugins page.
main	`NavModelItem`	Main page. that wraps the navigation. Generate the `children` property generate tabs when used with the Page component.
node	`NavModelItem`	This is the current active tab/navigation.

breadcrumbs property

Describes breadcrumbs that are used in places such as data source settings., folder page and plugins page.

Signature

breadcrumbs?: NavModelItem[];

main property

Main page. that wraps the navigation. Generate the children property generate tabs when used with the Page component.

Signature

main: NavModelItem;

node property

This is the current active tab/navigation.

Signature

node: NavModelItem;

NavModelBreadcrumb

Sat, 04 Apr 2026 12:26:57 +0000

NavModelBreadcrumb interface

Signature

export interface NavModelBreadcrumb

Import

import { NavModelBreadcrumb } from '@grafana/data';

Properties

Property	Type	Description
title	`string`
url	`string`

title property

Signature

title: string;

url property

Signature

url?: string;

NavModelItem

Sat, 04 Apr 2026 12:26:57 +0000

NavModelItem interface

Signature

export interface NavModelItem

Import

import { NavModelItem } from '@grafana/data';

Properties

Property	Type	Description
active	`boolean`
breadcrumbs	`NavModelBreadcrumb[]`
children	`NavModelItem[]`
divider	`boolean`
hideFromMenu	`boolean`
hideFromTabs	`boolean`
highlightId	`string`
highlightText	`string`
icon	`string`
id	`string`
img	`string`
menuItemType	`NavMenuItemType`
onClick	`() => void`
parentItem	`NavModelItem`
section	`NavSection`
showOrgSwitcher	`boolean`
subTitle	`string`
tabSuffix	`ComponentType<{` `className?: string;` `}>`
target	`string`
text	`string`
url	`string`

active property

Signature

active?: boolean;

breadcrumbs property

Signature

breadcrumbs?: NavModelBreadcrumb[];

children property

Signature

children?: NavModelItem[];

divider property

Signature

divider?: boolean;

hideFromMenu property

Signature

hideFromMenu?: boolean;

hideFromTabs property

Signature

hideFromTabs?: boolean;

highlightId property

Signature

highlightId?: string;

highlightText property

Signature

highlightText?: string;

icon property

Signature

icon?: string;

id property

Signature

id?: string;

img property

Signature

img?: string;

menuItemType property

Signature

menuItemType?: NavMenuItemType;

onClick property

Signature

onClick?: () => void;

parentItem property

Signature

parentItem?: NavModelItem;

section property

Signature

section?: NavSection;

showOrgSwitcher property

Signature

showOrgSwitcher?: boolean;

subTitle property

Signature

subTitle?: string;

tabSuffix property

Signature

tabSuffix?: ComponentType<{
        className?: string;
    }>;

target property

Signature

target?: string;

text property

Signature

text: string;

url property

Signature

url?: string;

NavSection

Sat, 04 Apr 2026 12:26:57 +0000

NavSection enum

Signature

export declare enum NavSection

Import

import { NavSection } from '@grafana/data';

Enumeration Members

Member	Value	Description
Config	`"config"`
Core	`"core"`
Plugin	`"plugin"`

NodeGraphDataFrameFieldNames

Sat, 04 Apr 2026 12:26:57 +0000

NodeGraphDataFrameFieldNames enum

Signature

export declare enum NodeGraphDataFrameFieldNames

Import

import { NodeGraphDataFrameFieldNames } from '@grafana/data';

Enumeration Members

Member	Value	Description
arc	`"arc__"`
color	`"color"`
detail	`"detail__"`
id	`"id"`
mainStat	`"mainStat"`
secondaryStat	`"secondaryStat"`
source	`"source"`
subTitle	`"subTitle"`
target	`"target"`
title	`"title"`

NullValueMode

Sat, 04 Apr 2026 12:26:57 +0000

NullValueMode enum

Signature

export declare enum NullValueMode

Import

import { NullValueMode } from '@grafana/data';

Enumeration Members

Member	Value	Description
AsZero	`"null as zero"`
Ignore	`"connected"`
Null	`"null"`

NumberFieldConfigSettings

Sat, 04 Apr 2026 12:26:57 +0000

NumberFieldConfigSettings interface

Signature

export interface NumberFieldConfigSettings

Import

import { NumberFieldConfigSettings } from '@grafana/data';

Properties

Property	Type	Description
integer	`boolean`
max	`number`
min	`number`
placeholder	`string`
step	`number`

integer property

Signature

integer?: boolean;

max property

Signature

max?: number;

min property

Signature

min?: number;

placeholder property

Signature

placeholder?: string;

step property

Signature

step?: number;

numberOverrideProcessor

Sat, 04 Apr 2026 12:26:57 +0000

numberOverrideProcessor variable

Signature

numberOverrideProcessor: (value: any, context: FieldOverrideContext, settings?: NumberFieldConfigSettings | undefined) => number | undefined

Import

import { numberOverrideProcessor } from '@grafana/data';

NumericRange

Sat, 04 Apr 2026 12:26:57 +0000

NumericRange interface

Signature

export interface NumericRange

Import

import { NumericRange } from '@grafana/data';

Properties

Property	Type	Description
delta	`number`
max	`number \| null`
min	`number \| null`

delta property

Signature

delta: number;

max property

Signature

max?: number | null;

min property

Signature

min?: number | null;

objRemoveUndefined

Sat, 04 Apr 2026 12:26:57 +0000

objRemoveUndefined variable

Signature

objRemoveUndefined: (obj: any) => any

Import

import { objRemoveUndefined } from '@grafana/data';

onUpdateDatasourceJsonDataOption

Sat, 04 Apr 2026 12:26:57 +0000

onUpdateDatasourceJsonDataOption variable

Signature

onUpdateDatasourceJsonDataOption: <J, S, K extends keyof J>(props: DataSourcePluginOptionsEditorProps<J, S>, key: K) => (event: React.SyntheticEvent<HTMLInputElement | HTMLSelectElement>) => void

Import

import { onUpdateDatasourceJsonDataOption } from '@grafana/data';

onUpdateDatasourceJsonDataOptionChecked

Sat, 04 Apr 2026 12:26:57 +0000

onUpdateDatasourceJsonDataOptionChecked variable

Signature

onUpdateDatasourceJsonDataOptionChecked: <J, S, K extends keyof J>(props: DataSourcePluginOptionsEditorProps<J, S>, key: K) => (event: React.SyntheticEvent<HTMLInputElement>) => void

Import

import { onUpdateDatasourceJsonDataOptionChecked } from '@grafana/data';

onUpdateDatasourceJsonDataOptionSelect

Sat, 04 Apr 2026 12:26:57 +0000

onUpdateDatasourceJsonDataOptionSelect variable

Signature

onUpdateDatasourceJsonDataOptionSelect: <J, S, K extends keyof J>(props: DataSourcePluginOptionsEditorProps<J, S>, key: K) => (selected: SelectableValue) => void

Import

import { onUpdateDatasourceJsonDataOptionSelect } from '@grafana/data';

onUpdateDatasourceOption

Sat, 04 Apr 2026 12:26:57 +0000

onUpdateDatasourceOption variable

Signature

onUpdateDatasourceOption: (props: DataSourcePluginOptionsEditorProps, key: keyof DataSourceSettings) => (event: React.SyntheticEvent<HTMLInputElement | HTMLSelectElement>) => void

Import

import { onUpdateDatasourceOption } from '@grafana/data';

onUpdateDatasourceResetOption

Sat, 04 Apr 2026 12:26:57 +0000

onUpdateDatasourceResetOption variable

Signature

onUpdateDatasourceResetOption: (props: DataSourcePluginOptionsEditorProps, key: string) => (event: React.MouseEvent<HTMLButtonElement, MouseEvent>) => void

Import

import { onUpdateDatasourceResetOption } from '@grafana/data';

onUpdateDatasourceSecureJsonDataOption

Sat, 04 Apr 2026 12:26:57 +0000

onUpdateDatasourceSecureJsonDataOption variable

Signature

onUpdateDatasourceSecureJsonDataOption: <J, S extends {} = KeyValue<any>>(props: DataSourcePluginOptionsEditorProps<J, S>, key: string) => (event: React.SyntheticEvent<HTMLInputElement | HTMLSelectElement>) => void

Import

import { onUpdateDatasourceSecureJsonDataOption } from '@grafana/data';

onUpdateDatasourceSecureJsonDataOptionSelect

Sat, 04 Apr 2026 12:26:57 +0000

onUpdateDatasourceSecureJsonDataOptionSelect variable

Signature

onUpdateDatasourceSecureJsonDataOptionSelect: <J, S extends {} = KeyValue<any>>(props: DataSourcePluginOptionsEditorProps<J, S>, key: string) => (selected: SelectableValue) => void

Import

import { onUpdateDatasourceSecureJsonDataOptionSelect } from '@grafana/data';

OrgRole

Sat, 04 Apr 2026 12:26:57 +0000

OrgRole enum

Signature

export declare enum OrgRole

Import

import { OrgRole } from '@grafana/data';

Enumeration Members

Member	Value	Description
Admin	`"Admin"`
Editor	`"Editor"`
Viewer	`"Viewer"`

outerJoinDataFrames

Sat, 04 Apr 2026 12:26:57 +0000

outerJoinDataFrames() function

This will return a single frame joined by the first matching field. When a join field is not specified, the default will use the first time field

Signature

export declare function outerJoinDataFrames(options: JoinOptions): DataFrame | undefined;

Import

import { outerJoinDataFrames } from '@grafana/data';

Parameters

Parameter	Type	Description
options	`JoinOptions`

Returns:

DataFrame | undefined

PanelData

Sat, 04 Apr 2026 12:26:57 +0000

PanelData interface

Signature

export interface PanelData

Import

import { PanelData } from '@grafana/data';

Properties

Property	Type	Description
annotations	`DataFrame[]`	A list of annotation items
error	`DataQueryError`	Any query errors
request	`DataQueryRequest`	Request contains the queries and properties sent to the datasource
series	`DataFrame[]`	Contains data frames with field overrides applied
state	`LoadingState`	State of the data (loading, done, error, streaming)
structureRev	`number`	This is a key that will change when the DataFrame[] structure changes. The revision is a useful way to know if only data has changed or data+structure
timeRange	`TimeRange`	Contains the range from the request or a shifted time range if a request uses relative time
timings	`DataQueryTimings`	Timing measurements

annotations property

A list of annotation items

Signature

annotations?: DataFrame[];

error property

Any query errors

Signature

error?: DataQueryError;

request property

Request contains the queries and properties sent to the datasource

Signature

request?: DataQueryRequest;

series property

Contains data frames with field overrides applied

Signature

series: DataFrame[];

state property

State of the data (loading, done, error, streaming)

Signature

state: LoadingState;

structureRev property

This is a key that will change when the DataFrame[] structure changes. The revision is a useful way to know if only data has changed or data+structure

Signature

structureRev?: number;

timeRange property

Contains the range from the request or a shifted time range if a request uses relative time

Signature

timeRange: TimeRange;

timings property

Timing measurements

Signature

timings?: DataQueryTimings;

PanelEditorProps

Sat, 04 Apr 2026 12:26:57 +0000

PanelEditorProps interface

Signature

export interface PanelEditorProps<T = any>

Import

import { PanelEditorProps } from '@grafana/data';

Properties

Property	Type	Description
data	`PanelData`	Result set of panel queries
onOptionsChange	`(options: T, callback?: () => void) => void`	Panel options change handler
options	`T`	Panel options

data property

Result set of panel queries

Signature

data?: PanelData;

onOptionsChange property

Panel options change handler

Signature

onOptionsChange: (options: T, callback?: () => void) => void;

options property

Panel options

Signature

options: T;

PanelEvents

Sat, 04 Apr 2026 12:26:57 +0000

PanelEvents variable

Signature

PanelEvents: {
    refresh: import("../events").AppEvent<undefined>;
    componentDidMount: import("../events").AppEvent<undefined>;
    dataReceived: import("../events").AppEvent<any[]>;
    dataError: import("../events").AppEvent<DataQueryError>;
    dataFramesReceived: import("../events").AppEvent<DataFrame[]>;
    dataSnapshotLoad: import("../events").AppEvent<any[]>;
    editModeInitialized: import("../events").AppEvent<undefined>;
    initPanelActions: import("../events").AppEvent<AngularPanelMenuItem[]>;
    initialized: import("../events").AppEvent<undefined>;
    panelTeardown: import("../events").AppEvent<undefined>;
    render: import("../events").AppEvent<any>;
}

Import

import { PanelEvents } from '@grafana/data';

PanelMigrationHandler

Sat, 04 Apr 2026 12:26:57 +0000

PanelMigrationHandler type

Called when a panel is first loaded with current panel model

Signature

export declare type PanelMigrationHandler<TOptions = any> = (panel: PanelModel<TOptions>) => Partial<TOptions>;

Import

import { PanelMigrationHandler } from '@grafana/data';

PanelModel

Sat, 04 Apr 2026 12:26:57 +0000

PanelModel interface

Signature

export interface PanelModel<TOptions = any, TCustomFieldConfig = any>

Import

import { PanelModel } from '@grafana/data';

Properties

Property	Type	Description
alert	`any`	alerting v1 object
datasource	`DataSourceRef \| null`	The datasource used in all targets
description	`string`	Description
fieldConfig	`FieldConfigSource<TCustomFieldConfig>`	Field options configuration
id	`number`	ID of the panel within the current dashboard
options	`TOptions`	Panel options
pluginVersion	`string`	Version of the panel plugin
targets	`DataQuery[]`	The queries in a panel
title	`string`	Panel title

alert property

alerting v1 object

Signature

alert?: any;

datasource property

The datasource used in all targets

Signature

datasource?: DataSourceRef | null;

description property

Description

Signature

description?: string;

fieldConfig property

Field options configuration

Signature

fieldConfig: FieldConfigSource<TCustomFieldConfig>;

id property

ID of the panel within the current dashboard

Signature

id: number;

options property

Panel options

Signature

options: TOptions;

pluginVersion property

Version of the panel plugin

Signature

pluginVersion?: string;

targets property

The queries in a panel

Signature

targets?: DataQuery[];

title property

Panel title

Signature

title?: string;

PanelOptionEditorsRegistry

Sat, 04 Apr 2026 12:26:57 +0000

PanelOptionEditorsRegistry type

Signature

export declare type PanelOptionEditorsRegistry = Registry<PanelOptionsEditorItem>;

Import

import { PanelOptionEditorsRegistry } from '@grafana/data';

PanelOptionsEditorBuilder

Sat, 04 Apr 2026 12:26:57 +0000

PanelOptionsEditorBuilder class

Fluent API for declarative creation of panel options

Signature

export declare class PanelOptionsEditorBuilder<TOptions> extends OptionsUIRegistryBuilder<TOptions, StandardEditorProps, PanelOptionsEditorItem<TOptions>>

Import

import { PanelOptionsEditorBuilder } from '@grafana/data';

Methods

Method	Modifiers	Description
addBooleanSwitch(config)
addColorPicker(config)
addDashboardPicker(config)
addFieldNamePicker(config)
addMultiSelect(config)
addNestedOptions(opts)
addNumberInput(config)
addRadio(config)
addSelect(config)
addSliderInput(config)
addStringArray(config)
addTextInput(config)
addTimeZonePicker(config)
addUnitPicker(config)

addBooleanSwitch method

Signature

addBooleanSwitch<TSettings = any>(config: PanelOptionsEditorConfig<TOptions, TSettings, boolean>): this;

Parameters

Parameter	Type	Description
config	`PanelOptionsEditorConfig<TOptions, TSettings, boolean>`

Returns:

this

addColorPicker method

Signature

addColorPicker<TSettings = any>(config: PanelOptionsEditorConfig<TOptions, TSettings, string>): this;

Parameters

Parameter	Type	Description
config	`PanelOptionsEditorConfig<TOptions, TSettings, string>`

Returns:

this

addDashboardPicker method

Signature

addDashboardPicker<TSettings = any>(config: PanelOptionsEditorConfig<TOptions, TSettings & FieldNamePickerConfigSettings, string>): this;

Parameters

Parameter	Type	Description
config	`PanelOptionsEditorConfig<TOptions, TSettings & FieldNamePickerConfigSettings, string>`

Returns:

this

addFieldNamePicker method

Signature

addFieldNamePicker<TSettings = any>(config: PanelOptionsEditorConfig<TOptions, TSettings & FieldNamePickerConfigSettings, string>): this;

Parameters

Parameter	Type	Description
config	`PanelOptionsEditorConfig<TOptions, TSettings & FieldNamePickerConfigSettings, string>`

Returns:

this

addMultiSelect method

Signature

addMultiSelect<TOption, TSettings extends SelectFieldConfigSettings<TOption>>(config: PanelOptionsEditorConfig<TOptions, TSettings, TOption>): this;

Parameters

Parameter	Type	Description
config	`PanelOptionsEditorConfig<TOptions, TSettings, TOption>`

Returns:

this

addNestedOptions method

Signature

addNestedOptions<Sub>(opts: NestedPanelOptions<Sub>): this;

Parameters

Parameter	Type	Description
opts	`NestedPanelOptions<Sub>`

Returns:

this

addNumberInput method

Signature

addNumberInput<TSettings>(config: PanelOptionsEditorConfig<TOptions, TSettings & NumberFieldConfigSettings, number>): this;

Parameters

Parameter	Type	Description
config	`PanelOptionsEditorConfig<TOptions, TSettings & NumberFieldConfigSettings, number>`

Returns:

this

addRadio method

Signature

addRadio<TOption, TSettings extends SelectFieldConfigSettings<TOption>>(config: PanelOptionsEditorConfig<TOptions, TSettings, TOption>): this;

Parameters

Parameter	Type	Description
config	`PanelOptionsEditorConfig<TOptions, TSettings, TOption>`

Returns:

this

addSelect method

Signature

addSelect<TOption, TSettings extends SelectFieldConfigSettings<TOption>>(config: PanelOptionsEditorConfig<TOptions, TSettings, TOption>): this;

Parameters

Parameter	Type	Description
config	`PanelOptionsEditorConfig<TOptions, TSettings, TOption>`

Returns:

this

addSliderInput method

Signature

addSliderInput<TSettings>(config: PanelOptionsEditorConfig<TOptions, TSettings & SliderFieldConfigSettings, number>): this;

Parameters

Parameter	Type	Description
config	`PanelOptionsEditorConfig<TOptions, TSettings & SliderFieldConfigSettings, number>`

Returns:

this

addStringArray method

Signature

addStringArray<TSettings>(config: PanelOptionsEditorConfig<TOptions, TSettings & StringFieldConfigSettings, string[]>): this;

Parameters

Parameter	Type	Description
config	`PanelOptionsEditorConfig<TOptions, TSettings & StringFieldConfigSettings, string[]>`

Returns:

this

addTextInput method

Signature

addTextInput<TSettings>(config: PanelOptionsEditorConfig<TOptions, TSettings & StringFieldConfigSettings, string>): this;

Parameters

Parameter	Type	Description
config	`PanelOptionsEditorConfig<TOptions, TSettings & StringFieldConfigSettings, string>`

Returns:

this

addTimeZonePicker method

Signature

addTimeZonePicker<TSettings = any>(config: PanelOptionsEditorConfig<TOptions, TSettings, string>): this;

Parameters

Parameter	Type	Description
config	`PanelOptionsEditorConfig<TOptions, TSettings, string>`

Returns:

this

addUnitPicker method

Signature

addUnitPicker<TSettings = any>(config: PanelOptionsEditorConfig<TOptions, TSettings & UnitFieldConfigSettings, string>): this;

Parameters

Parameter	Type	Description
config	`PanelOptionsEditorConfig<TOptions, TSettings & UnitFieldConfigSettings, string>`

Returns:

this

PanelOptionsEditorConfig

Sat, 04 Apr 2026 12:26:57 +0000

PanelOptionsEditorConfig interface

Signature

export interface PanelOptionsEditorConfig<TOptions, TSettings = any, TValue = any> extends OptionEditorConfig<TOptions, TSettings, TValue>

Import

import { PanelOptionsEditorConfig } from '@grafana/data';

PanelOptionsEditorItem

Sat, 04 Apr 2026 12:26:57 +0000

PanelOptionsEditorItem interface

Signature

export interface PanelOptionsEditorItem<TOptions = any, TValue = any, TSettings = any> extends OptionsEditorItem<TOptions, TSettings, PanelOptionsEditorProps<TValue>, TValue>

Import

import { PanelOptionsEditorItem } from '@grafana/data';

PanelOptionsEditorProps

Sat, 04 Apr 2026 12:26:57 +0000

PanelOptionsEditorProps interface

Signature

export interface PanelOptionsEditorProps<TValue> extends StandardEditorProps<TValue>

Import

import { PanelOptionsEditorProps } from '@grafana/data';

PanelPlugin

Sat, 04 Apr 2026 12:26:57 +0000

PanelPlugin class

Signature

export declare class PanelPlugin<TOptions = any, TFieldConfigOptions extends object = any> extends GrafanaPlugin<PanelPluginMeta>

Import

import { PanelPlugin } from '@grafana/data';

Constructors

Constructor	Modifiers	Description
constructor(panel)		Constructs a new instance of the `PanelPlugin` class

Properties

Property	Type	Description
angularPanelCtrl	`any`	Legacy angular ctrl. If this exists it will be used instead of the panel
dataSupport	`PanelPluginDataSupport`
defaults	`{}`
editor	`ComponentClass<PanelEditorProps<TOptions>>`
fieldConfigDefaults	`FieldConfigSource<TFieldConfigOptions>`
fieldConfigRegistry	`FieldConfigOptionsRegistry`
noPadding	`boolean`
onPanelMigration	`PanelMigrationHandler<TOptions>`
onPanelTypeChanged	`PanelTypeChangedHandler<TOptions>`
panel	`ComponentType<PanelProps<TOptions>> \| null`

Methods

Method	Modifiers	Description
setDataSupport(support)		Tells Grafana if the plugin should subscribe to annotation and alertState results.
setDefaults(defaults)
setEditor(editor)
setMigrationHandler(handler)		This function is called before the panel first loads if the current version is different than the version that was saved.This is a good place to support any changes to the options model
setNoPadding()
setPanelChangeHandler(handler)		This function is called when the visualization was changed. This passes in the panel model for previous visualisation options inspection and panel model updates.This is useful for supporting PanelModel API updates when changing between Angular and React panels.
setPanelOptions(builder)		Enables panel options editor creation
useFieldConfig(config)		Allows specifying which standard field config options panel should use and defining default values

constructor(panel)

Constructs a new instance of the PanelPlugin class

Signature

constructor(panel: ComponentType<PanelProps<TOptions>> | null);

Parameters

Parameter	Type	Description
panel	`ComponentType<PanelProps<TOptions>> \| null`

angularPanelCtrl property

Legacy angular ctrl. If this exists it will be used instead of the panel

Signature

angularPanelCtrl?: any;

dataSupport property

Signature

dataSupport: PanelPluginDataSupport;

defaults property

Signature

get defaults(): {};

editor property

Signature

editor?: ComponentClass<PanelEditorProps<TOptions>>;

fieldConfigDefaults property

Signature

get fieldConfigDefaults(): FieldConfigSource<TFieldConfigOptions>;

fieldConfigRegistry property

Signature

get fieldConfigRegistry(): FieldConfigOptionsRegistry;

noPadding property

Signature

noPadding?: boolean;

onPanelMigration property

Signature

onPanelMigration?: PanelMigrationHandler<TOptions>;

onPanelTypeChanged property

Signature

onPanelTypeChanged?: PanelTypeChangedHandler<TOptions>;

panel property

Signature

panel: ComponentType<PanelProps<TOptions>> | null;

setDataSupport method

Tells Grafana if the plugin should subscribe to annotation and alertState results.

Signature

setDataSupport(support: Partial<PanelPluginDataSupport>): this;

Parameters

Parameter	Type	Description
support	`Partial<PanelPluginDataSupport>`

Returns:

this

Example


import { ShapePanel } from './ShapePanel';

interface ShapePanelOptions {}

export const plugin = new PanelPlugin<ShapePanelOptions>(ShapePanel)
    .useFieldConfig({})
    ...
    ...
    .setDataSupport({
      annotations: true,
      alertStates: true,
    });

setDefaults method

Signature

setDefaults(defaults: TOptions): this;

Parameters

Parameter	Type	Description
defaults	`TOptions`

Returns:

this

setEditor method

Signature

setEditor(editor: ComponentClass<PanelEditorProps<TOptions>>): this;

Parameters

Parameter	Type	Description
editor	`ComponentClass<PanelEditorProps<TOptions>>`

Returns:

this

setMigrationHandler method

This function is called before the panel first loads if the current version is different than the version that was saved.

This is a good place to support any changes to the options model

Signature

setMigrationHandler(handler: PanelMigrationHandler<TOptions>): this;

Parameters

Parameter	Type	Description
handler	`PanelMigrationHandler<TOptions>`

Returns:

this

setNoPadding method

Signature

setNoPadding(): this;

Returns:

this

setPanelChangeHandler method

This function is called when the visualization was changed. This passes in the panel model for previous visualisation options inspection and panel model updates.

This is useful for supporting PanelModel API updates when changing between Angular and React panels.

Signature

setPanelChangeHandler(handler: PanelTypeChangedHandler): this;

Parameters

Parameter	Type	Description
handler	`PanelTypeChangedHandler`

Returns:

this

setPanelOptions method

Enables panel options editor creation

Signature

setPanelOptions(builder: PanelOptionsSupplier<TOptions>): this;

Parameters

Parameter	Type	Description
builder	`PanelOptionsSupplier<TOptions>`

Returns:

this

Example


import { ShapePanel } from './ShapePanel';

interface ShapePanelOptions {}

export const plugin = new PanelPlugin<ShapePanelOptions>(ShapePanel)
  .setPanelOptions(builder => {
    builder
      .addSelect({
        id: 'shape',
        name: 'Shape',
        description: 'Select shape to render'
        settings: {
          options: [
            {value: 'circle', label: 'Circle' },
            {value: 'square', label: 'Square },
            {value: 'triangle', label: 'Triangle }
           ]
        },
      })
  })

useFieldConfig method

Allows specifying which standard field config options panel should use and defining default values

Signature

useFieldConfig(config?: SetFieldConfigOptionsArgs<TFieldConfigOptions>): this;

Parameters

Parameter	Type	Description
config	`SetFieldConfigOptionsArgs<TFieldConfigOptions>`

Returns:

this

Example


import { ShapePanel } from './ShapePanel';

interface ShapePanelOptions {}

// when plugin should use all standard options
export const plugin = new PanelPlugin<ShapePanelOptions>(ShapePanel)
 .useFieldConfig();

// when plugin should only display specific standard options
// note, that options will be displayed in the order they are provided
export const plugin = new PanelPlugin<ShapePanelOptions>(ShapePanel)
 .useFieldConfig({
   standardOptions: [FieldConfigProperty.Min, FieldConfigProperty.Max]
  });

// when standard option's default value needs to be provided
export const plugin = new PanelPlugin<ShapePanelOptions>(ShapePanel)
 .useFieldConfig({
   standardOptions: [FieldConfigProperty.Min, FieldConfigProperty.Max],
   standardOptionsDefaults: {
     [FieldConfigProperty.Min]: 20,
     [FieldConfigProperty.Max]: 100
   }
 });

// when custom field config options needs to be provided
export const plugin = new PanelPlugin<ShapePanelOptions>(ShapePanel)
 .useFieldConfig({
   useCustomConfig: builder => {
     builder
      .addNumberInput({
        id: 'shapeBorderWidth',
        name: 'Border width',
        description: 'Border width of the shape',
        settings: {
          min: 1,
          max: 5,
        },
      })
      .addSelect({
        id: 'displayMode',
        name: 'Display mode',
        description: 'How the shape shout be rendered'
        settings: {
        options: [{value: 'fill', label: 'Fill' }, {value: 'transparent', label: 'Transparent }]
      },
    })
  },
 });

PanelPluginDataSupport

Sat, 04 Apr 2026 12:26:57 +0000

PanelPluginDataSupport interface

Signature

export interface PanelPluginDataSupport

Import

import { PanelPluginDataSupport } from '@grafana/data';

Properties

Property	Type	Description
alertStates	`boolean`
annotations	`boolean`

alertStates property

Signature

alertStates: boolean;

annotations property

Signature

annotations: boolean;

PanelPluginMeta

Sat, 04 Apr 2026 12:26:57 +0000

PanelPluginMeta interface

Signature

export interface PanelPluginMeta extends PluginMeta

Import

import { PanelPluginMeta } from '@grafana/data';

Properties

Property	Type	Description
hideFromList	`boolean`	Indicates that panel should not be available in visualisation picker
skipDataQuery	`boolean`	Indicates that panel does not issue queries
sort	`number`	Sort order

hideFromList property

Indicates that panel should not be available in visualisation picker

Signature

hideFromList?: boolean;

skipDataQuery property

Indicates that panel does not issue queries

Signature

skipDataQuery?: boolean;

sort property

Sort order

Signature

sort: number;

PanelProps

Sat, 04 Apr 2026 12:26:57 +0000

PanelProps interface

Signature

export interface PanelProps<T = any>

Import

import { PanelProps } from '@grafana/data';

Properties

Property	Type	Description
data	`PanelData`	Result set of panel queries
eventBus	`EventBus`	EventBus
fieldConfig	`FieldConfigSource`	Field options configuration
height	`number`	Current height of the panel
id	`number`	ID of the panel within the current dashboard
onChangeTimeRange	`(timeRange: AbsoluteTimeRange) => void`	Time range change handler
onFieldConfigChange	`(config: FieldConfigSource) => void`	Field config change handler
onOptionsChange	`(options: T) => void`	Panel options change handler
options	`T`	Panel options
replaceVariables	`InterpolateFunction`	Template variables interpolation function
timeRange	`TimeRange`	Time range of the current dashboard
timeZone	`TimeZone`	Time zone of the current dashboard
title	`string`	Panel title
transparent	`boolean`	Indicates whether or not panel should be rendered transparent
width	`number`	Current width of the panel

data property

Result set of panel queries

Signature

data: PanelData;

eventBus property

EventBus

Signature

eventBus: EventBus;

fieldConfig property

Field options configuration

Signature

fieldConfig: FieldConfigSource;

height property

Current height of the panel

Signature

height: number;

id property

ID of the panel within the current dashboard

Signature

id: number;

onChangeTimeRange property

Time range change handler

Signature

onChangeTimeRange: (timeRange: AbsoluteTimeRange) => void;

onFieldConfigChange property

Field config change handler

Signature

onFieldConfigChange: (config: FieldConfigSource) => void;

onOptionsChange property

Panel options change handler

Signature

onOptionsChange: (options: T) => void;

options property

Panel options

Signature

options: T;

replaceVariables property

Template variables interpolation function

Signature

replaceVariables: InterpolateFunction;

timeRange property

Time range of the current dashboard

Signature

timeRange: TimeRange;

timeZone property

Time zone of the current dashboard

Signature

timeZone: TimeZone;

title property

Panel title

Signature

title: string;

transparent property

Indicates whether or not panel should be rendered transparent

Signature

transparent: boolean;

width property

Current width of the panel

Signature

width: number;

PanelTypeChangedHandler

Sat, 04 Apr 2026 12:26:57 +0000

PanelTypeChangedHandler type

Called before a panel is initialized. Allows panel inspection for any updates before changing the panel type.

Signature

export declare type PanelTypeChangedHandler<TOptions = any> = (panel: PanelModel<TOptions>, prevPluginId: string, prevOptions: Record<string, any>, prevFieldConfig: FieldConfigSource) => Partial<TOptions>;

Import

import { PanelTypeChangedHandler } from '@grafana/data';

parse

Sat, 04 Apr 2026 12:26:57 +0000

dateMath.parse() function

Parses different types input to a moment instance. There is a specific formatting language that can be used if text arg is string. See unit tests for examples.

Signature

export declare function parse(text?: string | DateTime | Date | null, roundUp?: boolean, timezone?: TimeZone, fiscalYearStartMonth?: number): DateTime | undefined;

Import

import { dateMath } from '@grafana/data';
const { parse } = dateMath;

Parameters

Parameter	Type	Description
text	`string \| DateTime \| Date \| null`
roundUp	`boolean`	See parseDateMath function.
timezone	`TimeZone`	Only string ‘utc’ is acceptable here, for anything else, local timezone is used.
fiscalYearStartMonth	`number`

Returns:

DateTime | undefined

parseDateMath

Sat, 04 Apr 2026 12:26:57 +0000

dateMath.parseDateMath() function

Parses math part of the time string and shifts supplied time according to that math. See unit tests for examples.

Signature

export declare function parseDateMath(mathString: string, time: any, roundUp?: boolean, fiscalYearStartMonth?: number): DateTime | undefined;

Import

import { dateMath } from '@grafana/data';
const { parseDateMath } = dateMath;

Parameters

Parameter	Type	Description
mathString	`string`
time	`any`
roundUp	`boolean`	If true it will round the time to endOf time unit, otherwise to startOf time unit.
fiscalYearStartMonth	`number`

Returns:

DateTime | undefined

parseDuration

Sat, 04 Apr 2026 12:26:57 +0000

parseDuration() function

parseDuration parses duration string into datefns Duration object

Signature

export declare function parseDuration(durationString: string): Duration;

Import

import { parseDuration } from '@grafana/data';

Parameters

Parameter	Type	Description
durationString	`string`	string to convert. For example ‘2m’, ‘5h 20s’

Returns:

Duration

parseFlags

Sat, 04 Apr 2026 12:26:57 +0000

parseFlags() function

Converts any mode modifiers in the text to the Javascript equivalent flag

Signature

export declare function parseFlags(text: string): {
    cleaned: string;
    flags: string;
};

Import

import { parseFlags } from '@grafana/data';

Parameters

Parameter	Type	Description
text	`string`

Returns:

{ cleaned: string; flags: string; }

parseLabels

Sat, 04 Apr 2026 12:26:57 +0000

parseLabels() function

Returns a map of label keys to value from an input selector string.

Example: parseLabels('{job="foo", instance="bar"}) // {job: "foo", instance: "bar"}

Signature

export declare function parseLabels(labels: string): Labels;

Import

import { parseLabels } from '@grafana/data';

Parameters

Parameter	Type	Description
labels	`string`

Returns:

Labels

PluginBuildInfo

Sat, 04 Apr 2026 12:26:57 +0000

PluginBuildInfo interface

Signature

export interface PluginBuildInfo

Import

import { PluginBuildInfo } from '@grafana/data';

Properties

Property	Type	Description
branch	`string`
hash	`string`
number	`number`
pr	`number`
repo	`string`
time	`number`

branch property

Signature

branch?: string;

hash property

Signature

hash?: string;

number property

Signature

number?: number;

pr property

Signature

pr?: number;

repo property

Signature

repo?: string;

time property

Signature

time?: number;

PluginConfigPage

Sat, 04 Apr 2026 12:26:57 +0000

PluginConfigPage interface

Signature

export interface PluginConfigPage<T extends PluginMeta>

Import

import { PluginConfigPage } from '@grafana/data';

Properties

Property	Type	Description
body	`ComponentType<PluginConfigPageProps<T>>`
icon	`string`
id	`string`
title	`string`

body property

Signature

body: ComponentType<PluginConfigPageProps<T>>;

icon property

Signature

icon?: string;

id property

Signature

id: string;

title property

Signature

title: string;

PluginConfigPageProps

Sat, 04 Apr 2026 12:26:57 +0000

PluginConfigPageProps interface

Signature

export interface PluginConfigPageProps<T extends PluginMeta>

Import

import { PluginConfigPageProps } from '@grafana/data';

Properties

Property	Type	Description
plugin	`GrafanaPlugin<T>`
query	`KeyValue`

plugin property

Signature

plugin: GrafanaPlugin<T>;

query property

Signature

query: KeyValue;

PluginDependencies

Sat, 04 Apr 2026 12:26:57 +0000

PluginDependencies interface

Signature

export interface PluginDependencies

Import

import { PluginDependencies } from '@grafana/data';

Properties

Property	Type	Description
grafanaDependency	`string`
grafanaVersion	`string`
plugins	`PluginDependencyInfo[]`

grafanaDependency property

Signature

grafanaDependency?: string;

grafanaVersion property

Signature

grafanaVersion: string;

plugins property

Signature

plugins: PluginDependencyInfo[];

PluginError

Sat, 04 Apr 2026 12:26:57 +0000

PluginError interface

Describes error returned from Grafana plugins API call

Signature

export interface PluginError

Import

import { PluginError } from '@grafana/data';

Properties

Property	Type	Description
errorCode	`PluginErrorCode`
pluginId	`string`

errorCode property

Signature

errorCode: PluginErrorCode;

pluginId property

Signature

pluginId: string;

PluginErrorCode

Sat, 04 Apr 2026 12:26:57 +0000

PluginErrorCode enum

Describes error code returned from Grafana plugins API call

Signature

export declare enum PluginErrorCode

Import

import { PluginErrorCode } from '@grafana/data';

Enumeration Members

Member	Value	Description
invalidSignature	`"signatureInvalid"`
missingSignature	`"signatureMissing"`
modifiedSignature	`"signatureModified"`

PluginInclude

Sat, 04 Apr 2026 12:26:57 +0000

PluginInclude interface

Signature

export interface PluginInclude

Import

import { PluginInclude } from '@grafana/data';

Properties

Property	Type	Description
addToNav	`boolean`
component	`string`
icon	`string`
name	`string`
path	`string`
role	`string`
type	`PluginIncludeType`

addToNav property

Signature

addToNav?: boolean;

component property

Signature

component?: string;

icon property

Signature

icon?: string;

name property

Signature

name: string;

path property

Signature

path?: string;

role property

Signature

role?: string;

type property

Signature

type: PluginIncludeType;

PluginIncludeType

Sat, 04 Apr 2026 12:26:57 +0000

PluginIncludeType enum

Signature

export declare enum PluginIncludeType

Import

import { PluginIncludeType } from '@grafana/data';

Enumeration Members

Member	Value	Description
dashboard	`"dashboard"`
datasource	`"datasource"`
page	`"page"`
panel	`"panel"`

PluginMeta

Sat, 04 Apr 2026 12:26:57 +0000

PluginMeta interface

Signature

export interface PluginMeta<T extends KeyValue = {}>

Import

import { PluginMeta } from '@grafana/data';

Properties

Property	Type	Description
baseUrl	`string`
defaultNavUrl	`string`
dependencies	`PluginDependencies`
enabled	`boolean`
enterprise	`boolean`
hasUpdate	`boolean`
id	`string`
includes	`PluginInclude[]`
info	`PluginMetaInfo`
jsonData	`T`
latestVersion	`string`
live	`boolean`
module	`string`
name	`string`
pinned	`boolean`
secureJsonData	`KeyValue`
signature	`PluginSignatureStatus`
signatureOrg	`string`
signatureType	`PluginSignatureType`
state	`PluginState`
type	`PluginType`

baseUrl property

Signature

baseUrl: string;

defaultNavUrl property

Signature

defaultNavUrl?: string;

dependencies property

Signature

dependencies?: PluginDependencies;

enabled property

Signature

enabled?: boolean;

enterprise property

Signature

enterprise?: boolean;

hasUpdate property

Signature

hasUpdate?: boolean;

id property

Signature

id: string;

includes property

Signature

includes?: PluginInclude[];

info property

Signature

info: PluginMetaInfo;

jsonData property

Signature

jsonData?: T;

latestVersion property

Signature

latestVersion?: string;

live property

Signature

live?: boolean;

module property

Signature

module: string;

name property

Signature

name: string;

pinned property

Signature

pinned?: boolean;

secureJsonData property

Signature

secureJsonData?: KeyValue;

signature property

Signature

signature?: PluginSignatureStatus;

signatureOrg property

Signature

signatureOrg?: string;

signatureType property

Signature

signatureType?: PluginSignatureType;

state property

Signature

state?: PluginState;

type property

Signature

type: PluginType;

PluginMetaInfo

Sat, 04 Apr 2026 12:26:57 +0000

PluginMetaInfo interface

Signature

export interface PluginMetaInfo

Import

import { PluginMetaInfo } from '@grafana/data';

Properties

Property	Type	Description
author	`{` `name: string;` `url?: string;` `}`
build	`PluginBuildInfo`
description	`string`
links	`PluginMetaInfoLink[]`
logos	`{` `large: string;` `small: string;` `}`
screenshots	`ScreenshotInfo[]`
updated	`string`
version	`string`

author property

Signature

author: {
        name: string;
        url?: string;
    };

build property

Signature

build?: PluginBuildInfo;

description property

Signature

description: string;

links property

Signature

links: PluginMetaInfoLink[];

logos property

Signature

logos: {
        large: string;
        small: string;
    };

screenshots property

Signature

screenshots: ScreenshotInfo[];

updated property

Signature

updated: string;

version property

Signature

version: string;

PluginSignatureStatus

Sat, 04 Apr 2026 12:26:57 +0000

PluginSignatureStatus enum

Describes status of plugin signature

Signature

export declare enum PluginSignatureStatus

Import

import { PluginSignatureStatus } from '@grafana/data';

Enumeration Members

Member	Value	Description
internal	`"internal"`
invalid	`"invalid"`
missing	`"missing"`
modified	`"modified"`
valid	`"valid"`

PluginSignatureType

Sat, 04 Apr 2026 12:26:57 +0000

PluginSignatureType enum

Describes level of plugin signature level

Signature

export declare enum PluginSignatureType

Import

import { PluginSignatureType } from '@grafana/data';

Enumeration Members

Member	Value	Description
commercial	`"commercial"`
community	`"community"`
core	`"core"`
grafana	`"grafana"`
private	`"private"`

PluginState

Sat, 04 Apr 2026 12:26:57 +0000

PluginState enum

Describes plugins life cycle status

Signature

export declare enum PluginState

Import

import { PluginState } from '@grafana/data';

Enumeration Members

Member	Value	Description
alpha	`"alpha"`
beta	`"beta"`
deprecated	`"deprecated"`
stable	`"stable"`

PluginType

Sat, 04 Apr 2026 12:26:57 +0000

PluginType enum

Describes type of plugin

Signature

export declare enum PluginType

Import

import { PluginType } from '@grafana/data';

Enumeration Members

Member	Value	Description
app	`"app"`
datasource	`"datasource"`
panel	`"panel"`
renderer	`"renderer"`

PreferredVisualisationType

Sat, 04 Apr 2026 12:26:57 +0000

PreferredVisualisationType type

Signature

export declare type PreferredVisualisationType = 'graph' | 'table' | 'logs' | 'trace' | 'nodeGraph';

Import

import { PreferredVisualisationType } from '@grafana/data';

PreloadPlugin

Sat, 04 Apr 2026 12:26:57 +0000

PreloadPlugin type

Describes the plugins that should be preloaded prior to start Grafana.

Signature

export declare type PreloadPlugin = {
    path: string;
    version: string;
};

Import

import { PreloadPlugin } from '@grafana/data';

QueryEditorHelpProps

Sat, 04 Apr 2026 12:26:57 +0000

QueryEditorHelpProps interface

Signature

export interface QueryEditorHelpProps<TQuery extends DataQuery = DataQuery>

Import

import { QueryEditorHelpProps } from '@grafana/data';

Properties

Property	Type	Description
datasource	`DataSourceApi<TQuery>`
exploreId	`any`
onClickExample	`(query: TQuery) => void`

datasource property

Signature

datasource: DataSourceApi<TQuery>;

exploreId property

Signature

exploreId?: any;

onClickExample property

Signature

onClickExample: (query: TQuery) => void;

QueryEditorProps

Sat, 04 Apr 2026 12:26:57 +0000

QueryEditorProps interface

Signature

export interface QueryEditorProps<DSType extends DataSourceApi<TQuery, TOptions>, TQuery extends DataQuery = DataQuery, TOptions extends DataSourceJsonData = DataSourceJsonData, TVQuery extends DataQuery = TQuery>

Import

import { QueryEditorProps } from '@grafana/data';

Properties

Property	Type	Description
app	`CoreApp`
data	`PanelData`	Contains query response filtered by refId of QueryResultBase and possible query error
datasource	`DSType`
exploreId	`any`
history	`Array<HistoryItem<TQuery>>`
onBlur	`() => void`
onChange	`(value: TVQuery) => void`
onRunQuery	`() => void`
queries	`DataQuery[]`
query	`TVQuery`
range	`TimeRange`

app property

Signature

app?: CoreApp;

data property

Contains query response filtered by refId of QueryResultBase and possible query error

Signature

data?: PanelData;

datasource property

Signature

datasource: DSType;

exploreId property

Signature

exploreId?: any;

history property

Signature

history?: Array<HistoryItem<TQuery>>;

onBlur property

Signature

onBlur?: () => void;

onChange property

Signature

onChange: (value: TVQuery) => void;

onRunQuery property

Signature

onRunQuery: () => void;

queries property

Signature

queries?: DataQuery[];

query property

Signature

query: TVQuery;

range property

Signature

range?: TimeRange;

QueryFix

Sat, 04 Apr 2026 12:26:57 +0000

QueryFix interface

Signature

export interface QueryFix

Import

import { QueryFix } from '@grafana/data';

Properties

Property	Type	Description
action	`QueryFixAction`
label	`string`

action property

Signature

action?: QueryFixAction;

label property

Signature

label: string;

QueryFixAction

Sat, 04 Apr 2026 12:26:57 +0000

QueryFixAction interface

Signature

export interface QueryFixAction

Import

import { QueryFixAction } from '@grafana/data';

Properties

Property	Type	Description
preventSubmit	`boolean`
query	`string`
type	`string`

preventSubmit property

Signature

preventSubmit?: boolean;

query property

Signature

query?: string;

type property

Signature

type: string;

QueryHint

Sat, 04 Apr 2026 12:26:57 +0000

QueryHint interface

Signature

export interface QueryHint

Import

import { QueryHint } from '@grafana/data';

Properties

Property	Type	Description
fix	`QueryFix`
label	`string`
type	`string`

fix property

Signature

fix?: QueryFix;

label property

Signature

label: string;

type property

Signature

type: string;

QueryResultBase

Sat, 04 Apr 2026 12:26:57 +0000

QueryResultBase interface

Signature

export interface QueryResultBase

Import

import { QueryResultBase } from '@grafana/data';

Properties

Property	Type	Description
meta	`QueryResultMeta`	Used by some backend data sources to communicate back info about the execution (generated sql, timing)
refId	`string`	Matches the query target refId

meta property

Used by some backend data sources to communicate back info about the execution (generated sql, timing)

Signature

meta?: QueryResultMeta;

refId property

Matches the query target refId

Signature

refId?: string;

QueryResultMeta

Sat, 04 Apr 2026 12:26:57 +0000

QueryResultMeta interface

Signature

export interface QueryResultMeta

Import

import { QueryResultMeta } from '@grafana/data';

Properties

Property	Type	Description
alignmentPeriod	`number`	Legacy data source specific, should be moved to custom
channel	`string`	The path for live stream updates for this frame
custom	`Record<string, any>`	DatasSource Specific Values
dataTopic	`DataTopic`	Optionally identify which topic the frame should be assigned to. A value specified in the response will override what the request asked for.
executedQueryString	`string`	This is the raw query sent to the underlying system. All macros and templating as been applied. When metadata contains this value, it will be shown in the query inspector
instant	`boolean`
json	`boolean`
limit	`number`
notices	`QueryResultMetaNotice[]`	Meta Notices
path	`string`	A browsable path on the datasource
pathSeparator	`string`	defaults to ‘/’
preferredVisualisationType	`PreferredVisualisationType`	Currently used to show results in Explore only in preferred visualisation option
searchWords	`string[]`
stats	`QueryResultMetaStat[]`	Stats
transformations	`string[]`	Used to track transformation ids that where part of the processing
type	`DataFrameType`

alignmentPeriod property

Legacy data source specific, should be moved to custom

Signature

alignmentPeriod?: number;

channel property

The path for live stream updates for this frame

Signature

channel?: string;

custom property

DatasSource Specific Values

Signature

custom?: Record<string, any>;

dataTopic property

Optionally identify which topic the frame should be assigned to. A value specified in the response will override what the request asked for.

Signature

dataTopic?: DataTopic;

executedQueryString property

This is the raw query sent to the underlying system. All macros and templating as been applied. When metadata contains this value, it will be shown in the query inspector

Signature

executedQueryString?: string;

instant property

Signature

instant?: boolean;

json property

Signature

json?: boolean;

limit property

Signature

limit?: number;

notices property

Meta Notices

Signature

notices?: QueryResultMetaNotice[];

path property

A browsable path on the datasource

Signature

path?: string;

pathSeparator property

defaults to ‘/’

Signature

pathSeparator?: string;

preferredVisualisationType property

Currently used to show results in Explore only in preferred visualisation option

Signature

preferredVisualisationType?: PreferredVisualisationType;

searchWords property

Signature

searchWords?: string[];

stats property

Stats

Signature

stats?: QueryResultMetaStat[];

transformations property

Used to track transformation ids that where part of the processing

Signature

transformations?: string[];

type property

Signature

type?: DataFrameType;

QueryResultMetaNotice

Sat, 04 Apr 2026 12:26:57 +0000

QueryResultMetaNotice interface

QueryResultMetaNotice is a structure that provides user notices for query result data

Signature

export interface QueryResultMetaNotice

Import

import { QueryResultMetaNotice } from '@grafana/data';

Properties

Property	Type	Description
inspect	`‘meta’ \| ’error’ \| ‘data’ \| ‘stats’`	Optionally suggest an appropriate tab for the panel inspector
link	`string`	An optional link that may be displayed in the UI. This value may be an absolute URL or relative to grafana root
severity	`‘info’ \| ‘warning’ \| ’error’`	Specify the notice severity
text	`string`	Notice descriptive text

inspect property

Optionally suggest an appropriate tab for the panel inspector

Signature

inspect?: 'meta' | 'error' | 'data' | 'stats';

link property

An optional link that may be displayed in the UI. This value may be an absolute URL or relative to grafana root

Signature

link?: string;

severity property

Specify the notice severity

Signature

severity: 'info' | 'warning' | 'error';

text property

Notice descriptive text

Signature

text: string;

QueryResultMetaStat

Sat, 04 Apr 2026 12:26:57 +0000

QueryResultMetaStat interface

Signature

export interface QueryResultMetaStat extends FieldConfig

Import

import { QueryResultMetaStat } from '@grafana/data';

Properties

Property	Type	Description
displayName	`string`
value	`number`

displayName property

Signature

displayName: string;

value property

Signature

value: number;

rangeUtil

Sat, 04 Apr 2026 12:26:57 +0000

rangeUtil namespace

rangeUtil namespace

Import

import { rangeUtil } from '@grafana/data';

Functions

Function	Description
calculateInterval(range, resolution, lowLimitInterval)
describeInterval(str)
describeTextRange(expr)
intervalToMs(str)
intervalToSeconds(str)
isFiscal(timeRange)
isRelativeTimeRange(raw)
msRangeToTimeString(rangeMs)
roundInterval(interval)
secondsToHms(seconds)

Variables

Variable	Description
convertRawToRange
describeTimeRangeAbbreviation
isValidTimeSpan

RangeValueMatcherOptions

Sat, 04 Apr 2026 12:26:57 +0000

RangeValueMatcherOptions interface

Describes a range value matcher option that has a to and a from value to be able to match a range.

Signature

export interface RangeValueMatcherOptions<T = any> extends ValueMatcherOptions

Import

import { RangeValueMatcherOptions } from '@grafana/data';

Properties

Property	Type	Description
from	`T`
to	`T`

from property

Signature

from: T;

to property

Signature

to: T;

RawTimeRange

Sat, 04 Apr 2026 12:26:57 +0000

RawTimeRange interface

Signature

export interface RawTimeRange

Import

import { RawTimeRange } from '@grafana/data';

Properties

Property	Type	Description
from	`DateTime \| string`
to	`DateTime \| string`

from property

Signature

from: DateTime | string;

to property

Signature

to: DateTime | string;

readCSV

Sat, 04 Apr 2026 12:26:57 +0000

readCSV() function

Signature

export declare function readCSV(csv: string, options?: CSVOptions): DataFrame[];

Import

import { readCSV } from '@grafana/data';

Parameters

Parameter	Type	Description
csv	`string`
options	`CSVOptions`

Returns:

DataFrame[]

ReadWriteVector

Sat, 04 Apr 2026 12:26:57 +0000

ReadWriteVector interface

Apache arrow vectors are Read/Write

Signature

export interface ReadWriteVector<T = any> extends Vector<T>

Import

import { ReadWriteVector } from '@grafana/data';

Properties

Property	Type	Description
set	`(index: number, value: T) => void`

set property

Signature

set: (index: number, value: T) => void;

recomposeColor

Sat, 04 Apr 2026 12:26:57 +0000

colorManipulator.recomposeColor() function

colorManipulator.recomposeColor() function

Converts a color object with type and values to a string.

Signature

export declare function recomposeColor(color: DecomposeColor): string;

Import

import { colorManipulator } from '@grafana/data';
const { recomposeColor } = colorManipulator;

Parameters

Parameter	Type	Description
color	`DecomposeColor`	Decomposed color

Returns:

string

A CSS color string

ReduceDataOptions

Sat, 04 Apr 2026 12:26:57 +0000

ReduceDataOptions interface

Options for how to turn DataFrames into an array of display values

Signature

export interface ReduceDataOptions

Import

import { ReduceDataOptions } from '@grafana/data';

Properties

Property	Type	Description
calcs	`string[]`	When !values, pick one value for the whole field
fields	`string`	Which fields to show. By default this is only numeric fields
limit	`number`	if showing all values limit
values	`boolean`

calcs property

When !values, pick one value for the whole field

Signature

calcs: string[];

fields property

Which fields to show. By default this is only numeric fields

Signature

fields?: string;

limit property

if showing all values limit

Signature

limit?: number;

values property

Signature

values?: boolean;

reduceField

Sat, 04 Apr 2026 12:26:57 +0000

reduceField() function

Signature

export declare function reduceField(options: ReduceFieldOptions): FieldCalcs;

Import

import { reduceField } from '@grafana/data';

Parameters

Parameter	Type	Description
options	`ReduceFieldOptions`

Returns:

FieldCalcs

an object with a key for each selected stat NOTE: This will also modify the ‘field.state’ object, leaving values in a cache until cleared.

ReducerID

Sat, 04 Apr 2026 12:26:57 +0000

ReducerID enum

Signature

export declare enum ReducerID

Import

import { ReducerID } from '@grafana/data';

Enumeration Members

Member	Value	Description
allIsNull	`"allIsNull"`
allIsZero	`"allIsZero"`
allValues	`"allValues"`
changeCount	`"changeCount"`
count	`"count"`
delta	`"delta"`
diff	`"diff"`
diffperc	`"diffperc"`
distinctCount	`"distinctCount"`
first	`"first"`
firstNotNull	`"firstNotNull"`
last	`"last"`
lastNotNull	`"lastNotNull"`
logmin	`"logmin"`
max	`"max"`
mean	`"mean"`
min	`"min"`
range	`"range"`
step	`"step"`
sum	`"sum"`

RegexpOrNamesMatcherOptions

Sat, 04 Apr 2026 12:26:57 +0000

RegexpOrNamesMatcherOptions interface

Signature

export interface RegexpOrNamesMatcherOptions

Import

import { RegexpOrNamesMatcherOptions } from '@grafana/data';

Properties

Property	Type	Description
names	`string[]`
pattern	`string`

names property

Signature

names?: string[];

pattern property

Signature

pattern?: string;

Registry

Sat, 04 Apr 2026 12:26:57 +0000

Registry class

Signature

export declare class Registry<T extends RegistryItem>

Import

import { Registry } from '@grafana/data';

Constructors

Constructor	Modifiers	Description
constructor(init)		Constructs a new instance of the `Registry` class

Properties

Property	Modifiers	Type	Description
setInit		`(init: () => T[]) => void`

Methods

Method	Modifiers	Description
get(id)
getIfExists(id)
isEmpty()
list(ids)		Return a list of values by ID, or all values if not specified
register(ext)
selectOptions(current, filter)

constructor(init)

Constructs a new instance of the Registry class

Signature

constructor(init?: (() => T[]) | undefined);

Parameters

Parameter	Type	Description
init	`(() => T[]) \| undefined`

setInit property

Signature

setInit: (init: () => T[]) => void;

get method

Signature

get(id: string): T;

Parameters

Parameter	Type	Description
id	`string`

Returns:

T

getIfExists method

Signature

getIfExists(id: string | undefined): T | undefined;

Parameters

Parameter	Type	Description
id	`string \| undefined`

Returns:

T | undefined

isEmpty method

Signature

isEmpty(): boolean;

Returns:

boolean

list method

Return a list of values by ID, or all values if not specified

Signature

list(ids?: any[]): T[];

Parameters

Parameter	Type	Description
ids	`any[]`

Returns:

T[]

register method

Signature

register(ext: T): void;

Parameters

Parameter	Type	Description
ext	`T`

Returns:

void

selectOptions method

Signature

selectOptions(current?: string[], filter?: (ext: T) => boolean): RegistrySelectInfo;

Parameters

Parameter	Type	Description
current	`string[]`
filter	`(ext: T) => boolean`

Returns:

RegistrySelectInfo

RegistryItem

Sat, 04 Apr 2026 12:26:57 +0000

RegistryItem interface

Signature

export interface RegistryItem

Import

import { RegistryItem } from '@grafana/data';

Properties

Property	Type	Description
aliasIds	`string[]`
description	`string`
excludeFromPicker	`boolean`	Some extensions should not be user selectable like: ‘all’ and ‘any’ matchers;
id	`string`
name	`string`
state	`PluginState`	Optional feature state

aliasIds property

Signature

aliasIds?: string[];

description property

Signature

description?: string;

excludeFromPicker property

Some extensions should not be user selectable like: ‘all’ and ‘any’ matchers;

Signature

excludeFromPicker?: boolean;

id property

Signature

id: string;

name property

Signature

name: string;

state property

Optional feature state

Signature

state?: PluginState;

RegistryItemWithOptions

Sat, 04 Apr 2026 12:26:57 +0000

RegistryItemWithOptions interface

Signature

export interface RegistryItemWithOptions<TOptions = any> extends RegistryItem

Import

import { RegistryItemWithOptions } from '@grafana/data';

Properties

Property	Type	Description
defaultOptions	`TOptions`	Default options used if nothing else is specified
getOptionsDisplayText	`(options: TOptions) => string`	Convert the options to a string

defaultOptions property

Default options used if nothing else is specified

Signature

defaultOptions?: TOptions;

getOptionsDisplayText property

Convert the options to a string

Signature

getOptionsDisplayText?: (options: TOptions) => string;

RenameByRegexTransformerOptions

Sat, 04 Apr 2026 12:26:57 +0000

RenameByRegexTransformerOptions interface

Options for renameByRegexTransformer

Signature

export interface RenameByRegexTransformerOptions

Import

import { RenameByRegexTransformerOptions } from '@grafana/data';

Properties

Property	Type	Description
regex	`string`
renamePattern	`string`

regex property

Signature

regex: string;

renamePattern property

Signature

renamePattern: string;

renderMarkdown

Sat, 04 Apr 2026 12:26:57 +0000

renderMarkdown() function

Signature

export declare function renderMarkdown(str?: string, options?: RenderMarkdownOptions): string;

Import

import { renderMarkdown } from '@grafana/data';

Parameters

Parameter	Type	Description
str	`string`
options	`RenderMarkdownOptions`

Returns:

string

RenderMarkdownOptions

Sat, 04 Apr 2026 12:26:57 +0000

RenderMarkdownOptions interface

Signature

export interface RenderMarkdownOptions

Import

import { RenderMarkdownOptions } from '@grafana/data';

Properties

Property	Type	Description
noSanitize	`boolean`

noSanitize property

Signature

noSanitize?: boolean;

renderTextPanelMarkdown

Sat, 04 Apr 2026 12:26:57 +0000

renderTextPanelMarkdown() function

Signature

export declare function renderTextPanelMarkdown(str?: string, options?: RenderMarkdownOptions): string;

Import

import { renderTextPanelMarkdown } from '@grafana/data';

Parameters

Parameter	Type	Description
str	`string`
options	`RenderMarkdownOptions`

Returns:

string

reverseDataFrame

Sat, 04 Apr 2026 12:26:57 +0000

reverseDataFrame() function

Returns a copy with all values reversed

Signature

export declare function reverseDataFrame(data: DataFrame): DataFrame;

Import

import { reverseDataFrame } from '@grafana/data';

Parameters

Parameter	Type	Description
data	`DataFrame`

Returns:

DataFrame

rgbToHex

Sat, 04 Apr 2026 12:26:57 +0000

colorManipulator.rgbToHex() function

colorManipulator.rgbToHex() function

Converts a color from CSS rgb format to CSS hex format.

Signature

export declare function rgbToHex(color: string): string;

Import

import { colorManipulator } from '@grafana/data';
const { rgbToHex } = colorManipulator;

Parameters

Parameter	Type	Description
color	`string`	RGB color, i.e. rgb(n, n, n)

Returns:

string

A CSS rgb color string, i.e. #nnnnnn

roundInterval

Sat, 04 Apr 2026 12:26:57 +0000

rangeUtil.roundInterval() function

Signature

export declare function roundInterval(interval: number): 100 | 10 | 1000 | 20 | 50 | 200 | 500 | 2000 | 5000 | 10000 | 15000 | 20000 | 30000 | 60000 | 120000 | 300000 | 600000 | 900000 | 1200000 | 1800000 | 3600000 | 7200000 | 10800000 | 21600000 | 43200000 | 86400000 | 604800000 | 2592000000 | 31536000000;

Import

import { rangeUtil } from '@grafana/data';
const { roundInterval } = rangeUtil;

Parameters

Parameter	Type	Description
interval	`number`

Returns:

100 | 10 | 1000 | 20 | 50 | 200 | 500 | 2000 | 5000 | 10000 | 15000 | 20000 | 30000 | 60000 | 120000 | 300000 | 600000 | 900000 | 1200000 | 1800000 | 3600000 | 7200000 | 10800000 | 21600000 | 43200000 | 86400000 | 604800000 | 2592000000 | 31536000000

roundToFiscal

Sat, 04 Apr 2026 12:26:57 +0000

dateMath.roundToFiscal() function

Signature

export declare function roundToFiscal(fyStartMonth: number, dateTime: any, unit: string, roundUp: boolean | undefined): any;

Import

import { dateMath } from '@grafana/data';
const { roundToFiscal } = dateMath;

Parameters

Parameter	Type	Description
fyStartMonth	`number`
dateTime	`any`
unit	`string`
roundUp	`boolean \| undefined`

Returns:

any

scaledUnits

Sat, 04 Apr 2026 12:26:57 +0000

scaledUnits() function

Signature

export declare function scaledUnits(factor: number, extArray: string[]): ValueFormatter;

Import

import { scaledUnits } from '@grafana/data';

Parameters

Parameter	Type	Description
factor	`number`
extArray	`string[]`

Returns:

ValueFormatter

ScopedVar

Sat, 04 Apr 2026 12:26:57 +0000

ScopedVar interface

Signature

export interface ScopedVar<T = any>

Import

import { ScopedVar } from '@grafana/data';

Properties

Property	Type	Description
text	`any`
value	`T`

text property

Signature

text: any;

value property

Signature

value: T;

ScopedVars

Sat, 04 Apr 2026 12:26:57 +0000

ScopedVars interface

Signature

export interface ScopedVars extends Record<string, ScopedVar>

Import

import { ScopedVars } from '@grafana/data';

ScreenshotInfo

Sat, 04 Apr 2026 12:26:57 +0000

ScreenshotInfo interface

Signature

export interface ScreenshotInfo

Import

import { ScreenshotInfo } from '@grafana/data';

Properties

Property	Type	Description
name	`string`
path	`string`

name property

Signature

name: string;

path property

Signature

path: string;

secondsToHms

Sat, 04 Apr 2026 12:26:57 +0000

rangeUtil.secondsToHms() function

Signature

export declare function secondsToHms(seconds: number): string;

Import

import { rangeUtil } from '@grafana/data';
const { secondsToHms } = rangeUtil;

Parameters

Parameter	Type	Description
seconds	`number`

Returns:

string

SelectableValue

Sat, 04 Apr 2026 12:26:57 +0000

SelectableValue interface

Used in select elements

Signature

export interface SelectableValue<T = any>

Import

import { SelectableValue } from '@grafana/data';

Properties

Property	Type	Description
ariaLabel	`string`
description	`string`
icon	`string`
imgUrl	`string`
label	`string`
value	`T`

ariaLabel property

Signature

ariaLabel?: string;

description property

Signature

description?: string;

icon property

Signature

icon?: string;

imgUrl property

Signature

imgUrl?: string;

label property

Signature

label?: string;

value property

Signature

value?: T;

SelectFieldConfigSettings

Sat, 04 Apr 2026 12:26:57 +0000

SelectFieldConfigSettings interface

Signature

export interface SelectFieldConfigSettings<T>

Import

import { SelectFieldConfigSettings } from '@grafana/data';

Properties

Property	Type	Description
allowCustomValue	`boolean`
getOptions	`(context: FieldOverrideContext) => Promise<Array<SelectableValue<T>>>`	Optionally use the context to define the options
isClearable	`boolean`
options	`Array<SelectableValue<T>>`	The default options

allowCustomValue property

Signature

allowCustomValue?: boolean;

getOptions property

Optionally use the context to define the options

Signature

getOptions?: (context: FieldOverrideContext) => Promise<Array<SelectableValue<T>>>;

isClearable property

Signature

isClearable?: boolean;

options property

The default options

Signature

options: Array<SelectableValue<T>>;

selectOverrideProcessor

Sat, 04 Apr 2026 12:26:57 +0000

selectOverrideProcessor variable

Signature

selectOverrideProcessor: (value: any, _context: FieldOverrideContext, _settings?: SelectFieldConfigSettings<any> | undefined) => any

Import

import { selectOverrideProcessor } from '@grafana/data';

serializeStateToUrlParam

Sat, 04 Apr 2026 12:26:57 +0000

serializeStateToUrlParam() function

Create an string that is used in URL to represent the Explore state. This is basically just a stringified json that is that used as a state of a single Explore pane so it does not represent full Explore URL.

Signature

export declare function serializeStateToUrlParam(urlState: ExploreUrlState, compact?: boolean): string;

Import

import { serializeStateToUrlParam } from '@grafana/data';

Parameters

Parameter	Type	Description
urlState	`ExploreUrlState`
compact	`boolean`	this parameter is deprecated and will be removed in a future release.

Returns:

string

SetFieldConfigOptionsArgs

Sat, 04 Apr 2026 12:26:57 +0000

SetFieldConfigOptionsArgs interface

Signature

export interface SetFieldConfigOptionsArgs<TFieldConfigOptions = any>

Import

import { SetFieldConfigOptionsArgs } from '@grafana/data';

Properties

Property	Type	Description
disableStandardOptions	`FieldConfigProperty[]`	*(BETA)* Array of standard field config properties that should not be available in the panel
standardOptions	`Partial<Record<FieldConfigProperty, StandardOptionConfig>>`	*(BETA)* Configuration object of the standard field config properites
useCustomConfig	`(builder: FieldConfigEditorBuilder<TFieldConfigOptions>) => void`	*(BETA)* Function that allows custom field config properties definition.

disableStandardOptions property

Array of standard field config properties that should not be available in the panel

Signature

disableStandardOptions?: FieldConfigProperty[];

Example

{
  disableStandardOptions: [FieldConfigProperty.Min, FieldConfigProperty.Max, FieldConfigProperty.Unit]
}

standardOptions property

Configuration object of the standard field config properites

Signature

standardOptions?: Partial<Record<FieldConfigProperty, StandardOptionConfig>>;

Example

{
  standardOptions: {
    [FieldConfigProperty.Decimals]: {
      defaultValue: 3
    }
  }
}

useCustomConfig property

Function that allows custom field config properties definition.

Signature

useCustomConfig?: (builder: FieldConfigEditorBuilder<TFieldConfigOptions>) => void;

Example

useCustomConfig: builder => {
  builder
   .addNumberInput({
     id: 'shapeBorderWidth',
     name: 'Border width',
     description: 'Border width of the shape',
     settings: {
       min: 1,
       max: 5,
     },
   })
   .addSelect({
     id: 'displayMode',
     name: 'Display mode',
     description: 'How the shape shout be rendered'
     settings: {
     options: [{value: 'fill', label: 'Fill' }, {value: 'transparent', label: 'Transparent }]
   },
 })
}

setLocale

Sat, 04 Apr 2026 12:26:57 +0000

setLocale variable

Signature

setLocale: (language: string) => void

Import

import { setLocale } from '@grafana/data';

setWeekStart

Sat, 04 Apr 2026 12:26:57 +0000

setWeekStart variable

Signature

setWeekStart: (weekStart?: string | undefined) => void

Import

import { setWeekStart } from '@grafana/data';

shallowCompare

Sat, 04 Apr 2026 12:26:57 +0000

shallowCompare() function

shallowCompare() function

Checks if two objects are equal shallowly

Signature

export declare function shallowCompare<T extends {}>(a: T, b: T, cmp?: Cmp): boolean;

Import

import { shallowCompare } from '@grafana/data';

Parameters

Parameter	Type	Description
a	`T`
b	`T`
cmp	`Cmp`

Returns:

boolean

simpleCountUnit

Sat, 04 Apr 2026 12:26:57 +0000

simpleCountUnit() function

Signature

export declare function simpleCountUnit(symbol: string): ValueFormatter;

Import

import { simpleCountUnit } from '@grafana/data';

Parameters

Parameter	Type	Description
symbol	`string`

Returns:

ValueFormatter

SliderFieldConfigSettings

Sat, 04 Apr 2026 12:26:57 +0000

SliderFieldConfigSettings interface

Signature

export interface SliderFieldConfigSettings

Import

import { SliderFieldConfigSettings } from '@grafana/data';

Properties

Property	Type	Description
ariaLabelForHandle	`string`
included	`boolean`
marks	`SliderMarks`
max	`number`
min	`number`
step	`number`

ariaLabelForHandle property

Signature

ariaLabelForHandle?: string;

included property

Signature

included?: boolean;

marks property

Signature

marks?: SliderMarks;

max property

Signature

max: number;

min property

Signature

min: number;

step property

Signature

step?: number;

SliderMarks

Sat, 04 Apr 2026 12:26:57 +0000

SliderMarks type

Signature

export declare type SliderMarks = Record<number, React.ReactNode | {
    style?: React.CSSProperties;
    label?: string;
}>;

Import

import { SliderMarks } from '@grafana/data';

sortDataFrame

Sat, 04 Apr 2026 12:26:57 +0000

sortDataFrame() function

Signature

export declare function sortDataFrame(data: DataFrame, sortIndex?: number, reverse?: boolean): DataFrame;

Import

import { sortDataFrame } from '@grafana/data';

Parameters

Parameter	Type	Description
data	`DataFrame`
sortIndex	`number`
reverse	`boolean`

Returns:

DataFrame

SortedVector

Sat, 04 Apr 2026 12:26:57 +0000

SortedVector class

Values are returned in the order defined by the input parameter

Signature

export declare class SortedVector<T = any> implements Vector<T>

Import

import { SortedVector } from '@grafana/data';

Constructors

Constructor	Modifiers	Description
constructor(source, order)		Constructs a new instance of the `SortedVector` class

Properties

Property	Modifiers	Type	Description
length		`number`

Methods

Method	Modifiers	Description
get(index)
toArray()
toJSON()

constructor(source, order)

Constructs a new instance of the SortedVector class

Signature

constructor(source: Vector<T>, order: number[]);

Parameters

Parameter	Type	Description
source	`Vector<T>`
order	`number[]`

length property

Signature

get length(): number;

get method

Signature

get(index: number): T;

Parameters

Parameter	Type	Description
index	`number`

Returns:

T

toArray method

Signature

toArray(): T[];

Returns:

T[]

toJSON method

Signature

toJSON(): T[];

Returns:

T[]

sortInAscendingOrder

Sat, 04 Apr 2026 12:26:57 +0000

sortInAscendingOrder variable

Signature

sortInAscendingOrder: (a: LogRowModel, b: LogRowModel) => 0 | 1 | -1

Import

import { sortInAscendingOrder } from '@grafana/data';

sortInDescendingOrder

Sat, 04 Apr 2026 12:26:57 +0000

sortInDescendingOrder variable

Signature

sortInDescendingOrder: (a: LogRowModel, b: LogRowModel) => 0 | 1 | -1

Import

import { sortInDescendingOrder } from '@grafana/data';

sortLogRows

Sat, 04 Apr 2026 12:26:57 +0000

sortLogRows variable

Signature

sortLogRows: (logRows: LogRowModel[], sortOrder: LogsSortOrder) => LogRowModel[]

Import

import { sortLogRows } from '@grafana/data';

sortLogsResult

Sat, 04 Apr 2026 12:26:57 +0000

sortLogsResult variable

Signature

sortLogsResult: (logsResult: LogsModel | null, sortOrder: LogsSortOrder) => LogsModel

Import

import { sortLogsResult } from '@grafana/data';

sortThresholds

Sat, 04 Apr 2026 12:26:57 +0000

sortThresholds() function

Sorts the thresholds

Signature

export declare function sortThresholds(thresholds: Threshold[]): Threshold[];

Import

import { sortThresholds } from '@grafana/data';

Parameters

Parameter	Type	Description
thresholds	`Threshold[]`

Returns:

Threshold[]

sortValues

Sat, 04 Apr 2026 12:26:57 +0000

arrayUtils.sortValues() function

Signature

export declare function sortValues(sort: SortOrder.Ascending | SortOrder.Descending): (a: any, b: any) => number;

Import

import { arrayUtils } from '@grafana/data';
const { sortValues } = arrayUtils;

Parameters

Parameter	Type	Description
sort	`SortOrder.Ascending \| SortOrder.Descending`

Returns:

(a: any, b: any) => number

SplitOpen

Sat, 04 Apr 2026 12:26:57 +0000

SplitOpen type

SplitOpen type is used in Explore and related components.

Signature

export declare type SplitOpen = <T extends DataQuery = any>(options?: {
    datasourceUid: string;
    query: T;
    range?: TimeRange;
    panelsState?: ExplorePanelsState;
} | undefined) => void;

Import

import { SplitOpen } from '@grafana/data';

StandardEditorContext

Sat, 04 Apr 2026 12:26:57 +0000

StandardEditorContext interface

Signature

export interface StandardEditorContext<TOptions, TState = any>

Import

import { StandardEditorContext } from '@grafana/data';

Properties

Property	Type	Description
data	`DataFrame[]`
eventBus	`EventBus`
getSuggestions	`(scope?: VariableSuggestionsScope) => VariableSuggestion[]`
instanceState	`TState`
isOverride	`boolean`
options	`TOptions`
replaceVariables	`InterpolateFunction`

data property

Signature

data: DataFrame[];

eventBus property

Signature

eventBus?: EventBus;

getSuggestions property

Signature

getSuggestions?: (scope?: VariableSuggestionsScope) => VariableSuggestion[];

instanceState property

Signature

instanceState?: TState;

isOverride property

Signature

isOverride?: boolean;

options property

Signature

options?: TOptions;

replaceVariables property

Signature

replaceVariables?: InterpolateFunction;

StandardEditorProps

Sat, 04 Apr 2026 12:26:57 +0000

StandardEditorProps interface

Signature

export interface StandardEditorProps<TValue = any, TSettings = any, TOptions = any, TState = any>

Import

import { StandardEditorProps } from '@grafana/data';

Properties

Property	Type	Description
context	`StandardEditorContext<TOptions, TState>`
id	`string`
item	`StandardEditorsRegistryItem<TValue, TSettings>`
onChange	`(value?: TValue) => void`
value	`TValue`

context property

Signature

context: StandardEditorContext<TOptions, TState>;

id property

Signature

id?: string;

item property

Signature

item: StandardEditorsRegistryItem<TValue, TSettings>;

onChange property

Signature

onChange: (value?: TValue) => void;

value property

Signature

value: TValue;

standardEditorsRegistry

Sat, 04 Apr 2026 12:26:57 +0000

standardEditorsRegistry variable

Signature

standardEditorsRegistry: Registry<StandardEditorsRegistryItem<any, any>>

Import

import { standardEditorsRegistry } from '@grafana/data';

StandardEditorsRegistryItem

Sat, 04 Apr 2026 12:26:57 +0000

StandardEditorsRegistryItem interface

Signature

export interface StandardEditorsRegistryItem<TValue = any, TSettings = any> extends RegistryItem

Import

import { StandardEditorsRegistryItem } from '@grafana/data';

Properties

Property	Type	Description
editor	`ComponentType<StandardEditorProps<TValue, TSettings>>`
settings	`TSettings`

editor property

Signature

editor: ComponentType<StandardEditorProps<TValue, TSettings>>;

settings property

Signature

settings?: TSettings;

standardFieldConfigEditorRegistry

Sat, 04 Apr 2026 12:26:57 +0000

standardFieldConfigEditorRegistry variable

Signature

standardFieldConfigEditorRegistry: FieldConfigOptionsRegistry

Import

import { standardFieldConfigEditorRegistry } from '@grafana/data';

StandardOptionConfig

Sat, 04 Apr 2026 12:26:57 +0000

StandardOptionConfig type

StandardOptionConfig type

Signature

export declare type StandardOptionConfig = {
    defaultValue?: any;
    settings?: any;
};

Import

import { StandardOptionConfig } from '@grafana/data';

standardTransformers

Sat, 04 Apr 2026 12:26:57 +0000

standardTransformers variable

Signature

standardTransformers: {
    noopTransformer: import("..").DataTransformerInfo<import("./transformers/noop").NoopTransformerOptions>;
    filterFieldsTransformer: import("..").DataTransformerInfo<import("./transformers/filter").FilterOptions>;
    filterFieldsByNameTransformer: import("..").DataTransformerInfo<import("./transformers/filterByName").FilterFieldsByNameTransformerOptions>;
    filterFramesTransformer: import("..").DataTransformerInfo<import("./transformers/filter").FilterOptions>;
    filterFramesByRefIdTransformer: import("..").DataTransformerInfo<import("./transformers/filterByRefId").FilterFramesByRefIdTransformerOptions>;
    filterByValueTransformer: import("..").DataTransformerInfo<import("./transformers/filterByValue").FilterByValueTransformerOptions>;
    orderFieldsTransformer: import("..").DataTransformerInfo<import("./transformers/order").OrderFieldsTransformerOptions>;
    organizeFieldsTransformer: import("..").DataTransformerInfo<import("./transformers/organize").OrganizeFieldsTransformerOptions>;
    reduceTransformer: import("..").DataTransformerInfo<import("./transformers/reduce").ReduceTransformerOptions>;
    concatenateTransformer: import("..").DataTransformerInfo<import("./transformers/concat").ConcatenateTransformerOptions>;
    calculateFieldTransformer: import("..").DataTransformerInfo<import("./transformers/calculateField").CalculateFieldTransformerOptions>;
    seriesToColumnsTransformer: import("..").SynchronousDataTransformerInfo<import("./transformers/seriesToColumns").SeriesToColumnsOptions>;
    seriesToRowsTransformer: import("..").DataTransformerInfo<import("./transformers/seriesToRows").SeriesToRowsTransformerOptions>;
    renameFieldsTransformer: import("..").DataTransformerInfo<import("./transformers/rename").RenameFieldsTransformerOptions>;
    labelsToFieldsTransformer: import("..").SynchronousDataTransformerInfo<import("./transformers/labelsToFields").LabelsToFieldsOptions>;
    ensureColumnsTransformer: import("..").SynchronousDataTransformerInfo<any>;
    groupByTransformer: import("..").DataTransformerInfo<import("./transformers/groupBy").GroupByTransformerOptions>;
    sortByTransformer: import("..").DataTransformerInfo<import("./transformers/sortBy").SortByTransformerOptions>;
    mergeTransformer: import("..").DataTransformerInfo<import("./transformers/merge").MergeTransformerOptions>;
    renameByRegexTransformer: import("..").DataTransformerInfo<import("./transformers/renameByRegex").RenameByRegexTransformerOptions>;
    histogramTransformer: import("..").SynchronousDataTransformerInfo<import("./transformers/histogram").HistogramTransformerOptions>;
    convertFieldTypeTransformer: import("..").SynchronousDataTransformerInfo<import("./transformers/convertFieldType").ConvertFieldTypeTransformerOptions>;
}

Import

import { standardTransformers } from '@grafana/data';

standardTransformersRegistry

Sat, 04 Apr 2026 12:26:57 +0000

standardTransformersRegistry variable

Registry of transformation options that can be driven by stored configuration files.

Signature

standardTransformersRegistry: Registry<TransformerRegistryItem<any>>

Import

import { standardTransformersRegistry } from '@grafana/data';

StatsPickerConfigSettings

Sat, 04 Apr 2026 12:26:57 +0000

StatsPickerConfigSettings interface

Signature

export interface StatsPickerConfigSettings

Import

import { StatsPickerConfigSettings } from '@grafana/data';

Properties

Property	Type	Description
allowMultiple	`boolean`	Enable multi-selection in the stats picker
defaultStat	`string`	Default stats to be use in the stats picker

allowMultiple property

Enable multi-selection in the stats picker

Signature

allowMultiple: boolean;

defaultStat property

Default stats to be use in the stats picker

Signature

defaultStat?: string;

StringFieldConfigSettings

Sat, 04 Apr 2026 12:26:57 +0000

StringFieldConfigSettings interface

Signature

export interface StringFieldConfigSettings

Import

import { StringFieldConfigSettings } from '@grafana/data';

Properties

Property	Type	Description
expandTemplateVars	`boolean`
maxLength	`number`
placeholder	`string`
rows	`number`
useTextarea	`boolean`

expandTemplateVars property

Signature

expandTemplateVars?: boolean;

maxLength property

Signature

maxLength?: number;

placeholder property

Signature

placeholder?: string;

rows property

Signature

rows?: number;

useTextarea property

Signature

useTextarea?: boolean;

stringFormater

Sat, 04 Apr 2026 12:26:57 +0000

stringFormater() function

Signature

export declare function stringFormater(value: number): FormattedValue;

Import

import { stringFormater } from '@grafana/data';

Parameters

Parameter	Type	Description
value	`number`

Returns:

FormattedValue

stringOverrideProcessor

Sat, 04 Apr 2026 12:26:57 +0000

stringOverrideProcessor variable

Signature

stringOverrideProcessor: (value: any, context: FieldOverrideContext, settings?: StringFieldConfigSettings | undefined) => any

Import

import { stringOverrideProcessor } from '@grafana/data';

stringStartsAsRegEx

Sat, 04 Apr 2026 12:26:57 +0000

stringStartsAsRegEx() function

Signature

export declare function stringStartsAsRegEx(str: string): boolean;

Import

import { stringStartsAsRegEx } from '@grafana/data';

Parameters

Parameter	Type	Description
str	`string`

Returns:

boolean

stringToJsRegex

Sat, 04 Apr 2026 12:26:57 +0000

stringToJsRegex() function

Signature

export declare function stringToJsRegex(str: string): RegExp;

Import

import { stringToJsRegex } from '@grafana/data';

Parameters

Parameter	Type	Description
str	`string`

Returns:

RegExp

stringToMs

Sat, 04 Apr 2026 12:26:57 +0000

stringToMs() function

Signature

export declare function stringToMs(str: string): number;

Import

import { stringToMs } from '@grafana/data';

Parameters

Parameter	Type	Description
str	`string`

Returns:

number

SynchronousDataTransformerInfo

Sat, 04 Apr 2026 12:26:57 +0000

SynchronousDataTransformerInfo interface

Many transformations can be called with a simple synchronous function. When a transformer is defined, it should have identical behavior to using the operator

Signature

export interface SynchronousDataTransformerInfo<TOptions = any> extends DataTransformerInfo<TOptions>

Import

import { SynchronousDataTransformerInfo } from '@grafana/data';

Properties

Property	Type	Description
transformer	`(options: TOptions) => (frames: DataFrame[]) => DataFrame[]`

transformer property

Signature

transformer: (options: TOptions) => (frames: DataFrame[]) => DataFrame[];

systemDateFormats

Sat, 04 Apr 2026 12:26:57 +0000

systemDateFormats variable

Signature

systemDateFormats: SystemDateFormatsState

Import

import { systemDateFormats } from '@grafana/data';

SystemDateFormatSettings

Sat, 04 Apr 2026 12:26:57 +0000

SystemDateFormatSettings interface

Signature

export interface SystemDateFormatSettings

Import

import { SystemDateFormatSettings } from '@grafana/data';

Properties

Property	Type	Description
fullDate	`string`
interval	`{` `second: string;` `minute: string;` `hour: string;` `day: string;` `month: string;` `year: string;` `}`
useBrowserLocale	`boolean`

fullDate property

Signature

fullDate: string;

interval property

Signature

interval: {
        second: string;
        minute: string;
        hour: string;
        day: string;
        month: string;
        year: string;
    };

useBrowserLocale property

Signature

useBrowserLocale: boolean;

SystemDateFormatsState

Sat, 04 Apr 2026 12:26:57 +0000

SystemDateFormatsState class

Signature

export declare class SystemDateFormatsState

Import

import { SystemDateFormatsState } from '@grafana/data';

Properties

Property	Modifiers	Type	Description
fullDate		`string`
fullDateMS		`string`
interval		`{` `second: string;` `minute: string;` `hour: string;` `day: string;` `month: string;` `year: string;` `}`

Methods

Method	Modifiers	Description
getTimeFieldUnit(useMsResolution)
update(settings)
useBrowserLocale()

fullDate property

Signature

fullDate: string;

fullDateMS property

Signature

get fullDateMS(): string;

interval property

Signature

interval: {
        second: string;
        minute: string;
        hour: string;
        day: string;
        month: string;
        year: string;
    };

getTimeFieldUnit method

Signature

getTimeFieldUnit(useMsResolution?: boolean): string;

Parameters

Parameter	Type	Description
useMsResolution	`boolean`

Returns:

string

update method

Signature

update(settings: SystemDateFormatSettings): void;

Parameters

Parameter	Type	Description
settings	`SystemDateFormatSettings`

Returns:

void

useBrowserLocale method

Signature

useBrowserLocale(): void;

Returns:

void

TableData

Sat, 04 Apr 2026 12:26:57 +0000

TableData interface

Signature

export interface TableData extends QueryResultBase

Import

import { TableData } from '@grafana/data';

Properties

Property	Type	Description
columns	`Column[]`
name	`string`
rows	`any[][]`
type	`string`

columns property

Signature

columns: Column[];

name property

Signature

name?: string;

rows property

Signature

rows: any[][];

type property

Signature

type?: string;

TextMatch

Sat, 04 Apr 2026 12:26:57 +0000

TextMatch interface

Signature

export interface TextMatch

Import

import { TextMatch } from '@grafana/data';

Properties

Property	Type	Description
end	`number`
length	`number`
start	`number`
text	`string`

end property

Signature

end: number;

length property

Signature

length: number;

start property

Signature

start: number;

text property

Signature

text: string;

textUtil

Sat, 04 Apr 2026 12:26:57 +0000

textUtil variable

Signature

textUtil: {
    escapeHtml: typeof escapeHtml;
    hasAnsiCodes: typeof hasAnsiCodes;
    sanitize: typeof sanitize;
    sanitizeTextPanelContent: typeof sanitizeTextPanelContent;
    sanitizeUrl: typeof sanitizeUrl;
}

Import

import { textUtil } from '@grafana/data';

ThemeBreakpoints

Sat, 04 Apr 2026 12:26:57 +0000

ThemeBreakpoints interface

Signature

export interface ThemeBreakpoints

Import

import { ThemeBreakpoints } from '@grafana/data';

Properties

Property	Type	Description
down	`(key: ThemeBreakpointsKey) => string`	*(BETA)*
keys	`string[]`	*(BETA)*
unit	`string`	*(BETA)*
up	`(key: ThemeBreakpointsKey) => string`	*(BETA)*
values	`ThemeBreakpointValues`	*(BETA)*

down property

Signature

down: (key: ThemeBreakpointsKey) => string;

keys property

Signature

keys: string[];

unit property

Signature

unit: string;

up property

Signature

up: (key: ThemeBreakpointsKey) => string;

values property

Signature

values: ThemeBreakpointValues;

ThemeBreakpointsKey

Sat, 04 Apr 2026 12:26:57 +0000

ThemeBreakpointsKey type

ThemeBreakpointsKey type

Signature

export declare type ThemeBreakpointsKey = keyof ThemeBreakpointValues;

Import

import { ThemeBreakpointsKey } from '@grafana/data';

ThemeColors

Sat, 04 Apr 2026 12:26:57 +0000

ThemeColors interface

Signature

export interface ThemeColors extends ThemeColorsBase<ThemeRichColor>

Import

import { ThemeColors } from '@grafana/data';

Methods

Method	Description
emphasize(color, amount)	*(BETA)*
getContrastText(background, threshold)	*(BETA)* Returns a text color for the background

emphasize method

Signature

emphasize(color: string, amount?: number): string;

Parameters

Parameter	Type	Description
color	`string`
amount	`number`

Returns:

string

getContrastText method

Returns a text color for the background

Signature

getContrastText(background: string, threshold?: number): string;

Parameters

Parameter	Type	Description
background	`string`
threshold	`number`

Returns:

string

@grafana/data on Grafana Labs

AbsoluteTimeRange

AbsoluteTimeRange interface

from property

to property

addDurationToDate

addDurationToDate() function

addDurationToDate() function

addLogLevelToSeries

addLogLevelToSeries() function

addLogLevelToSeries() function

AlertErrorPayload

AlertErrorPayload type

AlertErrorPayload type

AlertPayload

AlertPayload type

AlertPayload type

alpha

colorManipulator.alpha() function

colorManipulator.alpha() function

AnnotationEvent

AnnotationEvent interface

alertId property

annotation property

avatarUrl property

color property

dashboardId property

email property

id property

isRegion property

login property

newState property

panelId property

source property

tags property

text property

time property

timeEnd property

title property

type property

userId property

AnnotationEventFieldMapping

AnnotationEventFieldMapping interface

regex property

source property

value property

AnnotationEventMappings

AnnotationEventMappings type

AnnotationEventMappings type

AnnotationEventUIModel

AnnotationEventUIModel interface

description property

from property

id property

tags property

to property

AnnotationQuery

AnnotationQuery interface

builtIn property

datasource property

enable property

hide property

iconColor property

mappings property

name property

snapshotData property

target property

type property

AnnotationQueryRequest

AnnotationQueryRequest interface

annotation property

dashboard property

range property

rangeRaw property

AnnotationSupport

AnnotationSupport interface

QueryEditor property

prepareAnnotation method

prepareQuery method

processEvents method