@grafana/plugin-ui 0.7.2 → 0.9.0

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 {};

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

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

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

@@ -0,0 +1,17 @@
+/// <reference types="react" />
+import { Grammar } from 'prismjs';
+import { QueryBuilderOperation, VisualQuery, VisualQueryModeller } from '../types';
+interface Props<T extends VisualQuery> {
+    query: T;
+    queryModeller: VisualQueryModeller;
+    explainMode?: boolean;
+    stepNumber: number;
+    language: {
+        grammar: Grammar;
+        name: string;
+    };
+    onMouseEnter?: (op: QueryBuilderOperation, index: number) => void;
+    onMouseLeave?: (op: QueryBuilderOperation, index: number) => void;
+}
+export declare function OperationListExplained<T extends VisualQuery>({ query, queryModeller, stepNumber, language, onMouseEnter, onMouseLeave, }: Props<T>): JSX.Element;
+export {};

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

@@ -0,0 +1,4 @@
+import { FunctionComponent } from 'react';
+import { QueryBuilderOperationParamDef, QueryBuilderOperationParamEditorProps } from '../types';
+export declare function getOperationParamEditor(paramDef: QueryBuilderOperationParamDef): FunctionComponent<QueryBuilderOperationParamEditorProps>;
+export declare function getOperationParamId(operationId: string, paramIndex: number): string;

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

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare function OperationsEditorRow({ children }: React.PropsWithChildren<{}>): JSX.Element;

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

@@ -0,0 +1,20 @@
+/// <reference types="react" />
+import { DataSourceApi, PanelData, DataQuery } from '@grafana/data';
+import { VisualQuery, VisualQueryModeller } from '../types';
+interface Props<TVisualQuery extends VisualQuery, TDataQuery extends DataQuery> {
+    query: TVisualQuery;
+    datasource: DataSourceApi<TDataQuery>;
+    queryModeller: VisualQueryModeller;
+    buildVisualQueryFromString: (queryString: string) => {
+        query: TVisualQuery;
+    };
+    buildDataQueryFromQueryString: (queryString: string) => TDataQuery;
+    buildQueryStringFromDataQuery: (dataQuery: TDataQuery) => string;
+    onChange: (update: TVisualQuery) => void;
+    data?: PanelData;
+}
+export declare const QueryBuilderHints: {
+    <TVisualQuery extends VisualQuery, TDataQuery extends DataQuery>({ datasource, query: visualQuery, onChange, data, queryModeller, buildVisualQueryFromString, buildDataQueryFromQueryString, buildQueryStringFromDataQuery, }: Props<TVisualQuery, TDataQuery>): JSX.Element;
+    displayName: string;
+};
+export {};

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

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { QueryEditorMode } from '../types';
+interface Props {
+    mode: QueryEditorMode;
+    onChange: (mode: QueryEditorMode) => void;
+}
+export declare function QueryEditorModeToggle({ mode, onChange }: Props): JSX.Element;
+export {};

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

@@ -0,0 +1,7 @@
+import { HTMLProps } from 'react';
+interface Props extends Omit<HTMLProps<HTMLInputElement>, 'value' | 'ref'> {
+    value?: boolean;
+    label: string;
+}
+export declare function QueryHeaderSwitch({ label, ...inputProps }: Props): JSX.Element;
+export {};

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

@@ -0,0 +1,9 @@
+import React from 'react';
+import { QueryStats } from '../types';
+interface Props {
+    title: string;
+    collapsedInfo: string[];
+    queryStats?: QueryStats | null;
+}
+export declare function QueryOptionGroup({ title, children, collapsedInfo, queryStats }: React.PropsWithChildren<Props>): JSX.Element;
+export {};

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

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import { Grammar } from 'prismjs';
+interface Props {
+    query: string;
+    language: {
+        grammar: Grammar;
+        name: string;
+    };
+    className?: string;
+}
+export declare function RawQuery({ query, language, className }: Props): JSX.Element;
+export {};

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

@@ -0,0 +1,13 @@
+export { QueryModellerBase } from './QueryModellerBase';
+export { LabelFilters } from './components/LabelFilters';
+export { OperationExplainedBox } from './components/OperationExplainedBox';
+export { OperationList } from './components/OperationList';
+export { OperationListExplained } from './components/OperationListExplained';
+export { OperationsEditorRow } from './components/OperationsEditorRow';
+export { QueryBuilderHints } from './components/QueryBuilderHints';
+export { QueryEditorModeToggle } from './components/QueryEditorModeToggle';
+export { QueryHeaderSwitch } from './components/QueryHeaderSwitch';
+export { QueryOptionGroup } from './components/QueryOptionGroup';
+export { RawQuery } from './components/RawQuery';
+export type { QueryBuilderOperationParamEditorProps, QueryBuilderLabelFilter, QueryBuilderOperation, QueryBuilderOperationParamValue, QueryBuilderOperationDefinition, QueryBuilderOperationParamDef, VisualQueryModeller, VisualQueryBinary, VisualQuery, QueryStats } from './types';
+export { QueryEditorMode, BINARY_OPERATIONS_KEY } from './types';