@intentius/chant-lexicon-grafana 0.97.0 → 0.99.0

package/dist/import/alerting.d.ts

@@ -0,0 +1,40 @@
+/**
+ * An alerting provisioning file -> a `Plan`, for `chant import`.
+ *
+ * Accepts what Grafana's file provisioner reads and what
+ * `GET /api/v1/provisioning/*\/export` writes (the same format at v12.4.11
+ * and v13.2.2): rule groups, contact points, notification policies, mute
+ * timings and templates, in one file or split across several.
+ *
+ * - A rule group becomes an `AlertRuleGroup`, each rule an `AlertRule`,
+ *   each entry of a rule's `data` a declaration of its own: a server-side
+ *   expression as its typed class (`ReduceExpression`, `ThresholdExpression`,
+ *   ...), and a datasource query as an `AlertQuery` holding its model as it
+ *   is, so nothing a plugin stores is lost.
+ * - A datasource uid a query names becomes an `ExternalDatasource` when the
+ *   file says its plugin type (`model.datasource.type`), so the checks can
+ *   see it (GRAF108 parses Prometheus queries). When the type has to be
+ *   inferred from the model, the import says so; when it cannot be told,
+ *   the query keeps the bare uid and the import says that too.
+ * - A contact point, policy, mute timing or template becomes its class;
+ *   a receiver or timing named in the same file is referenced by variable.
+ * - `deleteRules`, `deleteContactPoints`, `resetPolicies`, `deleteMuteTimes`
+ *   and `deleteTemplates` are not carried, with a warning.
+ *
+ * Grafana's editor writes keys into expression models that the expression
+ * does not read (a `conditions` block on reduce and math, `operator`,
+ * `query`, `reducer` and `type` in a threshold's conditions, `type` and
+ * `reducer.params` in classic conditions). They are left out as edits without a warning:
+ * Grafana evaluates the rule the same without them.
+ */
+import { type ImportEdit } from "./edits.js";
+import { type Plan } from "./model.js";
+type Json = Record<string, unknown>;
+/** Plan an alerting provisioning file. `edits` applied to the file give what the rebuilt file should equal (see `normalizeAlerting`). */
+export declare function planAlertingProvisioning(doc: Json): {
+    plan: Plan;
+    edits: ImportEdit[];
+    warnings: string[];
+};
+export {};
+//# sourceMappingURL=alerting.d.ts.map

package/dist/import/alerting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alerting.d.ts","sourceRoot":"","sources":["../../src/import/alerting.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,EAAW,KAAK,UAAU,EAAE,MAAM,SAAS,CAAC;AAEnD,OAAO,EAA2C,KAAK,IAAI,EAAE,MAAM,SAAS,CAAC;AAO7E,KAAK,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAucpC,yIAAyI;AACzI,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,IAAI,GAAG;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,UAAU,EAAE,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,CAI3G"}

package/dist/import/edits.d.ts

@@ -0,0 +1,47 @@
+/**
+ * What the importer did to a dashboard on the way to TypeScript, as edits
+ * to its JSON.
+ *
+ * Every key the importer leaves out, and every value it writes in another
+ * form, is one edit, and every edit that changes what Grafana does comes
+ * with an import warning. The round-trip test applies the edits to the
+ * source dashboard and expects the rebuilt dashboard to equal the result
+ * (after `normalizeDashboard`), which is how it checks that nothing is
+ * dropped without a warning.
+ */
+type Json = Record<string, unknown>;
+export type ImportEdit = 
+/** The value at `path` (a JSON pointer) is not carried. */
+{
+    readonly op: "remove";
+    readonly path: string;
+}
+/** The value at `path` is written as `value`. */
+ | {
+    readonly op: "replace";
+    readonly path: string;
+    readonly value: unknown;
+}
+/** Every string in the dashboard has `from` replaced by `to` (an `__inputs` constant filled in). */
+ | {
+    readonly op: "substitute";
+    readonly from: string;
+    readonly to: string;
+}
+/** `value` is added at the front of `templating.list` (an `__inputs` datasource as a variable). */
+ | {
+    readonly op: "prependVariable";
+    readonly value: Json;
+};
+/** `/a/b/0` as its unescaped segments. */
+export declare function pointerSegments(path: string): string[];
+/** A JSON pointer from segments. */
+export declare function pointer(...segments: Array<string | number>): string;
+/**
+ * The dashboard with the edits applied: substitutions first, then
+ * replacements and removals (all by pointers into the original), then the
+ * prepended variables.
+ */
+export declare function applyEdits(dashboard: Json, edits: readonly ImportEdit[]): Json;
+export {};
+//# sourceMappingURL=edits.d.ts.map

package/dist/import/edits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edits.d.ts","sourceRoot":"","sources":["../../src/import/edits.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,KAAK,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEpC,MAAM,MAAM,UAAU;AACpB,2DAA2D;AACzD;IAAE,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE;AAClD,iDAAiD;GAC/C;IAAE,QAAQ,CAAC,EAAE,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;CAAE;AAC5E,oGAAoG;GAClG;IAAE,QAAQ,CAAC,EAAE,EAAE,YAAY,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CAAE;AAC3E,mGAAmG;GACjG;IAAE,QAAQ,CAAC,EAAE,EAAE,iBAAiB,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAA;CAAE,CAAC;AAE7D,0CAA0C;AAC1C,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAMtD;AAED,oCAAoC;AACpC,wBAAgB,OAAO,CAAC,GAAG,QAAQ,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,GAAG,MAAM,CAEnE;AA+BD;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,UAAU,EAAE,GAAG,IAAI,CAoB9E"}

package/dist/import/embedded.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Dashboard JSON embedded in another lexicon's resource, for `chant import`
+ * (#2962): a k8s ConfigMap holding a dashboard, as the Grafana dashboard
+ * sidecar (the `grafana_dashboard` label) and file provisioning both mount
+ * them. Matching is by content, so a dashboard in an unlabelled ConfigMap
+ * is imported too.
+ *
+ * The dashboard is imported exactly as `chant import dashboard.json` would
+ * import it, into a directory of its own, and the host's value becomes
+ * `dashboardJson(dashboard)`, the JSON text the grafana serializer writes.
+ */
+import type { EmbeddedContentImporter } from "@intentius/chant/import/embedded";
+export declare const dashboardImporter: EmbeddedContentImporter;
+//# sourceMappingURL=embedded.d.ts.map

package/dist/import/embedded.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embedded.d.ts","sourceRoot":"","sources":["../../src/import/embedded.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,uBAAuB,EAAkB,MAAM,kCAAkC,CAAC;AAOhG,eAAO,MAAM,iBAAiB,EAAE,uBA2B/B,CAAC"}

package/dist/import/generator.d.ts

@@ -0,0 +1,60 @@
+/**
+ * `TemplateIR` -> TypeScript, for `chant import`.
+ *
+ * The parser has already decided what every declaration is (./model.ts);
+ * this module decides only how the plan is written, the way the lexicon's
+ * examples are written:
+ *
+ * - one constant per declaration, named from its title (`CPU Busy` becomes
+ *   `cpuBusy`; a panel's queries take its name and their refId, `cpuBusyA`);
+ * - a nested value lifted into a named const typed by the class's props
+ *   (`const cpuBusyOptions: PropsOf<typeof GaugePanel>["options"] = …`),
+ *   which is what COR001 asks;
+ * - at most eight declarables per module (COR009): a module group with
+ *   more is split into `<file>-1.ts`, `<file>-2.ts`, …, keeping a panel with
+ *   its queries;
+ * - an `export { … }` list at the end of each module (COR004), naming what
+ *   another module imports, and the dashboard;
+ * - classes the plan declares (`definePanel`, `defineQuery`) in their own
+ *   module, imported where they are used.
+ *
+ * A dashboard's modules go in a directory of their own (`plan.directory`),
+ * so importing a second dashboard into the same project does not collide
+ * with the first.
+ *
+ * Extension points:
+ *
+ * - `generatePlan(plan)` is the entry point for anything that builds a
+ *   plan without the parser (live export, #2946).
+ * - `DECLARABLES_PER_FILE` is COR009's limit.
+ * - Everything Grafana-specific lives in the parser's tables
+ *   (./mappings.ts); a new class needs no change here.
+ */
+import type { GeneratedFile, TypeScriptGenerator } from "@intentius/chant/import/generator";
+import type { TemplateIR } from "@intentius/chant/import/parser";
+import { type Plan } from "./model.js";
+/** COR009's default: at most this many declarables per file. */
+export declare const DECLARABLES_PER_FILE = 8;
+/** A value as a TypeScript expression, starting at column `col`, indented by `indent` spaces. */
+export declare function tsLiteral(v: unknown, indent: number, col?: number): string;
+/** The TypeScript for one plan: its modules, in the order they should be read. */
+export declare function generatePlan(plan: Plan): GeneratedFile[];
+/**
+ * The TypeScript for one plan, and where each declaration the plan exports
+ * is declared: its module's path and variable (#2962: a ConfigMap holding
+ * the dashboard refers to it).
+ */
+export declare function generatePlanModules(plan: Plan): {
+    files: GeneratedFile[];
+    exported: Map<string, {
+        path: string;
+        name: string;
+    }>;
+};
+/** The Grafana TypeScript generator `chant import` runs. */
+export declare class GrafanaGenerator implements TypeScriptGenerator {
+    /** Core writes exactly the files returned: a dashboard's modules refer to each other and live in its own directory. */
+    readonly ownsLayout = true;
+    generate(ir: TemplateIR): GeneratedFile[];
+}
+//# sourceMappingURL=generator.d.ts.map

package/dist/import/generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator.d.ts","sourceRoot":"","sources":["../../src/import/generator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AAC5F,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AACjE,OAAO,EAA8D,KAAK,IAAI,EAAE,MAAM,SAAS,CAAC;AAKhG,gEAAgE;AAChE,eAAO,MAAM,oBAAoB,IAAI,CAAC;AA6FtC,iGAAiG;AACjG,wBAAgB,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,SAAS,GAAG,MAAM,CAwB1E;AAoKD,kFAAkF;AAClF,wBAAgB,YAAY,CAAC,IAAI,EAAE,IAAI,GAAG,aAAa,EAAE,CAExD;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,IAAI,GAAG;IAC/C,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACvD,CA4GA;AAED,4DAA4D;AAC5D,qBAAa,gBAAiB,YAAW,mBAAmB;IAC1D,uHAAuH;IACvH,QAAQ,CAAC,UAAU,QAAQ;IAE3B,QAAQ,CAAC,EAAE,EAAE,UAAU,GAAG,aAAa,EAAE;CAU1C"}

package/dist/import/live-export.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Live Grafana objects -> chant's vocabulary, pure (#2946).
+ *
+ * Two consumers, one mapping:
+ *
+ * - live export (`../export-resources.ts`) turns dashboards and
+ *   datasources read over the API into `TemplateIR` that feeds
+ *   `templateGenerator()` unchanged;
+ * - deep observation (`../deep-observe.ts`) turns one live dashboard into
+ *   the property tree core diffs against the declaration.
+ *
+ * Both go through the importer (`./parser.ts`), so a dashboard read from
+ * Grafana and a dashboard file given to `chant import` become the same
+ * declarations. The importer is not changed here; this module only reads
+ * the plan it makes.
+ *
+ * ## Why the drift tree is in chant's vocabulary, not Grafana's
+ *
+ * Core diffs a declaration's `props` (with property-kind declarables, which
+ * panels, rows, queries and variables are, inlined as their own props)
+ * against the tree a reader returns. A `Dashboard`'s props are what the
+ * author wrote: `graphTooltip: "sharedCrosshair"`, `panels: [Row, ...]`, a
+ * query with no `refId`. The JSON Grafana stores is what the build wrote
+ * from them: `graphTooltip: 1`, a flat panel list, `refId: "A"`. So the
+ * live side has to be put into the author's vocabulary, and the importer
+ * is exactly that translation, already tested to round-trip. Reading the
+ * plan back as one tree (every reference replaced by what it refers to)
+ * gives the live counterpart of the declared tree.
+ *
+ * What the translation cannot decide on its own (a panel `id` the build
+ * numbered, a `gridPos` it laid out, the built-in annotation Grafana adds)
+ * is noise, and noise is named in `../deep-observe-hooks.ts`, which core
+ * applies to both trees.
+ */
+import type { TemplateIR } from "@intentius/chant/import/parser";
+import { type Plan } from "./model.js";
+type Json = Record<string, unknown>;
+/**
+ * The dashboard declaration of a plan as one property tree: each reference
+ * replaced by the props (or, for a `DatasourceRef` const, the value) of the
+ * declaration it names, the way core inlines a property-kind declarable.
+ */
+export declare function planTree(plan: Plan): Json;
+/** One live dashboard (classic JSON) as the property tree core diffs a `Dashboard` declaration against. */
+export declare function dashboardTree(dashboard: Json): {
+    tree: Json;
+    warnings: string[];
+};
+/** The keys a datasource's props take (`DatasourceProps`), in the order they are written. */
+export declare const DATASOURCE_PROP_KEYS: readonly string[];
+/**
+ * Grafana's value for a datasource key the API always returns, where it
+ * means "not set". Export leaves these out so the generated source says what
+ * somebody chose, as a provisioning file would.
+ */
+export declare const DATASOURCE_API_DEFAULTS: Readonly<Json>;
+/**
+ * One datasource from `GET /api/datasources[/uid/<uid>]` in `DatasourceProps`
+ * vocabulary.
+ *
+ * - `readOnly` (the API's word) becomes `editable` (the provisioning file's).
+ * - `secureJsonFields` names which secrets are set and never their values;
+ *   they become `secureJsonData` keys whose value is `[REDACTED]`, so the
+ *   key set compares and nothing secret is ever held.
+ * - `id`, `orgId`, `version`, `typeName`, `typeLogoUrl`, `apiVersion` and the
+ *   rest are the server's own and are left out.
+ *
+ * `keepDefaults` keeps keys at the API's "not set" value (`--verbatim`).
+ */
+export declare function datasourceProps(live: Json, options?: {
+    keepDefaults?: boolean;
+}): Json;
+/**
+ * A dashboard plan whose `ExternalDatasource`s for the given uids are
+ * written as plain `{ type, uid }` refs instead.
+ *
+ * The importer declares an `ExternalDatasource` for each datasource a
+ * dashboard names, because a dashboard file alone does not say where its
+ * datasources come from. A live export does know, when it exports the
+ * datasources too: they become `Datasource` declarations, and an
+ * `ExternalDatasource` with the same uid beside them fails the build (two
+ * datasources, one uid). A plain ref is what the importer itself writes when
+ * it cannot declare an external one (`settleExternals`), and GRAF101 still
+ * checks it against the declared `Datasource`.
+ */
+export declare function referDeclaredDatasources(plan: Plan, uids: ReadonlySet<string>): Plan;
+/**
+ * Live dashboards and datasources as import IR, for `chant import --from`.
+ *
+ * Each dashboard is planned by the importer exactly as a dashboard file
+ * would be, so the generated TypeScript is what `chant import` writes for
+ * the same JSON, except that a datasource exported alongside it is referred
+ * to by `{ type, uid }` (see `referDeclaredDatasources`). The datasources are
+ * planned as one provisioning file, with
+ * the secrets Grafana holds written as `[REDACTED]`: the generated source
+ * shows which secrets are set and must be filled in by hand (as
+ * `$__env{NAME}` references, which GRAF002 asks for).
+ */
+export declare function exportTemplate(input: {
+    dashboards: Array<{
+        json: Json;
+        warnings?: string[];
+    }>;
+    datasources: Json[];
+    keepDefaults?: boolean;
+}): TemplateIR;
+export {};
+//# sourceMappingURL=live-export.d.ts.map

package/dist/import/live-export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"live-export.d.ts","sourceRoot":"","sources":["../../src/import/live-export.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,KAAK,EAAc,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAC7E,OAAO,EAA+B,KAAK,IAAI,EAAE,MAAM,SAAS,CAAC;AAUjE,KAAK,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAMpC;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAuBzC;AAED,2GAA2G;AAC3G,wBAAgB,aAAa,CAAC,SAAS,EAAE,IAAI,GAAG;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,CAGjF;AAED,6FAA6F;AAC7F,eAAO,MAAM,oBAAoB,EAAE,SAAS,MAAM,EAiBjD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,IAAI,CASlD,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,GAAE;IAAE,YAAY,CAAC,EAAE,OAAO,CAAA;CAAO,GAAG,IAAI,CAgB1F;AAQD;;;;;;;;;;;;GAYG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,IAAI,CAmBpF;AAQD;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE;IACpC,UAAU,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,IAAI,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;IACvD,WAAW,EAAE,IAAI,EAAE,CAAC;IACpB,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB,GAAG,UAAU,CA8Cb"}

package/dist/import/mappings.d.ts

@@ -0,0 +1,83 @@
+/**
+ * What each piece of classic dashboard JSON becomes: the tables the
+ * importer's parser reads. They are the extension points for the issues
+ * that teach the importer more of Grafana.
+ *
+ * - Panel types (#2950): a built-in panel class is found in the panel
+ *   registry (`registeredPanels()`), so a class added with `builtin: true`
+ *   in `panels.ts` is used by the importer with no change here. Any other
+ *   type is declared in the imported source with `definePanel`.
+ * - Query types (#2951): the same, through `registeredQueries()`, keyed by
+ *   datasource plugin type; any other type gets a `defineQuery`.
+ * - Variable types (#2952): `VARIABLE_MAPPINGS` has one entry per type the
+ *   lexicon has a class for. A type with no entry (adhoc, groupby, switch)
+ *   is reported and left out. Add an entry when the class lands.
+ * - Dashboard and panel fields (#2953 annotations, and any new prop):
+ *   `DASHBOARD_FIELDS`, `PANEL_FIELDS` and `ROW_FIELDS` list the JSON keys
+ *   copied onto a prop as they are. A key in none of the tables, and not
+ *   handled by the parser, is reported and left out, unless it is at the
+ *   value Grafana assumes when it is missing (see `./normalize.ts`).
+ */
+import { type PanelDefinition } from "../panels.js";
+import { type QueryDefinition } from "../query.js";
+import type { VariableHide } from "../variables.js";
+import { splitValues } from "./normalize.js";
+type Json = Record<string, unknown>;
+/** Dashboard JSON keys carried onto the `Dashboard` prop of the same name, as they are. */
+export declare const DASHBOARD_FIELDS: readonly string[];
+/** Panel JSON keys carried onto the panel prop of the same name, as they are. */
+export declare const PANEL_FIELDS: readonly string[];
+/**
+ * Row JSON keys carried onto the `Row` prop of the same name. A row's
+ * `gridPos` is not among them: only its `y` is carried (Grafana draws a row
+ * header full width and one line high), so the row stays on its line even
+ * where the build would place it elsewhere, such as below an empty band.
+ */
+export declare const ROW_FIELDS: readonly string[];
+/** `graphTooltip` as Grafana stores it, and as `Dashboard` takes it. */
+export declare const GRAPH_TOOLTIP: Readonly<Record<number, "default" | "sharedCrosshair" | "sharedTooltip">>;
+/** A variable's `hide` as Grafana stores it, and as the variable classes take it. */
+export declare const VARIABLE_HIDE: Readonly<Record<number, VariableHide>>;
+/** A query variable's `refresh` as Grafana stores it, and as `QueryVariable` takes it. */
+export declare const QUERY_REFRESH: Readonly<Record<number, "never" | "onLoad" | "onTimeRangeChange">>;
+/** The class a panel of this plugin type is declared with, when chant ships one. */
+export declare function builtinPanelFor(type: string): PanelDefinition | undefined;
+/** The class a query to a datasource of this plugin type is declared with, when chant ships one. */
+export declare function builtinQueryFor(datasourceType: string): QueryDefinition | undefined;
+/**
+ * The datasource type a query with no datasource of its own, on a panel
+ * with none, is declared under. Grafana sends it to the default datasource;
+ * the class exists only to hold the query model.
+ */
+export declare const DEFAULT_DATASOURCE_TYPE = "default";
+/** What converting one variable needs from the rest of the import. */
+export interface VariableContext {
+    /** The variable's JSON. */
+    readonly json: Json;
+    /** Its JSON pointer, for edits. */
+    readonly path: string;
+    /** Resolve a `datasource` value to a prop value, reporting what cannot be resolved. */
+    datasource(value: unknown, path: string): unknown;
+    /** Report a key that is not carried; `why` is the end of the sentence, after "not carried". */
+    drop(key: string, why?: string): void;
+    /** Report the whole variable as not carried. */
+    dropVariable(why: string): void;
+    /** Record that `key` is written differently but means the same, or with the given warning. */
+    replace(key: string, value: unknown, why?: string): void;
+}
+/** One variable type the lexicon has a class for: which class, and how its JSON becomes props. */
+export interface VariableMapping {
+    readonly className: string;
+    /** JSON keys the mapping reads, whether it carries them or derives them. Any other key is reported. */
+    readonly keys: readonly string[];
+    /** The type-specific props, or undefined when the variable cannot be carried (after `ctx.dropVariable`). */
+    convert(ctx: VariableContext): Json | undefined;
+}
+/** Split a custom or interval variable's `query` the way Grafana does: on commas not escaped as `\\,`, trimmed. */
+export declare const valuesOf: typeof splitValues;
+/** Per Grafana variable type, the class and props it becomes. */
+export declare const VARIABLE_MAPPINGS: Readonly<Record<string, VariableMapping>>;
+/** Keys every variable type reads: the ones `CommonVariableProps` has, and `type`. */
+export declare const COMMON_VARIABLE_KEYS: readonly string[];
+export {};
+//# sourceMappingURL=mappings.d.ts.map

package/dist/import/mappings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mappings.d.ts","sourceRoot":"","sources":["../../src/import/mappings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAoB,KAAK,eAAe,EAAE,MAAM,WAAW,CAAC;AACnE,OAAO,EAAqB,KAAK,eAAe,EAAE,MAAM,UAAU,CAAC;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE1C,KAAK,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEpC,2FAA2F;AAC3F,eAAO,MAAM,gBAAgB,EAAE,SAAS,MAAM,EAc7C,CAAC;AAEF,iFAAiF;AACjF,eAAO,MAAM,YAAY,EAAE,SAAS,MAAM,EAkBzC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,UAAU,EAAE,SAAS,MAAM,EAAiC,CAAC;AAE1E,wEAAwE;AACxE,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,GAAG,iBAAiB,GAAG,eAAe,CAAC,CAInG,CAAC;AAEF,qFAAqF;AACrF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAA+C,CAAC;AAEjH,0FAA0F;AAC1F,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,QAAQ,GAAG,mBAAmB,CAAC,CAI5F,CAAC;AAEF,oFAAoF;AACpF,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS,CAEzE;AAED,oGAAoG;AACpG,wBAAgB,eAAe,CAAC,cAAc,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS,CAEnF;AAED;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,YAAY,CAAC;AAEjD,sEAAsE;AACtE,MAAM,WAAW,eAAe;IAC9B,2BAA2B;IAC3B,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IACpB,mCAAmC;IACnC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,uFAAuF;IACvF,UAAU,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAClD,+FAA+F;IAC/F,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtC,gDAAgD;IAChD,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,8FAA8F;IAC9F,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1D;AAED,kGAAkG;AAClG,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,uGAAuG;IACvG,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,4GAA4G;IAC5G,OAAO,CAAC,GAAG,EAAE,eAAe,GAAG,IAAI,GAAG,SAAS,CAAC;CACjD;AAaD,mHAAmH;AACnH,eAAO,MAAM,QAAQ,oBAAc,CAAC;AAgBpC,iEAAiE;AACjE,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAkGvE,CAAC;AAEF,sFAAsF;AACtF,eAAO,MAAM,oBAAoB,EAAE,SAAS,MAAM,EAAoE,CAAC"}

package/dist/import/model.d.ts

@@ -0,0 +1,98 @@
+/**
+ * The plan `chant import` hands from the parser to the generator: the
+ * declarations one dashboard becomes, with the references between them.
+ *
+ * The parser decides what each piece of dashboard JSON becomes (which
+ * class, which props, what cannot be carried) using the tables in
+ * `./mappings.ts`. The generator decides only how the plan is written:
+ * names, modules, imports, lifted consts. It knows nothing about Grafana,
+ * so live export (#2946) can build a plan from a dashboard read over the
+ * API and write it with the same generator.
+ */
+/** A value in a declaration's props that refers to another declaration, written as that declaration's variable. */
+export interface DeclRef {
+    readonly $decl: string;
+}
+export declare function declRef(id: string): DeclRef;
+export declare function isDeclRef(v: unknown): v is DeclRef;
+/**
+ * A value written as a call to a function the package exports, e.g.
+ * `customTransformation("sortBy", { ... })` for a transformation the typed
+ * form can't hold. The arguments are values like any other.
+ */
+export interface CallValue {
+    readonly $call: string;
+    readonly args: readonly unknown[];
+}
+export declare function callValue(fn: string, args: readonly unknown[]): CallValue;
+export declare function isCallValue(v: unknown): v is CallValue;
+/** Where a declaration's variable name comes from: a text to camelCase, or another declaration's name plus a suffix. */
+export type NameHint = string | {
+    readonly of: string;
+    readonly suffix: string;
+};
+/**
+ * One declaration.
+ *
+ * - `new`: `const name = new ClassName(props);`, a declarable.
+ * - `value`: `const name: type = value;`, a plain value other declarations
+ *   refer to (a `DatasourceRef`).
+ */
+export interface Declaration {
+    /** Unique in the plan, e.g. `panel:4`, `query:4:A`, `variable:job`, `datasource:prometheus:prom`, `dashboard`. */
+    readonly id: string;
+    readonly kind: "new" | "value";
+    /** For `new`: the class. A package export unless `customClass` says the import declares it. */
+    readonly className?: string;
+    /** For `new`: the id of the `CustomClass` declaring `className`, when it is not a package export. */
+    readonly customClass?: string;
+    /** For `new`: the constructor's props, in source order. */
+    readonly props?: Record<string, unknown>;
+    /** For `value`: the value, and its type annotation with the package types it names. */
+    readonly value?: unknown;
+    readonly type?: {
+        readonly text: string;
+        readonly imports: readonly string[];
+    };
+    readonly name: NameHint;
+    /** The module group it is written to (see `Plan.modules`). */
+    readonly module: string;
+    /**
+     * Declarations with the same unit stay in the same file when a module is
+     * split (a panel and its queries). Defaults to the id.
+     */
+    readonly unit?: string;
+    /** Comment lines written above it. */
+    readonly comment?: readonly string[];
+}
+/** A panel or query class the import declares, for a plugin chant has no class for. */
+export interface CustomClass {
+    /** e.g. `panel-class:grafana-clock-panel`, `query-class:elasticsearch`. */
+    readonly id: string;
+    readonly className: string;
+    /** `definePanel` or `defineQuery`. */
+    readonly factory: "definePanel" | "defineQuery";
+    /** The definition object passed to the factory. */
+    readonly definition: Record<string, unknown>;
+    readonly comment: readonly string[];
+}
+/** One module group: a base file name and the doc comment at its top. */
+export interface ModuleSpec {
+    readonly key: string;
+    /** File name without `.ts`; `-1`, `-2`, ... is added when the group is split. */
+    readonly file: string;
+    readonly summary: string;
+}
+/** Everything one dashboard becomes. */
+export interface Plan {
+    /** The directory its modules are written to, relative to the output directory. `""` for none. */
+    readonly directory: string;
+    /** Modules in the order they are written. */
+    readonly modules: readonly ModuleSpec[];
+    /** Declarations in dependency order: a declaration only refers to ones before it. */
+    readonly declarations: readonly Declaration[];
+    readonly customClasses: readonly CustomClass[];
+    /** Declarations exported even when no other module imports them (the dashboard). */
+    readonly exports: readonly string[];
+}
+//# sourceMappingURL=model.d.ts.map

package/dist/import/model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../src/import/model.ts"],"names":[],"mappings":"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"}

package/dist/import/normalize-alerting.d.ts

@@ -0,0 +1,26 @@
+/**
+ * An alerting provisioning file in a canonical form, so two files Grafana
+ * provisions the same way compare equal. The round-trip tests compare the
+ * source (with the importer's edits applied) and the rebuilt file through
+ * this.
+ *
+ * What it treats as equal, each from Grafana's file reader
+ * (`pkg/services/provisioning/alerting/*_types.go`, v12.4.11 and v13.2.2):
+ *
+ * - `orgId: 1` and no `orgId` (a value below 1 reads as 1);
+ * - a rule's `noDataState: NoData`, `execErrState: Alerting`, `for: 0s`,
+ *   `keepFiringFor: 0s`, `isPaused: false`, `panelId: 0`, empty `labels`
+ *   and `annotations`, and the same left out;
+ * - a query's `queryType: ""`, and a `relativeTimeRange` of 0 to 0, and
+ *   the same left out;
+ * - an expression model's `datasource` of `__expr__` and a `refId` equal
+ *   to the query's, and the same left out (Grafana sets both);
+ * - `disableResolveMessage: false` and none;
+ * - the order of rule groups, contact points, mute timings and templates,
+ *   which chant writes sorted.
+ */
+type Json = Record<string, unknown>;
+/** The file in canonical form. */
+export declare function normalizeAlerting(file: Json): Json;
+export {};
+//# sourceMappingURL=normalize-alerting.d.ts.map

package/dist/import/normalize-alerting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-alerting.d.ts","sourceRoot":"","sources":["../../src/import/normalize-alerting.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAKH,KAAK,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AA4CpC,kCAAkC;AAClC,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CA8BlD"}

package/dist/import/normalize.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Classic dashboard JSON in a canonical form, so two dashboards Grafana
+ * treats the same compare equal.
+ *
+ * Grafana fills in a default for most keys a dashboard leaves out, derives
+ * some keys from others (a custom variable's `options` from its `query`),
+ * and resolves a query without a datasource to its panel's. A dashboard it
+ * exported and the same dashboard rebuilt by chant differ in exactly those
+ * ways, so both are put through `normalizeDashboard` before they are
+ * compared: keys at their default are removed, derived keys are removed,
+ * and references are written one way.
+ *
+ * The import round trip compares with it, the importer asks `isDefault`
+ * whether a key it cannot carry is worth a warning (a key at its default is
+ * not), and drift detection (#2946) can compare a stored dashboard with a
+ * built one the same way.
+ *
+ * Only the dashboard, panel, row, target, variable and link levels are
+ * touched. Nothing inside `options`, `fieldConfig`, `transformations` or a
+ * query model is: a `null` in there (a threshold step's base value) means
+ * something.
+ */
+type Json = Record<string, unknown>;
+/** Grafana's value for a dashboard key the JSON leaves out. */
+export declare const DASHBOARD_DEFAULTS: Readonly<Json>;
+/** Grafana's value for a panel key the JSON leaves out. */
+export declare const PANEL_DEFAULTS: Readonly<Json>;
+/** Grafana's value for a row key the JSON leaves out. */
+export declare const ROW_DEFAULTS: Readonly<Json>;
+/** Grafana's value for a variable key the JSON leaves out, whatever the variable's type. */
+export declare const VARIABLE_DEFAULTS: Readonly<Json>;
+/** Per variable type, Grafana's value for a key the JSON leaves out, over `VARIABLE_DEFAULTS`. */
+export declare const VARIABLE_TYPE_DEFAULTS: Readonly<Record<string, Json>>;
+/** The defaults chant writes into a dashboard or panel link, which Grafana reads as unset. */
+export declare const LINK_DEFAULTS: Readonly<Json>;
+/** The annotation Grafana adds to every dashboard that has none: annotations and alerts from its own database. */
+export declare const BUILTIN_ANNOTATION: Readonly<Json>;
+/** Keys of a stored dashboard that belong to that copy (its database id, save counter), not to the dashboard. */
+export declare const BOOKKEEPING_KEYS: readonly string[];
+/** The panel datasource Grafana writes when a panel's queries go to different datasources. */
+export declare const MIXED_UID = "-- Mixed --";
+export declare function isObject(v: unknown): v is Json;
+export declare function deepEqual(a: unknown, b: unknown): boolean;
+/** True when `value` is what Grafana assumes for `key` when it is left out (a `null` counts as left out). */
+export declare function isDefault(defaults: Readonly<Json>, key: string, value: unknown): boolean;
+/** Defaults for one variable type. */
+export declare function variableDefaults(type: unknown): Json;
+/** The refId Grafana (and chant) gives the query at `index` when it has none: A, B, … Z, AA, AB, … */
+export declare function refIdAt(i: number): string;
+/** `$name` and `[[name]]` written as `${name}`, the form a datasource variable's reference takes. */
+export declare function canonicalVariableUid(uid: string): string;
+/** A custom or interval variable's `query` as the list of values Grafana splits it into. */
+export declare function splitValues(query: string): string[];
+/**
+ * Per datasource type, a query key's value when the target leaves it out.
+ * A Tempo query without `filters` has no search filters, which `TempoQuery`
+ * writes as `filters: []`.
+ */
+export declare const TARGET_DEFAULTS: Readonly<Record<string, Readonly<Json>>>;
+/**
+ * True for the annotation Grafana adds to every dashboard (annotations and
+ * alerts from its own database), in any of the forms Grafana versions have
+ * written it: a dashboard with it and one without are the same dashboard.
+ */
+export declare function isBuiltinAnnotation(a: unknown): boolean;
+/**
+ * The dashboard in canonical form: bookkeeping keys and keys at their
+ * default removed, derived keys removed, every query with its datasource and
+ * refId, every panel with the datasource its queries share. Returns a copy;
+ * key order is not canonicalised (compare with `deepEqual` or `toEqual`).
+ */
+export declare function normalizeDashboard(dashboard: Json): Json;
+export {};
+//# sourceMappingURL=normalize.d.ts.map

package/dist/import/normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../src/import/normalize.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAIH,KAAK,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEpC,+DAA+D;AAC/D,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,IAAI,CAc7C,CAAC;AAEF,2DAA2D;AAC3D,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,IAAI,CAUzC,CAAC;AAEF,yDAAyD;AACzD,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,IAAI,CAIvC,CAAC;AAEF,4FAA4F;AAC5F,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,IAAI,CAqB5C,CAAC;AAEF,kGAAkG;AAClG,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAIjE,CAAC;AAEF,8FAA8F;AAC9F,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,IAAI,CASxC,CAAC;AAEF,kHAAkH;AAClH,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,IAAI,CAQ7C,CAAC;AAEF,iHAAiH;AACjH,eAAO,MAAM,gBAAgB,EAAE,SAAS,MAAM,EAAmC,CAAC;AAElF,8FAA8F;AAC9F,eAAO,MAAM,SAAS,gBAAgB,CAAC;AAEvC,wBAAgB,QAAQ,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,IAAI,CAE9C;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAazD;AAED,6GAA6G;AAC7G,wBAAgB,SAAS,CAAC,QAAQ,EAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAGxF;AAED,sCAAsC;AACtC,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAEpD;AAQD,sGAAsG;AACtG,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAEzC;AAED,qGAAqG;AACrG,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAGxD;AAiBD,4FAA4F;AAC5F,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAOnD;AASD;;;;GAIG;AACH,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,CAEpE,CAAC;AAiHF;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAMvD;AAQD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,IAAI,GAAG,IAAI,CAexD"}