@intentius/chant-lexicon-grafana 0.98.0 → 0.100.0

package/src/query.ts

@@ -1,12 +1,17 @@
 /**
- * Typed queries, one class per datasource plugin: `PromQuery` (PromQL),
- * `TempoQuery` (TraceQL) and `LokiQuery` (LogQL), each typed from that
- * plugin's query schema at `GRAFANA_SCHEMA_PIN`.
+ * Typed queries, one class per datasource plugin. `PromQuery` (PromQL),
+ * `TempoQuery` (TraceQL), `LokiQuery` (LogQL), `ElasticsearchQuery`,
+ * `CloudWatchQuery`, `AzureMonitorQuery`, `CloudMonitoringQuery`,
+ * `BigQueryQuery` and `PyroscopeQuery` are typed from that plugin's query
+ * schema at `GRAFANA_SCHEMA_PIN`. `PostgresQuery`, `MySQLQuery` and
+ * `MSSQLQuery` have no schema upstream and are typed by hand from Grafana's
+ * source (`./query-models.ts`).
  *
- * The expression is a string; this lexicon does not parse PromQL, TraceQL or
- * LogQL. What it does check is where the query goes: `datasource` only
- * accepts a datasource of the query's own plugin type, and GRAF101, GRAF102
- * and GRAF103 check the emitted references after a build.
+ * The expression is a string. What the lexicon checks is where the query
+ * goes: `datasource` only accepts a datasource of the query's own plugin
+ * type, and GRAF101, GRAF102 and GRAF103 check the emitted references after
+ * a build. GRAF108 parses the PromQL of every query that reaches a
+ * Prometheus; TraceQL and LogQL are not parsed.
  *
  * `defineQuery` is the extension point for any other datasource plugin, and
  * the three built-ins are defined through it.
@@ -14,18 +19,47 @@
 
 import { createProperty } from "@intentius/chant/runtime";
 import type { Declarable } from "@intentius/chant/declarable";
-import type { DatasourceEntity, DatasourceRef } from "./datasource";
+import type { DatasourceEntity, DatasourceRef, ExternalDatasourceEntity } from "./datasource";
 import type { DatasourceVariableEntity } from "./variables";
 import type { SchemaName } from "./pin";
 import type { Dataquery as PrometheusDataquery } from "./schema/prometheus.gen";
 import type { Dataquery as TempoDataquery } from "./schema/tempo.gen";
 import type { Dataquery as LokiDataquery } from "./schema/loki.gen";
+import type { Dataquery as ElasticsearchDataquery } from "./schema/elasticsearch.gen";
+import type { Request as CloudWatchRequest } from "./schema/cloudwatch.gen";
+import type { MonitorQuery as AzureMonitorDataquery } from "./schema/azuremonitor.gen";
+import type { CloudMonitoringQuery as CloudMonitoringDataquery } from "./schema/googlecloudmonitoring.gen";
+import type { Dataquery as BigQueryDataquery } from "./schema/bigquery.gen";
+import type { Dataquery as PyroscopeDataquery } from "./schema/grafanapyroscope.gen";
+import type { SqlQueryModel } from "./query-models";
 
-/** Where a query or panel sends its request: a declared datasource, a datasource variable, or the ref of one declared elsewhere. */
-export type DatasourceInput<T extends string = string> = DatasourceEntity<T> | DatasourceVariableEntity<T> | DatasourceRef<T>;
+/** Where a query or panel sends its request: a declared or external datasource, a datasource variable, or the ref of one declared elsewhere. */
+export type DatasourceInput<T extends string = string> =
+  | DatasourceEntity<T>
+  | ExternalDatasourceEntity<T>
+  | DatasourceVariableEntity<T>
+  | DatasourceRef<T>;
 
-/** A query model's fields, less what chant fills in (`datasource`, `refId` stays optional). */
-export type QueryModel<M> = Omit<M, "datasource">;
+/**
+ * A query model's fields, less what chant fills in (`datasource`, `refId`
+ * stays optional). A model that is a union (CloudWatch's metrics, logs and
+ * annotation queries) stays one, member by member.
+ */
+export type QueryModel<M> = M extends unknown ? Omit<M, "datasource"> : never;
+
+/** `M` with the fields `K` optional, member by member: for fields a schema requires that Grafana fills in when they are missing. */
+export type Loosen<M, K extends PropertyKey> = M extends unknown ? Omit<M, K> & Partial<Pick<M, K & keyof M>> : never;
+
+type KeysOfUnion<U> = U extends unknown ? keyof U : never;
+
+/**
+ * A union of models as one object type: every member's fields, each
+ * optional, typed as the union of what the members allow there. A class
+ * whose props are a union could not have a single prop named by
+ * `PropsOf<typeof Class>["key"]`, which is how imported source types its
+ * lifted consts.
+ */
+export type MergedModel<U> = { [K in KeysOfUnion<U>]?: U extends unknown ? (K extends keyof U ? U[K] : never) : never };
 
 export type QueryProps<M, T extends string> = QueryModel<M> & {
   /** Overrides the panel's datasource for this query. */
@@ -46,6 +80,12 @@ export interface QueryDefinition<T extends string = string, M = Record<string, u
   defaults?: Partial<M>;
   /** True only for the queries this package ships. */
   builtin: boolean;
+  /**
+   * Other plugin ids Grafana accepts for the same plugin (`aliasIDs` in its
+   * plugin.json), e.g. `postgres` for `grafana-postgresql-datasource`. The
+   * class is registered under each, so imports and GRAF107 find it by either.
+   */
+  aliases?: readonly string[];
 }
 
 export interface QueryEntity<T extends string = string, M = Record<string, unknown>> extends Declarable {
@@ -66,9 +106,9 @@ function registry(): Map<string, QueryDefinition> {
   return (g[REGISTRY_KEY] ??= new Map());
 }
 
-/** Every registered query definition, keyed by datasource type. */
+/** Every registered query definition, once each (a definition with aliases is registered under several types). */
 export function registeredQueries(): QueryDefinition[] {
-  return [...registry().values()];
+  return [...new Set(registry().values())];
 }
 
 export function queryDefinitionFor(datasourceType: string): QueryDefinition | undefined {
@@ -80,7 +120,7 @@ function makeQueryClass<T extends string, M>(def: QueryDefinition<T, M>): QueryC
   if (existing?.builtin && !def.builtin) {
     throw new Error(`grafana: queries for "${def.datasourceType}" are built in (${existing.className}); use that class.`);
   }
-  registry().set(def.datasourceType, def as unknown as QueryDefinition);
+  for (const type of [def.datasourceType, ...(def.aliases ?? [])]) registry().set(type, def as unknown as QueryDefinition);
   const Base = createProperty(`${QUERY_TYPE_PREFIX}${def.datasourceType}`, "grafana") as unknown as (
     this: object,
     props: Record<string, unknown>,
@@ -99,16 +139,16 @@ function makeQueryClass<T extends string, M>(def: QueryDefinition<T, M>): QueryC
  *
  * @example
  * ```ts
- * interface ElasticQueryModel { query: string; metrics?: Array<{ type: string; id: string }>; refId?: string }
+ * interface OpenSearchQueryModel { query: string; queryType?: "lucene" | "PPL"; refId?: string }
  *
- * export const ElasticQuery = defineQuery<ElasticQueryModel>()({
- *   datasourceType: "elasticsearch",
- *   className: "ElasticQuery",
+ * export const OpenSearchQuery = defineQuery<OpenSearchQueryModel>()({
+ *   datasourceType: "grafana-opensearch-datasource",
+ *   className: "OpenSearchQuery",
  *   expressionField: "query",
  * });
  * ```
  */
-export function defineQuery<M>() {
+export function defineQuery<M = Record<string, unknown>>() {
   return function <T extends string>(def: Omit<QueryDefinition<T, M>, "builtin">): QueryClass<T, M> {
     return makeQueryClass<T, M>({ ...def, builtin: false });
   };
@@ -155,6 +195,136 @@ export const LokiQuery = makeQueryClass<"loki", LokiDataquery>({
   builtin: true,
 });
 
+/**
+ * An Elasticsearch query: `query` is Lucene (or the query string of a raw
+ * data, raw document or logs query), `metrics` and `bucketAggs` the
+ * aggregations.
+ */
+export const ElasticsearchQuery = makeQueryClass<"elasticsearch", ElasticsearchDataquery>({
+  datasourceType: "elasticsearch",
+  className: "ElasticsearchQuery",
+  description: "An Elasticsearch query; query is Lucene, metrics and bucketAggs the aggregations",
+  schema: "elasticsearch",
+  expressionField: "query",
+  builtin: true,
+});
+
+/**
+ * A CloudWatch query: a metrics query (`queryMode: "Metrics"`), a Logs
+ * Insights query (`queryMode: "Logs"`, `expression` in `queryLanguage`) or an
+ * annotation query. The three schema definitions are merged into one type
+ * with every field but `queryMode` optional, so each field is one prop;
+ * GRAF107 checks the fields against the three definitions. Grafana's editor
+ * starts `id` and `region` at `""` and `"default"`
+ * (public/app/plugins/datasource/cloudwatch/defaultQueries.ts:12-27 and
+ * 41-52 at v13.2.2), and the backend reads a missing region as the
+ * datasource's default (pkg/tsdb/cloudwatch/cloudwatch.go:65).
+ */
+export const CloudWatchQuery = makeQueryClass<"cloudwatch", MergedModel<CloudWatchRequest> & Pick<CloudWatchRequest, "queryMode">>({
+  datasourceType: "cloudwatch",
+  className: "CloudWatchQuery",
+  description: "A CloudWatch metrics, Logs Insights or annotation query, by queryMode",
+  schema: "cloudwatch",
+  expressionField: "expression",
+  builtin: true,
+});
+
+/**
+ * An Azure Monitor query: `queryType` picks which of `azureMonitor`,
+ * `azureLogAnalytics` (KQL), `azureResourceGraph` or `azureTraces` holds it.
+ */
+export const AzureMonitorQuery = makeQueryClass<"grafana-azure-monitor-datasource", AzureMonitorDataquery>({
+  datasourceType: "grafana-azure-monitor-datasource",
+  className: "AzureMonitorQuery",
+  description: "An Azure Monitor metrics, Log Analytics (KQL), Resource Graph or traces query, by queryType",
+  schema: "azuremonitor",
+  builtin: true,
+});
+
+/**
+ * A Google Cloud Monitoring query (plugin id `stackdriver`): `queryType`
+ * picks which of `timeSeriesList`, `timeSeriesQuery` (MQL), `sloQuery` or
+ * `promQLQuery` holds it.
+ */
+export const CloudMonitoringQuery = makeQueryClass<"stackdriver", CloudMonitoringDataquery>({
+  datasourceType: "stackdriver",
+  className: "CloudMonitoringQuery",
+  description: "A Google Cloud Monitoring time series, MQL, SLO or PromQL query, by queryType",
+  schema: "googlecloudmonitoring",
+  builtin: true,
+});
+
+/**
+ * A BigQuery query: `rawSql` is GoogleSQL. `format` and `rawSql` may be left
+ * out: the plugin fills in `table` and `""` (src/utils.ts:147-160 in
+ * grafana/google-bigquery-datasource v3.4.2).
+ */
+export const BigQueryQuery = makeQueryClass<"grafana-bigquery-datasource", Loosen<BigQueryDataquery, "format" | "rawSql">>({
+  datasourceType: "grafana-bigquery-datasource",
+  className: "BigQueryQuery",
+  description: "A BigQuery query; rawSql is GoogleSQL",
+  schema: "bigquery",
+  expressionField: "rawSql",
+  builtin: true,
+});
+
+/**
+ * A Grafana Pyroscope query: `labelSelector` selects the profiles of
+ * `profileTypeId`. `labelSelector` and `groupBy` may be left out: the plugin
+ * starts them at `{}` and none (dataquery.ts:67-75 and datasource.ts:156-164
+ * in grafana-pyroscope-datasource 13.0.4, the version bundled with
+ * grafana/grafana:13.2.2).
+ */
+export const PyroscopeQuery = makeQueryClass<"grafana-pyroscope-datasource", Loosen<PyroscopeDataquery, "labelSelector" | "groupBy">>({
+  datasourceType: "grafana-pyroscope-datasource",
+  className: "PyroscopeQuery",
+  description: "A Grafana Pyroscope profile or metrics query; labelSelector selects the profiles",
+  schema: "grafanapyroscope",
+  expressionField: "labelSelector",
+  builtin: true,
+});
+
+/**
+ * A PostgreSQL query: `rawSql` is SQL with Grafana's macros. Also used for
+ * the plugin's old id, `postgres` (an `aliasIDs` entry in the plugin.json of
+ * grafana-postgresql-datasource 13.0.3, bundled with grafana/grafana:13.2.2).
+ */
+export const PostgresQuery = makeQueryClass<"grafana-postgresql-datasource" | "postgres", SqlQueryModel>({
+  datasourceType: "grafana-postgresql-datasource",
+  aliases: ["postgres"],
+  className: "PostgresQuery",
+  description: "A PostgreSQL query; rawSql is SQL with Grafana's macros",
+  expressionField: "rawSql",
+  builtin: true,
+});
+
+/** A MySQL query: `rawSql` is SQL with Grafana's macros. */
+export const MySQLQuery = makeQueryClass<"mysql", SqlQueryModel>({
+  datasourceType: "mysql",
+  className: "MySQLQuery",
+  description: "A MySQL query; rawSql is SQL with Grafana's macros",
+  expressionField: "rawSql",
+  builtin: true,
+});
+
+/** A Microsoft SQL Server query: `rawSql` is T-SQL with Grafana's macros. */
+export const MSSQLQuery = makeQueryClass<"mssql", SqlQueryModel>({
+  datasourceType: "mssql",
+  className: "MSSQLQuery",
+  description: "A Microsoft SQL Server query; rawSql is T-SQL with Grafana's macros",
+  expressionField: "rawSql",
+  builtin: true,
+});
+
 export type PromQueryEntity = InstanceType<typeof PromQuery>;
 export type TempoQueryEntity = InstanceType<typeof TempoQuery>;
 export type LokiQueryEntity = InstanceType<typeof LokiQuery>;
+export type ElasticsearchQueryEntity = InstanceType<typeof ElasticsearchQuery>;
+export type CloudWatchQueryEntity = InstanceType<typeof CloudWatchQuery>;
+export type AzureMonitorQueryEntity = InstanceType<typeof AzureMonitorQuery>;
+export type CloudMonitoringQueryEntity = InstanceType<typeof CloudMonitoringQuery>;
+export type BigQueryQueryEntity = InstanceType<typeof BigQueryQuery>;
+export type PyroscopeQueryEntity = InstanceType<typeof PyroscopeQuery>;
+export type PostgresQueryEntity = InstanceType<typeof PostgresQuery>;
+export type MySQLQueryEntity = InstanceType<typeof MySQLQuery>;
+export type MSSQLQueryEntity = InstanceType<typeof MSSQLQuery>;

package/src/schema/azuremonitor.gen.ts

@@ -0,0 +1,381 @@
+// Code generated by chant generate from the vendored Grafana schema
+// src/spec/schemas/azuremonitor.jsonschema.json (see src/pin.ts) and its correction
+// overlay in src/spec/overlay/ (see src/spec/overlay.ts). DO NOT EDIT.
+/* eslint-disable */
+
+export interface MonitorQuery {
+  /**
+   * A unique identifier for the query within the list of targets.
+   * In server side expressions, the refId is used as a variable name to identify results.
+   * By default, the UI will assign A->Z; however setting meaningful names may be useful.
+   */
+  refId?: string | null;
+  /**
+   * If hide is set to true, Grafana will filter out the response(s) associated with this query before returning it to the panel.
+   */
+  hide?: boolean;
+  /**
+   * Specify the query flavor
+   * TODO make this required and give it a default
+   */
+  queryType?: string;
+  /**
+   * Azure subscription containing the resource(s) to be queried.
+   * Also used for template variable queries
+   */
+  subscription?: string;
+  /**
+   * Subscriptions to be queried via Azure Resource Graph.
+   */
+  subscriptions?: string[];
+  /**
+   * Azure Monitor Metrics sub-query properties.
+   */
+  azureMonitor?: MetricQuery;
+  /**
+   * Azure Monitor Logs sub-query properties.
+   */
+  azureLogAnalytics?: LogsQuery;
+  /**
+   * Azure Resource Graph sub-query properties.
+   */
+  azureResourceGraph?: ResourceGraphQuery;
+  /**
+   * Application Insights Traces sub-query properties.
+   */
+  azureTraces?: TracesQuery;
+  /**
+   * @deprecated Legacy template variable support.
+   */
+  grafanaTemplateVariableFn?: GrafanaTemplateVariableQuery;
+  /**
+   * Resource group used in template variable queries
+   */
+  resourceGroup?: string;
+  /**
+   * Namespace used in template variable queries
+   */
+  namespace?: string;
+  /**
+   * Resource used in template variable queries
+   */
+  resource?: string;
+  /**
+   * Region used in template variable queries
+   */
+  region?: string;
+  /**
+   * Custom namespace used in template variable queries
+   */
+  customNamespace?: string;
+  /**
+   * For mixed data sources the selected datasource is on the query level.
+   * For non mixed scenarios this is undefined.
+   * TODO find a better way to do this ^ that's friendly to schema
+   * TODO this shouldn't be unknown but DataSourceRef | null
+   */
+  datasource?: DataSourceRef;
+  /**
+   * Used only for exemplar queries from Prometheus
+   */
+  query?: string;
+}
+
+export interface MetricQuery {
+  /**
+   * Array of resource URIs to be queried.
+   */
+  resources?: MonitorResource[];
+  /**
+   * metricNamespace is used as the resource type (or resource namespace).
+   * It's usually equal to the target metric namespace. e.g. microsoft.storage/storageaccounts
+   * Kept the name of the variable as metricNamespace to avoid backward incompatibility issues.
+   */
+  metricNamespace?: string;
+  /**
+   * Used as the value for the metricNamespace property when it's different from the resource namespace.
+   */
+  customNamespace?: string;
+  /**
+   * The metric to query data for within the specified metricNamespace. e.g. UsedCapacity
+   */
+  metricName?: string;
+  /**
+   * The Azure region containing the resource(s).
+   */
+  region?: string;
+  /**
+   * The granularity of data points to be queried. Defaults to auto.
+   */
+  timeGrain?: string;
+  /**
+   * The aggregation to be used within the query. Defaults to the primaryAggregationType defined by the metric.
+   */
+  aggregation?: string;
+  /**
+   * Filters to reduce the set of data returned. Dimensions that can be filtered on are defined by the metric.
+   */
+  dimensionFilters?: MetricDimension[];
+  /**
+   * Maximum number of records to return. Defaults to 10.
+   */
+  top?: string;
+  /**
+   * Time grains that are supported by the metric.
+   */
+  allowedTimeGrainsMs?: number[];
+  /**
+   * Aliases can be set to modify the legend labels. e.g. {{ resourceGroup }}. See docs for more detail.
+   */
+  alias?: string;
+  /**
+   * @deprecated
+   */
+  timeGrainUnit?: string;
+  /**
+   * @deprecated This property was migrated to dimensionFilters and should only be accessed in the migration
+   */
+  dimension?: string;
+  /**
+   * @deprecated This property was migrated to dimensionFilters and should only be accessed in the migration
+   */
+  dimensionFilter?: string;
+  /**
+   * @deprecated Use metricNamespace instead
+   */
+  metricDefinition?: string;
+  /**
+   * @deprecated Use resourceGroup, resourceName and metricNamespace instead
+   */
+  resourceUri?: string;
+  /**
+   * @deprecated Use resources instead
+   */
+  resourceGroup?: string;
+  /**
+   * @deprecated Use resources instead
+   */
+  resourceName?: string;
+}
+
+export interface MonitorResource {
+  subscription?: string;
+  resourceGroup?: string;
+  resourceName?: string;
+  metricNamespace?: string;
+  region?: string;
+}
+
+export interface MetricDimension {
+  /**
+   * Name of Dimension to be filtered on.
+   */
+  dimension?: string;
+  /**
+   * String denoting the filter operation. Supports 'eq' - equals,'ne' - not equals, 'sw' - starts with. Note that some dimensions may not support all operators.
+   */
+  operator?: string;
+  /**
+   * Values to match with the filter.
+   */
+  filters?: string[];
+  /**
+   * @deprecated filter is deprecated in favour of filters to support multiselect.
+   */
+  filter?: string;
+}
+
+/**
+ * Azure Monitor Logs sub-query properties
+ */
+export interface LogsQuery {
+  /**
+   * KQL query to be executed.
+   */
+  query?: string;
+  /**
+   * Specifies the format results should be returned as.
+   */
+  resultFormat?: ResultFormat;
+  /**
+   * Array of resource URIs to be queried.
+   */
+  resources?: string[];
+  /**
+   * If set to true the dashboard time range will be used as a filter for the query. Otherwise the query time ranges will be used. Defaults to false.
+   */
+  dashboardTime?: boolean;
+  /**
+   * If dashboardTime is set to true this value dictates which column the time filter will be applied to. Defaults to the first tables timeSpan column, the first datetime column found, or TimeGenerated
+   */
+  timeColumn?: string;
+  /**
+   * If set to true the query will be run as a basic logs query
+   */
+  basicLogsQuery?: boolean;
+  /**
+   * Workspace ID. This was removed in Grafana 8, but remains for backwards compat.
+   */
+  workspace?: string;
+  /**
+   * @deprecated Use resources instead
+   */
+  resource?: string;
+  /**
+   * @deprecated Use dashboardTime instead
+   */
+  intersectTime?: boolean;
+}
+
+export type ResultFormat = "table" | "time_series" | "trace" | "logs";
+
+export interface ResourceGraphQuery {
+  /**
+   * Azure Resource Graph KQL query to be executed.
+   */
+  query?: string;
+  /**
+   * Specifies the format results should be returned as. Defaults to table.
+   */
+  resultFormat?: string;
+}
+
+/**
+ * Application Insights Traces sub-query properties
+ */
+export interface TracesQuery {
+  /**
+   * Specifies the format results should be returned as.
+   */
+  resultFormat?: ResultFormat;
+  /**
+   * Array of resource URIs to be queried.
+   */
+  resources?: string[];
+  /**
+   * Operation ID. Used only for Traces queries.
+   */
+  operationId?: string;
+  /**
+   * Types of events to filter by.
+   */
+  traceTypes?: string[];
+  /**
+   * Filters for property values.
+   */
+  filters?: TracesFilter[];
+  /**
+   * KQL query to be executed.
+   */
+  query?: string;
+}
+
+export interface TracesFilter {
+  /**
+   * Property name, auto-populated based on available traces.
+   */
+  property: string;
+  /**
+   * Comparison operator to use. Either equals or not equals.
+   */
+  operation: string;
+  /**
+   * Values to filter by.
+   */
+  filters: string[];
+}
+
+export type GrafanaTemplateVariableQuery = AppInsightsMetricNameQuery | AppInsightsGroupByQuery | SubscriptionsQuery | ResourceGroupsQuery | ResourceNamesQuery | MetricNamespaceQuery | MetricDefinitionsQuery | MetricNamesQuery | WorkspacesQuery | UnknownQuery;
+
+export interface AppInsightsMetricNameQuery {
+  rawQuery?: string;
+  kind: "AppInsightsMetricNameQuery";
+}
+
+export interface AppInsightsGroupByQuery {
+  rawQuery?: string;
+  kind: "AppInsightsGroupByQuery";
+  metricName: string;
+}
+
+export interface SubscriptionsQuery {
+  rawQuery?: string;
+  kind: "SubscriptionsQuery";
+}
+
+export interface ResourceGroupsQuery {
+  rawQuery?: string;
+  kind: "ResourceGroupsQuery";
+  subscription: string;
+}
+
+export interface ResourceNamesQuery {
+  rawQuery?: string;
+  kind: "ResourceNamesQuery";
+  subscription: string;
+  resourceGroup: string;
+  metricNamespace: string;
+}
+
+export interface MetricNamespaceQuery {
+  rawQuery?: string;
+  kind: "MetricNamespaceQuery";
+  subscription: string;
+  resourceGroup: string;
+  metricNamespace?: string;
+  resourceName?: string;
+}
+
+/**
+ * @deprecated Use MetricNamespaceQuery instead
+ */
+export interface MetricDefinitionsQuery {
+  rawQuery?: string;
+  kind: "MetricDefinitionsQuery";
+  subscription: string;
+  resourceGroup: string;
+  metricNamespace?: string;
+  resourceName?: string;
+}
+
+export interface MetricNamesQuery {
+  rawQuery?: string;
+  kind: "MetricNamesQuery";
+  subscription: string;
+  resourceGroup: string;
+  resourceName: string;
+  metricNamespace: string;
+}
+
+export interface WorkspacesQuery {
+  rawQuery?: string;
+  kind: "WorkspacesQuery";
+  subscription: string;
+}
+
+export interface UnknownQuery {
+  rawQuery?: string;
+  kind: "UnknownQuery";
+}
+
+/**
+ * Defines the supported queryTypes. GrafanaTemplateVariableFn is deprecated
+ */
+export type QueryType = "Azure Monitor" | "Azure Log Analytics" | "Azure Resource Graph" | "Azure Traces" | "Azure Subscriptions" | "Azure Resource Groups" | "Azure Namespaces" | "Azure Resource Names" | "Azure Metric Names" | "Azure Workspaces" | "Azure Regions" | "Grafana Template Variable Function" | "traceql" | "Azure Custom Namespaces" | "Azure Custom Metric Names";
+
+export type GrafanaTemplateVariableQueryType = "AppInsightsMetricNameQuery" | "AppInsightsGroupByQuery" | "SubscriptionsQuery" | "ResourceGroupsQuery" | "ResourceNamesQuery" | "MetricNamespaceQuery" | "MetricNamesQuery" | "WorkspacesQuery" | "UnknownQuery";
+
+export interface BaseGrafanaTemplateVariableQuery {
+  rawQuery?: string;
+}
+
+export interface DataSourceRef {
+  /**
+   * The plugin type-id
+   */
+  type?: string;
+  /**
+   * Specific datasource instance
+   */
+  uid?: string;
+}