@grafana/plugin-ui 0.8.0 → 0.9.0

package/dist/src/components/SQLEditor/mocks/queries/singleLineFullQuery.d.ts

@@ -0,0 +1,2 @@
+import { TestQueryModel } from '../../test-utils/types';
+export declare const singleLineFullQuery: TestQueryModel;

package/dist/src/components/SQLEditor/mocks/queries/singleLineFullQueryWithAggregation.d.ts

@@ -0,0 +1,2 @@
+import { TestQueryModel } from '../../test-utils/types';
+export declare const singleLineFullQueryWithAggregation: TestQueryModel;

package/dist/src/components/SQLEditor/mocks/queries/singleLineMultipleColumns.d.ts

@@ -0,0 +1,2 @@
+import { TestQueryModel } from '../../test-utils/types';
+export declare const singleLineMultipleColumns: TestQueryModel;

package/dist/src/components/SQLEditor/mocks/queries/singleLineTwoQueries.d.ts

@@ -0,0 +1,2 @@
+import { TestQueryModel } from '../../test-utils/types';
+export declare const singleLineTwoQueries: TestQueryModel;

package/dist/src/components/SQLEditor/mocks/queries/singleLineTwoQueriesWithAggregation.d.ts

@@ -0,0 +1,2 @@
+import { TestQueryModel } from '../../test-utils/types';
+export declare const singleLineTwoQueriesWithAggregation: TestQueryModel;

package/dist/src/components/SQLEditor/mocks/testData.d.ts

@@ -0,0 +1,9 @@
+export { singleLineFullQuery } from './queries/singleLineFullQuery';
+export { singleLineFullQueryWithAggregation } from './queries/singleLineFullQueryWithAggregation';
+export { multiLineFullQuery } from './queries/multiLineFullQuery';
+export { multiLineFullQueryWithAggregation } from './queries/multiLineFullQueryWithAggregation';
+export { singleLineEmptyQuery } from './queries/singleLineEmptyQuery';
+export { singleLineTwoQueries } from './queries/singleLineTwoQueries';
+export { singleLineTwoQueriesWithAggregation } from './queries/singleLineTwoQueriesWithAggregation';
+export { singleLineMultipleColumns } from './queries/singleLineMultipleColumns';
+export { multiLineMultipleColumns } from './queries/multiLineMultipleColumns';

package/dist/src/components/SQLEditor/standardSql/definition.d.ts

@@ -0,0 +1,3 @@
+import { LanguageDefinition } from '../components/SQLEditor';
+declare const standardSQLLanguageDefinition: LanguageDefinition;
+export default standardSQLLanguageDefinition;

package/dist/src/components/SQLEditor/standardSql/getStandardSuggestions.d.ts

@@ -0,0 +1,6 @@
+import { Registry } from '@grafana/data';
+import { Monaco, monacoTypes } from '@grafana/ui';
+import { PositionContext, SuggestionKind } from '../types';
+import { LinkedToken } from '../utils/LinkedToken';
+import { SuggestionsRegistryItem } from './types';
+export declare const getStandardSuggestions: (monaco: Monaco, currentToken: LinkedToken | null, suggestionKinds: SuggestionKind[], positionContext: PositionContext, suggestionsRegistry: Registry<SuggestionsRegistryItem>) => Promise<monacoTypes.languages.CompletionItem[]>;

package/dist/src/components/SQLEditor/standardSql/getStatementPosition.d.ts

@@ -0,0 +1,5 @@
+import { StatementPosition } from '../types';
+import { LinkedToken } from '../utils/LinkedToken';
+import { StatementPositionResolversRegistryItem } from './types';
+import { Registry } from '@grafana/data';
+export declare function getStatementPosition(currentToken: LinkedToken | null, statementPositionResolversRegistry: Registry<StatementPositionResolversRegistryItem>): StatementPosition[];

package/dist/src/components/SQLEditor/standardSql/language.d.ts

@@ -0,0 +1,23 @@
+import { monacoTypes } from '@grafana/ui';
+import { SQLMonarchLanguage } from './types';
+export declare const SELECT = "select";
+export declare const FROM = "from";
+export declare const WHERE = "where";
+export declare const GROUP = "group";
+export declare const ORDER = "order";
+export declare const BY = "by";
+export declare const DESC = "desc";
+export declare const ASC = "asc";
+export declare const LIMIT = "limit";
+export declare const WITH = "with";
+export declare const AS = "as";
+export declare const SCHEMA = "schema";
+export declare const AND = "AND";
+export declare const OR = "OR";
+export declare const LOGICAL_OPERATORS: string[];
+export declare const EQUALS = "=";
+export declare const NOT_EQUALS = "!=";
+export declare const COMPARISON_OPERATORS: string[];
+export declare const STD_OPERATORS: string[];
+export declare const conf: monacoTypes.languages.LanguageConfiguration;
+export declare const language: SQLMonarchLanguage;

package/dist/src/components/SQLEditor/standardSql/macros.d.ts

@@ -0,0 +1,2 @@
+import { MacrosRegistryItem } from './types';
+export declare const MACROS: MacrosRegistryItem[];

package/dist/src/components/SQLEditor/standardSql/standardSQLCompletionItemProvider.d.ts

@@ -0,0 +1,4 @@
+import { Monaco } from '@grafana/ui';
+import { SQLCompletionItemProvider } from '../types';
+import { SQLMonarchLanguage } from './types';
+export declare function getStandardSQLCompletionProvider(monaco: Monaco, language: SQLMonarchLanguage): SQLCompletionItemProvider;

package/dist/src/components/SQLEditor/standardSql/standardSuggestionsRegistry.d.ts

@@ -0,0 +1,7 @@
+import { Registry } from '@grafana/data';
+import { FunctionsRegistryItem, MacrosRegistryItem, OperatorsRegistryItem, SuggestionsRegistryItem } from './types';
+/**
+ * This registry glues particular SuggestionKind with an async function that provides completion items for it.
+ * To add a new suggestion kind, SQLEditor should be configured with a provider that implements customSuggestionKinds.
+ */
+export declare const initStandardSuggestions: (functions: Registry<FunctionsRegistryItem>, operators: Registry<OperatorsRegistryItem>, macros: Registry<MacrosRegistryItem>) => () => SuggestionsRegistryItem[];

package/dist/src/components/SQLEditor/standardSql/statementPositionResolversRegistry.d.ts

@@ -0,0 +1,2 @@
+import { StatementPositionResolversRegistryItem } from './types';
+export declare function initStatementPositionResolvers(): StatementPositionResolversRegistryItem[];

package/dist/src/components/SQLEditor/standardSql/suggestionsKindRegistry.d.ts

@@ -0,0 +1,7 @@
+import { RegistryItem } from '@grafana/data';
+import { StatementPosition, SuggestionKind } from '../types';
+export interface SuggestionKindRegistryItem extends RegistryItem {
+    id: StatementPosition;
+    kind: SuggestionKind[];
+}
+export declare const initSuggestionsKindRegistry: () => SuggestionKindRegistryItem[];

package/dist/src/components/SQLEditor/standardSql/types.d.ts

@@ -0,0 +1,33 @@
+import { RegistryItem } from '@grafana/data';
+import { monacoTypes } from '@grafana/ui';
+import { CustomSuggestion, MacroType, OperatorType, PositionContext, StatementPosition, SuggestionKind } from '../types';
+import { LinkedToken } from '../utils/LinkedToken';
+export interface SuggestionsRegistryItem extends RegistryItem {
+    id: SuggestionKind;
+    suggestions: (position: PositionContext, m: typeof monacoTypes) => Promise<CustomSuggestion[]>;
+}
+export interface MacrosRegistryItem extends RegistryItem {
+    type: MacroType;
+    text: string;
+    args: string[];
+}
+export interface FunctionsRegistryItem extends RegistryItem {
+}
+export interface OperatorsRegistryItem extends RegistryItem {
+    operator: string;
+    type: OperatorType;
+}
+export type StatementPositionResolver = (currentToken: LinkedToken | null, previousKeyword: LinkedToken | null, previousNonWhiteSpace: LinkedToken | null, previousIsSlash: Boolean) => Boolean;
+export interface StatementPositionResolversRegistryItem extends RegistryItem {
+    id: StatementPosition;
+    resolve: StatementPositionResolver;
+}
+export type SuggestionsResolver = <T extends PositionContext = PositionContext>(positionContext: T) => Promise<CustomSuggestion[]>;
+export interface SQLMonarchLanguage extends monacoTypes.languages.IMonarchLanguage {
+    keywords?: string[];
+    builtinFunctions?: string[];
+    logicalOperators?: string[];
+    comparisonOperators?: string[];
+    /** Used by basic languages in the monaco registry **/
+    operators?: string[];
+}

package/dist/src/components/SQLEditor/test-utils/index.d.ts

@@ -0,0 +1,7 @@
+import * as testData from '../mocks/testData';
+import { TestQueryModel } from './types';
+export declare const SQLEditorTestUtils: {
+    testData: typeof testData;
+    testStatementPosition: (expected: string, cases: import("./types").StatementPositionResolverTestCase[], resolvers: () => import("../types").CustomStatementPlacement[]) => void;
+};
+export type { TestQueryModel };

package/dist/src/components/SQLEditor/test-utils/statementPosition.d.ts

@@ -0,0 +1,3 @@
+import { CustomStatementPlacement, StatementPosition } from '../types';
+import { StatementPositionResolverTestCase } from './types';
+export declare const testStatementPosition: (expected: StatementPosition | string, cases: StatementPositionResolverTestCase[], resolvers: () => CustomStatementPlacement[]) => void;

package/dist/src/components/SQLEditor/test-utils/types.d.ts

@@ -0,0 +1,12 @@
+import { monacoTypes } from '@grafana/ui';
+export interface TestQueryModel {
+    query: string;
+    tokens: Array<Array<Pick<monacoTypes.Token, 'language' | 'offset' | 'type'>>>;
+}
+export interface StatementPositionResolverTestCase {
+    query: TestQueryModel;
+    position: {
+        line: number;
+        column: number;
+    };
+}

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

@@ -0,0 +1,249 @@
+import { Monaco, monacoTypes } from '@grafana/ui';
+import { SQLMonarchLanguage, StatementPositionResolver, SuggestionsResolver } from './standardSql/types';
+import { LinkedToken } from './utils/LinkedToken';
+/**
+ * Provides a context for suggestions resolver
+ * @alpha
+ */
+export interface PositionContext {
+    position: monacoTypes.IPosition;
+    kind: SuggestionKind[];
+    statementPosition: StatementPosition[];
+    currentToken: LinkedToken | null;
+    range: monacoTypes.IRange;
+}
+export type CustomSuggestion = Partial<monacoTypes.languages.CompletionItem> & {
+    label: string;
+};
+export interface CustomSuggestionKind {
+    id: string;
+    suggestionsResolver: SuggestionsResolver;
+    applyTo?: Array<StatementPosition | string>;
+    overrideDefault?: boolean;
+}
+export interface CustomStatementPlacement {
+    id: string;
+    name?: string;
+    resolve: StatementPositionResolver;
+    overrideDefault?: boolean;
+}
+export type StatementPlacementProvider = () => CustomStatementPlacement[];
+export type SuggestionKindProvider = () => CustomSuggestionKind[];
+export interface ColumnDefinition {
+    name: string;
+    type?: string;
+    description?: string;
+    completion?: string;
+}
+export interface SchemaDefinition {
+    name: string;
+    completion?: string;
+}
+export interface TableDefinition {
+    name: string;
+    completion?: string;
+}
+export interface Operator {
+    id: string;
+    operator: string;
+    type: OperatorType;
+    description?: string;
+}
+export interface TableIdentifier {
+    table?: string;
+    schema?: string;
+}
+export interface SQLCompletionItemProvider extends Omit<monacoTypes.languages.CompletionItemProvider, 'provideCompletionItems'> {
+    /**
+     * Allows dialect specific functions to be added to the completion list.
+     * @alpha
+     */
+    supportedFunctions?: () => Array<{
+        id: string;
+        name: string;
+        description?: string;
+    }>;
+    /**
+     * Allows dialect specific operators to be added to the completion list.
+     * @alpha
+     */
+    supportedOperators?: () => Array<{
+        id: string;
+        operator: string;
+        type: OperatorType;
+        description?: string;
+    }>;
+    supportedMacros?: () => Array<{
+        id: string;
+        text: string;
+        type: MacroType;
+        args: string[];
+        description?: string;
+    }>;
+    /**
+     * Allows custom suggestion kinds to be defined and correlate them with <Custom>StatementPosition.
+     * @alpha
+     */
+    customSuggestionKinds?: SuggestionKindProvider;
+    /**
+     * Allows custom statement placement definition.
+     * @alpha
+     */
+    customStatementPlacement?: StatementPlacementProvider;
+    /**
+     * Allows providing a custom function for resolving schemas.
+     * It's up to the consumer to decide whether the schemas are resolved via API calls or preloaded in the query editor(i.e. full db schema is preloaded).
+     * @alpha
+     */
+    schemas?: {
+        resolve: () => Promise<SchemaDefinition[]>;
+    };
+    /**
+     * Allows providing a custom function for resolving db tables.
+     * It's up to the consumer to decide whether the columns are resolved via API calls or preloaded in the query editor(i.e. full db schema is preloaded).
+     * @alpha
+     */
+    tables?: {
+        resolve: (TableIdentifier: TableIdentifier | null) => Promise<TableDefinition[]>;
+        parseName?: (token: LinkedToken | null | undefined) => TableIdentifier;
+    };
+    /**
+     * Allows providing a custom function for resolving table.
+     * It's up to the consumer to decide whether the columns are resolved via API calls or preloaded in the query editor(i.e. full db schema is preloaded).
+     * @alpha
+     */
+    columns?: {
+        resolve: (identifier?: TableIdentifier) => Promise<ColumnDefinition[]>;
+    };
+    /**
+     * TODO: Not sure whether or not we need this. Would like to avoid this kind of flexibility.
+     * @alpha
+     */
+    provideCompletionItems?: (model: monacoTypes.editor.ITextModel, position: monacoTypes.Position, context: monacoTypes.languages.CompletionContext, token: monacoTypes.CancellationToken, positionContext: PositionContext) => monacoTypes.languages.CompletionList;
+}
+export type LanguageCompletionProvider = (m: Monaco, l?: SQLMonarchLanguage) => SQLCompletionItemProvider;
+export declare enum OperatorType {
+    Comparison = 0,
+    Logical = 1
+}
+export declare enum MacroType {
+    Value = 0,
+    Filter = 1,
+    Group = 2,
+    Column = 3,
+    Table = 4
+}
+export declare enum TokenType {
+    Parenthesis = "delimiter.parenthesis.sql",
+    Whitespace = "white.sql",
+    Keyword = "keyword.sql",
+    Delimiter = "delimiter.sql",
+    Operator = "operator.sql",
+    Identifier = "identifier.sql",
+    IdentifierQuote = "identifier.quote.sql",
+    Type = "type.sql",
+    Function = "predefined.sql",
+    Number = "number.sql",
+    String = "string.sql",
+    Variable = "variable.sql"
+}
+export declare enum StatementPosition {
+    Unknown = "unknown",
+    SelectKeyword = "selectKeyword",
+    WithKeyword = "withKeyword",
+    AfterSelectKeyword = "afterSelectKeyword",
+    AfterSelectArguments = "afterSelectArguments",
+    AfterSelectFuncFirstArgument = "afterSelectFuncFirstArgument",
+    SelectAlias = "selectAlias",
+    AfterFromKeyword = "afterFromKeyword",
+    AfterTable = "afterTable",
+    SchemaFuncFirstArgument = "schemaFuncFirstArgument",
+    SchemaFuncExtraArgument = "schemaFuncExtraArgument",
+    FromKeyword = "fromKeyword",
+    AfterFrom = "afterFrom",
+    WhereKeyword = "whereKeyword",
+    WhereComparisonOperator = "whereComparisonOperator",
+    WhereValue = "whereValue",
+    AfterWhereFunctionArgument = "afterWhereFunctionArgument",
+    AfterGroupByFunctionArgument = "afterGroupByFunctionArgument",
+    AfterWhereValue = "afterWhereValue",
+    AfterGroupByKeywords = "afterGroupByKeywords",
+    AfterGroupBy = "afterGroupBy",
+    AfterOrderByKeywords = "afterOrderByKeywords",
+    AfterOrderByFunction = "afterOrderByFunction",
+    AfterOrderByDirection = "afterOrderByDirection",
+    AfterIsOperator = "afterIsOperator",
+    AfterIsNotOperator = "afterIsNotOperator",
+    AfterSchema = "afterSchema"
+}
+export declare enum SuggestionKind {
+    Schemas = "schemas",
+    Tables = "tables",
+    Columns = "columns",
+    SelectKeyword = "selectKeyword",
+    WithKeyword = "withKeyword",
+    FunctionsWithArguments = "functionsWithArguments",
+    FromKeyword = "fromKeyword",
+    WhereKeyword = "whereKeyword",
+    GroupByKeywords = "groupByKeywords",
+    OrderByKeywords = "orderByKeywords",
+    FunctionsWithoutArguments = "functionsWithoutArguments",
+    LimitKeyword = "limitKeyword",
+    SortOrderDirectionKeyword = "sortOrderDirectionKeyword",
+    ComparisonOperators = "comparisonOperators",
+    LogicalOperators = "logicalOperators",
+    SelectMacro = "selectMacro",
+    TableMacro = "tableMacro",
+    FilterMacro = "filterMacro",
+    GroupMacro = "groupMacro",
+    BoolValues = "boolValues",
+    NullValue = "nullValue",
+    NotKeyword = "notKeyword",
+    TemplateVariables = "templateVariables",
+    StarWildCard = "starWildCard"
+}
+export declare enum CompletionItemPriority {
+    High = "a",
+    MediumHigh = "d",
+    Medium = "g",
+    MediumLow = "k",
+    Low = "q"
+}
+export declare enum CompletionItemKind {
+    Method = 0,
+    Function = 1,
+    Constructor = 2,
+    Field = 3,
+    Variable = 4,
+    Class = 5,
+    Struct = 6,
+    Interface = 7,
+    Module = 8,
+    Property = 9,
+    Event = 10,
+    Operator = 11,
+    Unit = 12,
+    Value = 13,
+    Constant = 14,
+    Enum = 15,
+    EnumMember = 16,
+    Keyword = 17,
+    Text = 18,
+    Color = 19,
+    File = 20,
+    Reference = 21,
+    Customcolor = 22,
+    Folder = 23,
+    TypeParameter = 24,
+    User = 25,
+    Issue = 26,
+    Snippet = 27
+}
+export declare enum CompletionItemInsertTextRule {
+    KeepWhitespace = 1,
+    InsertAsSnippet = 4
+}
+export declare enum SQLEditorMode {
+    Builder = "builder",
+    Code = "code"
+}

package/dist/src/components/SQLEditor/utils/LinkedToken.d.ts

@@ -0,0 +1,29 @@
+import { monacoTypes } from '@grafana/ui';
+import { TokenType } from '../types';
+export declare class LinkedToken {
+    type: string;
+    value: string;
+    range: monacoTypes.IRange;
+    previous: LinkedToken | null;
+    next: LinkedToken | null;
+    constructor(type: string, value: string, range: monacoTypes.IRange, previous: LinkedToken | null, next: LinkedToken | null);
+    isKeyword(): boolean;
+    isWhiteSpace(): boolean;
+    isParenthesis(): boolean;
+    isIdentifier(): boolean;
+    isString(): boolean;
+    isNumber(): boolean;
+    isDoubleQuotedString(): boolean;
+    isVariable(): boolean;
+    isFunction(): boolean;
+    isOperator(): boolean;
+    isTemplateVariable(): boolean;
+    is(type: TokenType, value?: string | number | boolean): boolean;
+    getPreviousNonWhiteSpaceToken(): LinkedToken | null;
+    getPreviousOfType(type: TokenType, value?: string): LinkedToken | null;
+    getPreviousUntil(type: TokenType, ignoreTypes: TokenType[], value?: string): LinkedToken[] | null;
+    getNextUntil(type: TokenType, ignoreTypes: TokenType[], value?: string): LinkedToken[] | null;
+    getPreviousKeyword(): LinkedToken | null;
+    getNextNonWhiteSpaceToken(): LinkedToken | null;
+    getNextOfType(type: TokenType, value?: string): LinkedToken | null;
+}

package/dist/src/components/SQLEditor/utils/commands.d.ts

@@ -0,0 +1,4 @@
+export declare const TRIGGER_SUGGEST: {
+    id: string;
+    title: string;
+};

package/dist/src/components/SQLEditor/utils/debugger.d.ts

@@ -0,0 +1,5 @@
+declare let sqlEditorLogger: {
+    logger: () => void;
+};
+declare let sqlEditorLog: (...t: any[]) => void;
+export { sqlEditorLog, sqlEditorLogger };

package/dist/src/components/SQLEditor/utils/getSuggestionKind.d.ts

@@ -0,0 +1,7 @@
+import { Registry } from '@grafana/data';
+import { SuggestionKindRegistryItem } from '../standardSql/suggestionsKindRegistry';
+import { StatementPosition, SuggestionKind } from '../types';
+/**
+ * Given statement positions, returns list of suggestion kinds that apply to those positions.
+ */
+export declare function getSuggestionKinds(statementPosition: StatementPosition[], suggestionsKindRegistry: Registry<SuggestionKindRegistryItem>): SuggestionKind[];

package/dist/src/components/SQLEditor/utils/linkedTokenBuilder.d.ts

@@ -0,0 +1,4 @@
+import type { monacoTypes } from '@grafana/ui';
+import { LinkedToken } from './LinkedToken';
+import { Monaco } from './types';
+export declare function linkedTokenBuilder(monaco: Monaco, model: monacoTypes.editor.ITextModel, position: monacoTypes.IPosition, languageId?: string): LinkedToken | null;

package/dist/src/components/SQLEditor/utils/toCompletionItem.d.ts

@@ -0,0 +1,2 @@
+import { monacoTypes } from '@grafana/ui';
+export declare const toCompletionItem: (value: string, range: monacoTypes.IRange, rest?: Partial<monacoTypes.languages.CompletionItem>) => monacoTypes.languages.CompletionItem;

package/dist/src/components/SQLEditor/utils/tokenUtils.d.ts

@@ -0,0 +1,14 @@
+import { LinkedToken } from './LinkedToken';
+export declare const getSelectToken: (currentToken: LinkedToken | null) => LinkedToken | null;
+export declare const getSelectStatisticToken: (currentToken: LinkedToken | null) => LinkedToken | null;
+export declare const getMetricNameToken: (currentToken: LinkedToken | null) => LinkedToken | null;
+export declare const getFromKeywordToken: (currentToken: LinkedToken | null) => LinkedToken | null | undefined;
+export declare const getNamespaceToken: (currentToken: LinkedToken | null) => LinkedToken | null;
+export declare const getTableToken: (currentToken: LinkedToken | null) => LinkedToken | null | undefined;
+export declare const defaultTableNameParser: (token: LinkedToken | null | undefined) => {
+    table: string;
+    schema?: undefined;
+} | {
+    schema: string;
+    table: string;
+} | null;

package/dist/src/components/SQLEditor/utils/types.d.ts

@@ -0,0 +1,11 @@
+import { monacoTypes } from '@grafana/ui';
+export interface Editor {
+    tokenize: (value: string, languageId: string) => monacoTypes.Token[][];
+}
+export interface Range {
+    containsPosition: (range: monacoTypes.IRange, position: monacoTypes.IPosition) => boolean;
+}
+export interface Monaco {
+    editor: Editor;
+    Range: Range;
+}

package/dist/src/components/VisualQueryBuilder/QueryModellerBase.d.ts

@@ -0,0 +1,18 @@
+import { Registry } from '@grafana/data';
+import { VisualQuery, VisualQueryBinary, QueryBuilderLabelFilter, QueryBuilderOperation, VisualQueryModeller, QueryBuilderOperationDefinition } from './types';
+export declare abstract class QueryModellerBase implements VisualQueryModeller {
+    protected operationsRegistry: Registry<QueryBuilderOperationDefinition>;
+    private categories;
+    innerQueryPlaceholder: string;
+    constructor(operationDefinitions: QueryBuilderOperationDefinition[], innerQueryPlaceholder?: string);
+    protected setOperationCategories(categories: string[]): void;
+    abstract renderOperations(queryString: string, operations: QueryBuilderOperation[]): string;
+    abstract renderBinaryQueries(queryString: string, binaryQueries?: Array<VisualQueryBinary<VisualQuery>>): string;
+    abstract renderLabels(labels: QueryBuilderLabelFilter[]): string;
+    abstract renderQuery(query: VisualQuery, nested?: boolean): string;
+    getOperationsForCategory(category: string): QueryBuilderOperationDefinition<any>[];
+    getAlternativeOperations(key: string): QueryBuilderOperationDefinition<any>[];
+    getCategories(): string[];
+    getOperationDefinition(id: string): QueryBuilderOperationDefinition | undefined;
+    hasBinaryOp(query: VisualQuery): boolean;
+}

package/dist/src/components/VisualQueryBuilder/components/LabelFilterItem.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="react" />
+import { SelectableValue } from '@grafana/data';
+import { QueryBuilderLabelFilter } from '../types';
+interface Props {
+    defaultOp: string;
+    item: Partial<QueryBuilderLabelFilter>;
+    items: Array<Partial<QueryBuilderLabelFilter>>;
+    onChange: (value: Partial<QueryBuilderLabelFilter>) => void;
+    onGetLabelNames: (forLabel: Partial<QueryBuilderLabelFilter>) => Promise<Array<SelectableValue<string>>>;
+    onGetLabelValues: (forLabel: Partial<QueryBuilderLabelFilter>) => Promise<Array<SelectableValue<string>>>;
+    onDelete: () => void;
+    invalidLabel?: boolean;
+    invalidValue?: boolean;
+    multiValueSeparator?: string;
+}
+export declare function LabelFilterItem({ item, items, defaultOp, onChange, onDelete, onGetLabelNames, onGetLabelValues, invalidLabel, invalidValue, multiValueSeparator, }: Props): JSX.Element;
+export declare function isConflictingLabelFilter(newLabel: Partial<QueryBuilderLabelFilter>, labels: Array<Partial<QueryBuilderLabelFilter>>): boolean;
+export {};

package/dist/src/components/VisualQueryBuilder/components/LabelFilters.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="react" />
+import { SelectableValue } from '@grafana/data';
+import { QueryBuilderLabelFilter } from '../types';
+export declare const MISSING_LABEL_FILTER_ERROR_MESSAGE = "Select at least 1 label filter (label and value)";
+export interface Props {
+    labelsFilters: QueryBuilderLabelFilter[];
+    onChange: (labelFilters: QueryBuilderLabelFilter[]) => void;
+    onGetLabelNames: (forLabel: Partial<QueryBuilderLabelFilter>) => Promise<SelectableValue[]>;
+    onGetLabelValues: (forLabel: Partial<QueryBuilderLabelFilter>) => Promise<SelectableValue[]>;
+    /** If set to true, component will show error message until at least 1 filter is selected */
+    labelFilterRequired?: boolean;
+    multiValueSeparator?: string;
+}
+export declare function LabelFilters({ labelsFilters, onChange, onGetLabelNames, onGetLabelValues, labelFilterRequired, multiValueSeparator, }: Props): JSX.Element;

package/dist/src/components/VisualQueryBuilder/components/OperationEditor.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="react" />
+import { DataSourceApi, TimeRange } from '@grafana/data';
+import { QueryBuilderOperation, VisualQuery, VisualQueryModeller } from '../types';
+interface Props<T extends VisualQuery> {
+    operation: QueryBuilderOperation;
+    index: number;
+    query: T;
+    datasource: DataSourceApi;
+    queryModeller: VisualQueryModeller;
+    onChange: (index: number, update: QueryBuilderOperation) => void;
+    onRemove: (index: number) => void;
+    onRunQuery: () => void;
+    flash?: boolean;
+    highlight?: boolean;
+    timeRange?: TimeRange;
+    isConflictingOperation?: (operation: QueryBuilderOperation, otherOperations: QueryBuilderOperation[]) => boolean;
+}
+export declare function OperationEditor<T extends VisualQuery>({ operation, index, onRemove, onChange, onRunQuery, queryModeller, query, datasource, flash, highlight, timeRange, isConflictingOperation, }: Props<T>): JSX.Element;
+export {};

package/dist/src/components/VisualQueryBuilder/components/OperationEditorBody.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="react" />
+import { DraggableProvided } from '@hello-pangea/dnd';
+import { DataSourceApi, TimeRange } from '@grafana/data';
+import { QueryBuilderOperation, QueryBuilderOperationDefinition, VisualQuery, VisualQueryModeller } from '../types';
+type Props = {
+    provided: DraggableProvided;
+    isConflicting: boolean;
+    index: number;
+    operation: QueryBuilderOperation;
+    definition: QueryBuilderOperationDefinition;
+    queryModeller: VisualQueryModeller;
+    query: VisualQuery;
+    onChange: (index: number, update: QueryBuilderOperation) => void;
+    onRemove: (index: number) => void;
+    onRunQuery: () => void;
+    datasource: DataSourceApi;
+    flash?: boolean;
+    highlight?: boolean;
+    timeRange?: TimeRange;
+};
+export declare function OperationEditorBody({ provided, flash, isConflicting, highlight, index, queryModeller, onChange, onRemove, operation, definition, query, timeRange, onRunQuery, datasource, }: Props): JSX.Element;
+export {};

package/dist/src/components/VisualQueryBuilder/components/OperationExplainedBox.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+export interface Props {
+    title?: React.ReactNode;
+    markdown?: string;
+    stepNumber?: number;
+}
+export declare function OperationExplainedBox({ title, stepNumber, markdown, children }: React.PropsWithChildren<Props>): JSX.Element;

package/dist/src/components/VisualQueryBuilder/components/OperationHeader.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { DraggableProvided } from '@hello-pangea/dnd';
+import { VisualQueryModeller, QueryBuilderOperation, QueryBuilderOperationDefinition } from '../types';
+interface Props {
+    operation: QueryBuilderOperation;
+    definition: QueryBuilderOperationDefinition;
+    index: number;
+    queryModeller: VisualQueryModeller;
+    dragHandleProps?: DraggableProvided['dragHandleProps'];
+    onChange: (index: number, update: QueryBuilderOperation) => void;
+    onRemove: (index: number) => void;
+}
+export declare const OperationHeader: React.NamedExoticComponent<Props>;
+export {};

package/dist/src/components/VisualQueryBuilder/components/OperationInfoButton.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { QueryBuilderOperation, QueryBuilderOperationDefinition } from '../types';
+interface Props {
+    operation: QueryBuilderOperation;
+    definition: QueryBuilderOperationDefinition;
+    innerQueryPlaceholder: string;
+}
+export declare const OperationInfoButton: React.NamedExoticComponent<Props>;
+export {};