@intentius/chant-lexicon-grafana 0.97.0 → 0.99.0

package/dist/api/apply.d.ts

@@ -0,0 +1,156 @@
+/**
+ * The Grafana API applier (#2948): folders, library panels and dashboards
+ * written over Grafana's HTTP API, stamped with chant's ownership labels,
+ * and an owned-only prune.
+ *
+ * ## The API path
+ *
+ * The server's dashboard API is discovered once per client
+ * (`dashboardApi` in ./dashboards.ts, shared with observe):
+ *
+ * - **Grafana 12.4 and 13.x**: `dashboard.grafana.app` (`v1beta1` on 12.4,
+ *   `v1` on 13.x). A dashboard is created with `POST` to the collection and
+ *   updated with `PUT` to its name, without a `resourceVersion`, which both
+ *   versions accept as an unconditional update. The resource carries the
+ *   classic JSON in `spec`, chant's labels in `metadata.labels`
+ *   (`grafanaOwnershipLabels`, the marker observe reads back), and its
+ *   folder in the `grafana.app/folder` annotation.
+ * - **Grafana 11**: `POST /api/dashboards/db` with `overwrite: true` and the
+ *   folder's uid. There is no metadata channel, so nothing is stamped and
+ *   nothing is pruned: the prune reports both kinds as `not-prunable`.
+ *
+ * Folders are ./folders.ts and library panels ./library-panels.ts. The write
+ * order is folders (parents first), then library panels, then dashboards, so
+ * nothing is written before what it references.
+ *
+ * ## Unchanged
+ *
+ * Every write is preceded by a read, and a resource whose live content
+ * already covers what would be sent (./converge.ts), with the same folder
+ * and labels, is `unchanged` and not written.
+ *
+ * ## Prune
+ *
+ * Only with `prune`, and only what carries this project's marker: chant's
+ * managed-by label with the same stack and the same env (an env-less marker
+ * matches only an env-less apply). Dashboards go first, then folders, a
+ * child before its parent, and a folder that still holds anything after
+ * that (a dashboard saved into it in the UI, a library panel) is left, as
+ * `not-prunable` with what it holds. Library panels are never pruned: their
+ * API has no labels.
+ */
+import { type OwnershipMarker } from "@intentius/chant/ownership";
+import type { NotAttemptedReason } from "@intentius/chant/apply";
+import { type GrafanaClient } from "./client.js";
+import { type FolderPlan } from "./folders.js";
+import { type LibraryPanelPlan } from "./library-panels.js";
+type Json = Record<string, unknown>;
+/** The kinds the applier names in its result: Grafana's own type names. */
+export declare const GRAFANA_APPLY_KINDS: {
+    readonly dashboard: "Dashboard";
+    readonly folder: "Folder";
+    readonly libraryPanel: "LibraryPanel";
+    /** An `__elements` entry that is not a panel (a library variable), which the applier cannot write. */
+    readonly libraryElement: "LibraryElement";
+};
+/** One dashboard a build needs. */
+export interface DashboardPlan {
+    readonly uid: string;
+    /** The classic dashboard JSON, without the export-only keys. */
+    readonly json: Json;
+    readonly folderUid?: string;
+}
+/** Everything one apply writes, in the order it writes it. */
+export interface GrafanaApplyPlan {
+    readonly folders: FolderPlan[];
+    readonly libraryPanels: LibraryPanelPlan[];
+    readonly dashboards: DashboardPlan[];
+    /** What the input declared that the applier has no writer for. */
+    readonly unsupported: Array<{
+        kind: string;
+        name: string;
+        detail: string;
+    }>;
+}
+/** A dashboard as the build hands it over: its JSON and the folder title it names. */
+export interface BuiltDashboardInput {
+    readonly json: Json;
+    readonly folder?: string;
+}
+/**
+ * Turn built dashboards into an apply plan: the folders they name, the
+ * library panels their `__elements` carry, and the dashboards themselves.
+ * Throws on a plan no apply could satisfy: a dashboard with no uid, two
+ * dashboards with one uid, or one library panel uid with two models.
+ */
+export declare function planFromDashboards(dashboards: readonly BuiltDashboardInput[]): GrafanaApplyPlan;
+/** Every resource in a plan, as `{ kind, name }`: what the result must account for. */
+export declare function planRefs(plan: GrafanaApplyPlan): Array<{
+    kind: string;
+    name: string;
+}>;
+export type AppliedAction = "created" | "updated" | "unchanged";
+/** What the applier did, in its own terms. `toApplyResult` projects it onto core's envelope. */
+export interface GrafanaApplyOutcome {
+    /** Where the binding came from: `grafana.profiles.prod`, `env GRAFANA_URL`. Empty when nothing was bound. */
+    target: string;
+    /** The dashboard API written to: `apis/v1`, `apis/v1beta1` or `legacy`. Empty when nothing was written. */
+    api: string;
+    applied: Array<{
+        kind: string;
+        name: string;
+        action: AppliedAction;
+        address: string;
+    }>;
+    pruned: Array<{
+        kind: string;
+        name: string;
+        deleted: boolean;
+        address: string;
+    }>;
+    notAttempted: Array<{
+        kind: string;
+        name: string;
+        reason: NotAttemptedReason;
+        detail?: string;
+    }>;
+    /** Kinds the prune could not consider at all, and why. Empty without `prune`. */
+    notPrunable: Array<{
+        kind: string;
+        detail: string;
+    }>;
+}
+export interface ApplyGrafanaOptions {
+    /**
+     * The stack and env stamped on every dashboard and folder, and the only
+     * marker the prune deletes. Without it, only the managed-by label is
+     * stamped and the prune does nothing (it reports why).
+     */
+    marker?: OwnershipMarker;
+    /** Delete this project's dashboards and folders that the plan no longer has. Off by default. */
+    prune?: boolean;
+    signal?: AbortSignal;
+}
+/** The labels an apply stamps: the full marker, or only managed-by when no stack is known. */
+export declare function stampLabels(marker: OwnershipMarker | undefined): Record<string, string>;
+/** True when `labels` carry exactly this project's marker: chant's, this stack, this env. */
+export declare function carriesMarker(labels: Readonly<Record<string, string>>, marker: OwnershipMarker): boolean;
+/**
+ * Create or update one dashboard. Unchanged, with nothing written, when the
+ * live dashboard already covers the JSON and sits in the same folder with
+ * the same labels.
+ */
+export declare function ensureDashboard(client: GrafanaClient, plan: DashboardPlan, labels: Readonly<Record<string, string>>): Promise<{
+    action: AppliedAction;
+    address: string;
+}>;
+/**
+ * Apply `plan` to the Grafana behind `client`. Throws `GrafanaApiError` when
+ * a write fails; a refused first read (401/403) is returned instead, with
+ * every resource `no-credentials`, since nothing was written.
+ */
+export declare function applyGrafana(client: GrafanaClient, plan: GrafanaApplyPlan, opts?: ApplyGrafanaOptions): Promise<GrafanaApplyOutcome>;
+/** Parse a stored dashboard JSON file's content; throws with the file name when it is not a JSON object. */
+export declare function parseDashboardFile(content: string, file: string): Json;
+export {};
+//# sourceMappingURL=apply.d.ts.map

package/dist/api/apply.d.ts.map

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

package/dist/api/bind.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Binding a client for one environment: the config lookup, the target, the
+ * transport. Shared by observe, export and (#2948) apply, so all three read
+ * and write the same Grafana.
+ */
+import type { ChantConfig } from "@intentius/chant/config";
+import type { UnobservedReason } from "@intentius/chant/observation";
+import { GrafanaClient, type GrafanaHttp } from "./client.js";
+import { type UnresolvedTarget } from "../config.js";
+/** What callers may inject: tests pass `http` (and usually `config`), the CLI passes nothing. */
+export interface BindOptions {
+    environment?: string;
+    /** The project's config. Loaded from `cwd` (default: the working directory) when omitted. */
+    config?: Pick<ChantConfig, "grafana">;
+    cwd?: string;
+    env?: Record<string, string | undefined>;
+    /** Transport override. The target is still resolved, so a test exercises the binding too. */
+    http?: GrafanaHttp;
+}
+/** A target that could not be resolved, thrown by {@link bindGrafana} and classified by {@link classifyGrafanaFailure}. */
+export declare class GrafanaBindingError extends Error {
+    readonly unresolved: UnresolvedTarget;
+    constructor(unresolved: UnresolvedTarget);
+}
+/** Resolve the environment's target and return a client for it. Throws {@link GrafanaBindingError} when there is none. */
+export declare function bindGrafana(options?: BindOptions): Promise<GrafanaClient>;
+/** What a failed bind or read means, in the observation vocabulary. */
+export declare function classifyGrafanaFailure(err: unknown): {
+    reason: UnobservedReason;
+    detail: string;
+};
+//# sourceMappingURL=bind.d.ts.map

package/dist/api/bind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bind.d.ts","sourceRoot":"","sources":["../../src/api/bind.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,EAAmB,aAAa,EAAe,KAAK,WAAW,EAAE,MAAM,UAAU,CAAC;AACzF,OAAO,EAA4C,KAAK,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAE5F,iGAAiG;AACjG,MAAM,WAAW,WAAW;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,6FAA6F;IAC7F,MAAM,CAAC,EAAE,IAAI,CAAC,WAAW,EAAE,SAAS,CAAC,CAAC;IACtC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;IACzC,6FAA6F;IAC7F,IAAI,CAAC,EAAE,WAAW,CAAC;CACpB;AAED,2HAA2H;AAC3H,qBAAa,mBAAoB,SAAQ,KAAK;IAChC,QAAQ,CAAC,UAAU,EAAE,gBAAgB;gBAA5B,UAAU,EAAE,gBAAgB;CAIlD;AAYD,0HAA0H;AAC1H,wBAAsB,WAAW,CAAC,OAAO,GAAE,WAAgB,GAAG,OAAO,CAAC,aAAa,CAAC,CAKnF;AAED,uEAAuE;AACvE,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,OAAO,GAAG;IAAE,MAAM,EAAE,gBAAgB,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAQjG"}

package/dist/api/client.d.ts

@@ -0,0 +1,76 @@
+/**
+ * The Grafana HTTP transport (#2946): one client for observe, export and,
+ * later, the API applier (#2948), so all three reach the same instance with
+ * the same credentials.
+ *
+ * `GrafanaHttp` is the seam. The default is `fetch` against a resolved
+ * target (./target.ts); a test hands in a function that answers by path, so
+ * nothing needs a module mock.
+ *
+ * Status mapping is in one place ({@link statusVerdict}): a 404 is the only
+ * answer that means "not there", 401/403 mean the credentials were refused,
+ * and anything else that is not a 2xx is a failed read. A reader that turned
+ * a 500 or a refused token into "absent" would have `chant lifecycle plan`
+ * propose creating a dashboard that is running.
+ */
+/** How the client authenticates. A service account token is the usual form; basic auth suits a local instance. */
+export type GrafanaAuth = {
+    readonly token: string;
+} | {
+    readonly user: string;
+    readonly password: string;
+};
+/** A resolved Grafana instance: where, as whom, which organisation, and where that came from. */
+export interface GrafanaTarget {
+    /** Base URL, without a trailing slash: `https://grafana.example.com`. */
+    readonly url: string;
+    readonly auth?: GrafanaAuth;
+    /** Organisation id; 1 when not set. Selects the `X-Grafana-Org-Id` header and the API namespace. */
+    readonly orgId?: number;
+    /**
+     * The `dashboard.grafana.app` namespace. Defaults to `default` for org 1
+     * and `org-<id>` otherwise; Grafana Cloud stacks use `stacks-<id>`.
+     */
+    readonly namespace?: string;
+    /** Where the binding came from, in the project's vocabulary: `grafana.profiles.prod`, `env GRAFANA_URL`. */
+    readonly source: string;
+}
+export interface GrafanaResponse {
+    readonly status: number;
+    /** The parsed body, or undefined when it was empty or not JSON. */
+    readonly json: unknown;
+}
+/** One request. `path` starts with `/` and is relative to the target's URL. */
+export type GrafanaHttp = (method: string, path: string, body?: unknown) => Promise<GrafanaResponse>;
+/** The API namespace for a target (see {@link GrafanaTarget.namespace}). */
+export declare function namespaceOf(target: Pick<GrafanaTarget, "orgId" | "namespace">): string;
+/** The default transport: `fetch` against the target, JSON in and out. */
+export declare function grafanaHttp(target: GrafanaTarget, fetchImpl?: typeof fetch): GrafanaHttp;
+/** What a status means for a read. */
+export type StatusVerdict = "ok" | "not-found" | "refused" | "failed";
+export declare function statusVerdict(status: number): StatusVerdict;
+/** A non-2xx answer, with enough to classify it and to say where it came from. */
+export declare class GrafanaApiError extends Error {
+    readonly status: number;
+    readonly method: string;
+    readonly path: string;
+    readonly verdict: StatusVerdict;
+    constructor(status: number, method: string, path: string, body: unknown);
+}
+/**
+ * A bound client: the transport, the target it reaches, and per-client
+ * caches (the API version a server serves, folder titles) so N reads do not
+ * repeat the same lookup.
+ */
+export declare class GrafanaClient {
+    readonly http: GrafanaHttp;
+    readonly target: GrafanaTarget;
+    private readonly memo;
+    constructor(http: GrafanaHttp, target: GrafanaTarget);
+    get namespace(): string;
+    /** GET, returning the body; undefined on 404; throws {@link GrafanaApiError} on any other non-2xx. */
+    get<T = unknown>(path: string): Promise<T | undefined>;
+    /** Run `fn` once per key for this client's lifetime; concurrent callers share the promise. */
+    once<T>(key: string, fn: () => Promise<T>): Promise<T>;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/api/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/api/client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,kHAAkH;AAClH,MAAM,MAAM,WAAW,GAAG;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AAE5G,iGAAiG;AACjG,MAAM,WAAW,aAAa;IAC5B,yEAAyE;IACzE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,IAAI,CAAC,EAAE,WAAW,CAAC;IAC5B,oGAAoG;IACpG,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,4GAA4G;IAC5G,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,mEAAmE;IACnE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;CACxB;AAED,+EAA+E;AAC/E,MAAM,MAAM,WAAW,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC,eAAe,CAAC,CAAC;AAErG,4EAA4E;AAC5E,wBAAgB,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,aAAa,EAAE,OAAO,GAAG,WAAW,CAAC,GAAG,MAAM,CAItF;AAQD,0EAA0E;AAC1E,wBAAgB,WAAW,CAAC,MAAM,EAAE,aAAa,EAAE,SAAS,GAAE,OAAO,KAAa,GAAG,WAAW,CAwB/F;AAED,sCAAsC;AACtC,MAAM,MAAM,aAAa,GAAG,IAAI,GAAG,WAAW,GAAG,SAAS,GAAG,QAAQ,CAAC;AAEtE,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa,CAK3D;AAED,kFAAkF;AAClF,qBAAa,eAAgB,SAAQ,KAAK;IAGtC,QAAQ,CAAC,MAAM,EAAE,MAAM;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM;IAJvB,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC;gBAErB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACrB,IAAI,EAAE,OAAO;CAOhB;AAED;;;;GAIG;AACH,qBAAa,aAAa;IAItB,QAAQ,CAAC,IAAI,EAAE,WAAW;IAC1B,QAAQ,CAAC,MAAM,EAAE,aAAa;IAJhC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAuC;gBAGjD,IAAI,EAAE,WAAW,EACjB,MAAM,EAAE,aAAa;IAGhC,IAAI,SAAS,IAAI,MAAM,CAEtB;IAED,sGAAsG;IAChG,GAAG,CAAC,CAAC,GAAG,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;IAQ5D,8FAA8F;IAC9F,IAAI,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;CAUvD"}

package/dist/api/converge.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Whether what Grafana holds already is what the applier would write
+ * (#2948), so a re-apply reports `unchanged` and writes nothing.
+ *
+ * Grafana does not answer this itself: a `PUT` of identical content still
+ * bumps `generation` and `resourceVersion` (measured on 12.4.11 and 13.2.2),
+ * so a no-op cannot be told from an update after the fact. And the stored
+ * dashboard is not the one sent: Grafana fills in defaults
+ * (`fiscalYearStartMonth: 0`, `links: []`, `timepicker: {}`, ...), adds the
+ * built-in annotation, drops `null`s and empty `options`, and may migrate
+ * `schemaVersion`.
+ *
+ * So the test is one-sided: every value the applier would send must be in
+ * the live object, equal, and anything Grafana added on top is ignored. An
+ * array must match element for element, since a panel added in the UI is a
+ * change. The noise is the same list the drift hooks carry (#2946):
+ *
+ * - `null` and empty objects sent are satisfied by an absent key;
+ * - the built-in "Annotations & Alerts" annotation is ignored on both sides;
+ * - `id`, `version` and `uid` at the top level are identity, not content, and
+ *   `schemaVersion` is Grafana's to migrate.
+ */
+/** Top-level dashboard keys that are identity or Grafana-managed, never content. */
+export declare const IDENTITY_KEYS: readonly string[];
+/**
+ * True when `live` already holds everything in `want`. For a dashboard,
+ * the top-level identity keys ({@link IDENTITY_KEYS}) are left out of the
+ * comparison.
+ */
+export declare function converged(want: unknown, live: unknown, opts?: {
+    dashboard?: boolean;
+}): boolean;
+//# sourceMappingURL=converge.d.ts.map

package/dist/api/converge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"converge.d.ts","sourceRoot":"","sources":["../../src/api/converge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAQH,oFAAoF;AACpF,eAAO,MAAM,aAAa,EAAE,SAAS,MAAM,EAA8C,CAAC;AAuB1F;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,GAAE;IAAE,SAAS,CAAC,EAAE,OAAO,CAAA;CAAO,GAAG,OAAO,CAInG"}

package/dist/api/dashboards.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Reading dashboards (#2946).
+ *
+ * Grafana 12 and 13 serve dashboards as Kubernetes-style resources under
+ * `/apis/dashboard.grafana.app/<version>/namespaces/<ns>/dashboards/<uid>`:
+ * the classic dashboard JSON in `spec`, and who manages it in
+ * `metadata.annotations` and `metadata.labels` (./../ownership.ts). The
+ * version is discovered once per client from the API group, preferring the
+ * newest classic (v1-family) version the server serves: `v1` on 13.x,
+ * `v1beta1` on 12.x. A server without the group (Grafana 11) is read over
+ * `GET /api/dashboards/uid/<uid>`, which has the same JSON and no metadata
+ * channel.
+ *
+ * ## The version branch is one place
+ *
+ * {@link classicDashboardOf} decides how a stored dashboard is read as
+ * classic JSON. Everything downstream (observe, deep observe, export) only
+ * ever sees its answer. A dashboard Grafana stores as v2 (the layout-and-
+ * elements schema) is not read through Grafana's own v2-to-v1 conversion,
+ * which drops what v1 cannot hold with nothing to show it (the importer
+ * refuses that read too, `lossyV1Read`). Instead {@link readDashboard} and
+ * {@link listDashboards} read it again at the newest v2 version the server
+ * serves (`v2` on 13.x, `v2beta1` on 12.x), and `classicDashboardOf`
+ * converts that with the importer's v2 reader (./../import/v2.ts), which
+ * names everything v2 holds that the classic model cannot (#2947). Only a
+ * v2-stored dashboard the server cannot serve at v2, or whose conversion
+ * failed, is reported as not readable.
+ */
+import type { GrafanaClient } from "./client.js";
+type Json = Record<string, unknown>;
+export declare const DASHBOARD_GROUP = "dashboard.grafana.app";
+/** Classic-schema versions of the dashboard API, newest first. */
+export declare const CLASSIC_DASHBOARD_VERSIONS: readonly string[];
+/** v2-schema versions of the dashboard API the v2 reader understands, newest first. */
+export declare const V2_DASHBOARD_VERSIONS: readonly string[];
+/**
+ * How this server serves dashboards: the classic version it is read at,
+ * and the v2 version a dashboard stored as v2 is read at instead (#2947).
+ */
+export type DashboardApi = {
+    readonly kind: "apis";
+    readonly version: string;
+    readonly v2Version?: string;
+} | {
+    readonly kind: "legacy";
+};
+/** The dashboard API the server behind `client` serves, discovered once per client. */
+export declare function dashboardApi(client: GrafanaClient): Promise<DashboardApi>;
+/** One dashboard as Grafana holds it. */
+export interface LiveDashboard {
+    readonly uid: string;
+    /**
+     * The stored resource as it came back: a `dashboard.grafana.app` resource
+     * (`{ metadata, spec, status }`) or, on the legacy API, `{ dashboard, meta }`.
+     * Read it through {@link classicDashboardOf}.
+     */
+    readonly raw: Json;
+    readonly via: "apis" | "legacy";
+    /** `metadata.labels`. Empty on the legacy API, which has no labels. */
+    readonly labels: Readonly<Record<string, string>>;
+    /** `metadata.annotations`. Empty on the legacy API. */
+    readonly annotations: Readonly<Record<string, string>>;
+    /** The folder's uid, when it is in one. */
+    readonly folderUid?: string;
+    /** The folder's title, when the read returned it (the legacy API does). */
+    readonly folderTitle?: string;
+    /** The request path it was read from. */
+    readonly address: string;
+}
+/** A dashboard read: there, not there (404), or there but not readable as classic JSON. */
+export type DashboardRead = {
+    readonly present: LiveDashboard;
+} | {
+    readonly absent: true;
+    readonly address: string;
+};
+/** The request path for one dashboard on this API (at `version` instead of the classic one, when given). */
+export declare function dashboardPath(api: DashboardApi, namespace: string, uid: string, version?: string): string;
+/** Read one dashboard by uid. Throws `GrafanaApiError` for anything but a 2xx or a 404. */
+export declare function readDashboard(client: GrafanaClient, uid: string): Promise<DashboardRead>;
+/** Every dashboard in the organisation, paged. */
+export declare function listDashboards(client: GrafanaClient): Promise<LiveDashboard[]>;
+/**
+ * The stored dashboard as classic JSON, with its uid, or why it cannot be
+ * read as one. The only place the dashboard schema version branches. A v2
+ * dashboard is converted by the importer's v2 reader; `warnings` then names
+ * what v2 holds that the classic JSON does not (tabs, auto grids,
+ * conditional rendering), and is absent for a classic dashboard.
+ */
+export declare function classicDashboardOf(dashboard: LiveDashboard): {
+    json: Json;
+    warnings?: string[];
+} | {
+    unsupported: string;
+};
+/**
+ * The title of the folder a dashboard is in, or undefined for the General
+ * folder. One `GET /api/folders/<uid>` per folder per client.
+ */
+export declare function folderTitleOf(client: GrafanaClient, dashboard: LiveDashboard): Promise<string | undefined>;
+export {};
+//# sourceMappingURL=dashboards.d.ts.map

package/dist/api/dashboards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dashboards.d.ts","sourceRoot":"","sources":["../../src/api/dashboards.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE9C,KAAK,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAWpC,eAAO,MAAM,eAAe,0BAA0B,CAAC;AAEvD,kEAAkE;AAClE,eAAO,MAAM,0BAA0B,EAAE,SAAS,MAAM,EAAkC,CAAC;AAE3F,uFAAuF;AACvF,eAAO,MAAM,qBAAqB,EAAE,SAAS,MAAM,EAAsB,CAAC;AAE1E;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC;AAE1I,uFAAuF;AACvF,wBAAgB,YAAY,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC,CAQzE;AAED,yCAAyC;AACzC,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,QAAQ,CAAC,GAAG,EAAE,IAAI,CAAC;IACnB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,CAAC;IAChC,uEAAuE;IACvE,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAClD,uDAAuD;IACvD,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACvD,2CAA2C;IAC3C,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,2EAA2E;IAC3E,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,yCAAyC;IACzC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,2FAA2F;AAC3F,MAAM,MAAM,aAAa,GACrB;IAAE,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAA;CAAE,GACnC;IAAE,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAExD,4GAA4G;AAC5G,wBAAgB,aAAa,CAAC,GAAG,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAKzG;AA+CD,2FAA2F;AAC3F,wBAAsB,aAAa,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAO9F;AAED,kDAAkD;AAClD,wBAAsB,cAAc,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC,CA6BpF;AAYD;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,aAAa,GAAG;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,CAwB1H;AAED;;;GAGG;AACH,wBAAsB,aAAa,CAAC,MAAM,EAAE,aAAa,EAAE,SAAS,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAQhH"}

package/dist/api/datasources.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Reading datasources (#2946), over `GET /api/datasources/uid/<uid>` and
+ * `GET /api/datasources`. Grafana 12.4 and 13.2 serve no general
+ * datasource resource under `/apis`, so this is the one datasource API both
+ * have, and it carries no labels or annotations: a datasource's ownership
+ * cannot be read (see ../ownership.ts).
+ *
+ * The API never returns secret values. `secureJsonFields` says which
+ * secrets are set, and that is all this reads of them.
+ */
+import type { GrafanaClient } from "./client.js";
+type Json = Record<string, unknown>;
+export type DatasourceRead = {
+    readonly present: Json;
+    readonly address: string;
+} | {
+    readonly absent: true;
+    readonly address: string;
+};
+export declare function datasourcePath(uid: string): string;
+/** Read one datasource by uid. Throws `GrafanaApiError` for anything but a 2xx or a 404. */
+export declare function readDatasource(client: GrafanaClient, uid: string): Promise<DatasourceRead>;
+/** Every datasource in the organisation. */
+export declare function listDatasources(client: GrafanaClient): Promise<Json[]>;
+export {};
+//# sourceMappingURL=datasources.d.ts.map

package/dist/api/datasources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"datasources.d.ts","sourceRoot":"","sources":["../../src/api/datasources.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE9C,KAAK,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEpC,MAAM,MAAM,cAAc,GAAG;IAAE,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAExI,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAElD;AAED,4FAA4F;AAC5F,wBAAsB,cAAc,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CAIhG;AAED,4CAA4C;AAC5C,wBAAsB,eAAe,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC,CAG5E"}

package/dist/api/fake-grafana-writes.d.ts

@@ -0,0 +1,41 @@
+/**
+ * A Grafana that remembers writes, in memory, for the applier's tests
+ * (#2948). The read-only fake (./fake-grafana.ts) serves a fixed state for
+ * observe and export; this one serves the routes the applier writes to and
+ * keeps what it was sent, so a second apply sees the first one's result.
+ *
+ * It behaves as Grafana 12.4.11 and 13.2.2 did when the applier was checked
+ * against them (../op/activities/grafana-apply.e2e.test.ts): `POST` to an
+ * existing name is a 409, `PUT` needs no `resourceVersion`, a stored
+ * dashboard gets the built-in annotation and Grafana's defaults
+ * (`storedDashboard`), a folder with anything in it cannot be deleted over
+ * `/apis`, and a library element update needs its `version`. With
+ * `api: "legacy"` it is a Grafana 11: no `/apis` groups, dashboards over
+ * `/api/dashboards/db` and `/api/dashboards/uid`, folders over `/api/folders`.
+ */
+import type { GrafanaHttp } from "./client.js";
+type Json = Record<string, unknown>;
+export interface StoredResource {
+    spec: Json;
+    labels: Record<string, string>;
+    annotations: Record<string, string>;
+}
+export interface WritableGrafanaState {
+    /** `v1` (13.x), `v1beta1` (12.4), or `legacy` (11.x). */
+    api: "v1" | "v1beta1" | "legacy";
+    dashboards: Record<string, StoredResource>;
+    /** Folders by uid; `spec.title` is the title and the `grafana.app/folder` annotation the parent. */
+    folders: Record<string, StoredResource>;
+    libraryElements: Record<string, Json>;
+    namespace?: string;
+    /** Answer every request with this status (a refused token: 401). */
+    status?: number;
+}
+export declare function emptyGrafana(api: WritableGrafanaState["api"]): WritableGrafanaState;
+/**
+ * A {@link GrafanaHttp} over `state`, which it changes as it is written to.
+ * Every request is recorded in `calls` as `METHOD path`.
+ */
+export declare function writableGrafana(state: WritableGrafanaState, calls?: string[]): GrafanaHttp;
+export {};
+//# sourceMappingURL=fake-grafana-writes.d.ts.map

package/dist/api/fake-grafana-writes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake-grafana-writes.d.ts","sourceRoot":"","sources":["../../src/api/fake-grafana-writes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAmB,MAAM,UAAU,CAAC;AAG7D,KAAK,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAMpC,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,IAAI,CAAC;IACX,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACrC;AAED,MAAM,WAAW,oBAAoB;IACnC,yDAAyD;IACzD,GAAG,EAAE,IAAI,GAAG,SAAS,GAAG,QAAQ,CAAC;IACjC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IAC3C,oGAAoG;IACpG,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IACxC,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IACtC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,oEAAoE;IACpE,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wBAAgB,YAAY,CAAC,GAAG,EAAE,oBAAoB,CAAC,KAAK,CAAC,GAAG,oBAAoB,CAEnF;AAYD;;;GAGG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,oBAAoB,EAAE,KAAK,GAAE,MAAM,EAAO,GAAG,WAAW,CA2I9F"}

package/dist/api/fake-grafana.d.ts

@@ -0,0 +1,61 @@
+/**
+ * A Grafana API in memory, for the observe and export tests (#2946).
+ *
+ * Serves the routes the readers use, from a state the test sets up, in the
+ * shapes Grafana 12.4.11 and 13.2.2 return (checked against both with the
+ * e2e in ../observe.e2e.test.ts): the API group discovery, dashboard
+ * resources under `/apis`, the legacy `/api/dashboards/uid` and
+ * `/api/search`, folders, and datasources. `storedDashboard` does to a built
+ * dashboard what Grafana does when it stores one.
+ */
+import type { GrafanaHttp } from "./client.js";
+type Json = Record<string, unknown>;
+export interface FakeDashboard {
+    /** The classic JSON, as it would be stored (see {@link storedDashboard}). */
+    spec: Json;
+    labels?: Record<string, string>;
+    annotations?: Record<string, string>;
+    /** The version it is stored at: `v0alpha1` for a classic dashboard, `v2beta1` for one saved as v2. */
+    storedVersion?: string;
+    /**
+     * For a dashboard stored as v2, its v2 spec, served at the v2 versions the
+     * server has (`spec` is then the classic read's down-conversion). Without
+     * it the v2 routes answer 404.
+     */
+    v2?: Json;
+    folderUid?: string;
+}
+export interface FakeGrafanaState {
+    /** `v1` (13.x), `v1beta1` (12.x), or `legacy` for a server with no `/apis/dashboard.grafana.app` (11.x). */
+    api: "v1" | "v1beta1" | "legacy";
+    dashboards: Record<string, FakeDashboard>;
+    datasources?: Record<string, Json>;
+    folders?: Record<string, string>;
+    /** Answer every request with this status (a refused token: 401). */
+    status?: number;
+    namespace?: string;
+}
+/**
+ * A built dashboard as Grafana hands it back through `/apis` (measured on
+ * 12.4.11 and 13.2.2): the built-in annotation added, empty `options` and
+ * `fieldConfig` dropped, `null` values dropped, and the uid moved to the
+ * resource's name. The legacy route (`/api/dashboards/uid`) serves the
+ * built JSON plus `id` and `version`; the fake serves this model on both,
+ * which is the harder case for the legacy path.
+ */
+export declare function storedDashboard(built: Json): Json;
+/** A {@link GrafanaHttp} over `state`, recording every request path in `calls`. */
+export declare function fakeGrafana(state: FakeGrafanaState, calls?: string[]): GrafanaHttp;
+/** A datasource as `GET /api/datasources/uid/<uid>` returns one provisioned from a file. */
+export declare function liveDatasource(ds: {
+    name: string;
+    type: string;
+    uid: string;
+    url?: string;
+    isDefault?: boolean;
+    jsonData?: Json;
+    secure?: string[];
+    readOnly?: boolean;
+}): Json;
+export {};
+//# sourceMappingURL=fake-grafana.d.ts.map

package/dist/api/fake-grafana.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake-grafana.d.ts","sourceRoot":"","sources":["../../src/api/fake-grafana.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAmB,MAAM,UAAU,CAAC;AAE7D,KAAK,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEpC,MAAM,WAAW,aAAa;IAC5B,6EAA6E;IAC7E,IAAI,EAAE,IAAI,CAAC;IACX,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,sGAAsG;IACtG,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,EAAE,CAAC,EAAE,IAAI,CAAC;IACV,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,gBAAgB;IAC/B,4GAA4G;IAC5G,GAAG,EAAE,IAAI,GAAG,SAAS,GAAG,QAAQ,CAAC;IACjC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IAC1C,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IACnC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,oEAAoE;IACpE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AA+BD;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,IAAI,GAAG,IAAI,CAOjD;AAKD,mFAAmF;AACnF,wBAAgB,WAAW,CAAC,KAAK,EAAE,gBAAgB,EAAE,KAAK,GAAE,MAAM,EAAO,GAAG,WAAW,CAoEtF;AAED,4FAA4F;AAC5F,wBAAgB,cAAc,CAAC,EAAE,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,IAAI,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,CAsB/K"}