@grafana/plugin-ui 0.1.10

package/dist/src/components/QueryEditor/types.d.ts

@@ -0,0 +1,149 @@
+import { JsonTree } from 'react-awesome-query-builder';
+import { DataFrame, DataQuery, DataSourceJsonData, MetricFindValue, SelectableValue, TimeRange } from '@grafana/data';
+import { QueryWithDefaults } from './defaults';
+import { QueryEditorFunctionExpression, QueryEditorGroupByExpression, QueryEditorPropertyExpression } from './expressions';
+import { CompletionItemKind, LanguageCompletionProvider } from '@grafana/experimental';
+export interface SqlQueryForInterpolation {
+    dataset?: string;
+    alias?: string;
+    format?: QueryFormat;
+    rawSql?: string;
+    refId: string;
+    hide?: boolean;
+}
+export interface SQLConnectionLimits {
+    maxOpenConns: number;
+    maxIdleConns: number;
+    connMaxLifetime: number;
+}
+export interface SQLOptions extends SQLConnectionLimits, DataSourceJsonData {
+    tlsAuth: boolean;
+    tlsAuthWithCACert: boolean;
+    timezone: string;
+    tlsSkipVerify: boolean;
+    user: string;
+    database: string;
+    url: string;
+    timeInterval: string;
+}
+export declare enum QueryFormat {
+    Timeseries = "time_series",
+    Table = "table"
+}
+export declare enum EditorMode {
+    Builder = "builder",
+    Code = "code"
+}
+export interface SQLQuery extends DataQuery {
+    alias?: string;
+    format?: QueryFormat;
+    rawSql?: string;
+    dataset?: string;
+    table?: string;
+    sql?: SQLExpression;
+    editorMode?: EditorMode;
+    rawQuery?: boolean;
+}
+export interface NameValue {
+    name: string;
+    value: string;
+}
+export declare type SQLFilters = NameValue[];
+export interface SQLExpression {
+    columns?: QueryEditorFunctionExpression[];
+    whereJsonTree?: JsonTree;
+    whereString?: string;
+    filters?: SQLFilters;
+    groupBy?: QueryEditorGroupByExpression[];
+    orderBy?: QueryEditorPropertyExpression;
+    orderByDirection?: 'ASC' | 'DESC';
+    limit?: number;
+    offset?: number;
+}
+export interface TableSchema {
+    name?: string;
+    schema?: TableFieldSchema[];
+}
+export interface TableFieldSchema {
+    name: string;
+    description?: string;
+    type: string;
+    repeated: boolean;
+    schema: TableFieldSchema[];
+}
+export interface QueryRowFilter {
+    filter: boolean;
+    group: boolean;
+    order: boolean;
+    preview: boolean;
+}
+export declare const QUERY_FORMAT_OPTIONS: {
+    label: string;
+    value: QueryFormat;
+}[];
+export declare const toOption: (value: string) => SelectableValue<string>;
+export interface ResourceSelectorProps {
+    disabled?: boolean;
+    className?: string;
+    applyDefault?: boolean;
+}
+export declare type RAQBFieldTypes = 'text' | 'number' | 'boolean' | 'datetime' | 'date' | 'time';
+export interface SQLSelectableValue extends SelectableValue {
+    type?: string;
+    raqbFieldType?: RAQBFieldTypes;
+}
+export interface Aggregate {
+    id: string;
+    name: string;
+    description?: string;
+}
+export interface DB {
+    init?: (datasourceId?: string) => Promise<boolean>;
+    datasets: () => Promise<string[]>;
+    tables: (dataset?: string) => Promise<string[]>;
+    fields: (query: SQLQuery, order?: boolean) => Promise<SQLSelectableValue[]>;
+    validateQuery: (query: SQLQuery, range?: TimeRange) => Promise<ValidationResults>;
+    dsID: () => number;
+    dispose?: (dsID?: string) => void;
+    lookup: (path?: string) => Promise<Array<{
+        name: string;
+        completion: string;
+    }>>;
+    getSqlCompletionProvider: () => LanguageCompletionProvider;
+    toRawSql?: (query: SQLQuery) => string;
+    functions: () => Promise<Aggregate[]>;
+    labels: Map<string, string>;
+}
+export interface QueryEditorProps {
+    db: DB;
+    query: QueryWithDefaults;
+    onChange: (query: SQLQuery) => void;
+    range?: TimeRange;
+}
+export interface ValidationResults {
+    query: SQLQuery;
+    rawSql?: string;
+    error: string;
+    isError: boolean;
+    isValid: boolean;
+    statistics?: {
+        TotalBytesProcessed: number;
+    } | null;
+}
+export interface SqlQueryModel {
+    interpolate: () => string;
+    quoteLiteral: (v: string) => string;
+}
+export interface ResponseParser {
+    transformMetricFindResponse: (frame: DataFrame) => MetricFindValue[];
+}
+export interface MetaDefinition {
+    name: string;
+    completion?: string;
+    kind: CompletionItemKind;
+}
+export interface SQLConnectionLimits {
+    maxOpenConns: number;
+    maxIdleConns: number;
+    connMaxLifetime: number;
+}

package/dist/src/components/QueryEditor/utils/formatSQL.d.ts

@@ -0,0 +1 @@
+export declare function formatSQL(q: string): any;

package/dist/src/components/QueryEditor/utils/sql.utils.d.ts

@@ -0,0 +1,13 @@
+import { QueryEditorFunctionExpression, QueryEditorGroupByExpression, QueryEditorPropertyExpression } from '../expressions';
+import { SQLQuery, SQLExpression } from '../types';
+export declare function defaultToRawSql({ sql, dataset, table }: SQLQuery): string;
+export declare const haveColumns: (columns: SQLExpression['columns']) => columns is QueryEditorFunctionExpression[];
+/**
+ * Creates a GroupByExpression for a specified field
+ */
+export declare function setGroupByField(field?: string): QueryEditorGroupByExpression;
+/**
+ * Creates a PropertyExpression for a specified field
+ */
+export declare function setPropertyField(field?: string): QueryEditorPropertyExpression;
+export declare function createFunctionField(functionName?: string): QueryEditorFunctionExpression;

package/dist/src/components/QueryEditor/utils/useSqlChange.d.ts

@@ -0,0 +1,10 @@
+import { DB, SQLExpression, SQLQuery } from '../types';
+interface UseSqlChange {
+    db: DB;
+    query: SQLQuery;
+    onQueryChange: (query: SQLQuery) => void;
+}
+export declare function useSqlChange({ query, onQueryChange, db }: UseSqlChange): {
+    onSqlChange: (sql: SQLExpression) => void;
+};
+export {};

package/dist/src/components/QueryEditor/visual-query-builder/AwesomeQueryBuilder.d.ts

@@ -0,0 +1,7 @@
+import { Config, JsonItem, JsonTree, Settings, Widgets } from 'react-awesome-query-builder';
+export declare const emptyInitValue: JsonItem;
+export declare const emptyInitTree: JsonTree;
+export declare const widgets: Widgets;
+export declare const settings: Settings;
+export declare const raqbConfig: Config;
+export type { Config };

package/dist/src/components/QueryEditor/visual-query-builder/EditorField.d.ts

@@ -0,0 +1,11 @@
+import React, { ComponentProps } from 'react';
+import { Field, PopoverContent } from '@grafana/ui';
+interface EditorFieldProps extends ComponentProps<typeof Field> {
+    label: string;
+    children: React.ReactElement;
+    width?: number | string;
+    optional?: boolean;
+    tooltip?: PopoverContent;
+}
+export declare const EditorField: React.FC<EditorFieldProps>;
+export {};

package/dist/src/components/QueryEditor/visual-query-builder/EditorRow.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+interface EditorRowProps {
+}
+export declare const EditorRow: React.FC<EditorRowProps>;
+export {};

package/dist/src/components/QueryEditor/visual-query-builder/EditorRows.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+interface EditorRowsProps {
+}
+export declare const EditorRows: React.FC<EditorRowsProps>;
+export {};

package/dist/src/components/QueryEditor/visual-query-builder/GroupByRow.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { SelectableValue } from '@grafana/data';
+import { SQLExpression } from '../types';
+interface GroupByRowProps {
+    sql: SQLExpression;
+    onSqlChange: (sql: SQLExpression) => void;
+    columns?: Array<SelectableValue<string>>;
+}
+export declare function GroupByRow({ sql, columns, onSqlChange }: GroupByRowProps): JSX.Element;
+export {};

package/dist/src/components/QueryEditor/visual-query-builder/OrderByRow.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import { SelectableValue } from '@grafana/data';
+import { SQLExpression } from '../types';
+declare type OrderByRowProps = {
+    sql: SQLExpression;
+    onSqlChange: (sql: SQLExpression) => void;
+    columns?: Array<SelectableValue<string>>;
+    showOffset?: boolean;
+};
+export declare function OrderByRow({ sql, onSqlChange, columns, showOffset }: OrderByRowProps): JSX.Element;
+export {};

package/dist/src/components/QueryEditor/visual-query-builder/Preview.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+declare type PreviewProps = {
+    rawSql: string;
+};
+export declare function Preview({ rawSql }: PreviewProps): JSX.Element;
+export {};

package/dist/src/components/QueryEditor/visual-query-builder/SQLGroupByRow.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import { SelectableValue } from '@grafana/data';
+import { QueryWithDefaults } from '../defaults';
+import { SQLQuery, DB } from '../types';
+interface SQLGroupByRowProps {
+    fields: SelectableValue[];
+    query: QueryWithDefaults;
+    onQueryChange: (query: SQLQuery) => void;
+    db: DB;
+}
+export declare function SQLGroupByRow({ fields, query, onQueryChange, db }: SQLGroupByRowProps): JSX.Element;
+export {};

package/dist/src/components/QueryEditor/visual-query-builder/SQLOrderByRow.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import { SelectableValue } from '@grafana/data';
+import { QueryWithDefaults } from '../defaults';
+import { SQLQuery, DB } from '../types';
+declare type SQLOrderByRowProps = {
+    fields: SelectableValue[];
+    query: QueryWithDefaults;
+    onQueryChange: (query: SQLQuery) => void;
+    db: DB;
+};
+export declare function SQLOrderByRow({ fields, query, onQueryChange, db }: SQLOrderByRowProps): JSX.Element;
+export {};

package/dist/src/components/QueryEditor/visual-query-builder/SQLSelectRow.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import { SelectableValue } from '@grafana/data';
+import { QueryWithDefaults } from '../defaults';
+import { SQLQuery, DB } from '../types';
+interface SQLSelectRowProps {
+    fields: SelectableValue[];
+    query: QueryWithDefaults;
+    onQueryChange: (query: SQLQuery) => void;
+    db: DB;
+}
+export declare function SQLSelectRow({ fields, query, onQueryChange, db }: SQLSelectRowProps): JSX.Element;
+export {};

package/dist/src/components/QueryEditor/visual-query-builder/SQLWhereRow.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import { SelectableValue } from '@grafana/data';
+import { QueryWithDefaults } from '../defaults';
+import { SQLQuery, DB } from '../types';
+interface WhereRowProps {
+    query: QueryWithDefaults;
+    fields: SelectableValue[];
+    onQueryChange: (query: SQLQuery) => void;
+    db: DB;
+}
+export declare function SQLWhereRow({ query, fields, onQueryChange, db }: WhereRowProps): JSX.Element;
+export {};

package/dist/src/components/QueryEditor/visual-query-builder/SelectRow.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import { SelectableValue } from '@grafana/data';
+import { SQLExpression } from '../types';
+interface SelectRowProps {
+    sql: SQLExpression;
+    onSqlChange: (sql: SQLExpression) => void;
+    columns?: Array<SelectableValue<string>>;
+    functions?: Array<SelectableValue<string>>;
+}
+export declare function SelectRow({ sql, columns, onSqlChange, functions }: SelectRowProps): JSX.Element;
+export {};

package/dist/src/components/QueryEditor/visual-query-builder/Stack.d.ts

@@ -0,0 +1,9 @@
+import React, { CSSProperties } from 'react';
+interface StackProps {
+    direction?: CSSProperties['flexDirection'];
+    alignItems?: CSSProperties['alignItems'];
+    wrap?: boolean;
+    gap?: number;
+}
+export declare const Stack: React.FC<StackProps>;
+export {};

package/dist/src/components/QueryEditor/visual-query-builder/VisualEditor.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { DB, QueryEditorProps, QueryRowFilter } from '../types';
+import { SQLQuery } from '../types';
+import { TimeRange } from '@grafana/data';
+interface VisualEditorProps extends QueryEditorProps {
+    query: SQLQuery;
+    db: DB;
+    queryRowFilter: QueryRowFilter;
+    onChange: (q: SQLQuery) => void;
+    onValidate: (isValid: boolean) => void;
+    range?: TimeRange;
+}
+export declare const VisualEditor: React.FC<VisualEditorProps>;
+export {};

package/dist/src/components/QueryEditor/visual-query-builder/WhereRow.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { Config } from 'react-awesome-query-builder';
+import { SQLExpression } from '../types';
+interface SQLBuilderWhereRowProps {
+    sql: SQLExpression;
+    onSqlChange: (sql: SQLExpression) => void;
+    config?: Partial<Config>;
+}
+export declare function WhereRow({ sql, config, onSqlChange }: SQLBuilderWhereRowProps): JSX.Element | null;
+export {};

package/dist/src/components/QueryEditor/visual-query-builder/index.d.ts

@@ -0,0 +1 @@
+export { GroupByRow } from './GroupByRow';

package/dist/src/components/QueryEditorRow/QueryEditorRow.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+export interface QueryEditorRowProps {
+    label?: string;
+    className?: string;
+    noFillEnd?: boolean;
+    children?: React.ReactNode;
+}
+export declare const QueryEditorRow: (props: QueryEditorRowProps) => JSX.Element;

package/dist/src/components/Segment/Segment.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { SegmentSyncProps as GrafanaSegmentProps } from '@grafana/ui/components/Segment/Segment';
+export interface SegmentProps<T> extends Omit<GrafanaSegmentProps<T>, 'onChange'> {
+    value: T;
+    onDebounce: (debouncedSegment?: T) => void;
+    delay?: number;
+}
+export declare function Segment<T>(props: SegmentProps<T>): JSX.Element;

package/dist/src/components/index.d.ts

@@ -0,0 +1,11 @@
+export { AsyncButtonCascader } from './AsyncButtonCascader/AsyncButtonCascader';
+export { QueryEditorRow } from './QueryEditorRow/QueryEditorRow';
+export { DebounceInput, DebounceInputProps, } from './DebounceInput/DebounceInput';
+export { Segment, SegmentProps, } from './Segment/Segment';
+export { DatePicker, DatePickerProps } from './DatePicker/DatePicker';
+export { DatePickerWithInput, DatePickerWithInputProps, formatDate, } from './DatePickerWithInput/DatePickerWithInput';
+export * from './DataSourcePicker/DataSourcePicker';
+export * from './DataLinks';
+export * from './Cascader/Cascader';
+export { InlineSwitch, CertificationKey } from '@grafana/ui';
+export * from './QueryEditor';

package/dist/src/datasource/SqlDatasource.d.ts

@@ -0,0 +1,64 @@
+import { DataFrameView, DataSourceInstanceSettings, DataSourceRef, MetricFindValue, ScopedVars, TimeRange, VariableModel } from '@grafana/data';
+import { DataSourceWithBackend, TemplateSrv } from '@grafana/runtime';
+import { SQLQuery, SQLOptions, DB, SqlQueryModel, ResponseParser } from '../components/QueryEditor/types';
+export interface SearchFilterOptions {
+    searchFilter?: string;
+}
+export interface VariableWithMultiSupport extends VariableWithOptions {
+    multi: boolean;
+    includeAll: boolean;
+    allValue?: string | null;
+}
+export interface VariableWithOptions extends VariableModel {
+    current: VariableOption;
+    options: VariableOption[];
+    query: string;
+}
+export interface VariableOption {
+    selected: boolean;
+    text: string | string[];
+    value: string | string[];
+    isNone?: boolean;
+}
+export declare abstract class SqlDatasource extends DataSourceWithBackend<SQLQuery, SQLOptions> {
+    protected readonly templateSrv: TemplateSrv;
+    id: number;
+    name: string;
+    interval: string;
+    db: DB;
+    annotations: {};
+    constructor(instanceSettings: DataSourceInstanceSettings<SQLOptions>, templateSrv?: TemplateSrv);
+    abstract getDB(dsID?: number): DB;
+    abstract getQueryModel(target?: SQLQuery, templateSrv?: TemplateSrv, scopedVars?: ScopedVars): SqlQueryModel;
+    abstract getResponseParser(): ResponseParser;
+    interpolateVariable: (value: string | string[] | number, variable: VariableWithMultiSupport) => string | number;
+    interpolateVariablesInQueries(queries: SQLQuery[], scopedVars: ScopedVars): SQLQuery[];
+    filterQuery(query: SQLQuery): boolean;
+    applyTemplateVariables(target: SQLQuery, scopedVars: ScopedVars): Record<string, string | DataSourceRef | SQLQuery['format']>;
+    clean(value: string): string;
+    metricFindQuery(query: string, optionalOptions?: MetricFindQueryOptions): Promise<MetricFindValue[]>;
+    runSql<T>(query: string, options?: RunSQLOptions): Promise<DataFrameView<T>>;
+    private runMetaQuery;
+    testDatasource(): Promise<{
+        status: string;
+        message: string;
+    }>;
+    targetContainsTemplate(target: SQLQuery): boolean;
+}
+interface RunSQLOptions extends MetricFindQueryOptions {
+    refId?: string;
+}
+interface MetricFindQueryOptions extends SearchFilterOptions {
+    range?: TimeRange;
+}
+export declare const SEARCH_FILTER_VARIABLE = "__searchFilter";
+export declare const containsSearchFilter: (query: string | unknown) => boolean;
+export interface SearchFilterOptions {
+    searchFilter?: string;
+}
+export declare const getSearchFilterScopedVar: (args: {
+    query: string;
+    wildcardChar: string;
+    options?: SearchFilterOptions;
+}) => ScopedVars;
+export {};

package/dist/src/datasource/constants.d.ts

@@ -0,0 +1 @@
+export declare const MACRO_NAMES: string[];

package/dist/src/hooks/useDebounce.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_DELAY = 275;
+export declare const useDebounce: <T>(value: T, delay?: number) => T;

package/dist/src/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * A library containing the different design components of the Grafana plugins ecosystem.
+ *
+ * @packageDocumentation
+ */
+export * from './components';
+export * from './unreleasedComponents';
+export * from './test/mocks';
+export * from './utils';
+export { SqlDatasource } from './datasource/SqlDatasource';
+export { selectOption, generateOptions } from './8x';

package/dist/src/test/mocks/DataQuery.d.ts

@@ -0,0 +1,2 @@
+import { DataQuery } from '@grafana/data';
+export declare const mockDataQuery: () => DataQuery;

package/dist/src/test/mocks/Datasource.d.ts

@@ -0,0 +1,4 @@
+import { DataSourceInstanceSettings } from '@grafana/data';
+import { DataSourceWithBackend } from '@grafana/runtime';
+export declare const mockDatasource: () => DataSourceWithBackend;
+export declare const mockDatasourceInstanceSettings: () => DataSourceInstanceSettings;

package/dist/src/test/mocks/Plugin.d.ts

@@ -0,0 +1,10 @@
+import { DataSourcePluginMeta, PluginMetaInfo, PluginMeta, PluginState, PluginSignatureStatus, PluginInclude, PluginIncludeType, PluginDependencies, PluginType } from '@grafana/data';
+export declare const mockDataSourcePluginMeta: () => DataSourcePluginMeta;
+export declare const mockPluginMetaInfo: () => PluginMetaInfo;
+export declare const mockPluginMeta: () => PluginMeta;
+export declare const mockPluginInclude: () => PluginInclude;
+export declare const mockPluginType: () => PluginType;
+export declare const mockPluginIncludeType: () => PluginIncludeType;
+export declare const mockPluginState: () => PluginState;
+export declare const mockPluginDependencies: () => PluginDependencies;
+export declare const mockPluginSignatureStatus: () => PluginSignatureStatus;

package/dist/src/test/mocks/QueryEditorProps.d.ts

@@ -0,0 +1,4 @@
+import { QueryEditorProps, LoadingState, TimeRange } from '@grafana/data';
+export declare const mockQueryEditorProps: () => QueryEditorProps<any, any, any>;
+export declare const mockLoadingState: () => LoadingState;
+export declare const mockTimeRange: () => TimeRange;

package/dist/src/test/mocks/TestDatasource.d.ts

@@ -0,0 +1,6 @@
+import { HealthCheckResult } from "@grafana/runtime";
+import { HealthCheckError, HealthCheckResultDetails, TestDatasourceReturn } from "../../utils/testDatasource";
+export declare const mockTestDatasourceReturn: () => TestDatasourceReturn;
+export declare const mockHealthCheckResult: () => HealthCheckResult;
+export declare const mockHealthCheckDetails: () => HealthCheckResultDetails;
+export declare const mockHealthCheckResultError: (details?: HealthCheckResultDetails) => HealthCheckError;

package/dist/src/test/mocks/index.d.ts

@@ -0,0 +1,5 @@
+export * from './Datasource';
+export * from './DataQuery';
+export * from './Plugin';
+export * from './QueryEditorProps';
+export * from './utils';

package/dist/src/test/mocks/style.d.ts

@@ -0,0 +1 @@
+export declare const style = "style";

package/dist/src/test/mocks/utils.d.ts

@@ -0,0 +1,18 @@
+export declare const generateBoolean: () => boolean;
+export declare const undefinedOr: (fn: Function) => any;
+export declare const generateArrayOf: (fn: Function, numberOf?: number) => any[];
+/**
+ * Opens a Select or MultiSelect dropdown
+ *
+ * @param {HTMLElement} container The container wrapping the Select or MultiSelect component
+ * @param {string} optionLabel The option text we want to type or search
+ */
+export declare const openSelect: (container: HTMLElement, optionLabel?: string) => void;
+/**
+ * Selects an option from the Select or MultiSelect component
+ *
+ * @param {HTMLElement} container The container wrapping the Select or MultiSelect component
+ * @param {string} optionLabel The option we want to select
+ * @param {boolean} [typeOptionLabel=false] If we should type the optional label after opening - this is useful for AsyncSelect
+ */
+export declare const selectOption: (container: HTMLElement, optionLabel: string, typeOptionLabel?: boolean) => Promise<void>;

package/dist/src/test/setupTests.d.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom';

package/dist/src/unreleasedComponents/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/utils/compatFeatures.d.ts

@@ -0,0 +1,9 @@
+import { BaseTestDatasource, TestDatasourceReturn } from "./testDatasource";
+/**
+ * Calls the override testDatasource function for backwards compatibility if needed.
+ *
+ * @param baseTestDatasource The original testDatasource function
+ * @param toggle Accepts a feature toggle. Defaults to false so it is clear when we want this feature turned on.
+ * @returns The result in the expected format for the Grafana version
+ */
+export declare const healthDiagnosticsErrorsCompat: (baseTestDatasource: BaseTestDatasource, toggle?: boolean) => Promise<TestDatasourceReturn>;

package/dist/src/utils/compatibility.d.ts

@@ -0,0 +1,12 @@
+export declare enum CompatibilityFeature {
+    HEALTH_DIAGNOSTICS_ERRORS = 0
+}
+/**
+ * Checks if the currently running version of Grafana supports the feature.
+ *
+ * Enables graceful degradation for earlier versions that don't support a given capability.
+ *
+ * @param feature The feature that requires backwards compatibility
+ * @returns True if the Grafana version running can support the feature, otherwise false
+ */
+export declare const hasCompatibility: (feature: CompatibilityFeature) => boolean;

package/dist/src/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./compatibility";
+export * from "./compatFeatures";
+export * as compatFeatures from "./compatFeatures";

package/dist/src/utils/testDatasource.d.ts

@@ -0,0 +1,19 @@
+import { HealthCheckResult } from '@grafana/runtime';
+export declare type HealthCheckResultDetails = Record<string, any> | undefined;
+export declare class HealthCheckError extends Error {
+    details: HealthCheckResultDetails;
+    constructor(message: string, details: HealthCheckResultDetails);
+}
+export declare type TestDatasourceReturn = Partial<HealthCheckResult> | Error;
+export declare type BaseTestDatasource = () => Promise<TestDatasourceReturn>;
+/**
+ * Override function for testDatasource in Grafana for the health check
+ *
+ * There is a new error format that is introduced in Grafana 8 which is not backwards compatible by default
+ *
+ * This transforms the health check result into the old format if Grafana <8 is being used
+ *
+ * @param baseTestDatasource The original testDatasource function
+ * @returns Either the health check result if the health check was successful or an error that is handled later by Grafana
+ */
+export declare const testDatasource: (baseTestDatasource: BaseTestDatasource) => Promise<TestDatasourceReturn>;

package/dist/test/mocks/DataQuery.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mockDataQuery = void 0;
+const chance_1 = require("chance");
+const utils_1 = require("./utils");
+const mockDataQuery = () => ({
+    refId: (0, chance_1.Chance)().word(),
+    hide: false,
+    key: (0, chance_1.Chance)().guid(),
+    queryType: (0, chance_1.Chance)().word(),
+    datasource: (0, utils_1.undefinedOr)(() => (0, chance_1.Chance)().word()),
+});
+exports.mockDataQuery = mockDataQuery;
+//# sourceMappingURL=DataQuery.js.map

package/dist/test/mocks/DataQuery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DataQuery.js","sourceRoot":"","sources":["../../../src/test/mocks/DataQuery.ts"],"names":[],"mappings":";;;AACA,mCAAgC;AAChC,mCAAsC;AAE/B,MAAM,aAAa,GAAG,GAAc,EAAE,CAAC,CAAC;IAC7C,KAAK,EAAE,IAAA,eAAM,GAAE,CAAC,IAAI,EAAE;IACtB,IAAI,EAAE,KAAK;IACX,GAAG,EAAE,IAAA,eAAM,GAAE,CAAC,IAAI,EAAE;IACpB,SAAS,EAAE,IAAA,eAAM,GAAE,CAAC,IAAI,EAAE;IAC1B,UAAU,EAAE,IAAA,mBAAW,EAAC,GAAG,EAAE,CAAC,IAAA,eAAM,GAAE,CAAC,IAAI,EAAE,CAAC;CAC/C,CAAC,CAAC;AANU,QAAA,aAAa,iBAMvB"}